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 deUint32 tex = 0; 1084 vector<deUint8> data; 1085 1086 DE_ASSERT(m_numLevels == 1); 1087 1088 // Fill data with grid. 1089 data.resize(pixelSize * m_skipPixels + rowPitch * (m_height + m_skipRows)); 1090 { 1091 Vec4 cScale = m_texFormatInfo.valueMax-m_texFormatInfo.valueMin; 1092 Vec4 cBias = m_texFormatInfo.valueMin; 1093 Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*cScale + cBias; 1094 Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*cScale + cBias; 1095 1096 tcu::fillWithGrid(tcu::PixelBufferAccess(m_texFormat, m_width, m_height, 1, rowPitch, 0, &data[0] + m_skipRows*rowPitch + m_skipPixels*pixelSize), 4, colorA, colorB); 1097 } 1098 1099 glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength); 1100 glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows); 1101 glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels); 1102 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment); 1103 1104 glGenTextures(1, &tex); 1105 glBindTexture(GL_TEXTURE_2D, tex); 1106 glTexImage2D(GL_TEXTURE_2D, 0, m_internalFormat, m_width, m_height, 0, transferFmt.format, transferFmt.dataType, &data[0]); 1107 } 1108 1109 deUint32 m_internalFormat; 1110 int m_rowLength; 1111 int m_skipRows; 1112 int m_skipPixels; 1113 int m_alignment; 1114 }; 1115 1116 // TexImage3D() unpack parameters case. 1117 class TexImage3DParamsCase : public Texture3DSpecCase 1118 { 1119 public: 1120 TexImage3DParamsCase (Context& context, 1121 const char* name, 1122 const char* desc, 1123 deUint32 internalFormat, 1124 int width, 1125 int height, 1126 int depth, 1127 int imageHeight, 1128 int rowLength, 1129 int skipImages, 1130 int skipRows, 1131 int skipPixels, 1132 int alignment) 1133 : Texture3DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, depth, 1) 1134 , m_internalFormat (internalFormat) 1135 , m_imageHeight (imageHeight) 1136 , m_rowLength (rowLength) 1137 , m_skipImages (skipImages) 1138 , m_skipRows (skipRows) 1139 , m_skipPixels (skipPixels) 1140 , m_alignment (alignment) 1141 { 1142 } 1143 1144 protected: 1145 void createTexture (void) 1146 { 1147 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat); 1148 int pixelSize = m_texFormat.getPixelSize(); 1149 int rowLength = m_rowLength > 0 ? m_rowLength : m_width; 1150 int rowPitch = deAlign32(rowLength*pixelSize, m_alignment); 1151 int imageHeight = m_imageHeight > 0 ? m_imageHeight : m_height; 1152 int slicePitch = imageHeight*rowPitch; 1153 deUint32 tex = 0; 1154 vector<deUint8> data; 1155 1156 DE_ASSERT(m_numLevels == 1); 1157 1158 // Fill data with grid. 1159 data.resize(pixelSize * m_skipPixels + rowPitch * m_skipRows + slicePitch * (m_skipImages + m_depth)); 1160 { 1161 Vec4 cScale = m_texFormatInfo.valueMax-m_texFormatInfo.valueMin; 1162 Vec4 cBias = m_texFormatInfo.valueMin; 1163 Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*cScale + cBias; 1164 Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*cScale + cBias; 1165 1166 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); 1167 } 1168 1169 glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, m_imageHeight); 1170 glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength); 1171 glPixelStorei(GL_UNPACK_SKIP_IMAGES, m_skipImages); 1172 glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows); 1173 glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels); 1174 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment); 1175 1176 glGenTextures(1, &tex); 1177 glBindTexture(GL_TEXTURE_3D, tex); 1178 glTexImage3D(GL_TEXTURE_3D, 0, m_internalFormat, m_width, m_height, m_depth, 0, transferFmt.format, transferFmt.dataType, &data[0]); 1179 } 1180 1181 deUint32 m_internalFormat; 1182 int m_imageHeight; 1183 int m_rowLength; 1184 int m_skipImages; 1185 int m_skipRows; 1186 int m_skipPixels; 1187 int m_alignment; 1188 }; 1189 1190 // Basic TexSubImage2D() with 2D texture usage 1191 class BasicTexSubImage2DCase : public Texture2DSpecCase 1192 { 1193 public: 1194 BasicTexSubImage2DCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int width, int height) 1195 : Texture2DSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), width, height, maxLevelCount(width, height)) 1196 , m_internalFormat (format) 1197 , m_format (format) 1198 , m_dataType (dataType) 1199 { 1200 } 1201 1202 BasicTexSubImage2DCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height) 1203 : Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, maxLevelCount(width, height)) 1204 , m_internalFormat (internalFormat) 1205 , m_format (GL_NONE) 1206 , m_dataType (GL_NONE) 1207 { 1208 glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat); 1209 m_format = fmt.format; 1210 m_dataType = fmt.dataType; 1211 } 1212 1213 protected: 1214 void createTexture (void) 1215 { 1216 deUint32 tex = 0; 1217 tcu::TextureLevel data (m_texFormat); 1218 de::Random rnd (deStringHash(getName())); 1219 1220 glGenTextures(1, &tex); 1221 glBindTexture(GL_TEXTURE_2D, tex); 1222 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 1223 1224 // First specify full texture. 1225 for (int ndx = 0; ndx < m_numLevels; ndx++) 1226 { 1227 int levelW = de::max(1, m_width >> ndx); 1228 int levelH = de::max(1, m_height >> ndx); 1229 Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 1230 Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 1231 1232 data.setSize(levelW, levelH); 1233 tcu::fillWithComponentGradients(data.getAccess(), gMin, gMax); 1234 1235 glTexImage2D(GL_TEXTURE_2D, ndx, m_internalFormat, levelW, levelH, 0, m_format, m_dataType, data.getAccess().getDataPtr()); 1236 } 1237 1238 // Re-specify parts of each level. 1239 for (int ndx = 0; ndx < m_numLevels; ndx++) 1240 { 1241 int levelW = de::max(1, m_width >> ndx); 1242 int levelH = de::max(1, m_height >> ndx); 1243 1244 int w = rnd.getInt(1, levelW); 1245 int h = rnd.getInt(1, levelH); 1246 int x = rnd.getInt(0, levelW-w); 1247 int y = rnd.getInt(0, levelH-h); 1248 1249 Vec4 colorA = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 1250 Vec4 colorB = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 1251 int cellSize = rnd.getInt(2, 16); 1252 1253 data.setSize(w, h); 1254 tcu::fillWithGrid(data.getAccess(), cellSize, colorA, colorB); 1255 1256 glTexSubImage2D(GL_TEXTURE_2D, ndx, x, y, w, h, m_format, m_dataType, data.getAccess().getDataPtr()); 1257 } 1258 } 1259 1260 deUint32 m_internalFormat; 1261 deUint32 m_format; 1262 deUint32 m_dataType; 1263 }; 1264 1265 // Basic TexSubImage2D() with cubemap usage 1266 class BasicTexSubImageCubeCase : public TextureCubeSpecCase 1267 { 1268 public: 1269 BasicTexSubImageCubeCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int size) 1270 : TextureCubeSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), size, deLog2Floor32(size)+1) 1271 , m_internalFormat (format) 1272 , m_format (format) 1273 , m_dataType (dataType) 1274 { 1275 } 1276 1277 BasicTexSubImageCubeCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int size) 1278 : TextureCubeSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), size, deLog2Floor32(size)+1) 1279 , m_internalFormat (internalFormat) 1280 , m_format (GL_NONE) 1281 , m_dataType (GL_NONE) 1282 { 1283 glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat); 1284 m_format = fmt.format; 1285 m_dataType = fmt.dataType; 1286 } 1287 1288 protected: 1289 void createTexture (void) 1290 { 1291 deUint32 tex = 0; 1292 tcu::TextureLevel data (m_texFormat); 1293 de::Random rnd (deStringHash(getName())); 1294 1295 glGenTextures(1, &tex); 1296 glBindTexture(GL_TEXTURE_CUBE_MAP, tex); 1297 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 1298 1299 for (int ndx = 0; ndx < m_numLevels; ndx++) 1300 { 1301 int levelSize = de::max(1, m_size >> ndx); 1302 1303 data.setSize(levelSize, levelSize); 1304 1305 for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++) 1306 { 1307 Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 1308 Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 1309 1310 tcu::fillWithComponentGradients(data.getAccess(), gMin, gMax); 1311 1312 glTexImage2D(s_cubeMapFaces[face], ndx, m_internalFormat, levelSize, levelSize, 0, m_format, m_dataType, data.getAccess().getDataPtr()); 1313 } 1314 } 1315 1316 // Re-specify parts of each face and level. 1317 for (int ndx = 0; ndx < m_numLevels; ndx++) 1318 { 1319 int levelSize = de::max(1, m_size >> ndx); 1320 1321 for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++) 1322 { 1323 int w = rnd.getInt(1, levelSize); 1324 int h = rnd.getInt(1, levelSize); 1325 int x = rnd.getInt(0, levelSize-w); 1326 int y = rnd.getInt(0, levelSize-h); 1327 1328 Vec4 colorA = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 1329 Vec4 colorB = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 1330 int cellSize = rnd.getInt(2, 16); 1331 1332 data.setSize(w, h); 1333 tcu::fillWithGrid(data.getAccess(), cellSize, colorA, colorB); 1334 1335 glTexSubImage2D(s_cubeMapFaces[face], ndx, x, y, w, h, m_format, m_dataType, data.getAccess().getDataPtr()); 1336 } 1337 } 1338 } 1339 1340 deUint32 m_internalFormat; 1341 deUint32 m_format; 1342 deUint32 m_dataType; 1343 }; 1344 1345 // TexSubImage2D() unpack parameters case. 1346 class TexSubImage2DParamsCase : public Texture2DSpecCase 1347 { 1348 public: 1349 TexSubImage2DParamsCase (Context& context, 1350 const char* name, 1351 const char* desc, 1352 deUint32 internalFormat, 1353 int width, 1354 int height, 1355 int subX, 1356 int subY, 1357 int subW, 1358 int subH, 1359 int rowLength, 1360 int skipRows, 1361 int skipPixels, 1362 int alignment) 1363 : Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, 1) 1364 , m_internalFormat (internalFormat) 1365 , m_subX (subX) 1366 , m_subY (subY) 1367 , m_subW (subW) 1368 , m_subH (subH) 1369 , m_rowLength (rowLength) 1370 , m_skipRows (skipRows) 1371 , m_skipPixels (skipPixels) 1372 , m_alignment (alignment) 1373 { 1374 } 1375 1376 protected: 1377 void createTexture (void) 1378 { 1379 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat); 1380 int pixelSize = m_texFormat.getPixelSize(); 1381 deUint32 tex = 0; 1382 vector<deUint8> data; 1383 1384 DE_ASSERT(m_numLevels == 1); 1385 1386 glGenTextures(1, &tex); 1387 glBindTexture(GL_TEXTURE_2D, tex); 1388 1389 // First fill texture with gradient. 1390 data.resize(deAlign32(m_width*pixelSize, 4)*m_height); 1391 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); 1392 glTexImage2D(GL_TEXTURE_2D, 0, m_internalFormat, m_width, m_height, 0, transferFmt.format, transferFmt.dataType, &data[0]); 1393 1394 // Fill data with grid. 1395 { 1396 int rowLength = m_rowLength > 0 ? m_rowLength : m_subW; 1397 int rowPitch = deAlign32(rowLength*pixelSize, m_alignment); 1398 int height = m_subH + m_skipRows; 1399 Vec4 cScale = m_texFormatInfo.valueMax-m_texFormatInfo.valueMin; 1400 Vec4 cBias = m_texFormatInfo.valueMin; 1401 Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*cScale + cBias; 1402 Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*cScale + cBias; 1403 1404 data.resize(rowPitch*height); 1405 tcu::fillWithGrid(tcu::PixelBufferAccess(m_texFormat, m_subW, m_subH, 1, rowPitch, 0, &data[0] + m_skipRows*rowPitch + m_skipPixels*pixelSize), 4, colorA, colorB); 1406 } 1407 1408 glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength); 1409 glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows); 1410 glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels); 1411 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment); 1412 glTexSubImage2D(GL_TEXTURE_2D, 0, m_subX, m_subY, m_subW, m_subH, transferFmt.format, transferFmt.dataType, &data[0]); 1413 } 1414 1415 deUint32 m_internalFormat; 1416 int m_subX; 1417 int m_subY; 1418 int m_subW; 1419 int m_subH; 1420 int m_rowLength; 1421 int m_skipRows; 1422 int m_skipPixels; 1423 int m_alignment; 1424 }; 1425 1426 // Basic TexSubImage3D() with 3D texture usage 1427 class BasicTexSubImage3DCase : public Texture3DSpecCase 1428 { 1429 public: 1430 BasicTexSubImage3DCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height, int depth) 1431 : Texture3DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, depth, maxLevelCount(width, height, depth)) 1432 , m_internalFormat (internalFormat) 1433 { 1434 } 1435 1436 protected: 1437 void createTexture (void) 1438 { 1439 deUint32 tex = 0; 1440 tcu::TextureLevel data (m_texFormat); 1441 de::Random rnd (deStringHash(getName())); 1442 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat); 1443 1444 glGenTextures(1, &tex); 1445 glBindTexture(GL_TEXTURE_3D, tex); 1446 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 1447 1448 // First specify full texture. 1449 for (int ndx = 0; ndx < m_numLevels; ndx++) 1450 { 1451 int levelW = de::max(1, m_width >> ndx); 1452 int levelH = de::max(1, m_height >> ndx); 1453 int levelD = de::max(1, m_depth >> ndx); 1454 Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 1455 Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 1456 1457 data.setSize(levelW, levelH, levelD); 1458 tcu::fillWithComponentGradients(data.getAccess(), gMin, gMax); 1459 1460 glTexImage3D(GL_TEXTURE_3D, ndx, m_internalFormat, levelW, levelH, levelD, 0, transferFmt.format, transferFmt.dataType, data.getAccess().getDataPtr()); 1461 } 1462 1463 // Re-specify parts of each level. 1464 for (int ndx = 0; ndx < m_numLevels; ndx++) 1465 { 1466 int levelW = de::max(1, m_width >> ndx); 1467 int levelH = de::max(1, m_height >> ndx); 1468 int levelD = de::max(1, m_depth >> ndx); 1469 1470 int w = rnd.getInt(1, levelW); 1471 int h = rnd.getInt(1, levelH); 1472 int d = rnd.getInt(1, levelD); 1473 int x = rnd.getInt(0, levelW-w); 1474 int y = rnd.getInt(0, levelH-h); 1475 int z = rnd.getInt(0, levelD-d); 1476 1477 Vec4 colorA = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 1478 Vec4 colorB = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 1479 int cellSize = rnd.getInt(2, 16); 1480 1481 data.setSize(w, h, d); 1482 tcu::fillWithGrid(data.getAccess(), cellSize, colorA, colorB); 1483 1484 glTexSubImage3D(GL_TEXTURE_3D, ndx, x, y, z, w, h, d, transferFmt.format, transferFmt.dataType, data.getAccess().getDataPtr()); 1485 } 1486 } 1487 1488 deUint32 m_internalFormat; 1489 }; 1490 1491 // TexSubImage2D() to texture initialized with empty data 1492 class TexSubImage2DEmptyTexCase : public Texture2DSpecCase 1493 { 1494 public: 1495 TexSubImage2DEmptyTexCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int width, int height) 1496 : Texture2DSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), width, height, maxLevelCount(width, height)) 1497 , m_internalFormat (format) 1498 , m_format (format) 1499 , m_dataType (dataType) 1500 { 1501 } 1502 1503 TexSubImage2DEmptyTexCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height) 1504 : Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, maxLevelCount(width, height)) 1505 , m_internalFormat (internalFormat) 1506 , m_format (GL_NONE) 1507 , m_dataType (GL_NONE) 1508 { 1509 glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat); 1510 m_format = fmt.format; 1511 m_dataType = fmt.dataType; 1512 } 1513 1514 protected: 1515 void createTexture (void) 1516 { 1517 deUint32 tex = 0; 1518 tcu::TextureLevel data (m_texFormat); 1519 de::Random rnd (deStringHash(getName())); 1520 1521 glGenTextures(1, &tex); 1522 glBindTexture(GL_TEXTURE_2D, tex); 1523 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 1524 1525 // First allocate storage for each level. 1526 for (int ndx = 0; ndx < m_numLevels; ndx++) 1527 { 1528 int levelW = de::max(1, m_width >> ndx); 1529 int levelH = de::max(1, m_height >> ndx); 1530 1531 glTexImage2D(GL_TEXTURE_2D, ndx, m_internalFormat, levelW, levelH, 0, m_format, m_dataType, DE_NULL); 1532 } 1533 1534 // Specify pixel data to all levels using glTexSubImage2D() 1535 for (int ndx = 0; ndx < m_numLevels; ndx++) 1536 { 1537 int levelW = de::max(1, m_width >> ndx); 1538 int levelH = de::max(1, m_height >> ndx); 1539 Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 1540 Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 1541 1542 data.setSize(levelW, levelH); 1543 tcu::fillWithComponentGradients(data.getAccess(), gMin, gMax); 1544 1545 glTexSubImage2D(GL_TEXTURE_2D, ndx, 0, 0, levelW, levelH, m_format, m_dataType, data.getAccess().getDataPtr()); 1546 } 1547 } 1548 1549 deUint32 m_internalFormat; 1550 deUint32 m_format; 1551 deUint32 m_dataType; 1552 }; 1553 1554 // TexSubImage2D() to empty cubemap texture 1555 class TexSubImageCubeEmptyTexCase : public TextureCubeSpecCase 1556 { 1557 public: 1558 TexSubImageCubeEmptyTexCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int size) 1559 : TextureCubeSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), size, deLog2Floor32(size)+1) 1560 , m_internalFormat (format) 1561 , m_format (format) 1562 , m_dataType (dataType) 1563 { 1564 } 1565 1566 TexSubImageCubeEmptyTexCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int size) 1567 : TextureCubeSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), size, deLog2Floor32(size)+1) 1568 , m_internalFormat (internalFormat) 1569 , m_format (GL_NONE) 1570 , m_dataType (GL_NONE) 1571 { 1572 glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat); 1573 m_format = fmt.format; 1574 m_dataType = fmt.dataType; 1575 } 1576 1577 protected: 1578 void createTexture (void) 1579 { 1580 deUint32 tex = 0; 1581 tcu::TextureLevel data (m_texFormat); 1582 de::Random rnd (deStringHash(getName())); 1583 1584 glGenTextures(1, &tex); 1585 glBindTexture(GL_TEXTURE_CUBE_MAP, tex); 1586 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 1587 1588 // Specify storage for each level. 1589 for (int ndx = 0; ndx < m_numLevels; ndx++) 1590 { 1591 int levelSize = de::max(1, m_size >> ndx); 1592 1593 for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++) 1594 glTexImage2D(s_cubeMapFaces[face], ndx, m_internalFormat, levelSize, levelSize, 0, m_format, m_dataType, DE_NULL); 1595 } 1596 1597 // Specify data using glTexSubImage2D() 1598 for (int ndx = 0; ndx < m_numLevels; ndx++) 1599 { 1600 int levelSize = de::max(1, m_size >> ndx); 1601 1602 data.setSize(levelSize, levelSize); 1603 1604 for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++) 1605 { 1606 Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 1607 Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 1608 1609 tcu::fillWithComponentGradients(data.getAccess(), gMin, gMax); 1610 1611 glTexSubImage2D(s_cubeMapFaces[face], ndx, 0, 0, levelSize, levelSize, m_format, m_dataType, data.getAccess().getDataPtr()); 1612 } 1613 } 1614 } 1615 1616 deUint32 m_internalFormat; 1617 deUint32 m_format; 1618 deUint32 m_dataType; 1619 }; 1620 1621 // TexSubImage2D() unpack alignment with 2D texture 1622 class TexSubImage2DAlignCase : public Texture2DSpecCase 1623 { 1624 public: 1625 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) 1626 : Texture2DSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), width, height, 1) 1627 , m_internalFormat (format) 1628 , m_format (format) 1629 , m_dataType (dataType) 1630 , m_subX (subX) 1631 , m_subY (subY) 1632 , m_subW (subW) 1633 , m_subH (subH) 1634 , m_alignment (alignment) 1635 { 1636 } 1637 1638 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) 1639 : Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, 1) 1640 , m_internalFormat (internalFormat) 1641 , m_format (GL_NONE) 1642 , m_dataType (GL_NONE) 1643 , m_subX (subX) 1644 , m_subY (subY) 1645 , m_subW (subW) 1646 , m_subH (subH) 1647 , m_alignment (alignment) 1648 { 1649 glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat); 1650 m_format = fmt.format; 1651 m_dataType = fmt.dataType; 1652 } 1653 1654 protected: 1655 void createTexture (void) 1656 { 1657 deUint32 tex = 0; 1658 vector<deUint8> data; 1659 1660 glGenTextures(1, &tex); 1661 glBindTexture(GL_TEXTURE_2D, tex); 1662 1663 // Specify base level. 1664 data.resize(m_texFormat.getPixelSize()*m_width*m_height); 1665 tcu::fillWithComponentGradients(tcu::PixelBufferAccess(m_texFormat, m_width, m_height, 1, &data[0]), Vec4(0.0f), Vec4(1.0f)); 1666 1667 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 1668 glTexImage2D(GL_TEXTURE_2D, 0, m_internalFormat, m_width, m_height, 0, m_format, m_dataType, &data[0]); 1669 1670 // Re-specify subrectangle. 1671 int rowPitch = deAlign32(m_texFormat.getPixelSize()*m_subW, m_alignment); 1672 data.resize(rowPitch*m_subH); 1673 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)); 1674 1675 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment); 1676 glTexSubImage2D(GL_TEXTURE_2D, 0, m_subX, m_subY, m_subW, m_subH, m_format, m_dataType, &data[0]); 1677 } 1678 1679 deUint32 m_internalFormat; 1680 deUint32 m_format; 1681 deUint32 m_dataType; 1682 int m_subX; 1683 int m_subY; 1684 int m_subW; 1685 int m_subH; 1686 int m_alignment; 1687 }; 1688 1689 // TexSubImage2D() unpack alignment with cubemap texture 1690 class TexSubImageCubeAlignCase : public TextureCubeSpecCase 1691 { 1692 public: 1693 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) 1694 : TextureCubeSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), size, 1) 1695 , m_internalFormat (format) 1696 , m_format (format) 1697 , m_dataType (dataType) 1698 , m_subX (subX) 1699 , m_subY (subY) 1700 , m_subW (subW) 1701 , m_subH (subH) 1702 , m_alignment (alignment) 1703 { 1704 } 1705 1706 TexSubImageCubeAlignCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int size, int subX, int subY, int subW, int subH, int alignment) 1707 : TextureCubeSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), size, 1) 1708 , m_internalFormat (internalFormat) 1709 , m_format (GL_NONE) 1710 , m_dataType (GL_NONE) 1711 , m_subX (subX) 1712 , m_subY (subY) 1713 , m_subW (subW) 1714 , m_subH (subH) 1715 , m_alignment (alignment) 1716 { 1717 glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat); 1718 m_format = fmt.format; 1719 m_dataType = fmt.dataType; 1720 } 1721 1722 protected: 1723 void createTexture (void) 1724 { 1725 deUint32 tex = 0; 1726 vector<deUint8> data; 1727 1728 glGenTextures(1, &tex); 1729 glBindTexture(GL_TEXTURE_CUBE_MAP, tex); 1730 1731 // Specify base level. 1732 data.resize(m_texFormat.getPixelSize()*m_size*m_size); 1733 tcu::fillWithComponentGradients(tcu::PixelBufferAccess(m_texFormat, m_size, m_size, 1, &data[0]), Vec4(0.0f), Vec4(1.0f)); 1734 1735 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 1736 for (int face = 0; face < tcu::CUBEFACE_LAST; face++) 1737 glTexImage2D(s_cubeMapFaces[face], 0, m_internalFormat, m_size, m_size, 0, m_format, m_dataType, &data[0]); 1738 1739 // Re-specify subrectangle. 1740 int rowPitch = deAlign32(m_texFormat.getPixelSize()*m_subW, m_alignment); 1741 data.resize(rowPitch*m_subH); 1742 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)); 1743 1744 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment); 1745 for (int face = 0; face < tcu::CUBEFACE_LAST; face++) 1746 glTexSubImage2D(s_cubeMapFaces[face], 0, m_subX, m_subY, m_subW, m_subH, m_format, m_dataType, &data[0]); 1747 } 1748 1749 deUint32 m_internalFormat; 1750 deUint32 m_format; 1751 deUint32 m_dataType; 1752 int m_subX; 1753 int m_subY; 1754 int m_subW; 1755 int m_subH; 1756 int m_alignment; 1757 }; 1758 1759 // TexSubImage3D() unpack parameters case. 1760 class TexSubImage3DParamsCase : public Texture3DSpecCase 1761 { 1762 public: 1763 TexSubImage3DParamsCase (Context& context, 1764 const char* name, 1765 const char* desc, 1766 deUint32 internalFormat, 1767 int width, 1768 int height, 1769 int depth, 1770 int subX, 1771 int subY, 1772 int subZ, 1773 int subW, 1774 int subH, 1775 int subD, 1776 int imageHeight, 1777 int rowLength, 1778 int skipImages, 1779 int skipRows, 1780 int skipPixels, 1781 int alignment) 1782 : Texture3DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, depth, 1) 1783 , m_internalFormat (internalFormat) 1784 , m_subX (subX) 1785 , m_subY (subY) 1786 , m_subZ (subZ) 1787 , m_subW (subW) 1788 , m_subH (subH) 1789 , m_subD (subD) 1790 , m_imageHeight (imageHeight) 1791 , m_rowLength (rowLength) 1792 , m_skipImages (skipImages) 1793 , m_skipRows (skipRows) 1794 , m_skipPixels (skipPixels) 1795 , m_alignment (alignment) 1796 { 1797 } 1798 1799 protected: 1800 void createTexture (void) 1801 { 1802 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat); 1803 int pixelSize = m_texFormat.getPixelSize(); 1804 deUint32 tex = 0; 1805 vector<deUint8> data; 1806 1807 DE_ASSERT(m_numLevels == 1); 1808 1809 glGenTextures(1, &tex); 1810 glBindTexture(GL_TEXTURE_3D, tex); 1811 1812 // Fill with gradient. 1813 { 1814 int rowPitch = deAlign32(pixelSize*m_width, 4); 1815 int slicePitch = rowPitch*m_height; 1816 1817 data.resize(slicePitch*m_depth); 1818 tcu::fillWithComponentGradients(tcu::PixelBufferAccess(m_texFormat, m_width, m_height, m_depth, rowPitch, slicePitch, &data[0]), m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 1819 } 1820 1821 glTexImage3D(GL_TEXTURE_3D, 0, m_internalFormat, m_width, m_height, m_depth, 0, transferFmt.format, transferFmt.dataType, &data[0]); 1822 1823 // Fill data with grid. 1824 { 1825 int rowLength = m_rowLength > 0 ? m_rowLength : m_subW; 1826 int rowPitch = deAlign32(rowLength*pixelSize, m_alignment); 1827 int imageHeight = m_imageHeight > 0 ? m_imageHeight : m_subH; 1828 int slicePitch = imageHeight*rowPitch; 1829 Vec4 cScale = m_texFormatInfo.valueMax-m_texFormatInfo.valueMin; 1830 Vec4 cBias = m_texFormatInfo.valueMin; 1831 Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*cScale + cBias; 1832 Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*cScale + cBias; 1833 1834 data.resize(slicePitch*(m_depth+m_skipImages)); 1835 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); 1836 } 1837 1838 glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, m_imageHeight); 1839 glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength); 1840 glPixelStorei(GL_UNPACK_SKIP_IMAGES, m_skipImages); 1841 glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows); 1842 glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels); 1843 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment); 1844 glTexSubImage3D(GL_TEXTURE_3D, 0, m_subX, m_subY, m_subZ, m_subW, m_subH, m_subD, transferFmt.format, transferFmt.dataType, &data[0]); 1845 } 1846 1847 deUint32 m_internalFormat; 1848 int m_subX; 1849 int m_subY; 1850 int m_subZ; 1851 int m_subW; 1852 int m_subH; 1853 int m_subD; 1854 int m_imageHeight; 1855 int m_rowLength; 1856 int m_skipImages; 1857 int m_skipRows; 1858 int m_skipPixels; 1859 int m_alignment; 1860 }; 1861 1862 // Basic CopyTexImage2D() with 2D texture usage 1863 class BasicCopyTexImage2DCase : public Texture2DSpecCase 1864 { 1865 public: 1866 BasicCopyTexImage2DCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height) 1867 : Texture2DSpecCase (context, name, desc, glu::mapGLTransferFormat(internalFormat, GL_UNSIGNED_BYTE), width, height, maxLevelCount(width, height)) 1868 , m_internalFormat (internalFormat) 1869 { 1870 } 1871 1872 protected: 1873 void createTexture (void) 1874 { 1875 const tcu::RenderTarget& renderTarget = TestCase::m_context.getRenderContext().getRenderTarget(); 1876 bool targetHasRGB = renderTarget.getPixelFormat().redBits > 0 && renderTarget.getPixelFormat().greenBits > 0 && renderTarget.getPixelFormat().blueBits > 0; 1877 bool targetHasAlpha = renderTarget.getPixelFormat().alphaBits > 0; 1878 tcu::TextureFormat fmt = mapGLUnsizedInternalFormat(m_internalFormat); 1879 bool texHasRGB = fmt.order != tcu::TextureFormat::A; 1880 bool texHasAlpha = fmt.order == tcu::TextureFormat::RGBA || fmt.order == tcu::TextureFormat::LA || fmt.order == tcu::TextureFormat::A; 1881 deUint32 tex = 0; 1882 de::Random rnd (deStringHash(getName())); 1883 GradientShader shader (glu::TYPE_FLOAT_VEC4); 1884 deUint32 shaderID = getCurrentContext()->createProgram(&shader); 1885 1886 if ((texHasRGB && !targetHasRGB) || (texHasAlpha && !targetHasAlpha)) 1887 throw tcu::NotSupportedError("Copying from current framebuffer is not supported", "", __FILE__, __LINE__); 1888 1889 // Fill render target with gradient. 1890 shader.setGradient(*getCurrentContext(), shaderID, Vec4(0.0f), Vec4(1.0f)); 1891 sglr::drawQuad(*getCurrentContext(), shaderID, tcu::Vec3(-1.0f, -1.0f, 0.0f), tcu::Vec3(1.0f, 1.0f, 0.0f)); 1892 1893 glGenTextures(1, &tex); 1894 glBindTexture(GL_TEXTURE_2D, tex); 1895 1896 for (int ndx = 0; ndx < m_numLevels; ndx++) 1897 { 1898 int levelW = de::max(1, m_width >> ndx); 1899 int levelH = de::max(1, m_height >> ndx); 1900 int x = rnd.getInt(0, getWidth() - levelW); 1901 int y = rnd.getInt(0, getHeight() - levelH); 1902 1903 glCopyTexImage2D(GL_TEXTURE_2D, ndx, m_internalFormat, x, y, levelW, levelH, 0); 1904 } 1905 } 1906 1907 deUint32 m_internalFormat; 1908 }; 1909 1910 // Basic CopyTexImage2D() with cubemap usage 1911 class BasicCopyTexImageCubeCase : public TextureCubeSpecCase 1912 { 1913 public: 1914 BasicCopyTexImageCubeCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int size) 1915 : TextureCubeSpecCase (context, name, desc, glu::mapGLTransferFormat(internalFormat, GL_UNSIGNED_BYTE), size, deLog2Floor32(size)+1) 1916 , m_internalFormat (internalFormat) 1917 { 1918 } 1919 1920 protected: 1921 void createTexture (void) 1922 { 1923 const tcu::RenderTarget& renderTarget = TestCase::m_context.getRenderContext().getRenderTarget(); 1924 bool targetHasRGB = renderTarget.getPixelFormat().redBits > 0 && renderTarget.getPixelFormat().greenBits > 0 && renderTarget.getPixelFormat().blueBits > 0; 1925 bool targetHasAlpha = renderTarget.getPixelFormat().alphaBits > 0; 1926 tcu::TextureFormat fmt = mapGLUnsizedInternalFormat(m_internalFormat); 1927 bool texHasRGB = fmt.order != tcu::TextureFormat::A; 1928 bool texHasAlpha = fmt.order == tcu::TextureFormat::RGBA || fmt.order == tcu::TextureFormat::LA || fmt.order == tcu::TextureFormat::A; 1929 deUint32 tex = 0; 1930 de::Random rnd (deStringHash(getName())); 1931 GradientShader shader (glu::TYPE_FLOAT_VEC4); 1932 deUint32 shaderID = getCurrentContext()->createProgram(&shader); 1933 1934 if ((texHasRGB && !targetHasRGB) || (texHasAlpha && !targetHasAlpha)) 1935 throw tcu::NotSupportedError("Copying from current framebuffer is not supported", "", __FILE__, __LINE__); 1936 1937 // Fill render target with gradient. 1938 shader.setGradient(*getCurrentContext(), shaderID, Vec4(0.0f), Vec4(1.0f)); 1939 sglr::drawQuad(*getCurrentContext(), shaderID, tcu::Vec3(-1.0f, -1.0f, 0.0f), tcu::Vec3(1.0f, 1.0f, 0.0f)); 1940 1941 glGenTextures(1, &tex); 1942 glBindTexture(GL_TEXTURE_CUBE_MAP, tex); 1943 1944 for (int ndx = 0; ndx < m_numLevels; ndx++) 1945 { 1946 int levelSize = de::max(1, m_size >> ndx); 1947 1948 for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++) 1949 { 1950 int x = rnd.getInt(0, getWidth() - levelSize); 1951 int y = rnd.getInt(0, getHeight() - levelSize); 1952 1953 glCopyTexImage2D(s_cubeMapFaces[face], ndx, m_internalFormat, x, y, levelSize, levelSize, 0); 1954 } 1955 } 1956 } 1957 1958 deUint32 m_internalFormat; 1959 }; 1960 1961 // Basic CopyTexSubImage2D() with 2D texture usage 1962 class BasicCopyTexSubImage2DCase : public Texture2DSpecCase 1963 { 1964 public: 1965 BasicCopyTexSubImage2DCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int width, int height) 1966 : Texture2DSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), width, height, maxLevelCount(width, height)) 1967 , m_format (format) 1968 , m_dataType (dataType) 1969 { 1970 } 1971 1972 protected: 1973 void createTexture (void) 1974 { 1975 const tcu::RenderTarget& renderTarget = TestCase::m_context.getRenderContext().getRenderTarget(); 1976 bool targetHasRGB = renderTarget.getPixelFormat().redBits > 0 && renderTarget.getPixelFormat().greenBits > 0 && renderTarget.getPixelFormat().blueBits > 0; 1977 bool targetHasAlpha = renderTarget.getPixelFormat().alphaBits > 0; 1978 tcu::TextureFormat fmt = glu::mapGLTransferFormat(m_format, m_dataType); 1979 bool texHasRGB = fmt.order != tcu::TextureFormat::A; 1980 bool texHasAlpha = fmt.order == tcu::TextureFormat::RGBA || fmt.order == tcu::TextureFormat::LA || fmt.order == tcu::TextureFormat::A; 1981 deUint32 tex = 0; 1982 tcu::TextureLevel data (fmt); 1983 de::Random rnd (deStringHash(getName())); 1984 GradientShader shader (glu::TYPE_FLOAT_VEC4); 1985 deUint32 shaderID = getCurrentContext()->createProgram(&shader); 1986 1987 if ((texHasRGB && !targetHasRGB) || (texHasAlpha && !targetHasAlpha)) 1988 throw tcu::NotSupportedError("Copying from current framebuffer is not supported", "", __FILE__, __LINE__); 1989 1990 glGenTextures(1, &tex); 1991 glBindTexture(GL_TEXTURE_2D, tex); 1992 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 1993 1994 // First specify full texture. 1995 for (int ndx = 0; ndx < m_numLevels; ndx++) 1996 { 1997 int levelW = de::max(1, m_width >> ndx); 1998 int levelH = de::max(1, m_height >> ndx); 1999 2000 Vec4 colorA = randomVector<4>(rnd); 2001 Vec4 colorB = randomVector<4>(rnd); 2002 int cellSize = rnd.getInt(2, 16); 2003 2004 data.setSize(levelW, levelH); 2005 tcu::fillWithGrid(data.getAccess(), cellSize, colorA, colorB); 2006 2007 glTexImage2D(GL_TEXTURE_2D, ndx, m_format, levelW, levelH, 0, m_format, m_dataType, data.getAccess().getDataPtr()); 2008 } 2009 2010 // Fill render target with gradient. 2011 shader.setGradient(*getCurrentContext(), shaderID, Vec4(0.0f), Vec4(1.0f)); 2012 sglr::drawQuad(*getCurrentContext(), shaderID, tcu::Vec3(-1.0f, -1.0f, 0.0f), tcu::Vec3(1.0f, 1.0f, 0.0f)); 2013 2014 // Re-specify parts of each level. 2015 for (int ndx = 0; ndx < m_numLevels; ndx++) 2016 { 2017 int levelW = de::max(1, m_width >> ndx); 2018 int levelH = de::max(1, m_height >> ndx); 2019 2020 int w = rnd.getInt(1, levelW); 2021 int h = rnd.getInt(1, levelH); 2022 int xo = rnd.getInt(0, levelW-w); 2023 int yo = rnd.getInt(0, levelH-h); 2024 2025 int x = rnd.getInt(0, getWidth() - w); 2026 int y = rnd.getInt(0, getHeight() - h); 2027 2028 glCopyTexSubImage2D(GL_TEXTURE_2D, ndx, xo, yo, x, y, w, h); 2029 } 2030 } 2031 2032 deUint32 m_format; 2033 deUint32 m_dataType; 2034 }; 2035 2036 // Basic CopyTexSubImage2D() with cubemap usage 2037 class BasicCopyTexSubImageCubeCase : public TextureCubeSpecCase 2038 { 2039 public: 2040 BasicCopyTexSubImageCubeCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int size) 2041 : TextureCubeSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), size, deLog2Floor32(size)+1) 2042 , m_format (format) 2043 , m_dataType (dataType) 2044 { 2045 } 2046 2047 protected: 2048 void createTexture (void) 2049 { 2050 const tcu::RenderTarget& renderTarget = TestCase::m_context.getRenderContext().getRenderTarget(); 2051 bool targetHasRGB = renderTarget.getPixelFormat().redBits > 0 && renderTarget.getPixelFormat().greenBits > 0 && renderTarget.getPixelFormat().blueBits > 0; 2052 bool targetHasAlpha = renderTarget.getPixelFormat().alphaBits > 0; 2053 tcu::TextureFormat fmt = glu::mapGLTransferFormat(m_format, m_dataType); 2054 bool texHasRGB = fmt.order != tcu::TextureFormat::A; 2055 bool texHasAlpha = fmt.order == tcu::TextureFormat::RGBA || fmt.order == tcu::TextureFormat::LA || fmt.order == tcu::TextureFormat::A; 2056 deUint32 tex = 0; 2057 tcu::TextureLevel data (fmt); 2058 de::Random rnd (deStringHash(getName())); 2059 GradientShader shader (glu::TYPE_FLOAT_VEC4); 2060 deUint32 shaderID = getCurrentContext()->createProgram(&shader); 2061 2062 if ((texHasRGB && !targetHasRGB) || (texHasAlpha && !targetHasAlpha)) 2063 throw tcu::NotSupportedError("Copying from current framebuffer is not supported", "", __FILE__, __LINE__); 2064 2065 glGenTextures(1, &tex); 2066 glBindTexture(GL_TEXTURE_CUBE_MAP, tex); 2067 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 2068 2069 for (int ndx = 0; ndx < m_numLevels; ndx++) 2070 { 2071 int levelSize = de::max(1, m_size >> ndx); 2072 2073 data.setSize(levelSize, levelSize); 2074 2075 for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++) 2076 { 2077 Vec4 colorA = randomVector<4>(rnd); 2078 Vec4 colorB = randomVector<4>(rnd); 2079 int cellSize = rnd.getInt(2, 16); 2080 2081 tcu::fillWithGrid(data.getAccess(), cellSize, colorA, colorB); 2082 glTexImage2D(s_cubeMapFaces[face], ndx, m_format, levelSize, levelSize, 0, m_format, m_dataType, data.getAccess().getDataPtr()); 2083 } 2084 } 2085 2086 // Fill render target with gradient. 2087 shader.setGradient(*getCurrentContext(), shaderID, Vec4(0.0f), Vec4(1.0f)); 2088 sglr::drawQuad(*getCurrentContext(), shaderID, tcu::Vec3(-1.0f, -1.0f, 0.0f), tcu::Vec3(1.0f, 1.0f, 0.0f)); 2089 2090 // Re-specify parts of each face and level. 2091 for (int ndx = 0; ndx < m_numLevels; ndx++) 2092 { 2093 int levelSize = de::max(1, m_size >> ndx); 2094 2095 for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++) 2096 { 2097 int w = rnd.getInt(1, levelSize); 2098 int h = rnd.getInt(1, levelSize); 2099 int xo = rnd.getInt(0, levelSize-w); 2100 int yo = rnd.getInt(0, levelSize-h); 2101 2102 int x = rnd.getInt(0, getWidth() - w); 2103 int y = rnd.getInt(0, getHeight() - h); 2104 2105 glCopyTexSubImage2D(s_cubeMapFaces[face], ndx, xo, yo, x, y, w, h); 2106 } 2107 } 2108 } 2109 2110 deUint32 m_format; 2111 deUint32 m_dataType; 2112 }; 2113 2114 // Basic glTexStorage2D() with 2D texture usage 2115 class BasicTexStorage2DCase : public Texture2DSpecCase 2116 { 2117 public: 2118 BasicTexStorage2DCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height, int numLevels) 2119 : Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, numLevels) 2120 , m_internalFormat (internalFormat) 2121 { 2122 } 2123 2124 protected: 2125 void createTexture (void) 2126 { 2127 tcu::TextureFormat fmt = glu::mapGLInternalFormat(m_internalFormat); 2128 glu::TransferFormat transferFmt = glu::getTransferFormat(fmt); 2129 deUint32 tex = 0; 2130 tcu::TextureLevel levelData (glu::mapGLTransferFormat(transferFmt.format, transferFmt.dataType)); 2131 de::Random rnd (deStringHash(getName())); 2132 2133 glGenTextures(1, &tex); 2134 glBindTexture(GL_TEXTURE_2D, tex); 2135 glTexStorage2D(GL_TEXTURE_2D, m_numLevels, m_internalFormat, m_width, m_height); 2136 2137 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 2138 2139 for (int ndx = 0; ndx < m_numLevels; ndx++) 2140 { 2141 int levelW = de::max(1, m_width >> ndx); 2142 int levelH = de::max(1, m_height >> ndx); 2143 Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 2144 Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 2145 2146 levelData.setSize(levelW, levelH); 2147 tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax); 2148 2149 glTexSubImage2D(GL_TEXTURE_2D, ndx, 0, 0, levelW, levelH, transferFmt.format, transferFmt.dataType, levelData.getAccess().getDataPtr()); 2150 } 2151 } 2152 2153 deUint32 m_internalFormat; 2154 }; 2155 2156 // Basic glTexStorage2D() with cubemap usage 2157 class BasicTexStorageCubeCase : public TextureCubeSpecCase 2158 { 2159 public: 2160 BasicTexStorageCubeCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int size, int numLevels) 2161 : TextureCubeSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), size, numLevels) 2162 , m_internalFormat (internalFormat) 2163 { 2164 } 2165 2166 protected: 2167 void createTexture (void) 2168 { 2169 tcu::TextureFormat fmt = glu::mapGLInternalFormat(m_internalFormat); 2170 glu::TransferFormat transferFmt = glu::getTransferFormat(fmt); 2171 deUint32 tex = 0; 2172 tcu::TextureLevel levelData (glu::mapGLTransferFormat(transferFmt.format, transferFmt.dataType)); 2173 de::Random rnd (deStringHash(getName())); 2174 2175 glGenTextures(1, &tex); 2176 glBindTexture(GL_TEXTURE_CUBE_MAP, tex); 2177 glTexStorage2D(GL_TEXTURE_CUBE_MAP, m_numLevels, m_internalFormat, m_size, m_size); 2178 2179 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 2180 2181 for (int ndx = 0; ndx < m_numLevels; ndx++) 2182 { 2183 int levelSize = de::max(1, m_size >> ndx); 2184 2185 levelData.setSize(levelSize, levelSize); 2186 2187 for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++) 2188 { 2189 Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 2190 Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 2191 2192 tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax); 2193 2194 glTexSubImage2D(s_cubeMapFaces[face], ndx, 0, 0, levelSize, levelSize, transferFmt.format, transferFmt.dataType, levelData.getAccess().getDataPtr()); 2195 } 2196 } 2197 } 2198 2199 deUint32 m_internalFormat; 2200 }; 2201 2202 // Basic glTexStorage3D() with 2D array texture usage 2203 class BasicTexStorage2DArrayCase : public Texture2DArraySpecCase 2204 { 2205 public: 2206 BasicTexStorage2DArrayCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height, int numLayers, int numLevels) 2207 : Texture2DArraySpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, numLayers, numLevels) 2208 , m_internalFormat (internalFormat) 2209 { 2210 } 2211 2212 protected: 2213 void createTexture (void) 2214 { 2215 deUint32 tex = 0; 2216 de::Random rnd (deStringHash(getName())); 2217 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat); 2218 tcu::TextureLevel levelData (glu::mapGLTransferFormat(transferFmt.format, transferFmt.dataType)); 2219 2220 glGenTextures (1, &tex); 2221 glBindTexture (GL_TEXTURE_2D_ARRAY, tex); 2222 glTexStorage3D (GL_TEXTURE_2D_ARRAY, m_numLevels, m_internalFormat, m_width, m_height, m_numLayers); 2223 2224 glPixelStorei (GL_UNPACK_ALIGNMENT, 1); 2225 2226 for (int ndx = 0; ndx < m_numLevels; ndx++) 2227 { 2228 int levelW = de::max(1, m_width >> ndx); 2229 int levelH = de::max(1, m_height >> ndx); 2230 Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 2231 Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 2232 2233 levelData.setSize(levelW, levelH, m_numLayers); 2234 tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax); 2235 2236 glTexSubImage3D(GL_TEXTURE_2D_ARRAY, ndx, 0, 0, 0, levelW, levelH, m_numLayers, transferFmt.format, transferFmt.dataType, levelData.getAccess().getDataPtr()); 2237 } 2238 } 2239 2240 deUint32 m_internalFormat; 2241 }; 2242 2243 // Basic TexStorage3D() with 3D texture usage 2244 class BasicTexStorage3DCase : public Texture3DSpecCase 2245 { 2246 public: 2247 BasicTexStorage3DCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height, int depth, int numLevels) 2248 : Texture3DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, depth, numLevels) 2249 , m_internalFormat (internalFormat) 2250 { 2251 } 2252 2253 protected: 2254 void createTexture (void) 2255 { 2256 deUint32 tex = 0; 2257 de::Random rnd (deStringHash(getName())); 2258 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat); 2259 tcu::TextureLevel levelData (glu::mapGLTransferFormat(transferFmt.format, transferFmt.dataType)); 2260 2261 glGenTextures (1, &tex); 2262 glBindTexture (GL_TEXTURE_3D, tex); 2263 glTexStorage3D (GL_TEXTURE_3D, m_numLevels, m_internalFormat, m_width, m_height, m_depth); 2264 2265 glPixelStorei (GL_UNPACK_ALIGNMENT, 1); 2266 2267 for (int ndx = 0; ndx < m_numLevels; ndx++) 2268 { 2269 int levelW = de::max(1, m_width >> ndx); 2270 int levelH = de::max(1, m_height >> ndx); 2271 int levelD = de::max(1, m_depth >> ndx); 2272 Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 2273 Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 2274 2275 levelData.setSize(levelW, levelH, levelD); 2276 tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax); 2277 2278 glTexSubImage3D(GL_TEXTURE_3D, ndx, 0, 0, 0, levelW, levelH, levelD, transferFmt.format, transferFmt.dataType, levelData.getAccess().getDataPtr()); 2279 } 2280 } 2281 2282 deUint32 m_internalFormat; 2283 }; 2284 2285 // Pixel buffer object cases. 2286 2287 // TexImage2D() from pixel buffer object. 2288 class TexImage2DBufferCase : public Texture2DSpecCase 2289 { 2290 public: 2291 TexImage2DBufferCase (Context& context, 2292 const char* name, 2293 const char* desc, 2294 deUint32 internalFormat, 2295 int width, 2296 int height, 2297 int rowLength, 2298 int skipRows, 2299 int skipPixels, 2300 int alignment, 2301 int offset) 2302 : Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, 1) 2303 , m_internalFormat (internalFormat) 2304 , m_rowLength (rowLength) 2305 , m_skipRows (skipRows) 2306 , m_skipPixels (skipPixels) 2307 , m_alignment (alignment) 2308 , m_offset (offset) 2309 { 2310 } 2311 2312 protected: 2313 void createTexture (void) 2314 { 2315 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat); 2316 int pixelSize = m_texFormat.getPixelSize(); 2317 int rowLength = m_rowLength > 0 ? m_rowLength : m_width + m_skipPixels; 2318 int rowPitch = deAlign32(rowLength*pixelSize, m_alignment); 2319 int height = m_height + m_skipRows; 2320 deUint32 buf = 0; 2321 deUint32 tex = 0; 2322 vector<deUint8> data; 2323 2324 DE_ASSERT(m_numLevels == 1); 2325 2326 // Fill data with grid. 2327 data.resize(rowPitch*height + m_offset); 2328 { 2329 Vec4 cScale = m_texFormatInfo.valueMax-m_texFormatInfo.valueMin; 2330 Vec4 cBias = m_texFormatInfo.valueMin; 2331 Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*cScale + cBias; 2332 Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*cScale + cBias; 2333 2334 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); 2335 } 2336 2337 // Create buffer and upload. 2338 glGenBuffers(1, &buf); 2339 glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buf); 2340 glBufferData(GL_PIXEL_UNPACK_BUFFER, (int)data.size(), &data[0], GL_STATIC_DRAW); 2341 2342 glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength); 2343 glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows); 2344 glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels); 2345 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment); 2346 2347 glGenTextures(1, &tex); 2348 glBindTexture(GL_TEXTURE_2D, tex); 2349 glTexImage2D(GL_TEXTURE_2D, 0, m_internalFormat, m_width, m_height, 0, transferFmt.format, transferFmt.dataType, (const void*)(deUintptr)m_offset); 2350 } 2351 2352 deUint32 m_internalFormat; 2353 int m_rowLength; 2354 int m_skipRows; 2355 int m_skipPixels; 2356 int m_alignment; 2357 int m_offset; 2358 }; 2359 2360 // TexImage2D() cubemap from pixel buffer object case 2361 class TexImageCubeBufferCase : public TextureCubeSpecCase 2362 { 2363 public: 2364 TexImageCubeBufferCase (Context& context, 2365 const char* name, 2366 const char* desc, 2367 deUint32 internalFormat, 2368 int size, 2369 int rowLength, 2370 int skipRows, 2371 int skipPixels, 2372 int alignment, 2373 int offset) 2374 : TextureCubeSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), size, 1) 2375 , m_internalFormat (internalFormat) 2376 , m_rowLength (rowLength) 2377 , m_skipRows (skipRows) 2378 , m_skipPixels (skipPixels) 2379 , m_alignment (alignment) 2380 , m_offset (offset) 2381 { 2382 } 2383 2384 protected: 2385 void createTexture (void) 2386 { 2387 de::Random rnd (deStringHash(getName())); 2388 deUint32 tex = 0; 2389 glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat); 2390 const int pixelSize = m_texFormat.getPixelSize(); 2391 const int rowLength = m_rowLength > 0 ? m_rowLength : m_size + m_skipPixels; 2392 const int rowPitch = deAlign32(rowLength*pixelSize, m_alignment); 2393 const int height = m_size + m_skipRows; 2394 vector<vector<deUint8> > data (DE_LENGTH_OF_ARRAY(s_cubeMapFaces)); 2395 2396 DE_ASSERT(m_numLevels == 1); 2397 2398 glGenTextures(1, &tex); 2399 glBindTexture(GL_TEXTURE_CUBE_MAP, tex); 2400 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 2401 2402 for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++) 2403 { 2404 deUint32 buf = 0; 2405 2406 { 2407 const Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 2408 const Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 2409 2410 data[face].resize(rowPitch*height + m_offset); 2411 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); 2412 } 2413 2414 // Create buffer and upload. 2415 glGenBuffers(1, &buf); 2416 glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buf); 2417 glBufferData(GL_PIXEL_UNPACK_BUFFER, (int)data[face].size(), &data[face][0], GL_STATIC_DRAW); 2418 2419 glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength); 2420 glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows); 2421 glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels); 2422 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment); 2423 2424 glTexImage2D(s_cubeMapFaces[face], 0, m_internalFormat, m_size, m_size, 0, fmt.format, fmt.dataType, (const void*)(deUintptr)m_offset); 2425 } 2426 } 2427 2428 deUint32 m_internalFormat; 2429 int m_rowLength; 2430 int m_skipRows; 2431 int m_skipPixels; 2432 int m_alignment; 2433 int m_offset; 2434 }; 2435 2436 // TexImage3D() 2D array from pixel buffer object. 2437 class TexImage2DArrayBufferCase : public Texture2DArraySpecCase 2438 { 2439 public: 2440 TexImage2DArrayBufferCase (Context& context, 2441 const char* name, 2442 const char* desc, 2443 deUint32 internalFormat, 2444 int width, 2445 int height, 2446 int depth, 2447 int imageHeight, 2448 int rowLength, 2449 int skipImages, 2450 int skipRows, 2451 int skipPixels, 2452 int alignment, 2453 int offset) 2454 : Texture2DArraySpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, depth, 1) 2455 , m_internalFormat (internalFormat) 2456 , m_imageHeight (imageHeight) 2457 , m_rowLength (rowLength) 2458 , m_skipImages (skipImages) 2459 , m_skipRows (skipRows) 2460 , m_skipPixels (skipPixels) 2461 , m_alignment (alignment) 2462 , m_offset (offset) 2463 { 2464 } 2465 2466 protected: 2467 void createTexture (void) 2468 { 2469 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat); 2470 int pixelSize = m_texFormat.getPixelSize(); 2471 int rowLength = m_rowLength > 0 ? m_rowLength : m_width; 2472 int rowPitch = deAlign32(rowLength*pixelSize, m_alignment); 2473 int imageHeight = m_imageHeight > 0 ? m_imageHeight : m_height; 2474 int slicePitch = imageHeight*rowPitch; 2475 deUint32 tex = 0; 2476 deUint32 buf = 0; 2477 vector<deUint8> data; 2478 2479 DE_ASSERT(m_numLevels == 1); 2480 2481 // Fill data with grid. 2482 data.resize(slicePitch*(m_numLayers+m_skipImages) + m_offset); 2483 { 2484 Vec4 cScale = m_texFormatInfo.valueMax-m_texFormatInfo.valueMin; 2485 Vec4 cBias = m_texFormatInfo.valueMin; 2486 Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*cScale + cBias; 2487 Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*cScale + cBias; 2488 2489 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); 2490 } 2491 2492 glGenBuffers(1, &buf); 2493 glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buf); 2494 glBufferData(GL_PIXEL_UNPACK_BUFFER, (int)data.size(), &data[0], GL_STATIC_DRAW); 2495 2496 glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, m_imageHeight); 2497 glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength); 2498 glPixelStorei(GL_UNPACK_SKIP_IMAGES, m_skipImages); 2499 glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows); 2500 glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels); 2501 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment); 2502 2503 glGenTextures(1, &tex); 2504 glBindTexture(GL_TEXTURE_2D_ARRAY, tex); 2505 glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, m_internalFormat, m_width, m_height, m_numLayers, 0, transferFmt.format, transferFmt.dataType, (const void*)(deUintptr)m_offset); 2506 } 2507 2508 deUint32 m_internalFormat; 2509 int m_imageHeight; 2510 int m_rowLength; 2511 int m_skipImages; 2512 int m_skipRows; 2513 int m_skipPixels; 2514 int m_alignment; 2515 int m_offset; 2516 }; 2517 2518 // TexImage3D() from pixel buffer object. 2519 class TexImage3DBufferCase : public Texture3DSpecCase 2520 { 2521 public: 2522 TexImage3DBufferCase (Context& context, 2523 const char* name, 2524 const char* desc, 2525 deUint32 internalFormat, 2526 int width, 2527 int height, 2528 int depth, 2529 int imageHeight, 2530 int rowLength, 2531 int skipImages, 2532 int skipRows, 2533 int skipPixels, 2534 int alignment, 2535 int offset) 2536 : Texture3DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, depth, 1) 2537 , m_internalFormat (internalFormat) 2538 , m_imageHeight (imageHeight) 2539 , m_rowLength (rowLength) 2540 , m_skipImages (skipImages) 2541 , m_skipRows (skipRows) 2542 , m_skipPixels (skipPixels) 2543 , m_alignment (alignment) 2544 , m_offset (offset) 2545 { 2546 } 2547 2548 protected: 2549 void createTexture (void) 2550 { 2551 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat); 2552 int pixelSize = m_texFormat.getPixelSize(); 2553 int rowLength = m_rowLength > 0 ? m_rowLength : m_width; 2554 int rowPitch = deAlign32(rowLength*pixelSize, m_alignment); 2555 int imageHeight = m_imageHeight > 0 ? m_imageHeight : m_height; 2556 int slicePitch = imageHeight*rowPitch; 2557 deUint32 tex = 0; 2558 deUint32 buf = 0; 2559 vector<deUint8> data; 2560 2561 DE_ASSERT(m_numLevels == 1); 2562 2563 // Fill data with grid. 2564 data.resize(slicePitch*(m_depth+m_skipImages) + m_offset); 2565 { 2566 Vec4 cScale = m_texFormatInfo.valueMax-m_texFormatInfo.valueMin; 2567 Vec4 cBias = m_texFormatInfo.valueMin; 2568 Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*cScale + cBias; 2569 Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*cScale + cBias; 2570 2571 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); 2572 } 2573 2574 glGenBuffers(1, &buf); 2575 glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buf); 2576 glBufferData(GL_PIXEL_UNPACK_BUFFER, (int)data.size(), &data[0], GL_STATIC_DRAW); 2577 2578 glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, m_imageHeight); 2579 glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength); 2580 glPixelStorei(GL_UNPACK_SKIP_IMAGES, m_skipImages); 2581 glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows); 2582 glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels); 2583 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment); 2584 2585 glGenTextures(1, &tex); 2586 glBindTexture(GL_TEXTURE_3D, tex); 2587 glTexImage3D(GL_TEXTURE_3D, 0, m_internalFormat, m_width, m_height, m_depth, 0, transferFmt.format, transferFmt.dataType, (const void*)(deUintptr)m_offset); 2588 } 2589 2590 deUint32 m_internalFormat; 2591 int m_imageHeight; 2592 int m_rowLength; 2593 int m_skipImages; 2594 int m_skipRows; 2595 int m_skipPixels; 2596 int m_alignment; 2597 int m_offset; 2598 }; 2599 2600 // TexSubImage2D() PBO case. 2601 class TexSubImage2DBufferCase : public Texture2DSpecCase 2602 { 2603 public: 2604 TexSubImage2DBufferCase (Context& context, 2605 const char* name, 2606 const char* desc, 2607 deUint32 internalFormat, 2608 int width, 2609 int height, 2610 int subX, 2611 int subY, 2612 int subW, 2613 int subH, 2614 int rowLength, 2615 int skipRows, 2616 int skipPixels, 2617 int alignment, 2618 int offset) 2619 : Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, 1) 2620 , m_internalFormat (internalFormat) 2621 , m_subX (subX) 2622 , m_subY (subY) 2623 , m_subW (subW) 2624 , m_subH (subH) 2625 , m_rowLength (rowLength) 2626 , m_skipRows (skipRows) 2627 , m_skipPixels (skipPixels) 2628 , m_alignment (alignment) 2629 , m_offset (offset) 2630 { 2631 } 2632 2633 protected: 2634 void createTexture (void) 2635 { 2636 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat); 2637 int pixelSize = m_texFormat.getPixelSize(); 2638 deUint32 tex = 0; 2639 deUint32 buf = 0; 2640 vector<deUint8> data; 2641 2642 DE_ASSERT(m_numLevels == 1); 2643 2644 glGenTextures(1, &tex); 2645 glBindTexture(GL_TEXTURE_2D, tex); 2646 2647 // First fill texture with gradient. 2648 data.resize(deAlign32(m_width*pixelSize, 4)*m_height); 2649 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); 2650 glTexImage2D(GL_TEXTURE_2D, 0, m_internalFormat, m_width, m_height, 0, transferFmt.format, transferFmt.dataType, &data[0]); 2651 2652 // Fill data with grid. 2653 { 2654 int rowLength = m_rowLength > 0 ? m_rowLength : m_subW; 2655 int rowPitch = deAlign32(rowLength*pixelSize, m_alignment); 2656 int height = m_subH + m_skipRows; 2657 Vec4 cScale = m_texFormatInfo.valueMax-m_texFormatInfo.valueMin; 2658 Vec4 cBias = m_texFormatInfo.valueMin; 2659 Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*cScale + cBias; 2660 Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*cScale + cBias; 2661 2662 data.resize(rowPitch*height + m_offset); 2663 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); 2664 } 2665 2666 glGenBuffers(1, &buf); 2667 glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buf); 2668 glBufferData(GL_PIXEL_UNPACK_BUFFER, (int)data.size(), &data[0], GL_STATIC_DRAW); 2669 2670 glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength); 2671 glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows); 2672 glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels); 2673 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment); 2674 glTexSubImage2D(GL_TEXTURE_2D, 0, m_subX, m_subY, m_subW, m_subH, transferFmt.format, transferFmt.dataType, (const void*)(deUintptr)m_offset); 2675 } 2676 2677 deUint32 m_internalFormat; 2678 int m_subX; 2679 int m_subY; 2680 int m_subW; 2681 int m_subH; 2682 int m_rowLength; 2683 int m_skipRows; 2684 int m_skipPixels; 2685 int m_alignment; 2686 int m_offset; 2687 }; 2688 2689 // TexSubImage2D() cubemap PBO case. 2690 class TexSubImageCubeBufferCase : public TextureCubeSpecCase 2691 { 2692 public: 2693 TexSubImageCubeBufferCase (Context& context, 2694 const char* name, 2695 const char* desc, 2696 deUint32 internalFormat, 2697 int size, 2698 int subX, 2699 int subY, 2700 int subW, 2701 int subH, 2702 int rowLength, 2703 int skipRows, 2704 int skipPixels, 2705 int alignment, 2706 int offset) 2707 : TextureCubeSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), size, 1) 2708 , m_internalFormat (internalFormat) 2709 , m_subX (subX) 2710 , m_subY (subY) 2711 , m_subW (subW) 2712 , m_subH (subH) 2713 , m_rowLength (rowLength) 2714 , m_skipRows (skipRows) 2715 , m_skipPixels (skipPixels) 2716 , m_alignment (alignment) 2717 , m_offset (offset) 2718 { 2719 } 2720 2721 protected: 2722 void createTexture (void) 2723 { 2724 de::Random rnd (deStringHash(getName())); 2725 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat); 2726 int pixelSize = m_texFormat.getPixelSize(); 2727 deUint32 tex = 0; 2728 deUint32 buf = 0; 2729 vector<deUint8> data; 2730 2731 DE_ASSERT(m_numLevels == 1); 2732 2733 glGenTextures(1, &tex); 2734 glBindTexture(GL_TEXTURE_CUBE_MAP, tex); 2735 2736 // Fill faces with different gradients. 2737 2738 data.resize(deAlign32(m_size*pixelSize, 4)*m_size); 2739 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 2740 2741 for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++) 2742 { 2743 const Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 2744 const Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 2745 2746 tcu::fillWithComponentGradients(tcu::PixelBufferAccess(m_texFormat, m_size, m_size, 1, deAlign32(m_size*pixelSize, 4), 0, &data[0]), gMin, gMax); 2747 2748 glTexImage2D(s_cubeMapFaces[face], 0, m_internalFormat, m_size, m_size, 0, transferFmt.format, transferFmt.dataType, &data[0]); 2749 } 2750 2751 // Fill data with grid. 2752 { 2753 int rowLength = m_rowLength > 0 ? m_rowLength : m_subW; 2754 int rowPitch = deAlign32(rowLength*pixelSize, m_alignment); 2755 int height = m_subH + m_skipRows; 2756 Vec4 cScale = m_texFormatInfo.valueMax-m_texFormatInfo.valueMin; 2757 Vec4 cBias = m_texFormatInfo.valueMin; 2758 Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*cScale + cBias; 2759 Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*cScale + cBias; 2760 2761 data.resize(rowPitch*height + m_offset); 2762 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); 2763 } 2764 2765 glGenBuffers(1, &buf); 2766 glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buf); 2767 glBufferData(GL_PIXEL_UNPACK_BUFFER, (int)data.size(), &data[0], GL_STATIC_DRAW); 2768 2769 glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength); 2770 glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows); 2771 glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels); 2772 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment); 2773 2774 for (int face = 0; face < tcu::CUBEFACE_LAST; face++) 2775 glTexSubImage2D(s_cubeMapFaces[face], 0, m_subX, m_subY, m_subW, m_subH, transferFmt.format, transferFmt.dataType, (const void*)(deUintptr)m_offset); 2776 } 2777 2778 deUint32 m_internalFormat; 2779 int m_subX; 2780 int m_subY; 2781 int m_subW; 2782 int m_subH; 2783 int m_rowLength; 2784 int m_skipRows; 2785 int m_skipPixels; 2786 int m_alignment; 2787 int m_offset; 2788 }; 2789 2790 // TexSubImage3D() 2D array PBO case. 2791 class TexSubImage2DArrayBufferCase : public Texture2DArraySpecCase 2792 { 2793 public: 2794 TexSubImage2DArrayBufferCase (Context& context, 2795 const char* name, 2796 const char* desc, 2797 deUint32 internalFormat, 2798 int width, 2799 int height, 2800 int depth, 2801 int subX, 2802 int subY, 2803 int subZ, 2804 int subW, 2805 int subH, 2806 int subD, 2807 int imageHeight, 2808 int rowLength, 2809 int skipImages, 2810 int skipRows, 2811 int skipPixels, 2812 int alignment, 2813 int offset) 2814 : Texture2DArraySpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, depth, 1) 2815 , m_internalFormat (internalFormat) 2816 , m_subX (subX) 2817 , m_subY (subY) 2818 , m_subZ (subZ) 2819 , m_subW (subW) 2820 , m_subH (subH) 2821 , m_subD (subD) 2822 , m_imageHeight (imageHeight) 2823 , m_rowLength (rowLength) 2824 , m_skipImages (skipImages) 2825 , m_skipRows (skipRows) 2826 , m_skipPixels (skipPixels) 2827 , m_alignment (alignment) 2828 , m_offset (offset) 2829 { 2830 } 2831 2832 protected: 2833 void createTexture (void) 2834 { 2835 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat); 2836 int pixelSize = m_texFormat.getPixelSize(); 2837 deUint32 tex = 0; 2838 deUint32 buf = 0; 2839 vector<deUint8> data; 2840 2841 DE_ASSERT(m_numLevels == 1); 2842 2843 glGenTextures(1, &tex); 2844 glBindTexture(GL_TEXTURE_2D_ARRAY, tex); 2845 2846 // Fill with gradient. 2847 { 2848 int rowPitch = deAlign32(pixelSize*m_width, 4); 2849 int slicePitch = rowPitch*m_height; 2850 2851 data.resize(slicePitch*m_numLayers); 2852 tcu::fillWithComponentGradients(tcu::PixelBufferAccess(m_texFormat, m_width, m_height, m_numLayers, rowPitch, slicePitch, &data[0]), m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 2853 } 2854 2855 glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, m_internalFormat, m_width, m_height, m_numLayers, 0, transferFmt.format, transferFmt.dataType, &data[0]); 2856 2857 // Fill data with grid. 2858 { 2859 int rowLength = m_rowLength > 0 ? m_rowLength : m_subW; 2860 int rowPitch = deAlign32(rowLength*pixelSize, m_alignment); 2861 int imageHeight = m_imageHeight > 0 ? m_imageHeight : m_subH; 2862 int slicePitch = imageHeight*rowPitch; 2863 Vec4 cScale = m_texFormatInfo.valueMax-m_texFormatInfo.valueMin; 2864 Vec4 cBias = m_texFormatInfo.valueMin; 2865 Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*cScale + cBias; 2866 Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*cScale + cBias; 2867 2868 data.resize(slicePitch*(m_numLayers+m_skipImages) + m_offset); 2869 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); 2870 } 2871 2872 glGenBuffers(1, &buf); 2873 glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buf); 2874 glBufferData(GL_PIXEL_UNPACK_BUFFER, (int)data.size(), &data[0], GL_STATIC_DRAW); 2875 2876 glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, m_imageHeight); 2877 glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength); 2878 glPixelStorei(GL_UNPACK_SKIP_IMAGES, m_skipImages); 2879 glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows); 2880 glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels); 2881 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment); 2882 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); 2883 } 2884 2885 deUint32 m_internalFormat; 2886 int m_subX; 2887 int m_subY; 2888 int m_subZ; 2889 int m_subW; 2890 int m_subH; 2891 int m_subD; 2892 int m_imageHeight; 2893 int m_rowLength; 2894 int m_skipImages; 2895 int m_skipRows; 2896 int m_skipPixels; 2897 int m_alignment; 2898 int m_offset; 2899 }; 2900 2901 // TexSubImage3D() PBO case. 2902 class TexSubImage3DBufferCase : public Texture3DSpecCase 2903 { 2904 public: 2905 TexSubImage3DBufferCase (Context& context, 2906 const char* name, 2907 const char* desc, 2908 deUint32 internalFormat, 2909 int width, 2910 int height, 2911 int depth, 2912 int subX, 2913 int subY, 2914 int subZ, 2915 int subW, 2916 int subH, 2917 int subD, 2918 int imageHeight, 2919 int rowLength, 2920 int skipImages, 2921 int skipRows, 2922 int skipPixels, 2923 int alignment, 2924 int offset) 2925 : Texture3DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, depth, 1) 2926 , m_internalFormat (internalFormat) 2927 , m_subX (subX) 2928 , m_subY (subY) 2929 , m_subZ (subZ) 2930 , m_subW (subW) 2931 , m_subH (subH) 2932 , m_subD (subD) 2933 , m_imageHeight (imageHeight) 2934 , m_rowLength (rowLength) 2935 , m_skipImages (skipImages) 2936 , m_skipRows (skipRows) 2937 , m_skipPixels (skipPixels) 2938 , m_alignment (alignment) 2939 , m_offset (offset) 2940 { 2941 } 2942 2943 protected: 2944 void createTexture (void) 2945 { 2946 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat); 2947 int pixelSize = m_texFormat.getPixelSize(); 2948 deUint32 tex = 0; 2949 deUint32 buf = 0; 2950 vector<deUint8> data; 2951 2952 DE_ASSERT(m_numLevels == 1); 2953 2954 glGenTextures(1, &tex); 2955 glBindTexture(GL_TEXTURE_3D, tex); 2956 2957 // Fill with gradient. 2958 { 2959 int rowPitch = deAlign32(pixelSize*m_width, 4); 2960 int slicePitch = rowPitch*m_height; 2961 2962 data.resize(slicePitch*m_depth); 2963 tcu::fillWithComponentGradients(tcu::PixelBufferAccess(m_texFormat, m_width, m_height, m_depth, rowPitch, slicePitch, &data[0]), m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 2964 } 2965 2966 glTexImage3D(GL_TEXTURE_3D, 0, m_internalFormat, m_width, m_height, m_depth, 0, transferFmt.format, transferFmt.dataType, &data[0]); 2967 2968 // Fill data with grid. 2969 { 2970 int rowLength = m_rowLength > 0 ? m_rowLength : m_subW; 2971 int rowPitch = deAlign32(rowLength*pixelSize, m_alignment); 2972 int imageHeight = m_imageHeight > 0 ? m_imageHeight : m_subH; 2973 int slicePitch = imageHeight*rowPitch; 2974 Vec4 cScale = m_texFormatInfo.valueMax-m_texFormatInfo.valueMin; 2975 Vec4 cBias = m_texFormatInfo.valueMin; 2976 Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*cScale + cBias; 2977 Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*cScale + cBias; 2978 2979 data.resize(slicePitch*(m_depth+m_skipImages) + m_offset); 2980 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); 2981 } 2982 2983 glGenBuffers(1, &buf); 2984 glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buf); 2985 glBufferData(GL_PIXEL_UNPACK_BUFFER, (int)data.size(), &data[0], GL_STATIC_DRAW); 2986 2987 glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, m_imageHeight); 2988 glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength); 2989 glPixelStorei(GL_UNPACK_SKIP_IMAGES, m_skipImages); 2990 glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows); 2991 glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels); 2992 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment); 2993 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); 2994 } 2995 2996 deUint32 m_internalFormat; 2997 int m_subX; 2998 int m_subY; 2999 int m_subZ; 3000 int m_subW; 3001 int m_subH; 3002 int m_subD; 3003 int m_imageHeight; 3004 int m_rowLength; 3005 int m_skipImages; 3006 int m_skipRows; 3007 int m_skipPixels; 3008 int m_alignment; 3009 int m_offset; 3010 }; 3011 3012 // TexImage2D() depth case. 3013 class TexImage2DDepthCase : public Texture2DSpecCase 3014 { 3015 public: 3016 TexImage2DDepthCase (Context& context, 3017 const char* name, 3018 const char* desc, 3019 deUint32 internalFormat, 3020 int imageWidth, 3021 int imageHeight) 3022 : Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), imageWidth, imageHeight, maxLevelCount(imageWidth, imageHeight)) 3023 , m_internalFormat (internalFormat) 3024 { 3025 // we are interested in the behavior near [-2, 2], map it to visible range [0, 1] 3026 m_texFormatInfo.lookupBias = Vec4(0.25f, 0.0f, 0.0f, 1.0f); 3027 m_texFormatInfo.lookupScale = Vec4(0.5f, 1.0f, 1.0f, 0.0f); 3028 } 3029 3030 void createTexture (void) 3031 { 3032 glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat); 3033 deUint32 tex = 0; 3034 tcu::TextureLevel levelData (glu::mapGLTransferFormat(fmt.format, fmt.dataType)); 3035 3036 glGenTextures(1, &tex); 3037 glBindTexture(GL_TEXTURE_2D, tex); 3038 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 3039 GLU_CHECK(); 3040 3041 for (int ndx = 0; ndx < m_numLevels; ndx++) 3042 { 3043 const int levelW = de::max(1, m_width >> ndx); 3044 const int levelH = de::max(1, m_height >> ndx); 3045 const Vec4 gMin = Vec4(-1.5f, -2.0f, 1.7f, -1.5f); 3046 const Vec4 gMax = Vec4(2.0f, 1.5f, -1.0f, 2.0f); 3047 3048 levelData.setSize(levelW, levelH); 3049 tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax); 3050 3051 glTexImage2D(GL_TEXTURE_2D, ndx, m_internalFormat, levelW, levelH, 0, fmt.format, fmt.dataType, levelData.getAccess().getDataPtr()); 3052 } 3053 } 3054 3055 const deUint32 m_internalFormat; 3056 }; 3057 3058 // TexImage3D() depth case. 3059 class TexImage2DArrayDepthCase : public Texture2DArraySpecCase 3060 { 3061 public: 3062 TexImage2DArrayDepthCase (Context& context, 3063 const char* name, 3064 const char* desc, 3065 deUint32 internalFormat, 3066 int imageWidth, 3067 int imageHeight, 3068 int numLayers) 3069 : Texture2DArraySpecCase(context, name, desc, glu::mapGLInternalFormat(internalFormat), imageWidth, imageHeight, numLayers, maxLevelCount(imageWidth, imageHeight)) 3070 , m_internalFormat (internalFormat) 3071 { 3072 // we are interested in the behavior near [-2, 2], map it to visible range [0, 1] 3073 m_texFormatInfo.lookupBias = Vec4(0.25f, 0.0f, 0.0f, 1.0f); 3074 m_texFormatInfo.lookupScale = Vec4(0.5f, 1.0f, 1.0f, 0.0f); 3075 } 3076 3077 void createTexture (void) 3078 { 3079 glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat); 3080 deUint32 tex = 0; 3081 tcu::TextureLevel levelData (glu::mapGLTransferFormat(fmt.format, fmt.dataType)); 3082 3083 glGenTextures(1, &tex); 3084 glBindTexture(GL_TEXTURE_2D_ARRAY, tex); 3085 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 3086 GLU_CHECK(); 3087 3088 for (int ndx = 0; ndx < m_numLevels; ndx++) 3089 { 3090 const int levelW = de::max(1, m_width >> ndx); 3091 const int levelH = de::max(1, m_height >> ndx); 3092 const Vec4 gMin = Vec4(-1.5f, -2.0f, 1.7f, -1.5f); 3093 const Vec4 gMax = Vec4(2.0f, 1.5f, -1.0f, 2.0f); 3094 3095 levelData.setSize(levelW, levelH, m_numLayers); 3096 tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax); 3097 3098 glTexImage3D(GL_TEXTURE_2D_ARRAY, ndx, m_internalFormat, levelW, levelH, m_numLayers, 0, fmt.format, fmt.dataType, levelData.getAccess().getDataPtr()); 3099 } 3100 } 3101 3102 const deUint32 m_internalFormat; 3103 }; 3104 3105 // TexSubImage2D() depth case. 3106 class TexSubImage2DDepthCase : public Texture2DSpecCase 3107 { 3108 public: 3109 TexSubImage2DDepthCase (Context& context, 3110 const char* name, 3111 const char* desc, 3112 deUint32 internalFormat, 3113 int imageWidth, 3114 int imageHeight) 3115 : Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), imageWidth, imageHeight, maxLevelCount(imageWidth, imageHeight)) 3116 , m_internalFormat (internalFormat) 3117 { 3118 // we are interested in the behavior near [-2, 2], map it to visible range [0, 1] 3119 m_texFormatInfo.lookupBias = Vec4(0.25f, 0.0f, 0.0f, 1.0f); 3120 m_texFormatInfo.lookupScale = Vec4(0.5f, 1.0f, 1.0f, 0.0f); 3121 } 3122 3123 void createTexture (void) 3124 { 3125 glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat); 3126 de::Random rnd (deStringHash(getName())); 3127 deUint32 tex = 0; 3128 tcu::TextureLevel levelData (glu::mapGLTransferFormat(fmt.format, fmt.dataType)); 3129 3130 glGenTextures(1, &tex); 3131 glBindTexture(GL_TEXTURE_2D, tex); 3132 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 3133 GLU_CHECK(); 3134 3135 // First specify full texture. 3136 for (int ndx = 0; ndx < m_numLevels; ndx++) 3137 { 3138 const int levelW = de::max(1, m_width >> ndx); 3139 const int levelH = de::max(1, m_height >> ndx); 3140 const Vec4 gMin = Vec4(-1.5f, -2.0f, 1.7f, -1.5f); 3141 const Vec4 gMax = Vec4(2.0f, 1.5f, -1.0f, 2.0f); 3142 3143 levelData.setSize(levelW, levelH); 3144 tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax); 3145 3146 glTexImage2D(GL_TEXTURE_2D, ndx, m_internalFormat, levelW, levelH, 0, fmt.format, fmt.dataType, levelData.getAccess().getDataPtr()); 3147 } 3148 3149 // Re-specify parts of each level. 3150 for (int ndx = 0; ndx < m_numLevels; ndx++) 3151 { 3152 const int levelW = de::max(1, m_width >> ndx); 3153 const int levelH = de::max(1, m_height >> ndx); 3154 3155 const int w = rnd.getInt(1, levelW); 3156 const int h = rnd.getInt(1, levelH); 3157 const int x = rnd.getInt(0, levelW-w); 3158 const int y = rnd.getInt(0, levelH-h); 3159 3160 const Vec4 colorA = Vec4(2.0f, 1.5f, -1.0f, 2.0f); 3161 const Vec4 colorB = Vec4(-1.5f, -2.0f, 1.7f, -1.5f); 3162 const int cellSize = rnd.getInt(2, 16); 3163 3164 levelData.setSize(w, h); 3165 tcu::fillWithGrid(levelData.getAccess(), cellSize, colorA, colorB); 3166 3167 glTexSubImage2D(GL_TEXTURE_2D, ndx, x, y, w, h, fmt.format, fmt.dataType, levelData.getAccess().getDataPtr()); 3168 } 3169 } 3170 3171 const deUint32 m_internalFormat; 3172 }; 3173 3174 // TexSubImage3D() depth case. 3175 class TexSubImage2DArrayDepthCase : public Texture2DArraySpecCase 3176 { 3177 public: 3178 TexSubImage2DArrayDepthCase (Context& context, 3179 const char* name, 3180 const char* desc, 3181 deUint32 internalFormat, 3182 int imageWidth, 3183 int imageHeight, 3184 int numLayers) 3185 : Texture2DArraySpecCase(context, name, desc, glu::mapGLInternalFormat(internalFormat), imageWidth, imageHeight, numLayers, maxLevelCount(imageWidth, imageHeight)) 3186 , m_internalFormat (internalFormat) 3187 { 3188 // we are interested in the behavior near [-2, 2], map it to visible range [0, 1] 3189 m_texFormatInfo.lookupBias = Vec4(0.25f, 0.0f, 0.0f, 1.0f); 3190 m_texFormatInfo.lookupScale = Vec4(0.5f, 1.0f, 1.0f, 0.0f); 3191 } 3192 3193 void createTexture (void) 3194 { 3195 glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat); 3196 de::Random rnd (deStringHash(getName())); 3197 deUint32 tex = 0; 3198 tcu::TextureLevel levelData (glu::mapGLTransferFormat(fmt.format, fmt.dataType)); 3199 3200 glGenTextures(1, &tex); 3201 glBindTexture(GL_TEXTURE_2D_ARRAY, tex); 3202 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 3203 GLU_CHECK(); 3204 3205 // First specify full texture. 3206 for (int ndx = 0; ndx < m_numLevels; ndx++) 3207 { 3208 const int levelW = de::max(1, m_width >> ndx); 3209 const int levelH = de::max(1, m_height >> ndx); 3210 const Vec4 gMin = Vec4(-1.5f, -2.0f, 1.7f, -1.5f); 3211 const Vec4 gMax = Vec4(2.0f, 1.5f, -1.0f, 2.0f); 3212 3213 levelData.setSize(levelW, levelH, m_numLayers); 3214 tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax); 3215 3216 glTexImage3D(GL_TEXTURE_2D_ARRAY, ndx, m_internalFormat, levelW, levelH, m_numLayers, 0, fmt.format, fmt.dataType, levelData.getAccess().getDataPtr()); 3217 } 3218 3219 // Re-specify parts of each level. 3220 for (int ndx = 0; ndx < m_numLevels; ndx++) 3221 { 3222 const int levelW = de::max(1, m_width >> ndx); 3223 const int levelH = de::max(1, m_height >> ndx); 3224 3225 const int w = rnd.getInt(1, levelW); 3226 const int h = rnd.getInt(1, levelH); 3227 const int d = rnd.getInt(1, m_numLayers); 3228 const int x = rnd.getInt(0, levelW-w); 3229 const int y = rnd.getInt(0, levelH-h); 3230 const int z = rnd.getInt(0, m_numLayers-d); 3231 3232 const Vec4 colorA = Vec4(2.0f, 1.5f, -1.0f, 2.0f); 3233 const Vec4 colorB = Vec4(-1.5f, -2.0f, 1.7f, -1.5f); 3234 const int cellSize = rnd.getInt(2, 16); 3235 3236 levelData.setSize(w, h, d); 3237 tcu::fillWithGrid(levelData.getAccess(), cellSize, colorA, colorB); 3238 3239 glTexSubImage3D(GL_TEXTURE_2D_ARRAY, ndx, x, y, z, w, h, d, fmt.format, fmt.dataType, levelData.getAccess().getDataPtr()); 3240 } 3241 } 3242 3243 const deUint32 m_internalFormat; 3244 }; 3245 3246 // TexImage2D() depth case with pbo. 3247 class TexImage2DDepthBufferCase : public Texture2DSpecCase 3248 { 3249 public: 3250 TexImage2DDepthBufferCase (Context& context, 3251 const char* name, 3252 const char* desc, 3253 deUint32 internalFormat, 3254 int imageWidth, 3255 int imageHeight) 3256 : Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), imageWidth, imageHeight, 1) 3257 , m_internalFormat (internalFormat) 3258 { 3259 // we are interested in the behavior near [-2, 2], map it to visible range [0, 1] 3260 m_texFormatInfo.lookupBias = Vec4(0.25f, 0.0f, 0.0f, 1.0f); 3261 m_texFormatInfo.lookupScale = Vec4(0.5f, 1.0f, 1.0f, 0.0f); 3262 } 3263 3264 void createTexture (void) 3265 { 3266 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat); 3267 int pixelSize = m_texFormat.getPixelSize(); 3268 int rowLength = m_width; 3269 int alignment = 4; 3270 int rowPitch = deAlign32(rowLength*pixelSize, alignment); 3271 int height = m_height; 3272 deUint32 buf = 0; 3273 deUint32 tex = 0; 3274 vector<deUint8> data; 3275 3276 DE_ASSERT(m_numLevels == 1); 3277 3278 // Fill data with gradient 3279 data.resize(rowPitch*height); 3280 { 3281 const Vec4 gMin = Vec4(-1.5f, -2.0f, 1.7f, -1.5f); 3282 const Vec4 gMax = Vec4(2.0f, 1.5f, -1.0f, 2.0f); 3283 3284 tcu::fillWithComponentGradients(tcu::PixelBufferAccess(m_texFormat, m_width, m_height, 1, rowPitch, 0, &data[0]), gMin, gMax); 3285 } 3286 3287 // Create buffer and upload. 3288 glGenBuffers(1, &buf); 3289 glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buf); 3290 glBufferData(GL_PIXEL_UNPACK_BUFFER, (int)data.size(), &data[0], GL_STATIC_DRAW); 3291 3292 glPixelStorei(GL_UNPACK_ROW_LENGTH, rowLength); 3293 glPixelStorei(GL_UNPACK_SKIP_ROWS, 0); 3294 glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0); 3295 glPixelStorei(GL_UNPACK_ALIGNMENT, alignment); 3296 3297 glGenTextures(1, &tex); 3298 glBindTexture(GL_TEXTURE_2D, tex); 3299 glTexImage2D(GL_TEXTURE_2D, 0, m_internalFormat, m_width, m_height, 0, transferFmt.format, transferFmt.dataType, DE_NULL); 3300 glDeleteBuffers(1, &buf); 3301 } 3302 3303 const deUint32 m_internalFormat; 3304 }; 3305 3306 // TexImage3D() depth case with pbo. 3307 class TexImage2DArrayDepthBufferCase : public Texture2DArraySpecCase 3308 { 3309 public: 3310 TexImage2DArrayDepthBufferCase (Context& context, 3311 const char* name, 3312 const char* desc, 3313 deUint32 internalFormat, 3314 int imageWidth, 3315 int imageHeight, 3316 int numLayers) 3317 : Texture2DArraySpecCase(context, name, desc, glu::mapGLInternalFormat(internalFormat), imageWidth, imageHeight, numLayers, 1) 3318 , m_internalFormat (internalFormat) 3319 { 3320 // we are interested in the behavior near [-2, 2], map it to visible range [0, 1] 3321 m_texFormatInfo.lookupBias = Vec4(0.25f, 0.0f, 0.0f, 1.0f); 3322 m_texFormatInfo.lookupScale = Vec4(0.5f, 1.0f, 1.0f, 0.0f); 3323 } 3324 3325 void createTexture (void) 3326 { 3327 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat); 3328 int pixelSize = m_texFormat.getPixelSize(); 3329 int rowLength = m_width; 3330 int alignment = 4; 3331 int rowPitch = deAlign32(rowLength*pixelSize, alignment); 3332 int imageHeight = m_height; 3333 int slicePitch = imageHeight*rowPitch; 3334 deUint32 tex = 0; 3335 deUint32 buf = 0; 3336 vector<deUint8> data; 3337 3338 DE_ASSERT(m_numLevels == 1); 3339 3340 // Fill data with grid. 3341 data.resize(slicePitch*m_numLayers); 3342 { 3343 const Vec4 gMin = Vec4(-1.5f, -2.0f, 1.7f, -1.5f); 3344 const Vec4 gMax = Vec4(2.0f, 1.5f, -1.0f, 2.0f); 3345 3346 tcu::fillWithComponentGradients(tcu::PixelBufferAccess(m_texFormat, m_width, m_height, m_numLayers, rowPitch, slicePitch, &data[0]), gMin, gMax); 3347 } 3348 3349 glGenBuffers(1, &buf); 3350 glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buf); 3351 glBufferData(GL_PIXEL_UNPACK_BUFFER, (int)data.size(), &data[0], GL_STATIC_DRAW); 3352 3353 glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, imageHeight); 3354 glPixelStorei(GL_UNPACK_ROW_LENGTH, rowLength); 3355 glPixelStorei(GL_UNPACK_SKIP_IMAGES, 0); 3356 glPixelStorei(GL_UNPACK_SKIP_ROWS, 0); 3357 glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0); 3358 glPixelStorei(GL_UNPACK_ALIGNMENT, alignment); 3359 3360 glGenTextures(1, &tex); 3361 glBindTexture(GL_TEXTURE_2D_ARRAY, tex); 3362 glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, m_internalFormat, m_width, m_height, m_numLayers, 0, transferFmt.format, transferFmt.dataType, DE_NULL); 3363 glDeleteBuffers(1, &buf); 3364 } 3365 3366 const deUint32 m_internalFormat; 3367 }; 3368 3369 TextureSpecificationTests::TextureSpecificationTests (Context& context) 3370 : TestCaseGroup(context, "specification", "Texture Specification Tests") 3371 { 3372 } 3373 3374 TextureSpecificationTests::~TextureSpecificationTests (void) 3375 { 3376 } 3377 3378 void TextureSpecificationTests::init (void) 3379 { 3380 struct 3381 { 3382 const char* name; 3383 deUint32 format; 3384 deUint32 dataType; 3385 } unsizedFormats[] = 3386 { 3387 { "alpha_unsigned_byte", GL_ALPHA, GL_UNSIGNED_BYTE }, 3388 { "luminance_unsigned_byte", GL_LUMINANCE, GL_UNSIGNED_BYTE }, 3389 { "luminance_alpha_unsigned_byte", GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE }, 3390 { "rgb_unsigned_short_5_6_5", GL_RGB, GL_UNSIGNED_SHORT_5_6_5 }, 3391 { "rgb_unsigned_byte", GL_RGB, GL_UNSIGNED_BYTE }, 3392 { "rgba_unsigned_short_4_4_4_4", GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4 }, 3393 { "rgba_unsigned_short_5_5_5_1", GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1 }, 3394 { "rgba_unsigned_byte", GL_RGBA, GL_UNSIGNED_BYTE } 3395 }; 3396 3397 struct 3398 { 3399 const char* name; 3400 deUint32 internalFormat; 3401 } colorFormats[] = 3402 { 3403 { "rgba32f", GL_RGBA32F, }, 3404 { "rgba32i", GL_RGBA32I, }, 3405 { "rgba32ui", GL_RGBA32UI, }, 3406 { "rgba16f", GL_RGBA16F, }, 3407 { "rgba16i", GL_RGBA16I, }, 3408 { "rgba16ui", GL_RGBA16UI, }, 3409 { "rgba8", GL_RGBA8, }, 3410 { "rgba8i", GL_RGBA8I, }, 3411 { "rgba8ui", GL_RGBA8UI, }, 3412 { "srgb8_alpha8", GL_SRGB8_ALPHA8, }, 3413 { "rgb10_a2", GL_RGB10_A2, }, 3414 { "rgb10_a2ui", GL_RGB10_A2UI, }, 3415 { "rgba4", GL_RGBA4, }, 3416 { "rgb5_a1", GL_RGB5_A1, }, 3417 { "rgba8_snorm", GL_RGBA8_SNORM, }, 3418 { "rgb8", GL_RGB8, }, 3419 { "rgb565", GL_RGB565, }, 3420 { "r11f_g11f_b10f", GL_R11F_G11F_B10F, }, 3421 { "rgb32f", GL_RGB32F, }, 3422 { "rgb32i", GL_RGB32I, }, 3423 { "rgb32ui", GL_RGB32UI, }, 3424 { "rgb16f", GL_RGB16F, }, 3425 { "rgb16i", GL_RGB16I, }, 3426 { "rgb16ui", GL_RGB16UI, }, 3427 { "rgb8_snorm", GL_RGB8_SNORM, }, 3428 { "rgb8i", GL_RGB8I, }, 3429 { "rgb8ui", GL_RGB8UI, }, 3430 { "srgb8", GL_SRGB8, }, 3431 { "rgb9_e5", GL_RGB9_E5, }, 3432 { "rg32f", GL_RG32F, }, 3433 { "rg32i", GL_RG32I, }, 3434 { "rg32ui", GL_RG32UI, }, 3435 { "rg16f", GL_RG16F, }, 3436 { "rg16i", GL_RG16I, }, 3437 { "rg16ui", GL_RG16UI, }, 3438 { "rg8", GL_RG8, }, 3439 { "rg8i", GL_RG8I, }, 3440 { "rg8ui", GL_RG8UI, }, 3441 { "rg8_snorm", GL_RG8_SNORM, }, 3442 { "r32f", GL_R32F, }, 3443 { "r32i", GL_R32I, }, 3444 { "r32ui", GL_R32UI, }, 3445 { "r16f", GL_R16F, }, 3446 { "r16i", GL_R16I, }, 3447 { "r16ui", GL_R16UI, }, 3448 { "r8", GL_R8, }, 3449 { "r8i", GL_R8I, }, 3450 { "r8ui", GL_R8UI, }, 3451 { "r8_snorm", GL_R8_SNORM, } 3452 }; 3453 3454 static const struct 3455 { 3456 const char* name; 3457 deUint32 internalFormat; 3458 } depthStencilFormats[] = 3459 { 3460 // Depth and stencil formats 3461 { "depth_component32f", GL_DEPTH_COMPONENT32F }, 3462 { "depth_component24", GL_DEPTH_COMPONENT24 }, 3463 { "depth_component16", GL_DEPTH_COMPONENT16 }, 3464 { "depth32f_stencil8", GL_DEPTH32F_STENCIL8 }, 3465 { "depth24_stencil8", GL_DEPTH24_STENCIL8 } 3466 }; 3467 3468 // Basic TexImage2D usage. 3469 { 3470 tcu::TestCaseGroup* basicTexImageGroup = new tcu::TestCaseGroup(m_testCtx, "basic_teximage2d", "Basic glTexImage2D() usage"); 3471 addChild(basicTexImageGroup); 3472 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(colorFormats); formatNdx++) 3473 { 3474 const char* fmtName = colorFormats[formatNdx].name; 3475 deUint32 format = colorFormats[formatNdx].internalFormat; 3476 const int tex2DWidth = 64; 3477 const int tex2DHeight = 128; 3478 const int texCubeSize = 64; 3479 3480 basicTexImageGroup->addChild(new BasicTexImage2DCase (m_context, (string(fmtName) + "_2d").c_str(), "", format, tex2DWidth, tex2DHeight)); 3481 basicTexImageGroup->addChild(new BasicTexImageCubeCase (m_context, (string(fmtName) + "_cube").c_str(), "", format, texCubeSize)); 3482 } 3483 } 3484 3485 // Randomized TexImage2D order. 3486 { 3487 tcu::TestCaseGroup* randomTexImageGroup = new tcu::TestCaseGroup(m_testCtx, "random_teximage2d", "Randomized glTexImage2D() usage"); 3488 addChild(randomTexImageGroup); 3489 3490 de::Random rnd(9); 3491 3492 // 2D cases. 3493 for (int ndx = 0; ndx < 10; ndx++) 3494 { 3495 int formatNdx = rnd.getInt(0, DE_LENGTH_OF_ARRAY(colorFormats)-1); 3496 int width = 1 << rnd.getInt(2, 8); 3497 int height = 1 << rnd.getInt(2, 8); 3498 3499 randomTexImageGroup->addChild(new RandomOrderTexImage2DCase(m_context, (string("2d_") + de::toString(ndx)).c_str(), "", colorFormats[formatNdx].internalFormat, width, height)); 3500 } 3501 3502 // Cubemap cases. 3503 for (int ndx = 0; ndx < 10; ndx++) 3504 { 3505 int formatNdx = rnd.getInt(0, DE_LENGTH_OF_ARRAY(colorFormats)-1); 3506 int size = 1 << rnd.getInt(2, 8); 3507 3508 randomTexImageGroup->addChild(new RandomOrderTexImageCubeCase(m_context, (string("cube_") + de::toString(ndx)).c_str(), "", colorFormats[formatNdx].internalFormat, size)); 3509 } 3510 } 3511 3512 // TexImage2D unpack alignment. 3513 { 3514 tcu::TestCaseGroup* alignGroup = new tcu::TestCaseGroup(m_testCtx, "teximage2d_align", "glTexImage2D() unpack alignment tests"); 3515 addChild(alignGroup); 3516 3517 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_r8_4_8", "", GL_R8, 4, 8, 4, 8)); 3518 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_r8_63_1", "", GL_R8, 63, 30, 1, 1)); 3519 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_r8_63_2", "", GL_R8, 63, 30, 1, 2)); 3520 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_r8_63_4", "", GL_R8, 63, 30, 1, 4)); 3521 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_r8_63_8", "", GL_R8, 63, 30, 1, 8)); 3522 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgba4_51_1", "", GL_RGBA4, 51, 30, 1, 1)); 3523 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgba4_51_2", "", GL_RGBA4, 51, 30, 1, 2)); 3524 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgba4_51_4", "", GL_RGBA4, 51, 30, 1, 4)); 3525 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgba4_51_8", "", GL_RGBA4, 51, 30, 1, 8)); 3526 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgb8_39_1", "", GL_RGB8, 39, 43, 1, 1)); 3527 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgb8_39_2", "", GL_RGB8, 39, 43, 1, 2)); 3528 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgb8_39_4", "", GL_RGB8, 39, 43, 1, 4)); 3529 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgb8_39_8", "", GL_RGB8, 39, 43, 1, 8)); 3530 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgba8_47_1", "", GL_RGBA8, 47, 27, 1, 1)); 3531 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgba8_47_2", "", GL_RGBA8, 47, 27, 1, 2)); 3532 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgba8_47_4", "", GL_RGBA8, 47, 27, 1, 4)); 3533 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgba8_47_8", "", GL_RGBA8, 47, 27, 1, 8)); 3534 3535 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_r8_4_8", "", GL_R8, 4, 3, 8)); 3536 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_r8_63_1", "", GL_R8, 63, 1, 1)); 3537 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_r8_63_2", "", GL_R8, 63, 1, 2)); 3538 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_r8_63_4", "", GL_R8, 63, 1, 4)); 3539 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_r8_63_8", "", GL_R8, 63, 1, 8)); 3540 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgba4_51_1", "", GL_RGBA4, 51, 1, 1)); 3541 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgba4_51_2", "", GL_RGBA4, 51, 1, 2)); 3542 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgba4_51_4", "", GL_RGBA4, 51, 1, 4)); 3543 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgba4_51_8", "", GL_RGBA4, 51, 1, 8)); 3544 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgb8_39_1", "", GL_RGB8, 39, 1, 1)); 3545 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgb8_39_2", "", GL_RGB8, 39, 1, 2)); 3546 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgb8_39_4", "", GL_RGB8, 39, 1, 4)); 3547 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgb8_39_8", "", GL_RGB8, 39, 1, 8)); 3548 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgba8_47_1", "", GL_RGBA8, 47, 1, 1)); 3549 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgba8_47_2", "", GL_RGBA8, 47, 1, 2)); 3550 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgba8_47_4", "", GL_RGBA8, 47, 1, 4)); 3551 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgba8_47_8", "", GL_RGBA8, 47, 1, 8)); 3552 } 3553 3554 // glTexImage2D() unpack parameter cases. 3555 { 3556 tcu::TestCaseGroup* paramGroup = new tcu::TestCaseGroup(m_testCtx, "teximage2d_unpack_params", "glTexImage2D() pixel transfer mode cases"); 3557 addChild(paramGroup); 3558 3559 static const struct 3560 { 3561 const char* name; 3562 deUint32 format; 3563 int width; 3564 int height; 3565 int rowLength; 3566 int skipRows; 3567 int skipPixels; 3568 int alignment; 3569 } cases[] = 3570 { 3571 { "rgb8_alignment", GL_RGB8, 31, 30, 0, 0, 0, 2 }, 3572 { "rgb8_row_length", GL_RGB8, 31, 30, 50, 0, 0, 4 }, 3573 { "rgb8_skip_rows", GL_RGB8, 31, 30, 0, 3, 0, 4 }, 3574 { "rgb8_skip_pixels", GL_RGB8, 31, 30, 36, 0, 5, 4 }, 3575 { "r8_complex1", GL_R8, 31, 30, 64, 1, 3, 1 }, 3576 { "r8_complex2", GL_R8, 31, 30, 64, 1, 3, 2 }, 3577 { "r8_complex3", GL_R8, 31, 30, 64, 1, 3, 4 }, 3578 { "r8_complex4", GL_R8, 31, 30, 64, 1, 3, 8 }, 3579 { "rgba8_complex1", GL_RGBA8, 56, 61, 69, 0, 0, 8 }, 3580 { "rgba8_complex2", GL_RGBA8, 56, 61, 69, 0, 7, 8 }, 3581 { "rgba8_complex3", GL_RGBA8, 56, 61, 69, 3, 0, 8 }, 3582 { "rgba8_complex4", GL_RGBA8, 56, 61, 69, 3, 7, 8 }, 3583 { "rgba32f_complex", GL_RGBA32F, 19, 10, 27, 1, 7, 8 } 3584 }; 3585 3586 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(cases); ndx++) 3587 paramGroup->addChild(new TexImage2DParamsCase(m_context, cases[ndx].name, "", 3588 cases[ndx].format, 3589 cases[ndx].width, 3590 cases[ndx].height, 3591 cases[ndx].rowLength, 3592 cases[ndx].skipRows, 3593 cases[ndx].skipPixels, 3594 cases[ndx].alignment)); 3595 } 3596 3597 // glTexImage2D() pbo cases. 3598 { 3599 tcu::TestCaseGroup* pboGroup = new tcu::TestCaseGroup(m_testCtx, "teximage2d_pbo", "glTexImage2D() from PBO"); 3600 addChild(pboGroup); 3601 3602 // Parameter cases 3603 static const struct 3604 { 3605 const char* name; 3606 deUint32 format; 3607 int width; 3608 int height; 3609 int rowLength; 3610 int skipRows; 3611 int skipPixels; 3612 int alignment; 3613 int offset; 3614 } parameterCases[] = 3615 { 3616 { "rgb8_offset", GL_RGB8, 31, 30, 0, 0, 0, 4, 67 }, 3617 { "rgb8_alignment", GL_RGB8, 31, 30, 0, 0, 0, 2, 0 }, 3618 { "rgb8_row_length", GL_RGB8, 31, 30, 50, 0, 0, 4, 0 }, 3619 { "rgb8_skip_rows", GL_RGB8, 31, 30, 0, 3, 0, 4, 0 }, 3620 { "rgb8_skip_pixels", GL_RGB8, 31, 30, 36, 0, 5, 4, 0 } 3621 }; 3622 3623 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(colorFormats); formatNdx++) 3624 { 3625 const string fmtName = colorFormats[formatNdx].name; 3626 const deUint32 format = colorFormats[formatNdx].internalFormat; 3627 const int tex2DWidth = 65; 3628 const int tex2DHeight = 37; 3629 const int texCubeSize = 64; 3630 3631 pboGroup->addChild(new TexImage2DBufferCase (m_context, (fmtName + "_2d").c_str(), "", format, tex2DWidth, tex2DHeight, 0, 0, 0, 4, 0)); 3632 pboGroup->addChild(new TexImageCubeBufferCase (m_context, (fmtName + "_cube").c_str(), "", format, texCubeSize, 0, 0, 0, 4, 0)); 3633 } 3634 3635 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(parameterCases); ndx++) 3636 { 3637 pboGroup->addChild(new TexImage2DBufferCase(m_context, (string(parameterCases[ndx].name) + "_2d").c_str(), "", 3638 parameterCases[ndx].format, 3639 parameterCases[ndx].width, 3640 parameterCases[ndx].height, 3641 parameterCases[ndx].rowLength, 3642 parameterCases[ndx].skipRows, 3643 parameterCases[ndx].skipPixels, 3644 parameterCases[ndx].alignment, 3645 parameterCases[ndx].offset)); 3646 pboGroup->addChild(new TexImageCubeBufferCase(m_context, (string(parameterCases[ndx].name) + "_cube").c_str(), "", 3647 parameterCases[ndx].format, 3648 parameterCases[ndx].width, 3649 parameterCases[ndx].rowLength, 3650 parameterCases[ndx].skipRows, 3651 parameterCases[ndx].skipPixels, 3652 parameterCases[ndx].alignment, 3653 parameterCases[ndx].offset)); 3654 } 3655 } 3656 3657 // glTexImage2D() depth cases. 3658 { 3659 tcu::TestCaseGroup* shadow2dGroup = new tcu::TestCaseGroup(m_testCtx, "teximage2d_depth", "glTexImage2D() with depth or depth/stencil format"); 3660 addChild(shadow2dGroup); 3661 3662 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(depthStencilFormats); ndx++) 3663 { 3664 const int tex2DWidth = 64; 3665 const int tex2DHeight = 128; 3666 3667 shadow2dGroup->addChild(new TexImage2DDepthCase(m_context, depthStencilFormats[ndx].name, "", depthStencilFormats[ndx].internalFormat, tex2DWidth, tex2DHeight)); 3668 } 3669 } 3670 3671 // glTexImage2D() depth cases with pbo. 3672 { 3673 tcu::TestCaseGroup* shadow2dGroup = new tcu::TestCaseGroup(m_testCtx, "teximage2d_depth_pbo", "glTexImage2D() with depth or depth/stencil format with pbo"); 3674 addChild(shadow2dGroup); 3675 3676 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(depthStencilFormats); ndx++) 3677 { 3678 const int tex2DWidth = 64; 3679 const int tex2DHeight = 128; 3680 3681 shadow2dGroup->addChild(new TexImage2DDepthBufferCase(m_context, depthStencilFormats[ndx].name, "", depthStencilFormats[ndx].internalFormat, tex2DWidth, tex2DHeight)); 3682 } 3683 } 3684 3685 // Basic TexSubImage2D usage. 3686 { 3687 tcu::TestCaseGroup* basicTexSubImageGroup = new tcu::TestCaseGroup(m_testCtx, "basic_texsubimage2d", "Basic glTexSubImage2D() usage"); 3688 addChild(basicTexSubImageGroup); 3689 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(colorFormats); formatNdx++) 3690 { 3691 const char* fmtName = colorFormats[formatNdx].name; 3692 deUint32 format = colorFormats[formatNdx].internalFormat; 3693 const int tex2DWidth = 64; 3694 const int tex2DHeight = 128; 3695 const int texCubeSize = 64; 3696 3697 basicTexSubImageGroup->addChild(new BasicTexSubImage2DCase (m_context, (string(fmtName) + "_2d").c_str(), "", format, tex2DWidth, tex2DHeight)); 3698 basicTexSubImageGroup->addChild(new BasicTexSubImageCubeCase (m_context, (string(fmtName) + "_cube").c_str(), "", format, texCubeSize)); 3699 } 3700 } 3701 3702 // TexSubImage2D to empty texture. 3703 { 3704 tcu::TestCaseGroup* texSubImageEmptyTexGroup = new tcu::TestCaseGroup(m_testCtx, "texsubimage2d_empty_tex", "glTexSubImage2D() to texture that has storage but no data"); 3705 addChild(texSubImageEmptyTexGroup); 3706 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(unsizedFormats); formatNdx++) 3707 { 3708 const char* fmtName = unsizedFormats[formatNdx].name; 3709 deUint32 format = unsizedFormats[formatNdx].format; 3710 deUint32 dataType = unsizedFormats[formatNdx].dataType; 3711 const int tex2DWidth = 64; 3712 const int tex2DHeight = 32; 3713 const int texCubeSize = 32; 3714 3715 texSubImageEmptyTexGroup->addChild(new TexSubImage2DEmptyTexCase (m_context, (string(fmtName) + "_2d").c_str(), "", format, dataType, tex2DWidth, tex2DHeight)); 3716 texSubImageEmptyTexGroup->addChild(new TexSubImageCubeEmptyTexCase (m_context, (string(fmtName) + "_cube").c_str(), "", format, dataType, texCubeSize)); 3717 } 3718 } 3719 3720 // TexSubImage2D alignment cases. 3721 { 3722 tcu::TestCaseGroup* alignGroup = new tcu::TestCaseGroup(m_testCtx, "texsubimage2d_align", "glTexSubImage2D() unpack alignment tests"); 3723 addChild(alignGroup); 3724 3725 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_r8_1_1", "", GL_R8, 64, 64, 13, 17, 1, 6, 1)); 3726 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_r8_1_2", "", GL_R8, 64, 64, 13, 17, 1, 6, 2)); 3727 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_r8_1_4", "", GL_R8, 64, 64, 13, 17, 1, 6, 4)); 3728 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_r8_1_8", "", GL_R8, 64, 64, 13, 17, 1, 6, 8)); 3729 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_r8_63_1", "", GL_R8, 64, 64, 1, 9, 63, 30, 1)); 3730 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_r8_63_2", "", GL_R8, 64, 64, 1, 9, 63, 30, 2)); 3731 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_r8_63_4", "", GL_R8, 64, 64, 1, 9, 63, 30, 4)); 3732 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_r8_63_8", "", GL_R8, 64, 64, 1, 9, 63, 30, 8)); 3733 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgba4_51_1", "", GL_RGBA4, 64, 64, 7, 29, 51, 30, 1)); 3734 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgba4_51_2", "", GL_RGBA4, 64, 64, 7, 29, 51, 30, 2)); 3735 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgba4_51_4", "", GL_RGBA4, 64, 64, 7, 29, 51, 30, 4)); 3736 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgba4_51_8", "", GL_RGBA4, 64, 64, 7, 29, 51, 30, 8)); 3737 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgb8_39_1", "", GL_RGB8, 64, 64, 11, 8, 39, 43, 1)); 3738 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgb8_39_2", "", GL_RGB8, 64, 64, 11, 8, 39, 43, 2)); 3739 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgb8_39_4", "", GL_RGB8, 64, 64, 11, 8, 39, 43, 4)); 3740 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgb8_39_8", "", GL_RGB8, 64, 64, 11, 8, 39, 43, 8)); 3741 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgba8_47_1", "", GL_RGBA8, 64, 64, 10, 1, 47, 27, 1)); 3742 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgba8_47_2", "", GL_RGBA8, 64, 64, 10, 1, 47, 27, 2)); 3743 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgba8_47_4", "", GL_RGBA8, 64, 64, 10, 1, 47, 27, 4)); 3744 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgba8_47_8", "", GL_RGBA8, 64, 64, 10, 1, 47, 27, 8)); 3745 3746 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_r8_1_1", "", GL_R8, 64, 13, 17, 1, 6, 1)); 3747 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_r8_1_2", "", GL_R8, 64, 13, 17, 1, 6, 2)); 3748 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_r8_1_4", "", GL_R8, 64, 13, 17, 1, 6, 4)); 3749 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_r8_1_8", "", GL_R8, 64, 13, 17, 1, 6, 8)); 3750 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_r8_63_1", "", GL_R8, 64, 1, 9, 63, 30, 1)); 3751 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_r8_63_2", "", GL_R8, 64, 1, 9, 63, 30, 2)); 3752 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_r8_63_4", "", GL_R8, 64, 1, 9, 63, 30, 4)); 3753 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_r8_63_8", "", GL_R8, 64, 1, 9, 63, 30, 8)); 3754 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgba4_51_1", "", GL_RGBA4, 64, 7, 29, 51, 30, 1)); 3755 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgba4_51_2", "", GL_RGBA4, 64, 7, 29, 51, 30, 2)); 3756 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgba4_51_4", "", GL_RGBA4, 64, 7, 29, 51, 30, 4)); 3757 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgba4_51_8", "", GL_RGBA4, 64, 7, 29, 51, 30, 8)); 3758 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgb8_39_1", "", GL_RGB8, 64, 11, 8, 39, 43, 1)); 3759 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgb8_39_2", "", GL_RGB8, 64, 11, 8, 39, 43, 2)); 3760 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgb8_39_4", "", GL_RGB8, 64, 11, 8, 39, 43, 4)); 3761 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgb8_39_8", "", GL_RGB8, 64, 11, 8, 39, 43, 8)); 3762 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgba8_47_1", "", GL_RGBA8, 64, 10, 1, 47, 27, 1)); 3763 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgba8_47_2", "", GL_RGBA8, 64, 10, 1, 47, 27, 2)); 3764 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgba8_47_4", "", GL_RGBA8, 64, 10, 1, 47, 27, 4)); 3765 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgba8_47_8", "", GL_RGBA8, 64, 10, 1, 47, 27, 8)); 3766 } 3767 3768 // glTexSubImage2D() pixel transfer mode cases. 3769 { 3770 tcu::TestCaseGroup* paramGroup = new tcu::TestCaseGroup(m_testCtx, "texsubimage2d_unpack_params", "glTexSubImage2D() pixel transfer mode cases"); 3771 addChild(paramGroup); 3772 3773 static const struct 3774 { 3775 const char* name; 3776 deUint32 format; 3777 int width; 3778 int height; 3779 int subX; 3780 int subY; 3781 int subW; 3782 int subH; 3783 int rowLength; 3784 int skipRows; 3785 int skipPixels; 3786 int alignment; 3787 } cases[] = 3788 { 3789 { "rgb8_alignment", GL_RGB8, 54, 60, 11, 7, 31, 30, 0, 0, 0, 2 }, 3790 { "rgb8_row_length", GL_RGB8, 54, 60, 11, 7, 31, 30, 50, 0, 0, 4 }, 3791 { "rgb8_skip_rows", GL_RGB8, 54, 60, 11, 7, 31, 30, 0, 3, 0, 4 }, 3792 { "rgb8_skip_pixels", GL_RGB8, 54, 60, 11, 7, 31, 30, 36, 0, 5, 4 }, 3793 { "r8_complex1", GL_R8, 54, 60, 11, 7, 31, 30, 64, 1, 3, 1 }, 3794 { "r8_complex2", GL_R8, 54, 60, 11, 7, 31, 30, 64, 1, 3, 2 }, 3795 { "r8_complex3", GL_R8, 54, 60, 11, 7, 31, 30, 64, 1, 3, 4 }, 3796 { "r8_complex4", GL_R8, 54, 60, 11, 7, 31, 30, 64, 1, 3, 8 }, 3797 { "rgba8_complex1", GL_RGBA8, 92, 84, 13, 19, 56, 61, 69, 0, 0, 8 }, 3798 { "rgba8_complex2", GL_RGBA8, 92, 84, 13, 19, 56, 61, 69, 0, 7, 8 }, 3799 { "rgba8_complex3", GL_RGBA8, 92, 84, 13, 19, 56, 61, 69, 3, 0, 8 }, 3800 { "rgba8_complex4", GL_RGBA8, 92, 84, 13, 19, 56, 61, 69, 3, 7, 8 }, 3801 { "rgba32f_complex", GL_RGBA32F, 92, 84, 13, 19, 56, 61, 69, 3, 7, 8 } 3802 }; 3803 3804 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(cases); ndx++) 3805 paramGroup->addChild(new TexSubImage2DParamsCase(m_context, cases[ndx].name, "", 3806 cases[ndx].format, 3807 cases[ndx].width, 3808 cases[ndx].height, 3809 cases[ndx].subX, 3810 cases[ndx].subY, 3811 cases[ndx].subW, 3812 cases[ndx].subH, 3813 cases[ndx].rowLength, 3814 cases[ndx].skipRows, 3815 cases[ndx].skipPixels, 3816 cases[ndx].alignment)); 3817 } 3818 3819 // glTexSubImage2D() PBO cases. 3820 { 3821 tcu::TestCaseGroup* pboGroup = new tcu::TestCaseGroup(m_testCtx, "texsubimage2d_pbo", "glTexSubImage2D() pixel buffer object tests"); 3822 addChild(pboGroup); 3823 3824 static const struct 3825 { 3826 const char* name; 3827 deUint32 format; 3828 int width; 3829 int height; 3830 int subX; 3831 int subY; 3832 int subW; 3833 int subH; 3834 int rowLength; 3835 int skipRows; 3836 int skipPixels; 3837 int alignment; 3838 int offset; 3839 } paramCases[] = 3840 { 3841 { "rgb8_offset", GL_RGB8, 54, 60, 11, 7, 31, 30, 0, 0, 0, 4, 67 }, 3842 { "rgb8_alignment", GL_RGB8, 54, 60, 11, 7, 31, 30, 0, 0, 0, 2, 0 }, 3843 { "rgb8_row_length", GL_RGB8, 54, 60, 11, 7, 31, 30, 50, 0, 0, 4, 0 }, 3844 { "rgb8_skip_rows", GL_RGB8, 54, 60, 11, 7, 31, 30, 0, 3, 0, 4, 0 }, 3845 { "rgb8_skip_pixels", GL_RGB8, 54, 60, 11, 7, 31, 30, 36, 0, 5, 4, 0 } 3846 }; 3847 3848 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(colorFormats); ndx++) 3849 { 3850 pboGroup->addChild(new TexSubImage2DBufferCase(m_context, (std::string(colorFormats[ndx].name) + "_2d").c_str(), "", 3851 colorFormats[ndx].internalFormat, 3852 54, // Width 3853 60, // Height 3854 11, // Sub X 3855 7, // Sub Y 3856 31, // Sub W 3857 30, // Sub H 3858 0, // Row len 3859 0, // Skip rows 3860 0, // Skip pixels 3861 4, // Alignment 3862 0 /* offset */)); 3863 pboGroup->addChild(new TexSubImageCubeBufferCase(m_context, (std::string(colorFormats[ndx].name) + "_cube").c_str(), "", 3864 colorFormats[ndx].internalFormat, 3865 64, // Size 3866 11, // Sub X 3867 7, // Sub Y 3868 31, // Sub W 3869 30, // Sub H 3870 0, // Row len 3871 0, // Skip rows 3872 0, // Skip pixels 3873 4, // Alignment 3874 0 /* offset */)); 3875 } 3876 3877 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(paramCases); ndx++) 3878 { 3879 pboGroup->addChild(new TexSubImage2DBufferCase(m_context, (std::string(paramCases[ndx].name) + "_2d").c_str(), "", 3880 paramCases[ndx].format, 3881 paramCases[ndx].width, 3882 paramCases[ndx].height, 3883 paramCases[ndx].subX, 3884 paramCases[ndx].subY, 3885 paramCases[ndx].subW, 3886 paramCases[ndx].subH, 3887 paramCases[ndx].rowLength, 3888 paramCases[ndx].skipRows, 3889 paramCases[ndx].skipPixels, 3890 paramCases[ndx].alignment, 3891 paramCases[ndx].offset)); 3892 pboGroup->addChild(new TexSubImageCubeBufferCase(m_context, (std::string(paramCases[ndx].name) + "_cube").c_str(), "", 3893 paramCases[ndx].format, 3894 paramCases[ndx].width, 3895 paramCases[ndx].subX, 3896 paramCases[ndx].subY, 3897 paramCases[ndx].subW, 3898 paramCases[ndx].subH, 3899 paramCases[ndx].rowLength, 3900 paramCases[ndx].skipRows, 3901 paramCases[ndx].skipPixels, 3902 paramCases[ndx].alignment, 3903 paramCases[ndx].offset)); 3904 } 3905 } 3906 3907 // glTexSubImage2D() depth cases. 3908 { 3909 tcu::TestCaseGroup* shadow2dGroup = new tcu::TestCaseGroup(m_testCtx, "texsubimage2d_depth", "glTexSubImage2D() with depth or depth/stencil format"); 3910 addChild(shadow2dGroup); 3911 3912 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(depthStencilFormats); ndx++) 3913 { 3914 const int tex2DWidth = 64; 3915 const int tex2DHeight = 32; 3916 3917 shadow2dGroup->addChild(new TexSubImage2DDepthCase(m_context, depthStencilFormats[ndx].name, "", depthStencilFormats[ndx].internalFormat, tex2DWidth, tex2DHeight)); 3918 } 3919 } 3920 3921 // Basic glCopyTexImage2D() cases 3922 { 3923 tcu::TestCaseGroup* copyTexImageGroup = new tcu::TestCaseGroup(m_testCtx, "basic_copyteximage2d", "Basic glCopyTexImage2D() usage"); 3924 addChild(copyTexImageGroup); 3925 3926 copyTexImageGroup->addChild(new BasicCopyTexImage2DCase (m_context, "2d_alpha", "", GL_ALPHA, 128, 64)); 3927 copyTexImageGroup->addChild(new BasicCopyTexImage2DCase (m_context, "2d_luminance", "", GL_LUMINANCE, 128, 64)); 3928 copyTexImageGroup->addChild(new BasicCopyTexImage2DCase (m_context, "2d_luminance_alpha", "", GL_LUMINANCE_ALPHA, 128, 64)); 3929 copyTexImageGroup->addChild(new BasicCopyTexImage2DCase (m_context, "2d_rgb", "", GL_RGB, 128, 64)); 3930 copyTexImageGroup->addChild(new BasicCopyTexImage2DCase (m_context, "2d_rgba", "", GL_RGBA, 128, 64)); 3931 3932 copyTexImageGroup->addChild(new BasicCopyTexImageCubeCase (m_context, "cube_alpha", "", GL_ALPHA, 64)); 3933 copyTexImageGroup->addChild(new BasicCopyTexImageCubeCase (m_context, "cube_luminance", "", GL_LUMINANCE, 64)); 3934 copyTexImageGroup->addChild(new BasicCopyTexImageCubeCase (m_context, "cube_luminance_alpha", "", GL_LUMINANCE_ALPHA, 64)); 3935 copyTexImageGroup->addChild(new BasicCopyTexImageCubeCase (m_context, "cube_rgb", "", GL_RGB, 64)); 3936 copyTexImageGroup->addChild(new BasicCopyTexImageCubeCase (m_context, "cube_rgba", "", GL_RGBA, 64)); 3937 } 3938 3939 // Basic glCopyTexSubImage2D() cases 3940 { 3941 tcu::TestCaseGroup* copyTexSubImageGroup = new tcu::TestCaseGroup(m_testCtx, "basic_copytexsubimage2d", "Basic glCopyTexSubImage2D() usage"); 3942 addChild(copyTexSubImageGroup); 3943 3944 copyTexSubImageGroup->addChild(new BasicCopyTexSubImage2DCase (m_context, "2d_alpha", "", GL_ALPHA, GL_UNSIGNED_BYTE, 128, 64)); 3945 copyTexSubImageGroup->addChild(new BasicCopyTexSubImage2DCase (m_context, "2d_luminance", "", GL_LUMINANCE, GL_UNSIGNED_BYTE, 128, 64)); 3946 copyTexSubImageGroup->addChild(new BasicCopyTexSubImage2DCase (m_context, "2d_luminance_alpha", "", GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, 128, 64)); 3947 copyTexSubImageGroup->addChild(new BasicCopyTexSubImage2DCase (m_context, "2d_rgb", "", GL_RGB, GL_UNSIGNED_BYTE, 128, 64)); 3948 copyTexSubImageGroup->addChild(new BasicCopyTexSubImage2DCase (m_context, "2d_rgba", "", GL_RGBA, GL_UNSIGNED_BYTE, 128, 64)); 3949 3950 copyTexSubImageGroup->addChild(new BasicCopyTexSubImageCubeCase (m_context, "cube_alpha", "", GL_ALPHA, GL_UNSIGNED_BYTE, 64)); 3951 copyTexSubImageGroup->addChild(new BasicCopyTexSubImageCubeCase (m_context, "cube_luminance", "", GL_LUMINANCE, GL_UNSIGNED_BYTE, 64)); 3952 copyTexSubImageGroup->addChild(new BasicCopyTexSubImageCubeCase (m_context, "cube_luminance_alpha", "", GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, 64)); 3953 copyTexSubImageGroup->addChild(new BasicCopyTexSubImageCubeCase (m_context, "cube_rgb", "", GL_RGB, GL_UNSIGNED_BYTE, 64)); 3954 copyTexSubImageGroup->addChild(new BasicCopyTexSubImageCubeCase (m_context, "cube_rgba", "", GL_RGBA, GL_UNSIGNED_BYTE, 64)); 3955 } 3956 3957 // Basic TexImage3D usage. 3958 { 3959 tcu::TestCaseGroup* basicTexImageGroup = new tcu::TestCaseGroup(m_testCtx, "basic_teximage3d", "Basic glTexImage3D() usage"); 3960 addChild(basicTexImageGroup); 3961 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(colorFormats); formatNdx++) 3962 { 3963 const char* fmtName = colorFormats[formatNdx].name; 3964 deUint32 format = colorFormats[formatNdx].internalFormat; 3965 const int tex2DArrayWidth = 57; 3966 const int tex2DArrayHeight = 44; 3967 const int tex2DArrayLevels = 5; 3968 const int tex3DWidth = 63; 3969 const int tex3DHeight = 29; 3970 const int tex3DDepth = 11; 3971 3972 basicTexImageGroup->addChild(new BasicTexImage2DArrayCase (m_context, (string(fmtName) + "_2d_array").c_str(), "", format, tex2DArrayWidth, tex2DArrayHeight, tex2DArrayLevels)); 3973 basicTexImageGroup->addChild(new BasicTexImage3DCase (m_context, (string(fmtName) + "_3d").c_str(), "", format, tex3DWidth, tex3DHeight, tex3DDepth)); 3974 } 3975 } 3976 3977 // glTexImage3D() unpack params cases. 3978 { 3979 tcu::TestCaseGroup* paramGroup = new tcu::TestCaseGroup(m_testCtx, "teximage3d_unpack_params", "glTexImage3D() unpack parameters"); 3980 addChild(paramGroup); 3981 3982 static const struct 3983 { 3984 const char* name; 3985 deUint32 format; 3986 int width; 3987 int height; 3988 int depth; 3989 int imageHeight; 3990 int rowLength; 3991 int skipImages; 3992 int skipRows; 3993 int skipPixels; 3994 int alignment; 3995 } cases[] = 3996 { 3997 { "rgb8_image_height", GL_RGB8, 23, 19, 8, 26, 0, 0, 0, 0, 4 }, 3998 { "rgb8_row_length", GL_RGB8, 23, 19, 8, 0, 27, 0, 0, 0, 4 }, 3999 { "rgb8_skip_images", GL_RGB8, 23, 19, 8, 0, 0, 3, 0, 0, 4 }, 4000 { "rgb8_skip_rows", GL_RGB8, 23, 19, 8, 22, 0, 0, 3, 0, 4 }, 4001 { "rgb8_skip_pixels", GL_RGB8, 23, 19, 8, 0, 25, 0, 0, 2, 4 }, 4002 { "r8_complex1", GL_R8, 13, 17, 11, 23, 15, 2, 3, 1, 1 }, 4003 { "r8_complex2", GL_R8, 13, 17, 11, 23, 15, 2, 3, 1, 2 }, 4004 { "r8_complex3", GL_R8, 13, 17, 11, 23, 15, 2, 3, 1, 4 }, 4005 { "r8_complex4", GL_R8, 13, 17, 11, 23, 15, 2, 3, 1, 8 }, 4006 { "rgba8_complex1", GL_RGBA8, 11, 20, 8, 25, 14, 0, 0, 0, 8 }, 4007 { "rgba8_complex2", GL_RGBA8, 11, 20, 8, 25, 14, 0, 2, 0, 8 }, 4008 { "rgba8_complex3", GL_RGBA8, 11, 20, 8, 25, 14, 0, 0, 3, 8 }, 4009 { "rgba8_complex4", GL_RGBA8, 11, 20, 8, 25, 14, 0, 2, 3, 8 }, 4010 { "rgba32f_complex", GL_RGBA32F, 11, 20, 8, 25, 14, 0, 2, 3, 8 } 4011 }; 4012 4013 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(cases); ndx++) 4014 paramGroup->addChild(new TexImage3DParamsCase(m_context, cases[ndx].name, "", 4015 cases[ndx].format, 4016 cases[ndx].width, 4017 cases[ndx].height, 4018 cases[ndx].depth, 4019 cases[ndx].imageHeight, 4020 cases[ndx].rowLength, 4021 cases[ndx].skipImages, 4022 cases[ndx].skipRows, 4023 cases[ndx].skipPixels, 4024 cases[ndx].alignment)); 4025 } 4026 4027 // glTexImage3D() pbo cases. 4028 { 4029 tcu::TestCaseGroup* pboGroup = new tcu::TestCaseGroup(m_testCtx, "teximage3d_pbo", "glTexImage3D() from PBO"); 4030 addChild(pboGroup); 4031 4032 // Parameter cases 4033 static const struct 4034 { 4035 const char* name; 4036 deUint32 format; 4037 int width; 4038 int height; 4039 int depth; 4040 int imageHeight; 4041 int rowLength; 4042 int skipImages; 4043 int skipRows; 4044 int skipPixels; 4045 int alignment; 4046 int offset; 4047 } parameterCases[] = 4048 { 4049 { "rgb8_offset", GL_RGB8, 23, 19, 8, 0, 0, 0, 0, 0, 1, 67 }, 4050 { "rgb8_alignment", GL_RGB8, 23, 19, 8, 0, 0, 0, 0, 0, 2, 0 }, 4051 { "rgb8_image_height", GL_RGB8, 23, 19, 8, 26, 0, 0, 0, 0, 4, 0 }, 4052 { "rgb8_row_length", GL_RGB8, 23, 19, 8, 0, 27, 0, 0, 0, 4, 0 }, 4053 { "rgb8_skip_images", GL_RGB8, 23, 19, 8, 0, 0, 3, 0, 0, 4, 0 }, 4054 { "rgb8_skip_rows", GL_RGB8, 23, 19, 8, 22, 0, 0, 3, 0, 4, 0 }, 4055 { "rgb8_skip_pixels", GL_RGB8, 23, 19, 8, 0, 25, 0, 0, 2, 4, 0 } 4056 }; 4057 4058 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(colorFormats); formatNdx++) 4059 { 4060 const string fmtName = colorFormats[formatNdx].name; 4061 const deUint32 format = colorFormats[formatNdx].internalFormat; 4062 const int tex3DWidth = 11; 4063 const int tex3DHeight = 20; 4064 const int tex3DDepth = 8; 4065 4066 pboGroup->addChild(new TexImage2DArrayBufferCase (m_context, (fmtName + "_2d_array").c_str(), "", format, tex3DWidth, tex3DHeight, tex3DDepth, 0, 0, 0, 0, 0, 4, 0)); 4067 pboGroup->addChild(new TexImage3DBufferCase (m_context, (fmtName + "_3d").c_str(), "", format, tex3DWidth, tex3DHeight, tex3DDepth, 0, 0, 0, 0, 0, 4, 0)); 4068 } 4069 4070 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(parameterCases); ndx++) 4071 { 4072 pboGroup->addChild(new TexImage2DArrayBufferCase(m_context, (string(parameterCases[ndx].name) + "_2d_array").c_str(), "", 4073 parameterCases[ndx].format, 4074 parameterCases[ndx].width, 4075 parameterCases[ndx].depth, 4076 parameterCases[ndx].height, 4077 parameterCases[ndx].imageHeight, 4078 parameterCases[ndx].rowLength, 4079 parameterCases[ndx].skipImages, 4080 parameterCases[ndx].skipRows, 4081 parameterCases[ndx].skipPixels, 4082 parameterCases[ndx].alignment, 4083 parameterCases[ndx].offset)); 4084 pboGroup->addChild(new TexImage3DBufferCase(m_context, (string(parameterCases[ndx].name) + "_3d").c_str(), "", 4085 parameterCases[ndx].format, 4086 parameterCases[ndx].width, 4087 parameterCases[ndx].depth, 4088 parameterCases[ndx].height, 4089 parameterCases[ndx].imageHeight, 4090 parameterCases[ndx].rowLength, 4091 parameterCases[ndx].skipImages, 4092 parameterCases[ndx].skipRows, 4093 parameterCases[ndx].skipPixels, 4094 parameterCases[ndx].alignment, 4095 parameterCases[ndx].offset)); 4096 } 4097 } 4098 4099 // glTexImage3D() depth cases. 4100 { 4101 tcu::TestCaseGroup* shadow3dGroup = new tcu::TestCaseGroup(m_testCtx, "teximage3d_depth", "glTexImage3D() with depth or depth/stencil format"); 4102 addChild(shadow3dGroup); 4103 4104 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(depthStencilFormats); ndx++) 4105 { 4106 const int tex3DWidth = 32; 4107 const int tex3DHeight = 64; 4108 const int tex3DDepth = 8; 4109 4110 shadow3dGroup->addChild(new TexImage2DArrayDepthCase(m_context, (std::string(depthStencilFormats[ndx].name) + "_2d_array").c_str(), "", depthStencilFormats[ndx].internalFormat, tex3DWidth, tex3DHeight, tex3DDepth)); 4111 } 4112 } 4113 4114 // glTexImage3D() depth cases with pbo. 4115 { 4116 tcu::TestCaseGroup* shadow3dGroup = new tcu::TestCaseGroup(m_testCtx, "teximage3d_depth_pbo", "glTexImage3D() with depth or depth/stencil format with pbo"); 4117 addChild(shadow3dGroup); 4118 4119 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(depthStencilFormats); ndx++) 4120 { 4121 const int tex3DWidth = 32; 4122 const int tex3DHeight = 64; 4123 const int tex3DDepth = 8; 4124 4125 shadow3dGroup->addChild(new TexImage2DArrayDepthBufferCase(m_context, (std::string(depthStencilFormats[ndx].name) + "_2d_array").c_str(), "", depthStencilFormats[ndx].internalFormat, tex3DWidth, tex3DHeight, tex3DDepth)); 4126 } 4127 } 4128 4129 // Basic TexSubImage3D usage. 4130 { 4131 tcu::TestCaseGroup* basicTexSubImageGroup = new tcu::TestCaseGroup(m_testCtx, "basic_texsubimage3d", "Basic glTexSubImage3D() usage"); 4132 addChild(basicTexSubImageGroup); 4133 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(colorFormats); formatNdx++) 4134 { 4135 const char* fmtName = colorFormats[formatNdx].name; 4136 deUint32 format = colorFormats[formatNdx].internalFormat; 4137 const int tex3DWidth = 32; 4138 const int tex3DHeight = 64; 4139 const int tex3DDepth = 8; 4140 4141 basicTexSubImageGroup->addChild(new BasicTexSubImage3DCase(m_context, (string(fmtName) + "_3d").c_str(), "", format, tex3DWidth, tex3DHeight, tex3DDepth)); 4142 } 4143 } 4144 4145 // glTexSubImage3D() unpack params cases. 4146 { 4147 tcu::TestCaseGroup* paramGroup = new tcu::TestCaseGroup(m_testCtx, "texsubimage3d_unpack_params", "glTexSubImage3D() unpack parameters"); 4148 addChild(paramGroup); 4149 4150 static const struct 4151 { 4152 const char* name; 4153 deUint32 format; 4154 int width; 4155 int height; 4156 int depth; 4157 int subX; 4158 int subY; 4159 int subZ; 4160 int subW; 4161 int subH; 4162 int subD; 4163 int imageHeight; 4164 int rowLength; 4165 int skipImages; 4166 int skipRows; 4167 int skipPixels; 4168 int alignment; 4169 } cases[] = 4170 { 4171 { "rgb8_image_height", GL_RGB8, 26, 25, 10, 1, 2, 1, 23, 19, 8, 26, 0, 0, 0, 0, 4 }, 4172 { "rgb8_row_length", GL_RGB8, 26, 25, 10, 1, 2, 1, 23, 19, 8, 0, 27, 0, 0, 0, 4 }, 4173 { "rgb8_skip_images", GL_RGB8, 26, 25, 10, 1, 2, 1, 23, 19, 8, 0, 0, 3, 0, 0, 4 }, 4174 { "rgb8_skip_rows", GL_RGB8, 26, 25, 10, 1, 2, 1, 23, 19, 8, 22, 0, 0, 3, 0, 4 }, 4175 { "rgb8_skip_pixels", GL_RGB8, 26, 25, 10, 1, 2, 1, 23, 19, 8, 0, 25, 0, 0, 2, 4 }, 4176 { "r8_complex1", GL_R8, 15, 20, 11, 1, 1, 0, 13, 17, 11, 23, 15, 2, 3, 1, 1 }, 4177 { "r8_complex2", GL_R8, 15, 20, 11, 1, 1, 0, 13, 17, 11, 23, 15, 2, 3, 1, 2 }, 4178 { "r8_complex3", GL_R8, 15, 20, 11, 1, 1, 0, 13, 17, 11, 23, 15, 2, 3, 1, 4 }, 4179 { "r8_complex4", GL_R8, 15, 20, 11, 1, 1, 0, 13, 17, 11, 23, 15, 2, 3, 1, 8 }, 4180 { "rgba8_complex1", GL_RGBA8, 15, 25, 10, 0, 5, 1, 11, 20, 8, 25, 14, 0, 0, 0, 8 }, 4181 { "rgba8_complex2", GL_RGBA8, 15, 25, 10, 0, 5, 1, 11, 20, 8, 25, 14, 0, 2, 0, 8 }, 4182 { "rgba8_complex3", GL_RGBA8, 15, 25, 10, 0, 5, 1, 11, 20, 8, 25, 14, 0, 0, 3, 8 }, 4183 { "rgba8_complex4", GL_RGBA8, 15, 25, 10, 0, 5, 1, 11, 20, 8, 25, 14, 0, 2, 3, 8 }, 4184 { "rgba32f_complex", GL_RGBA32F, 15, 25, 10, 0, 5, 1, 11, 20, 8, 25, 14, 0, 2, 3, 8 } 4185 }; 4186 4187 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(cases); ndx++) 4188 paramGroup->addChild(new TexSubImage3DParamsCase(m_context, cases[ndx].name, "", 4189 cases[ndx].format, 4190 cases[ndx].width, 4191 cases[ndx].height, 4192 cases[ndx].depth, 4193 cases[ndx].subX, 4194 cases[ndx].subY, 4195 cases[ndx].subZ, 4196 cases[ndx].subW, 4197 cases[ndx].subH, 4198 cases[ndx].subD, 4199 cases[ndx].imageHeight, 4200 cases[ndx].rowLength, 4201 cases[ndx].skipImages, 4202 cases[ndx].skipRows, 4203 cases[ndx].skipPixels, 4204 cases[ndx].alignment)); 4205 } 4206 4207 // glTexSubImage3D() PBO cases. 4208 { 4209 tcu::TestCaseGroup* pboGroup = new tcu::TestCaseGroup(m_testCtx, "texsubimage3d_pbo", "glTexSubImage3D() pixel buffer object tests"); 4210 addChild(pboGroup); 4211 4212 static const struct 4213 { 4214 const char* name; 4215 deUint32 format; 4216 int width; 4217 int height; 4218 int depth; 4219 int subX; 4220 int subY; 4221 int subZ; 4222 int subW; 4223 int subH; 4224 int subD; 4225 int imageHeight; 4226 int rowLength; 4227 int skipImages; 4228 int skipRows; 4229 int skipPixels; 4230 int alignment; 4231 int offset; 4232 } paramCases[] = 4233 { 4234 { "rgb8_offset", GL_RGB8, 26, 25, 10, 1, 2, 1, 23, 19, 8, 0, 0, 0, 0, 0, 4, 67 }, 4235 { "rgb8_image_height", GL_RGB8, 26, 25, 10, 1, 2, 1, 23, 19, 8, 26, 0, 0, 0, 0, 4, 0 }, 4236 { "rgb8_row_length", GL_RGB8, 26, 25, 10, 1, 2, 1, 23, 19, 8, 0, 27, 0, 0, 0, 4, 0 }, 4237 { "rgb8_skip_images", GL_RGB8, 26, 25, 10, 1, 2, 1, 23, 19, 8, 0, 0, 3, 0, 0, 4, 0 }, 4238 { "rgb8_skip_rows", GL_RGB8, 26, 25, 10, 1, 2, 1, 23, 19, 8, 22, 0, 0, 3, 0, 4, 0 }, 4239 { "rgb8_skip_pixels", GL_RGB8, 26, 25, 10, 1, 2, 1, 23, 19, 8, 0, 25, 0, 0, 2, 4, 0 } 4240 }; 4241 4242 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(colorFormats); ndx++) 4243 { 4244 pboGroup->addChild(new TexSubImage2DArrayBufferCase(m_context, (std::string(colorFormats[ndx].name) + "_2d_array").c_str(), "", 4245 colorFormats[ndx].internalFormat, 4246 26, // Width 4247 25, // Height 4248 10, // Depth 4249 1, // Sub X 4250 2, // Sub Y 4251 0, // Sub Z 4252 23, // Sub W 4253 19, // Sub H 4254 8, // Sub D 4255 0, // Image height 4256 0, // Row length 4257 0, // Skip images 4258 0, // Skip rows 4259 0, // Skip pixels 4260 4, // Alignment 4261 0 /* offset */)); 4262 pboGroup->addChild(new TexSubImage3DBufferCase(m_context, (std::string(colorFormats[ndx].name) + "_3d").c_str(), "", 4263 colorFormats[ndx].internalFormat, 4264 26, // Width 4265 25, // Height 4266 10, // Depth 4267 1, // Sub X 4268 2, // Sub Y 4269 0, // Sub Z 4270 23, // Sub W 4271 19, // Sub H 4272 8, // Sub D 4273 0, // Image height 4274 0, // Row length 4275 0, // Skip images 4276 0, // Skip rows 4277 0, // Skip pixels 4278 4, // Alignment 4279 0 /* offset */)); 4280 } 4281 4282 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(paramCases); ndx++) 4283 { 4284 pboGroup->addChild(new TexSubImage2DArrayBufferCase(m_context, (std::string(paramCases[ndx].name) + "_2d_array").c_str(), "", 4285 paramCases[ndx].format, 4286 paramCases[ndx].width, 4287 paramCases[ndx].height, 4288 paramCases[ndx].depth, 4289 paramCases[ndx].subX, 4290 paramCases[ndx].subY, 4291 paramCases[ndx].subZ, 4292 paramCases[ndx].subW, 4293 paramCases[ndx].subH, 4294 paramCases[ndx].subD, 4295 paramCases[ndx].imageHeight, 4296 paramCases[ndx].rowLength, 4297 paramCases[ndx].skipImages, 4298 paramCases[ndx].skipRows, 4299 paramCases[ndx].skipPixels, 4300 paramCases[ndx].alignment, 4301 paramCases[ndx].offset)); 4302 pboGroup->addChild(new TexSubImage3DBufferCase(m_context, (std::string(paramCases[ndx].name) + "_3d").c_str(), "", 4303 paramCases[ndx].format, 4304 paramCases[ndx].width, 4305 paramCases[ndx].height, 4306 paramCases[ndx].depth, 4307 paramCases[ndx].subX, 4308 paramCases[ndx].subY, 4309 paramCases[ndx].subZ, 4310 paramCases[ndx].subW, 4311 paramCases[ndx].subH, 4312 paramCases[ndx].subD, 4313 paramCases[ndx].imageHeight, 4314 paramCases[ndx].rowLength, 4315 paramCases[ndx].skipImages, 4316 paramCases[ndx].skipRows, 4317 paramCases[ndx].skipPixels, 4318 paramCases[ndx].alignment, 4319 paramCases[ndx].offset)); 4320 } 4321 } 4322 4323 // glTexSubImage3D() depth cases. 4324 { 4325 tcu::TestCaseGroup* shadow3dGroup = new tcu::TestCaseGroup(m_testCtx, "texsubimage3d_depth", "glTexSubImage3D() with depth or depth/stencil format"); 4326 addChild(shadow3dGroup); 4327 4328 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(depthStencilFormats); ndx++) 4329 { 4330 const int tex2DArrayWidth = 57; 4331 const int tex2DArrayHeight = 44; 4332 const int tex2DArrayLevels = 5; 4333 4334 shadow3dGroup->addChild(new TexSubImage2DArrayDepthCase(m_context, (std::string(depthStencilFormats[ndx].name) + "_2d_array").c_str(), "", depthStencilFormats[ndx].internalFormat, tex2DArrayWidth, tex2DArrayHeight, tex2DArrayLevels)); 4335 } 4336 } 4337 4338 // glTexStorage2D() cases. 4339 { 4340 tcu::TestCaseGroup* texStorageGroup = new tcu::TestCaseGroup(m_testCtx, "texstorage2d", "Basic glTexStorage2D() usage"); 4341 addChild(texStorageGroup); 4342 4343 // All formats. 4344 tcu::TestCaseGroup* formatGroup = new tcu::TestCaseGroup(m_testCtx, "format", "glTexStorage2D() with all formats"); 4345 texStorageGroup->addChild(formatGroup); 4346 4347 // Color formats. 4348 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(colorFormats); formatNdx++) 4349 { 4350 const char* fmtName = colorFormats[formatNdx].name; 4351 deUint32 internalFormat = colorFormats[formatNdx].internalFormat; 4352 const int tex2DWidth = 117; 4353 const int tex2DHeight = 97; 4354 int tex2DLevels = maxLevelCount(tex2DWidth, tex2DHeight); 4355 const int cubeSize = 57; 4356 int cubeLevels = maxLevelCount(cubeSize, cubeSize); 4357 4358 formatGroup->addChild(new BasicTexStorage2DCase (m_context, (string(fmtName) + "_2d").c_str(), "", internalFormat, tex2DWidth, tex2DHeight, tex2DLevels)); 4359 formatGroup->addChild(new BasicTexStorageCubeCase (m_context, (string(fmtName) + "_cube").c_str(), "", internalFormat, cubeSize, cubeLevels)); 4360 } 4361 4362 // Depth / stencil formats. 4363 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(depthStencilFormats); formatNdx++) 4364 { 4365 const char* fmtName = depthStencilFormats[formatNdx].name; 4366 deUint32 internalFormat = depthStencilFormats[formatNdx].internalFormat; 4367 const int tex2DWidth = 117; 4368 const int tex2DHeight = 97; 4369 int tex2DLevels = maxLevelCount(tex2DWidth, tex2DHeight); 4370 const int cubeSize = 57; 4371 int cubeLevels = maxLevelCount(cubeSize, cubeSize); 4372 4373 formatGroup->addChild(new BasicTexStorage2DCase (m_context, (string(fmtName) + "_2d").c_str(), "", internalFormat, tex2DWidth, tex2DHeight, tex2DLevels)); 4374 formatGroup->addChild(new BasicTexStorageCubeCase (m_context, (string(fmtName) + "_cube").c_str(), "", internalFormat, cubeSize, cubeLevels)); 4375 } 4376 4377 // Sizes. 4378 static const struct 4379 { 4380 int width; 4381 int height; 4382 int levels; 4383 } tex2DSizes[] = 4384 { 4385 // W H L 4386 { 1, 1, 1 }, 4387 { 2, 2, 2 }, 4388 { 64, 32, 7 }, 4389 { 32, 64, 4 }, 4390 { 57, 63, 1 }, 4391 { 57, 63, 2 }, 4392 { 57, 63, 6 } 4393 }; 4394 static const struct 4395 { 4396 int size; 4397 int levels; 4398 } cubeSizes[] = 4399 { 4400 // S L 4401 { 1, 1 }, 4402 { 2, 2 }, 4403 { 57, 1 }, 4404 { 57, 2 }, 4405 { 57, 6 }, 4406 { 64, 4 }, 4407 { 64, 7 }, 4408 }; 4409 4410 tcu::TestCaseGroup* sizeGroup = new tcu::TestCaseGroup(m_testCtx, "size", "glTexStorage2D() with various sizes"); 4411 texStorageGroup->addChild(sizeGroup); 4412 4413 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(tex2DSizes); ndx++) 4414 { 4415 const deUint32 format = GL_RGBA8; 4416 int width = tex2DSizes[ndx].width; 4417 int height = tex2DSizes[ndx].height; 4418 int levels = tex2DSizes[ndx].levels; 4419 string name = string("2d_") + de::toString(width) + "x" + de::toString(height) + "_" + de::toString(levels) + "_levels"; 4420 4421 sizeGroup->addChild(new BasicTexStorage2DCase(m_context, name.c_str(), "", format, width, height, levels)); 4422 } 4423 4424 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(cubeSizes); ndx++) 4425 { 4426 const deUint32 format = GL_RGBA8; 4427 int size = cubeSizes[ndx].size; 4428 int levels = cubeSizes[ndx].levels; 4429 string name = string("cube_") + de::toString(size) + "x" + de::toString(size) + "_" + de::toString(levels) + "_levels"; 4430 4431 sizeGroup->addChild(new BasicTexStorageCubeCase(m_context, name.c_str(), "", format, size, levels)); 4432 } 4433 } 4434 4435 // glTexStorage3D() cases. 4436 { 4437 tcu::TestCaseGroup* texStorageGroup = new tcu::TestCaseGroup(m_testCtx, "texstorage3d", "Basic glTexStorage3D() usage"); 4438 addChild(texStorageGroup); 4439 4440 // All formats. 4441 tcu::TestCaseGroup* formatGroup = new tcu::TestCaseGroup(m_testCtx, "format", "glTexStorage3D() with all formats"); 4442 texStorageGroup->addChild(formatGroup); 4443 4444 // Color formats. 4445 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(colorFormats); formatNdx++) 4446 { 4447 const char* fmtName = colorFormats[formatNdx].name; 4448 deUint32 internalFormat = colorFormats[formatNdx].internalFormat; 4449 const int tex2DArrayWidth = 57; 4450 const int tex2DArrayHeight = 13; 4451 const int tex2DArrayLayers = 7; 4452 int tex2DArrayLevels = maxLevelCount(tex2DArrayWidth, tex2DArrayHeight); 4453 const int tex3DWidth = 59; 4454 const int tex3DHeight = 37; 4455 const int tex3DDepth = 11; 4456 int tex3DLevels = maxLevelCount(tex3DWidth, tex3DHeight, tex3DDepth); 4457 4458 formatGroup->addChild(new BasicTexStorage2DArrayCase (m_context, (string(fmtName) + "_2d_array").c_str(), "", internalFormat, tex2DArrayWidth, tex2DArrayHeight, tex2DArrayLayers, tex2DArrayLevels)); 4459 formatGroup->addChild(new BasicTexStorage3DCase (m_context, (string(fmtName) + "_3d").c_str(), "", internalFormat, tex3DWidth, tex3DHeight, tex3DDepth, tex3DLevels)); 4460 } 4461 4462 // Depth/stencil formats (only 2D texture array is supported). 4463 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(depthStencilFormats); formatNdx++) 4464 { 4465 const char* fmtName = depthStencilFormats[formatNdx].name; 4466 deUint32 internalFormat = depthStencilFormats[formatNdx].internalFormat; 4467 const int tex2DArrayWidth = 57; 4468 const int tex2DArrayHeight = 13; 4469 const int tex2DArrayLayers = 7; 4470 int tex2DArrayLevels = maxLevelCount(tex2DArrayWidth, tex2DArrayHeight); 4471 4472 formatGroup->addChild(new BasicTexStorage2DArrayCase (m_context, (string(fmtName) + "_2d_array").c_str(), "", internalFormat, tex2DArrayWidth, tex2DArrayHeight, tex2DArrayLayers, tex2DArrayLevels)); 4473 } 4474 4475 // Sizes. 4476 static const struct 4477 { 4478 int width; 4479 int height; 4480 int layers; 4481 int levels; 4482 } tex2DArraySizes[] = 4483 { 4484 // W H La Le 4485 { 1, 1, 1, 1 }, 4486 { 2, 2, 2, 2 }, 4487 { 64, 32, 3, 7 }, 4488 { 32, 64, 3, 4 }, 4489 { 57, 63, 5, 1 }, 4490 { 57, 63, 5, 2 }, 4491 { 57, 63, 5, 6 } 4492 }; 4493 static const struct 4494 { 4495 int width; 4496 int height; 4497 int depth; 4498 int levels; 4499 } tex3DSizes[] = 4500 { 4501 // W H D L 4502 { 1, 1, 1, 1 }, 4503 { 2, 2, 2, 2 }, 4504 { 64, 32, 16, 7 }, 4505 { 32, 64, 16, 4 }, 4506 { 32, 16, 64, 4 }, 4507 { 57, 63, 11, 1 }, 4508 { 57, 63, 11, 2 }, 4509 { 57, 63, 11, 6 } 4510 }; 4511 4512 tcu::TestCaseGroup* sizeGroup = new tcu::TestCaseGroup(m_testCtx, "size", "glTexStorage2D() with various sizes"); 4513 texStorageGroup->addChild(sizeGroup); 4514 4515 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(tex2DArraySizes); ndx++) 4516 { 4517 const deUint32 format = GL_RGBA8; 4518 int width = tex2DArraySizes[ndx].width; 4519 int height = tex2DArraySizes[ndx].height; 4520 int layers = tex2DArraySizes[ndx].layers; 4521 int levels = tex2DArraySizes[ndx].levels; 4522 string name = string("2d_array_") + de::toString(width) + "x" + de::toString(height) + "x" + de::toString(layers) + "_" + de::toString(levels) + "_levels"; 4523 4524 sizeGroup->addChild(new BasicTexStorage2DArrayCase(m_context, name.c_str(), "", format, width, height, layers, levels)); 4525 } 4526 4527 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(tex3DSizes); ndx++) 4528 { 4529 const deUint32 format = GL_RGBA8; 4530 int width = tex3DSizes[ndx].width; 4531 int height = tex3DSizes[ndx].height; 4532 int depth = tex3DSizes[ndx].depth; 4533 int levels = tex3DSizes[ndx].levels; 4534 string name = string("3d_") + de::toString(width) + "x" + de::toString(height) + "x" + de::toString(depth) + "_" + de::toString(levels) + "_levels"; 4535 4536 sizeGroup->addChild(new BasicTexStorage3DCase(m_context, name.c_str(), "", format, width, height, depth, levels)); 4537 } 4538 } 4539 } 4540 4541 } // Functional 4542 } // gles3 4543 } // deqp 4544