1/*------------------------------------------------------------------------- 2 * drawElements Quality Program OpenGL ES 2.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 completeness tests. 22 *//*--------------------------------------------------------------------*/ 23 24#include "es2fTextureCompletenessTests.hpp" 25#include "glsTextureTestUtil.hpp" 26 27#include "tcuTestLog.hpp" 28#include "tcuSurface.hpp" 29#include "tcuImageCompare.hpp" 30#include "tcuVector.hpp" 31#include "tcuTextureUtil.hpp" 32#include "tcuRenderTarget.hpp" 33 34#include "deRandom.hpp" 35#include "deMath.h" 36#include "deInt32.h" 37#include "deString.h" 38 39#include "gluTextureUtil.hpp" 40#include "gluPixelTransfer.hpp" 41#include "gluContextInfo.hpp" 42#include "gluRenderContext.hpp" 43 44#include "glw.h" 45 46#include <cstdlib> 47 48namespace deqp 49{ 50namespace gles2 51{ 52namespace Functional 53{ 54 55using std::vector; 56using std::string; 57using tcu::TestLog; 58using tcu::TextureFormat; 59using tcu::Sampler; 60using tcu::IVec2; 61using tcu::RGBA; 62using gls::TextureTestUtil::TextureRenderer; 63using gls::TextureTestUtil::computeQuadTexCoord2D; 64using gls::TextureTestUtil::computeQuadTexCoordCube; 65using gls::TextureTestUtil::clear; 66 67static const GLenum s_cubeTargets[] = 68{ 69 GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 70 GL_TEXTURE_CUBE_MAP_POSITIVE_X, 71 GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 72 GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 73 GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 74 GL_TEXTURE_CUBE_MAP_POSITIVE_Z 75}; 76 77static bool isExtensionSupported (const glu::ContextInfo& ctxInfo, const char* extension) 78{ 79 vector<string> extensions = ctxInfo.getExtensions(); 80 81 for (vector<string>::iterator iter = extensions.begin(); iter != extensions.end(); ++iter) 82 if (iter->compare(extension) == 0) 83 return true; 84 85 return false; 86} 87 88static bool compareToConstantColor (TestLog& log, const char* imageSetName, const char* imageSetDesc, const tcu::Surface& result, tcu::CompareLogMode logMode, RGBA color) 89{ 90 bool isOk = true; 91 92 for (int y = 0; y < result.getHeight(); y++) 93 { 94 for (int x = 0; x < result.getWidth(); x++) 95 { 96 if (result.getPixel(x, y).getRed() != color.getRed() || 97 result.getPixel(x, y).getGreen() != color.getGreen() || 98 result.getPixel(x, y).getBlue() != color.getBlue() || 99 result.getPixel(x, y).getAlpha() != color.getAlpha()) 100 { 101 isOk = false; 102 } 103 } 104 } 105 106 if (!isOk || logMode == tcu::COMPARE_LOG_EVERYTHING) 107 { 108 if (!isOk) 109 log << TestLog::Message << "Image comparison failed" << TestLog::EndMessage; 110 111 log << TestLog::ImageSet(imageSetName, imageSetDesc) 112 << TestLog::Image("Result", "Result", result) 113 << TestLog::EndImageSet; 114 } 115 else if (logMode == tcu::COMPARE_LOG_RESULT) 116 log << TestLog::ImageSet(imageSetName, imageSetDesc) 117 << TestLog::Image("Result", "Result", result) 118 << TestLog::EndImageSet; 119 120 return isOk; 121} 122 123// Base classes. 124 125class Tex2DCompletenessCase : public tcu::TestCase 126{ 127public: 128 Tex2DCompletenessCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description); 129 ~Tex2DCompletenessCase (void) {}; 130 131 IterateResult iterate (void); 132 133protected: 134 virtual void createTexture (void) = 0; 135 136 tcu::TestContext& m_testCtx; 137 glu::RenderContext& m_renderCtx; 138 RGBA m_compareColor; 139}; 140 141Tex2DCompletenessCase::Tex2DCompletenessCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description) 142 : TestCase (testCtx, name, description) 143 , m_testCtx (testCtx) 144 , m_renderCtx (renderCtx) 145 , m_compareColor (RGBA(0,0,0,255)) 146{ 147} 148 149Tex2DCompletenessCase::IterateResult Tex2DCompletenessCase::iterate (void) 150{ 151 int viewportWidth = de::min(64, m_renderCtx.getRenderTarget().getWidth()); 152 int viewportHeight = de::min(64, m_renderCtx.getRenderTarget().getHeight()); 153 TestLog& log = m_testCtx.getLog(); 154 TextureRenderer renderer (m_renderCtx, m_testCtx, glu::GLSL_VERSION_100_ES, glu::PRECISION_MEDIUMP); 155 tcu::Surface renderedFrame (viewportWidth, viewportHeight); 156 vector<float> texCoord; 157 158 de::Random random (deStringHash(getName())); 159 int offsetX = random.getInt(0, m_renderCtx.getRenderTarget().getWidth() - viewportWidth ); 160 int offsetY = random.getInt(0, m_renderCtx.getRenderTarget().getHeight() - viewportHeight); 161 162 computeQuadTexCoord2D (texCoord, tcu::Vec2(0.0f, 0.0f), tcu::Vec2(1.0f, 1.0f)); 163 164 glViewport (offsetX, offsetY, viewportWidth, viewportHeight); 165 166 createTexture (); 167 renderer.renderQuad (0, &texCoord[0], gls::TextureTestUtil::TEXTURETYPE_2D); 168 glu::readPixels (m_renderCtx, offsetX, offsetY, renderedFrame.getAccess()); 169 170 bool isOk = compareToConstantColor(log, "Result", "Image comparison result", renderedFrame, tcu::COMPARE_LOG_RESULT, m_compareColor); 171 172 m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL, 173 isOk ? "Pass" : "Image comparison failed"); 174 return STOP; 175} 176 177class TexCubeCompletenessCase : public tcu::TestCase 178{ 179public: 180 TexCubeCompletenessCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description); 181 ~TexCubeCompletenessCase (void) {}; 182 183 IterateResult iterate (void); 184 185protected: 186 virtual void createTexture (void) = 0; 187 188 tcu::TestContext& m_testCtx; 189 glu::RenderContext& m_renderCtx; 190 RGBA m_compareColor; 191}; 192 193TexCubeCompletenessCase::TexCubeCompletenessCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description) 194 : TestCase (testCtx, name, description) 195 , m_testCtx (testCtx) 196 , m_renderCtx (renderCtx) 197 , m_compareColor (RGBA(0,0,0,255)) 198{ 199} 200 201TexCubeCompletenessCase::IterateResult TexCubeCompletenessCase::iterate (void) 202{ 203 int viewportWidth = de::min(64, m_renderCtx.getRenderTarget().getWidth()); 204 int viewportHeight = de::min(64, m_renderCtx.getRenderTarget().getHeight()); 205 bool allFacesOk = true; 206 TestLog& log = m_testCtx.getLog(); 207 TextureRenderer renderer (m_renderCtx, m_testCtx, glu::GLSL_VERSION_100_ES, glu::PRECISION_MEDIUMP); 208 tcu::Surface renderedFrame (viewportWidth, viewportHeight); 209 vector<float> texCoord; 210 211 de::Random random (deStringHash(getName())); 212 int offsetX = random.getInt(0, de::max(0,m_renderCtx.getRenderTarget().getWidth() - 64)); 213 int offsetY = random.getInt(0, de::max(0,m_renderCtx.getRenderTarget().getHeight() - 64)); 214 215 createTexture(); 216 217 for (int face = 0; face < tcu::CUBEFACE_LAST; face++) 218 { 219 computeQuadTexCoordCube (texCoord, (tcu::CubeFace)face); 220 221 glViewport (offsetX, offsetY, viewportWidth, viewportHeight); 222 223 renderer.renderQuad (0, &texCoord[0], gls::TextureTestUtil::TEXTURETYPE_CUBE); 224 glu::readPixels (m_renderCtx, offsetX, offsetY, renderedFrame.getAccess()); 225 226 bool isOk = compareToConstantColor(log, "Result", "Image comparison result", renderedFrame, tcu::COMPARE_LOG_RESULT, m_compareColor); 227 228 if (!isOk) 229 allFacesOk = false; 230 } 231 232 m_testCtx.setTestResult(allFacesOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL, 233 allFacesOk ? "Pass" : "Image comparison failed"); 234 return STOP; 235} 236 237// Texture 2D tests. 238 239class Incomplete2DSizeCase : public Tex2DCompletenessCase 240{ 241public: 242 Incomplete2DSizeCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, IVec2 size, IVec2 invalidLevelSize, int invalidLevelNdx, const glu::ContextInfo& ctxInfo); 243 ~Incomplete2DSizeCase (void) {} 244 245 virtual void createTexture (void); 246 247private: 248 int m_invalidLevelNdx; 249 IVec2 m_invalidLevelSize; 250 const glu::ContextInfo& m_ctxInfo; 251 IVec2 m_size; 252}; 253 254Incomplete2DSizeCase::Incomplete2DSizeCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, IVec2 size, IVec2 invalidLevelSize, int invalidLevelNdx, const glu::ContextInfo& ctxInfo) 255 : Tex2DCompletenessCase (testCtx, renderCtx, name, description) 256 , m_invalidLevelNdx (invalidLevelNdx) 257 , m_invalidLevelSize (invalidLevelSize) 258 , m_ctxInfo (ctxInfo) 259 , m_size (size) 260{ 261} 262 263void Incomplete2DSizeCase::createTexture (void) 264{ 265 tcu::TextureFormat fmt = glu::mapGLTransferFormat(GL_RGBA, GL_UNSIGNED_BYTE); 266 tcu::TextureLevel levelData (fmt); 267 TestLog& log = m_testCtx.getLog(); 268 269 GLuint texture; 270 glGenTextures (1, &texture); 271 glPixelStorei (GL_UNPACK_ALIGNMENT, 1); 272 glBindTexture (GL_TEXTURE_2D, texture); 273 274 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); 275 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); 276 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST); 277 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 278 279 int numLevels = 1 + de::max(deLog2Floor32(m_size.x()), deLog2Floor32(m_size.y())); 280 281 for (int levelNdx = 0; levelNdx < numLevels; levelNdx++) 282 { 283 int levelW = (levelNdx == m_invalidLevelNdx) ? m_invalidLevelSize.x() : de::max(1, m_size.x() >> levelNdx); 284 int levelH = (levelNdx == m_invalidLevelNdx) ? m_invalidLevelSize.y() : de::max(1, m_size.y() >> levelNdx); 285 286 levelData.setSize(m_size.x(), m_size.y()); 287 clear(levelData.getAccess(), tcu::Vec4(0.0f, 0.0f, 1.0f, 1.0f)); 288 289 glTexImage2D(GL_TEXTURE_2D, levelNdx, GL_RGBA, levelW, levelH, 0, GL_RGBA, GL_UNSIGNED_BYTE, levelData.getAccess().getDataPtr()); 290 } 291 292 GLU_CHECK_MSG("Set texturing state"); 293 294 const char* extension = "GL_NV_texture_npot_2D_mipmap"; 295 if (isExtensionSupported(m_ctxInfo, extension) && !deIsPowerOfTwo32(m_size.x()) && !deIsPowerOfTwo32(m_size.y())) 296 { 297 log << TestLog::Message << extension << " supported, assuming completeness test to pass." << TestLog::EndMessage; 298 m_compareColor = RGBA(0,0,255,255); 299 } 300} 301 302class Incomplete2DFormatCase : public Tex2DCompletenessCase 303{ 304public: 305 Incomplete2DFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, IVec2 size, deUint32 format, deUint32 invalidFormat, int invalidLevelNdx); 306 ~Incomplete2DFormatCase (void) {} 307 308 virtual void createTexture (void); 309 310private: 311 int m_invalidLevelNdx; 312 deUint32 m_format; 313 deUint32 m_invalidFormat; 314 IVec2 m_size; 315}; 316 317Incomplete2DFormatCase::Incomplete2DFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, IVec2 size, deUint32 format, deUint32 invalidFormat, int invalidLevelNdx) 318 : Tex2DCompletenessCase (testCtx, renderCtx, name, description) 319 , m_invalidLevelNdx (invalidLevelNdx) 320 , m_format (format) 321 , m_invalidFormat (invalidFormat) 322 , m_size (size) 323{ 324} 325 326void Incomplete2DFormatCase::createTexture (void) 327{ 328 tcu::TextureFormat fmt = glu::mapGLTransferFormat(m_format, GL_UNSIGNED_BYTE); 329 tcu::TextureLevel levelData (fmt); 330 331 GLuint texture; 332 glGenTextures (1, &texture); 333 glPixelStorei (GL_UNPACK_ALIGNMENT, 1); 334 glBindTexture (GL_TEXTURE_2D, texture); 335 336 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); 337 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); 338 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST); 339 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 340 341 int numLevels = 1 + de::max(deLog2Floor32(m_size.x()), deLog2Floor32(m_size.y())); 342 343 for (int levelNdx = 0; levelNdx < numLevels; levelNdx++) 344 { 345 int levelW = de::max(1, m_size.x() >> levelNdx); 346 int levelH = de::max(1, m_size.y() >> levelNdx); 347 348 levelData.setSize(m_size.x(), m_size.y()); 349 clear(levelData.getAccess(), tcu::Vec4(0.0f, 0.0f, 1.0f, 1.0f)); 350 351 deUint32 format = levelNdx == m_invalidLevelNdx ? m_invalidFormat : m_format; 352 353 glTexImage2D(GL_TEXTURE_2D, levelNdx, format, levelW, levelH, 0, format, GL_UNSIGNED_BYTE, levelData.getAccess().getDataPtr()); 354 } 355 356 GLU_CHECK_MSG("Set texturing state"); 357} 358 359class Incomplete2DMissingLevelCase : public Tex2DCompletenessCase 360{ 361public: 362 Incomplete2DMissingLevelCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, IVec2 size, int missingLevelNdx); 363 ~Incomplete2DMissingLevelCase (void) {} 364 365 virtual void createTexture (void); 366 367private: 368 int m_missingLevelNdx; 369 IVec2 m_size; 370}; 371 372Incomplete2DMissingLevelCase::Incomplete2DMissingLevelCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, IVec2 size, int missingLevelNdx) 373 : Tex2DCompletenessCase (testCtx, renderCtx, name, description) 374 , m_missingLevelNdx (missingLevelNdx) 375 , m_size (size) 376{ 377} 378 379void Incomplete2DMissingLevelCase::createTexture (void) 380{ 381 tcu::TextureFormat fmt = glu::mapGLTransferFormat(GL_RGBA, GL_UNSIGNED_BYTE); 382 tcu::TextureLevel levelData (fmt); 383 384 GLuint texture; 385 glGenTextures (1, &texture); 386 glPixelStorei (GL_UNPACK_ALIGNMENT, 1); 387 glBindTexture (GL_TEXTURE_2D, texture); 388 389 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); 390 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); 391 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST); 392 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 393 394 int numLevels = 1 + de::max(deLog2Floor32(m_size.x()), deLog2Floor32(m_size.y())); 395 396 for (int levelNdx = 0; levelNdx < numLevels; levelNdx++) 397 { 398 levelData.setSize(m_size.x(), m_size.y()); 399 clear(levelData.getAccess(), tcu::Vec4(0.0f, 0.0f, 1.0f, 1.0f)); 400 401 int levelW = de::max(1, m_size.x() >> levelNdx); 402 int levelH = de::max(1, m_size.y() >> levelNdx); 403 404 // Skip specified level. 405 if (levelNdx != m_missingLevelNdx) 406 glTexImage2D(GL_TEXTURE_2D, levelNdx, GL_RGBA, levelW, levelH, 0, GL_RGBA, GL_UNSIGNED_BYTE, levelData.getAccess().getDataPtr()); 407 } 408 409 GLU_CHECK_MSG("Set texturing state"); 410} 411 412class Incomplete2DWrapModeCase : public Tex2DCompletenessCase 413{ 414public: 415 Incomplete2DWrapModeCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, IVec2 size, deUint32 wrapT, deUint32 wrapS, const glu::ContextInfo& ctxInfo); 416 ~Incomplete2DWrapModeCase (void) {} 417 418 virtual void createTexture (void); 419 420private: 421 deUint32 m_wrapT; 422 deUint32 m_wrapS; 423 const glu::ContextInfo& m_ctxInfo; 424 IVec2 m_size; 425}; 426 427Incomplete2DWrapModeCase::Incomplete2DWrapModeCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, IVec2 size, deUint32 wrapT, deUint32 wrapS, const glu::ContextInfo& ctxInfo) 428 : Tex2DCompletenessCase (testCtx, renderCtx, name, description) 429 , m_wrapT (wrapT) 430 , m_wrapS (wrapS) 431 , m_ctxInfo (ctxInfo) 432 , m_size (size) 433{ 434} 435 436void Incomplete2DWrapModeCase::createTexture (void) 437{ 438 TestLog& log = m_testCtx.getLog(); 439 tcu::TextureFormat fmt = glu::mapGLTransferFormat(GL_RGBA, GL_UNSIGNED_BYTE); 440 tcu::TextureLevel levelData (fmt); 441 442 GLuint texture; 443 glGenTextures(1, &texture); 444 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 445 glBindTexture(GL_TEXTURE_2D, texture); 446 447 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, m_wrapS); 448 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, m_wrapT); 449 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 450 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 451 452 levelData.setSize(m_size.x(), m_size.y()); 453 clear(levelData.getAccess(), tcu::Vec4(0.0f, 0.0f, 1.0f, 1.0f)); 454 455 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_size.x(), m_size.y(), 0, GL_RGBA, GL_UNSIGNED_BYTE, levelData.getAccess().getDataPtr()); 456 457 GLU_CHECK_MSG("Set texturing state"); 458 459 const char* extension = "GL_OES_texture_npot"; 460 if (isExtensionSupported(m_ctxInfo, extension)) 461 { 462 log << TestLog::Message << extension << " supported, assuming completeness test to pass." << TestLog::EndMessage; 463 m_compareColor = RGBA(0,0,255,255); 464 } 465} 466 467class Complete2DExtraLevelCase : public Tex2DCompletenessCase 468{ 469public: 470 Complete2DExtraLevelCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, IVec2 size); 471 ~Complete2DExtraLevelCase (void) {} 472 473 virtual void createTexture (void); 474 475private: 476 IVec2 m_size; 477}; 478 479Complete2DExtraLevelCase::Complete2DExtraLevelCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, IVec2 size) 480 : Tex2DCompletenessCase (testCtx, renderCtx, name, description) 481 , m_size (size) 482{ 483} 484 485void Complete2DExtraLevelCase::createTexture (void) 486{ 487 tcu::TextureFormat fmt = glu::mapGLTransferFormat(GL_RGBA, GL_UNSIGNED_BYTE); 488 tcu::TextureLevel levelData (fmt); 489 490 GLuint texture; 491 glGenTextures (1, &texture); 492 glPixelStorei (GL_UNPACK_ALIGNMENT, 1); 493 glBindTexture (GL_TEXTURE_2D, texture); 494 495 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); 496 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); 497 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST); 498 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 499 500 int numLevels = 1 + de::max(deLog2Floor32(m_size.x()), deLog2Floor32(m_size.y())); 501 502 for (int levelNdx = 0; levelNdx < numLevels; levelNdx++) 503 { 504 int levelW = de::max(1, m_size.x() >> levelNdx); 505 int levelH = de::max(1, m_size.y() >> levelNdx); 506 507 levelData.setSize(m_size.x(), m_size.y()); 508 clear(levelData.getAccess(), tcu::Vec4(0.0f, 0.0f, 1.0f, 1.0f)); 509 510 glTexImage2D(GL_TEXTURE_2D, levelNdx, GL_RGBA, levelW, levelH, 0, GL_RGBA, GL_UNSIGNED_BYTE, levelData.getAccess().getDataPtr()); 511 } 512 513 // Specify extra level. 514 glTexImage2D(GL_TEXTURE_2D, numLevels+1, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, levelData.getAccess().getDataPtr()); 515 m_compareColor = RGBA(0,0,255,255); 516 517 GLU_CHECK_MSG("Set texturing state"); 518} 519 520class Incomplete2DEmptyObjectCase : public Tex2DCompletenessCase 521{ 522public: 523 Incomplete2DEmptyObjectCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, IVec2 size); 524 ~Incomplete2DEmptyObjectCase (void) {} 525 526 virtual void createTexture (void); 527 528private: 529 IVec2 m_size; 530}; 531 532Incomplete2DEmptyObjectCase::Incomplete2DEmptyObjectCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, IVec2 size) 533 : Tex2DCompletenessCase (testCtx, renderCtx, name, description) 534 , m_size (size) 535{ 536} 537 538void Incomplete2DEmptyObjectCase::createTexture (void) 539{ 540 tcu::TextureFormat fmt = glu::mapGLTransferFormat(GL_RGBA, GL_UNSIGNED_BYTE); 541 tcu::TextureLevel levelData (fmt); 542 543 GLuint texture; 544 glGenTextures (1, &texture); 545 glPixelStorei (GL_UNPACK_ALIGNMENT, 1); 546 glBindTexture (GL_TEXTURE_2D, texture); 547 548 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); 549 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); 550 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST); 551 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 552 553 GLU_CHECK_MSG("Set texturing state"); 554} 555 556// Cube texture tests. 557 558class IncompleteCubeSizeCase : public TexCubeCompletenessCase 559{ 560public: 561 IncompleteCubeSizeCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, IVec2 size, IVec2 invalidLevelSize, int invalidLevelNdx); 562 IncompleteCubeSizeCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, IVec2 size, IVec2 invalidLevelSize, int invalidLevelNdx, tcu::CubeFace invalidCubeFace); 563 ~IncompleteCubeSizeCase (void) {} 564 565 virtual void createTexture (void); 566 567private: 568 int m_invalidLevelNdx; 569 IVec2 m_invalidLevelSize; 570 tcu::CubeFace m_invalidCubeFace; 571 IVec2 m_size; 572}; 573 574IncompleteCubeSizeCase::IncompleteCubeSizeCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, IVec2 size, IVec2 invalidLevelSize, int invalidLevelNdx) 575 : TexCubeCompletenessCase (testCtx, renderCtx, name, description) 576 , m_invalidLevelNdx (invalidLevelNdx) 577 , m_invalidLevelSize (invalidLevelSize) 578 , m_invalidCubeFace (tcu::CUBEFACE_LAST) 579 , m_size (size) 580{ 581} 582 583IncompleteCubeSizeCase::IncompleteCubeSizeCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, IVec2 size, IVec2 invalidLevelSize, int invalidLevelNdx, tcu::CubeFace invalidCubeFace) 584 : TexCubeCompletenessCase (testCtx, renderCtx, name, description) 585 , m_invalidLevelNdx (invalidLevelNdx) 586 , m_invalidLevelSize (invalidLevelSize) 587 , m_invalidCubeFace (invalidCubeFace) 588 , m_size (size) 589{ 590} 591 592void IncompleteCubeSizeCase::createTexture (void) 593{ 594 tcu::TextureFormat fmt = glu::mapGLTransferFormat(GL_RGBA, GL_UNSIGNED_BYTE); 595 tcu::TextureLevel levelData (fmt); 596 597 GLuint texture; 598 glGenTextures (1, &texture); 599 glPixelStorei (GL_UNPACK_ALIGNMENT, 1); 600 glBindTexture (GL_TEXTURE_CUBE_MAP, texture); 601 602 glTexParameteri (GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_REPEAT); 603 glTexParameteri (GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_REPEAT); 604 glTexParameteri (GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST); 605 glTexParameteri (GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 606 607 int numLevels = 1 + de::max(deLog2Floor32(m_size.x()), deLog2Floor32(m_size.y())); 608 609 for (int levelNdx = 0; levelNdx < numLevels; levelNdx++) 610 { 611 levelData.setSize(m_size.x(), m_size.y()); 612 clear(levelData.getAccess(), tcu::Vec4(0.0f, 0.0f, 1.0f, 1.0f)); 613 614 for (int targetNdx = 0; targetNdx < DE_LENGTH_OF_ARRAY(s_cubeTargets); targetNdx++) 615 { 616 int levelW = de::max(1, m_size.x() >> levelNdx); 617 int levelH = de::max(1, m_size.y() >> levelNdx); 618 if (levelNdx == m_invalidLevelNdx && (m_invalidCubeFace == tcu::CUBEFACE_LAST || m_invalidCubeFace == targetNdx)) 619 { 620 levelW = m_invalidLevelSize.x(); 621 levelH = m_invalidLevelSize.y(); 622 } 623 glTexImage2D(s_cubeTargets[targetNdx], levelNdx, GL_RGBA, levelW, levelH, 0, GL_RGBA, GL_UNSIGNED_BYTE, levelData.getAccess().getDataPtr()); 624 } 625 } 626 627 GLU_CHECK_MSG("Set texturing state"); 628} 629 630class IncompleteCubeFormatCase : public TexCubeCompletenessCase 631{ 632public: 633 IncompleteCubeFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, IVec2 size, deUint32 format, deUint32 invalidFormat); 634 IncompleteCubeFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, IVec2 size, deUint32 format, deUint32 invalidFormat, tcu::CubeFace invalidCubeFace); 635 ~IncompleteCubeFormatCase (void) {} 636 637 virtual void createTexture (void); 638 639private: 640 deUint32 m_format; 641 deUint32 m_invalidFormat; 642 tcu::CubeFace m_invalidCubeFace; 643 IVec2 m_size; 644}; 645 646IncompleteCubeFormatCase::IncompleteCubeFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, IVec2 size, deUint32 format, deUint32 invalidFormat) 647 : TexCubeCompletenessCase (testCtx, renderCtx, name, description) 648 , m_format (format) 649 , m_invalidFormat (invalidFormat) 650 , m_invalidCubeFace (tcu::CUBEFACE_LAST) 651 , m_size (size) 652{ 653} 654 655IncompleteCubeFormatCase::IncompleteCubeFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, IVec2 size, deUint32 format, deUint32 invalidFormat, tcu::CubeFace invalidCubeFace) 656 : TexCubeCompletenessCase (testCtx, renderCtx, name, description) 657 , m_format (format) 658 , m_invalidFormat (invalidFormat) 659 , m_invalidCubeFace (invalidCubeFace) 660 , m_size (size) 661{ 662} 663 664void IncompleteCubeFormatCase::createTexture (void) 665{ 666 tcu::TextureFormat fmt = glu::mapGLTransferFormat(GL_RGBA, GL_UNSIGNED_BYTE); 667 tcu::TextureLevel levelData (fmt); 668 669 GLuint texture; 670 glGenTextures (1, &texture); 671 glPixelStorei (GL_UNPACK_ALIGNMENT, 1); 672 glBindTexture (GL_TEXTURE_CUBE_MAP, texture); 673 674 glTexParameteri (GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_REPEAT); 675 glTexParameteri (GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_REPEAT); 676 glTexParameteri (GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST); 677 glTexParameteri (GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 678 679 int numLevels = 1 + de::max(deLog2Floor32(m_size.x()), deLog2Floor32(m_size.y())); 680 681 for (int levelNdx = 0; levelNdx < numLevels; levelNdx++) 682 { 683 levelData.setSize(m_size.x(), m_size.y()); 684 clear(levelData.getAccess(), tcu::Vec4(0.0f, 0.0f, 1.0f, 1.0f)); 685 686 int levelW = de::max(1, m_size.x() >> levelNdx); 687 int levelH = de::max(1, m_size.y() >> levelNdx); 688 689 for (int targetNdx = 0; targetNdx < DE_LENGTH_OF_ARRAY(s_cubeTargets); targetNdx++) 690 { 691 deUint32 format = m_format; 692 if (levelNdx == 0 && (m_invalidCubeFace == tcu::CUBEFACE_LAST || m_invalidCubeFace == targetNdx)) 693 format = m_invalidFormat; 694 695 glTexImage2D(s_cubeTargets[targetNdx], levelNdx, format, levelW, levelH, 0, format, GL_UNSIGNED_BYTE, levelData.getAccess().getDataPtr()); 696 } 697 } 698 699 GLU_CHECK_MSG("Set texturing state"); 700} 701 702class IncompleteCubeMissingLevelCase : public TexCubeCompletenessCase 703{ 704public: 705 IncompleteCubeMissingLevelCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, IVec2 size, int invalidLevelNdx); 706 IncompleteCubeMissingLevelCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, IVec2 size, int invalidLevelNdx, tcu::CubeFace invalidCubeFace); 707 ~IncompleteCubeMissingLevelCase (void) {} 708 709 virtual void createTexture (void); 710 711private: 712 int m_invalidLevelNdx; 713 tcu::CubeFace m_invalidCubeFace; 714 IVec2 m_size; 715}; 716 717IncompleteCubeMissingLevelCase::IncompleteCubeMissingLevelCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, IVec2 size, int invalidLevelNdx) 718 : TexCubeCompletenessCase (testCtx, renderCtx, name, description) 719 , m_invalidLevelNdx (invalidLevelNdx) 720 , m_invalidCubeFace (tcu::CUBEFACE_LAST) 721 , m_size (size) 722{ 723} 724 725IncompleteCubeMissingLevelCase::IncompleteCubeMissingLevelCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, IVec2 size, int invalidLevelNdx, tcu::CubeFace invalidCubeFace) 726 : TexCubeCompletenessCase (testCtx, renderCtx, name, description) 727 , m_invalidLevelNdx (invalidLevelNdx) 728 , m_invalidCubeFace (invalidCubeFace) 729 , m_size (size) 730{ 731} 732 733void IncompleteCubeMissingLevelCase::createTexture (void) 734{ 735 tcu::TextureFormat fmt = glu::mapGLTransferFormat(GL_RGBA, GL_UNSIGNED_BYTE); 736 tcu::TextureLevel levelData (fmt); 737 738 GLuint texture; 739 glGenTextures (1, &texture); 740 glPixelStorei (GL_UNPACK_ALIGNMENT, 1); 741 glBindTexture (GL_TEXTURE_CUBE_MAP, texture); 742 743 glTexParameteri (GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_REPEAT); 744 glTexParameteri (GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_REPEAT); 745 glTexParameteri (GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST); 746 glTexParameteri (GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 747 748 int numLevels = 1 + de::max(deLog2Floor32(m_size.x()), deLog2Floor32(m_size.y())); 749 750 for (int levelNdx = 0; levelNdx < numLevels; levelNdx++) 751 { 752 levelData.setSize(m_size.x(), m_size.y()); 753 clear(levelData.getAccess(), tcu::Vec4(0.0f, 0.0f, 1.0f, 1.0f)); 754 755 int levelW = (levelNdx == m_invalidLevelNdx) ? m_size.x() : de::max(1, m_size.x() >> levelNdx); 756 int levelH = (levelNdx == m_invalidLevelNdx) ? m_size.y() : de::max(1, m_size.y() >> levelNdx); 757 758 if (levelNdx != m_invalidLevelNdx || m_invalidCubeFace != tcu::CUBEFACE_LAST) 759 { 760 for (int targetNdx = 0; targetNdx < DE_LENGTH_OF_ARRAY(s_cubeTargets); targetNdx++) 761 { 762 // If single cubeface is specified then skip only that one. 763 if (m_invalidCubeFace != targetNdx) 764 glTexImage2D(s_cubeTargets[targetNdx], levelNdx, GL_RGBA, levelW, levelH, 0, GL_RGBA, GL_UNSIGNED_BYTE, levelData.getAccess().getDataPtr()); 765 } 766 } 767 } 768 769 GLU_CHECK_MSG("Set texturing state"); 770} 771 772class IncompleteCubeWrapModeCase : public TexCubeCompletenessCase 773{ 774public: 775 IncompleteCubeWrapModeCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, IVec2 size, deUint32 wrapT, deUint32 wrapS, const glu::ContextInfo& ctxInfo); 776 ~IncompleteCubeWrapModeCase (void) {} 777 778 virtual void createTexture (void); 779 780private: 781 deUint32 m_wrapT; 782 deUint32 m_wrapS; 783 const glu::ContextInfo& m_ctxInfo; 784 IVec2 m_size; 785}; 786 787IncompleteCubeWrapModeCase::IncompleteCubeWrapModeCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, IVec2 size, deUint32 wrapT, deUint32 wrapS, const glu::ContextInfo& ctxInfo) 788 : TexCubeCompletenessCase (testCtx, renderCtx, name, description) 789 , m_wrapT (wrapT) 790 , m_wrapS (wrapS) 791 , m_ctxInfo (ctxInfo) 792 , m_size (size) 793{ 794} 795 796void IncompleteCubeWrapModeCase::createTexture (void) 797{ 798 TestLog& log = m_testCtx.getLog(); 799 tcu::TextureFormat fmt = glu::mapGLTransferFormat(GL_RGBA, GL_UNSIGNED_BYTE); 800 tcu::TextureLevel levelData (fmt); 801 802 GLuint texture; 803 glGenTextures(1, &texture); 804 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 805 glBindTexture(GL_TEXTURE_2D, texture); 806 807 glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, m_wrapS); 808 glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, m_wrapT); 809 glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 810 glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 811 812 levelData.setSize(m_size.x(), m_size.y()); 813 clear(levelData.getAccess(), tcu::Vec4(0.0f, 0.0f, 1.0f, 1.0f)); 814 815 for (int targetNdx = 0; targetNdx < DE_LENGTH_OF_ARRAY(s_cubeTargets); targetNdx++) 816 glTexImage2D(s_cubeTargets[targetNdx], 0, GL_RGBA, m_size.x(), m_size.y(), 0, GL_RGBA, GL_UNSIGNED_BYTE, levelData.getAccess().getDataPtr()); 817 818 GLU_CHECK_MSG("Set texturing state"); 819 820 const char* extension = "GL_OES_texture_npot"; 821 if (isExtensionSupported(m_ctxInfo, extension)) 822 { 823 log << TestLog::Message << extension << " supported, assuming completeness test to pass." << TestLog::EndMessage; 824 m_compareColor = RGBA(0,0,255,255); 825 } 826} 827 828class CompleteCubeExtraLevelCase : public TexCubeCompletenessCase 829{ 830public: 831 CompleteCubeExtraLevelCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, IVec2 size); 832 ~CompleteCubeExtraLevelCase (void) {} 833 834 virtual void createTexture (void); 835 836private: 837 IVec2 m_size; 838}; 839 840CompleteCubeExtraLevelCase::CompleteCubeExtraLevelCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, IVec2 size) 841 : TexCubeCompletenessCase (testCtx, renderCtx, name, description) 842 , m_size (size) 843{ 844} 845 846void CompleteCubeExtraLevelCase::createTexture (void) 847{ 848 tcu::TextureFormat fmt = glu::mapGLTransferFormat(GL_RGBA, GL_UNSIGNED_BYTE); 849 tcu::TextureLevel levelData (fmt); 850 851 GLuint texture; 852 glGenTextures (1, &texture); 853 glPixelStorei (GL_UNPACK_ALIGNMENT, 1); 854 glBindTexture (GL_TEXTURE_2D, texture); 855 856 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); 857 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); 858 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST); 859 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 860 861 int numLevels = 1 + de::max(deLog2Floor32(m_size.x()), deLog2Floor32(m_size.y())); 862 863 levelData.setSize(m_size.x(), m_size.y()); 864 clear(levelData.getAccess(), tcu::Vec4(0.0f, 0.0f, 1.0f, 1.0f)); 865 866 for (int levelNdx = 0; levelNdx < numLevels; levelNdx++) 867 { 868 int levelW = de::max(1, m_size.x() >> levelNdx); 869 int levelH = de::max(1, m_size.y() >> levelNdx); 870 871 for (int targetNdx = 0; targetNdx < DE_LENGTH_OF_ARRAY(s_cubeTargets); targetNdx++) 872 glTexImage2D(s_cubeTargets[targetNdx], levelNdx, GL_RGBA, levelW, levelH, 0, GL_RGBA, GL_UNSIGNED_BYTE, levelData.getAccess().getDataPtr()); 873 } 874 875 // Specify extra level. 876 for (int targetNdx = 0; targetNdx < DE_LENGTH_OF_ARRAY(s_cubeTargets); targetNdx++) 877 glTexImage2D(s_cubeTargets[targetNdx], numLevels+1, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, levelData.getAccess().getDataPtr()); 878 879 m_compareColor = RGBA(0,0,255,255); 880 881 GLU_CHECK_MSG("Set texturing state"); 882} 883 884class IncompleteCubeEmptyObjectCase : public TexCubeCompletenessCase 885{ 886public: 887 IncompleteCubeEmptyObjectCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, IVec2 size); 888 ~IncompleteCubeEmptyObjectCase (void) {} 889 890 virtual void createTexture (void); 891 892private: 893 IVec2 m_size; 894}; 895 896IncompleteCubeEmptyObjectCase::IncompleteCubeEmptyObjectCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, IVec2 size) 897 : TexCubeCompletenessCase (testCtx, renderCtx, name, description) 898 , m_size (size) 899{ 900} 901 902void IncompleteCubeEmptyObjectCase::createTexture (void) 903{ 904 tcu::TextureFormat fmt = glu::mapGLTransferFormat(GL_RGBA, GL_UNSIGNED_BYTE); 905 tcu::TextureLevel levelData (fmt); 906 907 GLuint texture; 908 glGenTextures (1, &texture); 909 glPixelStorei (GL_UNPACK_ALIGNMENT, 1); 910 glBindTexture (GL_TEXTURE_2D, texture); 911 912 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); 913 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); 914 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST); 915 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 916 917 GLU_CHECK_MSG("Set texturing state"); 918} 919 920// Texture completeness group. 921 922TextureCompletenessTests::TextureCompletenessTests (Context& context) 923 : TestCaseGroup(context, "completeness", "Completeness tests") 924{ 925} 926 927void TextureCompletenessTests::init (void) 928{ 929 tcu::TestCaseGroup* tex2d = new tcu::TestCaseGroup(m_testCtx, "2d", "2D completeness"); 930 addChild(tex2d); 931 tcu::TestCaseGroup* cube = new tcu::TestCaseGroup(m_testCtx, "cube", "Cubemap completeness"); 932 addChild(cube); 933 934 // Texture 2D size. 935 tex2d->addChild(new Incomplete2DSizeCase(m_testCtx, m_context.getRenderContext(), "npot_size", "", IVec2(255, 255), IVec2(255, 255), 0, m_context.getContextInfo())); 936 tex2d->addChild(new Incomplete2DSizeCase(m_testCtx, m_context.getRenderContext(), "npot_size_level_0", "", IVec2(256, 256), IVec2(255, 255), 0, m_context.getContextInfo())); 937 tex2d->addChild(new Incomplete2DSizeCase(m_testCtx, m_context.getRenderContext(), "npot_size_level_1", "", IVec2(256, 256), IVec2(127, 127), 1, m_context.getContextInfo())); 938 tex2d->addChild(new Incomplete2DSizeCase(m_testCtx, m_context.getRenderContext(), "not_positive_level_0", "", IVec2(256, 256), IVec2(0, 0), 0, m_context.getContextInfo())); 939 // Texture 2D format. 940 tex2d->addChild(new Incomplete2DFormatCase(m_testCtx, m_context.getRenderContext(), "format_mismatch_rgb_rgba", "", IVec2(128, 128), GL_RGB, GL_RGBA, 1)); 941 tex2d->addChild(new Incomplete2DFormatCase(m_testCtx, m_context.getRenderContext(), "format_mismatch_rgba_rgb", "", IVec2(128, 128), GL_RGBA, GL_RGB, 1)); 942 tex2d->addChild(new Incomplete2DFormatCase(m_testCtx, m_context.getRenderContext(), "format_mismatch_luminance_luminance_alpha", "", IVec2(128, 128), GL_LUMINANCE, GL_LUMINANCE_ALPHA, 1)); 943 tex2d->addChild(new Incomplete2DFormatCase(m_testCtx, m_context.getRenderContext(), "format_mismatch_luminance_alpha_luminance", "", IVec2(128, 128), GL_LUMINANCE_ALPHA, GL_LUMINANCE, 1)); 944 // Texture 2D missing level. 945 tex2d->addChild(new Incomplete2DMissingLevelCase(m_testCtx, m_context.getRenderContext(), "missing_level_1", "", IVec2(128, 128), 1)); 946 tex2d->addChild(new Incomplete2DMissingLevelCase(m_testCtx, m_context.getRenderContext(), "missing_level_3", "", IVec2(128, 128), 3)); 947 tex2d->addChild(new Incomplete2DMissingLevelCase(m_testCtx, m_context.getRenderContext(), "last_level_missing", "", IVec2(128, 64), de::max(deLog2Floor32(128), deLog2Floor32(64)))); 948 // Texture 2D wrap modes. 949 tex2d->addChild(new Incomplete2DWrapModeCase(m_testCtx, m_context.getRenderContext(), "npot_t_repeat", "", IVec2(127, 127), GL_CLAMP_TO_EDGE, GL_REPEAT, m_context.getContextInfo())); 950 tex2d->addChild(new Incomplete2DWrapModeCase(m_testCtx, m_context.getRenderContext(), "npot_s_repeat", "", IVec2(127, 127), GL_REPEAT, GL_CLAMP_TO_EDGE, m_context.getContextInfo())); 951 tex2d->addChild(new Incomplete2DWrapModeCase(m_testCtx, m_context.getRenderContext(), "npot_all_repeat", "", IVec2(127, 127), GL_REPEAT, GL_REPEAT, m_context.getContextInfo())); 952 tex2d->addChild(new Incomplete2DWrapModeCase(m_testCtx, m_context.getRenderContext(), "npot_mirrored_repeat", "", IVec2(127, 127), GL_MIRRORED_REPEAT, GL_MIRRORED_REPEAT, m_context.getContextInfo())); 953 tex2d->addChild(new Incomplete2DWrapModeCase(m_testCtx, m_context.getRenderContext(), "repeat_width_npot", "", IVec2(127, 128), GL_REPEAT, GL_REPEAT, m_context.getContextInfo())); 954 tex2d->addChild(new Incomplete2DWrapModeCase(m_testCtx, m_context.getRenderContext(), "repeat_height_npot", "", IVec2(128, 127), GL_REPEAT, GL_REPEAT, m_context.getContextInfo())); 955 // Texture 2D extra level. 956 tex2d->addChild(new Complete2DExtraLevelCase(m_testCtx, m_context.getRenderContext(), "extra_level", "", IVec2(64, 64))); 957 // Texture 2D empty object. 958 tex2d->addChild(new Incomplete2DEmptyObjectCase(m_testCtx, m_context.getRenderContext(), "empty_object", "", IVec2(64, 64))); 959 960 // Cube size. 961 cube->addChild(new IncompleteCubeSizeCase(m_testCtx, m_context.getRenderContext(), "npot_size_level_0", "", IVec2(64, 64), IVec2(63, 63), 0)); 962 cube->addChild(new IncompleteCubeSizeCase(m_testCtx, m_context.getRenderContext(), "npot_size_level_1", "", IVec2(64, 64), IVec2(31, 31), 1)); 963 cube->addChild(new IncompleteCubeSizeCase(m_testCtx, m_context.getRenderContext(), "npot_size_level_0_pos_x", "", IVec2(64, 64), IVec2(63, 63), 0, tcu::CUBEFACE_POSITIVE_X)); 964 cube->addChild(new IncompleteCubeSizeCase(m_testCtx, m_context.getRenderContext(), "npot_size_level_1_neg_x", "", IVec2(64, 64), IVec2(31, 31), 1, tcu::CUBEFACE_NEGATIVE_X)); 965 cube->addChild(new IncompleteCubeSizeCase(m_testCtx, m_context.getRenderContext(), "not_positive_level_0", "", IVec2(64, 64), IVec2(0,0) , 0)); 966 // Cube format. 967 cube->addChild(new IncompleteCubeFormatCase(m_testCtx, m_context.getRenderContext(), "format_mismatch_rgb_rgba_level_0", "", IVec2(64, 64), GL_RGB, GL_RGBA)); 968 cube->addChild(new IncompleteCubeFormatCase(m_testCtx, m_context.getRenderContext(), "format_mismatch_rgba_rgb_level_0", "", IVec2(64, 64), GL_RGBA, GL_RGB)); 969 cube->addChild(new IncompleteCubeFormatCase(m_testCtx, m_context.getRenderContext(), "format_mismatch_luminance_luminance_alpha_level_0", "", IVec2(64, 64), GL_LUMINANCE, GL_LUMINANCE_ALPHA)); 970 cube->addChild(new IncompleteCubeFormatCase(m_testCtx, m_context.getRenderContext(), "format_mismatch_luminance_alpha_luminance_level_0", "", IVec2(64, 64), GL_LUMINANCE_ALPHA, GL_LUMINANCE)); 971 cube->addChild(new IncompleteCubeFormatCase(m_testCtx, m_context.getRenderContext(), "format_mismatch_rgb_rgba_level_0_pos_z", "", IVec2(64, 64), GL_RGB, GL_RGBA, tcu::CUBEFACE_POSITIVE_Z)); 972 cube->addChild(new IncompleteCubeFormatCase(m_testCtx, m_context.getRenderContext(), "format_mismatch_rgba_rgb_level_0_neg_z", "", IVec2(64, 64), GL_RGBA, GL_RGB, tcu::CUBEFACE_NEGATIVE_Z)); 973 // Cube missing level. 974 cube->addChild(new IncompleteCubeMissingLevelCase(m_testCtx, m_context.getRenderContext(), "missing_level_1", "", IVec2(64, 64), 1)); 975 cube->addChild(new IncompleteCubeMissingLevelCase(m_testCtx, m_context.getRenderContext(), "missing_level_3", "", IVec2(64, 64), 3)); 976 cube->addChild(new IncompleteCubeMissingLevelCase(m_testCtx, m_context.getRenderContext(), "missing_level_1_pos_y", "", IVec2(64, 64), 1, tcu::CUBEFACE_POSITIVE_Y)); 977 cube->addChild(new IncompleteCubeMissingLevelCase(m_testCtx, m_context.getRenderContext(), "missing_level_3_neg_y", "", IVec2(64, 64), 3, tcu::CUBEFACE_NEGATIVE_Y)); 978 // Cube wrap modes. 979 cube->addChild(new IncompleteCubeWrapModeCase(m_testCtx, m_context.getRenderContext(), "npot_t_repeat", "", IVec2(127, 127), GL_CLAMP_TO_EDGE, GL_REPEAT, m_context.getContextInfo())); 980 cube->addChild(new IncompleteCubeWrapModeCase(m_testCtx, m_context.getRenderContext(), "npot_s_repeat", "", IVec2(127, 127), GL_REPEAT, GL_CLAMP_TO_EDGE, m_context.getContextInfo())); 981 cube->addChild(new IncompleteCubeWrapModeCase(m_testCtx, m_context.getRenderContext(), "npot_all_repeat", "", IVec2(127, 127), GL_REPEAT, GL_REPEAT, m_context.getContextInfo())); 982 cube->addChild(new IncompleteCubeWrapModeCase(m_testCtx, m_context.getRenderContext(), "npot_mirrored_repeat", "", IVec2(127, 127), GL_MIRRORED_REPEAT, GL_MIRRORED_REPEAT, m_context.getContextInfo())); 983 // Cube extra level. 984 cube->addChild(new CompleteCubeExtraLevelCase(m_testCtx, m_context.getRenderContext(), "extra_level", "", IVec2(64, 64))); 985 // Cube extra level. 986 cube->addChild(new IncompleteCubeEmptyObjectCase(m_testCtx, m_context.getRenderContext(), "empty_object", "", IVec2(64, 64))); 987} 988 989} // Functional 990} // gles2 991} // deqp 992