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 format tests. 22 * 23 * Constants: 24 * + nearest-neighbor filtering 25 * + no mipmaps 26 * + full texture coordinate range (but not outside) tested 27 * + accessed from fragment shader 28 * + texture unit 0 29 * + named texture object 30 * 31 * Variables: 32 * + texture format 33 * + texture type: 2D or cubemap 34 *//*--------------------------------------------------------------------*/ 35 36 #include "es3fTextureFormatTests.hpp" 37 #include "gluPixelTransfer.hpp" 38 #include "gluStrUtil.hpp" 39 #include "gluTexture.hpp" 40 #include "gluTextureUtil.hpp" 41 #include "glsTextureTestUtil.hpp" 42 #include "tcuTextureUtil.hpp" 43 #include "deStringUtil.hpp" 44 #include "deRandom.hpp" 45 #include "glwEnums.hpp" 46 #include "glwFunctions.hpp" 47 48 using std::vector; 49 using std::string; 50 using tcu::TestLog; 51 52 namespace deqp 53 { 54 namespace gles3 55 { 56 namespace Functional 57 { 58 59 using namespace deqp::gls; 60 using namespace deqp::gls::TextureTestUtil; 61 using tcu::Sampler; 62 63 // Texture2DFormatCase 64 65 class Texture2DFormatCase : public tcu::TestCase 66 { 67 public: 68 Texture2DFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, deUint32 format, deUint32 dataType, int width, int height); 69 Texture2DFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, deUint32 internalFormat, int width, int height); 70 ~Texture2DFormatCase (void); 71 72 void init (void); 73 void deinit (void); 74 IterateResult iterate (void); 75 76 private: 77 Texture2DFormatCase (const Texture2DFormatCase& other); 78 Texture2DFormatCase& operator= (const Texture2DFormatCase& other); 79 80 glu::RenderContext& m_renderCtx; 81 82 deUint32 m_format; 83 deUint32 m_dataType; 84 int m_width; 85 int m_height; 86 87 glu::Texture2D* m_texture; 88 TextureRenderer m_renderer; 89 }; 90 91 Texture2DFormatCase::Texture2DFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, deUint32 format, deUint32 dataType, int width, int height) 92 : TestCase (testCtx, name, description) 93 , m_renderCtx (renderCtx) 94 , m_format (format) 95 , m_dataType (dataType) 96 , m_width (width) 97 , m_height (height) 98 , m_texture (DE_NULL) 99 , m_renderer (renderCtx, testCtx.getLog(), glu::GLSL_VERSION_300_ES, glu::PRECISION_HIGHP) 100 { 101 } 102 103 Texture2DFormatCase::Texture2DFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, deUint32 internalFormat, int width, int height) 104 : TestCase (testCtx, name, description) 105 , m_renderCtx (renderCtx) 106 , m_format (internalFormat) 107 , m_dataType (GL_NONE) 108 , m_width (width) 109 , m_height (height) 110 , m_texture (DE_NULL) 111 , m_renderer (renderCtx, testCtx.getLog(), glu::GLSL_VERSION_300_ES, glu::PRECISION_HIGHP) 112 { 113 } 114 115 Texture2DFormatCase::~Texture2DFormatCase (void) 116 { 117 deinit(); 118 } 119 120 void Texture2DFormatCase::init (void) 121 { 122 TestLog& log = m_testCtx.getLog(); 123 tcu::TextureFormat fmt = m_dataType ? glu::mapGLTransferFormat(m_format, m_dataType) : glu::mapGLInternalFormat(m_format); 124 tcu::TextureFormatInfo spec = tcu::getTextureFormatInfo(fmt); 125 std::ostringstream fmtName; 126 127 if (m_dataType) 128 fmtName << glu::getTextureFormatStr(m_format) << ", " << glu::getTypeStr(m_dataType); 129 else 130 fmtName << glu::getTextureFormatStr(m_format); 131 132 log << TestLog::Message << "2D texture, " << fmtName.str() << ", " << m_width << "x" << m_height 133 << ",\n fill with " << formatGradient(&spec.valueMin, &spec.valueMax) << " gradient" 134 << TestLog::EndMessage; 135 136 m_texture = m_dataType != GL_NONE 137 ? new glu::Texture2D(m_renderCtx, m_format, m_dataType, m_width, m_height) // Implicit internal format. 138 : new glu::Texture2D(m_renderCtx, m_format, m_width, m_height); // Explicit internal format. 139 140 // Fill level 0. 141 m_texture->getRefTexture().allocLevel(0); 142 tcu::fillWithComponentGradients(m_texture->getRefTexture().getLevel(0), spec.valueMin, spec.valueMax); 143 } 144 145 void Texture2DFormatCase::deinit (void) 146 { 147 delete m_texture; 148 m_texture = DE_NULL; 149 150 m_renderer.clear(); 151 } 152 153 Texture2DFormatCase::IterateResult Texture2DFormatCase::iterate (void) 154 { 155 TestLog& log = m_testCtx.getLog(); 156 const glw::Functions& gl = m_renderCtx.getFunctions(); 157 RandomViewport viewport (m_renderCtx.getRenderTarget(), m_width, m_height, deStringHash(getName())); 158 tcu::Surface renderedFrame (viewport.width, viewport.height); 159 tcu::Surface referenceFrame (viewport.width, viewport.height); 160 tcu::RGBA threshold = m_renderCtx.getRenderTarget().getPixelFormat().getColorThreshold() + tcu::RGBA(1,1,1,1); 161 vector<float> texCoord; 162 ReferenceParams renderParams (TEXTURETYPE_2D); 163 tcu::TextureFormatInfo spec = tcu::getTextureFormatInfo(m_texture->getRefTexture().getFormat()); 164 const deUint32 wrapS = GL_CLAMP_TO_EDGE; 165 const deUint32 wrapT = GL_CLAMP_TO_EDGE; 166 const deUint32 minFilter = GL_NEAREST; 167 const deUint32 magFilter = GL_NEAREST; 168 169 renderParams.flags |= RenderParams::LOG_ALL; 170 renderParams.samplerType = getSamplerType(m_texture->getRefTexture().getFormat()); 171 renderParams.sampler = Sampler(Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::NEAREST, Sampler::NEAREST); 172 renderParams.colorScale = spec.lookupScale; 173 renderParams.colorBias = spec.lookupBias; 174 175 computeQuadTexCoord2D(texCoord, tcu::Vec2(0.0f, 0.0f), tcu::Vec2(1.0f, 1.0f)); 176 177 log << TestLog::Message << "Texture parameters:" 178 << "\n WRAP_S = " << glu::getTextureParameterValueStr(GL_TEXTURE_WRAP_S, wrapS) 179 << "\n WRAP_T = " << glu::getTextureParameterValueStr(GL_TEXTURE_WRAP_T, wrapT) 180 << "\n MIN_FILTER = " << glu::getTextureParameterValueStr(GL_TEXTURE_MIN_FILTER, minFilter) 181 << "\n MAG_FILTER = " << glu::getTextureParameterValueStr(GL_TEXTURE_MAG_FILTER, magFilter) 182 << TestLog::EndMessage; 183 184 // Setup base viewport. 185 gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height); 186 187 // Upload texture data to GL. 188 m_texture->upload(); 189 190 // Bind to unit 0. 191 gl.activeTexture(GL_TEXTURE0); 192 gl.bindTexture(GL_TEXTURE_2D, m_texture->getGLTexture()); 193 194 // Setup nearest neighbor filtering and clamp-to-edge. 195 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrapS); 196 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrapT); 197 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, minFilter); 198 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, magFilter); 199 200 GLU_EXPECT_NO_ERROR(gl.getError(), "Set texturing state"); 201 202 // Draw. 203 m_renderer.renderQuad(0, &texCoord[0], renderParams); 204 glu::readPixels(m_renderCtx, viewport.x, viewport.y, renderedFrame.getAccess()); 205 GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels()"); 206 207 // Compute reference. 208 sampleTexture(SurfaceAccess(referenceFrame, m_renderCtx.getRenderTarget().getPixelFormat()), m_texture->getRefTexture(), &texCoord[0], renderParams); 209 210 // Compare and log. 211 bool isOk = compareImages(log, referenceFrame, renderedFrame, threshold); 212 213 m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL, 214 isOk ? "Pass" : "Image comparison failed"); 215 216 return STOP; 217 } 218 219 // TextureCubeFormatCase 220 221 class TextureCubeFormatCase : public tcu::TestCase 222 { 223 public: 224 TextureCubeFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, deUint32 format, deUint32 dataType, int width, int height); 225 TextureCubeFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, deUint32 internalFormat, int width, int height); 226 ~TextureCubeFormatCase (void); 227 228 void init (void); 229 void deinit (void); 230 IterateResult iterate (void); 231 232 private: 233 TextureCubeFormatCase (const TextureCubeFormatCase& other); 234 TextureCubeFormatCase& operator= (const TextureCubeFormatCase& other); 235 236 bool testFace (tcu::CubeFace face); 237 238 glu::RenderContext& m_renderCtx; 239 240 deUint32 m_format; 241 deUint32 m_dataType; 242 int m_width; 243 int m_height; 244 245 glu::TextureCube* m_texture; 246 TextureRenderer m_renderer; 247 248 int m_curFace; 249 bool m_isOk; 250 }; 251 252 TextureCubeFormatCase::TextureCubeFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, deUint32 format, deUint32 dataType, int width, int height) 253 : TestCase (testCtx, name, description) 254 , m_renderCtx (renderCtx) 255 , m_format (format) 256 , m_dataType (dataType) 257 , m_width (width) 258 , m_height (height) 259 , m_texture (DE_NULL) 260 , m_renderer (renderCtx, testCtx.getLog(), glu::GLSL_VERSION_300_ES, glu::PRECISION_HIGHP) 261 , m_curFace (0) 262 , m_isOk (false) 263 { 264 } 265 266 TextureCubeFormatCase::TextureCubeFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, deUint32 internalFormat, int width, int height) 267 : TestCase (testCtx, name, description) 268 , m_renderCtx (renderCtx) 269 , m_format (internalFormat) 270 , m_dataType (GL_NONE) 271 , m_width (width) 272 , m_height (height) 273 , m_texture (DE_NULL) 274 , m_renderer (renderCtx, testCtx.getLog(), glu::GLSL_VERSION_300_ES, glu::PRECISION_HIGHP) 275 , m_curFace (0) 276 , m_isOk (false) 277 { 278 } 279 280 TextureCubeFormatCase::~TextureCubeFormatCase (void) 281 { 282 deinit(); 283 } 284 285 void TextureCubeFormatCase::init (void) 286 { 287 TestLog& log = m_testCtx.getLog(); 288 tcu::TextureFormat fmt = m_dataType ? glu::mapGLTransferFormat(m_format, m_dataType) : glu::mapGLInternalFormat(m_format); 289 tcu::TextureFormatInfo spec = tcu::getTextureFormatInfo(fmt); 290 std::ostringstream fmtName; 291 292 if (m_dataType) 293 fmtName << glu::getTextureFormatStr(m_format) << ", " << glu::getTypeStr(m_dataType); 294 else 295 fmtName << glu::getTextureFormatStr(m_format); 296 297 log << TestLog::Message << "Cube map texture, " << fmtName.str() << ", " << m_width << "x" << m_height 298 << ",\n fill with " << formatGradient(&spec.valueMin, &spec.valueMax) << " gradient" 299 << TestLog::EndMessage; 300 301 DE_ASSERT(m_width == m_height); 302 m_texture = m_dataType != GL_NONE 303 ? new glu::TextureCube(m_renderCtx, m_format, m_dataType, m_width) // Implicit internal format. 304 : new glu::TextureCube(m_renderCtx, m_format, m_width); // Explicit internal format. 305 306 // Fill level 0. 307 for (int face = 0; face < tcu::CUBEFACE_LAST; face++) 308 { 309 tcu::Vec4 gMin, gMax; 310 311 switch (face) 312 { 313 case 0: gMin = spec.valueMin.swizzle(0, 1, 2, 3); gMax = spec.valueMax.swizzle(0, 1, 2, 3); break; 314 case 1: gMin = spec.valueMin.swizzle(2, 1, 0, 3); gMax = spec.valueMax.swizzle(2, 1, 0, 3); break; 315 case 2: gMin = spec.valueMin.swizzle(1, 2, 0, 3); gMax = spec.valueMax.swizzle(1, 2, 0, 3); break; 316 case 3: gMin = spec.valueMax.swizzle(0, 1, 2, 3); gMax = spec.valueMin.swizzle(0, 1, 2, 3); break; 317 case 4: gMin = spec.valueMax.swizzle(2, 1, 0, 3); gMax = spec.valueMin.swizzle(2, 1, 0, 3); break; 318 case 5: gMin = spec.valueMax.swizzle(1, 2, 0, 3); gMax = spec.valueMin.swizzle(1, 2, 0, 3); break; 319 default: 320 DE_ASSERT(false); 321 } 322 323 m_texture->getRefTexture().allocLevel((tcu::CubeFace)face, 0); 324 tcu::fillWithComponentGradients(m_texture->getRefTexture().getLevelFace(0, (tcu::CubeFace)face), gMin, gMax); 325 } 326 327 // Upload texture data to GL. 328 m_texture->upload(); 329 330 // Initialize iteration state. 331 m_curFace = 0; 332 m_isOk = true; 333 } 334 335 void TextureCubeFormatCase::deinit (void) 336 { 337 delete m_texture; 338 m_texture = DE_NULL; 339 340 m_renderer.clear(); 341 } 342 343 bool TextureCubeFormatCase::testFace (tcu::CubeFace face) 344 { 345 TestLog& log = m_testCtx.getLog(); 346 const glw::Functions& gl = m_renderCtx.getFunctions(); 347 RandomViewport viewport (m_renderCtx.getRenderTarget(), m_width, m_height, deStringHash(getName())+(deUint32)face); 348 tcu::Surface renderedFrame (viewport.width, viewport.height); 349 tcu::Surface referenceFrame (viewport.width, viewport.height); 350 tcu::RGBA threshold = m_renderCtx.getRenderTarget().getPixelFormat().getColorThreshold() + tcu::RGBA(1,1,1,1); 351 vector<float> texCoord; 352 ReferenceParams renderParams (TEXTURETYPE_CUBE); 353 tcu::TextureFormatInfo spec = tcu::getTextureFormatInfo(m_texture->getRefTexture().getFormat()); 354 355 renderParams.samplerType = getSamplerType(m_texture->getRefTexture().getFormat()); 356 renderParams.sampler = Sampler(Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::NEAREST, Sampler::NEAREST); 357 renderParams.sampler.seamlessCubeMap = true; 358 renderParams.colorScale = spec.lookupScale; 359 renderParams.colorBias = spec.lookupBias; 360 361 // Log render info on first face. 362 if (face == tcu::CUBEFACE_NEGATIVE_X) 363 renderParams.flags |= RenderParams::LOG_ALL; 364 365 computeQuadTexCoordCube(texCoord, face); 366 367 // \todo [2011-10-28 pyry] Image set name / section? 368 log << TestLog::Message << face << TestLog::EndMessage; 369 370 // Setup base viewport. 371 gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height); 372 373 // Bind to unit 0. 374 gl.activeTexture(GL_TEXTURE0); 375 gl.bindTexture(GL_TEXTURE_CUBE_MAP, m_texture->getGLTexture()); 376 377 // Setup nearest neighbor filtering and clamp-to-edge. 378 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 379 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 380 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 381 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 382 383 GLU_EXPECT_NO_ERROR(gl.getError(), "Set texturing state"); 384 385 m_renderer.renderQuad(0, &texCoord[0], renderParams); 386 glu::readPixels(m_renderCtx, viewport.x, viewport.y, renderedFrame.getAccess()); 387 GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels()"); 388 389 // Compute reference. 390 sampleTexture(SurfaceAccess(referenceFrame, m_renderCtx.getRenderTarget().getPixelFormat()), m_texture->getRefTexture(), &texCoord[0], renderParams); 391 392 // Compare and log. 393 return compareImages(log, referenceFrame, renderedFrame, threshold); 394 } 395 396 TextureCubeFormatCase::IterateResult TextureCubeFormatCase::iterate (void) 397 { 398 // Execute test for all faces. 399 if (!testFace((tcu::CubeFace)m_curFace)) 400 m_isOk = false; 401 402 m_curFace += 1; 403 404 if (m_curFace == tcu::CUBEFACE_LAST) 405 { 406 m_testCtx.setTestResult(m_isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL, 407 m_isOk ? "Pass" : "Image comparison failed"); 408 return STOP; 409 } 410 else 411 return CONTINUE; 412 } 413 414 // Texture2DArrayFormatCase 415 416 class Texture2DArrayFormatCase : public tcu::TestCase 417 { 418 public: 419 Texture2DArrayFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, deUint32 format, deUint32 dataType, int width, int height, int numLayers); 420 Texture2DArrayFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, deUint32 internalFormat, int width, int height, int numLayers); 421 ~Texture2DArrayFormatCase (void); 422 423 void init (void); 424 void deinit (void); 425 IterateResult iterate (void); 426 427 private: 428 Texture2DArrayFormatCase (const Texture2DArrayFormatCase& other); 429 Texture2DArrayFormatCase& operator= (const Texture2DArrayFormatCase& other); 430 431 bool testLayer (int layerNdx); 432 433 glu::RenderContext& m_renderCtx; 434 435 deUint32 m_format; 436 deUint32 m_dataType; 437 int m_width; 438 int m_height; 439 int m_numLayers; 440 441 glu::Texture2DArray* m_texture; 442 TextureTestUtil::TextureRenderer m_renderer; 443 444 int m_curLayer; 445 }; 446 447 Texture2DArrayFormatCase::Texture2DArrayFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, deUint32 format, deUint32 dataType, int width, int height, int numLayers) 448 : TestCase (testCtx, name, description) 449 , m_renderCtx (renderCtx) 450 , m_format (format) 451 , m_dataType (dataType) 452 , m_width (width) 453 , m_height (height) 454 , m_numLayers (numLayers) 455 , m_texture (DE_NULL) 456 , m_renderer (renderCtx, testCtx.getLog(), glu::GLSL_VERSION_300_ES, glu::PRECISION_HIGHP) 457 , m_curLayer (0) 458 { 459 } 460 461 Texture2DArrayFormatCase::Texture2DArrayFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, deUint32 internalFormat, int width, int height, int numLayers) 462 : TestCase (testCtx, name, description) 463 , m_renderCtx (renderCtx) 464 , m_format (internalFormat) 465 , m_dataType (GL_NONE) 466 , m_width (width) 467 , m_height (height) 468 , m_numLayers (numLayers) 469 , m_texture (DE_NULL) 470 , m_renderer (renderCtx, testCtx.getLog(), glu::GLSL_VERSION_300_ES, glu::PRECISION_HIGHP) 471 , m_curLayer (0) 472 { 473 } 474 475 Texture2DArrayFormatCase::~Texture2DArrayFormatCase (void) 476 { 477 deinit(); 478 } 479 480 void Texture2DArrayFormatCase::init (void) 481 { 482 m_texture = m_dataType != GL_NONE 483 ? new glu::Texture2DArray(m_renderCtx, m_format, m_dataType, m_width, m_height, m_numLayers) // Implicit internal format. 484 : new glu::Texture2DArray(m_renderCtx, m_format, m_width, m_height, m_numLayers); // Explicit internal format. 485 486 tcu::TextureFormatInfo spec = tcu::getTextureFormatInfo(m_texture->getRefTexture().getFormat()); 487 488 // Fill level 0. 489 m_texture->getRefTexture().allocLevel(0); 490 tcu::fillWithComponentGradients(m_texture->getRefTexture().getLevel(0), spec.valueMin, spec.valueMax); 491 492 // Initialize state. 493 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 494 m_curLayer = 0; 495 } 496 497 void Texture2DArrayFormatCase::deinit (void) 498 { 499 delete m_texture; 500 m_texture = DE_NULL; 501 502 m_renderer.clear(); 503 } 504 505 bool Texture2DArrayFormatCase::testLayer (int layerNdx) 506 { 507 const glw::Functions& gl = m_renderCtx.getFunctions(); 508 TestLog& log = m_testCtx.getLog(); 509 RandomViewport viewport (m_renderCtx.getRenderTarget(), m_width, m_height, deStringHash(getName())); 510 tcu::Surface renderedFrame (viewport.width, viewport.height); 511 tcu::Surface referenceFrame (viewport.width, viewport.height); 512 tcu::RGBA threshold = m_renderCtx.getRenderTarget().getPixelFormat().getColorThreshold() + tcu::RGBA(1,1,1,1); 513 vector<float> texCoord; 514 ReferenceParams renderParams (TEXTURETYPE_2D_ARRAY); 515 tcu::TextureFormatInfo spec = tcu::getTextureFormatInfo(m_texture->getRefTexture().getFormat()); 516 517 renderParams.samplerType = getSamplerType(m_texture->getRefTexture().getFormat()); 518 renderParams.sampler = Sampler(Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::NEAREST, Sampler::NEAREST); 519 renderParams.colorScale = spec.lookupScale; 520 renderParams.colorBias = spec.lookupBias; 521 522 computeQuadTexCoord2DArray(texCoord, layerNdx, tcu::Vec2(0.0f, 0.0f), tcu::Vec2(1.0f, 1.0f)); 523 524 // Setup base viewport. 525 gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height); 526 527 // Upload texture data to GL. 528 m_texture->upload(); 529 530 // Bind to unit 0. 531 gl.activeTexture(GL_TEXTURE0); 532 gl.bindTexture(GL_TEXTURE_2D_ARRAY, m_texture->getGLTexture()); 533 534 // Setup nearest neighbor filtering and clamp-to-edge. 535 gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 536 gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 537 gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 538 gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 539 540 GLU_EXPECT_NO_ERROR(gl.getError(), "Set texturing state"); 541 542 // Draw. 543 m_renderer.renderQuad(0, &texCoord[0], renderParams); 544 glu::readPixels(m_renderCtx, viewport.x, viewport.y, renderedFrame.getAccess()); 545 546 // Compute reference. 547 sampleTexture(SurfaceAccess(referenceFrame, m_renderCtx.getRenderTarget().getPixelFormat()), m_texture->getRefTexture(), &texCoord[0], renderParams); 548 549 // Compare and log. 550 return compareImages(log, (string("Layer" + de::toString(layerNdx))).c_str(), (string("Layer " + de::toString(layerNdx))).c_str(), referenceFrame, renderedFrame, threshold); 551 } 552 553 Texture2DArrayFormatCase::IterateResult Texture2DArrayFormatCase::iterate (void) 554 { 555 // Execute test for all layers. 556 bool isOk = testLayer(m_curLayer); 557 558 if (!isOk && m_testCtx.getTestResult() == QP_TEST_RESULT_PASS) 559 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image comparison failed"); 560 561 m_curLayer += 1; 562 563 return m_curLayer < m_texture->getRefTexture().getNumLayers() ? CONTINUE : STOP; 564 } 565 566 // Texture2DFormatCase 567 568 class Texture3DFormatCase : public tcu::TestCase 569 { 570 public: 571 Texture3DFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, deUint32 format, deUint32 dataType, int width, int height, int depth); 572 Texture3DFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, deUint32 internalFormat, int width, int height, int depth); 573 ~Texture3DFormatCase (void); 574 575 void init (void); 576 void deinit (void); 577 IterateResult iterate (void); 578 579 private: 580 Texture3DFormatCase (const Texture3DFormatCase& other); 581 Texture3DFormatCase& operator= (const Texture3DFormatCase& other); 582 583 bool testSlice (int sliceNdx); 584 585 glu::RenderContext& m_renderCtx; 586 587 deUint32 m_format; 588 deUint32 m_dataType; 589 int m_width; 590 int m_height; 591 int m_depth; 592 593 glu::Texture3D* m_texture; 594 TextureTestUtil::TextureRenderer m_renderer; 595 596 int m_curSlice; 597 }; 598 599 Texture3DFormatCase::Texture3DFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, deUint32 format, deUint32 dataType, int width, int height, int depth) 600 : TestCase (testCtx, name, description) 601 , m_renderCtx (renderCtx) 602 , m_format (format) 603 , m_dataType (dataType) 604 , m_width (width) 605 , m_height (height) 606 , m_depth (depth) 607 , m_texture (DE_NULL) 608 , m_renderer (renderCtx, testCtx.getLog(), glu::GLSL_VERSION_300_ES, glu::PRECISION_HIGHP) 609 , m_curSlice (0) 610 { 611 } 612 613 Texture3DFormatCase::Texture3DFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, deUint32 internalFormat, int width, int height, int depth) 614 : TestCase (testCtx, name, description) 615 , m_renderCtx (renderCtx) 616 , m_format (internalFormat) 617 , m_dataType (GL_NONE) 618 , m_width (width) 619 , m_height (height) 620 , m_depth (depth) 621 , m_texture (DE_NULL) 622 , m_renderer (renderCtx, testCtx.getLog(), glu::GLSL_VERSION_300_ES, glu::PRECISION_HIGHP) 623 , m_curSlice (0) 624 { 625 } 626 627 Texture3DFormatCase::~Texture3DFormatCase (void) 628 { 629 deinit(); 630 } 631 632 void Texture3DFormatCase::init (void) 633 { 634 m_texture = m_dataType != GL_NONE 635 ? new glu::Texture3D(m_renderCtx, m_format, m_dataType, m_width, m_height, m_depth) // Implicit internal format. 636 : new glu::Texture3D(m_renderCtx, m_format, m_width, m_height, m_depth); // Explicit internal format. 637 638 tcu::TextureFormatInfo spec = tcu::getTextureFormatInfo(m_texture->getRefTexture().getFormat()); 639 640 // Fill level 0. 641 m_texture->getRefTexture().allocLevel(0); 642 tcu::fillWithComponentGradients(m_texture->getRefTexture().getLevel(0), spec.valueMin, spec.valueMax); 643 644 // Initialize state. 645 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 646 m_curSlice = 0; 647 } 648 649 void Texture3DFormatCase::deinit (void) 650 { 651 delete m_texture; 652 m_texture = DE_NULL; 653 654 m_renderer.clear(); 655 } 656 657 bool Texture3DFormatCase::testSlice (int sliceNdx) 658 { 659 TestLog& log = m_testCtx.getLog(); 660 const glw::Functions& gl = m_renderCtx.getFunctions(); 661 RandomViewport viewport (m_renderCtx.getRenderTarget(), m_width, m_height, deStringHash(getName())); 662 tcu::Surface renderedFrame (viewport.width, viewport.height); 663 tcu::Surface referenceFrame (viewport.width, viewport.height); 664 tcu::RGBA threshold = m_renderCtx.getRenderTarget().getPixelFormat().getColorThreshold() + tcu::RGBA(1,1,1,1); 665 vector<float> texCoord; 666 ReferenceParams renderParams (TEXTURETYPE_3D); 667 tcu::TextureFormatInfo spec = tcu::getTextureFormatInfo(m_texture->getRefTexture().getFormat()); 668 float r = ((float)sliceNdx + 0.5f) / (float)m_depth; 669 670 renderParams.samplerType = getSamplerType(m_texture->getRefTexture().getFormat()); 671 renderParams.sampler = Sampler(Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::NEAREST, Sampler::NEAREST); 672 renderParams.colorScale = spec.lookupScale; 673 renderParams.colorBias = spec.lookupBias; 674 675 computeQuadTexCoord3D(texCoord, tcu::Vec3(0.0f, 0.0f, r), tcu::Vec3(1.0f, 1.0f, r), tcu::IVec3(0,1,2)); 676 677 // Setup base viewport. 678 gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height); 679 680 // Upload texture data to GL. 681 m_texture->upload(); 682 683 // Bind to unit 0. 684 gl.activeTexture(GL_TEXTURE0); 685 gl.bindTexture(GL_TEXTURE_3D, m_texture->getGLTexture()); 686 687 // Setup nearest neighbor filtering and clamp-to-edge. 688 gl.texParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 689 gl.texParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 690 gl.texParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 691 gl.texParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 692 693 GLU_EXPECT_NO_ERROR(gl.getError(), "Set texturing state"); 694 695 // Draw. 696 m_renderer.renderQuad(0, &texCoord[0], renderParams); 697 glu::readPixels(m_renderCtx, viewport.x, viewport.y, renderedFrame.getAccess()); 698 699 // Compute reference. 700 sampleTexture(SurfaceAccess(referenceFrame, m_renderCtx.getRenderTarget().getPixelFormat()), m_texture->getRefTexture(), &texCoord[0], renderParams); 701 702 // Compare and log. 703 return compareImages(log, (string("Slice" + de::toString(sliceNdx))).c_str(), (string("Slice " + de::toString(sliceNdx))).c_str(), referenceFrame, renderedFrame, threshold); 704 } 705 706 Texture3DFormatCase::IterateResult Texture3DFormatCase::iterate (void) 707 { 708 // Execute test for all slices. 709 bool isOk = testSlice(m_curSlice); 710 711 if (!isOk && m_testCtx.getTestResult() == QP_TEST_RESULT_PASS) 712 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image comparison failed"); 713 714 m_curSlice += 1; 715 716 return m_curSlice < m_texture->getRefTexture().getDepth() ? CONTINUE : STOP; 717 } 718 719 // Compressed2FormatCase 720 721 class Compressed2DFormatCase : public tcu::TestCase 722 { 723 public: 724 Compressed2DFormatCase (tcu::TestContext& testCtx, 725 glu::RenderContext& renderCtx, 726 const glu::ContextInfo& renderCtxInfo, 727 const char* name, 728 const char* description, 729 tcu::CompressedTexFormat format, 730 deUint32 randomSeed, 731 int width, 732 int height); 733 ~Compressed2DFormatCase (void); 734 735 void init (void); 736 void deinit (void); 737 IterateResult iterate (void); 738 739 private: 740 Compressed2DFormatCase (const Compressed2DFormatCase& other); 741 Compressed2DFormatCase& operator= (const Compressed2DFormatCase& other); 742 743 glu::RenderContext& m_renderCtx; 744 const glu::ContextInfo& m_renderCtxInfo; 745 746 tcu::CompressedTexFormat m_format; 747 748 deUint32 m_randomSeed; 749 int m_width; 750 int m_height; 751 752 glu::Texture2D* m_texture; 753 TextureTestUtil::TextureRenderer m_renderer; 754 }; 755 756 Compressed2DFormatCase::Compressed2DFormatCase (tcu::TestContext& testCtx, 757 glu::RenderContext& renderCtx, 758 const glu::ContextInfo& renderCtxInfo, 759 const char* name, 760 const char* description, 761 tcu::CompressedTexFormat format, 762 deUint32 randomSeed, 763 int width, 764 int height) 765 : TestCase (testCtx, name, description) 766 , m_renderCtx (renderCtx) 767 , m_renderCtxInfo (renderCtxInfo) 768 , m_format (format) 769 , m_randomSeed (randomSeed) 770 , m_width (width) 771 , m_height (height) 772 , m_texture (DE_NULL) 773 , m_renderer (renderCtx, testCtx.getLog(), glu::GLSL_VERSION_300_ES, glu::PRECISION_HIGHP) 774 { 775 } 776 777 Compressed2DFormatCase::~Compressed2DFormatCase (void) 778 { 779 deinit(); 780 } 781 782 void Compressed2DFormatCase::init (void) 783 { 784 // Create texture. 785 tcu::CompressedTexture compressedTexture (m_format, m_width, m_height); 786 int dataSize = compressedTexture.getDataSize(); 787 deUint8* data = (deUint8*)compressedTexture.getData(); 788 de::Random rnd (m_randomSeed); 789 790 for (int i = 0; i < dataSize; i++) 791 data[i] = rnd.getUint32() & 0xff; 792 793 m_texture = new glu::Texture2D(m_renderCtx, m_renderCtxInfo, 1, &compressedTexture); 794 } 795 796 void Compressed2DFormatCase::deinit (void) 797 { 798 delete m_texture; 799 m_texture = DE_NULL; 800 801 m_renderer.clear(); 802 } 803 804 Compressed2DFormatCase::IterateResult Compressed2DFormatCase::iterate (void) 805 { 806 const glw::Functions& gl = m_renderCtx.getFunctions(); 807 TestLog& log = m_testCtx.getLog(); 808 RandomViewport viewport (m_renderCtx.getRenderTarget(), m_texture->getRefTexture().getWidth(), m_texture->getRefTexture().getHeight(), deStringHash(getName())); 809 tcu::Surface renderedFrame (viewport.width, viewport.height); 810 tcu::Surface referenceFrame (viewport.width, viewport.height); 811 tcu::RGBA threshold = m_renderCtx.getRenderTarget().getPixelFormat().getColorThreshold() + tcu::RGBA(1,1,1,1); 812 vector<float> texCoord; 813 ReferenceParams renderParams (TEXTURETYPE_2D); 814 tcu::TextureFormatInfo spec = tcu::getTextureFormatInfo(m_texture->getRefTexture().getFormat()); 815 816 renderParams.samplerType = getSamplerType(m_texture->getRefTexture().getFormat()); 817 renderParams.sampler = Sampler(Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::NEAREST, Sampler::NEAREST); 818 renderParams.colorScale = spec.lookupScale; 819 renderParams.colorBias = spec.lookupBias; 820 821 computeQuadTexCoord2D(texCoord, tcu::Vec2(0.0f, 0.0f), tcu::Vec2(1.0f, 1.0f)); 822 823 // Setup base viewport. 824 gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height); 825 826 // Bind to unit 0. 827 gl.activeTexture(GL_TEXTURE0); 828 gl.bindTexture(GL_TEXTURE_2D, m_texture->getGLTexture()); 829 830 // Setup nearest neighbor filtering and clamp-to-edge. 831 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 832 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 833 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 834 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 835 836 GLU_EXPECT_NO_ERROR(gl.getError(), "Set texturing state"); 837 838 // Draw. 839 m_renderer.renderQuad(0, &texCoord[0], renderParams); 840 glu::readPixels(m_renderCtx, viewport.x, viewport.y, renderedFrame.getAccess()); 841 842 // Compute reference. 843 sampleTexture(SurfaceAccess(referenceFrame, m_renderCtx.getRenderTarget().getPixelFormat()), m_texture->getRefTexture(), &texCoord[0], renderParams); 844 845 // Compare and log. 846 bool isOk = compareImages(log, referenceFrame, renderedFrame, threshold); 847 848 m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL, 849 isOk ? "Pass" : "Image comparison failed"); 850 851 return STOP; 852 } 853 854 // CompressedCubeFormatCase 855 856 class CompressedCubeFormatCase : public tcu::TestCase 857 { 858 public: 859 CompressedCubeFormatCase (tcu::TestContext& testCtx, 860 glu::RenderContext& renderCtx, 861 const glu::ContextInfo& renderCtxInfo, 862 const char* name, 863 const char* description, 864 tcu::CompressedTexFormat format, 865 deUint32 randomSeed, 866 int width, 867 int height); 868 869 ~CompressedCubeFormatCase (void); 870 871 void init (void); 872 void deinit (void); 873 IterateResult iterate (void); 874 875 private: 876 CompressedCubeFormatCase (const CompressedCubeFormatCase& other); 877 CompressedCubeFormatCase& operator= (const CompressedCubeFormatCase& other); 878 879 bool testFace (tcu::CubeFace face); 880 881 glu::RenderContext& m_renderCtx; 882 const glu::ContextInfo& m_renderCtxInfo; 883 884 tcu::CompressedTexFormat m_format; 885 886 deUint32 m_randomSeed; 887 int m_width; 888 int m_height; 889 890 glu::TextureCube* m_texture; 891 TextureTestUtil::TextureRenderer m_renderer; 892 893 int m_curFace; 894 bool m_isOk; 895 }; 896 897 CompressedCubeFormatCase::CompressedCubeFormatCase (tcu::TestContext& testCtx, 898 glu::RenderContext& renderCtx, 899 const glu::ContextInfo& renderCtxInfo, 900 const char* name, 901 const char* description, 902 tcu::CompressedTexFormat format, 903 deUint32 randomSeed, 904 int width, 905 int height) 906 : TestCase (testCtx, name, description) 907 , m_renderCtx (renderCtx) 908 , m_renderCtxInfo (renderCtxInfo) 909 , m_format (format) 910 , m_randomSeed (randomSeed) 911 , m_width (width) 912 , m_height (height) 913 , m_texture (DE_NULL) 914 , m_renderer (renderCtx, testCtx.getLog(), glu::GLSL_VERSION_300_ES, glu::PRECISION_HIGHP) 915 , m_curFace (0) 916 , m_isOk (false) 917 { 918 } 919 920 CompressedCubeFormatCase::~CompressedCubeFormatCase (void) 921 { 922 deinit(); 923 } 924 925 void CompressedCubeFormatCase::init (void) 926 { 927 vector<tcu::CompressedTexture> levels (tcu::CUBEFACE_LAST); 928 de::Random rnd (m_randomSeed); 929 930 for (int face = 0; face < tcu::CUBEFACE_LAST; face++) 931 { 932 levels[face].setStorage(m_format, m_width, m_height); 933 934 int dataSize = levels[face].getDataSize(); 935 deUint8* data = (deUint8*)levels[face].getData(); 936 937 for (int i = 0; i < dataSize; i++) 938 data[i] = rnd.getUint32() & 0xff; 939 } 940 941 m_texture = new glu::TextureCube(m_renderCtx, m_renderCtxInfo, 1, &levels[0]); 942 943 m_curFace = 0; 944 m_isOk = true; 945 } 946 947 void CompressedCubeFormatCase::deinit (void) 948 { 949 delete m_texture; 950 m_texture = DE_NULL; 951 952 m_renderer.clear(); 953 } 954 955 bool CompressedCubeFormatCase::testFace (tcu::CubeFace face) 956 { 957 const glw::Functions& gl = m_renderCtx.getFunctions(); 958 TestLog& log = m_testCtx.getLog(); 959 RandomViewport viewport (m_renderCtx.getRenderTarget(), m_texture->getRefTexture().getSize(), m_texture->getRefTexture().getSize(), deStringHash(getName())+(deUint32)face); 960 tcu::Surface renderedFrame (viewport.width, viewport.height); 961 tcu::Surface referenceFrame (viewport.width, viewport.height); 962 tcu::RGBA threshold = m_renderCtx.getRenderTarget().getPixelFormat().getColorThreshold() + tcu::RGBA(1,1,1,1); 963 vector<float> texCoord; 964 ReferenceParams renderParams (TEXTURETYPE_CUBE); 965 tcu::TextureFormatInfo spec = tcu::getTextureFormatInfo(m_texture->getRefTexture().getFormat()); 966 967 renderParams.samplerType = getSamplerType(m_texture->getRefTexture().getFormat()); 968 renderParams.sampler = Sampler(Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::NEAREST, Sampler::NEAREST); 969 renderParams.sampler.seamlessCubeMap = true; 970 renderParams.colorScale = spec.lookupScale; 971 renderParams.colorBias = spec.lookupBias; 972 973 computeQuadTexCoordCube(texCoord, face); 974 975 log << TestLog::Message << face << TestLog::EndMessage; 976 977 // Setup base viewport. 978 gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height); 979 980 // Bind to unit 0. 981 gl.activeTexture(GL_TEXTURE0); 982 gl.bindTexture(GL_TEXTURE_CUBE_MAP, m_texture->getGLTexture()); 983 984 // Setup nearest neighbor filtering and clamp-to-edge. 985 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 986 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 987 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 988 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 989 990 GLU_EXPECT_NO_ERROR(gl.getError(), "Set texturing state"); 991 992 m_renderer.renderQuad(0, &texCoord[0], renderParams); 993 glu::readPixels(m_renderCtx, viewport.x, viewport.y, renderedFrame.getAccess()); 994 995 // Compute reference. 996 sampleTexture(SurfaceAccess(referenceFrame, m_renderCtx.getRenderTarget().getPixelFormat()), m_texture->getRefTexture(), &texCoord[0], renderParams); 997 998 // Compare and log. 999 return compareImages(log, referenceFrame, renderedFrame, threshold); 1000 } 1001 1002 CompressedCubeFormatCase::IterateResult CompressedCubeFormatCase::iterate (void) 1003 { 1004 // Execute test for all faces. 1005 if (!testFace((tcu::CubeFace)m_curFace)) 1006 m_isOk = false; 1007 1008 m_curFace += 1; 1009 1010 if (m_curFace == tcu::CUBEFACE_LAST) 1011 { 1012 m_testCtx.setTestResult(m_isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL, 1013 m_isOk ? "Pass" : "Image comparison failed"); 1014 return STOP; 1015 } 1016 else 1017 return CONTINUE; 1018 } 1019 1020 // Texture2DFileCase 1021 1022 class Texture2DFileCase : public tcu::TestCase 1023 { 1024 public: 1025 Texture2DFileCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const glu::ContextInfo& renderCtxInfo, const char* name, const char* description, const std::vector<std::string>& filenames); 1026 ~Texture2DFileCase (void); 1027 1028 void init (void); 1029 void deinit (void); 1030 IterateResult iterate (void); 1031 1032 private: 1033 Texture2DFileCase (const Texture2DFileCase& other); 1034 Texture2DFileCase& operator= (const Texture2DFileCase& other); 1035 1036 glu::RenderContext& m_renderCtx; 1037 const glu::ContextInfo& m_renderCtxInfo; 1038 1039 std::vector<std::string> m_filenames; 1040 1041 glu::Texture2D* m_texture; 1042 TextureRenderer m_renderer; 1043 }; 1044 1045 Texture2DFileCase::Texture2DFileCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const glu::ContextInfo& renderCtxInfo, const char* name, const char* description, const std::vector<std::string>& filenames) 1046 : TestCase (testCtx, name, description) 1047 , m_renderCtx (renderCtx) 1048 , m_renderCtxInfo (renderCtxInfo) 1049 , m_filenames (filenames) 1050 , m_texture (DE_NULL) 1051 , m_renderer (renderCtx, testCtx.getLog(), glu::GLSL_VERSION_300_ES, glu::PRECISION_HIGHP) 1052 { 1053 } 1054 1055 Texture2DFileCase::~Texture2DFileCase (void) 1056 { 1057 deinit(); 1058 } 1059 1060 void Texture2DFileCase::init (void) 1061 { 1062 // Create texture. 1063 m_texture = glu::Texture2D::create(m_renderCtx, m_renderCtxInfo, m_testCtx.getArchive(), (int)m_filenames.size(), m_filenames); 1064 } 1065 1066 void Texture2DFileCase::deinit (void) 1067 { 1068 delete m_texture; 1069 m_texture = DE_NULL; 1070 1071 m_renderer.clear(); 1072 } 1073 1074 Texture2DFileCase::IterateResult Texture2DFileCase::iterate (void) 1075 { 1076 const glw::Functions& gl = m_renderCtx.getFunctions(); 1077 TestLog& log = m_testCtx.getLog(); 1078 RandomViewport viewport (m_renderCtx.getRenderTarget(), m_texture->getRefTexture().getWidth(), m_texture->getRefTexture().getHeight(), deStringHash(getName())); 1079 tcu::Surface renderedFrame (viewport.width, viewport.height); 1080 tcu::Surface referenceFrame (viewport.width, viewport.height); 1081 tcu::RGBA threshold = m_renderCtx.getRenderTarget().getPixelFormat().getColorThreshold() + tcu::RGBA(1,1,1,1); 1082 vector<float> texCoord; 1083 1084 computeQuadTexCoord2D(texCoord, tcu::Vec2(0.0f, 0.0f), tcu::Vec2(1.0f, 1.0f)); 1085 1086 // Setup base viewport. 1087 gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height); 1088 1089 // Bind to unit 0. 1090 gl.activeTexture(GL_TEXTURE0); 1091 gl.bindTexture(GL_TEXTURE_2D, m_texture->getGLTexture()); 1092 1093 // Setup nearest neighbor filtering and clamp-to-edge. 1094 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 1095 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 1096 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 1097 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 1098 1099 GLU_EXPECT_NO_ERROR(gl.getError(), "Set texturing state"); 1100 1101 // Draw. 1102 m_renderer.renderQuad(0, &texCoord[0], TEXTURETYPE_2D); 1103 glu::readPixels(m_renderCtx, viewport.x, viewport.y, renderedFrame.getAccess()); 1104 GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels()"); 1105 1106 // Compute reference. 1107 ReferenceParams refParams(TEXTURETYPE_2D); 1108 refParams.sampler = Sampler(Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::NEAREST, Sampler::NEAREST); 1109 sampleTexture(SurfaceAccess(referenceFrame, m_renderCtx.getRenderTarget().getPixelFormat()), m_texture->getRefTexture(), &texCoord[0], refParams); 1110 1111 // Compare and log. 1112 bool isOk = compareImages(log, referenceFrame, renderedFrame, threshold); 1113 1114 m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL, 1115 isOk ? "Pass" : "Image comparison failed"); 1116 1117 return STOP; 1118 } 1119 1120 // TextureCubeFileCase 1121 1122 class TextureCubeFileCase : public tcu::TestCase 1123 { 1124 public: 1125 TextureCubeFileCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const glu::ContextInfo& renderCtxInfo, const char* name, const char* description, const std::vector<std::string>& filenames); 1126 ~TextureCubeFileCase (void); 1127 1128 void init (void); 1129 void deinit (void); 1130 IterateResult iterate (void); 1131 1132 private: 1133 TextureCubeFileCase (const TextureCubeFileCase& other); 1134 TextureCubeFileCase& operator= (const TextureCubeFileCase& other); 1135 1136 bool testFace (tcu::CubeFace face); 1137 1138 glu::RenderContext& m_renderCtx; 1139 const glu::ContextInfo& m_renderCtxInfo; 1140 1141 std::vector<std::string> m_filenames; 1142 1143 glu::TextureCube* m_texture; 1144 TextureRenderer m_renderer; 1145 1146 int m_curFace; 1147 bool m_isOk; 1148 }; 1149 1150 TextureCubeFileCase::TextureCubeFileCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const glu::ContextInfo& renderCtxInfo, const char* name, const char* description, const std::vector<std::string>& filenames) 1151 : TestCase (testCtx, name, description) 1152 , m_renderCtx (renderCtx) 1153 , m_renderCtxInfo (renderCtxInfo) 1154 , m_filenames (filenames) 1155 , m_texture (DE_NULL) 1156 , m_renderer (renderCtx, testCtx.getLog(), glu::GLSL_VERSION_300_ES, glu::PRECISION_HIGHP) 1157 , m_curFace (0) 1158 , m_isOk (false) 1159 { 1160 } 1161 1162 TextureCubeFileCase::~TextureCubeFileCase (void) 1163 { 1164 deinit(); 1165 } 1166 1167 void TextureCubeFileCase::init (void) 1168 { 1169 // Create texture. 1170 DE_ASSERT(m_filenames.size() % 6 == 0); 1171 m_texture = glu::TextureCube::create(m_renderCtx, m_renderCtxInfo, m_testCtx.getArchive(), (int)m_filenames.size()/6, m_filenames); 1172 1173 m_curFace = 0; 1174 m_isOk = true; 1175 } 1176 1177 void TextureCubeFileCase::deinit (void) 1178 { 1179 delete m_texture; 1180 m_texture = DE_NULL; 1181 1182 m_renderer.clear(); 1183 } 1184 1185 bool TextureCubeFileCase::testFace (tcu::CubeFace face) 1186 { 1187 const glw::Functions& gl = m_renderCtx.getFunctions(); 1188 TestLog& log = m_testCtx.getLog(); 1189 RandomViewport viewport (m_renderCtx.getRenderTarget(), m_texture->getRefTexture().getSize(), m_texture->getRefTexture().getSize(), deStringHash(getName())+(deUint32)face); 1190 tcu::Surface renderedFrame (viewport.width, viewport.height); 1191 tcu::Surface referenceFrame (viewport.width, viewport.height); 1192 Sampler sampler (Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::NEAREST, Sampler::NEAREST); 1193 tcu::RGBA threshold = m_renderCtx.getRenderTarget().getPixelFormat().getColorThreshold() + tcu::RGBA(1,1,1,1); 1194 vector<float> texCoord; 1195 1196 computeQuadTexCoordCube(texCoord, face); 1197 1198 // \todo [2011-10-28 pyry] Image set name / section? 1199 log << TestLog::Message << face << TestLog::EndMessage; 1200 1201 // Setup base viewport. 1202 gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height); 1203 1204 // Bind to unit 0. 1205 gl.activeTexture(GL_TEXTURE0); 1206 gl.bindTexture(GL_TEXTURE_CUBE_MAP, m_texture->getGLTexture()); 1207 1208 // Setup nearest neighbor filtering and clamp-to-edge. 1209 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 1210 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 1211 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 1212 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 1213 1214 GLU_EXPECT_NO_ERROR(gl.getError(), "Set texturing state"); 1215 1216 m_renderer.renderQuad(0, &texCoord[0], TEXTURETYPE_CUBE); 1217 glu::readPixels(m_renderCtx, viewport.x, viewport.y, renderedFrame.getAccess()); 1218 GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels()"); 1219 1220 // Compute reference. 1221 sampleTexture(SurfaceAccess(referenceFrame, m_renderCtx.getRenderTarget().getPixelFormat()), m_texture->getRefTexture(), &texCoord[0], ReferenceParams(TEXTURETYPE_CUBE, sampler)); 1222 1223 // Compare and log. 1224 return compareImages(log, referenceFrame, renderedFrame, threshold); 1225 } 1226 1227 TextureCubeFileCase::IterateResult TextureCubeFileCase::iterate (void) 1228 { 1229 // Execute test for all faces. 1230 if (!testFace((tcu::CubeFace)m_curFace)) 1231 m_isOk = false; 1232 1233 m_curFace += 1; 1234 1235 if (m_curFace == tcu::CUBEFACE_LAST) 1236 { 1237 m_testCtx.setTestResult(m_isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL, 1238 m_isOk ? "Pass" : "Image comparison failed"); 1239 return STOP; 1240 } 1241 else 1242 return CONTINUE; 1243 } 1244 1245 // TextureFormatTests 1246 1247 TextureFormatTests::TextureFormatTests (Context& context) 1248 : TestCaseGroup(context, "format", "Texture Format Tests") 1249 { 1250 } 1251 1252 TextureFormatTests::~TextureFormatTests (void) 1253 { 1254 } 1255 1256 vector<string> toStringVector (const char* const* str, int numStr) 1257 { 1258 vector<string> v; 1259 v.resize(numStr); 1260 for (int i = 0; i < numStr; i++) 1261 v[i] = str[i]; 1262 return v; 1263 } 1264 1265 void TextureFormatTests::init (void) 1266 { 1267 tcu::TestCaseGroup* unsizedGroup = DE_NULL; 1268 tcu::TestCaseGroup* sizedGroup = DE_NULL; 1269 tcu::TestCaseGroup* compressedGroup = DE_NULL; 1270 addChild((unsizedGroup = new tcu::TestCaseGroup(m_testCtx, "unsized", "Unsized formats"))); 1271 addChild((sizedGroup = new tcu::TestCaseGroup(m_testCtx, "sized", "Sized formats"))); 1272 addChild((compressedGroup = new tcu::TestCaseGroup(m_testCtx, "compressed", "Compressed formats"))); 1273 1274 tcu::TestCaseGroup* sized2DGroup = DE_NULL; 1275 tcu::TestCaseGroup* sizedCubeGroup = DE_NULL; 1276 tcu::TestCaseGroup* sized2DArrayGroup = DE_NULL; 1277 tcu::TestCaseGroup* sized3DGroup = DE_NULL; 1278 sizedGroup->addChild((sized2DGroup = new tcu::TestCaseGroup(m_testCtx, "2d", "Sized formats (2D)"))); 1279 sizedGroup->addChild((sizedCubeGroup = new tcu::TestCaseGroup(m_testCtx, "cube", "Sized formats (Cubemap)"))); 1280 sizedGroup->addChild((sized2DArrayGroup = new tcu::TestCaseGroup(m_testCtx, "2d_array", "Sized formats (2D Array)"))); 1281 sizedGroup->addChild((sized3DGroup = new tcu::TestCaseGroup(m_testCtx, "3d", "Sized formats (3D)"))); 1282 1283 struct 1284 { 1285 const char* name; 1286 deUint32 format; 1287 deUint32 dataType; 1288 } texFormats[] = 1289 { 1290 { "alpha", GL_ALPHA, GL_UNSIGNED_BYTE }, 1291 { "luminance", GL_LUMINANCE, GL_UNSIGNED_BYTE }, 1292 { "luminance_alpha", GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE }, 1293 { "rgb_unsigned_short_5_6_5", GL_RGB, GL_UNSIGNED_SHORT_5_6_5 }, 1294 { "rgb_unsigned_byte", GL_RGB, GL_UNSIGNED_BYTE }, 1295 { "rgba_unsigned_short_4_4_4_4", GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4 }, 1296 { "rgba_unsigned_short_5_5_5_1", GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1 }, 1297 { "rgba_unsigned_byte", GL_RGBA, GL_UNSIGNED_BYTE } 1298 }; 1299 1300 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(texFormats); formatNdx++) 1301 { 1302 deUint32 format = texFormats[formatNdx].format; 1303 deUint32 dataType = texFormats[formatNdx].dataType; 1304 string nameBase = texFormats[formatNdx].name; 1305 string descriptionBase = string(glu::getTextureFormatName(format)) + ", " + glu::getTypeName(dataType); 1306 1307 unsizedGroup->addChild(new Texture2DFormatCase (m_testCtx, m_context.getRenderContext(), (nameBase + "_2d_pot").c_str(), (descriptionBase + ", GL_TEXTURE_2D").c_str(), format, dataType, 128, 128)); 1308 unsizedGroup->addChild(new Texture2DFormatCase (m_testCtx, m_context.getRenderContext(), (nameBase + "_2d_npot").c_str(), (descriptionBase + ", GL_TEXTURE_2D").c_str(), format, dataType, 63, 112)); 1309 unsizedGroup->addChild(new TextureCubeFormatCase (m_testCtx, m_context.getRenderContext(), (nameBase + "_cube_pot").c_str(), (descriptionBase + ", GL_TEXTURE_CUBE_MAP").c_str(), format, dataType, 64, 64)); 1310 unsizedGroup->addChild(new TextureCubeFormatCase (m_testCtx, m_context.getRenderContext(), (nameBase + "_cube_npot").c_str(), (descriptionBase + ", GL_TEXTURE_CUBE_MAP").c_str(), format, dataType, 57, 57)); 1311 unsizedGroup->addChild(new Texture2DArrayFormatCase (m_testCtx, m_context.getRenderContext(), (nameBase + "_2d_array_pot").c_str(), (descriptionBase + ", GL_TEXTURE_2D_ARRAY").c_str(), format, dataType, 64, 64, 8)); 1312 unsizedGroup->addChild(new Texture2DArrayFormatCase (m_testCtx, m_context.getRenderContext(), (nameBase + "_2d_array_npot").c_str(), (descriptionBase + ", GL_TEXTURE_2D_ARRAY").c_str(), format, dataType, 63, 57, 7)); 1313 unsizedGroup->addChild(new Texture3DFormatCase (m_testCtx, m_context.getRenderContext(), (nameBase + "_3d_pot").c_str(), (descriptionBase + ", GL_TEXTURE_3D").c_str(), format, dataType, 8, 32, 16)); 1314 unsizedGroup->addChild(new Texture3DFormatCase (m_testCtx, m_context.getRenderContext(), (nameBase + "_3d_npot").c_str(), (descriptionBase + ", GL_TEXTURE_3D").c_str(), format, dataType, 11, 31, 7)); 1315 } 1316 1317 struct 1318 { 1319 const char* name; 1320 deUint32 internalFormat; 1321 } sizedColorFormats[] = 1322 { 1323 { "rgba32f", GL_RGBA32F, }, 1324 { "rgba32i", GL_RGBA32I, }, 1325 { "rgba32ui", GL_RGBA32UI, }, 1326 { "rgba16f", GL_RGBA16F, }, 1327 { "rgba16i", GL_RGBA16I, }, 1328 { "rgba16ui", GL_RGBA16UI, }, 1329 { "rgba8", GL_RGBA8, }, 1330 { "rgba8i", GL_RGBA8I, }, 1331 { "rgba8ui", GL_RGBA8UI, }, 1332 { "srgb8_alpha8", GL_SRGB8_ALPHA8, }, 1333 { "rgb10_a2", GL_RGB10_A2, }, 1334 { "rgb10_a2ui", GL_RGB10_A2UI, }, 1335 { "rgba4", GL_RGBA4, }, 1336 { "rgb5_a1", GL_RGB5_A1, }, 1337 { "rgba8_snorm", GL_RGBA8_SNORM, }, 1338 { "rgb8", GL_RGB8, }, 1339 { "rgb565", GL_RGB565, }, 1340 { "r11f_g11f_b10f", GL_R11F_G11F_B10F, }, 1341 { "rgb32f", GL_RGB32F, }, 1342 { "rgb32i", GL_RGB32I, }, 1343 { "rgb32ui", GL_RGB32UI, }, 1344 { "rgb16f", GL_RGB16F, }, 1345 { "rgb16i", GL_RGB16I, }, 1346 { "rgb16ui", GL_RGB16UI, }, 1347 { "rgb8_snorm", GL_RGB8_SNORM, }, 1348 { "rgb8i", GL_RGB8I, }, 1349 { "rgb8ui", GL_RGB8UI, }, 1350 { "srgb8", GL_SRGB8, }, 1351 { "rgb9_e5", GL_RGB9_E5, }, 1352 { "rg32f", GL_RG32F, }, 1353 { "rg32i", GL_RG32I, }, 1354 { "rg32ui", GL_RG32UI, }, 1355 { "rg16f", GL_RG16F, }, 1356 { "rg16i", GL_RG16I, }, 1357 { "rg16ui", GL_RG16UI, }, 1358 { "rg8", GL_RG8, }, 1359 { "rg8i", GL_RG8I, }, 1360 { "rg8ui", GL_RG8UI, }, 1361 { "rg8_snorm", GL_RG8_SNORM, }, 1362 { "r32f", GL_R32F, }, 1363 { "r32i", GL_R32I, }, 1364 { "r32ui", GL_R32UI, }, 1365 { "r16f", GL_R16F, }, 1366 { "r16i", GL_R16I, }, 1367 { "r16ui", GL_R16UI, }, 1368 { "r8", GL_R8, }, 1369 { "r8i", GL_R8I, }, 1370 { "r8ui", GL_R8UI, }, 1371 { "r8_snorm", GL_R8_SNORM, } 1372 }; 1373 1374 struct 1375 { 1376 const char* name; 1377 deUint32 internalFormat; 1378 } sizedDepthStencilFormats[] = 1379 { 1380 // Depth and stencil formats 1381 { "depth_component32f", GL_DEPTH_COMPONENT32F }, 1382 { "depth_component24", GL_DEPTH_COMPONENT24 }, 1383 { "depth_component16", GL_DEPTH_COMPONENT16 }, 1384 { "depth32f_stencil8", GL_DEPTH32F_STENCIL8 }, 1385 { "depth24_stencil8", GL_DEPTH24_STENCIL8 } 1386 }; 1387 1388 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(sizedColorFormats); formatNdx++) 1389 { 1390 deUint32 internalFormat = sizedColorFormats[formatNdx].internalFormat; 1391 string nameBase = sizedColorFormats[formatNdx].name; 1392 string descriptionBase = glu::getTextureFormatName(internalFormat); 1393 1394 sized2DGroup->addChild (new Texture2DFormatCase (m_testCtx, m_context.getRenderContext(), (nameBase + "_pot").c_str(), (descriptionBase + ", GL_TEXTURE_2D").c_str(), internalFormat, 128, 128)); 1395 sized2DGroup->addChild (new Texture2DFormatCase (m_testCtx, m_context.getRenderContext(), (nameBase + "_npot").c_str(), (descriptionBase + ", GL_TEXTURE_2D").c_str(), internalFormat, 63, 112)); 1396 sizedCubeGroup->addChild (new TextureCubeFormatCase (m_testCtx, m_context.getRenderContext(), (nameBase + "_pot").c_str(), (descriptionBase + ", GL_TEXTURE_CUBE_MAP").c_str(), internalFormat, 64, 64)); 1397 sizedCubeGroup->addChild (new TextureCubeFormatCase (m_testCtx, m_context.getRenderContext(), (nameBase + "_npot").c_str(), (descriptionBase + ", GL_TEXTURE_CUBE_MAP").c_str(), internalFormat, 57, 57)); 1398 sized2DArrayGroup->addChild (new Texture2DArrayFormatCase (m_testCtx, m_context.getRenderContext(), (nameBase + "_pot").c_str(), (descriptionBase + ", GL_TEXTURE_2D_ARRAY").c_str(), internalFormat, 64, 64, 8)); 1399 sized2DArrayGroup->addChild (new Texture2DArrayFormatCase (m_testCtx, m_context.getRenderContext(), (nameBase + "_npot").c_str(), (descriptionBase + ", GL_TEXTURE_2D_ARRAY").c_str(), internalFormat, 63, 57, 7)); 1400 sized3DGroup->addChild (new Texture3DFormatCase (m_testCtx, m_context.getRenderContext(), (nameBase + "_pot").c_str(), (descriptionBase + ", GL_TEXTURE_3D").c_str(), internalFormat, 8, 32, 16)); 1401 sized3DGroup->addChild (new Texture3DFormatCase (m_testCtx, m_context.getRenderContext(), (nameBase + "_npot").c_str(), (descriptionBase + ", GL_TEXTURE_3D").c_str(), internalFormat, 11, 31, 7)); 1402 } 1403 1404 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(sizedDepthStencilFormats); formatNdx++) 1405 { 1406 deUint32 internalFormat = sizedDepthStencilFormats[formatNdx].internalFormat; 1407 string nameBase = sizedDepthStencilFormats[formatNdx].name; 1408 string descriptionBase = glu::getTextureFormatName(internalFormat); 1409 1410 sized2DGroup->addChild (new Texture2DFormatCase (m_testCtx, m_context.getRenderContext(), (nameBase + "_pot").c_str(), (descriptionBase + ", GL_TEXTURE_2D").c_str(), internalFormat, 128, 128)); 1411 sized2DGroup->addChild (new Texture2DFormatCase (m_testCtx, m_context.getRenderContext(), (nameBase + "_npot").c_str(), (descriptionBase + ", GL_TEXTURE_2D").c_str(), internalFormat, 63, 112)); 1412 sizedCubeGroup->addChild (new TextureCubeFormatCase (m_testCtx, m_context.getRenderContext(), (nameBase + "_pot").c_str(), (descriptionBase + ", GL_TEXTURE_CUBE_MAP").c_str(), internalFormat, 64, 64)); 1413 sizedCubeGroup->addChild (new TextureCubeFormatCase (m_testCtx, m_context.getRenderContext(), (nameBase + "_npot").c_str(), (descriptionBase + ", GL_TEXTURE_CUBE_MAP").c_str(), internalFormat, 57, 57)); 1414 sized2DArrayGroup->addChild (new Texture2DArrayFormatCase (m_testCtx, m_context.getRenderContext(), (nameBase + "_pot").c_str(), (descriptionBase + ", GL_TEXTURE_2D_ARRAY").c_str(), internalFormat, 64, 64, 8)); 1415 sized2DArrayGroup->addChild (new Texture2DArrayFormatCase (m_testCtx, m_context.getRenderContext(), (nameBase + "_npot").c_str(), (descriptionBase + ", GL_TEXTURE_2D_ARRAY").c_str(), internalFormat, 63, 57, 7)); 1416 } 1417 1418 // ETC-1 compressed formats. 1419 { 1420 static const char* filenames[] = 1421 { 1422 "data/etc1/photo_helsinki_mip_0.pkm", 1423 "data/etc1/photo_helsinki_mip_1.pkm", 1424 "data/etc1/photo_helsinki_mip_2.pkm", 1425 "data/etc1/photo_helsinki_mip_3.pkm", 1426 "data/etc1/photo_helsinki_mip_4.pkm", 1427 "data/etc1/photo_helsinki_mip_5.pkm", 1428 "data/etc1/photo_helsinki_mip_6.pkm", 1429 "data/etc1/photo_helsinki_mip_7.pkm" 1430 }; 1431 compressedGroup->addChild(new Texture2DFileCase(m_testCtx, m_context.getRenderContext(), m_context.getContextInfo(), "etc1_2d_pot", "GL_ETC1_RGB8_OES, GL_TEXTURE_2D", toStringVector(filenames, DE_LENGTH_OF_ARRAY(filenames)))); 1432 } 1433 1434 { 1435 vector<string> filenames; 1436 filenames.push_back("data/etc1/photo_helsinki_113x89.pkm"); 1437 compressedGroup->addChild(new Texture2DFileCase(m_testCtx, m_context.getRenderContext(), m_context.getContextInfo(), "etc1_2d_npot", "GL_ETC1_RGB8_OES, GL_TEXTURE_2D", filenames)); 1438 } 1439 1440 { 1441 static const char* faceExt[] = { "neg_x", "pos_x", "neg_y", "pos_y", "neg_z", "pos_z" }; 1442 1443 const int potNumLevels = 7; 1444 vector<string> potFilenames; 1445 for (int level = 0; level < potNumLevels; level++) 1446 for (int face = 0; face < tcu::CUBEFACE_LAST; face++) 1447 potFilenames.push_back(string("data/etc1/skybox_") + faceExt[face] + "_mip_" + de::toString(level) + ".pkm"); 1448 1449 compressedGroup->addChild(new TextureCubeFileCase(m_testCtx, m_context.getRenderContext(), m_context.getContextInfo(), "etc1_cube_pot", "GL_ETC1_RGB8_OES, GL_TEXTURE_CUBE_MAP", potFilenames)); 1450 1451 vector<string> npotFilenames; 1452 for (int face = 0; face < tcu::CUBEFACE_LAST; face++) 1453 npotFilenames.push_back(string("data/etc1/skybox_61x61_") + faceExt[face] + ".pkm"); 1454 1455 compressedGroup->addChild(new TextureCubeFileCase(m_testCtx, m_context.getRenderContext(), m_context.getContextInfo(), "etc1_cube_npot", "GL_ETC_RGB8_OES, GL_TEXTURE_CUBE_MAP", npotFilenames)); 1456 } 1457 1458 // ETC-2 and EAC compressed formats. 1459 struct { 1460 const char* descriptionBase; 1461 const char* nameBase; 1462 tcu::CompressedTexFormat format; 1463 } etc2Formats[] = 1464 { 1465 { "GL_COMPRESSED_R11_EAC", "eac_r11", tcu::COMPRESSEDTEXFORMAT_EAC_R11, }, 1466 { "GL_COMPRESSED_SIGNED_R11_EAC", "eac_signed_r11", tcu::COMPRESSEDTEXFORMAT_EAC_SIGNED_R11, }, 1467 { "GL_COMPRESSED_RG11_EAC", "eac_rg11", tcu::COMPRESSEDTEXFORMAT_EAC_RG11, }, 1468 { "GL_COMPRESSED_SIGNED_RG11_EAC", "eac_signed_rg11", tcu::COMPRESSEDTEXFORMAT_EAC_SIGNED_RG11, }, 1469 { "GL_COMPRESSED_RGB8_ETC2", "etc2_rgb8", tcu::COMPRESSEDTEXFORMAT_ETC2_RGB8, }, 1470 { "GL_COMPRESSED_SRGB8_ETC2", "etc2_srgb8", tcu::COMPRESSEDTEXFORMAT_ETC2_SRGB8, }, 1471 { "GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2", "etc2_rgb8_punchthrough_alpha1", tcu::COMPRESSEDTEXFORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1, }, 1472 { "GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2", "etc2_srgb8_punchthrough_alpha1", tcu::COMPRESSEDTEXFORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1, }, 1473 { "GL_COMPRESSED_RGBA8_ETC2_EAC", "etc2_eac_rgba8", tcu::COMPRESSEDTEXFORMAT_ETC2_EAC_RGBA8, }, 1474 { "GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC", "etc2_eac_srgb8_alpha8", tcu::COMPRESSEDTEXFORMAT_ETC2_EAC_SRGB8_ALPHA8, } 1475 }; 1476 1477 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(etc2Formats); formatNdx++) 1478 { 1479 string descriptionBase = etc2Formats[formatNdx].descriptionBase; 1480 string nameBase = etc2Formats[formatNdx].nameBase; 1481 1482 compressedGroup->addChild(new Compressed2DFormatCase (m_testCtx, m_context.getRenderContext(), m_context.getContextInfo(), (nameBase + "_2d_pot").c_str(), (descriptionBase + ", GL_TEXTURE_2D").c_str(), etc2Formats[formatNdx].format, 1, 128, 64)); 1483 compressedGroup->addChild(new CompressedCubeFormatCase (m_testCtx, m_context.getRenderContext(), m_context.getContextInfo(), (nameBase + "_cube_pot").c_str(), (descriptionBase + ", GL_TEXTURE_CUBE_MAP").c_str(), etc2Formats[formatNdx].format, 1, 64, 64)); 1484 compressedGroup->addChild(new Compressed2DFormatCase (m_testCtx, m_context.getRenderContext(), m_context.getContextInfo(), (nameBase + "_2d_npot").c_str(), (descriptionBase + ", GL_TEXTURE_2D").c_str(), etc2Formats[formatNdx].format, 1, 51, 65)); 1485 compressedGroup->addChild(new CompressedCubeFormatCase (m_testCtx, m_context.getRenderContext(), m_context.getContextInfo(), (nameBase + "_cube_npot").c_str(), (descriptionBase + ", GL_TEXTURE_CUBE_MAP").c_str(), etc2Formats[formatNdx].format, 1, 51, 51)); 1486 } 1487 1488 1489 } 1490 1491 } // Functional 1492 } // gles3 1493 } // deqp 1494
