modules/gles3/functional/es3fTextureShadowTests.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 Shadow texture lookup tests.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "es3fTextureShadowTests.hpp"
  25 #include "gluTexture.hpp"
  26 #include "gluPixelTransfer.hpp"
  27 #include "gluTextureUtil.hpp"
  28 #include "glsTextureTestUtil.hpp"
  29 #include "tcuTextureUtil.hpp"
  30 #include "tcuRenderTarget.hpp"
  31 #include "tcuTexCompareVerifier.hpp"
  32 #include "deString.h"
  33 #include "deStringUtil.hpp"
  34 #include "glwFunctions.hpp"
  35 #include "glwEnums.hpp"
  36
  37 namespace deqp
  38 {
  39 namespace gles3
  40 {
  41 namespace Functional
  42 {
  43
  44 using std::vector;
  45 using std::string;
  46 using tcu::TestLog;
  47 using namespace deqp::gls::TextureTestUtil;
  48
  49 enum
  50 {
  51         TEX2D_VIEWPORT_WIDTH            = 64,
  52         TEX2D_VIEWPORT_HEIGHT           = 64,
  53         TEX2D_MIN_VIEWPORT_WIDTH        = 64,
  54         TEX2D_MIN_VIEWPORT_HEIGHT       = 64
  55 };
  56
  57 static bool isFloatingPointDepthFormat (const tcu::TextureFormat& format)
  58 {
  59         // Only two depth and depth-stencil formats are floating point
  60         return  (format.order == tcu::TextureFormat::D && format.type == tcu::TextureFormat::FLOAT) ||
  61                         (format.order == tcu::TextureFormat::DS && format.type == tcu::TextureFormat::FLOAT_UNSIGNED_INT_24_8_REV);
  62 }
  63
  64 static void clampFloatingPointTexture (const tcu::PixelBufferAccess& access)
  65 {
  66         DE_ASSERT(isFloatingPointDepthFormat(access.getFormat()));
  67
  68         for (int z = 0; z < access.getDepth(); ++z)
  69         for (int y = 0; y < access.getHeight(); ++y)
  70         for (int x = 0; x < access.getWidth(); ++x)
  71                 access.setPixDepth( de::clamp(access.getPixDepth(x, y, z), 0.0f, 1.0f), x, y, z);
  72 }
  73
  74 static void clampFloatingPointTexture (tcu::Texture2D& target)
  75 {
  76         for (int level = 0; level < target.getNumLevels(); ++level)
  77                 if (!target.isLevelEmpty(level))
  78                         clampFloatingPointTexture(target.getLevel(level));
  79 }
  80
  81 static void clampFloatingPointTexture (tcu::Texture2DArray& target)
  82 {
  83         for (int level = 0; level < target.getNumLevels(); ++level)
  84                 if (!target.isLevelEmpty(level))
  85                         clampFloatingPointTexture(target.getLevel(level));
  86 }
  87
  88 static void clampFloatingPointTexture (tcu::TextureCube& target)
  89 {
  90         for (int level = 0; level < target.getNumLevels(); ++level)
  91                 for (int face = tcu::CUBEFACE_NEGATIVE_X; face < tcu::CUBEFACE_LAST; ++face)
  92                         clampFloatingPointTexture(target.getLevelFace(level, (tcu::CubeFace)face));
  93 }
  94
  95 template<typename TextureType>
  96 bool verifyTexCompareResult (tcu::TestContext&                                          testCtx,
  97                                                          const tcu::ConstPixelBufferAccess&             result,
  98                                                          const TextureType&                                             src,
  99                                                          const float*                                                   texCoord,
 100                                                          const ReferenceParams&                                 sampleParams,
 101                                                          const tcu::TexComparePrecision&                comparePrec,
 102                                                          const tcu::LodPrecision&                               lodPrec,
 103                                                          const tcu::PixelFormat&                                pixelFormat)
 104 {
 105         tcu::TestLog&   log                                     = testCtx.getLog();
 106         tcu::Surface    reference                       (result.getWidth(), result.getHeight());
 107         tcu::Surface    errorMask                       (result.getWidth(), result.getHeight());
 108         const tcu::Vec3 nonShadowThreshold      = tcu::computeFixedPointThreshold(getBitsVec(pixelFormat)-1).swizzle(1,2,3);
 109         int                             numFailedPixels;
 110
 111         // sampleTexture() expects source image to be the same state as it would be in a GL implementation, that is
 112         // the floating point depth values should be in [0, 1] range as data is clamped during texture upload. Since
 113         // we don't have a separate "uploading" phase and just reuse the buffer we used for GL-upload, do the clamping
 114         // here if necessary.
 115
 116         if (isFloatingPointDepthFormat(src.getFormat()))
 117         {
 118                 TextureType clampedSource(src);
 119
 120                 clampFloatingPointTexture(clampedSource);
 121
 122                 // sample clamped values
 123
 124                 sampleTexture(SurfaceAccess(reference, pixelFormat), clampedSource, texCoord, sampleParams);
 125                 numFailedPixels = computeTextureCompareDiff(result, reference.getAccess(), errorMask.getAccess(), clampedSource, texCoord, sampleParams, comparePrec, lodPrec, nonShadowThreshold);
 126         }
 127         else
 128         {
 129                 // sample raw values (they are guaranteed to be in [0, 1] range as the format cannot represent any other values)
 130
 131                 sampleTexture(SurfaceAccess(reference, pixelFormat), src, texCoord, sampleParams);
 132                 numFailedPixels = computeTextureCompareDiff(result, reference.getAccess(), errorMask.getAccess(), src, texCoord, sampleParams, comparePrec, lodPrec, nonShadowThreshold);
 133         }
 134
 135         if (numFailedPixels > 0)
 136                 log << TestLog::Message << "ERROR: Result verification failed, got " << numFailedPixels << " invalid pixels!" << TestLog::EndMessage;
 137
 138         log << TestLog::ImageSet("VerifyResult", "Verification result")
 139                 << TestLog::Image("Rendered", "Rendered image", result);
 140
 141         if (numFailedPixels > 0)
 142         {
 143                 log << TestLog::Image("Reference", "Ideal reference image", reference)
 144                         << TestLog::Image("ErrorMask", "Error mask", errorMask);
 145         }
 146
 147         log << TestLog::EndImageSet;
 148
 149         return numFailedPixels == 0;
 150 }
 151
 152 class Texture2DShadowCase : public TestCase
 153 {
 154 public:
 155                                                                         Texture2DShadowCase                     (Context& context, const char* name, const char* desc, deUint32 minFilter, deUint32 magFilter, deUint32 wrapS, deUint32 wrapT, deUint32 format, int width, int height, deUint32 compareFunc);
 156                                                                         ~Texture2DShadowCase            (void);
 157
 158         void                                                    init                                            (void);
 159         void                                                    deinit                                          (void);
 160         IterateResult                                   iterate                                         (void);
 161
 162 private:
 163                                                                         Texture2DShadowCase                     (const Texture2DShadowCase& other);
 164         Texture2DShadowCase&                    operator=                                       (const Texture2DShadowCase& other);
 165
 166         const deUint32                                  m_minFilter;
 167         const deUint32                                  m_magFilter;
 168         const deUint32                                  m_wrapS;
 169         const deUint32                                  m_wrapT;
 170         const deUint32                                  m_format;
 171         const int                                               m_width;
 172         const int                                               m_height;
 173         const deUint32                                  m_compareFunc;
 174
 175         struct FilterCase
 176         {
 177                 const glu::Texture2D*   texture;
 178                 tcu::Vec2                               minCoord;
 179                 tcu::Vec2                               maxCoord;
 180                 float                                   ref;
 181
 182                 FilterCase (void)
 183                         : texture       (DE_NULL)
 184                         , ref           (0.0f)
 185                 {
 186                 }
 187
 188                 FilterCase (const glu::Texture2D* tex_, const float ref_, const tcu::Vec2& minCoord_, const tcu::Vec2& maxCoord_)
 189                         : texture       (tex_)
 190                         , minCoord      (minCoord_)
 191                         , maxCoord      (maxCoord_)
 192                         , ref           (ref_)
 193                 {
 194                 }
 195         };
 196
 197         std::vector<glu::Texture2D*>    m_textures;
 198         std::vector<FilterCase>                 m_cases;
 199
 200         TextureRenderer                                 m_renderer;
 201
 202         int                                                             m_caseNdx;
 203 };
 204
 205 Texture2DShadowCase::Texture2DShadowCase (Context& context, const char* name, const char* desc, deUint32 minFilter, deUint32 magFilter, deUint32 wrapS, deUint32 wrapT, deUint32 format, int width, int height, deUint32 compareFunc)
 206         : TestCase                      (context, name, desc)
 207         , m_minFilter           (minFilter)
 208         , m_magFilter           (magFilter)
 209         , m_wrapS                       (wrapS)
 210         , m_wrapT                       (wrapT)
 211         , m_format                      (format)
 212         , m_width                       (width)
 213         , m_height                      (height)
 214         , m_compareFunc         (compareFunc)
 215         , m_renderer            (context.getRenderContext(), context.getTestContext().getLog(), glu::GLSL_VERSION_300_ES, glu::PRECISION_HIGHP)
 216         , m_caseNdx                     (0)
 217 {
 218 }
 219
 220 Texture2DShadowCase::~Texture2DShadowCase (void)
 221 {
 222         deinit();
 223 }
 224
 225 void Texture2DShadowCase::init (void)
 226 {
 227         try
 228         {
 229                 // Create 2 textures.
 230                 m_textures.reserve(2);
 231                 m_textures.push_back(new glu::Texture2D(m_context.getRenderContext(), m_format, m_width, m_height));
 232                 m_textures.push_back(new glu::Texture2D(m_context.getRenderContext(), m_format, m_width, m_height));
 233
 234                 int numLevels = m_textures[0]->getRefTexture().getNumLevels();
 235
 236                 // Fill first gradient texture.
 237                 for (int levelNdx = 0; levelNdx < numLevels; levelNdx++)
 238                 {
 239                         m_textures[0]->getRefTexture().allocLevel(levelNdx);
 240                         tcu::fillWithComponentGradients(m_textures[0]->getRefTexture().getLevel(levelNdx), tcu::Vec4(-0.5f, -0.5f, -0.5f, 2.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f));
 241                 }
 242
 243                 // Fill second with grid texture.
 244                 for (int levelNdx = 0; levelNdx < numLevels; levelNdx++)
 245                 {
 246                         deUint32        step    = 0x00ffffff / numLevels;
 247                         deUint32        rgb             = step*levelNdx;
 248                         deUint32        colorA  = 0xff000000 | rgb;
 249                         deUint32        colorB  = 0xff000000 | ~rgb;
 250
 251                         m_textures[1]->getRefTexture().allocLevel(levelNdx);
 252                         tcu::fillWithGrid(m_textures[1]->getRefTexture().getLevel(levelNdx), 4, toVec4(tcu::RGBA(colorA)), toVec4(tcu::RGBA(colorB)));
 253                 }
 254
 255                 // Upload.
 256                 for (std::vector<glu::Texture2D*>::iterator i = m_textures.begin(); i != m_textures.end(); i++)
 257                         (*i)->upload();
 258         }
 259         catch (const std::exception&)
 260         {
 261                 // Clean up to save memory.
 262                 Texture2DShadowCase::deinit();
 263                 throw;
 264         }
 265
 266         // Compute cases.
 267         {
 268                 const float refInRangeUpper             = (m_compareFunc == GL_EQUAL || m_compareFunc == GL_NOTEQUAL) ? 1.0f : 0.5f;
 269                 const float refInRangeLower             = (m_compareFunc == GL_EQUAL || m_compareFunc == GL_NOTEQUAL) ? 0.0f : 0.5f;
 270                 const float refOutOfBoundsUpper = 1.1f;         // !< lookup function should clamp values to [0, 1] range
 271                 const float refOutOfBoundsLower = -0.1f;
 272
 273                 const struct
 274                 {
 275                         int             texNdx;
 276                         float   ref;
 277                         float   lodX;
 278                         float   lodY;
 279                         float   oX;
 280                         float   oY;
 281                 } cases[] =
 282                 {
 283                         { 0,    refInRangeUpper,                1.6f,   2.9f,   -1.0f,  -2.7f   },
 284                         { 0,    refInRangeLower,                -2.0f,  -1.35f, -0.2f,  0.7f    },
 285                         { 1,    refInRangeUpper,                0.14f,  0.275f, -1.5f,  -1.1f   },
 286                         { 1,    refInRangeLower,                -0.92f, -2.64f, 0.4f,   -0.1f   },
 287                         { 1,    refOutOfBoundsUpper,    -0.39f, -0.52f, 0.65f,  0.87f   },
 288                         { 1,    refOutOfBoundsLower,    -1.55f, 0.65f,  0.35f,  0.91f   },
 289                 };
 290
 291                 const float     viewportW       = (float)de::min<int>(TEX2D_VIEWPORT_WIDTH, m_context.getRenderTarget().getWidth());
 292                 const float     viewportH       = (float)de::min<int>(TEX2D_VIEWPORT_HEIGHT, m_context.getRenderTarget().getHeight());
 293
 294                 for (int caseNdx = 0; caseNdx < DE_LENGTH_OF_ARRAY(cases); caseNdx++)
 295                 {
 296                         const int       texNdx  = de::clamp(cases[caseNdx].texNdx, 0, (int)m_textures.size()-1);
 297                         const float ref         = cases[caseNdx].ref;
 298                         const float     lodX    = cases[caseNdx].lodX;
 299                         const float     lodY    = cases[caseNdx].lodY;
 300                         const float     oX              = cases[caseNdx].oX;
 301                         const float     oY              = cases[caseNdx].oY;
 302                         const float     sX              = deFloatExp2(lodX)*viewportW / float(m_textures[texNdx]->getRefTexture().getWidth());
 303                         const float     sY              = deFloatExp2(lodY)*viewportH / float(m_textures[texNdx]->getRefTexture().getHeight());
 304
 305                         m_cases.push_back(FilterCase(m_textures[texNdx], ref, tcu::Vec2(oX, oY), tcu::Vec2(oX+sX, oY+sY)));
 306                 }
 307         }
 308
 309         m_caseNdx = 0;
 310         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 311 }
 312
 313 void Texture2DShadowCase::deinit (void)
 314 {
 315         for (std::vector<glu::Texture2D*>::iterator i = m_textures.begin(); i != m_textures.end(); i++)
 316                 delete *i;
 317         m_textures.clear();
 318
 319         m_renderer.clear();
 320         m_cases.clear();
 321 }
 322
 323 Texture2DShadowCase::IterateResult Texture2DShadowCase::iterate (void)
 324 {
 325         const glw::Functions&                   gl                              = m_context.getRenderContext().getFunctions();
 326         const RandomViewport                    viewport                (m_context.getRenderTarget(), TEX2D_VIEWPORT_WIDTH, TEX2D_VIEWPORT_HEIGHT, deStringHash(getName()) ^ deInt32Hash(m_caseNdx));
 327         const FilterCase&                               curCase                 = m_cases[m_caseNdx];
 328         const tcu::ScopedLogSection             section                 (m_testCtx.getLog(), string("Test") + de::toString(m_caseNdx), string("Test ") + de::toString(m_caseNdx));
 329         ReferenceParams                                 sampleParams    (TEXTURETYPE_2D);
 330         tcu::Surface                                    rendered                (viewport.width, viewport.height);
 331         vector<float>                                   texCoord;
 332
 333         if (viewport.width < TEX2D_MIN_VIEWPORT_WIDTH || viewport.height < TEX2D_MIN_VIEWPORT_HEIGHT)
 334                 throw tcu::NotSupportedError("Too small render target", "", __FILE__, __LINE__);
 335
 336         // Setup params for reference.
 337         sampleParams.sampler                    = glu::mapGLSampler(m_wrapS, m_wrapT, m_minFilter, m_magFilter);
 338         sampleParams.sampler.compare    = glu::mapGLCompareFunc(m_compareFunc);
 339         sampleParams.samplerType                = SAMPLERTYPE_SHADOW;
 340         sampleParams.lodMode                    = LODMODE_EXACT;
 341         sampleParams.ref                                = curCase.ref;
 342
 343         m_testCtx.getLog() << TestLog::Message << "Compare reference value =  " << sampleParams.ref << TestLog::EndMessage;
 344
 345         // Compute texture coordinates.
 346         m_testCtx.getLog() << TestLog::Message << "Texture coordinates: " << curCase.minCoord << " -> " << curCase.maxCoord << TestLog::EndMessage;
 347         computeQuadTexCoord2D(texCoord, curCase.minCoord, curCase.maxCoord);
 348
 349         gl.bindTexture  (GL_TEXTURE_2D, curCase.texture->getGLTexture());
 350         gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,          m_minFilter);
 351         gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,          m_magFilter);
 352         gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,                      m_wrapS);
 353         gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,                      m_wrapT);
 354         gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE,        GL_COMPARE_REF_TO_TEXTURE);
 355         gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC,        m_compareFunc);
 356
 357         gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height);
 358         m_renderer.renderQuad(0, &texCoord[0], sampleParams);
 359         glu::readPixels(m_context.getRenderContext(), viewport.x, viewport.y, rendered.getAccess());
 360
 361         {
 362                 const tcu::PixelFormat          pixelFormat             = m_context.getRenderTarget().getPixelFormat();
 363                 tcu::LodPrecision                       lodPrecision;
 364                 tcu::TexComparePrecision        texComparePrecision;
 365
 366                 lodPrecision.derivateBits                       = 18;
 367                 lodPrecision.lodBits                            = 6;
 368                 texComparePrecision.coordBits           = tcu::IVec3(20,20,0);
 369                 texComparePrecision.uvwBits                     = tcu::IVec3(7,7,0);
 370                 texComparePrecision.pcfBits                     = 5;
 371                 texComparePrecision.referenceBits       = 16;
 372                 texComparePrecision.resultBits          = pixelFormat.redBits-1;
 373
 374                 const bool isHighQuality = verifyTexCompareResult(m_testCtx, rendered.getAccess(), curCase.texture->getRefTexture(),
 375                                                                                                                   &texCoord[0], sampleParams, texComparePrecision, lodPrecision, pixelFormat);
 376
 377                 if (!isHighQuality)
 378                 {
 379                         m_testCtx.getLog() << TestLog::Message << "Warning: Verification assuming high-quality PCF filtering failed." << TestLog::EndMessage;
 380
 381                         lodPrecision.lodBits                    = 4;
 382                         texComparePrecision.uvwBits             = tcu::IVec3(4,4,0);
 383                         texComparePrecision.pcfBits             = 0;
 384
 385                         const bool isOk = verifyTexCompareResult(m_testCtx, rendered.getAccess(), curCase.texture->getRefTexture(),
 386                                                                                                          &texCoord[0], sampleParams, texComparePrecision, lodPrecision, pixelFormat);
 387
 388                         if (!isOk)
 389                         {
 390                                 m_testCtx.getLog() << TestLog::Message << "ERROR: Verification against low precision requirements failed, failing test case." << TestLog::EndMessage;
 391                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image verification failed");
 392                         }
 393                         else if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 394                                 m_testCtx.setTestResult(QP_TEST_RESULT_QUALITY_WARNING, "Low-quality result");
 395                 }
 396         }
 397
 398         m_caseNdx += 1;
 399         return m_caseNdx < (int)m_cases.size() ? CONTINUE : STOP;
 400 }
 401
 402 class TextureCubeShadowCase : public TestCase
 403 {
 404 public:
 405                                                                 TextureCubeShadowCase           (Context& context, const char* name, const char* desc, deUint32 minFilter, deUint32 magFilter, deUint32 wrapS, deUint32 wrapT, deUint32 format, int size, deUint32 compareFunc);
 406                                                                 ~TextureCubeShadowCase          (void);
 407
 408         void                                            init                                            (void);
 409         void                                            deinit                                          (void);
 410         IterateResult                           iterate                                         (void);
 411
 412 private:
 413                                                                 TextureCubeShadowCase           (const TextureCubeShadowCase& other);
 414         TextureCubeShadowCase&          operator=                                       (const TextureCubeShadowCase& other);
 415
 416         const deUint32                          m_minFilter;
 417         const deUint32                          m_magFilter;
 418         const deUint32                          m_wrapS;
 419         const deUint32                          m_wrapT;
 420
 421         const deUint32                          m_format;
 422         const int                                       m_size;
 423
 424         const deUint32                          m_compareFunc;
 425
 426         struct FilterCase
 427         {
 428                 const glu::TextureCube* texture;
 429                 tcu::Vec2                               bottomLeft;
 430                 tcu::Vec2                               topRight;
 431                 float                                   ref;
 432
 433                 FilterCase (void)
 434                         : texture       (DE_NULL)
 435                         , ref           (0.0f)
 436                 {
 437                 }
 438
 439                 FilterCase (const glu::TextureCube* tex_, const float ref_, const tcu::Vec2& bottomLeft_, const tcu::Vec2& topRight_)
 440                         : texture       (tex_)
 441                         , bottomLeft(bottomLeft_)
 442                         , topRight      (topRight_)
 443                         , ref           (ref_)
 444                 {
 445                 }
 446         };
 447
 448         glu::TextureCube*                       m_gradientTex;
 449         glu::TextureCube*                       m_gridTex;
 450         std::vector<FilterCase>         m_cases;
 451
 452         TextureRenderer                         m_renderer;
 453
 454         int                                                     m_caseNdx;
 455 };
 456
 457 TextureCubeShadowCase::TextureCubeShadowCase (Context& context, const char* name, const char* desc, deUint32 minFilter, deUint32 magFilter, deUint32 wrapS, deUint32 wrapT, deUint32 format, int size, deUint32 compareFunc)
 458         : TestCase                      (context, name, desc)
 459         , m_minFilter           (minFilter)
 460         , m_magFilter           (magFilter)
 461         , m_wrapS                       (wrapS)
 462         , m_wrapT                       (wrapT)
 463         , m_format                      (format)
 464         , m_size                        (size)
 465         , m_compareFunc         (compareFunc)
 466         , m_gradientTex         (DE_NULL)
 467         , m_gridTex                     (DE_NULL)
 468         , m_renderer            (context.getRenderContext(), context.getTestContext().getLog(), glu::GLSL_VERSION_300_ES, glu::PRECISION_HIGHP)
 469         , m_caseNdx                     (0)
 470 {
 471 }
 472
 473 TextureCubeShadowCase::~TextureCubeShadowCase (void)
 474 {
 475         TextureCubeShadowCase::deinit();
 476 }
 477
 478 void TextureCubeShadowCase::init (void)
 479 {
 480         try
 481         {
 482                 DE_ASSERT(!m_gradientTex && !m_gridTex);
 483
 484                 int                                             numLevels       = deLog2Floor32(m_size)+1;
 485                 tcu::TextureFormat              texFmt          = glu::mapGLInternalFormat(m_format);
 486                 tcu::TextureFormatInfo  fmtInfo         = tcu::getTextureFormatInfo(texFmt);
 487                 tcu::Vec4                               cBias           = fmtInfo.valueMin;
 488                 tcu::Vec4                               cScale          = fmtInfo.valueMax-fmtInfo.valueMin;
 489
 490                 // Create textures.
 491                 m_gradientTex   = new glu::TextureCube(m_context.getRenderContext(), m_format, m_size);
 492                 m_gridTex               = new glu::TextureCube(m_context.getRenderContext(), m_format, m_size);
 493
 494                 // Fill first with gradient texture.
 495                 static const tcu::Vec4 gradients[tcu::CUBEFACE_LAST][2] =
 496                 {
 497                         { tcu::Vec4(-1.0f, -1.0f, -1.0f, 2.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f) }, // negative x
 498                         { tcu::Vec4( 0.0f, -1.0f, -1.0f, 2.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f) }, // positive x
 499                         { tcu::Vec4(-1.0f,  0.0f, -1.0f, 2.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f) }, // negative y
 500                         { tcu::Vec4(-1.0f, -1.0f,  0.0f, 2.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f) }, // positive y
 501                         { tcu::Vec4(-1.0f, -1.0f, -1.0f, 0.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f) }, // negative z
 502                         { tcu::Vec4( 0.0f,  0.0f,  0.0f, 2.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f) }  // positive z
 503                 };
 504                 for (int face = 0; face < tcu::CUBEFACE_LAST; face++)
 505                 {
 506                         for (int levelNdx = 0; levelNdx < numLevels; levelNdx++)
 507                         {
 508                                 m_gradientTex->getRefTexture().allocLevel((tcu::CubeFace)face, levelNdx);
 509                                 tcu::fillWithComponentGradients(m_gradientTex->getRefTexture().getLevelFace(levelNdx, (tcu::CubeFace)face), gradients[face][0]*cScale + cBias, gradients[face][1]*cScale + cBias);
 510                         }
 511                 }
 512
 513                 // Fill second with grid texture.
 514                 for (int face = 0; face < tcu::CUBEFACE_LAST; face++)
 515                 {
 516                         for (int levelNdx = 0; levelNdx < numLevels; levelNdx++)
 517                         {
 518                                 deUint32        step    = 0x00ffffff / (numLevels*tcu::CUBEFACE_LAST);
 519                                 deUint32        rgb             = step*levelNdx*face;
 520                                 deUint32        colorA  = 0xff000000 | rgb;
 521                                 deUint32        colorB  = 0xff000000 | ~rgb;
 522
 523                                 m_gridTex->getRefTexture().allocLevel((tcu::CubeFace)face, levelNdx);
 524                                 tcu::fillWithGrid(m_gridTex->getRefTexture().getLevelFace(levelNdx, (tcu::CubeFace)face), 4, toVec4(tcu::RGBA(colorA))*cScale + cBias, toVec4(tcu::RGBA(colorB))*cScale + cBias);
 525                         }
 526                 }
 527
 528                 // Upload.
 529                 m_gradientTex->upload();
 530                 m_gridTex->upload();
 531         }
 532         catch (const std::exception&)
 533         {
 534                 // Clean up to save memory.
 535                 TextureCubeShadowCase::deinit();
 536                 throw;
 537         }
 538
 539         // Compute cases
 540         {
 541                 const float refInRangeUpper             = (m_compareFunc == GL_EQUAL || m_compareFunc == GL_NOTEQUAL) ? 1.0f : 0.5f;
 542                 const float refInRangeLower             = (m_compareFunc == GL_EQUAL || m_compareFunc == GL_NOTEQUAL) ? 0.0f : 0.5f;
 543                 const float refOutOfBoundsUpper = 1.1f;
 544                 const float refOutOfBoundsLower = -0.1f;
 545                 const bool      singleSample            = m_context.getRenderTarget().getNumSamples() == 0;
 546
 547                 if (singleSample)
 548                         m_cases.push_back(FilterCase(m_gradientTex,     refInRangeUpper, tcu::Vec2(-1.25f, -1.2f), tcu::Vec2(1.2f, 1.25f)));    // minification
 549                 else
 550                         m_cases.push_back(FilterCase(m_gradientTex,     refInRangeUpper, tcu::Vec2(-1.19f, -1.3f), tcu::Vec2(1.1f, 1.35f)));    // minification - w/ tuned coordinates to avoid hitting triangle edges
 551
 552                 m_cases.push_back(FilterCase(m_gradientTex,     refInRangeLower,                tcu::Vec2(0.8f, 0.8f), tcu::Vec2(1.25f, 1.20f)));       // magnification
 553                 m_cases.push_back(FilterCase(m_gridTex,         refInRangeUpper,                tcu::Vec2(-1.19f, -1.3f), tcu::Vec2(1.1f, 1.35f)));     // minification
 554                 m_cases.push_back(FilterCase(m_gridTex,         refInRangeLower,                tcu::Vec2(-1.2f, -1.1f), tcu::Vec2(-0.8f, -0.8f)));     // magnification
 555                 m_cases.push_back(FilterCase(m_gridTex,         refOutOfBoundsUpper,    tcu::Vec2(-0.61f, -0.1f), tcu::Vec2(0.9f, 1.18f)));     // reference value clamp, upper
 556
 557                 if (singleSample)
 558                         m_cases.push_back(FilterCase(m_gridTex, refOutOfBoundsLower, tcu::Vec2(-0.75f, 1.0f), tcu::Vec2(0.05f, 0.75f)));        // reference value clamp, lower
 559                 else
 560                         m_cases.push_back(FilterCase(m_gridTex, refOutOfBoundsLower, tcu::Vec2(-0.75f, 1.0f), tcu::Vec2(0.25f, 0.75f)));        // reference value clamp, lower
 561         }
 562
 563         m_caseNdx = 0;
 564         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 565 }
 566
 567 void TextureCubeShadowCase::deinit (void)
 568 {
 569         delete m_gradientTex;
 570         delete m_gridTex;
 571
 572         m_gradientTex   = DE_NULL;
 573         m_gridTex               = DE_NULL;
 574
 575         m_renderer.clear();
 576         m_cases.clear();
 577 }
 578
 579 static const char* getFaceDesc (const tcu::CubeFace face)
 580 {
 581         switch (face)
 582         {
 583                 case tcu::CUBEFACE_NEGATIVE_X:  return "-X";
 584                 case tcu::CUBEFACE_POSITIVE_X:  return "+X";
 585                 case tcu::CUBEFACE_NEGATIVE_Y:  return "-Y";
 586                 case tcu::CUBEFACE_POSITIVE_Y:  return "+Y";
 587                 case tcu::CUBEFACE_NEGATIVE_Z:  return "-Z";
 588                 case tcu::CUBEFACE_POSITIVE_Z:  return "+Z";
 589                 default:
 590                         DE_ASSERT(false);
 591                         return DE_NULL;
 592         }
 593 }
 594
 595 TextureCubeShadowCase::IterateResult TextureCubeShadowCase::iterate (void)
 596 {
 597         const glw::Functions&                   gl                              = m_context.getRenderContext().getFunctions();
 598         const int                                               viewportSize    = 28;
 599         const RandomViewport                    viewport                (m_context.getRenderTarget(), viewportSize, viewportSize, deStringHash(getName()) ^ deInt32Hash(m_caseNdx));
 600         const tcu::ScopedLogSection             iterSection             (m_testCtx.getLog(), string("Test") + de::toString(m_caseNdx), string("Test ") + de::toString(m_caseNdx));
 601         const FilterCase&                               curCase                 = m_cases[m_caseNdx];
 602         ReferenceParams                                 sampleParams    (TEXTURETYPE_CUBE);
 603
 604         if (viewport.width < viewportSize || viewport.height < viewportSize)
 605                 throw tcu::NotSupportedError("Too small render target", DE_NULL, __FILE__, __LINE__);
 606
 607         // Setup texture
 608         gl.bindTexture  (GL_TEXTURE_CUBE_MAP, curCase.texture->getGLTexture());
 609         gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER,    m_minFilter);
 610         gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER,    m_magFilter);
 611         gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S,                m_wrapS);
 612         gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T,                m_wrapT);
 613         gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_COMPARE_MODE,  GL_COMPARE_REF_TO_TEXTURE);
 614         gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_COMPARE_FUNC,  m_compareFunc);
 615
 616         // Other state
 617         gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height);
 618
 619         // Params for reference computation.
 620         sampleParams.sampler                                    = glu::mapGLSampler(GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE, m_minFilter, m_magFilter);
 621         sampleParams.sampler.seamlessCubeMap    = true;
 622         sampleParams.sampler.compare                    = glu::mapGLCompareFunc(m_compareFunc);
 623         sampleParams.samplerType                                = SAMPLERTYPE_SHADOW;
 624         sampleParams.lodMode                                    = LODMODE_EXACT;
 625         sampleParams.ref                                                = curCase.ref;
 626
 627         m_testCtx.getLog()
 628                 << TestLog::Message
 629                 << "Compare reference value =  " << sampleParams.ref << "\n"
 630                 << "Coordinates: " << curCase.bottomLeft << " -> " << curCase.topRight
 631                 << TestLog::EndMessage;
 632
 633         for (int faceNdx = 0; faceNdx < tcu::CUBEFACE_LAST; faceNdx++)
 634         {
 635                 const tcu::CubeFace             face            = tcu::CubeFace(faceNdx);
 636                 tcu::Surface                    result          (viewport.width, viewport.height);
 637                 vector<float>                   texCoord;
 638
 639                 computeQuadTexCoordCube(texCoord, face, curCase.bottomLeft, curCase.topRight);
 640
 641                 m_testCtx.getLog() << TestLog::Message << "Face " << getFaceDesc(face) << TestLog::EndMessage;
 642
 643                 // \todo Log texture coordinates.
 644
 645                 m_renderer.renderQuad(0, &texCoord[0], sampleParams);
 646                 GLU_EXPECT_NO_ERROR(gl.getError(), "Draw");
 647
 648                 glu::readPixels(m_context.getRenderContext(), viewport.x, viewport.y, result.getAccess());
 649                 GLU_EXPECT_NO_ERROR(gl.getError(), "Read pixels");
 650
 651                 {
 652                         const tcu::PixelFormat          pixelFormat             = m_context.getRenderTarget().getPixelFormat();
 653                         tcu::LodPrecision                       lodPrecision;
 654                         tcu::TexComparePrecision        texComparePrecision;
 655
 656                         lodPrecision.derivateBits                       = 10;
 657                         lodPrecision.lodBits                            = 5;
 658                         texComparePrecision.coordBits           = tcu::IVec3(10,10,10);
 659                         texComparePrecision.uvwBits                     = tcu::IVec3(6,6,0);
 660                         texComparePrecision.pcfBits                     = 5;
 661                         texComparePrecision.referenceBits       = 16;
 662                         texComparePrecision.resultBits          = pixelFormat.redBits-1;
 663
 664                         const bool isHighQuality = verifyTexCompareResult(m_testCtx, result.getAccess(), curCase.texture->getRefTexture(),
 665                                                                                                                           &texCoord[0], sampleParams, texComparePrecision, lodPrecision, pixelFormat);
 666
 667                         if (!isHighQuality)
 668                         {
 669                                 m_testCtx.getLog() << TestLog::Message << "Warning: Verification assuming high-quality PCF filtering failed." << TestLog::EndMessage;
 670
 671                                 lodPrecision.lodBits                    = 4;
 672                                 texComparePrecision.uvwBits             = tcu::IVec3(4,4,0);
 673                                 texComparePrecision.pcfBits             = 0;
 674
 675                                 const bool isOk = verifyTexCompareResult(m_testCtx, result.getAccess(), curCase.texture->getRefTexture(),
 676                                                                                                                  &texCoord[0], sampleParams, texComparePrecision, lodPrecision, pixelFormat);
 677
 678                                 if (!isOk)
 679                                 {
 680                                         m_testCtx.getLog() << TestLog::Message << "ERROR: Verification against low precision requirements failed, failing test case." << TestLog::EndMessage;
 681                                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image verification failed");
 682                                 }
 683                                 else if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 684                                         m_testCtx.setTestResult(QP_TEST_RESULT_QUALITY_WARNING, "Low-quality result");
 685                         }
 686                 }
 687         }
 688
 689         m_caseNdx += 1;
 690         return m_caseNdx < (int)m_cases.size() ? CONTINUE : STOP;
 691 }
 692
 693 class Texture2DArrayShadowCase : public TestCase
 694 {
 695 public:
 696                                                                 Texture2DArrayShadowCase        (Context& context, const char* name, const char* desc, deUint32 minFilter, deUint32 magFilter, deUint32 wrapS, deUint32 wrapT, deUint32 format, int width, int height, int numLayers, deUint32 compareFunc);
 697                                                                 ~Texture2DArrayShadowCase       (void);
 698
 699         void                                            init                                            (void);
 700         void                                            deinit                                          (void);
 701         IterateResult                           iterate                                         (void);
 702
 703 private:
 704                                                                 Texture2DArrayShadowCase        (const Texture2DArrayShadowCase& other);
 705         Texture2DArrayShadowCase&       operator=                                       (const Texture2DArrayShadowCase& other);
 706
 707         const deUint32                          m_minFilter;
 708         const deUint32                          m_magFilter;
 709         const deUint32                          m_wrapS;
 710         const deUint32                          m_wrapT;
 711
 712         const deUint32                          m_format;
 713         const int                                       m_width;
 714         const int                                       m_height;
 715         const int                                       m_numLayers;
 716
 717         const deUint32                          m_compareFunc;
 718
 719         struct FilterCase
 720         {
 721                 const glu::Texture2DArray*      texture;
 722                 tcu::Vec3                                       minCoord;
 723                 tcu::Vec3                                       maxCoord;
 724                 float                                           ref;
 725
 726                 FilterCase (void)
 727                         : texture       (DE_NULL)
 728                         , ref           (0.0f)
 729                 {
 730                 }
 731
 732                 FilterCase (const glu::Texture2DArray* tex_, float ref_, const tcu::Vec3& minCoord_, const tcu::Vec3& maxCoord_)
 733                         : texture       (tex_)
 734                         , minCoord      (minCoord_)
 735                         , maxCoord      (maxCoord_)
 736                         , ref           (ref_)
 737                 {
 738                 }
 739         };
 740
 741         glu::Texture2DArray*            m_gradientTex;
 742         glu::Texture2DArray*            m_gridTex;
 743         std::vector<FilterCase>         m_cases;
 744
 745         TextureRenderer                         m_renderer;
 746
 747         int                                                     m_caseNdx;
 748 };
 749
 750 Texture2DArrayShadowCase::Texture2DArrayShadowCase (Context& context, const char* name, const char* desc, deUint32 minFilter, deUint32 magFilter, deUint32 wrapS, deUint32 wrapT, deUint32 format, int width, int height, int numLayers, deUint32 compareFunc)
 751         : TestCase                      (context, name, desc)
 752         , m_minFilter           (minFilter)
 753         , m_magFilter           (magFilter)
 754         , m_wrapS                       (wrapS)
 755         , m_wrapT                       (wrapT)
 756         , m_format                      (format)
 757         , m_width                       (width)
 758         , m_height                      (height)
 759         , m_numLayers           (numLayers)
 760         , m_compareFunc         (compareFunc)
 761         , m_gradientTex         (DE_NULL)
 762         , m_gridTex                     (DE_NULL)
 763         , m_renderer            (context.getRenderContext(), context.getTestContext().getLog(), glu::GLSL_VERSION_300_ES, glu::PRECISION_HIGHP)
 764         , m_caseNdx                     (0)
 765 {
 766 }
 767
 768 Texture2DArrayShadowCase::~Texture2DArrayShadowCase (void)
 769 {
 770         Texture2DArrayShadowCase::deinit();
 771 }
 772
 773 void Texture2DArrayShadowCase::init (void)
 774 {
 775         try
 776         {
 777                 tcu::TextureFormat              texFmt          = glu::mapGLInternalFormat(m_format);
 778                 tcu::TextureFormatInfo  fmtInfo         = tcu::getTextureFormatInfo(texFmt);
 779                 tcu::Vec4                               cScale          = fmtInfo.valueMax-fmtInfo.valueMin;
 780                 tcu::Vec4                               cBias           = fmtInfo.valueMin;
 781                 int                                             numLevels       = deLog2Floor32(de::max(m_width, m_height)) + 1;
 782
 783                 // Create textures.
 784                 m_gradientTex   = new glu::Texture2DArray(m_context.getRenderContext(), m_format, m_width, m_height, m_numLayers);
 785                 m_gridTex               = new glu::Texture2DArray(m_context.getRenderContext(), m_format, m_width, m_height, m_numLayers);
 786
 787                 // Fill first gradient texture.
 788                 for (int levelNdx = 0; levelNdx < numLevels; levelNdx++)
 789                 {
 790                         tcu::Vec4 gMin = tcu::Vec4(-0.5f, -0.5f, -0.5f, 2.0f)*cScale + cBias;
 791                         tcu::Vec4 gMax = tcu::Vec4( 1.0f,  1.0f,  1.0f, 0.0f)*cScale + cBias;
 792
 793                         m_gradientTex->getRefTexture().allocLevel(levelNdx);
 794                         tcu::fillWithComponentGradients(m_gradientTex->getRefTexture().getLevel(levelNdx), gMin, gMax);
 795                 }
 796
 797                 // Fill second with grid texture.
 798                 for (int levelNdx = 0; levelNdx < numLevels; levelNdx++)
 799                 {
 800                         deUint32        step    = 0x00ffffff / numLevels;
 801                         deUint32        rgb             = step*levelNdx;
 802                         deUint32        colorA  = 0xff000000 | rgb;
 803                         deUint32        colorB  = 0xff000000 | ~rgb;
 804
 805                         m_gridTex->getRefTexture().allocLevel(levelNdx);
 806                         tcu::fillWithGrid(m_gridTex->getRefTexture().getLevel(levelNdx), 4, tcu::RGBA(colorA).toVec()*cScale + cBias, tcu::RGBA(colorB).toVec()*cScale + cBias);
 807                 }
 808
 809                 // Upload.
 810                 m_gradientTex->upload();
 811                 m_gridTex->upload();
 812         }
 813         catch (...)
 814         {
 815                 // Clean up to save memory.
 816                 Texture2DArrayShadowCase::deinit();
 817                 throw;
 818         }
 819
 820         // Compute cases.
 821         {
 822                 const float refInRangeUpper             = (m_compareFunc == GL_EQUAL || m_compareFunc == GL_NOTEQUAL) ? 1.0f : 0.5f;
 823                 const float refInRangeLower             = (m_compareFunc == GL_EQUAL || m_compareFunc == GL_NOTEQUAL) ? 0.0f : 0.5f;
 824                 const float refOutOfBoundsUpper = 1.1f;         // !< lookup function should clamp values to [0, 1] range
 825                 const float refOutOfBoundsLower = -0.1f;
 826
 827                 const struct
 828                 {
 829                         int             texNdx;
 830                         float   ref;
 831                         float   lodX;
 832                         float   lodY;
 833                         float   oX;
 834                         float   oY;
 835                 } cases[] =
 836                 {
 837                         { 0,    refInRangeUpper,                1.6f,   2.9f,   -1.0f,  -2.7f   },
 838                         { 0,    refInRangeLower,                -2.0f,  -1.35f, -0.2f,  0.7f    },
 839                         { 1,    refInRangeUpper,                0.14f,  0.275f, -1.5f,  -1.1f   },
 840                         { 1,    refInRangeLower,                -0.92f, -2.64f, 0.4f,   -0.1f   },
 841                         { 1,    refOutOfBoundsUpper,    -0.49f, -0.22f, 0.45f,  0.97f   },
 842                         { 1,    refOutOfBoundsLower,    -0.85f, 0.75f,  0.25f,  0.61f   },
 843                 };
 844
 845                 const float     viewportW       = (float)de::min<int>(TEX2D_VIEWPORT_WIDTH, m_context.getRenderTarget().getWidth());
 846                 const float     viewportH       = (float)de::min<int>(TEX2D_VIEWPORT_HEIGHT, m_context.getRenderTarget().getHeight());
 847
 848                 const float     minLayer        = -0.5f;
 849                 const float     maxLayer        = (float)m_numLayers;
 850
 851                 for (int caseNdx = 0; caseNdx < DE_LENGTH_OF_ARRAY(cases); caseNdx++)
 852                 {
 853                         const glu::Texture2DArray*      tex             = cases[caseNdx].texNdx > 0 ? m_gridTex : m_gradientTex;
 854                         const float                                     ref             = cases[caseNdx].ref;
 855                         const float                                     lodX    = cases[caseNdx].lodX;
 856                         const float                                     lodY    = cases[caseNdx].lodY;
 857                         const float                                     oX              = cases[caseNdx].oX;
 858                         const float                                     oY              = cases[caseNdx].oY;
 859                         const float                                     sX              = deFloatExp2(lodX)*viewportW / float(tex->getRefTexture().getWidth());
 860                         const float                                     sY              = deFloatExp2(lodY)*viewportH / float(tex->getRefTexture().getHeight());
 861
 862                         m_cases.push_back(FilterCase(tex, ref, tcu::Vec3(oX, oY, minLayer), tcu::Vec3(oX+sX, oY+sY, maxLayer)));
 863                 }
 864         }
 865
 866         m_caseNdx = 0;
 867         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 868 }
 869
 870 void Texture2DArrayShadowCase::deinit (void)
 871 {
 872         delete m_gradientTex;
 873         delete m_gridTex;
 874
 875         m_gradientTex   = DE_NULL;
 876         m_gridTex               = DE_NULL;
 877
 878         m_renderer.clear();
 879         m_cases.clear();
 880 }
 881
 882 Texture2DArrayShadowCase::IterateResult Texture2DArrayShadowCase::iterate (void)
 883 {
 884         const glw::Functions&                   gl                              = m_context.getRenderContext().getFunctions();
 885         const RandomViewport                    viewport                (m_context.getRenderTarget(), TEX2D_VIEWPORT_WIDTH, TEX2D_VIEWPORT_HEIGHT, deStringHash(getName()) ^ deInt32Hash(m_caseNdx));
 886         const FilterCase&                               curCase                 = m_cases[m_caseNdx];
 887         const tcu::ScopedLogSection             section                 (m_testCtx.getLog(), string("Test") + de::toString(m_caseNdx), string("Test ") + de::toString(m_caseNdx));
 888         ReferenceParams                                 sampleParams    (TEXTURETYPE_2D_ARRAY);
 889         tcu::Surface                                    rendered                (viewport.width, viewport.height);
 890
 891         const float                                             texCoord[]              =
 892         {
 893                 curCase.minCoord.x(), curCase.minCoord.y(), curCase.minCoord.z(),
 894                 curCase.minCoord.x(), curCase.maxCoord.y(), (curCase.minCoord.z() + curCase.maxCoord.z()) / 2.0f,
 895                 curCase.maxCoord.x(), curCase.minCoord.y(), (curCase.minCoord.z() + curCase.maxCoord.z()) / 2.0f,
 896                 curCase.maxCoord.x(), curCase.maxCoord.y(), curCase.maxCoord.z()
 897         };
 898
 899         if (viewport.width < TEX2D_MIN_VIEWPORT_WIDTH || viewport.height < TEX2D_MIN_VIEWPORT_HEIGHT)
 900                 throw tcu::NotSupportedError("Too small render target", "", __FILE__, __LINE__);
 901
 902         // Setup params for reference.
 903         sampleParams.sampler                    = glu::mapGLSampler(m_wrapS, m_wrapT, m_minFilter, m_magFilter);
 904         sampleParams.sampler.compare    = glu::mapGLCompareFunc(m_compareFunc);
 905         sampleParams.samplerType                = SAMPLERTYPE_SHADOW;
 906         sampleParams.lodMode                    = LODMODE_EXACT;
 907         sampleParams.ref                                = curCase.ref;
 908
 909         m_testCtx.getLog()
 910                 << TestLog::Message
 911                 << "Compare reference value =  " << sampleParams.ref << "\n"
 912                 << "Texture coordinates: " << curCase.minCoord << " -> " << curCase.maxCoord
 913                 << TestLog::EndMessage;
 914
 915         gl.bindTexture  (GL_TEXTURE_2D_ARRAY, curCase.texture->getGLTexture());
 916         gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER,    m_minFilter);
 917         gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER,    m_magFilter);
 918         gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_S,                m_wrapS);
 919         gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_T,                m_wrapT);
 920         gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_COMPARE_MODE,  GL_COMPARE_REF_TO_TEXTURE);
 921         gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_COMPARE_FUNC,  m_compareFunc);
 922
 923         gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height);
 924         m_renderer.renderQuad(0, &texCoord[0], sampleParams);
 925         glu::readPixels(m_context.getRenderContext(), viewport.x, viewport.y, rendered.getAccess());
 926
 927         {
 928                 const tcu::PixelFormat          pixelFormat             = m_context.getRenderTarget().getPixelFormat();
 929                 tcu::LodPrecision                       lodPrecision;
 930                 tcu::TexComparePrecision        texComparePrecision;
 931
 932                 lodPrecision.derivateBits                       = 18;
 933                 lodPrecision.lodBits                            = 6;
 934                 texComparePrecision.coordBits           = tcu::IVec3(20,20,20);
 935                 texComparePrecision.uvwBits                     = tcu::IVec3(7,7,7);
 936                 texComparePrecision.pcfBits                     = 5;
 937                 texComparePrecision.referenceBits       = 16;
 938                 texComparePrecision.resultBits          = pixelFormat.redBits-1;
 939
 940                 const bool isHighQuality = verifyTexCompareResult(m_testCtx, rendered.getAccess(), curCase.texture->getRefTexture(),
 941                                                                                                                   &texCoord[0], sampleParams, texComparePrecision, lodPrecision, pixelFormat);
 942
 943                 if (!isHighQuality)
 944                 {
 945                         m_testCtx.getLog() << TestLog::Message << "Warning: Verification assuming high-quality PCF filtering failed." << TestLog::EndMessage;
 946
 947                         lodPrecision.lodBits                    = 4;
 948                         texComparePrecision.uvwBits             = tcu::IVec3(4,4,4);
 949                         texComparePrecision.pcfBits             = 0;
 950
 951                         const bool isOk = verifyTexCompareResult(m_testCtx, rendered.getAccess(), curCase.texture->getRefTexture(),
 952                                                                                                          &texCoord[0], sampleParams, texComparePrecision, lodPrecision, pixelFormat);
 953
 954                         if (!isOk)
 955                         {
 956                                 m_testCtx.getLog() << TestLog::Message << "ERROR: Verification against low precision requirements failed, failing test case." << TestLog::EndMessage;
 957                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image verification failed");
 958                         }
 959                         else if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 960                                 m_testCtx.setTestResult(QP_TEST_RESULT_QUALITY_WARNING, "Low-quality result");
 961                 }
 962         }
 963
 964         m_caseNdx += 1;
 965         return m_caseNdx < (int)m_cases.size() ? CONTINUE : STOP;
 966 }
 967
 968 TextureShadowTests::TextureShadowTests (Context& context)
 969         : TestCaseGroup(context, "shadow", "Shadow texture lookup tests")
 970 {
 971 }
 972
 973 TextureShadowTests::~TextureShadowTests (void)
 974 {
 975 }
 976
 977 void TextureShadowTests::init (void)
 978 {
 979         static const struct
 980         {
 981                 const char*             name;
 982                 deUint32                format;
 983         } formats[] =
 984         {
 985                 { "depth_component16",  GL_DEPTH_COMPONENT16    },
 986                 { "depth_component32f", GL_DEPTH_COMPONENT32F   },
 987                 { "depth24_stencil8",   GL_DEPTH24_STENCIL8             }
 988         };
 989
 990         static const struct
 991         {
 992                 const char*             name;
 993                 deUint32                minFilter;
 994                 deUint32                magFilter;
 995         } filters[] =
 996         {
 997                 { "nearest",                            GL_NEAREST,                                     GL_NEAREST      },
 998                 { "linear",                                     GL_LINEAR,                                      GL_LINEAR       },
 999                 { "nearest_mipmap_nearest",     GL_NEAREST_MIPMAP_NEAREST,      GL_LINEAR       },
1000                 { "linear_mipmap_nearest",      GL_LINEAR_MIPMAP_NEAREST,       GL_LINEAR       },
1001                 { "nearest_mipmap_linear",      GL_NEAREST_MIPMAP_LINEAR,       GL_LINEAR       },
1002                 { "linear_mipmap_linear",       GL_LINEAR_MIPMAP_LINEAR,        GL_LINEAR       }
1003         };
1004
1005         static const struct
1006         {
1007                 const char*             name;
1008                 deUint32                func;
1009         } compareFuncs[] =
1010         {
1011                 { "less_or_equal",              GL_LEQUAL       },
1012                 { "greater_or_equal",   GL_GEQUAL       },
1013                 { "less",                               GL_LESS         },
1014                 { "greater",                    GL_GREATER      },
1015                 { "equal",                              GL_EQUAL        },
1016                 { "not_equal",                  GL_NOTEQUAL     },
1017                 { "always",                             GL_ALWAYS       },
1018                 { "never",                              GL_NEVER        }
1019         };
1020
1021         // 2D cases.
1022         {
1023                 tcu::TestCaseGroup* group2D = new tcu::TestCaseGroup(m_testCtx, "2d", "2D texture shadow lookup tests");
1024                 addChild(group2D);
1025
1026                 for (int filterNdx = 0; filterNdx < DE_LENGTH_OF_ARRAY(filters); filterNdx++)
1027                 {
1028                         tcu::TestCaseGroup* filterGroup = new tcu::TestCaseGroup(m_testCtx, filters[filterNdx].name, "");
1029                         group2D->addChild(filterGroup);
1030
1031                         for (int compareNdx = 0; compareNdx < DE_LENGTH_OF_ARRAY(compareFuncs); compareNdx++)
1032                         {
1033                                 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(formats); formatNdx++)
1034                                 {
1035                                         deUint32                minFilter               = filters[filterNdx].minFilter;
1036                                         deUint32                magFilter               = filters[filterNdx].magFilter;
1037                                         deUint32                format                  = formats[formatNdx].format;
1038                                         deUint32                compareFunc             = compareFuncs[compareNdx].func;
1039                                         const deUint32  wrapS                   = GL_REPEAT;
1040                                         const deUint32  wrapT                   = GL_REPEAT;
1041                                         const int               width                   = 32;
1042                                         const int               height                  = 64;
1043                                         string                  name                    = string(compareFuncs[compareNdx].name) + "_" + formats[formatNdx].name;
1044
1045                                         filterGroup->addChild(new Texture2DShadowCase(m_context, name.c_str(), "", minFilter, magFilter, wrapS, wrapT, format, width, height, compareFunc));
1046                                 }
1047                         }
1048                 }
1049         }
1050
1051         // Cubemap cases.
1052         {
1053                 tcu::TestCaseGroup* groupCube = new tcu::TestCaseGroup(m_testCtx, "cube", "Cube map texture shadow lookup tests");
1054                 addChild(groupCube);
1055
1056                 for (int filterNdx = 0; filterNdx < DE_LENGTH_OF_ARRAY(filters); filterNdx++)
1057                 {
1058                         tcu::TestCaseGroup* filterGroup = new tcu::TestCaseGroup(m_testCtx, filters[filterNdx].name, "");
1059                         groupCube->addChild(filterGroup);
1060
1061                         for (int compareNdx = 0; compareNdx < DE_LENGTH_OF_ARRAY(compareFuncs); compareNdx++)
1062                         {
1063                                 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(formats); formatNdx++)
1064                                 {
1065                                         deUint32                minFilter               = filters[filterNdx].minFilter;
1066                                         deUint32                magFilter               = filters[filterNdx].magFilter;
1067                                         deUint32                format                  = formats[formatNdx].format;
1068                                         deUint32                compareFunc             = compareFuncs[compareNdx].func;
1069                                         const deUint32  wrapS                   = GL_REPEAT;
1070                                         const deUint32  wrapT                   = GL_REPEAT;
1071                                         const int               size                    = 32;
1072                                         string                  name                    = string(compareFuncs[compareNdx].name) + "_" + formats[formatNdx].name;
1073
1074                                         filterGroup->addChild(new TextureCubeShadowCase(m_context, name.c_str(), "", minFilter, magFilter, wrapS, wrapT, format, size, compareFunc));
1075                                 }
1076                         }
1077                 }
1078         }
1079
1080         // 2D array cases.
1081         {
1082                 tcu::TestCaseGroup* group2DArray = new tcu::TestCaseGroup(m_testCtx, "2d_array", "2D texture array shadow lookup tests");
1083                 addChild(group2DArray);
1084
1085                 for (int filterNdx = 0; filterNdx < DE_LENGTH_OF_ARRAY(filters); filterNdx++)
1086                 {
1087                         tcu::TestCaseGroup* filterGroup = new tcu::TestCaseGroup(m_testCtx, filters[filterNdx].name, "");
1088                         group2DArray->addChild(filterGroup);
1089
1090                         for (int compareNdx = 0; compareNdx < DE_LENGTH_OF_ARRAY(compareFuncs); compareNdx++)
1091                         {
1092                                 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(formats); formatNdx++)
1093                                 {
1094                                         deUint32                minFilter               = filters[filterNdx].minFilter;
1095                                         deUint32                magFilter               = filters[filterNdx].magFilter;
1096                                         deUint32                format                  = formats[formatNdx].format;
1097                                         deUint32                compareFunc             = compareFuncs[compareNdx].func;
1098                                         const deUint32  wrapS                   = GL_REPEAT;
1099                                         const deUint32  wrapT                   = GL_REPEAT;
1100                                         const int               width                   = 32;
1101                                         const int               height                  = 64;
1102                                         const int               numLayers               = 8;
1103                                         string                  name                    = string(compareFuncs[compareNdx].name) + "_" + formats[formatNdx].name;
1104
1105                                         filterGroup->addChild(new Texture2DArrayShadowCase(m_context, name.c_str(), "", minFilter, magFilter, wrapS, wrapT, format, width, height, numLayers, compareFunc));
1106                                 }
1107                         }
1108                 }
1109         }
1110 }
1111
1112 } // Functional
1113 } // gles3
1114 } // deqp