modules/gles2/functional/es2fTextureFormatTests.cpp

   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 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 "es2fTextureFormatTests.hpp"
  37 #include "glsTextureTestUtil.hpp"
  38 #include "gluTexture.hpp"
  39 #include "gluStrUtil.hpp"
  40 #include "gluTextureUtil.hpp"
  41 #include "gluPixelTransfer.hpp"
  42 #include "tcuSurfaceAccess.hpp"
  43 #include "tcuTestLog.hpp"
  44 #include "tcuTextureUtil.hpp"
  45
  46 #include "deStringUtil.hpp"
  47
  48 #include "glwEnums.hpp"
  49 #include "glwFunctions.hpp"
  50
  51 namespace deqp
  52 {
  53 namespace gles2
  54 {
  55 namespace Functional
  56 {
  57
  58 using tcu::TestLog;
  59 using std::vector;
  60 using std::string;
  61 using tcu::Sampler;
  62 using namespace glu;
  63 using namespace gls::TextureTestUtil;
  64 using namespace glu::TextureTestUtil;
  65
  66 // Texture2DFormatCase
  67
  68 class Texture2DFormatCase : public tcu::TestCase
  69 {
  70 public:
  71                                                         Texture2DFormatCase             (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, deUint32 format, deUint32 dataType, int width, int height);
  72                                                         ~Texture2DFormatCase    (void);
  73
  74         void                                    init                                    (void);
  75         void                                    deinit                                  (void);
  76         IterateResult                   iterate                                 (void);
  77
  78 private:
  79                                                         Texture2DFormatCase             (const Texture2DFormatCase& other);
  80         Texture2DFormatCase&    operator=                               (const Texture2DFormatCase& other);
  81
  82         glu::RenderContext&             m_renderCtx;
  83
  84         const deUint32                  m_format;
  85         const deUint32                  m_dataType;
  86         const int                               m_width;
  87         const int                               m_height;
  88
  89         glu::Texture2D*                 m_texture;
  90         TextureRenderer                 m_renderer;
  91 };
  92
  93 Texture2DFormatCase::Texture2DFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, deUint32 format, deUint32 dataType, int width, int height)
  94         : TestCase              (testCtx, name, description)
  95         , m_renderCtx   (renderCtx)
  96         , m_format              (format)
  97         , m_dataType    (dataType)
  98         , m_width               (width)
  99         , m_height              (height)
 100         , m_texture             (DE_NULL)
 101         , m_renderer    (renderCtx, testCtx.getLog(), glu::GLSL_VERSION_100_ES, glu::PRECISION_MEDIUMP)
 102 {
 103 }
 104
 105 Texture2DFormatCase::~Texture2DFormatCase (void)
 106 {
 107         deinit();
 108 }
 109
 110 void Texture2DFormatCase::init (void)
 111 {
 112         TestLog&                                log             = m_testCtx.getLog();
 113         tcu::TextureFormat              fmt             = glu::mapGLTransferFormat(m_format, m_dataType);
 114         tcu::TextureFormatInfo  spec    = tcu::getTextureFormatInfo(fmt);
 115         std::ostringstream              fmtName;
 116
 117         fmtName << getTextureFormatStr(m_format) << ", " << getTypeStr(m_dataType);
 118
 119         log << TestLog::Message << "2D texture, " << fmtName.str() << ", " << m_width << "x" << m_height
 120                                                         << ",\n  fill with " << formatGradient(&spec.valueMin, &spec.valueMax) << " gradient"
 121                 << TestLog::EndMessage;
 122
 123         m_texture = new Texture2D(m_renderCtx, m_format, m_dataType, m_width, m_height);
 124
 125         // Fill level 0.
 126         m_texture->getRefTexture().allocLevel(0);
 127         tcu::fillWithComponentGradients(m_texture->getRefTexture().getLevel(0), spec.valueMin, spec.valueMax);
 128 }
 129
 130 void Texture2DFormatCase::deinit (void)
 131 {
 132         delete m_texture;
 133         m_texture = DE_NULL;
 134
 135         m_renderer.clear();
 136 }
 137
 138 Texture2DFormatCase::IterateResult Texture2DFormatCase::iterate (void)
 139 {
 140         TestLog&                                log                                     = m_testCtx.getLog();
 141         const glw::Functions&   gl                                      = m_renderCtx.getFunctions();
 142         RandomViewport                  viewport                        (m_renderCtx.getRenderTarget(), m_width, m_height, deStringHash(getName()));
 143         tcu::Surface                    renderedFrame           (viewport.width, viewport.height);
 144         tcu::Surface                    referenceFrame          (viewport.width, viewport.height);
 145         tcu::RGBA                               threshold                       = m_renderCtx.getRenderTarget().getPixelFormat().getColorThreshold() + tcu::RGBA(1,1,1,1);
 146         vector<float>                   texCoord;
 147         ReferenceParams                 renderParams            (TEXTURETYPE_2D);
 148         tcu::TextureFormatInfo  spec                            = tcu::getTextureFormatInfo(m_texture->getRefTexture().getFormat());
 149         const deUint32                  wrapS                           = GL_CLAMP_TO_EDGE;
 150         const deUint32                  wrapT                           = GL_CLAMP_TO_EDGE;
 151         const deUint32                  minFilter                       = GL_NEAREST;
 152         const deUint32                  magFilter                       = GL_NEAREST;
 153
 154         renderParams.flags                      |= RenderParams::LOG_ALL;
 155         renderParams.samplerType        = getSamplerType(m_texture->getRefTexture().getFormat());
 156         renderParams.sampler            = Sampler(Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::NEAREST, Sampler::NEAREST);
 157         renderParams.colorScale         = spec.lookupScale;
 158         renderParams.colorBias          = spec.lookupBias;
 159
 160         computeQuadTexCoord2D(texCoord, tcu::Vec2(0.0f, 0.0f), tcu::Vec2(1.0f, 1.0f));
 161
 162         log << TestLog::Message << "Texture parameters:"
 163                                                         << "\n  WRAP_S = " << getTextureParameterValueStr(GL_TEXTURE_WRAP_S, wrapS)
 164                                                         << "\n  WRAP_T = " << getTextureParameterValueStr(GL_TEXTURE_WRAP_T, wrapT)
 165                                                         << "\n  MIN_FILTER = " << getTextureParameterValueStr(GL_TEXTURE_MIN_FILTER, minFilter)
 166                                                         << "\n  MAG_FILTER = " << getTextureParameterValueStr(GL_TEXTURE_MAG_FILTER, magFilter)
 167                 << TestLog::EndMessage;
 168
 169         // Setup base viewport.
 170         gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height);
 171
 172         // Upload texture data to GL.
 173         m_texture->upload();
 174
 175         // Bind to unit 0.
 176         gl.activeTexture(GL_TEXTURE0);
 177         gl.bindTexture(GL_TEXTURE_2D, m_texture->getGLTexture());
 178
 179         // Setup nearest neighbor filtering and clamp-to-edge.
 180         gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrapS);
 181         gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrapT);
 182         gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, minFilter);
 183         gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, magFilter);
 184
 185         GLU_EXPECT_NO_ERROR(gl.getError(), "Set texturing state");
 186
 187         // Draw.
 188         m_renderer.renderQuad(0, &texCoord[0], renderParams);
 189         glu::readPixels(m_renderCtx, viewport.x, viewport.y, renderedFrame.getAccess());
 190         GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels()");
 191
 192         // Compute reference.
 193         sampleTexture(tcu::SurfaceAccess(referenceFrame, m_renderCtx.getRenderTarget().getPixelFormat()), m_texture->getRefTexture(), &texCoord[0], renderParams);
 194
 195         // Compare and log.
 196         bool isOk = compareImages(log, referenceFrame, renderedFrame, threshold);
 197
 198         m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS      : QP_TEST_RESULT_FAIL,
 199                                                         isOk ? "Pass"                           : "Image comparison failed");
 200
 201         return STOP;
 202 }
 203
 204 // TextureCubeFormatCase
 205
 206 class TextureCubeFormatCase : public tcu::TestCase
 207 {
 208 public:
 209                                                         TextureCubeFormatCase   (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, deUint32 format, deUint32 dataType, int width, int height);
 210                                                         ~TextureCubeFormatCase  (void);
 211
 212         void                                    init                                    (void);
 213         void                                    deinit                                  (void);
 214         IterateResult                   iterate                                 (void);
 215
 216 private:
 217                                                         TextureCubeFormatCase   (const TextureCubeFormatCase& other);
 218         TextureCubeFormatCase&  operator=                               (const TextureCubeFormatCase& other);
 219
 220         bool                                    testFace                                (tcu::CubeFace face);
 221
 222         glu::RenderContext&             m_renderCtx;
 223
 224         const deUint32                  m_format;
 225         const deUint32                  m_dataType;
 226         const int                               m_width;
 227         const int                               m_height;
 228
 229         glu::TextureCube*               m_texture;
 230         TextureRenderer                 m_renderer;
 231
 232         int                                             m_curFace;
 233         bool                                    m_isOk;
 234 };
 235
 236
 237 TextureCubeFormatCase::TextureCubeFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, deUint32 format, deUint32 dataType, int width, int height)
 238         : TestCase              (testCtx, name, description)
 239         , m_renderCtx   (renderCtx)
 240         , m_format              (format)
 241         , m_dataType    (dataType)
 242         , m_width               (width)
 243         , m_height              (height)
 244         , m_texture             (DE_NULL)
 245         , m_renderer    (renderCtx, testCtx.getLog(), glu::GLSL_VERSION_100_ES, glu::PRECISION_MEDIUMP)
 246         , m_curFace             (0)
 247         , m_isOk                (false)
 248 {
 249 }
 250
 251 TextureCubeFormatCase::~TextureCubeFormatCase (void)
 252 {
 253         deinit();
 254 }
 255
 256 void TextureCubeFormatCase::init (void)
 257 {
 258         TestLog&                                log             = m_testCtx.getLog();
 259         tcu::TextureFormat              fmt             = glu::mapGLTransferFormat(m_format, m_dataType);
 260         tcu::TextureFormatInfo  spec    = tcu::getTextureFormatInfo(fmt);
 261         std::ostringstream              fmtName;
 262
 263         if (m_dataType)
 264                 fmtName << getTextureFormatStr(m_format) << ", " << getTypeStr(m_dataType);
 265         else
 266                 fmtName << getTextureFormatStr(m_format);
 267
 268         log << TestLog::Message << "Cube map texture, " << fmtName.str() << ", " << m_width << "x" << m_height
 269                                                         << ",\n  fill with " << formatGradient(&spec.valueMin, &spec.valueMax) << " gradient"
 270                 << TestLog::EndMessage;
 271
 272         DE_ASSERT(m_width == m_height);
 273         m_texture = m_dataType != GL_NONE
 274                           ? new TextureCube(m_renderCtx, m_format, m_dataType, m_width) // Implicit internal format.
 275                       : new TextureCube(m_renderCtx, m_format, m_width);                                // Explicit internal format.
 276
 277         // Fill level 0.
 278         for (int face = 0; face < tcu::CUBEFACE_LAST; face++)
 279         {
 280                 tcu::Vec4 gMin, gMax;
 281
 282                 switch (face)
 283                 {
 284                         case 0: gMin = spec.valueMin.swizzle(0, 1, 2, 3); gMax = spec.valueMax.swizzle(0, 1, 2, 3); break;
 285                         case 1: gMin = spec.valueMin.swizzle(2, 1, 0, 3); gMax = spec.valueMax.swizzle(2, 1, 0, 3); break;
 286                         case 2: gMin = spec.valueMin.swizzle(1, 2, 0, 3); gMax = spec.valueMax.swizzle(1, 2, 0, 3); break;
 287                         case 3: gMin = spec.valueMax.swizzle(0, 1, 2, 3); gMax = spec.valueMin.swizzle(0, 1, 2, 3); break;
 288                         case 4: gMin = spec.valueMax.swizzle(2, 1, 0, 3); gMax = spec.valueMin.swizzle(2, 1, 0, 3); break;
 289                         case 5: gMin = spec.valueMax.swizzle(1, 2, 0, 3); gMax = spec.valueMin.swizzle(1, 2, 0, 3); break;
 290                         default:
 291                                 DE_ASSERT(false);
 292                 }
 293
 294                 m_texture->getRefTexture().allocLevel((tcu::CubeFace)face, 0);
 295                 tcu::fillWithComponentGradients(m_texture->getRefTexture().getLevelFace(0, (tcu::CubeFace)face), gMin, gMax);
 296         }
 297
 298         // Upload texture data to GL.
 299         m_texture->upload();
 300
 301         // Initialize iteration state.
 302         m_curFace       = 0;
 303         m_isOk          = true;
 304 }
 305
 306 void TextureCubeFormatCase::deinit (void)
 307 {
 308         delete m_texture;
 309         m_texture = DE_NULL;
 310
 311         m_renderer.clear();
 312 }
 313
 314 bool TextureCubeFormatCase::testFace (tcu::CubeFace face)
 315 {
 316         const glw::Functions&   gl                                      = m_renderCtx.getFunctions();
 317         TestLog&                                log                                     = m_testCtx.getLog();
 318         RandomViewport                  viewport                        (m_renderCtx.getRenderTarget(), m_width, m_height, deStringHash(getName())+(deUint32)face);
 319         tcu::Surface                    renderedFrame           (viewport.width, viewport.height);
 320         tcu::Surface                    referenceFrame          (viewport.width, viewport.height);
 321         tcu::RGBA                               threshold                       = m_renderCtx.getRenderTarget().getPixelFormat().getColorThreshold() + tcu::RGBA(1,1,1,1);
 322         vector<float>                   texCoord;
 323         ReferenceParams                 renderParams            (TEXTURETYPE_CUBE);
 324         tcu::TextureFormatInfo  spec                            = tcu::getTextureFormatInfo(m_texture->getRefTexture().getFormat());
 325
 326         renderParams.samplerType                                = getSamplerType(m_texture->getRefTexture().getFormat());
 327         renderParams.sampler                                    = Sampler(Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::NEAREST, Sampler::NEAREST);
 328         renderParams.sampler.seamlessCubeMap    = false;
 329         renderParams.colorScale                                 = spec.lookupScale;
 330         renderParams.colorBias                                  = spec.lookupBias;
 331
 332         // Log render info on first face.
 333         if (face == tcu::CUBEFACE_NEGATIVE_X)
 334                 renderParams.flags |= RenderParams::LOG_ALL;
 335
 336         computeQuadTexCoordCube(texCoord, face);
 337
 338         // \todo [2011-10-28 pyry] Image set name / section?
 339         log << TestLog::Message << face << TestLog::EndMessage;
 340
 341         // Setup base viewport.
 342         gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height);
 343
 344         // Bind to unit 0.
 345         gl.activeTexture(GL_TEXTURE0);
 346         gl.bindTexture(GL_TEXTURE_CUBE_MAP, m_texture->getGLTexture());
 347
 348         // Setup nearest neighbor filtering and clamp-to-edge.
 349         gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 350         gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 351         gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 352         gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 353
 354         GLU_EXPECT_NO_ERROR(gl.getError(), "Set texturing state");
 355
 356         m_renderer.renderQuad(0, &texCoord[0], renderParams);
 357         glu::readPixels(m_renderCtx, viewport.x, viewport.y, renderedFrame.getAccess());
 358         GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels()");
 359
 360         // Compute reference.
 361         sampleTexture(tcu::SurfaceAccess(referenceFrame, m_renderCtx.getRenderTarget().getPixelFormat()), m_texture->getRefTexture(), &texCoord[0], renderParams);
 362
 363         // Compare and log.
 364         return compareImages(log, referenceFrame, renderedFrame, threshold);
 365 }
 366
 367 TextureCubeFormatCase::IterateResult TextureCubeFormatCase::iterate (void)
 368 {
 369         // Execute test for all faces.
 370         if (!testFace((tcu::CubeFace)m_curFace))
 371                 m_isOk = false;
 372
 373         m_curFace += 1;
 374
 375         if (m_curFace == tcu::CUBEFACE_LAST)
 376         {
 377                 m_testCtx.setTestResult(m_isOk ? QP_TEST_RESULT_PASS    : QP_TEST_RESULT_FAIL,
 378                                                                 m_isOk ? "Pass"                                 : "Image comparison failed");
 379                 return STOP;
 380         }
 381         else
 382                 return CONTINUE;
 383 }
 384
 385 TextureFormatTests::TextureFormatTests (Context& context)
 386         : TestCaseGroup(context, "format", "Texture Format Tests")
 387 {
 388 }
 389
 390 TextureFormatTests::~TextureFormatTests (void)
 391 {
 392 }
 393
 394 // Compressed2DFormatCase
 395
 396 class Compressed2DFormatCase : public tcu::TestCase
 397 {
 398 public:
 399                                                                 Compressed2DFormatCase          (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const glu::ContextInfo& renderCtxInfo, const char* name, const char* description, const std::vector<std::string>& filenames);
 400                                                                 ~Compressed2DFormatCase         (void);
 401
 402         void                                            init                                            (void);
 403         void                                            deinit                                          (void);
 404         IterateResult                           iterate                                         (void);
 405
 406 private:
 407                                                                 Compressed2DFormatCase          (const Compressed2DFormatCase& other);
 408         Compressed2DFormatCase&         operator=                                       (const Compressed2DFormatCase& other);
 409
 410         glu::RenderContext&                     m_renderCtx;
 411         const glu::ContextInfo&         m_renderCtxInfo;
 412
 413         std::vector<std::string>        m_filenames;
 414
 415         glu::Texture2D*                         m_texture;
 416         TextureRenderer                         m_renderer;
 417 };
 418
 419 Compressed2DFormatCase::Compressed2DFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const glu::ContextInfo& renderCtxInfo, const char* name, const char* description, const std::vector<std::string>& filenames)
 420         : TestCase                      (testCtx, name, description)
 421         , m_renderCtx           (renderCtx)
 422         , m_renderCtxInfo       (renderCtxInfo)
 423         , m_filenames           (filenames)
 424         , m_texture                     (DE_NULL)
 425         , m_renderer            (renderCtx, testCtx.getLog(), glu::GLSL_VERSION_100_ES, glu::PRECISION_MEDIUMP)
 426 {
 427 }
 428
 429 Compressed2DFormatCase::~Compressed2DFormatCase (void)
 430 {
 431         deinit();
 432 }
 433
 434 void Compressed2DFormatCase::init (void)
 435 {
 436         // Create texture.
 437         m_texture = Texture2D::create(m_renderCtx, m_renderCtxInfo, m_testCtx.getArchive(), (int)m_filenames.size(), m_filenames);
 438 }
 439
 440 void Compressed2DFormatCase::deinit (void)
 441 {
 442         delete m_texture;
 443         m_texture = DE_NULL;
 444
 445         m_renderer.clear();
 446 }
 447
 448 Compressed2DFormatCase::IterateResult Compressed2DFormatCase::iterate (void)
 449 {
 450         const glw::Functions&   gl                                      = m_renderCtx.getFunctions();
 451         TestLog&                                log                                     = m_testCtx.getLog();
 452         RandomViewport                  viewport                        (m_renderCtx.getRenderTarget(), m_texture->getRefTexture().getWidth(), m_texture->getRefTexture().getHeight(), deStringHash(getName()));
 453         tcu::Surface                    renderedFrame           (viewport.width, viewport.height);
 454         tcu::Surface                    referenceFrame          (viewport.width, viewport.height);
 455         tcu::RGBA                               threshold                       = m_renderCtx.getRenderTarget().getPixelFormat().getColorThreshold() + tcu::RGBA(1,1,1,1);
 456         vector<float>                   texCoord;
 457
 458         computeQuadTexCoord2D(texCoord, tcu::Vec2(0.0f, 0.0f), tcu::Vec2(1.0f, 1.0f));
 459
 460         // Setup base viewport.
 461         gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height);
 462
 463         // Bind to unit 0.
 464         gl.activeTexture(GL_TEXTURE0);
 465         gl.bindTexture(GL_TEXTURE_2D, m_texture->getGLTexture());
 466
 467         // Setup nearest neighbor filtering and clamp-to-edge.
 468         gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,              GL_CLAMP_TO_EDGE);
 469         gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,              GL_CLAMP_TO_EDGE);
 470         gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,  GL_NEAREST);
 471         gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,  GL_NEAREST);
 472
 473         GLU_EXPECT_NO_ERROR(gl.getError(), "Set texturing state");
 474
 475         // Draw.
 476         m_renderer.renderQuad(0, &texCoord[0], TEXTURETYPE_2D);
 477         glu::readPixels(m_renderCtx, viewport.x, viewport.y, renderedFrame.getAccess());
 478         GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels()");
 479
 480         // Compute reference.
 481         ReferenceParams refParams(TEXTURETYPE_2D);
 482         refParams.sampler = Sampler(Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::NEAREST, Sampler::NEAREST);
 483         sampleTexture(tcu::SurfaceAccess(referenceFrame, m_renderCtx.getRenderTarget().getPixelFormat()), m_texture->getRefTexture(), &texCoord[0], refParams);
 484
 485         // Compare and log.
 486         bool isOk = compareImages(log, referenceFrame, renderedFrame, threshold);
 487
 488         m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS      : QP_TEST_RESULT_FAIL,
 489                                                         isOk ? "Pass"                           : "Image comparison failed");
 490
 491         return STOP;
 492 }
 493
 494 // CompressedCubeFormatCase
 495
 496 class CompressedCubeFormatCase : public tcu::TestCase
 497 {
 498 public:
 499                                                                 CompressedCubeFormatCase        (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const glu::ContextInfo& renderCtxInfo, const char* name, const char* description, const std::vector<std::string>& filenames);
 500                                                                 ~CompressedCubeFormatCase       (void);
 501
 502         void                                            init                                            (void);
 503         void                                            deinit                                          (void);
 504         IterateResult                           iterate                                         (void);
 505
 506 private:
 507                                                                 CompressedCubeFormatCase        (const CompressedCubeFormatCase& other);
 508         CompressedCubeFormatCase&       operator=                                       (const CompressedCubeFormatCase& other);
 509
 510         bool                                            testFace                                        (tcu::CubeFace face);
 511
 512         glu::RenderContext&                     m_renderCtx;
 513         const glu::ContextInfo&         m_renderCtxInfo;
 514
 515         std::vector<std::string>        m_filenames;
 516
 517         glu::TextureCube*                       m_texture;
 518         TextureRenderer                         m_renderer;
 519
 520         int                                                     m_curFace;
 521         bool                                            m_isOk;
 522 };
 523
 524 CompressedCubeFormatCase::CompressedCubeFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const glu::ContextInfo& renderCtxInfo, const char* name, const char* description, const std::vector<std::string>& filenames)
 525         : TestCase                      (testCtx, name, description)
 526         , m_renderCtx           (renderCtx)
 527         , m_renderCtxInfo       (renderCtxInfo)
 528         , m_filenames           (filenames)
 529         , m_texture                     (DE_NULL)
 530         , m_renderer            (renderCtx, testCtx.getLog(), glu::GLSL_VERSION_100_ES, glu::PRECISION_MEDIUMP)
 531         , m_curFace                     (0)
 532         , m_isOk                        (false)
 533 {
 534 }
 535
 536 CompressedCubeFormatCase::~CompressedCubeFormatCase (void)
 537 {
 538         deinit();
 539 }
 540
 541 void CompressedCubeFormatCase::init (void)
 542 {
 543         // Create texture.
 544         DE_ASSERT(m_filenames.size() % 6 == 0);
 545         m_texture = TextureCube::create(m_renderCtx, m_renderCtxInfo, m_testCtx.getArchive(), (int)m_filenames.size()/6, m_filenames);
 546
 547         m_curFace       = 0;
 548         m_isOk          = true;
 549 }
 550
 551 void CompressedCubeFormatCase::deinit (void)
 552 {
 553         delete m_texture;
 554         m_texture = DE_NULL;
 555
 556         m_renderer.clear();
 557 }
 558
 559 bool CompressedCubeFormatCase::testFace (tcu::CubeFace face)
 560 {
 561         const glw::Functions&   gl                                      = m_renderCtx.getFunctions();
 562         TestLog&                                log                                     = m_testCtx.getLog();
 563         RandomViewport                  viewport                        (m_renderCtx.getRenderTarget(), m_texture->getRefTexture().getSize(), m_texture->getRefTexture().getSize(), deStringHash(getName())+(deUint32)face);
 564         tcu::Surface                    renderedFrame           (viewport.width, viewport.height);
 565         tcu::Surface                    referenceFrame          (viewport.width, viewport.height);
 566         Sampler                                 sampler                         (Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::NEAREST, Sampler::NEAREST);
 567         tcu::RGBA                               threshold                       = m_renderCtx.getRenderTarget().getPixelFormat().getColorThreshold() + tcu::RGBA(1,1,1,1);
 568         vector<float>                   texCoord;
 569
 570         computeQuadTexCoordCube(texCoord, face);
 571
 572         // \todo [2011-10-28 pyry] Image set name / section?
 573         log << TestLog::Message << face << TestLog::EndMessage;
 574
 575         // Setup base viewport.
 576         gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height);
 577
 578         // Bind to unit 0.
 579         gl.activeTexture(GL_TEXTURE0);
 580         gl.bindTexture(GL_TEXTURE_CUBE_MAP, m_texture->getGLTexture());
 581
 582         // Setup nearest neighbor filtering and clamp-to-edge.
 583         gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 584         gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 585         gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 586         gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 587
 588         GLU_EXPECT_NO_ERROR(gl.getError(), "Set texturing state");
 589
 590         m_renderer.renderQuad(0, &texCoord[0], TEXTURETYPE_CUBE);
 591         glu::readPixels(m_renderCtx, viewport.x, viewport.y, renderedFrame.getAccess());
 592         GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels()");
 593
 594         // Compute reference.
 595         sampleTexture(tcu::SurfaceAccess(referenceFrame, m_renderCtx.getRenderTarget().getPixelFormat()), m_texture->getRefTexture(), &texCoord[0], ReferenceParams(TEXTURETYPE_CUBE, sampler));
 596
 597         // Compare and log.
 598         return compareImages(log, referenceFrame, renderedFrame, threshold);
 599 }
 600
 601 CompressedCubeFormatCase::IterateResult CompressedCubeFormatCase::iterate (void)
 602 {
 603         // Execute test for all faces.
 604         if (!testFace((tcu::CubeFace)m_curFace))
 605                 m_isOk = false;
 606
 607         m_curFace += 1;
 608
 609         if (m_curFace == tcu::CUBEFACE_LAST)
 610         {
 611                 m_testCtx.setTestResult(m_isOk ? QP_TEST_RESULT_PASS    : QP_TEST_RESULT_FAIL,
 612                                                                 m_isOk ? "Pass"                                 : "Image comparison failed");
 613                 return STOP;
 614         }
 615         else
 616                 return CONTINUE;
 617 }
 618
 619 vector<string> toStringVector (const char* const* str, int numStr)
 620 {
 621         vector<string> v;
 622         v.resize(numStr);
 623         for (int i = 0; i < numStr; i++)
 624                 v[i] = str[i];
 625         return v;
 626 }
 627
 628 void TextureFormatTests::init (void)
 629 {
 630         struct
 631         {
 632                 const char*     name;
 633                 deUint32                format;
 634                 deUint32                dataType;
 635         } texFormats[] =
 636         {
 637                 { "a8",                 GL_ALPHA,                       GL_UNSIGNED_BYTE },
 638                 { "l8",                 GL_LUMINANCE,           GL_UNSIGNED_BYTE },
 639                 { "la88",               GL_LUMINANCE_ALPHA,     GL_UNSIGNED_BYTE },
 640                 { "rgb565",             GL_RGB,                         GL_UNSIGNED_SHORT_5_6_5 },
 641                 { "rgb888",             GL_RGB,                         GL_UNSIGNED_BYTE },
 642                 { "rgba4444",   GL_RGBA,                        GL_UNSIGNED_SHORT_4_4_4_4 },
 643                 { "rgba5551",   GL_RGBA,                        GL_UNSIGNED_SHORT_5_5_5_1 },
 644                 { "rgba8888",   GL_RGBA,                        GL_UNSIGNED_BYTE }
 645         };
 646
 647         for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(texFormats); formatNdx++)
 648         {
 649                 deUint32        format                  = texFormats[formatNdx].format;
 650                 deUint32        dataType                = texFormats[formatNdx].dataType;
 651                 string  nameBase                = texFormats[formatNdx].name;
 652                 string  descriptionBase = string(glu::getTextureFormatName(format)) + ", " + glu::getTypeName(dataType);
 653
 654                 addChild(new Texture2DFormatCase        (m_testCtx, m_context.getRenderContext(),       (nameBase + "_2d_pot").c_str(),         (descriptionBase + ", GL_TEXTURE_2D").c_str(),                  format, dataType, 128, 128));
 655                 addChild(new Texture2DFormatCase        (m_testCtx, m_context.getRenderContext(),       (nameBase + "_2d_npot").c_str(),        (descriptionBase + ", GL_TEXTURE_2D").c_str(),                  format, dataType,  63, 112));
 656                 addChild(new TextureCubeFormatCase      (m_testCtx, m_context.getRenderContext(),       (nameBase + "_cube_pot").c_str(),       (descriptionBase + ", GL_TEXTURE_CUBE_MAP").c_str(),    format, dataType,  64,  64));
 657                 addChild(new TextureCubeFormatCase      (m_testCtx, m_context.getRenderContext(),       (nameBase + "_cube_npot").c_str(),      (descriptionBase + ", GL_TEXTURE_CUBE_MAP").c_str(),    format, dataType,  57,  57));
 658         }
 659
 660         // ETC-1 compressed formats.
 661         {
 662                 static const char* filenames[] =
 663                 {
 664                         "data/etc1/photo_helsinki_mip_0.pkm",
 665                         "data/etc1/photo_helsinki_mip_1.pkm",
 666                         "data/etc1/photo_helsinki_mip_2.pkm",
 667                         "data/etc1/photo_helsinki_mip_3.pkm",
 668                         "data/etc1/photo_helsinki_mip_4.pkm",
 669                         "data/etc1/photo_helsinki_mip_5.pkm",
 670                         "data/etc1/photo_helsinki_mip_6.pkm",
 671                         "data/etc1/photo_helsinki_mip_7.pkm"
 672                 };
 673                 addChild(new Compressed2DFormatCase(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))));
 674         }
 675
 676         {
 677                 vector<string> filenames;
 678                 filenames.push_back("data/etc1/photo_helsinki_113x89.pkm");
 679                 addChild(new Compressed2DFormatCase(m_testCtx, m_context.getRenderContext(), m_context.getContextInfo(), "etc1_2d_npot", "GL_ETC1_RGB8_OES, GL_TEXTURE_2D", filenames));
 680         }
 681
 682         {
 683                 static const char* faceExt[] = { "neg_x", "pos_x", "neg_y", "pos_y", "neg_z", "pos_z" };
 684
 685                 const int               potNumLevels    = 7;
 686                 vector<string>  potFilenames;
 687                 for (int level = 0; level < potNumLevels; level++)
 688                         for (int face = 0; face < tcu::CUBEFACE_LAST; face++)
 689                                 potFilenames.push_back(string("data/etc1/skybox_") + faceExt[face] + "_mip_" + de::toString(level) + ".pkm");
 690
 691                 addChild(new CompressedCubeFormatCase(m_testCtx, m_context.getRenderContext(), m_context.getContextInfo(), "etc1_cube_pot", "GL_ETC1_RGB8_OES, GL_TEXTURE_CUBE_MAP", potFilenames));
 692
 693                 vector<string> npotFilenames;
 694                 for (int face = 0; face < tcu::CUBEFACE_LAST; face++)
 695                         npotFilenames.push_back(string("data/etc1/skybox_61x61_") + faceExt[face] + ".pkm");
 696
 697                 addChild(new CompressedCubeFormatCase(m_testCtx, m_context.getRenderContext(), m_context.getContextInfo(), "etc1_cube_npot", "GL_ETC_RGB8_OES, GL_TEXTURE_CUBE_MAP", npotFilenames));
 698         }
 699 }
 700
 701 } // Functional
 702 } // gles2
 703 } // deqp