modules/gles31/functional/es31fTextureBorderClampTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program OpenGL ES 3.1 Module
   3  * -------------------------------------------------
   4  *
   5  * Copyright 2015 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 border clamp tests.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "es31fTextureBorderClampTests.hpp"
  25
  26 #include "glsTextureTestUtil.hpp"
  27
  28 #include "tcuTextureUtil.hpp"
  29 #include "tcuTexLookupVerifier.hpp"
  30 #include "tcuTexCompareVerifier.hpp"
  31 #include "tcuCompressedTexture.hpp"
  32 #include "tcuResultCollector.hpp"
  33 #include "tcuSurface.hpp"
  34 #include "tcuSeedBuilder.hpp"
  35 #include "tcuVectorUtil.hpp"
  36
  37 #include "rrGenericVector.hpp"
  38
  39 #include "gluContextInfo.hpp"
  40 #include "gluTexture.hpp"
  41 #include "gluTextureUtil.hpp"
  42 #include "gluPixelTransfer.hpp"
  43 #include "gluStrUtil.hpp"
  44 #include "gluObjectWrapper.hpp"
  45 #include "gluShaderProgram.hpp"
  46 #include "gluDrawUtil.hpp"
  47
  48 #include "glwEnums.hpp"
  49 #include "glwFunctions.hpp"
  50
  51 #include "deStringUtil.hpp"
  52 #include "deUniquePtr.hpp"
  53 #include "deRandom.hpp"
  54
  55 #include <limits>
  56
  57
  58 namespace deqp
  59 {
  60 namespace gles31
  61 {
  62 namespace Functional
  63 {
  64 namespace
  65 {
  66
  67 enum SizeType
  68 {
  69         SIZE_POT = 0,
  70         SIZE_NPOT
  71 };
  72
  73 bool filterRequiresFilterability (deUint32 filter)
  74 {
  75         switch (filter)
  76         {
  77                 case GL_NEAREST:
  78                 case GL_NEAREST_MIPMAP_NEAREST:
  79                         return false;
  80
  81                 case GL_LINEAR:
  82                 case GL_LINEAR_MIPMAP_NEAREST:
  83                 case GL_NEAREST_MIPMAP_LINEAR:
  84                 case GL_LINEAR_MIPMAP_LINEAR:
  85                         return true;
  86
  87                 default:
  88                         DE_ASSERT(false);
  89                         return false;
  90         }
  91 }
  92
  93 bool isDepthFormat (deUint32 format, tcu::Sampler::DepthStencilMode mode)
  94 {
  95         if (format == GL_LUMINANCE || format == GL_LUMINANCE_ALPHA || format == GL_ALPHA || format == GL_BGRA)
  96         {
  97                 // Unsized formats are a special case
  98                 return false;
  99         }
 100         else if (glu::isCompressedFormat(format))
 101         {
 102                 // no known compressed depth formats
 103                 return false;
 104         }
 105         else
 106         {
 107                 const tcu::TextureFormat fmt = glu::mapGLInternalFormat(format);
 108
 109                 if (fmt.order == tcu::TextureFormat::D)
 110                 {
 111                         DE_ASSERT(mode == tcu::Sampler::MODE_DEPTH);
 112                         return true;
 113                 }
 114                 else if (fmt.order == tcu::TextureFormat::DS && mode == tcu::Sampler::MODE_DEPTH)
 115                         return true;
 116                 else
 117                         return false;
 118         }
 119 }
 120
 121 bool isStencilFormat (deUint32 format, tcu::Sampler::DepthStencilMode mode)
 122 {
 123         if (format == GL_LUMINANCE || format == GL_LUMINANCE_ALPHA || format == GL_ALPHA || format == GL_BGRA)
 124         {
 125                 // Unsized formats are a special case
 126                 return false;
 127         }
 128         else if (glu::isCompressedFormat(format))
 129         {
 130                 // no known compressed stencil formats
 131                 return false;
 132         }
 133         else
 134         {
 135                 const tcu::TextureFormat fmt = glu::mapGLInternalFormat(format);
 136
 137                 if (fmt.order == tcu::TextureFormat::S)
 138                 {
 139                         DE_ASSERT(mode == tcu::Sampler::MODE_STENCIL);
 140                         return true;
 141                 }
 142                 else if (fmt.order == tcu::TextureFormat::DS && mode == tcu::Sampler::MODE_STENCIL)
 143                         return true;
 144                 else
 145                         return false;
 146         }
 147 }
 148
 149 tcu::TextureChannelClass getFormatChannelClass (deUint32 format, tcu::Sampler::DepthStencilMode mode)
 150 {
 151         if (format == GL_LUMINANCE || format == GL_LUMINANCE_ALPHA || format == GL_ALPHA || format == GL_BGRA)
 152         {
 153                 // Unsized formats are a special c, use UNORM8
 154                 return tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT;
 155         }
 156         else if (glu::isCompressedFormat(format))
 157         {
 158                 const tcu::CompressedTexFormat  compressedFmt   = glu::mapGLCompressedTexFormat(format);
 159                 const tcu::TextureFormat                uncompressedFmt = tcu::getUncompressedFormat(compressedFmt);
 160                 return tcu::getTextureChannelClass(uncompressedFmt.type);
 161         }
 162         else
 163         {
 164                 const tcu::TextureFormat fmt                    = glu::mapGLInternalFormat(format);
 165                 const tcu::TextureFormat effectiveFmt   = tcu::getEffectiveDepthStencilTextureFormat(fmt, mode);
 166
 167                 return tcu::getTextureChannelClass(effectiveFmt.type);
 168         }
 169 }
 170
 171 int getDimensionNumBlocks (int dimensionSize, int blockSize)
 172 {
 173         // ceil( a / b )
 174         return (dimensionSize + blockSize - 1) / blockSize;
 175 }
 176
 177 void generateDummyCompressedData (tcu::CompressedTexture& dst, const tcu::CompressedTexFormat& format)
 178 {
 179         const int                       blockByteSize   = tcu::getBlockSize(format);
 180         const tcu::IVec3        blockPixelSize  = tcu::getBlockPixelSize(format);
 181         const tcu::IVec3        numBlocks               (getDimensionNumBlocks(dst.getWidth(),    blockPixelSize.x()),
 182                                                                                  getDimensionNumBlocks(dst.getHeight(),   blockPixelSize.y()),
 183                                                                                  getDimensionNumBlocks(dst.getDepth(),    blockPixelSize.z()));
 184         const int                       numTotalBlocks  = numBlocks.x() * numBlocks.y() * numBlocks.z();
 185         const int                       dataSize                = numTotalBlocks * blockByteSize;
 186
 187         DE_ASSERT(dst.getDataSize() == dataSize);
 188
 189         if (tcu::isAstcFormat(format))
 190         {
 191                 // generate data that is valid in LDR mode
 192                 const int               BLOCK_SIZE                      = 16;
 193                 const deUint8   block[BLOCK_SIZE]       = { 252, 253, 255, 255, 255, 255, 255, 255, 223, 251, 28, 206, 54, 251, 160, 174 };
 194
 195                 DE_ASSERT(blockByteSize == BLOCK_SIZE);
 196                 for (int ndx = 0; ndx < numTotalBlocks; ++ndx)
 197                         deMemcpy((deUint8*)dst.getData() + ndx * BLOCK_SIZE, block, BLOCK_SIZE);
 198         }
 199         else
 200         {
 201                 // any data is ok
 202                 de::Random rnd(0xabc);
 203
 204                 for (int ndx = 0; ndx < dataSize; ++ndx)
 205                         ((deUint8*)dst.getData())[ndx] = rnd.getUint8();
 206         }
 207 }
 208
 209 template <typename T>
 210 struct TextureTraits
 211 {
 212 };
 213
 214 template <>
 215 struct TextureTraits<glu::Texture2D>
 216 {
 217         typedef tcu::IVec2 SizeType;
 218
 219         static de::MovePtr<glu::Texture2D> createTextureFromInternalFormat (glu::RenderContext& renderCtx, deUint32 texFormat, const tcu::IVec2& size)
 220         {
 221                 return de::MovePtr<glu::Texture2D>(new glu::Texture2D(renderCtx, texFormat, size.x(), size.y()));
 222         }
 223
 224         static de::MovePtr<glu::Texture2D> createTextureFromFormatAndType (glu::RenderContext& renderCtx, deUint32 texFormat, deUint32 type, const tcu::IVec2& size)
 225         {
 226                 return de::MovePtr<glu::Texture2D>(new glu::Texture2D(renderCtx, texFormat, type, size.x(), size.y()));
 227         }
 228
 229         static de::MovePtr<glu::Texture2D> createTextureFromCompressedData (glu::RenderContext&                                 renderCtx,
 230                                                                                                                                                 const glu::ContextInfo&                         ctxInfo,
 231                                                                                                                                                 const tcu::CompressedTexture&           compressedLevel,
 232                                                                                                                                                 const tcu::TexDecompressionParams&      decompressionParams)
 233         {
 234                 return de::MovePtr<glu::Texture2D>(new glu::Texture2D(renderCtx,
 235                                                                                                                           ctxInfo,
 236                                                                                                                           1,
 237                                                                                                                           &compressedLevel,
 238                                                                                                                           decompressionParams));
 239         }
 240
 241         static int getTextureNumLayers (const tcu::IVec2& size)
 242         {
 243                 // 2D textures have one layer
 244                 DE_UNREF(size);
 245                 return 1;
 246         }
 247 };
 248
 249 template <>
 250 struct TextureTraits<glu::Texture3D>
 251 {
 252         typedef tcu::IVec3 SizeType;
 253
 254         static de::MovePtr<glu::Texture3D> createTextureFromInternalFormat (glu::RenderContext& renderCtx, deUint32 texFormat, const tcu::IVec3& size)
 255         {
 256                 return de::MovePtr<glu::Texture3D>(new glu::Texture3D(renderCtx, texFormat, size.x(), size.y(), size.z()));
 257         }
 258
 259         static de::MovePtr<glu::Texture3D> createTextureFromFormatAndType (glu::RenderContext& renderCtx, deUint32 texFormat, deUint32 type, const tcu::IVec3& size)
 260         {
 261                 return de::MovePtr<glu::Texture3D>(new glu::Texture3D(renderCtx, texFormat, type, size.x(), size.y(), size.z()));
 262         }
 263
 264         static de::MovePtr<glu::Texture3D> createTextureFromCompressedData (glu::RenderContext&                                 renderCtx,
 265                                                                                                                                                 const glu::ContextInfo&                         ctxInfo,
 266                                                                                                                                                 const tcu::CompressedTexture&           compressedLevel,
 267                                                                                                                                                 const tcu::TexDecompressionParams&      decompressionParams)
 268         {
 269                 return de::MovePtr<glu::Texture3D>(new glu::Texture3D(renderCtx,
 270                                                                                                                           ctxInfo,
 271                                                                                                                           1,
 272                                                                                                                           &compressedLevel,
 273                                                                                                                           decompressionParams));
 274         }
 275
 276         static int getTextureNumLayers (const tcu::IVec3& size)
 277         {
 278                 // 3D textures have Z layers
 279                 return size.z();
 280         }
 281 };
 282
 283 template <typename T>
 284 de::MovePtr<T> genDummyTexture (glu::RenderContext& renderCtx, const glu::ContextInfo& ctxInfo, deUint32 texFormat, const typename TextureTraits<T>::SizeType& size)
 285 {
 286         de::MovePtr<T> texture;
 287
 288         if (isDepthFormat(texFormat, tcu::Sampler::MODE_DEPTH) || isStencilFormat(texFormat, tcu::Sampler::MODE_STENCIL))
 289         {
 290                 // fill different channels with different gradients
 291                 texture = TextureTraits<T>::createTextureFromInternalFormat(renderCtx, texFormat, size);
 292                 texture->getRefTexture().allocLevel(0);
 293
 294                 if (isDepthFormat(texFormat, tcu::Sampler::MODE_DEPTH))
 295                 {
 296                         // fill depth with 0 -> 1
 297                         const tcu::PixelBufferAccess depthAccess = tcu::getEffectiveDepthStencilAccess(texture->getRefTexture().getLevel(0), tcu::Sampler::MODE_DEPTH);
 298                         tcu::fillWithComponentGradients(depthAccess, tcu::Vec4(0.0f), tcu::Vec4(1.0f));
 299                 }
 300
 301                 if (isStencilFormat(texFormat, tcu::Sampler::MODE_STENCIL))
 302                 {
 303                         // fill stencil with 0 -> max
 304                         const tcu::PixelBufferAccess    stencilAccess   = tcu::getEffectiveDepthStencilAccess(texture->getRefTexture().getLevel(0), tcu::Sampler::MODE_STENCIL);
 305                         const tcu::TextureFormatInfo    texFormatInfo   = tcu::getTextureFormatInfo(stencilAccess.getFormat());
 306
 307                         // Flip y to make stencil and depth cases not look identical
 308                         tcu::fillWithComponentGradients(tcu::flipYAccess(stencilAccess), texFormatInfo.valueMax, texFormatInfo.valueMin);
 309                 }
 310
 311                 texture->upload();
 312         }
 313         else if (!glu::isCompressedFormat(texFormat))
 314         {
 315                 if (texFormat == GL_LUMINANCE || texFormat == GL_LUMINANCE_ALPHA || texFormat == GL_ALPHA || texFormat == GL_BGRA)
 316                         texture = TextureTraits<T>::createTextureFromFormatAndType(renderCtx, texFormat, GL_UNSIGNED_BYTE, size);
 317                 else
 318                         texture = TextureTraits<T>::createTextureFromInternalFormat(renderCtx, texFormat, size);
 319
 320                 // Fill level 0.
 321                 texture->getRefTexture().allocLevel(0);
 322
 323                 // fill with gradient min -> max
 324                 {
 325                         const tcu::TextureFormatInfo    texFormatInfo   = tcu::getTextureFormatInfo(texture->getRefTexture().getFormat());
 326                         const tcu::Vec4                                 rampLow                 = texFormatInfo.valueMin;
 327                         const tcu::Vec4                                 rampHigh                = texFormatInfo.valueMax;
 328                         tcu::fillWithComponentGradients(texture->getRefTexture().getLevel(0), rampLow, rampHigh);
 329                 }
 330
 331                 texture->upload();
 332         }
 333         else
 334         {
 335                 const tcu::CompressedTexFormat  compressedFormat        = glu::mapGLCompressedTexFormat(texFormat);
 336                 const int                                               numLayers                       = TextureTraits<T>::getTextureNumLayers(size);
 337                 tcu::CompressedTexture                  compressedLevel         (compressedFormat, size.x(), size.y(), numLayers);
 338                 const bool                                              isAstcFormat            = tcu::isAstcFormat(compressedFormat);
 339                 tcu::TexDecompressionParams             decompressionParams     ((isAstcFormat) ? (tcu::TexDecompressionParams::ASTCMODE_LDR) : (tcu::TexDecompressionParams::ASTCMODE_LAST));
 340
 341                 generateDummyCompressedData(compressedLevel, compressedFormat);
 342
 343                 texture = TextureTraits<T>::createTextureFromCompressedData(renderCtx,
 344                                                                                                                                         ctxInfo,
 345                                                                                                                                         compressedLevel,
 346                                                                                                                                         decompressionParams);
 347         }
 348
 349         return texture;
 350 }
 351
 352 int getNBitIntegerMaxValue (bool isSigned, int numBits)
 353 {
 354         DE_ASSERT(numBits < 32);
 355
 356         if (numBits == 0)
 357                 return 0;
 358         else if (isSigned)
 359                 return deIntMaxValue32(numBits);
 360         else
 361                 return deUintMaxValue32(numBits);
 362 }
 363
 364 int getNBitIntegerMinValue (bool isSigned, int numBits)
 365 {
 366         DE_ASSERT(numBits < 32);
 367
 368         if (numBits == 0)
 369                 return 0;
 370         else if (isSigned)
 371                 return deIntMinValue32(numBits);
 372         else
 373                 return 0;
 374 }
 375
 376 tcu::IVec4 getNBitIntegerVec4MaxValue (bool isSigned, const tcu::IVec4& numBits)
 377 {
 378         return tcu::IVec4(getNBitIntegerMaxValue(isSigned, numBits[0]),
 379                                           getNBitIntegerMaxValue(isSigned, numBits[1]),
 380                                           getNBitIntegerMaxValue(isSigned, numBits[2]),
 381                                           getNBitIntegerMaxValue(isSigned, numBits[3]));
 382 }
 383
 384 tcu::IVec4 getNBitIntegerVec4MinValue (bool isSigned, const tcu::IVec4& numBits)
 385 {
 386         return tcu::IVec4(getNBitIntegerMinValue(isSigned, numBits[0]),
 387                                           getNBitIntegerMinValue(isSigned, numBits[1]),
 388                                           getNBitIntegerMinValue(isSigned, numBits[2]),
 389                                           getNBitIntegerMinValue(isSigned, numBits[3]));
 390 }
 391
 392 rr::GenericVec4 mapToFormatColorUnits (const tcu::TextureFormat& texFormat, const tcu::Vec4& normalizedRange)
 393 {
 394         const tcu::TextureFormatInfo texFormatInfo = tcu::getTextureFormatInfo(texFormat);
 395
 396         switch (tcu::getTextureChannelClass(texFormat.type))
 397         {
 398                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:             return rr::GenericVec4(normalizedRange);
 399                 case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:               return rr::GenericVec4(normalizedRange * 2.0f - 1.0f);
 400                 case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:                   return rr::GenericVec4(texFormatInfo.valueMin + normalizedRange * texFormatInfo.valueMax);
 401                 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:                   return rr::GenericVec4(tcu::mix(texFormatInfo.valueMin, texFormatInfo.valueMax, normalizedRange).cast<deInt32>());
 402                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:                 return rr::GenericVec4(tcu::mix(texFormatInfo.valueMin, texFormatInfo.valueMax, normalizedRange).cast<deUint32>());
 403
 404                 default:
 405                         DE_ASSERT(false);
 406                         return rr::GenericVec4();
 407         }
 408 }
 409
 410 rr::GenericVec4 mapToFormatColorRepresentable (const tcu::TextureFormat& texFormat, const tcu::Vec4& normalizedRange)
 411 {
 412         // make sure value is representable in the target format and clear channels
 413         // not present in the target format.
 414
 415         const rr::GenericVec4           inFormatUnits   = mapToFormatColorUnits(texFormat, normalizedRange);
 416         const tcu::BVec4                        channelMask             = tcu::getTextureFormatChannelMask(texFormat);
 417         de::ArrayBuffer<deUint8, 4>     buffer                  (texFormat.getPixelSize());
 418         tcu::PixelBufferAccess          access                  (texFormat, tcu::IVec3(1, 1, 1), buffer.getPtr());
 419
 420         if (tcu::isSRGB(texFormat))
 421         {
 422                 DE_ASSERT(texFormat.type == tcu::TextureFormat::UNORM_INT8);
 423
 424                 // make sure border color (in linear space) can be converted to 8-bit sRGB space without
 425                 // significant loss.
 426                 const tcu::Vec4         sRGB            = tcu::linearToSRGB(normalizedRange);
 427                 const tcu::IVec4        sRGB8           = tcu::IVec4(tcu::floatToU8(sRGB[0]),
 428                                                                                                          tcu::floatToU8(sRGB[1]),
 429                                                                                                          tcu::floatToU8(sRGB[2]),
 430                                                                                                          tcu::floatToU8(sRGB[3]));
 431                 const tcu::Vec4         linearized      = tcu::sRGBToLinear(tcu::Vec4((float)sRGB8[0] / 255.0f,
 432                                                                                                                                           (float)sRGB8[1] / 255.0f,
 433                                                                                                                                           (float)sRGB8[2] / 255.0f,
 434                                                                                                                                           (float)sRGB8[3] / 255.0f));
 435
 436                 return rr::GenericVec4(tcu::select(linearized, tcu::Vec4(0.0f), channelMask));
 437         }
 438
 439         switch (tcu::getTextureChannelClass(texFormat.type))
 440         {
 441                 case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
 442                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
 443                 case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
 444                 {
 445                         access.setPixel(inFormatUnits.get<float>(), 0, 0);
 446                         return rr::GenericVec4(tcu::select(access.getPixel(0, 0), tcu::Vec4(0.0f), channelMask));
 447                 }
 448                 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
 449                 {
 450                         access.setPixel(inFormatUnits.get<deInt32>(), 0, 0);
 451                         return rr::GenericVec4(tcu::select(access.getPixelInt(0, 0), tcu::IVec4(0), channelMask));
 452                 }
 453                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
 454                 {
 455                         access.setPixel(inFormatUnits.get<deUint32>(), 0, 0);
 456                         return rr::GenericVec4(tcu::select(access.getPixelUint(0, 0), tcu::UVec4(0u), channelMask));
 457                 }
 458                 default:
 459                 {
 460                         DE_ASSERT(false);
 461                         return rr::GenericVec4();
 462                 }
 463         }
 464 }
 465
 466 bool isCoreFilterableFormat (deUint32 format, tcu::Sampler::DepthStencilMode mode)
 467 {
 468         const bool      isLuminanceOrAlpha              = (format == GL_LUMINANCE || format == GL_ALPHA || format == GL_LUMINANCE_ALPHA); // special case for luminance/alpha
 469         const bool      isUnsizedColorFormat    = (format == GL_BGRA);
 470         const bool      isCompressed                    = glu::isCompressedFormat(format);
 471         const bool      isDepth                                 = isDepthFormat(format, mode);
 472         const bool      isStencil                               = isStencilFormat(format, mode);
 473
 474         // special cases
 475         if (isLuminanceOrAlpha || isUnsizedColorFormat || isCompressed)
 476                 return true;
 477         if (isStencil || isDepth)
 478                 return false;
 479
 480         // color case
 481         return glu::isGLInternalColorFormatFilterable(format);
 482 }
 483
 484 class TextureBorderClampTest : public TestCase
 485 {
 486 public:
 487         enum StateType
 488         {
 489                 STATE_SAMPLER_PARAM = 0,
 490                 STATE_TEXTURE_PARAM,
 491
 492                 STATE_LAST
 493         };
 494
 495         enum SamplingFunction
 496         {
 497                 SAMPLE_FILTER = 0,
 498                 SAMPLE_GATHER,
 499
 500                 SAMPLE_LAST
 501         };
 502
 503         enum Flag
 504         {
 505                 FLAG_USE_SHADOW_SAMPLER = (1u << 0),
 506         };
 507
 508         struct IterationConfig
 509         {
 510                 tcu::Vec2               p0;
 511                 tcu::Vec2               p1;
 512                 rr::GenericVec4 borderColor;
 513                 tcu::Vec4               lookupScale;
 514                 tcu::Vec4               lookupBias;
 515                 deUint32                minFilter;
 516                 deUint32                magFilter;
 517                 std::string             description;
 518                 deUint32                sWrapMode;
 519                 deUint32                tWrapMode;
 520                 deUint32                compareMode;
 521                 float                   compareRef;
 522         };
 523
 524                                                                                                                 TextureBorderClampTest          (Context&                                               context,
 525                                                                                                                                                                          const char*                                    name,
 526                                                                                                                                                                          const char*                                    description,
 527                                                                                                                                                                          deUint32                                               texFormat,
 528                                                                                                                                                                          tcu::Sampler::DepthStencilMode mode,
 529                                                                                                                                                                          StateType                                              stateType,
 530                                                                                                                                                                          int                                                    texWidth,
 531                                                                                                                                                                          int                                                    texHeight,
 532                                                                                                                                                                          SamplingFunction                               samplingFunction,
 533                                                                                                                                                                          deUint32                                               flags                           = 0);
 534                                                                                                                 ~TextureBorderClampTest         (void);
 535
 536 protected:
 537         void                                                                                            init                                            (void);
 538         void                                                                                            deinit                                          (void);
 539
 540 private:
 541         IterateResult                                                                           iterate                                         (void);
 542
 543         void                                                                                            logParams                                       (const IterationConfig&                                                 config,
 544                                                                                                                                                                          const glu::TextureTestUtil::ReferenceParams&   samplerParams);
 545
 546         void                                                                                            renderTo                                        (tcu::Surface&                                                                  surface,
 547                                                                                                                                                                          const IterationConfig&                                                 config,
 548                                                                                                                                                                          const glu::TextureTestUtil::ReferenceParams&   samplerParams);
 549         void                                                                                            renderQuad                                      (const float*                                                                   texCoord,
 550                                                                                                                                                                          const glu::TextureTestUtil::ReferenceParams&   samplerParams);
 551
 552         void                                                                                            verifyImage                                     (const tcu::Surface&                                                    image,
 553                                                                                                                                                                          const IterationConfig&                                                 config,
 554                                                                                                                                                                          const glu::TextureTestUtil::ReferenceParams&   samplerParams);
 555
 556         bool                                                                                            verifyTextureSampleResult       (const tcu::ConstPixelBufferAccess&                             renderedFrame,
 557                                                                                                                                                                          const float*                                                                   texCoord,
 558                                                                                                                                                                          const glu::TextureTestUtil::ReferenceParams&   samplerParams,
 559                                                                                                                                                                          const tcu::LodPrecision&                                               lodPrecision,
 560                                                                                                                                                                          const tcu::LookupPrecision&                                    lookupPrecision);
 561
 562         bool                                                                                            verifyTextureCompareResult      (const tcu::ConstPixelBufferAccess&                             renderedFrame,
 563                                                                                                                                                                          const float*                                                                   texCoord,
 564                                                                                                                                                                          const glu::TextureTestUtil::ReferenceParams&   samplerParams,
 565                                                                                                                                                                          const tcu::TexComparePrecision&                                texComparePrecision,
 566                                                                                                                                                                          const tcu::TexComparePrecision&                                lowQualityTexComparePrecision,
 567                                                                                                                                                                          const tcu::LodPrecision&                                               lodPrecision,
 568                                                                                                                                                                          const tcu::LodPrecision&                                               lowQualityLodPrecision);
 569
 570         bool                                                                                            verifyTextureGatherResult       (const tcu::ConstPixelBufferAccess&                             renderedFrame,
 571                                                                                                                                                                          const float*                                                                   texCoord,
 572                                                                                                                                                                          const glu::TextureTestUtil::ReferenceParams&   samplerParams,
 573                                                                                                                                                                          const tcu::LookupPrecision&                                    lookupPrecision);
 574
 575         bool                                                                                            verifyTextureGatherCmpResult(const tcu::ConstPixelBufferAccess&                         renderedFrame,
 576                                                                                                                                                                          const float*                                                                   texCoord,
 577                                                                                                                                                                          const glu::TextureTestUtil::ReferenceParams&   samplerParams,
 578                                                                                                                                                                          const tcu::TexComparePrecision&                                texComparePrecision,
 579                                                                                                                                                                          const tcu::TexComparePrecision&                                lowQualityTexComparePrecision);
 580
 581         deUint32                                                                                        getIterationSeed                        (const IterationConfig& config) const;
 582         glu::TextureTestUtil::ReferenceParams                           genSamplerParams                        (const IterationConfig& config) const;
 583         glu::ShaderProgram*                                                                     genGatherProgram                        (void) const;
 584
 585         virtual int                                                                                     getNumIterations                        (void) const = 0;
 586         virtual IterationConfig                                                         getIteration                            (int ndx) const = 0;
 587
 588 protected:
 589         const glu::Texture2D*                                                           getTexture                                              (void) const;
 590
 591         const deUint32                                                                          m_texFormat;
 592         const tcu::Sampler::DepthStencilMode                            m_sampleMode;
 593         const tcu::TextureChannelClass                                          m_channelClass;
 594         const StateType                                                                         m_stateType;
 595
 596         const int                                                                                       m_texHeight;
 597         const int                                                                                       m_texWidth;
 598
 599         const SamplingFunction                                                          m_samplingFunction;
 600         const bool                                                                                      m_useShadowSampler;
 601 private:
 602         enum
 603         {
 604                 VIEWPORT_WIDTH          = 128,
 605                 VIEWPORT_HEIGHT         = 128,
 606         };
 607
 608         de::MovePtr<glu::Texture2D>                                                     m_texture;
 609         de::MovePtr<gls::TextureTestUtil::TextureRenderer>      m_renderer;
 610         de::MovePtr<glu::ShaderProgram>                                         m_gatherProgram;
 611
 612         int                                                                                                     m_iterationNdx;
 613         tcu::ResultCollector                                                            m_result;
 614 };
 615
 616 TextureBorderClampTest::TextureBorderClampTest (Context&                                                context,
 617                                                                                                 const char*                                             name,
 618                                                                                                 const char*                                             description,
 619                                                                                                 deUint32                                                texFormat,
 620                                                                                                 tcu::Sampler::DepthStencilMode  mode,
 621                                                                                                 StateType                                               stateType,
 622                                                                                                 int                                                             texWidth,
 623                                                                                                 int                                                             texHeight,
 624                                                                                                 SamplingFunction                                samplingFunction,
 625                                                                                                 deUint32                                                flags)
 626         : TestCase                              (context, name, description)
 627         , m_texFormat                   (texFormat)
 628         , m_sampleMode                  (mode)
 629         , m_channelClass                (getFormatChannelClass(texFormat, mode))
 630         , m_stateType                   (stateType)
 631         , m_texHeight                   (texHeight)
 632         , m_texWidth                    (texWidth)
 633         , m_samplingFunction    (samplingFunction)
 634         , m_useShadowSampler    ((flags & FLAG_USE_SHADOW_SAMPLER) != 0)
 635         , m_iterationNdx                (0)
 636         , m_result                              (context.getTestContext().getLog())
 637 {
 638         DE_ASSERT(stateType < STATE_LAST);
 639         DE_ASSERT(samplingFunction < SAMPLE_LAST);
 640         // mode must be set for combined depth-stencil formats
 641         DE_ASSERT(m_channelClass != tcu::TEXTURECHANNELCLASS_LAST || mode != tcu::Sampler::MODE_LAST);
 642 }
 643
 644 TextureBorderClampTest::~TextureBorderClampTest (void)
 645 {
 646         deinit();
 647 }
 648
 649 void TextureBorderClampTest::init (void)
 650 {
 651         // requirements
 652         const bool supportsES32 = glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2));
 653
 654         if (!supportsES32 && !m_context.getContextInfo().isExtensionSupported("GL_EXT_texture_border_clamp"))
 655                 throw tcu::NotSupportedError("Test requires GL_EXT_texture_border_clamp extension");
 656
 657         if (glu::isCompressedFormat(m_texFormat)                                                                                                        &&
 658                 !supportsES32                                                                                                                                                   &&
 659                 tcu::isAstcFormat(glu::mapGLCompressedTexFormat(m_texFormat))                                                   &&
 660                 !m_context.getContextInfo().isExtensionSupported("GL_KHR_texture_compression_astc_ldr"))
 661         {
 662                 throw tcu::NotSupportedError("Test requires GL_KHR_texture_compression_astc_ldr extension");
 663         }
 664
 665         if (m_texFormat == GL_BGRA && !m_context.getContextInfo().isExtensionSupported("GL_EXT_texture_format_BGRA8888"))
 666                 throw tcu::NotSupportedError("Test requires GL_EXT_texture_format_BGRA8888 extension");
 667
 668         if (m_context.getRenderTarget().getWidth() < VIEWPORT_WIDTH ||
 669                 m_context.getRenderTarget().getHeight() < VIEWPORT_HEIGHT)
 670         {
 671                 throw tcu::NotSupportedError("Test requires " + de::toString<int>(VIEWPORT_WIDTH) + "x" + de::toString<int>(VIEWPORT_HEIGHT) + " viewport");
 672         }
 673
 674         // resources
 675
 676         m_texture = genDummyTexture<glu::Texture2D>(m_context.getRenderContext(), m_context.getContextInfo(), m_texFormat, tcu::IVec2(m_texWidth, m_texHeight));
 677
 678         m_testCtx.getLog()      << tcu::TestLog::Message
 679                                                 << "Created texture with format " << glu::getTextureFormatName(m_texFormat)
 680                                                 << ", size (" << m_texture->getRefTexture().getWidth() << ", " << m_texture->getRefTexture().getHeight() << ")\n"
 681                                                 << "Setting sampling state using " << ((m_stateType == STATE_TEXTURE_PARAM) ? ("texture state") : ("sampler state"))
 682                                                 << tcu::TestLog::EndMessage;
 683
 684         if (m_samplingFunction == SAMPLE_FILTER)
 685         {
 686                 const glu::GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType());
 687
 688                 m_renderer = de::MovePtr<gls::TextureTestUtil::TextureRenderer>(new gls::TextureTestUtil::TextureRenderer(m_context.getRenderContext(), m_testCtx.getLog(), glslVersion, glu::PRECISION_HIGHP));
 689         }
 690         else
 691         {
 692                 m_gatherProgram = de::MovePtr<glu::ShaderProgram>(genGatherProgram());
 693
 694                 m_testCtx.getLog()      << tcu::TestLog::Message
 695                                                         << "Using texture gather to sample texture"
 696                                                         << tcu::TestLog::EndMessage
 697                                                         << *m_gatherProgram;
 698
 699                 if (!m_gatherProgram->isOk())
 700                         throw tcu::TestError("failed to build program");
 701         }
 702 }
 703
 704 void TextureBorderClampTest::deinit (void)
 705 {
 706         m_texture.clear();
 707         m_renderer.clear();
 708         m_gatherProgram.clear();
 709 }
 710
 711 TextureBorderClampTest::IterateResult TextureBorderClampTest::iterate (void)
 712 {
 713         const IterationConfig                                           iterationConfig         = getIteration(m_iterationNdx);
 714         const std::string                                                       iterationDesc           = "Iteration " + de::toString(m_iterationNdx+1) + (iterationConfig.description.empty() ? ("") : (" - " + iterationConfig.description));
 715         const tcu::ScopedLogSection                                     section                         (m_testCtx.getLog(), "Iteration", iterationDesc);
 716         tcu::Surface                                                            renderedFrame           (VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
 717         const glu::TextureTestUtil::ReferenceParams     samplerParams           = genSamplerParams(iterationConfig);
 718
 719         logParams(iterationConfig, samplerParams);
 720         renderTo(renderedFrame, iterationConfig, samplerParams);
 721         verifyImage(renderedFrame, iterationConfig, samplerParams);
 722
 723         if (++m_iterationNdx == getNumIterations())
 724         {
 725                 m_result.setTestContextResult(m_testCtx);
 726                 return STOP;
 727         }
 728         return CONTINUE;
 729 }
 730
 731 void TextureBorderClampTest::logParams (const IterationConfig& config, const glu::TextureTestUtil::ReferenceParams& samplerParams)
 732 {
 733         const std::string                               borderColorString       = (m_channelClass == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER)   ? (de::toString(config.borderColor.get<deInt32>()))
 734                                                                                                                 : (m_channelClass == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER) ? (de::toString(config.borderColor.get<deUint32>()))
 735                                                                                                                 :                                                                                                                                 (de::toString(config.borderColor.get<float>()));
 736
 737         m_testCtx.getLog()      << tcu::TestLog::Message
 738                                                 << "Rendering full screen quad, tex coords bottom-left: " << config.p0 << ", top-right " << config.p1 << "\n"
 739                                                 << "Border color is " << borderColorString << "\n"
 740                                                 << "Texture lookup bias: " << samplerParams.colorBias << "\n"
 741                                                 << "Texture lookup scale: " << samplerParams.colorScale << "\n"
 742                                                 << "Filters: min = " << glu::getTextureFilterName(glu::getGLFilterMode(samplerParams.sampler.minFilter))
 743                                                         << ", mag = " << glu::getTextureFilterName(glu::getGLFilterMode(samplerParams.sampler.magFilter)) << "\n"
 744                                                 << "Wrap mode: s = " << glu::getRepeatModeStr(config.sWrapMode)
 745                                                         << ", t = " << glu::getRepeatModeStr(config.tWrapMode) << "\n"
 746                                                 << tcu::TestLog::EndMessage;
 747
 748         if (m_sampleMode == tcu::Sampler::MODE_DEPTH)
 749                 m_testCtx.getLog() << tcu::TestLog::Message << "Depth stencil texture mode is DEPTH_COMPONENT" << tcu::TestLog::EndMessage;
 750         else if (m_sampleMode == tcu::Sampler::MODE_STENCIL)
 751                 m_testCtx.getLog() << tcu::TestLog::Message << "Depth stencil texture mode is STENCIL_INDEX" << tcu::TestLog::EndMessage;
 752
 753         if (config.compareMode != GL_NONE)
 754         {
 755                 m_testCtx.getLog()      << tcu::TestLog::Message
 756                                                         << "Texture mode is COMPARE_REF_TO_TEXTURE, mode = " << glu::getCompareFuncStr(config.compareMode) << "\n"
 757                                                         << "Compare reference value = " << config.compareRef << "\n"
 758                                                         << tcu::TestLog::EndMessage;
 759         }
 760 }
 761
 762 void TextureBorderClampTest::renderTo (tcu::Surface&                                                            surface,
 763                                                                            const IterationConfig&                                               config,
 764                                                                            const glu::TextureTestUtil::ReferenceParams& samplerParams)
 765 {
 766         const glw::Functions&                                           gl                      = m_context.getRenderContext().getFunctions();
 767         const gls::TextureTestUtil::RandomViewport      viewport        (m_context.getRenderTarget(), VIEWPORT_WIDTH, VIEWPORT_HEIGHT, getIterationSeed(config));
 768         std::vector<float>                                                      texCoord;
 769         de::MovePtr<glu::Sampler>                                       sampler;
 770
 771         glu::TextureTestUtil::computeQuadTexCoord2D(texCoord, config.p0, config.p1);
 772
 773         // Bind to unit 0.
 774         gl.activeTexture(GL_TEXTURE0);
 775         gl.bindTexture(GL_TEXTURE_2D, m_texture->getGLTexture());
 776
 777         if (m_sampleMode == tcu::Sampler::MODE_DEPTH)
 778                 gl.texParameteri(GL_TEXTURE_2D, GL_DEPTH_STENCIL_TEXTURE_MODE, GL_DEPTH_COMPONENT);
 779         else if (m_sampleMode == tcu::Sampler::MODE_STENCIL)
 780                 gl.texParameteri(GL_TEXTURE_2D, GL_DEPTH_STENCIL_TEXTURE_MODE, GL_STENCIL_INDEX);
 781
 782         if (config.compareMode == GL_NONE)
 783         {
 784                 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_NONE);
 785                 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_ALWAYS);
 786         }
 787         else
 788         {
 789                 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
 790                 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, config.compareMode);
 791         }
 792
 793         if (m_stateType == STATE_TEXTURE_PARAM)
 794         {
 795                 // Setup filtering and wrap modes.
 796                 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,              glu::getGLWrapMode(samplerParams.sampler.wrapS));
 797                 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,              glu::getGLWrapMode(samplerParams.sampler.wrapT));
 798                 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,  glu::getGLFilterMode(samplerParams.sampler.minFilter));
 799                 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,  glu::getGLFilterMode(samplerParams.sampler.magFilter));
 800
 801                 switch (m_channelClass)
 802                 {
 803                         case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
 804                         case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
 805                         case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
 806                                 gl.texParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, config.borderColor.getAccess<float>());
 807                                 break;
 808
 809                         case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
 810                                 gl.texParameterIiv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, config.borderColor.getAccess<deInt32>());
 811                                 break;
 812
 813                         case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
 814                                 gl.texParameterIuiv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, config.borderColor.getAccess<deUint32>());
 815                                 break;
 816
 817                         default:
 818                                 DE_ASSERT(false);
 819                 }
 820         }
 821         else if (m_stateType == STATE_SAMPLER_PARAM)
 822         {
 823                 const tcu::Vec4 blue(0.0f, 0.0f, 1.0f, 1.0f);
 824
 825                 // Setup filtering and wrap modes to bad values
 826                 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,              GL_REPEAT);
 827                 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,              GL_REPEAT);
 828                 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,  GL_NEAREST);
 829                 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,  GL_NEAREST);
 830                 gl.texParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, blue.getPtr()); // just set some unlikely color
 831
 832                 // setup sampler to correct values
 833                 sampler = de::MovePtr<glu::Sampler>(new glu::Sampler(m_context.getRenderContext()));
 834
 835                 gl.samplerParameteri(**sampler, GL_TEXTURE_WRAP_S,              glu::getGLWrapMode(samplerParams.sampler.wrapS));
 836                 gl.samplerParameteri(**sampler, GL_TEXTURE_WRAP_T,              glu::getGLWrapMode(samplerParams.sampler.wrapT));
 837                 gl.samplerParameteri(**sampler, GL_TEXTURE_MIN_FILTER,  glu::getGLFilterMode(samplerParams.sampler.minFilter));
 838                 gl.samplerParameteri(**sampler, GL_TEXTURE_MAG_FILTER,  glu::getGLFilterMode(samplerParams.sampler.magFilter));
 839
 840                 switch (m_channelClass)
 841                 {
 842                         case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
 843                         case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
 844                         case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
 845                                 gl.samplerParameterfv(**sampler, GL_TEXTURE_BORDER_COLOR, config.borderColor.getAccess<float>());
 846                                 break;
 847
 848                         case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
 849                                 gl.samplerParameterIiv(**sampler, GL_TEXTURE_BORDER_COLOR, config.borderColor.getAccess<deInt32>());
 850                                 break;
 851
 852                         case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
 853                                 gl.samplerParameterIuiv(**sampler, GL_TEXTURE_BORDER_COLOR, config.borderColor.getAccess<deUint32>());
 854                                 break;
 855
 856                         default:
 857                                 DE_ASSERT(false);
 858                 }
 859
 860                 gl.bindSampler(0, **sampler);
 861         }
 862
 863         GLU_EXPECT_NO_ERROR(gl.getError(), "Set texturing state");
 864
 865         gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height);
 866         renderQuad(&texCoord[0], samplerParams);
 867         glu::readPixels(m_context.getRenderContext(), viewport.x, viewport.y, surface.getAccess());
 868 }
 869
 870 void TextureBorderClampTest::renderQuad (const float* texCoord, const glu::TextureTestUtil::ReferenceParams& samplerParams)
 871 {
 872         // use TextureRenderer for basic rendering, use custom for gather
 873         if (m_samplingFunction == SAMPLE_FILTER)
 874                 m_renderer->renderQuad(0, texCoord, samplerParams);
 875         else
 876         {
 877                 static const float position[] =
 878                 {
 879                         -1.0f, -1.0f, 0.0f, 1.0f,
 880                         -1.0f, +1.0f, 0.0f, 1.0f,
 881                         +1.0f, -1.0f, 0.0f, 1.0f,
 882                         +1.0f, +1.0f, 0.0f, 1.0f
 883                 };
 884                 static const deUint16 indices[] =
 885                 {
 886                         0, 1, 2, 2, 1, 3
 887                 };
 888                 const glu::VertexArrayBinding vertexArrays[] =
 889                 {
 890                         glu::va::Float("a_position",    4,      4, 0, &position[0]),
 891                         glu::va::Float("a_texcoord",    2,      4, 0, texCoord)
 892                 };
 893
 894                 const glw::Functions&   gl              = m_context.getRenderContext().getFunctions();
 895                 const deUint32                  progId  = m_gatherProgram->getProgram();
 896
 897                 gl.useProgram(progId);
 898                 gl.uniform1i(gl.getUniformLocation(progId, "u_sampler"), 0);
 899                 if (m_useShadowSampler)
 900                         gl.uniform1f(gl.getUniformLocation(progId, "u_ref"), samplerParams.ref);
 901                 gl.uniform4fv(gl.getUniformLocation(progId, "u_colorScale"), 1, samplerParams.colorScale.getPtr());
 902                 gl.uniform4fv(gl.getUniformLocation(progId, "u_colorBias"), 1, samplerParams.colorBias.getPtr());
 903
 904                 glu::draw(m_context.getRenderContext(), progId, DE_LENGTH_OF_ARRAY(vertexArrays), &vertexArrays[0],
 905                                         glu::pr::Triangles(DE_LENGTH_OF_ARRAY(indices), &indices[0]));
 906         }
 907 }
 908
 909 void TextureBorderClampTest::verifyImage (const tcu::Surface&                                                   renderedFrame,
 910                                                                                   const IterationConfig&                                                config,
 911                                                                                   const glu::TextureTestUtil::ReferenceParams&  samplerParams)
 912 {
 913         const tcu::PixelFormat  pixelFormat             = m_context.getRenderTarget().getPixelFormat();
 914
 915         tcu::LodPrecision               lodPrecision;
 916         std::vector<float>              texCoord;
 917         bool                                    verificationOk;
 918
 919         glu::TextureTestUtil::computeQuadTexCoord2D(texCoord, config.p0, config.p1);
 920
 921         lodPrecision.derivateBits               = 18;
 922         lodPrecision.lodBits                    = 5;
 923
 924         if (samplerParams.sampler.compare == tcu::Sampler::COMPAREMODE_NONE)
 925         {
 926                 const tcu::TextureFormat                texFormat                       = tcu::getEffectiveDepthStencilTextureFormat(m_texture->getRefTexture().getFormat(), m_sampleMode);
 927                 const bool                                              isNearestMinFilter      = samplerParams.sampler.minFilter == tcu::Sampler::NEAREST || samplerParams.sampler.minFilter == tcu::Sampler::NEAREST_MIPMAP_NEAREST;
 928                 const bool                                              isNearestMagFilter      = samplerParams.sampler.magFilter == tcu::Sampler::NEAREST;
 929                 const bool                                              isNearestOnly           = isNearestMinFilter && isNearestMagFilter;
 930                 const bool                                              isSRGB                          = texFormat.order == tcu::TextureFormat::sRGB || texFormat.order == tcu::TextureFormat::sRGBA;
 931                 const int                                               colorErrorBits          = (isNearestOnly && !isSRGB) ? (1) : (2);
 932                 const tcu::IVec4                                colorBits                       = tcu::max(glu::TextureTestUtil::getBitsVec(pixelFormat) - tcu::IVec4(colorErrorBits), tcu::IVec4(0));
 933                 tcu::LookupPrecision                    lookupPrecision;
 934
 935                 lookupPrecision.colorThreshold  = tcu::computeFixedPointThreshold(colorBits) / samplerParams.colorScale;
 936                 lookupPrecision.coordBits               = tcu::IVec3(20,20,0);
 937                 lookupPrecision.uvwBits                 = tcu::IVec3(5,5,0);
 938                 lookupPrecision.colorMask               = glu::TextureTestUtil::getCompareMask(pixelFormat);
 939
 940                 if (m_samplingFunction == SAMPLE_FILTER)
 941                 {
 942                         verificationOk = verifyTextureSampleResult(renderedFrame.getAccess(),
 943                                                                                                            &texCoord[0],
 944                                                                                                            samplerParams,
 945                                                                                                            lodPrecision,
 946                                                                                                            lookupPrecision);
 947                 }
 948                 else if (m_samplingFunction == SAMPLE_GATHER)
 949                 {
 950                         verificationOk = verifyTextureGatherResult(renderedFrame.getAccess(),
 951                                                                                                            &texCoord[0],
 952                                                                                                            samplerParams,
 953                                                                                                            lookupPrecision);
 954                 }
 955                 else
 956                 {
 957                         DE_ASSERT(false);
 958                         verificationOk = false;
 959                 }
 960         }
 961         else
 962         {
 963                 tcu::TexComparePrecision        texComparePrecision;
 964                 tcu::TexComparePrecision        lowQualityTexComparePrecision;
 965                 tcu::LodPrecision                       lowQualityLodPrecision                  = lodPrecision;
 966
 967                 texComparePrecision.coordBits                                   = tcu::IVec3(20,20,0);
 968                 texComparePrecision.uvwBits                                             = tcu::IVec3(7,7,0);
 969                 texComparePrecision.pcfBits                                             = 5;
 970                 texComparePrecision.referenceBits                               = 16;
 971                 texComparePrecision.resultBits                                  = de::max(0, pixelFormat.redBits - 1);
 972
 973                 lowQualityTexComparePrecision.coordBits                 = tcu::IVec3(20,20,0);
 974                 lowQualityTexComparePrecision.uvwBits                   = tcu::IVec3(4,4,0);
 975                 lowQualityTexComparePrecision.pcfBits                   = 0;
 976                 lowQualityTexComparePrecision.referenceBits             = 16;
 977                 lowQualityTexComparePrecision.resultBits                = de::max(0, pixelFormat.redBits - 1);
 978
 979                 lowQualityLodPrecision.lodBits                                  = 4;
 980
 981                 if (m_samplingFunction == SAMPLE_FILTER)
 982                 {
 983                         verificationOk = verifyTextureCompareResult(renderedFrame.getAccess(),
 984                                                                                                                 &texCoord[0],
 985                                                                                                                 samplerParams,
 986                                                                                                                 texComparePrecision,
 987                                                                                                                 lowQualityTexComparePrecision,
 988                                                                                                                 lodPrecision,
 989                                                                                                                 lowQualityLodPrecision);
 990                 }
 991                 else if (m_samplingFunction == SAMPLE_GATHER)
 992                 {
 993                         verificationOk = verifyTextureGatherCmpResult(renderedFrame.getAccess(),
 994                                                                                                                   &texCoord[0],
 995                                                                                                                   samplerParams,
 996                                                                                                                   texComparePrecision,
 997                                                                                                                   lowQualityTexComparePrecision);
 998                 }
 999                 else
1000                 {
1001                         DE_ASSERT(false);
1002                         verificationOk = false;
1003                 }
1004         }
1005
1006         if (!verificationOk)
1007                 m_result.fail("Image verification failed");
1008 }
1009
1010 bool TextureBorderClampTest::verifyTextureSampleResult (const tcu::ConstPixelBufferAccess&                              renderedFrame,
1011                                                                                                                 const float*                                                                    texCoord,
1012                                                                                                                 const glu::TextureTestUtil::ReferenceParams&    samplerParams,
1013                                                                                                                 const tcu::LodPrecision&                                                lodPrecision,
1014                                                                                                             const tcu::LookupPrecision&                                         lookupPrecision)
1015 {
1016         const tcu::PixelFormat                  pixelFormat                     = m_context.getRenderTarget().getPixelFormat();
1017         tcu::Surface                                    reference                       (renderedFrame.getWidth(), renderedFrame.getHeight());
1018         tcu::Surface                                    errorMask                       (renderedFrame.getWidth(), renderedFrame.getHeight());
1019         int                                                             numFailedPixels;
1020
1021         glu::TextureTestUtil::sampleTexture(tcu::SurfaceAccess(reference, pixelFormat), m_texture->getRefTexture(), texCoord, samplerParams);
1022
1023         numFailedPixels = glu::TextureTestUtil::computeTextureLookupDiff(renderedFrame, reference.getAccess(), errorMask.getAccess(), m_texture->getRefTexture(),
1024                                                                                                                                          texCoord, samplerParams, lookupPrecision, lodPrecision, m_testCtx.getWatchDog());
1025
1026         if (numFailedPixels > 0)
1027                 m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: Result verification failed, got " << numFailedPixels << " invalid pixels!" << tcu::TestLog::EndMessage;
1028         m_testCtx.getLog()      << tcu::TestLog::ImageSet("VerifyResult", "Verification result")
1029                                                 << tcu::TestLog::Image("Rendered", "Rendered image", renderedFrame);
1030         if (numFailedPixels > 0)
1031         {
1032                 m_testCtx.getLog()      << tcu::TestLog::Image("Reference", "Ideal reference image", reference)
1033                                                         << tcu::TestLog::Image("ErrorMask", "Error mask", errorMask);
1034         }
1035         m_testCtx.getLog() << tcu::TestLog::EndImageSet;
1036
1037         return (numFailedPixels == 0);
1038 }
1039
1040 bool TextureBorderClampTest::verifyTextureCompareResult (const tcu::ConstPixelBufferAccess&                             renderedFrame,
1041                                                                                                                  const float*                                                                   texCoord,
1042                                                                                                                  const glu::TextureTestUtil::ReferenceParams&   samplerParams,
1043                                                                                                              const tcu::TexComparePrecision&                            texComparePrecision,
1044                                                                                                              const tcu::TexComparePrecision&                            lowQualityTexComparePrecision,
1045                                                                                                                  const tcu::LodPrecision&                                               lodPrecision,
1046                                                                                                                  const tcu::LodPrecision&                                               lowQualityLodPrecision)
1047 {
1048         const tcu::PixelFormat                                          pixelFormat                             = m_context.getRenderTarget().getPixelFormat();
1049         const int                                                                       colorErrorBits                  = 1;
1050         const tcu::IVec4                                                        nonShadowBits                   = tcu::max(glu::TextureTestUtil::getBitsVec(pixelFormat) - tcu::IVec4(colorErrorBits), tcu::IVec4(0));
1051         const tcu::Vec3                                                         nonShadowThreshold              = tcu::computeFixedPointThreshold(nonShadowBits).swizzle(1,2,3);
1052         std::vector<tcu::ConstPixelBufferAccess>        srcLevelStorage;
1053         const tcu::Texture2DView                                        effectiveView                   = tcu::getEffectiveTextureView(m_texture->getRefTexture(), srcLevelStorage, samplerParams.sampler);
1054         tcu::Surface                                                            reference                               (renderedFrame.getWidth(), renderedFrame.getHeight());
1055         tcu::Surface                                                            errorMask                               (renderedFrame.getWidth(), renderedFrame.getHeight());
1056         int                                                                                     numFailedPixels;
1057
1058         glu::TextureTestUtil::sampleTexture(tcu::SurfaceAccess(reference, pixelFormat), effectiveView, texCoord, samplerParams);
1059
1060         numFailedPixels = glu::TextureTestUtil::computeTextureCompareDiff(renderedFrame, reference.getAccess(), errorMask.getAccess(), effectiveView,
1061                                                                                                                                           texCoord, samplerParams, texComparePrecision, lodPrecision, nonShadowThreshold);
1062
1063         if (numFailedPixels > 0)
1064         {
1065                 m_testCtx.getLog()      << tcu::TestLog::Message
1066                                                         << "Warning: Verification assuming high-quality PCF filtering failed."
1067                                                         << tcu::TestLog::EndMessage;
1068
1069                 numFailedPixels = glu::TextureTestUtil::computeTextureCompareDiff(renderedFrame, reference.getAccess(), errorMask.getAccess(), effectiveView,
1070                                                                                                                                                   texCoord, samplerParams, lowQualityTexComparePrecision, lowQualityLodPrecision, nonShadowThreshold);
1071
1072                 if (numFailedPixels > 0)
1073                         m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: Verification against low precision requirements failed, failing test case." << tcu::TestLog::EndMessage;
1074                 else if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS)
1075                         m_result.addResult(QP_TEST_RESULT_QUALITY_WARNING, "Low-quality result");
1076         }
1077
1078         if (numFailedPixels > 0)
1079                 m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: Result verification failed, got " << numFailedPixels << " invalid pixels!" << tcu::TestLog::EndMessage;
1080         m_testCtx.getLog()      << tcu::TestLog::ImageSet("VerifyResult", "Verification result")
1081                                                 << tcu::TestLog::Image("Rendered", "Rendered image", renderedFrame);
1082         if (numFailedPixels > 0)
1083         {
1084                 m_testCtx.getLog()      << tcu::TestLog::Image("Reference", "Ideal reference image", reference)
1085                                                         << tcu::TestLog::Image("ErrorMask", "Error mask", errorMask);
1086         }
1087         m_testCtx.getLog() << tcu::TestLog::EndImageSet;
1088
1089         return (numFailedPixels == 0);
1090 }
1091
1092 template <typename T>
1093 static inline T triQuadInterpolate (const T (&values)[4], float xFactor, float yFactor)
1094 {
1095         if (xFactor + yFactor < 1.0f)
1096                 return values[0] + (values[2]-values[0])*xFactor                + (values[1]-values[0])*yFactor;
1097         else
1098                 return values[3] + (values[1]-values[3])*(1.0f-xFactor) + (values[2]-values[3])*(1.0f-yFactor);
1099 }
1100
1101 bool TextureBorderClampTest::verifyTextureGatherResult (const tcu::ConstPixelBufferAccess&                              renderedFrame,
1102                                                                                                                 const float*                                                                    texCoordArray,
1103                                                                                                                 const glu::TextureTestUtil::ReferenceParams&    samplerParams,
1104                                                                                                                 const tcu::LookupPrecision&                                             lookupPrecision)
1105 {
1106         const tcu::Vec2 texCoords[4] =
1107         {
1108                 tcu::Vec2(texCoordArray[0], texCoordArray[1]),
1109                 tcu::Vec2(texCoordArray[2], texCoordArray[3]),
1110                 tcu::Vec2(texCoordArray[4], texCoordArray[5]),
1111                 tcu::Vec2(texCoordArray[6], texCoordArray[7]),
1112         };
1113
1114         const tcu::PixelFormat                                          pixelFormat                     = m_context.getRenderTarget().getPixelFormat();
1115         const deUint8                                                           fbColormask                     = tcu::getColorMask(pixelFormat);
1116
1117         std::vector<tcu::ConstPixelBufferAccess>        srcLevelStorage;
1118         const tcu::Texture2DView                                        effectiveView           = tcu::getEffectiveTextureView(m_texture->getRefTexture(), srcLevelStorage, samplerParams.sampler);
1119
1120         tcu::Surface                                                            reference                       (renderedFrame.getWidth(), renderedFrame.getHeight());
1121         tcu::Surface                                                            errorMask                       (renderedFrame.getWidth(), renderedFrame.getHeight());
1122         int                                                                                     numFailedPixels         = 0;
1123
1124         tcu::clear(errorMask.getAccess(), tcu::RGBA::green().toVec());
1125
1126         for (int py = 0; py < reference.getHeight(); ++py)
1127         for (int px = 0; px < reference.getWidth(); ++px)
1128         {
1129                 const tcu::Vec2                 viewportCoord   = (tcu::Vec2((float)px, (float)py) + tcu::Vec2(0.5f)) / tcu::Vec2((float)reference.getWidth(), (float)reference.getHeight());
1130                 const tcu::Vec2                 texCoord                = triQuadInterpolate(texCoords, viewportCoord.x(), viewportCoord.y());
1131                 const tcu::Vec4                 referenceValue  = effectiveView.gatherOffsets(samplerParams.sampler, texCoord.x(), texCoord.y(), 0, glu::getDefaultGatherOffsets());
1132                 const tcu::Vec4                 referencePixel  = referenceValue * samplerParams.colorScale + samplerParams.colorBias;
1133                 const tcu::Vec4                 resultPixel             = renderedFrame.getPixel(px, py);
1134                 const tcu::Vec4                 resultValue             = (resultPixel - samplerParams.colorBias) / samplerParams.colorScale;
1135
1136                 reference.setPixel(px, py, tcu::toRGBAMasked(referenceValue, fbColormask));
1137
1138                 if (tcu::boolAny(tcu::logicalAnd(lookupPrecision.colorMask,
1139                                                                                  tcu::greaterThan(tcu::absDiff(resultPixel, referencePixel),
1140                                                                                                                   lookupPrecision.colorThreshold))))
1141                 {
1142                         if (!tcu::isGatherOffsetsResultValid(effectiveView, samplerParams.sampler, lookupPrecision, texCoord, 0, glu::getDefaultGatherOffsets(), resultValue))
1143                         {
1144                                 errorMask.setPixel(px, py, tcu::RGBA::red());
1145                                 ++numFailedPixels;
1146                         }
1147                 }
1148         }
1149
1150         if (numFailedPixels > 0)
1151                 m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: Result verification failed, got " << numFailedPixels << " invalid pixels!" << tcu::TestLog::EndMessage;
1152         m_testCtx.getLog()      << tcu::TestLog::ImageSet("VerifyResult", "Verification result")
1153                                                 << tcu::TestLog::Image("Rendered", "Rendered image", renderedFrame);
1154         if (numFailedPixels > 0)
1155         {
1156                 m_testCtx.getLog()      << tcu::TestLog::Image("Reference", "Ideal reference image", reference)
1157                                                         << tcu::TestLog::Image("ErrorMask", "Error mask", errorMask);
1158         }
1159         m_testCtx.getLog() << tcu::TestLog::EndImageSet;
1160
1161         return (numFailedPixels == 0);
1162 }
1163
1164 bool TextureBorderClampTest::verifyTextureGatherCmpResult (const tcu::ConstPixelBufferAccess&                   renderedFrame,
1165                                                                                                                    const float*                                                                 texCoordArray,
1166                                                                                                                    const glu::TextureTestUtil::ReferenceParams& samplerParams,
1167                                                                                                                    const tcu::TexComparePrecision&                              texComparePrecision,
1168                                                                                                                    const tcu::TexComparePrecision&                              lowQualityTexComparePrecision)
1169 {
1170         const tcu::Vec2 texCoords[4] =
1171         {
1172                 tcu::Vec2(texCoordArray[0], texCoordArray[1]),
1173                 tcu::Vec2(texCoordArray[2], texCoordArray[3]),
1174                 tcu::Vec2(texCoordArray[4], texCoordArray[5]),
1175                 tcu::Vec2(texCoordArray[6], texCoordArray[7]),
1176         };
1177
1178         std::vector<tcu::ConstPixelBufferAccess>        srcLevelStorage;
1179         const tcu::Texture2DView                                        effectiveView           = tcu::getEffectiveTextureView(m_texture->getRefTexture(), srcLevelStorage, samplerParams.sampler);
1180
1181         const tcu::PixelFormat                                          pixelFormat                     = m_context.getRenderTarget().getPixelFormat();
1182         const tcu::BVec4                                                        colorMask                       = glu::TextureTestUtil::getCompareMask(pixelFormat);
1183         const deUint8                                                           fbColormask                     = tcu::getColorMask(pixelFormat);
1184         tcu::Surface                                                            reference                       (renderedFrame.getWidth(), renderedFrame.getHeight());
1185         tcu::Surface                                                            errorMask                       (renderedFrame.getWidth(), renderedFrame.getHeight());
1186         int                                                                                     numFailedPixels         = 0;
1187         bool                                                                            lowQuality                      = false;
1188
1189         tcu::clear(errorMask.getAccess(), tcu::RGBA::green().toVec());
1190
1191         for (int py = 0; py < reference.getHeight(); ++py)
1192         for (int px = 0; px < reference.getWidth(); ++px)
1193         {
1194                 const tcu::Vec2                 viewportCoord   = (tcu::Vec2((float)px, (float)py) + tcu::Vec2(0.5f)) / tcu::Vec2((float)reference.getWidth(), (float)reference.getHeight());
1195                 const tcu::Vec2                 texCoord                = triQuadInterpolate(texCoords, viewportCoord.x(), viewportCoord.y());
1196                 const float                             refZ                    = samplerParams.ref;
1197                 const tcu::Vec4                 referenceValue  = effectiveView.gatherOffsetsCompare(samplerParams.sampler, refZ, texCoord.x(), texCoord.y(), glu::getDefaultGatherOffsets());
1198                 const tcu::Vec4                 resultValue             = renderedFrame.getPixel(px, py);
1199
1200                 reference.setPixel(px, py, tcu::toRGBAMasked(referenceValue, fbColormask));
1201
1202                 if (tcu::boolAny(tcu::logicalAnd(colorMask, tcu::notEqual(referenceValue, resultValue))))
1203                 {
1204                         if (!tcu::isGatherOffsetsCompareResultValid(effectiveView, samplerParams.sampler, texComparePrecision, texCoord, glu::getDefaultGatherOffsets(), refZ, resultValue))
1205                         {
1206                                 lowQuality = true;
1207
1208                                 // fall back to low quality verification
1209                                 if (!tcu::isGatherOffsetsCompareResultValid(effectiveView, samplerParams.sampler, lowQualityTexComparePrecision, texCoord, glu::getDefaultGatherOffsets(), refZ, resultValue))
1210                                 {
1211                                         errorMask.setPixel(px, py, tcu::RGBA::red());
1212                                         ++numFailedPixels;
1213                                 }
1214                         }
1215                 }
1216         }
1217
1218         if (numFailedPixels > 0)
1219                 m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: Result verification failed, got " << numFailedPixels << " invalid pixels!" << tcu::TestLog::EndMessage;
1220         else if (lowQuality)
1221         {
1222                 m_testCtx.getLog() << tcu::TestLog::Message << "Warning: Verification assuming high-quality PCF filtering failed." << tcu::TestLog::EndMessage;
1223                 m_result.addResult(QP_TEST_RESULT_QUALITY_WARNING, "Low-quality result");
1224         }
1225
1226         m_testCtx.getLog()      << tcu::TestLog::ImageSet("VerifyResult", "Verification result")
1227                                                 << tcu::TestLog::Image("Rendered", "Rendered image", renderedFrame);
1228         if (numFailedPixels > 0)
1229         {
1230                 m_testCtx.getLog()      << tcu::TestLog::Image("Reference", "Ideal reference image", reference)
1231                                                         << tcu::TestLog::Image("ErrorMask", "Error mask", errorMask);
1232         }
1233         m_testCtx.getLog() << tcu::TestLog::EndImageSet;
1234
1235         return (numFailedPixels == 0);
1236 }
1237
1238 const glu::Texture2D* TextureBorderClampTest::getTexture (void) const
1239 {
1240         return m_texture.get();
1241 }
1242
1243 deUint32 TextureBorderClampTest::getIterationSeed (const IterationConfig& config) const
1244 {
1245         tcu::SeedBuilder builder;
1246         builder << std::string(getName())
1247                         << m_iterationNdx
1248                         << m_texFormat
1249                         << config.minFilter << config.magFilter
1250                         << m_texture->getRefTexture().getWidth() << m_texture->getRefTexture().getHeight();
1251         return builder.get();
1252 }
1253
1254 glu::TextureTestUtil::ReferenceParams TextureBorderClampTest::genSamplerParams (const IterationConfig& config) const
1255 {
1256         const tcu::TextureFormat                                texFormat               = tcu::getEffectiveDepthStencilTextureFormat(m_texture->getRefTexture().getFormat(), m_sampleMode);
1257         glu::TextureTestUtil::ReferenceParams   refParams               (glu::TextureTestUtil::TEXTURETYPE_2D);
1258
1259         refParams.sampler                                       = glu::mapGLSampler(config.sWrapMode, config.tWrapMode, config.minFilter, config.magFilter);
1260         refParams.sampler.borderColor           = config.borderColor;
1261         refParams.sampler.compare                       = (!m_useShadowSampler) ? (tcu::Sampler::COMPAREMODE_NONE) : (glu::mapGLCompareFunc(config.compareMode));
1262         refParams.sampler.depthStencilMode      = m_sampleMode;
1263         refParams.lodMode                                       = glu::TextureTestUtil::LODMODE_EXACT;
1264         refParams.samplerType                           = (!m_useShadowSampler) ? (glu::TextureTestUtil::getSamplerType(texFormat)) : (glu::TextureTestUtil::SAMPLERTYPE_SHADOW);
1265         refParams.colorScale                            = config.lookupScale;
1266         refParams.colorBias                                     = config.lookupBias;
1267         refParams.ref                                           = config.compareRef;
1268
1269         // compare can only be used with depth textures
1270         if (!isDepthFormat(m_texFormat, m_sampleMode))
1271                 DE_ASSERT(refParams.sampler.compare == tcu::Sampler::COMPAREMODE_NONE);
1272
1273         // sampler type must match compare mode
1274         DE_ASSERT(m_useShadowSampler == (config.compareMode != GL_NONE));
1275
1276         // in gather, weird mapping is most likely an error
1277         if (m_samplingFunction == SAMPLE_GATHER)
1278         {
1279                 DE_ASSERT(refParams.colorScale == tcu::Vec4(refParams.colorScale.x()));
1280                 DE_ASSERT(refParams.colorBias == tcu::Vec4(refParams.colorBias.x()));
1281         }
1282
1283         return refParams;
1284 }
1285
1286 glu::ShaderProgram* TextureBorderClampTest::genGatherProgram (void) const
1287 {
1288         const std::string       glslVersionDecl = glu::getGLSLVersionDeclaration(glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType()));
1289         const std::string       vtxSource               = glslVersionDecl + "\n"
1290                                                                                 "in highp vec4 a_position;\n"
1291                                                                                 "in highp vec2 a_texcoord;\n"
1292                                                                                 "out highp vec2 v_texcoord;\n"
1293                                                                                 "void main()\n"
1294                                                                                 "{\n"
1295                                                                                 "       gl_Position = a_position;\n"
1296                                                                                 "       v_texcoord = a_texcoord;\n"
1297                                                                                 "}\n";
1298         const char*                     samplerType;
1299         const char*                     lookup;
1300         std::ostringstream      fragSource;
1301
1302         if (m_useShadowSampler)
1303         {
1304                 samplerType     = "sampler2DShadow";
1305                 lookup          = "textureGather(u_sampler, v_texcoord, u_ref)";
1306         }
1307         else
1308         {
1309                 switch (m_channelClass)
1310                 {
1311                         case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
1312                         case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
1313                         case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
1314                                 samplerType     = "sampler2D";
1315                                 lookup          = "textureGather(u_sampler, v_texcoord)";
1316                                 break;
1317
1318                         case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
1319                                 samplerType     = "isampler2D";
1320                                 lookup          = "vec4(textureGather(u_sampler, v_texcoord))";
1321                                 break;
1322
1323                         case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
1324                                 samplerType     = "usampler2D";
1325                                 lookup          = "vec4(textureGather(u_sampler, v_texcoord))";
1326                                 break;
1327
1328                         default:
1329                                 samplerType     = "";
1330                                 lookup          = "";
1331                                 DE_ASSERT(false);
1332                 }
1333         }
1334
1335         fragSource      <<      glslVersionDecl + "\n"
1336                                         "uniform highp " << samplerType << " u_sampler;\n"
1337                                         "uniform highp vec4 u_colorScale;\n"
1338                                         "uniform highp vec4 u_colorBias;\n"
1339                                 <<      ((m_useShadowSampler) ? ("uniform highp float u_ref;\n") : (""))
1340                                 <<      "in highp vec2 v_texcoord;\n"
1341                                         "layout(location=0) out highp vec4 o_color;\n"
1342                                         "void main()\n"
1343                                         "{\n"
1344                                         "       o_color = " << lookup << " * u_colorScale + u_colorBias;\n"
1345                                         "}\n";
1346
1347         return new glu::ShaderProgram(m_context.getRenderContext(), glu::ProgramSources() << glu::VertexSource(vtxSource) << glu::FragmentSource(fragSource.str()));
1348 }
1349
1350 class TextureBorderClampFormatCase : public TextureBorderClampTest
1351 {
1352 public:
1353                                                                         TextureBorderClampFormatCase    (Context&                                               context,
1354                                                                                                                                          const char*                                    name,
1355                                                                                                                                          const char*                                    description,
1356                                                                                                                                          deUint32                                               texFormat,
1357                                                                                                                                          tcu::Sampler::DepthStencilMode mode,
1358                                                                                                                                          StateType                                              stateType,
1359                                                                                                                                          SizeType                                               sizeType,
1360                                                                                                                                          deUint32                                               filter,
1361                                                                                                                                          SamplingFunction                               samplingFunction);
1362
1363 private:
1364         void                                                    init                                                    (void);
1365
1366         int                                                             getNumIterations                                (void) const;
1367         IterationConfig                                 getIteration                                    (int ndx) const;
1368
1369         const SizeType                                  m_sizeType;
1370         const deUint32                                  m_filter;
1371
1372         std::vector<IterationConfig>    m_iterations;
1373 };
1374
1375
1376 TextureBorderClampFormatCase::TextureBorderClampFormatCase      (Context&                                               context,
1377                                                                                                                          const char*                                    name,
1378                                                                                                                          const char*                                    description,
1379                                                                                                                          deUint32                                               texFormat,
1380                                                                                                                          tcu::Sampler::DepthStencilMode mode,
1381                                                                                                                          StateType                                              stateType,
1382                                                                                                                          SizeType                                               sizeType,
1383                                                                                                                          deUint32                                               filter,
1384                                                                                                                          SamplingFunction                               samplingFunction)
1385         : TextureBorderClampTest(context,
1386                                                          name,
1387                                                          description,
1388                                                          texFormat,
1389                                                          mode,
1390                                                          stateType,
1391                                                          (sizeType == SIZE_POT) ? (32) : (17),
1392                                                          (sizeType == SIZE_POT) ? (16) : (31),
1393                                                          samplingFunction)
1394         , m_sizeType                    (sizeType)
1395         , m_filter                              (filter)
1396 {
1397         if (m_sizeType == SIZE_POT)
1398                 DE_ASSERT(deIsPowerOfTwo32(m_texWidth) && deIsPowerOfTwo32(m_texHeight));
1399         else
1400                 DE_ASSERT(!deIsPowerOfTwo32(m_texWidth) && !deIsPowerOfTwo32(m_texHeight));
1401
1402         if (glu::isCompressedFormat(texFormat))
1403         {
1404                 const tcu::CompressedTexFormat  compressedFormat        = glu::mapGLCompressedTexFormat(texFormat);
1405                 const tcu::IVec3                                blockPixelSize          = tcu::getBlockPixelSize(compressedFormat);
1406
1407                 // is (not) multiple of a block size
1408                 if (m_sizeType == SIZE_POT)
1409                         DE_ASSERT((m_texWidth % blockPixelSize.x()) == 0 && (m_texHeight % blockPixelSize.y()) == 0);
1410                 else
1411                         DE_ASSERT((m_texWidth % blockPixelSize.x()) != 0 && (m_texHeight % blockPixelSize.y()) != 0);
1412
1413                 DE_UNREF(blockPixelSize);
1414         }
1415 }
1416
1417 void TextureBorderClampFormatCase::init (void)
1418 {
1419         TextureBorderClampTest::init();
1420
1421         // \note TextureBorderClampTest::init() creates texture
1422         const tcu::TextureFormat                texFormat               = tcu::getEffectiveDepthStencilTextureFormat(getTexture()->getRefTexture().getFormat(), m_sampleMode);
1423         const tcu::TextureFormatInfo    texFormatInfo   = tcu::getTextureFormatInfo(texFormat);
1424
1425         // iterations
1426
1427         {
1428                 IterationConfig iteration;
1429                 iteration.p0                    = tcu::Vec2(-1.5f, -3.0f);
1430                 iteration.p1                    = tcu::Vec2( 1.5f,  2.5f);
1431                 iteration.borderColor   = mapToFormatColorRepresentable(texFormat, tcu::Vec4(0.3f, 0.7f, 0.2f, 0.5f));
1432                 m_iterations.push_back(iteration);
1433         }
1434         {
1435                 IterationConfig iteration;
1436                 iteration.p0                    = tcu::Vec2(-0.5f, 0.75f);
1437                 iteration.p1                    = tcu::Vec2(0.25f, 1.25f);
1438                 iteration.borderColor   = mapToFormatColorRepresentable(texFormat, tcu::Vec4(0.9f, 0.2f, 0.4f, 0.6f));
1439                 m_iterations.push_back(iteration);
1440         }
1441
1442         // common parameters
1443         for (int ndx = 0; ndx < (int)m_iterations.size(); ++ndx)
1444         {
1445                 IterationConfig& iteration = m_iterations[ndx];
1446
1447                 if (m_samplingFunction == SAMPLE_GATHER)
1448                 {
1449                         iteration.lookupScale   = tcu::Vec4(texFormatInfo.lookupScale.x());
1450                         iteration.lookupBias    = tcu::Vec4(texFormatInfo.lookupBias.x());
1451                 }
1452                 else
1453                 {
1454                         iteration.lookupScale   = texFormatInfo.lookupScale;
1455                         iteration.lookupBias    = texFormatInfo.lookupBias;
1456                 }
1457
1458                 iteration.minFilter             = m_filter;
1459                 iteration.magFilter             = m_filter;
1460                 iteration.sWrapMode             = GL_CLAMP_TO_BORDER;
1461                 iteration.tWrapMode             = GL_CLAMP_TO_BORDER;
1462                 iteration.compareMode   = GL_NONE;
1463                 iteration.compareRef    = 0.0f;
1464         }
1465 }
1466
1467 int TextureBorderClampFormatCase::getNumIterations      (void) const
1468 {
1469         return (int)m_iterations.size();
1470 }
1471
1472 TextureBorderClampTest::IterationConfig TextureBorderClampFormatCase::getIteration (int ndx) const
1473 {
1474         return m_iterations[ndx];
1475 }
1476
1477 class TextureBorderClampRangeClampCase : public TextureBorderClampTest
1478 {
1479 public:
1480                                                                         TextureBorderClampRangeClampCase        (Context&                                               context,
1481                                                                                                                                                  const char*                                    name,
1482                                                                                                                                                  const char*                                    description,
1483                                                                                                                                                  deUint32                                               texFormat,
1484                                                                                                                                                  tcu::Sampler::DepthStencilMode mode,
1485                                                                                                                                                  deUint32                                               filter);
1486
1487 private:
1488         void                                                    init                                                            (void);
1489
1490         int                                                             getNumIterations                                        (void) const;
1491         IterationConfig                                 getIteration                                            (int ndx) const;
1492
1493         const deUint32                                  m_filter;
1494         std::vector<IterationConfig>    m_iterations;
1495 };
1496
1497 TextureBorderClampRangeClampCase::TextureBorderClampRangeClampCase      (Context&                                               context,
1498                                                                                                                                          const char*                                    name,
1499                                                                                                                                          const char*                                    description,
1500                                                                                                                                          deUint32                                               texFormat,
1501                                                                                                                                          tcu::Sampler::DepthStencilMode mode,
1502                                                                                                                                          deUint32                                               filter)
1503         : TextureBorderClampTest(context, name, description, texFormat, mode, TextureBorderClampTest::STATE_TEXTURE_PARAM, 8, 32, SAMPLE_FILTER)
1504         , m_filter                              (filter)
1505 {
1506 }
1507
1508 void TextureBorderClampRangeClampCase::init (void)
1509 {
1510         TextureBorderClampTest::init();
1511
1512         const tcu::TextureFormat        texFormat               = tcu::getEffectiveDepthStencilTextureFormat(getTexture()->getRefTexture().getFormat(), m_sampleMode);
1513         const bool                                      isDepth                 = isDepthFormat(m_texFormat, m_sampleMode);
1514         const bool                                      isFloat                 = m_channelClass == tcu::TEXTURECHANNELCLASS_FLOATING_POINT;
1515         const bool                                      isFixed                 = m_channelClass == tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT || m_channelClass == tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT;
1516         const bool                                      isPureInteger   = m_channelClass == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER || m_channelClass == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER;
1517
1518         if (isDepth || isFloat)
1519         {
1520                 // infinities are commonly used values on depth/float borders
1521                 {
1522                         IterationConfig iteration;
1523                         iteration.p0                    = tcu::Vec2(-1.2f, -3.0f);
1524                         iteration.p1                    = tcu::Vec2( 1.2f,  2.5f);
1525                         iteration.borderColor   = rr::GenericVec4(tcu::Vec4(std::numeric_limits<float>::infinity()));
1526                         iteration.lookupScale   = tcu::Vec4(0.5f); // scale & bias to [0.25, 0.5] range to make out-of-range values visible
1527                         iteration.lookupBias    = tcu::Vec4(0.25f);
1528                         iteration.description   = "border value infinity";
1529                         m_iterations.push_back(iteration);
1530                 }
1531                 {
1532                         IterationConfig iteration;
1533                         iteration.p0                    = tcu::Vec2(-0.25f, -0.75f);
1534                         iteration.p1                    = tcu::Vec2( 2.25f,  1.25f);
1535                         iteration.borderColor   = rr::GenericVec4(tcu::Vec4(-std::numeric_limits<float>::infinity()));
1536                         iteration.lookupScale   = tcu::Vec4(0.5f);
1537                         iteration.lookupBias    = tcu::Vec4(0.25f);
1538                         iteration.description   = "border value negative infinity";
1539                         m_iterations.push_back(iteration);
1540                 }
1541         }
1542         else if (isPureInteger)
1543         {
1544                 const tcu::IVec4                        numBits         = tcu::getTextureFormatBitDepth(texFormat);
1545                 const bool                                      isSigned        = m_channelClass == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER;
1546
1547                 // can't overflow 32bit integers with 32bit integers
1548                 for (int ndx = 0; ndx < 4; ++ndx)
1549                         DE_ASSERT(numBits[ndx] == 0 || numBits[ndx] == 8 || numBits[ndx] == 16);
1550
1551                 const tcu::IVec4        minValue                = getNBitIntegerVec4MinValue(isSigned, numBits);
1552                 const tcu::IVec4        maxValue                = getNBitIntegerVec4MaxValue(isSigned, numBits);
1553                 const tcu::IVec4        valueRange              = maxValue - minValue;
1554                 const tcu::IVec4        divSafeRange    ((valueRange[0]==0) ? (1) : (valueRange[0]),
1555                                                                                          (valueRange[1]==0) ? (1) : (valueRange[1]),
1556                                                                                          (valueRange[2]==0) ? (1) : (valueRange[2]),
1557                                                                                          (valueRange[3]==0) ? (1) : (valueRange[3]));
1558
1559                 // format max
1560                 {
1561                         const tcu::IVec4 value = maxValue + tcu::IVec4(1);
1562
1563                         IterationConfig iteration;
1564                         iteration.p0                    = tcu::Vec2(-1.2f, -3.0f);
1565                         iteration.p1                    = tcu::Vec2( 1.2f,  2.5f);
1566                         iteration.borderColor   = (isSigned) ? (rr::GenericVec4(value)) : (rr::GenericVec4(value.cast<deUint32>()));
1567                         iteration.lookupScale   = tcu::Vec4(0.5f) / divSafeRange.cast<float>();
1568                         iteration.lookupBias    = (isSigned) ? (tcu::Vec4(0.5f)) : (tcu::Vec4(0.25f));
1569                         iteration.description   = "border values one larger than maximum";
1570                         m_iterations.push_back(iteration);
1571                 }
1572                 // format min
1573                 if (isSigned)
1574                 {
1575                         const tcu::IVec4 value = minValue - tcu::IVec4(1);
1576
1577                         IterationConfig iteration;
1578                         iteration.p0                    = tcu::Vec2(-0.25f, -0.75f);
1579                         iteration.p1                    = tcu::Vec2( 2.25f,  1.25f);
1580                         iteration.borderColor   = rr::GenericVec4(value);
1581                         iteration.lookupScale   = tcu::Vec4(0.5f) / divSafeRange.cast<float>();
1582                         iteration.lookupBias    = tcu::Vec4(0.5f);
1583                         iteration.description   = "border values one less than minimum";
1584                         m_iterations.push_back(iteration);
1585                 }
1586                 // (u)int32 max
1587                 {
1588                         const tcu::IVec4 value = (isSigned) ? (tcu::IVec4(std::numeric_limits<deInt32>::max())) : (tcu::IVec4(std::numeric_limits<deUint32>::max()));
1589
1590                         IterationConfig iteration;
1591                         iteration.p0                    = tcu::Vec2(-1.6f, -2.1f);
1592                         iteration.p1                    = tcu::Vec2( 1.2f,  3.5f);
1593                         iteration.borderColor   = (isSigned) ? (rr::GenericVec4(value)) : (rr::GenericVec4(value.cast<deUint32>()));
1594                         iteration.lookupScale   = tcu::Vec4(0.5f) / divSafeRange.cast<float>();
1595                         iteration.lookupBias    = tcu::Vec4(0.25f);
1596                         iteration.description   = "border values 32-bit maximum";
1597                         m_iterations.push_back(iteration);
1598                 }
1599                 // int32 min
1600                 if (isSigned)
1601                 {
1602                         const tcu::IVec4 value = tcu::IVec4(std::numeric_limits<deInt32>::min());
1603
1604                         IterationConfig iteration;
1605                         iteration.p0                    = tcu::Vec2(-2.6f, -4.0f);
1606                         iteration.p1                    = tcu::Vec2( 1.1f,  1.5f);
1607                         iteration.borderColor   = rr::GenericVec4(value);
1608                         iteration.lookupScale   = tcu::Vec4(0.5f) / divSafeRange.cast<float>();
1609                         iteration.lookupBias    = tcu::Vec4(0.25f);
1610                         iteration.description   = "border values 0";
1611                         m_iterations.push_back(iteration);
1612                 }
1613         }
1614         else if (isFixed)
1615         {
1616                 const bool              isSigned        = m_channelClass == tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT;;
1617                 const tcu::Vec4 lookupBias      = (isSigned) ? (tcu::Vec4(0.5f))    : (tcu::Vec4(0.25f)); // scale & bias to [0.25, 0.5] range to make out-of-range values visible
1618                 const tcu::Vec4 lookupScale     = (isSigned) ? (tcu::Vec4(0.25f))   : (tcu::Vec4(0.5f));
1619
1620                 {
1621                         IterationConfig iteration;
1622                         iteration.p0                    = tcu::Vec2(-1.2f, -3.0f);
1623                         iteration.p1                    = tcu::Vec2( 1.2f,  2.5f);
1624                         iteration.borderColor   = mapToFormatColorUnits(texFormat, tcu::Vec4(1.1f, 1.3f, 2.2f, 1.3f));
1625                         iteration.lookupScale   = lookupScale;
1626                         iteration.lookupBias    = lookupBias;
1627                         iteration.description   = "border values larger than maximum";
1628                         m_iterations.push_back(iteration);
1629                 }
1630                 {
1631                         IterationConfig iteration;
1632                         iteration.p0                    = tcu::Vec2(-0.25f, -0.75f);
1633                         iteration.p1                    = tcu::Vec2( 2.25f,  1.25f);
1634                         iteration.borderColor   = mapToFormatColorUnits(texFormat, tcu::Vec4(-0.2f, -0.9f, -2.4f, -0.6f));
1635                         iteration.lookupScale   = lookupScale;
1636                         iteration.lookupBias    = lookupBias;
1637                         iteration.description   = "border values less than minimum";
1638                         m_iterations.push_back(iteration);
1639                 }
1640         }
1641         else
1642                 DE_ASSERT(false);
1643
1644         // common parameters
1645         for (int ndx = 0; ndx < (int)m_iterations.size(); ++ndx)
1646         {
1647                 IterationConfig& iteration = m_iterations[ndx];
1648
1649                 iteration.minFilter             = m_filter;
1650                 iteration.magFilter             = m_filter;
1651                 iteration.sWrapMode             = GL_CLAMP_TO_BORDER;
1652                 iteration.tWrapMode             = GL_CLAMP_TO_BORDER;
1653                 iteration.compareMode   = GL_NONE;
1654                 iteration.compareRef    = 0.0f;
1655         }
1656 }
1657
1658 int TextureBorderClampRangeClampCase::getNumIterations  (void) const
1659 {
1660         return (int)m_iterations.size();
1661 }
1662
1663 TextureBorderClampTest::IterationConfig TextureBorderClampRangeClampCase::getIteration (int ndx) const
1664 {
1665         return m_iterations[ndx];
1666 }
1667
1668 class TextureBorderClampPerAxisCase2D : public TextureBorderClampTest
1669 {
1670 public:
1671                                                                         TextureBorderClampPerAxisCase2D (Context&                                               context,
1672                                                                                                                                          const char*                                    name,
1673                                                                                                                                          const char*                                    description,
1674                                                                                                                                          deUint32                                               texFormat,
1675                                                                                                                                          tcu::Sampler::DepthStencilMode mode,
1676                                                                                                                                          SizeType                                               sizeType,
1677                                                                                                                                          deUint32                                               filter,
1678                                                                                                                                          deUint32                                               texSWrap,
1679                                                                                                                                          deUint32                                               texTWrap,
1680                                                                                                                                          SamplingFunction                               samplingFunction);
1681
1682 private:
1683         void                                                    init                                                    (void);
1684
1685         int                                                             getNumIterations                                (void) const;
1686         IterationConfig                                 getIteration                                    (int ndx) const;
1687
1688         const deUint32                                  m_texSWrap;
1689         const deUint32                                  m_texTWrap;
1690         const deUint32                                  m_filter;
1691
1692         std::vector<IterationConfig>    m_iterations;
1693 };
1694
1695 TextureBorderClampPerAxisCase2D::TextureBorderClampPerAxisCase2D (Context&                                                      context,
1696                                                                                                                                   const char*                                           name,
1697                                                                                                                                   const char*                                           description,
1698                                                                                                                                   deUint32                                                      texFormat,
1699                                                                                                                                   tcu::Sampler::DepthStencilMode        mode,
1700                                                                                                                                   SizeType                                                      sizeType,
1701                                                                                                                                   deUint32                                                      filter,
1702                                                                                                                                   deUint32                                                      texSWrap,
1703                                                                                                                                   deUint32                                                      texTWrap,
1704                                                                                                                                   SamplingFunction                                      samplingFunction)
1705         : TextureBorderClampTest(context,
1706                                                          name,
1707                                                          description,
1708                                                          texFormat,
1709                                                          mode,
1710                                                          TextureBorderClampTest::STATE_TEXTURE_PARAM,
1711                                                          (sizeType == SIZE_POT) ? (16) : (7),
1712                                                          (sizeType == SIZE_POT) ? (8) : (9),
1713                                                          samplingFunction)
1714         , m_texSWrap                    (texSWrap)
1715         , m_texTWrap                    (texTWrap)
1716         , m_filter                              (filter)
1717 {
1718 }
1719
1720 void TextureBorderClampPerAxisCase2D::init (void)
1721 {
1722         TextureBorderClampTest::init();
1723
1724         // \note TextureBorderClampTest::init() creates texture
1725         const tcu::TextureFormat                texFormat               = tcu::getEffectiveDepthStencilTextureFormat(getTexture()->getRefTexture().getFormat(), m_sampleMode);
1726         const tcu::TextureFormatInfo    texFormatInfo   = tcu::getTextureFormatInfo(texFormat);
1727
1728         IterationConfig iteration;
1729         iteration.p0                    = tcu::Vec2(-0.25f, -0.75f);
1730         iteration.p1                    = tcu::Vec2( 2.25f,  1.25f);
1731         iteration.borderColor   = mapToFormatColorRepresentable(texFormat, tcu::Vec4(0.4f, 0.9f, 0.1f, 0.2f));
1732
1733         if (m_samplingFunction == SAMPLE_GATHER)
1734         {
1735                 iteration.lookupScale   = tcu::Vec4(texFormatInfo.lookupScale.x());
1736                 iteration.lookupBias    = tcu::Vec4(texFormatInfo.lookupBias.x());
1737         }
1738         else
1739         {
1740                 iteration.lookupScale   = texFormatInfo.lookupScale;
1741                 iteration.lookupBias    = texFormatInfo.lookupBias;
1742         }
1743
1744         iteration.minFilter             = m_filter;
1745         iteration.magFilter             = m_filter;
1746         iteration.sWrapMode             = m_texSWrap;
1747         iteration.tWrapMode             = m_texTWrap;
1748         iteration.compareMode   = GL_NONE;
1749         iteration.compareRef    = 0.0f;
1750
1751         m_iterations.push_back(iteration);
1752 }
1753
1754 int TextureBorderClampPerAxisCase2D::getNumIterations   (void) const
1755 {
1756         return (int)m_iterations.size();
1757 }
1758
1759 TextureBorderClampTest::IterationConfig TextureBorderClampPerAxisCase2D::getIteration (int ndx) const
1760 {
1761         return m_iterations[ndx];
1762 }
1763
1764 class TextureBorderClampDepthCompareCase : public TextureBorderClampTest
1765 {
1766 public:
1767                                                                         TextureBorderClampDepthCompareCase      (Context&                       context,
1768                                                                                                                                                  const char*            name,
1769                                                                                                                                                  const char*            description,
1770                                                                                                                                                  deUint32                       texFormat,
1771                                                                                                                                                  SizeType                       sizeType,
1772                                                                                                                                                  deUint32                       filter,
1773                                                                                                                                                  SamplingFunction       samplingFunction);
1774
1775 private:
1776         void                                                    init                                                            (void);
1777
1778         int                                                             getNumIterations                                        (void) const;
1779         IterationConfig                                 getIteration                                            (int ndx) const;
1780
1781         const deUint32                                  m_filter;
1782         std::vector<IterationConfig>    m_iterations;
1783 };
1784
1785 TextureBorderClampDepthCompareCase::TextureBorderClampDepthCompareCase (Context&                        context,
1786                                                                                                                                                 const char*                     name,
1787                                                                                                                                                 const char*                     description,
1788                                                                                                                                                 deUint32                        texFormat,
1789                                                                                                                                                 SizeType                        sizeType,
1790                                                                                                                                                 deUint32                        filter,
1791                                                                                                                                                 SamplingFunction        samplingFunction)
1792         : TextureBorderClampTest(context,
1793                                                          name,
1794                                                          description,
1795                                                          texFormat,
1796                                                          tcu::Sampler::MODE_DEPTH,
1797                                                          TextureBorderClampTest::STATE_TEXTURE_PARAM,
1798                                                          (sizeType == SIZE_POT) ? (32) : (13),
1799                                                          (sizeType == SIZE_POT) ? (16) : (17),
1800                                                          samplingFunction,
1801                                                          FLAG_USE_SHADOW_SAMPLER)
1802         , m_filter                              (filter)
1803 {
1804 }
1805
1806 void TextureBorderClampDepthCompareCase::init (void)
1807 {
1808         TextureBorderClampTest::init();
1809
1810         // 0.5 <= 0.7
1811         {
1812                 IterationConfig iteration;
1813                 iteration.p0                    = tcu::Vec2(-0.15f, -0.35f);
1814                 iteration.p1                    = tcu::Vec2( 1.25f,  1.1f);
1815                 iteration.borderColor   = rr::GenericVec4(tcu::Vec4(0.7f, 0.0f, 0.0f, 0.0f));
1816                 iteration.description   = "Border color in [0, 1] range";
1817                 iteration.compareMode   = GL_LEQUAL;
1818                 iteration.compareRef    = 0.5f;
1819                 m_iterations.push_back(iteration);
1820         }
1821
1822         // 1.5 <= 1.0
1823         {
1824                 IterationConfig iteration;
1825                 iteration.p0                    = tcu::Vec2(-0.15f, -0.35f);
1826                 iteration.p1                    = tcu::Vec2( 1.25f,  1.1f);
1827                 iteration.borderColor   = rr::GenericVec4(tcu::Vec4(1.5f, 0.0f, 0.0f, 0.0f));
1828                 iteration.description   = "Border color > 1, should be clamped";
1829                 iteration.compareMode   = GL_LEQUAL;
1830                 iteration.compareRef    = 1.0f;
1831                 m_iterations.push_back(iteration);
1832         }
1833
1834         // -0.5 >= 0.0
1835         {
1836                 IterationConfig iteration;
1837                 iteration.p0                    = tcu::Vec2(-0.15f, -0.35f);
1838                 iteration.p1                    = tcu::Vec2( 1.25f,  1.1f);
1839                 iteration.borderColor   = rr::GenericVec4(tcu::Vec4(-0.5f, 0.0f, 0.0f, 0.0f));
1840                 iteration.description   = "Border color < 0, should be clamped";
1841                 iteration.compareMode   = GL_GEQUAL;
1842                 iteration.compareRef    = 0.0f;
1843                 m_iterations.push_back(iteration);
1844         }
1845
1846         // inf < 1.25
1847         {
1848                 IterationConfig iteration;
1849                 iteration.p0                    = tcu::Vec2(-0.15f, -0.35f);
1850                 iteration.p1                    = tcu::Vec2( 1.25f,  1.1f);
1851                 iteration.borderColor   = rr::GenericVec4(tcu::Vec4(std::numeric_limits<float>::infinity(), 0.0f, 0.0f, 0.0f));
1852                 iteration.description   = "Border color == inf, should be clamped; ref > 1";
1853                 iteration.compareMode   = GL_LESS;
1854                 iteration.compareRef    = 1.25f;
1855                 m_iterations.push_back(iteration);
1856         }
1857
1858         // -inf > -0.5
1859         {
1860                 IterationConfig iteration;
1861                 iteration.p0                    = tcu::Vec2(-0.15f, -0.35f);
1862                 iteration.p1                    = tcu::Vec2( 1.25f,  1.1f);
1863                 iteration.borderColor   = rr::GenericVec4(tcu::Vec4(-std::numeric_limits<float>::infinity(), 0.0f, 0.0f, 0.0f));
1864                 iteration.description   = "Border color == inf, should be clamped; ref < 0";
1865                 iteration.compareMode   = GL_GREATER;
1866                 iteration.compareRef    = -0.5f;
1867                 m_iterations.push_back(iteration);
1868         }
1869
1870         // common parameters
1871         for (int ndx = 0; ndx < (int)m_iterations.size(); ++ndx)
1872         {
1873                 IterationConfig& iteration = m_iterations[ndx];
1874
1875                 iteration.lookupScale   = tcu::Vec4(1.0);
1876                 iteration.lookupBias    = tcu::Vec4(0.0);
1877                 iteration.minFilter             = m_filter;
1878                 iteration.magFilter             = m_filter;
1879                 iteration.sWrapMode             = GL_CLAMP_TO_BORDER;
1880                 iteration.tWrapMode             = GL_CLAMP_TO_BORDER;
1881         }
1882 }
1883
1884 int TextureBorderClampDepthCompareCase::getNumIterations        (void) const
1885 {
1886         return (int)m_iterations.size();
1887 }
1888
1889 TextureBorderClampTest::IterationConfig TextureBorderClampDepthCompareCase::getIteration (int ndx) const
1890 {
1891         return m_iterations[ndx];
1892 }
1893
1894 class TextureBorderClampUnusedChannelCase : public TextureBorderClampTest
1895 {
1896 public:
1897                                                                         TextureBorderClampUnusedChannelCase     (Context&                                               context,
1898                                                                                                                                                  const char*                                    name,
1899                                                                                                                                                  const char*                                    description,
1900                                                                                                                                                  deUint32                                               texFormat,
1901                                                                                                                                                  tcu::Sampler::DepthStencilMode depthStencilMode);
1902
1903 private:
1904         void                                                    init                                                            (void);
1905
1906         int                                                             getNumIterations                                        (void) const;
1907         IterationConfig                                 getIteration                                            (int ndx) const;
1908
1909         std::vector<IterationConfig>    m_iterations;
1910 };
1911
1912 TextureBorderClampUnusedChannelCase::TextureBorderClampUnusedChannelCase (Context&                                                      context,
1913                                                                                                                                                   const char*                                           name,
1914                                                                                                                                                   const char*                                           description,
1915                                                                                                                                                   deUint32                                                      texFormat,
1916                                                                                                                                                   tcu::Sampler::DepthStencilMode        depthStencilMode)
1917         : TextureBorderClampTest(context,
1918                                                          name,
1919                                                          description,
1920                                                          texFormat,
1921                                                          depthStencilMode,
1922                                                          TextureBorderClampTest::STATE_TEXTURE_PARAM,
1923                                                          8,
1924                                                          8,
1925                                                          SAMPLE_FILTER)
1926 {
1927 }
1928
1929 static rr::GenericVec4 selectComponents (const rr::GenericVec4& trueComponents, const rr::GenericVec4& falseComponents, const tcu::BVec4& m)
1930 {
1931         return rr::GenericVec4(tcu::select(trueComponents.get<deUint32>(), falseComponents.get<deUint32>(), m));
1932 }
1933
1934 void TextureBorderClampUnusedChannelCase::init (void)
1935 {
1936         TextureBorderClampTest::init();
1937
1938         // \note TextureBorderClampTest::init() creates texture
1939         const tcu::TextureFormat                texFormat                       = tcu::getEffectiveDepthStencilTextureFormat(getTexture()->getRefTexture().getFormat(), m_sampleMode);
1940         const tcu::TextureFormatInfo    texFormatInfo           = tcu::getTextureFormatInfo(texFormat);
1941         const tcu::BVec4                                channelMask                     = tcu::getTextureFormatChannelMask(texFormat);
1942         const float                                             maxChannelValue         = (channelMask[0]) ? (texFormatInfo.valueMax[0])
1943                                                                                                                 : (channelMask[1]) ? (texFormatInfo.valueMax[1])
1944                                                                                                                 : (channelMask[2]) ? (texFormatInfo.valueMax[2])
1945                                                                                                                 :                    (texFormatInfo.valueMax[3]);
1946
1947         const rr::GenericVec4                   effectiveColors         = mapToFormatColorRepresentable(texFormat, tcu::Vec4(0.6f));
1948         rr::GenericVec4                                 nonEffectiveColors;
1949
1950         switch (m_channelClass)
1951         {
1952                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
1953                 case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
1954                 case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
1955                         nonEffectiveColors = rr::GenericVec4(tcu::Vec4(maxChannelValue * 0.8f));
1956                         break;
1957
1958                 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
1959                         nonEffectiveColors = rr::GenericVec4(tcu::Vec4(maxChannelValue * 0.8f).cast<deInt32>());
1960                         break;
1961
1962                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
1963                         nonEffectiveColors = rr::GenericVec4(tcu::Vec4(maxChannelValue * 0.8f).cast<deUint32>());
1964                         break;
1965                 default:
1966                         DE_ASSERT(false);
1967         }
1968
1969         IterationConfig iteration;
1970         iteration.p0                    = tcu::Vec2(-0.25f, -0.75f);
1971         iteration.p1                    = tcu::Vec2( 2.25f,  1.25f);
1972         iteration.borderColor   = selectComponents(effectiveColors, nonEffectiveColors, channelMask);
1973         iteration.lookupScale   = texFormatInfo.lookupScale;
1974         iteration.lookupBias    = texFormatInfo.lookupBias;
1975         iteration.minFilter             = GL_NEAREST;
1976         iteration.magFilter             = GL_NEAREST;
1977         iteration.sWrapMode             = GL_CLAMP_TO_BORDER;
1978         iteration.tWrapMode             = GL_CLAMP_TO_BORDER;
1979         iteration.compareMode   = GL_NONE;
1980         iteration.compareRef    = 0.0f;
1981         iteration.description   = "Setting values to unused border color components";
1982
1983         m_iterations.push_back(iteration);
1984 }
1985
1986 int TextureBorderClampUnusedChannelCase::getNumIterations       (void) const
1987 {
1988         return (int)m_iterations.size();
1989 }
1990
1991 TextureBorderClampTest::IterationConfig TextureBorderClampUnusedChannelCase::getIteration (int ndx) const
1992 {
1993         return m_iterations[ndx];
1994 }
1995
1996 class TextureBorderClampPerAxisCase3D : public TestCase
1997 {
1998 public:
1999                                                                                                                 TextureBorderClampPerAxisCase3D (Context&               context,
2000                                                                                                                                                                                  const char*    name,
2001                                                                                                                                                                                  const char*    description,
2002                                                                                                                                                                                  deUint32               texFormat,
2003                                                                                                                                                                                  SizeType               size,
2004                                                                                                                                                                                  deUint32               filter,
2005                                                                                                                                                                                  deUint32               sWrap,
2006                                                                                                                                                                                  deUint32               tWrap,
2007                                                                                                                                                                                  deUint32               rWrap);
2008
2009 private:
2010         void                                                                                            init                                                    (void);
2011         void                                                                                            deinit                                                  (void);
2012         IterateResult                                                                           iterate                                                 (void);
2013
2014         void                                                                                            renderTo                                                (tcu::Surface&                                                                  surface,
2015                                                                                                                                                                                  const glu::TextureTestUtil::ReferenceParams&   samplerParams);
2016
2017         void                                                                                            logParams                                               (const glu::TextureTestUtil::ReferenceParams&   samplerParams);
2018
2019         void                                                                                            verifyImage                                             (const tcu::Surface&                                                    image,
2020                                                                                                                                                                                  const glu::TextureTestUtil::ReferenceParams&   samplerParams);
2021
2022         glu::TextureTestUtil::ReferenceParams                           getSamplerParams                                (void) const;
2023         deUint32                                                                                        getCaseSeed                                             (void) const;
2024
2025         enum
2026         {
2027                 VIEWPORT_WIDTH          = 128,
2028                 VIEWPORT_HEIGHT         = 128,
2029         };
2030
2031         const deUint32                                                                          m_texFormat;
2032         const tcu::TextureChannelClass                                          m_channelClass;
2033         const tcu::IVec3                                                                        m_size;
2034         const deUint32                                                                          m_filter;
2035         const deUint32                                                                          m_sWrap;
2036         const deUint32                                                                          m_tWrap;
2037         const deUint32                                                                          m_rWrap;
2038
2039         de::MovePtr<glu::Texture3D>                                                     m_texture;
2040         de::MovePtr<gls::TextureTestUtil::TextureRenderer>      m_renderer;
2041
2042         rr::GenericVec4                                                                         m_borderColor;
2043         std::vector<float>                                                                      m_texCoords;
2044         tcu::Vec4                                                                                       m_lookupScale;
2045         tcu::Vec4                                                                                       m_lookupBias;
2046 };
2047
2048 TextureBorderClampPerAxisCase3D::TextureBorderClampPerAxisCase3D (Context&              context,
2049                                                                                                                                   const char*   name,
2050                                                                                                                                   const char*   description,
2051                                                                                                                                   deUint32              texFormat,
2052                                                                                                                                   SizeType              size,
2053                                                                                                                                   deUint32              filter,
2054                                                                                                                                   deUint32              sWrap,
2055                                                                                                                                   deUint32              tWrap,
2056                                                                                                                                   deUint32              rWrap)
2057         : TestCase                      (context, name, description)
2058         , m_texFormat           (texFormat)
2059         , m_channelClass        (getFormatChannelClass(texFormat, tcu::Sampler::MODE_LAST))
2060         , m_size                        ((size == SIZE_POT) ? (tcu::IVec3(8, 16, 4)) : (tcu::IVec3(13, 5, 7)))
2061         , m_filter                      (filter)
2062         , m_sWrap                       (sWrap)
2063         , m_tWrap                       (tWrap)
2064         , m_rWrap                       (rWrap)
2065 {
2066 }
2067
2068 void TextureBorderClampPerAxisCase3D::init (void)
2069 {
2070         const bool                              supportsES32    = glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2));
2071         const glu::GLSLVersion  glslVersion             = glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType());
2072
2073         if (!supportsES32 && !m_context.getContextInfo().isExtensionSupported("GL_EXT_texture_border_clamp"))
2074                 throw tcu::NotSupportedError("Test requires GL_EXT_texture_border_clamp extension");
2075
2076         if (glu::isCompressedFormat(m_texFormat)                                                                                                        &&
2077                 !supportsES32                                                                                                                                                   &&
2078                 tcu::isAstcFormat(glu::mapGLCompressedTexFormat(m_texFormat))                                                   &&
2079                 !m_context.getContextInfo().isExtensionSupported("GL_KHR_texture_compression_astc_ldr"))
2080         {
2081                 throw tcu::NotSupportedError("Test requires GL_KHR_texture_compression_astc_ldr extension");
2082         }
2083         if (m_texFormat == GL_BGRA && !m_context.getContextInfo().isExtensionSupported("GL_EXT_texture_format_BGRA8888"))
2084                 throw tcu::NotSupportedError("Test requires GL_EXT_texture_format_BGRA8888 extension");
2085         if (m_context.getRenderTarget().getWidth() < VIEWPORT_WIDTH ||
2086                 m_context.getRenderTarget().getHeight() < VIEWPORT_HEIGHT)
2087         {
2088                 throw tcu::NotSupportedError("Test requires " + de::toString<int>(VIEWPORT_WIDTH) + "x" + de::toString<int>(VIEWPORT_HEIGHT) + " viewport");
2089         }
2090
2091         // resources
2092         m_texture = genDummyTexture<glu::Texture3D>(m_context.getRenderContext(), m_context.getContextInfo(), m_texFormat, m_size);
2093         m_renderer = de::MovePtr<gls::TextureTestUtil::TextureRenderer>(new gls::TextureTestUtil::TextureRenderer(m_context.getRenderContext(), m_testCtx.getLog(), glslVersion, glu::PRECISION_HIGHP));
2094
2095         // texture info
2096         m_testCtx.getLog()      << tcu::TestLog::Message
2097                                                 << "Created 3D texture with format " << glu::getTextureFormatName(m_texFormat)
2098                                                 << ", size (" << m_texture->getRefTexture().getWidth() << ", " << m_texture->getRefTexture().getHeight() << ", " << m_texture->getRefTexture().getDepth() << ")\n"
2099                                                 << tcu::TestLog::EndMessage;
2100
2101         // tex coord
2102         {
2103                 m_testCtx.getLog()      << tcu::TestLog::Message
2104                                                         << "Setting tex coords bottom-left: (-1, -1, -1.5), top-right (2, 2, 2.5)\n"
2105                                                         << tcu::TestLog::EndMessage;
2106
2107                 m_texCoords.resize(4*3);
2108
2109                 m_texCoords[0] = -1.0f; m_texCoords[ 1] = -1.0f; m_texCoords[ 2] = -1.5f;
2110                 m_texCoords[3] = -1.0f; m_texCoords[ 4] =  2.0f; m_texCoords[ 5] = 0.5f;
2111                 m_texCoords[6] =  2.0f; m_texCoords[ 7] = -1.0f; m_texCoords[ 8] = 0.5f;
2112                 m_texCoords[9] =  2.0f; m_texCoords[10] =  2.0f; m_texCoords[11] =  2.5f;
2113         }
2114
2115         // set render params
2116         {
2117                 const tcu::TextureFormat                texFormat               = m_texture->getRefTexture().getFormat();
2118                 const tcu::TextureFormatInfo    texFormatInfo   = tcu::getTextureFormatInfo(texFormat);
2119
2120                 m_borderColor   = mapToFormatColorRepresentable(texFormat, tcu::Vec4(0.2f, 0.6f, 0.9f, 0.4f));
2121
2122                 m_lookupScale   = texFormatInfo.lookupScale;
2123                 m_lookupBias    = texFormatInfo.lookupBias;
2124         }
2125 }
2126
2127 void TextureBorderClampPerAxisCase3D::deinit (void)
2128 {
2129         m_texture.clear();
2130         m_renderer.clear();
2131 }
2132
2133 TextureBorderClampPerAxisCase3D::IterateResult TextureBorderClampPerAxisCase3D::iterate (void)
2134 {
2135         tcu::Surface                                                            renderedFrame           (VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
2136         const glu::TextureTestUtil::ReferenceParams     samplerParams           = getSamplerParams();
2137
2138         logParams(samplerParams);
2139         renderTo(renderedFrame, samplerParams);
2140         verifyImage(renderedFrame, samplerParams);
2141
2142         return STOP;
2143 }
2144
2145 void TextureBorderClampPerAxisCase3D::logParams (const glu::TextureTestUtil::ReferenceParams& samplerParams)
2146 {
2147         const std::string       borderColorString       = (m_channelClass == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER)   ? (de::toString(m_borderColor.get<deInt32>()))
2148                                                                                         : (m_channelClass == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER) ? (de::toString(m_borderColor.get<deUint32>()))
2149                                                                                         :                                                                                                                                 (de::toString(m_borderColor.get<float>()));
2150
2151         m_testCtx.getLog()      << tcu::TestLog::Message
2152                                                 << "Border color is " << borderColorString << "\n"
2153                                                 << "Texture lookup bias: " << samplerParams.colorBias << "\n"
2154                                                 << "Texture lookup scale: " << samplerParams.colorScale << "\n"
2155                                                 << "Filter: " << glu::getTextureFilterName(m_filter) << "\n"
2156                                                 << "Wrap mode: s = " << glu::getRepeatModeStr(m_sWrap)
2157                                                         << ", t = " << glu::getRepeatModeStr(m_tWrap)
2158                                                         << ", r = " << glu::getRepeatModeStr(m_rWrap) << "\n"
2159                                                 << tcu::TestLog::EndMessage;
2160 }
2161
2162 void TextureBorderClampPerAxisCase3D::renderTo (tcu::Surface&                                                                   surface,
2163                                                                                                 const glu::TextureTestUtil::ReferenceParams&    samplerParams)
2164 {
2165         const glw::Functions&                                           gl                      = m_context.getRenderContext().getFunctions();
2166         const gls::TextureTestUtil::RandomViewport      viewport        (m_context.getRenderTarget(), VIEWPORT_WIDTH, VIEWPORT_HEIGHT, getCaseSeed());
2167
2168         // Bind to unit 0.
2169         gl.activeTexture(GL_TEXTURE0);
2170         gl.bindTexture(GL_TEXTURE_3D, m_texture->getGLTexture());
2171
2172         // Setup filtering and wrap modes.
2173         gl.texParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S,              glu::getGLWrapMode(samplerParams.sampler.wrapS));
2174         gl.texParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T,              glu::getGLWrapMode(samplerParams.sampler.wrapT));
2175         gl.texParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R,              glu::getGLWrapMode(samplerParams.sampler.wrapR));
2176         gl.texParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER,  glu::getGLFilterMode(samplerParams.sampler.minFilter));
2177         gl.texParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER,  glu::getGLFilterMode(samplerParams.sampler.magFilter));
2178
2179         switch (m_channelClass)
2180         {
2181                 case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
2182                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
2183                 case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
2184                         gl.texParameterfv(GL_TEXTURE_3D, GL_TEXTURE_BORDER_COLOR, m_borderColor.getAccess<float>());
2185                         break;
2186
2187                 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
2188                         gl.texParameterIiv(GL_TEXTURE_3D, GL_TEXTURE_BORDER_COLOR, m_borderColor.getAccess<deInt32>());
2189                         break;
2190
2191                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
2192                         gl.texParameterIuiv(GL_TEXTURE_3D, GL_TEXTURE_BORDER_COLOR, m_borderColor.getAccess<deUint32>());
2193                         break;
2194
2195                 default:
2196                         DE_ASSERT(false);
2197         }
2198
2199         GLU_EXPECT_NO_ERROR(gl.getError(), "Set texturing state");
2200
2201         gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height);
2202         m_renderer->renderQuad(0, &m_texCoords[0], samplerParams);
2203         glu::readPixels(m_context.getRenderContext(), viewport.x, viewport.y, surface.getAccess());
2204 }
2205
2206 void TextureBorderClampPerAxisCase3D::verifyImage (const tcu::Surface&                                                  renderedFrame,
2207                                                                                                    const glu::TextureTestUtil::ReferenceParams& samplerParams)
2208 {
2209         const tcu::PixelFormat                  pixelFormat                     = m_context.getRenderTarget().getPixelFormat();
2210         const int                                               colorErrorBits          = 2;
2211         const tcu::IVec4                                colorBits                       = tcu::max(glu::TextureTestUtil::getBitsVec(pixelFormat) - tcu::IVec4(colorErrorBits), tcu::IVec4(0));
2212         tcu::Surface                                    reference                       (renderedFrame.getWidth(), renderedFrame.getHeight());
2213         tcu::Surface                                    errorMask                       (renderedFrame.getWidth(), renderedFrame.getHeight());
2214         tcu::LodPrecision                               lodPrecision;
2215         tcu::LookupPrecision                    lookupPrecision;
2216         int                                                             numFailedPixels;
2217
2218         lodPrecision.derivateBits               = 18;
2219         lodPrecision.lodBits                    = 5;
2220
2221         lookupPrecision.colorThreshold  = tcu::computeFixedPointThreshold(colorBits) / samplerParams.colorScale;
2222         lookupPrecision.coordBits               = tcu::IVec3(20,20,0);
2223         lookupPrecision.uvwBits                 = tcu::IVec3(5,5,0);
2224         lookupPrecision.colorMask               = glu::TextureTestUtil::getCompareMask(pixelFormat);
2225
2226         glu::TextureTestUtil::sampleTexture(tcu::SurfaceAccess(reference, pixelFormat), m_texture->getRefTexture(), &m_texCoords[0], samplerParams);
2227
2228         numFailedPixels = glu::TextureTestUtil::computeTextureLookupDiff(renderedFrame.getAccess(), reference.getAccess(), errorMask.getAccess(), m_texture->getRefTexture(),
2229                                                                                                                                          &m_texCoords[0], samplerParams, lookupPrecision, lodPrecision, m_testCtx.getWatchDog());
2230
2231         if (numFailedPixels > 0)
2232                 m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: Result verification failed, got " << numFailedPixels << " invalid pixels!" << tcu::TestLog::EndMessage;
2233         m_testCtx.getLog()      << tcu::TestLog::ImageSet("VerifyResult", "Verification result")
2234                                                 << tcu::TestLog::Image("Rendered", "Rendered image", renderedFrame);
2235         if (numFailedPixels > 0)
2236         {
2237                 m_testCtx.getLog()      << tcu::TestLog::Image("Reference", "Ideal reference image", reference)
2238                                                         << tcu::TestLog::Image("ErrorMask", "Error mask", errorMask);
2239         }
2240         m_testCtx.getLog() << tcu::TestLog::EndImageSet;
2241
2242         if (numFailedPixels == 0)
2243                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
2244         else
2245                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image verification failed");
2246 }
2247
2248 glu::TextureTestUtil::ReferenceParams TextureBorderClampPerAxisCase3D::getSamplerParams (void) const
2249 {
2250         const tcu::TextureFormat                                texFormat               = m_texture->getRefTexture().getFormat();
2251         glu::TextureTestUtil::ReferenceParams   refParams               (glu::TextureTestUtil::TEXTURETYPE_3D);
2252
2253         refParams.sampler                                       = glu::mapGLSampler(m_sWrap, m_tWrap, m_rWrap, m_filter, m_filter);
2254         refParams.sampler.borderColor           = m_borderColor;
2255         refParams.lodMode                                       = glu::TextureTestUtil::LODMODE_EXACT;
2256         refParams.samplerType                           = glu::TextureTestUtil::getSamplerType(texFormat);
2257         refParams.colorScale                            = m_lookupScale;
2258         refParams.colorBias                                     = m_lookupBias;
2259
2260         return refParams;
2261 }
2262
2263 deUint32 TextureBorderClampPerAxisCase3D::getCaseSeed (void) const
2264 {
2265         tcu::SeedBuilder builder;
2266         builder << std::string(getName())
2267                         << m_texFormat
2268                         << m_filter
2269                         << m_sWrap
2270                         << m_tWrap
2271                         << m_rWrap
2272                         << m_texture->getRefTexture().getWidth()
2273                         << m_texture->getRefTexture().getHeight()
2274                         << m_texture->getRefTexture().getDepth();
2275         return builder.get();
2276 }
2277
2278 } // anonymous
2279
2280 TextureBorderClampTests::TextureBorderClampTests (Context& context)
2281         : TestCaseGroup(context, "border_clamp", "EXT_texture_border_clamp tests")
2282 {
2283 }
2284
2285 TextureBorderClampTests::~TextureBorderClampTests (void)
2286 {
2287 }
2288
2289 void TextureBorderClampTests::init (void)
2290 {
2291         static const struct
2292         {
2293                 const char*                                                                     name;
2294                 deUint32                                                                        filter;
2295                 TextureBorderClampTest::SamplingFunction        sampling;
2296         } s_filters[] =
2297         {
2298                 { "nearest",    GL_NEAREST,     TextureBorderClampTest::SAMPLE_FILTER   },
2299                 { "linear",             GL_LINEAR,      TextureBorderClampTest::SAMPLE_FILTER   },
2300                 { "gather",             GL_NEAREST,     TextureBorderClampTest::SAMPLE_GATHER   },
2301         };
2302
2303         // .formats
2304         {
2305                 static const struct
2306                 {
2307                         const char*                                             name;
2308                         deUint32                                                format;
2309                         tcu::Sampler::DepthStencilMode  mode;
2310                 } formats[] =
2311                 {
2312                         { "luminance",                                                                  GL_LUMINANCE,                                                                   tcu::Sampler::MODE_LAST         },
2313                         { "alpha",                                                                              GL_ALPHA,                                                                               tcu::Sampler::MODE_LAST         },
2314                         { "luminance_alpha",                                                    GL_LUMINANCE_ALPHA,                                                             tcu::Sampler::MODE_LAST         },
2315                         { "bgra",                                                                               GL_BGRA,                                                                                tcu::Sampler::MODE_LAST         },
2316                         { "r8",                                                                                 GL_R8,                                                                                  tcu::Sampler::MODE_LAST         },
2317                         { "r8_snorm",                                                                   GL_R8_SNORM,                                                                    tcu::Sampler::MODE_LAST         },
2318                         { "rg8",                                                                                GL_RG8,                                                                                 tcu::Sampler::MODE_LAST         },
2319                         { "rg8_snorm",                                                                  GL_RG8_SNORM,                                                                   tcu::Sampler::MODE_LAST         },
2320                         { "rgb8",                                                                               GL_RGB8,                                                                                tcu::Sampler::MODE_LAST         },
2321                         { "rgb8_snorm",                                                                 GL_RGB8_SNORM,                                                                  tcu::Sampler::MODE_LAST         },
2322                         { "rgb565",                                                                             GL_RGB565,                                                                              tcu::Sampler::MODE_LAST         },
2323                         { "rgba4",                                                                              GL_RGBA4,                                                                               tcu::Sampler::MODE_LAST         },
2324                         { "rgb5_a1",                                                                    GL_RGB5_A1,                                                                             tcu::Sampler::MODE_LAST         },
2325                         { "rgba8",                                                                              GL_RGBA8,                                                                               tcu::Sampler::MODE_LAST         },
2326                         { "rgba8_snorm",                                                                GL_RGBA8_SNORM,                                                                 tcu::Sampler::MODE_LAST         },
2327                         { "rgb10_a2",                                                                   GL_RGB10_A2,                                                                    tcu::Sampler::MODE_LAST         },
2328                         { "rgb10_a2ui",                                                                 GL_RGB10_A2UI,                                                                  tcu::Sampler::MODE_LAST         },
2329                         { "srgb8",                                                                              GL_SRGB8,                                                                               tcu::Sampler::MODE_LAST         },
2330                         { "srgb8_alpha8",                                                               GL_SRGB8_ALPHA8,                                                                tcu::Sampler::MODE_LAST         },
2331                         { "r16f",                                                                               GL_R16F,                                                                                tcu::Sampler::MODE_LAST         },
2332                         { "rg16f",                                                                              GL_RG16F,                                                                               tcu::Sampler::MODE_LAST         },
2333                         { "rgb16f",                                                                             GL_RGB16F,                                                                              tcu::Sampler::MODE_LAST         },
2334                         { "rgba16f",                                                                    GL_RGBA16F,                                                                             tcu::Sampler::MODE_LAST         },
2335                         { "r32f",                                                                               GL_R32F,                                                                                tcu::Sampler::MODE_LAST         },
2336                         { "rg32f",                                                                              GL_RG32F,                                                                               tcu::Sampler::MODE_LAST         },
2337                         { "rgb32f",                                                                             GL_RGB32F,                                                                              tcu::Sampler::MODE_LAST         },
2338                         { "rgba32f",                                                                    GL_RGBA32F,                                                                             tcu::Sampler::MODE_LAST         },
2339                         { "r11f_g11f_b10f",                                                             GL_R11F_G11F_B10F,                                                              tcu::Sampler::MODE_LAST         },
2340                         { "rgb9_e5",                                                                    GL_RGB9_E5,                                                                             tcu::Sampler::MODE_LAST         },
2341                         { "r8i",                                                                                GL_R8I,                                                                                 tcu::Sampler::MODE_LAST         },
2342                         { "r8ui",                                                                               GL_R8UI,                                                                                tcu::Sampler::MODE_LAST         },
2343                         { "r16i",                                                                               GL_R16I,                                                                                tcu::Sampler::MODE_LAST         },
2344                         { "r16ui",                                                                              GL_R16UI,                                                                               tcu::Sampler::MODE_LAST         },
2345                         { "r32i",                                                                               GL_R32I,                                                                                tcu::Sampler::MODE_LAST         },
2346                         { "r32ui",                                                                              GL_R32UI,                                                                               tcu::Sampler::MODE_LAST         },
2347                         { "rg8i",                                                                               GL_RG8I,                                                                                tcu::Sampler::MODE_LAST         },
2348                         { "rg8ui",                                                                              GL_RG8UI,                                                                               tcu::Sampler::MODE_LAST         },
2349                         { "rg16i",                                                                              GL_RG16I,                                                                               tcu::Sampler::MODE_LAST         },
2350                         { "rg16ui",                                                                             GL_RG16UI,                                                                              tcu::Sampler::MODE_LAST         },
2351                         { "rg32i",                                                                              GL_RG32I,                                                                               tcu::Sampler::MODE_LAST         },
2352                         { "rg32ui",                                                                             GL_RG32UI,                                                                              tcu::Sampler::MODE_LAST         },
2353                         { "rgb8i",                                                                              GL_RGB8I,                                                                               tcu::Sampler::MODE_LAST         },
2354                         { "rgb8ui",                                                                             GL_RGB8UI,                                                                              tcu::Sampler::MODE_LAST         },
2355                         { "rgb16i",                                                                             GL_RGB16I,                                                                              tcu::Sampler::MODE_LAST         },
2356                         { "rgb16ui",                                                                    GL_RGB16UI,                                                                             tcu::Sampler::MODE_LAST         },
2357                         { "rgb32i",                                                                             GL_RGB32I,                                                                              tcu::Sampler::MODE_LAST         },
2358                         { "rgb32ui",                                                                    GL_RGB32UI,                                                                             tcu::Sampler::MODE_LAST         },
2359                         { "rgba8i",                                                                             GL_RGBA8I,                                                                              tcu::Sampler::MODE_LAST         },
2360                         { "rgba8ui",                                                                    GL_RGBA8UI,                                                                             tcu::Sampler::MODE_LAST         },
2361                         { "rgba16i",                                                                    GL_RGBA16I,                                                                             tcu::Sampler::MODE_LAST         },
2362                         { "rgba16ui",                                                                   GL_RGBA16UI,                                                                    tcu::Sampler::MODE_LAST         },
2363                         { "rgba32i",                                                                    GL_RGBA32I,                                                                             tcu::Sampler::MODE_LAST         },
2364                         { "rgba32ui",                                                                   GL_RGBA32UI,                                                                    tcu::Sampler::MODE_LAST         },
2365                         { "depth_component16",                                                  GL_DEPTH_COMPONENT16,                                                   tcu::Sampler::MODE_DEPTH        },
2366                         { "depth_component24",                                                  GL_DEPTH_COMPONENT24,                                                   tcu::Sampler::MODE_DEPTH        },
2367                         { "depth_component32f",                                                 GL_DEPTH_COMPONENT32F,                                                  tcu::Sampler::MODE_DEPTH        },
2368                         { "stencil_index8",                                                             GL_STENCIL_INDEX8,                                                              tcu::Sampler::MODE_STENCIL      },
2369                         { "depth24_stencil8_sample_depth",                              GL_DEPTH24_STENCIL8,                                                    tcu::Sampler::MODE_DEPTH        },
2370                         { "depth32f_stencil8_sample_depth",                             GL_DEPTH32F_STENCIL8,                                                   tcu::Sampler::MODE_DEPTH        },
2371                         { "depth24_stencil8_sample_stencil",                    GL_DEPTH24_STENCIL8,                                                    tcu::Sampler::MODE_STENCIL      },
2372                         { "depth32f_stencil8_sample_stencil",                   GL_DEPTH32F_STENCIL8,                                                   tcu::Sampler::MODE_STENCIL      },
2373                         { "compressed_r11_eac",                                                 GL_COMPRESSED_R11_EAC,                                                  tcu::Sampler::MODE_LAST         },
2374                         { "compressed_signed_r11_eac",                                  GL_COMPRESSED_SIGNED_R11_EAC,                                   tcu::Sampler::MODE_LAST         },
2375                         { "compressed_rg11_eac",                                                GL_COMPRESSED_RG11_EAC,                                                 tcu::Sampler::MODE_LAST         },
2376                         { "compressed_signed_rg11_eac",                                 GL_COMPRESSED_SIGNED_RG11_EAC,                                  tcu::Sampler::MODE_LAST         },
2377                         { "compressed_rgb8_etc2",                                               GL_COMPRESSED_RGB8_ETC2,                                                tcu::Sampler::MODE_LAST         },
2378                         { "compressed_srgb8_etc2",                                              GL_COMPRESSED_SRGB8_ETC2,                                               tcu::Sampler::MODE_LAST         },
2379                         { "compressed_rgb8_punchthrough_alpha1_etc2",   GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2,    tcu::Sampler::MODE_LAST         },
2380                         { "compressed_srgb8_punchthrough_alpha1_etc2",  GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2,   tcu::Sampler::MODE_LAST         },
2381                         { "compressed_rgba8_etc2_eac",                                  GL_COMPRESSED_RGBA8_ETC2_EAC,                                   tcu::Sampler::MODE_LAST         },
2382                         { "compressed_srgb8_alpha8_etc2_eac",                   GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC,                    tcu::Sampler::MODE_LAST         },
2383                 };
2384
2385                 tcu::TestCaseGroup* const formatsGroup = new tcu::TestCaseGroup(m_testCtx, "formats", "Format tests");
2386                 addChild(formatsGroup);
2387
2388                 // .format
2389                 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(formats); ++formatNdx)
2390                 {
2391                         const deUint32                                                  format                  = formats[formatNdx].format;
2392                         const tcu::Sampler::DepthStencilMode    sampleMode              = formats[formatNdx].mode;
2393                         const bool                                                              isCompressed    = glu::isCompressedFormat(format);
2394                         const bool                                                              coreFilterable  = isCoreFilterableFormat(format, sampleMode);
2395                         tcu::TestCaseGroup* const                               formatGroup             = new tcu::TestCaseGroup(m_testCtx, formats[formatNdx].name, "Format test");
2396
2397                         formatsGroup->addChild(formatGroup);
2398
2399                         // .nearest
2400                         // .linear
2401                         for (int filterNdx = 0; filterNdx < DE_LENGTH_OF_ARRAY(s_filters); ++filterNdx)
2402                         {
2403                                 // [not-compressed]
2404                                 // .size_pot
2405                                 // .size_npot
2406                                 // [compressed]
2407                                 // .size_tile_multiple (also pot)
2408                                 // .size_not_tile_multiple (also npot)
2409                                 for (int sizeNdx = 0; sizeNdx < 2; ++sizeNdx)
2410                                 {
2411                                         const bool                              isNpotCase              = (sizeNdx == 1);
2412                                         const char* const               sizePotName             = (!isCompressed) ? ("size_pot") : ("size_tile_multiple");
2413                                         const char* const               sizeNpotName    = (!isCompressed) ? ("size_npot") : ("size_not_tile_multiple");
2414                                         const char* const               sizeName                = (isNpotCase) ? (sizeNpotName) : (sizePotName);
2415                                         const SizeType                  sizeType                = (isNpotCase) ? (SIZE_NPOT) : (SIZE_POT);
2416                                         const std::string               caseName                = std::string() + s_filters[filterNdx].name + "_" + sizeName;
2417                                         const deUint32                  filter                  = s_filters[filterNdx].filter;
2418
2419                                         if (coreFilterable || !filterRequiresFilterability(filter))
2420                                                 formatGroup->addChild(new TextureBorderClampFormatCase(m_context,
2421                                                                                                                                                            caseName.c_str(),
2422                                                                                                                                                            "",
2423                                                                                                                                                            format,
2424                                                                                                                                                            sampleMode,
2425                                                                                                                                                            TextureBorderClampFormatCase::STATE_TEXTURE_PARAM,
2426                                                                                                                                                            sizeType,
2427                                                                                                                                                            filter,
2428                                                                                                                                                            s_filters[filterNdx].sampling));
2429                                 }
2430                         }
2431                 }
2432         }
2433
2434         // .range_clamp
2435         {
2436                 static const struct
2437                 {
2438                         const char*                                             name;
2439                         deUint32                                                format;
2440                         tcu::Sampler::DepthStencilMode  mode;
2441                 } formats[] =
2442                 {
2443                         { "unorm_color",                                                                GL_R8,                                  tcu::Sampler::MODE_LAST         },
2444                         { "snorm_color",                                                                GL_R8_SNORM,                    tcu::Sampler::MODE_LAST         },
2445                         { "float_color",                                                                GL_RG32F,                               tcu::Sampler::MODE_LAST         },
2446                         { "int_color",                                                                  GL_R8I,                                 tcu::Sampler::MODE_LAST         },
2447                         { "uint_color",                                                                 GL_R16UI,                               tcu::Sampler::MODE_LAST         },
2448                         { "srgb_color",                                                                 GL_SRGB8_ALPHA8,                tcu::Sampler::MODE_LAST         },
2449                         { "unorm_depth",                                                                GL_DEPTH_COMPONENT24,   tcu::Sampler::MODE_DEPTH        },
2450                         { "float_depth",                                                                GL_DEPTH_COMPONENT32F,  tcu::Sampler::MODE_DEPTH        },
2451                         { "uint_stencil",                                                               GL_STENCIL_INDEX8,              tcu::Sampler::MODE_STENCIL      },
2452                         { "float_depth_uint_stencil_sample_depth",              GL_DEPTH32F_STENCIL8,   tcu::Sampler::MODE_DEPTH        },
2453                         { "float_depth_uint_stencil_sample_stencil",    GL_DEPTH32F_STENCIL8,   tcu::Sampler::MODE_STENCIL      },
2454                         { "unorm_depth_uint_stencil_sample_depth",              GL_DEPTH24_STENCIL8,    tcu::Sampler::MODE_DEPTH        },
2455                         { "unorm_depth_uint_stencil_sample_stencil",    GL_DEPTH24_STENCIL8,    tcu::Sampler::MODE_STENCIL      },
2456                         { "compressed_color",                                                   GL_COMPRESSED_RG11_EAC, tcu::Sampler::MODE_LAST         },
2457                 };
2458
2459                 tcu::TestCaseGroup* const rangeClampGroup = new tcu::TestCaseGroup(m_testCtx, "range_clamp", "Range clamp tests");
2460                 addChild(rangeClampGroup);
2461
2462                 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(formats); ++formatNdx)
2463                 for (int filterNdx = 0; filterNdx < DE_LENGTH_OF_ARRAY(s_filters); ++filterNdx)
2464                 {
2465                         const deUint32                                                  format                  = formats[formatNdx].format;
2466                         const tcu::Sampler::DepthStencilMode    sampleMode              = formats[formatNdx].mode;
2467                         const std::string                                               caseName                = std::string() + s_filters[filterNdx].name + "_" + formats[formatNdx].name;
2468                         const deUint32                                                  filter                  = s_filters[filterNdx].filter;
2469                         const bool                                                              coreFilterable  = isCoreFilterableFormat(format, sampleMode);
2470
2471                         if (s_filters[filterNdx].sampling == TextureBorderClampTest::SAMPLE_GATHER)
2472                                 continue;
2473
2474                         if (coreFilterable || !filterRequiresFilterability(filter))
2475                                 rangeClampGroup->addChild(new TextureBorderClampRangeClampCase(m_context, caseName.c_str(), "", format, sampleMode, filter));
2476                 }
2477         }
2478
2479         // .sampler
2480         {
2481                 static const struct
2482                 {
2483                         const char*                                             name;
2484                         deUint32                                                format;
2485                         tcu::Sampler::DepthStencilMode  mode;
2486                 } formats[] =
2487                 {
2488                         { "unorm_color",                GL_R8,                                  tcu::Sampler::MODE_LAST         },
2489                         { "snorm_color",                GL_R8_SNORM,                    tcu::Sampler::MODE_LAST         },
2490                         { "float_color",                GL_RG32F,                               tcu::Sampler::MODE_LAST         },
2491                         { "int_color",                  GL_R8I,                                 tcu::Sampler::MODE_LAST         },
2492                         { "uint_color",                 GL_R16UI,                               tcu::Sampler::MODE_LAST         },
2493                         { "unorm_depth",                GL_DEPTH_COMPONENT24,   tcu::Sampler::MODE_DEPTH        },
2494                         { "float_depth",                GL_DEPTH_COMPONENT32F,  tcu::Sampler::MODE_DEPTH        },
2495                         { "uint_stencil",               GL_STENCIL_INDEX8,              tcu::Sampler::MODE_STENCIL      },
2496                         { "compressed_color",   GL_COMPRESSED_RG11_EAC, tcu::Sampler::MODE_LAST         },
2497                 };
2498
2499                 tcu::TestCaseGroup* const samplerGroup = new tcu::TestCaseGroup(m_testCtx, "sampler", "Sampler param tests");
2500                 addChild(samplerGroup);
2501
2502                 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(formats); ++formatNdx)
2503                 {
2504                         const deUint32                                                  format          = formats[formatNdx].format;
2505                         const tcu::Sampler::DepthStencilMode    sampleMode      = formats[formatNdx].mode;
2506                         const char*                                                             caseName        = formats[formatNdx].name;
2507
2508                         samplerGroup->addChild(new TextureBorderClampFormatCase(m_context,
2509                                                                                                                                         caseName,
2510                                                                                                                                         "",
2511                                                                                                                                         format,
2512                                                                                                                                         sampleMode,
2513                                                                                                                                         TextureBorderClampFormatCase::STATE_SAMPLER_PARAM,
2514                                                                                                                                         SIZE_POT,
2515                                                                                                                                         GL_NEAREST,
2516                                                                                                                                         TextureBorderClampFormatCase::SAMPLE_FILTER));
2517                 }
2518         }
2519
2520         // .per_axis_wrap_mode
2521         {
2522                 static const struct
2523                 {
2524                         const char*                                             name;
2525                         bool                                                    is3D;
2526                 } targets[] =
2527                 {
2528                         { "texture_2d", false   },
2529                         { "texture_3d", true    },
2530                 };
2531                 static const struct
2532                 {
2533                         const char*                                             name;
2534                         deUint32                                                format;
2535                         tcu::Sampler::DepthStencilMode  mode;
2536                         bool                                                    supports3D;
2537                 } formats[] =
2538                 {
2539                         { "unorm_color",                GL_RG8,                                         tcu::Sampler::MODE_LAST,        true    },
2540                         { "snorm_color",                GL_RG8_SNORM,                           tcu::Sampler::MODE_LAST,        true    },
2541                         { "float_color",                GL_R32F,                                        tcu::Sampler::MODE_LAST,        true    },
2542                         { "int_color",                  GL_RG16I,                                       tcu::Sampler::MODE_LAST,        true    },
2543                         { "uint_color",                 GL_R8UI,                                        tcu::Sampler::MODE_LAST,        true    },
2544                         { "unorm_depth",                GL_DEPTH_COMPONENT16,           tcu::Sampler::MODE_DEPTH,       false   },
2545                         { "float_depth",                GL_DEPTH32F_STENCIL8,           tcu::Sampler::MODE_DEPTH,       false   },
2546                         { "uint_stencil",               GL_DEPTH32F_STENCIL8,           tcu::Sampler::MODE_STENCIL,     false   },
2547                         { "compressed_color",   GL_COMPRESSED_RGB8_ETC2,        tcu::Sampler::MODE_LAST,        false   },
2548                 };
2549                 static const struct
2550                 {
2551                         const char*     name;
2552                         deUint32        sWrap;
2553                         deUint32        tWrap;
2554                         deUint32        rWrap;
2555                         bool            is3D;
2556                 } wrapConfigs[] =
2557                 {
2558                         // 2d configs
2559                         { "s_clamp_to_edge_t_clamp_to_border",                                          GL_CLAMP_TO_EDGE,       GL_CLAMP_TO_BORDER,     GL_NONE,                        false   },
2560                         { "s_repeat_t_clamp_to_border",                                                         GL_REPEAT,                      GL_CLAMP_TO_BORDER,     GL_NONE,                        false   },
2561                         { "s_mirrored_repeat_t_clamp_to_border",                                        GL_MIRRORED_REPEAT,     GL_CLAMP_TO_BORDER,     GL_NONE,                        false   },
2562
2563                         // 3d configs
2564                         { "s_clamp_to_border_t_clamp_to_border_r_clamp_to_border",      GL_CLAMP_TO_BORDER,     GL_CLAMP_TO_BORDER,     GL_CLAMP_TO_BORDER,     true    },
2565                         { "s_clamp_to_border_t_clamp_to_border_r_repeat",                       GL_CLAMP_TO_BORDER,     GL_CLAMP_TO_BORDER,     GL_REPEAT,                      true    },
2566                         { "s_mirrored_repeat_t_clamp_to_border_r_repeat",                       GL_MIRRORED_REPEAT,     GL_CLAMP_TO_BORDER,     GL_REPEAT,                      true    },
2567                         { "s_repeat_t_mirrored_repeat_r_clamp_to_border",                       GL_REPEAT,                      GL_MIRRORED_REPEAT,     GL_CLAMP_TO_BORDER,     true    },
2568                 };
2569
2570                 tcu::TestCaseGroup* const perAxisGroup = new tcu::TestCaseGroup(m_testCtx, "per_axis_wrap_mode", "Per-axis wrapping modes");
2571                 addChild(perAxisGroup);
2572
2573                 // .texture_nd
2574                 for (int targetNdx = 0; targetNdx < DE_LENGTH_OF_ARRAY(targets); ++targetNdx)
2575                 {
2576                         tcu::TestCaseGroup* const targetGroup = new tcu::TestCaseGroup(m_testCtx, targets[targetNdx].name, "Texture target test");
2577                         perAxisGroup->addChild(targetGroup);
2578
2579                         // .format
2580                         for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(formats); ++formatNdx)
2581                         {
2582                                 if (targets[targetNdx].is3D && !formats[formatNdx].supports3D)
2583                                         continue;
2584                                 else
2585                                 {
2586                                         const deUint32                                                  format                  = formats[formatNdx].format;
2587                                         const tcu::Sampler::DepthStencilMode    sampleMode              = formats[formatNdx].mode;
2588                                         const bool                                                              coreFilterable  = isCoreFilterableFormat(format, sampleMode);
2589                                         tcu::TestCaseGroup* const                               formatGroup             = new tcu::TestCaseGroup(m_testCtx, formats[formatNdx].name, "Format test");
2590                                         targetGroup->addChild(formatGroup);
2591
2592                                         // .linear
2593                                         // .nearest
2594                                         // .gather
2595                                         for (int filterNdx = 0; filterNdx < DE_LENGTH_OF_ARRAY(s_filters); ++filterNdx)
2596                                         {
2597                                                 const deUint32 filter = s_filters[filterNdx].filter;
2598
2599                                                 if (!coreFilterable && filterRequiresFilterability(filter))
2600                                                 {
2601                                                         // skip linear on pure integers
2602                                                         continue;
2603                                                 }
2604                                                 else if (s_filters[filterNdx].sampling == TextureBorderClampTest::SAMPLE_GATHER && targets[targetNdx].is3D)
2605                                                 {
2606                                                         // skip gather on 3d
2607                                                         continue;
2608                                                 }
2609                                                 else
2610                                                 {
2611                                                         tcu::TestCaseGroup* const filteringGroup = new tcu::TestCaseGroup(m_testCtx, s_filters[filterNdx].name, "Tests with specific filter");
2612                                                         formatGroup->addChild(filteringGroup);
2613
2614                                                         // .s_XXX_t_XXX(_r_XXX)
2615                                                         for (int wrapNdx = 0; wrapNdx < DE_LENGTH_OF_ARRAY(wrapConfigs); ++wrapNdx)
2616                                                         {
2617                                                                 if (wrapConfigs[wrapNdx].is3D != targets[targetNdx].is3D)
2618                                                                         continue;
2619                                                                 else
2620                                                                 {
2621                                                                         for (int sizeNdx = 0; sizeNdx < 2; ++sizeNdx)
2622                                                                         {
2623                                                                                 const char* const               wrapName                        = wrapConfigs[wrapNdx].name;
2624                                                                                 const bool                              isNpotCase                      = (sizeNdx == 1);
2625                                                                                 const char* const               sizeNameExtension       = (isNpotCase) ? ("_npot") : ("_pot");
2626                                                                                 const SizeType                  size                            = (isNpotCase) ? (SIZE_NPOT) : (SIZE_POT);
2627
2628                                                                                 if (!targets[targetNdx].is3D)
2629                                                                                         filteringGroup->addChild(new TextureBorderClampPerAxisCase2D(m_context,
2630                                                                                                                                                                                                                  (std::string() + wrapName + sizeNameExtension).c_str(),
2631                                                                                                                                                                                                                  "",
2632                                                                                                                                                                                                                  format,
2633                                                                                                                                                                                                                  sampleMode,
2634                                                                                                                                                                                                                  size,
2635                                                                                                                                                                                                                  filter,
2636                                                                                                                                                                                                                  wrapConfigs[wrapNdx].sWrap,
2637                                                                                                                                                                                                                  wrapConfigs[wrapNdx].tWrap,
2638                                                                                                                                                                                                                  s_filters[filterNdx].sampling));
2639                                                                                 else
2640                                                                                 {
2641                                                                                         DE_ASSERT(sampleMode == tcu::Sampler::MODE_LAST);
2642                                                                                         filteringGroup->addChild(new TextureBorderClampPerAxisCase3D(m_context,
2643                                                                                                                                                                                                                  (std::string() + wrapName + sizeNameExtension).c_str(),
2644                                                                                                                                                                                                                  "",
2645                                                                                                                                                                                                                  format,
2646                                                                                                                                                                                                                  size,
2647                                                                                                                                                                                                                  filter,
2648                                                                                                                                                                                                                  wrapConfigs[wrapNdx].sWrap,
2649                                                                                                                                                                                                                  wrapConfigs[wrapNdx].tWrap,
2650                                                                                                                                                                                                                  wrapConfigs[wrapNdx].rWrap));
2651                                                                                 }
2652                                                                         }
2653                                                                 }
2654                                                         }
2655                                                 }
2656                                         }
2657                                 }
2658                         }
2659                 }
2660         }
2661
2662         // .depth_compare_mode
2663         {
2664                 static const struct
2665                 {
2666                         const char*                                             name;
2667                         deUint32                                                format;
2668                 } formats[] =
2669                 {
2670                         { "depth_component16",          GL_DEPTH_COMPONENT16    },
2671                         { "depth_component24",          GL_DEPTH_COMPONENT24    },
2672                         { "depth24_stencil8",           GL_DEPTH24_STENCIL8             },
2673                         { "depth32f_stencil8",          GL_DEPTH32F_STENCIL8    },
2674                 };
2675
2676                 tcu::TestCaseGroup* const compareGroup = new tcu::TestCaseGroup(m_testCtx, "depth_compare_mode", "Tests depth compare mode");
2677                 addChild(compareGroup);
2678
2679                 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(formats); ++formatNdx)
2680                 {
2681                         const deUint32                                                  format                  = formats[formatNdx].format;
2682                         tcu::TestCaseGroup* const                               formatGroup             = new tcu::TestCaseGroup(m_testCtx, formats[formatNdx].name, "Format test");
2683
2684                         compareGroup->addChild(formatGroup);
2685
2686                         // (format).(linear|nearest|gather)_(pot|npot)
2687                         for (int filterNdx = 0; filterNdx < DE_LENGTH_OF_ARRAY(s_filters); ++filterNdx)
2688                         for (int sizeNdx = 0; sizeNdx < 2; ++sizeNdx)
2689                         {
2690                                         const bool                              isNpotCase              = (sizeNdx == 1);
2691                                         const char* const               sizeName                = (isNpotCase) ? ("size_npot") : ("size_pot");
2692                                         const SizeType                  sizeType                = (isNpotCase) ? (SIZE_NPOT) : (SIZE_POT);
2693                                         const std::string               caseName                = std::string() + s_filters[filterNdx].name + "_" + sizeName;
2694                                         const deUint32                  filter                  = s_filters[filterNdx].filter;
2695
2696                                         formatGroup->addChild(new TextureBorderClampDepthCompareCase(m_context,
2697                                                                                                                                                                  caseName.c_str(),
2698                                                                                                                                                                  "",
2699                                                                                                                                                                  format,
2700                                                                                                                                                                  sizeType,
2701                                                                                                                                                                  filter,
2702                                                                                                                                                                  s_filters[filterNdx].sampling));
2703                         }
2704                 }
2705         }
2706
2707         // unused channels (A in rgb, G in stencil etc.)
2708         {
2709                 static const struct
2710                 {
2711                         const char*                                             name;
2712                         deUint32                                                format;
2713                         tcu::Sampler::DepthStencilMode  mode;
2714                 } formats[] =
2715                 {
2716                         { "r8",                                                                         GL_R8,                                          tcu::Sampler::MODE_LAST         },
2717                         { "rg8_snorm",                                                          GL_RG8_SNORM,                           tcu::Sampler::MODE_LAST         },
2718                         { "rgb8",                                                                       GL_RGB8,                                        tcu::Sampler::MODE_LAST         },
2719                         { "rg32f",                                                                      GL_RG32F,                                       tcu::Sampler::MODE_LAST         },
2720                         { "r16i",                                                                       GL_RG16I,                                       tcu::Sampler::MODE_LAST         },
2721                         { "luminance",                                                          GL_LUMINANCE,                           tcu::Sampler::MODE_LAST         },
2722                         { "alpha",                                                                      GL_ALPHA,                                       tcu::Sampler::MODE_LAST         },
2723                         { "luminance_alpha",                                            GL_LUMINANCE_ALPHA,                     tcu::Sampler::MODE_LAST         },
2724                         { "depth_component16",                                          GL_DEPTH_COMPONENT16,           tcu::Sampler::MODE_DEPTH        },
2725                         { "depth_component32f",                                         GL_DEPTH_COMPONENT32F,          tcu::Sampler::MODE_DEPTH        },
2726                         { "stencil_index8",                                                     GL_STENCIL_INDEX8,                      tcu::Sampler::MODE_STENCIL      },
2727                         { "depth32f_stencil8_sample_depth",                     GL_DEPTH32F_STENCIL8,           tcu::Sampler::MODE_DEPTH        },
2728                         { "depth32f_stencil8_sample_stencil",           GL_DEPTH32F_STENCIL8,           tcu::Sampler::MODE_STENCIL      },
2729                         { "depth24_stencil8_sample_depth",                      GL_DEPTH24_STENCIL8,            tcu::Sampler::MODE_DEPTH        },
2730                         { "depth24_stencil8_sample_stencil",            GL_DEPTH24_STENCIL8,            tcu::Sampler::MODE_STENCIL      },
2731                         { "compressed_r11_eac",                                         GL_COMPRESSED_R11_EAC,          tcu::Sampler::MODE_LAST         },
2732                 };
2733
2734                 tcu::TestCaseGroup* const unusedGroup = new tcu::TestCaseGroup(m_testCtx, "unused_channels", "Tests channels that are not present in the internal format");
2735                 addChild(unusedGroup);
2736
2737                 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(formats); ++formatNdx)
2738                 {
2739                         unusedGroup->addChild(new TextureBorderClampUnusedChannelCase(m_context,
2740                                                                                                                                                   formats[formatNdx].name,
2741                                                                                                                                                   "",
2742                                                                                                                                                   formats[formatNdx].format,
2743                                                                                                                                                   formats[formatNdx].mode));
2744                 }
2745         }
2746 }
2747
2748 } // Functional
2749 } // gles31
2750 } // deqp