modules/gles3/functional/es3fTextureFormatTests.cpp

   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