modules/gles31/functional/es31fShaderImageLoadStoreTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program OpenGL ES 3.1 Module
   3  * -------------------------------------------------
   4  *
   5  * Copyright 2014 The Android Open Source Project
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief Shader Image Load & Store Tests.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "es31fShaderImageLoadStoreTests.hpp"
  25 #include "glsTextureTestUtil.hpp"
  26 #include "gluContextInfo.hpp"
  27 #include "gluRenderContext.hpp"
  28 #include "gluShaderProgram.hpp"
  29 #include "gluObjectWrapper.hpp"
  30 #include "gluPixelTransfer.hpp"
  31 #include "gluTextureUtil.hpp"
  32 #include "gluStrUtil.hpp"
  33 #include "gluCallLogWrapper.hpp"
  34 #include "gluProgramInterfaceQuery.hpp"
  35 #include "gluDrawUtil.hpp"
  36 #include "tcuTestLog.hpp"
  37 #include "tcuTextureUtil.hpp"
  38 #include "tcuVector.hpp"
  39 #include "tcuImageCompare.hpp"
  40 #include "tcuFloat.hpp"
  41 #include "tcuVectorUtil.hpp"
  42 #include "deStringUtil.hpp"
  43 #include "deSharedPtr.hpp"
  44 #include "deUniquePtr.hpp"
  45 #include "deRandom.hpp"
  46 #include "deMemory.h"
  47 #include "glwFunctions.hpp"
  48 #include "glwDefs.hpp"
  49 #include "glwEnums.hpp"
  50
  51 #include <vector>
  52 #include <string>
  53 #include <algorithm>
  54 #include <map>
  55
  56 using glu::RenderContext;
  57 using tcu::TestLog;
  58 using tcu::Vec2;
  59 using tcu::Vec3;
  60 using tcu::Vec4;
  61 using tcu::IVec2;
  62 using tcu::IVec3;
  63 using tcu::IVec4;
  64 using tcu::UVec2;
  65 using tcu::UVec3;
  66 using tcu::UVec4;
  67 using tcu::TextureFormat;
  68 using tcu::ConstPixelBufferAccess;
  69 using tcu::PixelBufferAccess;
  70 using de::toString;
  71 using de::SharedPtr;
  72 using de::UniquePtr;
  73
  74 using std::vector;
  75 using std::string;
  76
  77 namespace deqp
  78 {
  79
  80 using namespace gls::TextureTestUtil;
  81 using namespace glu::TextureTestUtil;
  82
  83 namespace gles31
  84 {
  85 namespace Functional
  86 {
  87
  88 //! Default image sizes used in most test cases.
  89 static inline IVec3 defaultImageSize (TextureType type)
  90 {
  91         switch (type)
  92         {
  93                 case TEXTURETYPE_BUFFER:        return IVec3(64,        1,              1);
  94                 case TEXTURETYPE_2D:            return IVec3(64,        64,             1);
  95                 case TEXTURETYPE_CUBE:          return IVec3(64,        64,             1);
  96                 case TEXTURETYPE_3D:            return IVec3(64,        64,             8);
  97                 case TEXTURETYPE_2D_ARRAY:      return IVec3(64,        64,             8);
  98                 default:
  99                         DE_ASSERT(false);
 100                         return IVec3(-1);
 101         }
 102 }
 103
 104 template <typename T, int Size>
 105 static string arrayStr (const T (&arr)[Size])
 106 {
 107         string result = "{ ";
 108         for (int i = 0; i < Size; i++)
 109                 result += (i > 0 ? ", " : "") + toString(arr[i]);
 110         result += " }";
 111         return result;
 112 }
 113
 114 template <typename T, int N>
 115 static int arrayIndexOf (const T (&arr)[N], const T& e)
 116 {
 117         return (int)(std::find(DE_ARRAY_BEGIN(arr), DE_ARRAY_END(arr), e) - DE_ARRAY_BEGIN(arr));
 118 }
 119
 120 static const char* getTextureTypeName (TextureType type)
 121 {
 122         switch (type)
 123         {
 124                 case TEXTURETYPE_BUFFER:        return "buffer";
 125                 case TEXTURETYPE_2D:            return "2d";
 126                 case TEXTURETYPE_CUBE:          return "cube";
 127                 case TEXTURETYPE_3D:            return "3d";
 128                 case TEXTURETYPE_2D_ARRAY:      return "2d_array";
 129                 default:
 130                         DE_ASSERT(false);
 131                         return DE_NULL;
 132         }
 133 }
 134
 135 static inline bool isFormatTypeUnsignedInteger (TextureFormat::ChannelType type)
 136 {
 137         return type == TextureFormat::UNSIGNED_INT8             ||
 138                    type == TextureFormat::UNSIGNED_INT16        ||
 139                    type == TextureFormat::UNSIGNED_INT32;
 140 }
 141
 142 static inline bool isFormatTypeSignedInteger (TextureFormat::ChannelType type)
 143 {
 144         return type == TextureFormat::SIGNED_INT8       ||
 145                    type == TextureFormat::SIGNED_INT16  ||
 146                    type == TextureFormat::SIGNED_INT32;
 147 }
 148
 149 static inline bool isFormatTypeInteger (TextureFormat::ChannelType type)
 150 {
 151         return isFormatTypeUnsignedInteger(type) || isFormatTypeSignedInteger(type);
 152 }
 153
 154 static inline bool isFormatTypeUnorm (TextureFormat::ChannelType type)
 155 {
 156         return type == TextureFormat::UNORM_INT8        ||
 157                    type == TextureFormat::UNORM_INT16   ||
 158                    type == TextureFormat::UNORM_INT32;
 159 }
 160
 161 static inline bool isFormatTypeSnorm (TextureFormat::ChannelType type)
 162 {
 163         return type == TextureFormat::SNORM_INT8        ||
 164                    type == TextureFormat::SNORM_INT16   ||
 165                    type == TextureFormat::SNORM_INT32;
 166 }
 167
 168 static inline bool isFormatSupportedForTextureBuffer (const TextureFormat& format)
 169 {
 170         switch (format.order)
 171         {
 172                 case TextureFormat::RGB:
 173                         return format.type == TextureFormat::FLOAT                              ||
 174                                    format.type == TextureFormat::SIGNED_INT32           ||
 175                                    format.type == TextureFormat::UNSIGNED_INT32;
 176
 177                 // \note Fallthroughs.
 178                 case TextureFormat::R:
 179                 case TextureFormat::RG:
 180                 case TextureFormat::RGBA:
 181                         return format.type == TextureFormat::UNORM_INT8                 ||
 182                                    format.type == TextureFormat::HALF_FLOAT                     ||
 183                                    format.type == TextureFormat::FLOAT                          ||
 184                                    format.type == TextureFormat::SIGNED_INT8            ||
 185                                    format.type == TextureFormat::SIGNED_INT16           ||
 186                                    format.type == TextureFormat::SIGNED_INT32           ||
 187                                    format.type == TextureFormat::UNSIGNED_INT8          ||
 188                                    format.type == TextureFormat::UNSIGNED_INT16         ||
 189                                    format.type == TextureFormat::UNSIGNED_INT32;
 190
 191                 default:
 192                         return false;
 193         }
 194 }
 195
 196 static inline string getShaderImageFormatQualifier (const TextureFormat& format)
 197 {
 198         const char* orderPart;
 199         const char* typePart;
 200
 201         switch (format.order)
 202         {
 203                 case TextureFormat::R:          orderPart = "r";                break;
 204                 case TextureFormat::RGBA:       orderPart = "rgba";             break;
 205                 default:
 206                         DE_ASSERT(false);
 207                         orderPart = DE_NULL;
 208         }
 209
 210         switch (format.type)
 211         {
 212                 case TextureFormat::FLOAT:                              typePart = "32f";                       break;
 213                 case TextureFormat::HALF_FLOAT:                 typePart = "16f";                       break;
 214
 215                 case TextureFormat::UNSIGNED_INT32:             typePart = "32ui";                      break;
 216                 case TextureFormat::UNSIGNED_INT16:             typePart = "16ui";                      break;
 217                 case TextureFormat::UNSIGNED_INT8:              typePart = "8ui";                       break;
 218
 219                 case TextureFormat::SIGNED_INT32:               typePart = "32i";                       break;
 220                 case TextureFormat::SIGNED_INT16:               typePart = "16i";                       break;
 221                 case TextureFormat::SIGNED_INT8:                typePart = "8i";                        break;
 222
 223                 case TextureFormat::UNORM_INT16:                typePart = "16";                        break;
 224                 case TextureFormat::UNORM_INT8:                 typePart = "8";                         break;
 225
 226                 case TextureFormat::SNORM_INT16:                typePart = "16_snorm";          break;
 227                 case TextureFormat::SNORM_INT8:                 typePart = "8_snorm";           break;
 228
 229                 default:
 230                         DE_ASSERT(false);
 231                         typePart = DE_NULL;
 232         }
 233
 234         return string() + orderPart + typePart;
 235 }
 236
 237 static inline string getShaderSamplerOrImageType (TextureFormat::ChannelType formatType, TextureType textureType, bool isSampler)
 238 {
 239         const char* const formatPart            = isFormatTypeUnsignedInteger(formatType)       ? "u"
 240                                                                                 : isFormatTypeSignedInteger(formatType)         ? "i"
 241                                                                                 : "";
 242
 243         const char* const imageTypePart         = textureType == TEXTURETYPE_BUFFER             ? "Buffer"
 244                                                                                 : textureType == TEXTURETYPE_2D                 ? "2D"
 245                                                                                 : textureType == TEXTURETYPE_3D                 ? "3D"
 246                                                                                 : textureType == TEXTURETYPE_CUBE               ? "Cube"
 247                                                                                 : textureType == TEXTURETYPE_2D_ARRAY   ? "2DArray"
 248                                                                                 : DE_NULL;
 249
 250         return string() + formatPart + (isSampler ? "sampler" : "image") + imageTypePart;
 251 }
 252
 253 static inline string getShaderImageType (TextureFormat::ChannelType formatType, TextureType imageType)
 254 {
 255         return getShaderSamplerOrImageType(formatType, imageType, false);
 256 }
 257
 258 static inline string getShaderSamplerType (TextureFormat::ChannelType formatType, TextureType imageType)
 259 {
 260         return getShaderSamplerOrImageType(formatType, imageType, true);
 261 }
 262
 263 static inline deUint32 getGLTextureTarget (TextureType texType)
 264 {
 265         switch (texType)
 266         {
 267                 case TEXTURETYPE_BUFFER:        return GL_TEXTURE_BUFFER;
 268                 case TEXTURETYPE_2D:            return GL_TEXTURE_2D;
 269                 case TEXTURETYPE_3D:            return GL_TEXTURE_3D;
 270                 case TEXTURETYPE_CUBE:          return GL_TEXTURE_CUBE_MAP;
 271                 case TEXTURETYPE_2D_ARRAY:      return GL_TEXTURE_2D_ARRAY;
 272                 default:
 273                         DE_ASSERT(false);
 274                         return (deUint32)-1;
 275         }
 276 }
 277
 278 static deUint32 cubeFaceToGLFace (tcu::CubeFace face)
 279 {
 280         switch (face)
 281         {
 282                 case tcu::CUBEFACE_NEGATIVE_X: return GL_TEXTURE_CUBE_MAP_NEGATIVE_X;
 283                 case tcu::CUBEFACE_POSITIVE_X: return GL_TEXTURE_CUBE_MAP_POSITIVE_X;
 284                 case tcu::CUBEFACE_NEGATIVE_Y: return GL_TEXTURE_CUBE_MAP_NEGATIVE_Y;
 285                 case tcu::CUBEFACE_POSITIVE_Y: return GL_TEXTURE_CUBE_MAP_POSITIVE_Y;
 286                 case tcu::CUBEFACE_NEGATIVE_Z: return GL_TEXTURE_CUBE_MAP_NEGATIVE_Z;
 287                 case tcu::CUBEFACE_POSITIVE_Z: return GL_TEXTURE_CUBE_MAP_POSITIVE_Z;
 288                 default:
 289                         DE_ASSERT(false);
 290                         return GL_NONE;
 291         }
 292 }
 293
 294 static inline tcu::Texture1D* newOneLevelTexture1D (const tcu::TextureFormat& format, int w)
 295 {
 296         tcu::Texture1D* const res = new tcu::Texture1D(format, w);
 297         res->allocLevel(0);
 298         return res;
 299 }
 300
 301 static inline tcu::Texture2D* newOneLevelTexture2D (const tcu::TextureFormat& format, int w, int h)
 302 {
 303         tcu::Texture2D* const res = new tcu::Texture2D(format, w, h);
 304         res->allocLevel(0);
 305         return res;
 306 }
 307
 308 static inline tcu::TextureCube* newOneLevelTextureCube (const tcu::TextureFormat& format, int size)
 309 {
 310         tcu::TextureCube* const res = new tcu::TextureCube(format, size);
 311         for (int i = 0; i < tcu::CUBEFACE_LAST; i++)
 312                 res->allocLevel((tcu::CubeFace)i, 0);
 313         return res;
 314 }
 315
 316 static inline tcu::Texture3D* newOneLevelTexture3D (const tcu::TextureFormat& format, int w, int h, int d)
 317 {
 318         tcu::Texture3D* const res = new tcu::Texture3D(format, w, h, d);
 319         res->allocLevel(0);
 320         return res;
 321 }
 322
 323 static inline tcu::Texture2DArray* newOneLevelTexture2DArray (const tcu::TextureFormat& format, int w, int h, int d)
 324 {
 325         tcu::Texture2DArray* const res = new tcu::Texture2DArray(format, w, h, d);
 326         res->allocLevel(0);
 327         return res;
 328 }
 329
 330 static inline TextureType textureLayerType (TextureType entireTextureType)
 331 {
 332         switch (entireTextureType)
 333         {
 334                 // Single-layer types.
 335                 // \note Fallthrough.
 336                 case TEXTURETYPE_BUFFER:
 337                 case TEXTURETYPE_2D:
 338                         return entireTextureType;
 339
 340                 // Multi-layer types with 2d layers.
 341                 case TEXTURETYPE_3D:
 342                 case TEXTURETYPE_CUBE:
 343                 case TEXTURETYPE_2D_ARRAY:
 344                         return TEXTURETYPE_2D;
 345
 346                 default:
 347                         DE_ASSERT(false);
 348                         return TEXTURETYPE_LAST;
 349         }
 350 }
 351
 352 static const char* const s_texBufExtString = "GL_EXT_texture_buffer";
 353
 354 static inline void checkTextureTypeExtensions (const glu::ContextInfo& contextInfo, TextureType type, const RenderContext& renderContext)
 355 {
 356         if (type == TEXTURETYPE_BUFFER && !contextInfo.isExtensionSupported(s_texBufExtString) && !glu::contextSupports(renderContext.getType(), glu::ApiType::es(3, 2)))
 357                 throw tcu::NotSupportedError("Test requires " + string(s_texBufExtString) + " extension");
 358 }
 359
 360 static inline string textureTypeExtensionShaderRequires (TextureType type, const RenderContext& renderContext)
 361 {
 362         if (!glu::contextSupports(renderContext.getType(), glu::ApiType::es(3, 2)) && (type == TEXTURETYPE_BUFFER))
 363                 return "#extension " + string(s_texBufExtString) + " : require\n";
 364         else
 365                 return "";
 366 }
 367
 368 static const char* const s_imageAtomicExtString = "GL_OES_shader_image_atomic";
 369
 370 static inline string imageAtomicExtensionShaderRequires (const RenderContext& renderContext)
 371 {
 372         if (!glu::contextSupports(renderContext.getType(), glu::ApiType::es(3, 2)))
 373                 return "#extension " + string(s_imageAtomicExtString) + " : require\n";
 374         else
 375                 return "";
 376 }
 377
 378 namespace
 379 {
 380
 381 enum AtomicOperation
 382 {
 383         ATOMIC_OPERATION_ADD = 0,
 384         ATOMIC_OPERATION_MIN,
 385         ATOMIC_OPERATION_MAX,
 386         ATOMIC_OPERATION_AND,
 387         ATOMIC_OPERATION_OR,
 388         ATOMIC_OPERATION_XOR,
 389         ATOMIC_OPERATION_EXCHANGE,
 390         ATOMIC_OPERATION_COMP_SWAP,
 391
 392         ATOMIC_OPERATION_LAST
 393 };
 394
 395 //! An order-independent operation is one for which the end result doesn't depend on the order in which the operations are carried (i.e. is both commutative and associative).
 396 static bool isOrderIndependentAtomicOperation (AtomicOperation op)
 397 {
 398         return op == ATOMIC_OPERATION_ADD       ||
 399                    op == ATOMIC_OPERATION_MIN   ||
 400                    op == ATOMIC_OPERATION_MAX   ||
 401                    op == ATOMIC_OPERATION_AND   ||
 402                    op == ATOMIC_OPERATION_OR    ||
 403                    op == ATOMIC_OPERATION_XOR;
 404 }
 405
 406 //! Computes the result of an atomic operation where "a" is the data operated on and "b" is the parameter to the atomic function.
 407 int computeBinaryAtomicOperationResult (AtomicOperation op, int a, int b)
 408 {
 409         switch (op)
 410         {
 411                 case ATOMIC_OPERATION_ADD:                      return a + b;
 412                 case ATOMIC_OPERATION_MIN:                      return de::min(a, b);
 413                 case ATOMIC_OPERATION_MAX:                      return de::max(a, b);
 414                 case ATOMIC_OPERATION_AND:                      return a & b;
 415                 case ATOMIC_OPERATION_OR:                       return a | b;
 416                 case ATOMIC_OPERATION_XOR:                      return a ^ b;
 417                 case ATOMIC_OPERATION_EXCHANGE:         return b;
 418                 default:
 419                         DE_ASSERT(false);
 420                         return -1;
 421         }
 422 }
 423
 424 //! \note For floats, only the exchange operation is supported.
 425 float computeBinaryAtomicOperationResult (AtomicOperation op, float /*a*/, float b)
 426 {
 427         switch (op)
 428         {
 429                 case ATOMIC_OPERATION_EXCHANGE: return b;
 430                 default:
 431                         DE_ASSERT(false);
 432                         return -1;
 433         }
 434 }
 435
 436 static const char* getAtomicOperationCaseName (AtomicOperation op)
 437 {
 438         switch (op)
 439         {
 440                 case ATOMIC_OPERATION_ADD:                      return "add";
 441                 case ATOMIC_OPERATION_MIN:                      return "min";
 442                 case ATOMIC_OPERATION_MAX:                      return "max";
 443                 case ATOMIC_OPERATION_AND:                      return "and";
 444                 case ATOMIC_OPERATION_OR:                       return "or";
 445                 case ATOMIC_OPERATION_XOR:                      return "xor";
 446                 case ATOMIC_OPERATION_EXCHANGE:         return "exchange";
 447                 case ATOMIC_OPERATION_COMP_SWAP:        return "comp_swap";
 448                 default:
 449                         DE_ASSERT(false);
 450                         return DE_NULL;
 451         }
 452 }
 453
 454 static const char* getAtomicOperationShaderFuncName (AtomicOperation op)
 455 {
 456         switch (op)
 457         {
 458                 case ATOMIC_OPERATION_ADD:                      return "imageAtomicAdd";
 459                 case ATOMIC_OPERATION_MIN:                      return "imageAtomicMin";
 460                 case ATOMIC_OPERATION_MAX:                      return "imageAtomicMax";
 461                 case ATOMIC_OPERATION_AND:                      return "imageAtomicAnd";
 462                 case ATOMIC_OPERATION_OR:                       return "imageAtomicOr";
 463                 case ATOMIC_OPERATION_XOR:                      return "imageAtomicXor";
 464                 case ATOMIC_OPERATION_EXCHANGE:         return "imageAtomicExchange";
 465                 case ATOMIC_OPERATION_COMP_SWAP:        return "imageAtomicCompSwap";
 466                 default:
 467                         DE_ASSERT(false);
 468                         return DE_NULL;
 469         }
 470 }
 471
 472 //! In GLSL, when accessing cube images, the z coordinate is mapped to a cube face.
 473 //! \note This is _not_ the same as casting the z to a tcu::CubeFace.
 474 static inline tcu::CubeFace glslImageFuncZToCubeFace (int z)
 475 {
 476         static const tcu::CubeFace faces[6] =
 477         {
 478                 tcu::CUBEFACE_POSITIVE_X,
 479                 tcu::CUBEFACE_NEGATIVE_X,
 480                 tcu::CUBEFACE_POSITIVE_Y,
 481                 tcu::CUBEFACE_NEGATIVE_Y,
 482                 tcu::CUBEFACE_POSITIVE_Z,
 483                 tcu::CUBEFACE_NEGATIVE_Z
 484         };
 485
 486         DE_ASSERT(de::inBounds(z, 0, DE_LENGTH_OF_ARRAY(faces)));
 487         return faces[z];
 488 }
 489
 490 class BufferMemMap
 491 {
 492 public:
 493         BufferMemMap (const glw::Functions& gl, deUint32 target, int offset, int size, deUint32 access)
 494                 : m_gl          (gl)
 495                 , m_target      (target)
 496                 , m_ptr         (DE_NULL)
 497         {
 498                 m_ptr = gl.mapBufferRange(target, offset, size, access);
 499                 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBufferRange()");
 500                 TCU_CHECK(m_ptr);
 501         }
 502
 503         ~BufferMemMap (void)
 504         {
 505                 m_gl.unmapBuffer(m_target);
 506         }
 507
 508         void*   getPtr          (void) const { return m_ptr; }
 509         void*   operator*       (void) const { return m_ptr; }
 510
 511 private:
 512                                                         BufferMemMap                    (const BufferMemMap& other);
 513         BufferMemMap&                   operator=                               (const BufferMemMap& other);
 514
 515         const glw::Functions&   m_gl;
 516         const deUint32                  m_target;
 517         void*                                   m_ptr;
 518 };
 519
 520 //! Utility for more readable uniform assignment logging; logs the name of the uniform when assigning. Handles the locations, querying them the first time they're assigned
 521 //  \note Assumes that the appropriate program is in use when assigning uniforms.
 522 class UniformAccessLogger
 523 {
 524 public:
 525         UniformAccessLogger (const glw::Functions& gl, TestLog& log, deUint32 programGL)
 526                 : m_gl                  (gl)
 527                 , m_log                 (log)
 528                 , m_programGL   (programGL)
 529         {
 530         }
 531
 532         void                                            assign1i (const string& name, int x);
 533         void                                            assign3f (const string& name, float x, float y, float z);
 534
 535 private:
 536         int                                                     getLocation (const string& name);
 537
 538         const glw::Functions&           m_gl;
 539         TestLog&                                        m_log;
 540         const deUint32                          m_programGL;
 541
 542         std::map<string, int>           m_uniformLocations;
 543 };
 544
 545 int UniformAccessLogger::getLocation (const string& name)
 546 {
 547         if (m_uniformLocations.find(name) == m_uniformLocations.end())
 548         {
 549                 const int loc = m_gl.getUniformLocation(m_programGL, name.c_str());
 550                 TCU_CHECK(loc != -1);
 551                 m_uniformLocations[name] = loc;
 552         }
 553         return m_uniformLocations[name];
 554 }
 555
 556 void UniformAccessLogger::assign1i (const string& name, int x)
 557 {
 558         const int loc = getLocation(name);
 559         m_log << TestLog::Message << "// Assigning to uniform " << name << ": " << x << TestLog::EndMessage;
 560         m_gl.uniform1i(loc, x);
 561 }
 562
 563 void UniformAccessLogger::assign3f (const string& name, float x, float y, float z)
 564 {
 565         const int loc = getLocation(name);
 566         m_log << TestLog::Message << "// Assigning to uniform " << name << ": " << Vec3(x, y, z) << TestLog::EndMessage;
 567         m_gl.uniform3f(loc, x, y, z);
 568 }
 569
 570 //! Class containing a (single-level) texture of a given type. Supports accessing pixels with coordinate convention similar to that in imageStore() and imageLoad() in shaders; useful especially for cube maps.
 571 class LayeredImage
 572 {
 573 public:
 574                                                                                                 LayeredImage                            (TextureType type, const TextureFormat& format, int w, int h, int d);
 575
 576         TextureType                                                                     getImageType                            (void) const { return m_type; }
 577         const IVec3&                                                            getSize                                         (void) const { return m_size; }
 578         const TextureFormat&                                            getFormat                                       (void) const { return m_format; }
 579
 580         // \note For cube maps, set/getPixel's z parameter specifies the cube face in the same manner as in imageStore/imageLoad in GL shaders (see glslImageFuncZToCubeFace), instead of directly as a tcu::CubeFace.
 581
 582         template <typename ColorT>
 583         void                                                                            setPixel                                        (int x, int y, int z, const ColorT& color) const;
 584
 585         Vec4                                                                            getPixel                                        (int x, int y, int z) const;
 586         IVec4                                                                           getPixelInt                                     (int x, int y, int z) const;
 587         UVec4                                                                           getPixelUint                            (int x, int y, int z) const { return getPixelInt(x, y, z).asUint(); }
 588
 589         PixelBufferAccess                                                       getAccess                                       (void)                                                  { return getAccessInternal();                           }
 590         PixelBufferAccess                                                       getSliceAccess                          (int slice)                                             { return getSliceAccessInternal(slice);         }
 591         PixelBufferAccess                                                       getCubeFaceAccess                       (tcu::CubeFace face)                    { return getCubeFaceAccessInternal(face);       }
 592
 593         ConstPixelBufferAccess                                          getAccess                                       (void)                                  const   { return getAccessInternal();                           }
 594         ConstPixelBufferAccess                                          getSliceAccess                          (int slice)                             const   { return getSliceAccessInternal(slice);         }
 595         ConstPixelBufferAccess                                          getCubeFaceAccess                       (tcu::CubeFace face)    const   { return getCubeFaceAccessInternal(face);       }
 596
 597 private:
 598                                                                                                 LayeredImage                            (const LayeredImage&);
 599         LayeredImage&                                                           operator=                                       (const LayeredImage&);
 600
 601         // Some helpers to reduce code duplication between const/non-const versions of getAccess and others.
 602         PixelBufferAccess                                                       getAccessInternal                       (void) const;
 603         PixelBufferAccess                                                       getSliceAccessInternal          (int slice) const;
 604         PixelBufferAccess                                                       getCubeFaceAccessInternal       (tcu::CubeFace face) const;
 605
 606         const TextureType                                                       m_type;
 607         const IVec3                                                                     m_size;
 608         const TextureFormat                                                     m_format;
 609
 610         // \note Depending on m_type, exactly one of the following will contain non-null.
 611         const SharedPtr<tcu::Texture1D>                         m_texBuffer;
 612         const SharedPtr<tcu::Texture2D>                         m_tex2D;
 613         const SharedPtr<tcu::TextureCube>                       m_texCube;
 614         const SharedPtr<tcu::Texture3D>                         m_tex3D;
 615         const SharedPtr<tcu::Texture2DArray>            m_tex2DArray;
 616 };
 617
 618 LayeredImage::LayeredImage (TextureType type, const TextureFormat& format, int w, int h, int d)
 619         : m_type                (type)
 620         , m_size                (w, h, d)
 621         , m_format              (format)
 622         , m_texBuffer   (type == TEXTURETYPE_BUFFER             ? SharedPtr<tcu::Texture1D>                     (newOneLevelTexture1D           (format, w))            : SharedPtr<tcu::Texture1D>())
 623         , m_tex2D               (type == TEXTURETYPE_2D                 ? SharedPtr<tcu::Texture2D>                     (newOneLevelTexture2D           (format, w, h))         : SharedPtr<tcu::Texture2D>())
 624         , m_texCube             (type == TEXTURETYPE_CUBE               ? SharedPtr<tcu::TextureCube>           (newOneLevelTextureCube         (format, w))            : SharedPtr<tcu::TextureCube>())
 625         , m_tex3D               (type == TEXTURETYPE_3D                 ? SharedPtr<tcu::Texture3D>                     (newOneLevelTexture3D           (format, w, h, d))      : SharedPtr<tcu::Texture3D>())
 626         , m_tex2DArray  (type == TEXTURETYPE_2D_ARRAY   ? SharedPtr<tcu::Texture2DArray>        (newOneLevelTexture2DArray      (format, w, h, d))      : SharedPtr<tcu::Texture2DArray>())
 627 {
 628         DE_ASSERT(m_size.z() == 1                                       ||
 629                           m_type == TEXTURETYPE_3D                      ||
 630                           m_type == TEXTURETYPE_2D_ARRAY);
 631
 632         DE_ASSERT(m_size.y() == 1                                       ||
 633                           m_type == TEXTURETYPE_2D                      ||
 634                           m_type == TEXTURETYPE_CUBE            ||
 635                           m_type == TEXTURETYPE_3D                      ||
 636                           m_type == TEXTURETYPE_2D_ARRAY);
 637
 638         DE_ASSERT(w == h || type != TEXTURETYPE_CUBE);
 639
 640         DE_ASSERT(m_texBuffer   != DE_NULL ||
 641                           m_tex2D               != DE_NULL ||
 642                           m_texCube             != DE_NULL ||
 643                           m_tex3D               != DE_NULL ||
 644                           m_tex2DArray  != DE_NULL);
 645 }
 646
 647 template <typename ColorT>
 648 void LayeredImage::setPixel (int x, int y, int z, const ColorT& color) const
 649 {
 650         const PixelBufferAccess access = m_type == TEXTURETYPE_BUFFER           ? m_texBuffer->getLevel(0)
 651                                                                    : m_type == TEXTURETYPE_2D                   ? m_tex2D->getLevel(0)
 652                                                                    : m_type == TEXTURETYPE_CUBE                 ? m_texCube->getLevelFace(0, glslImageFuncZToCubeFace(z))
 653                                                                    : m_type == TEXTURETYPE_3D                   ? m_tex3D->getLevel(0)
 654                                                                    : m_type == TEXTURETYPE_2D_ARRAY             ? m_tex2DArray->getLevel(0)
 655                                                                    : PixelBufferAccess();
 656
 657         access.setPixel(color, x, y, m_type == TEXTURETYPE_CUBE ? 0 : z);
 658 }
 659
 660 Vec4 LayeredImage::getPixel (int x, int y, int z) const
 661 {
 662         const ConstPixelBufferAccess access = m_type == TEXTURETYPE_CUBE ? getCubeFaceAccess(glslImageFuncZToCubeFace(z)) : getAccess();
 663         return access.getPixel(x, y, m_type == TEXTURETYPE_CUBE ? 0 : z);
 664 }
 665
 666 IVec4 LayeredImage::getPixelInt (int x, int y, int z) const
 667 {
 668         const ConstPixelBufferAccess access = m_type == TEXTURETYPE_CUBE ? getCubeFaceAccess(glslImageFuncZToCubeFace(z)) : getAccess();
 669         return access.getPixelInt(x, y, m_type == TEXTURETYPE_CUBE ? 0 : z);
 670 }
 671
 672 PixelBufferAccess LayeredImage::getAccessInternal (void) const
 673 {
 674         DE_ASSERT(m_type == TEXTURETYPE_BUFFER || m_type == TEXTURETYPE_2D || m_type == TEXTURETYPE_3D || m_type == TEXTURETYPE_2D_ARRAY);
 675
 676         return m_type == TEXTURETYPE_BUFFER             ? m_texBuffer->getLevel(0)
 677                  : m_type == TEXTURETYPE_2D                     ? m_tex2D->getLevel(0)
 678                  : m_type == TEXTURETYPE_3D                     ? m_tex3D->getLevel(0)
 679                  : m_type == TEXTURETYPE_2D_ARRAY       ? m_tex2DArray->getLevel(0)
 680                  : PixelBufferAccess();
 681 }
 682
 683 PixelBufferAccess LayeredImage::getSliceAccessInternal (int slice) const
 684 {
 685         const PixelBufferAccess srcAccess = getAccessInternal();
 686         return tcu::getSubregion(srcAccess, 0, 0, slice, srcAccess.getWidth(), srcAccess.getHeight(), 1);
 687 }
 688
 689 PixelBufferAccess LayeredImage::getCubeFaceAccessInternal (tcu::CubeFace face) const
 690 {
 691         DE_ASSERT(m_type == TEXTURETYPE_CUBE);
 692         return m_texCube->getLevelFace(0, face);
 693 }
 694
 695 //! Set texture storage or, if using buffer texture, setup buffer and attach to texture.
 696 static void setTextureStorage (glu::CallLogWrapper& glLog, TextureType imageType, deUint32 internalFormat, const IVec3& imageSize, deUint32 textureBufGL)
 697 {
 698         const deUint32 textureTarget = getGLTextureTarget(imageType);
 699
 700         switch (imageType)
 701         {
 702                 case TEXTURETYPE_BUFFER:
 703                 {
 704                         const TextureFormat             format          = glu::mapGLInternalFormat(internalFormat);
 705                         const int                               numBytes        = format.getPixelSize() * imageSize.x();
 706                         DE_ASSERT(isFormatSupportedForTextureBuffer(format));
 707                         glLog.glBindBuffer(GL_TEXTURE_BUFFER, textureBufGL);
 708                         glLog.glBufferData(GL_TEXTURE_BUFFER, numBytes, DE_NULL, GL_STATIC_DRAW);
 709                         glLog.glTexBuffer(GL_TEXTURE_BUFFER, internalFormat, textureBufGL);
 710                         DE_ASSERT(imageSize.y() == 1 && imageSize.z() == 1);
 711                         break;
 712                 }
 713
 714                 // \note Fall-throughs.
 715
 716                 case TEXTURETYPE_2D:
 717                 case TEXTURETYPE_CUBE:
 718                         glLog.glTexStorage2D(textureTarget, 1, internalFormat, imageSize.x(), imageSize.y());
 719                         DE_ASSERT(imageSize.z() == 1);
 720                         break;
 721
 722                 case TEXTURETYPE_3D:
 723                 case TEXTURETYPE_2D_ARRAY:
 724                         glLog.glTexStorage3D(textureTarget, 1, internalFormat, imageSize.x(), imageSize.y(), imageSize.z());
 725                         break;
 726
 727                 default:
 728                         DE_ASSERT(false);
 729         }
 730 }
 731
 732 static void uploadTexture (glu::CallLogWrapper& glLog, const LayeredImage& src, deUint32 textureBufGL)
 733 {
 734         const deUint32                          internalFormat  = glu::getInternalFormat(src.getFormat());
 735         const glu::TransferFormat       transferFormat  = glu::getTransferFormat(src.getFormat());
 736         const IVec3&                            imageSize               = src.getSize();
 737
 738         setTextureStorage(glLog, src.getImageType(), internalFormat, imageSize, textureBufGL);
 739
 740         {
 741                 const int       pixelSize = src.getFormat().getPixelSize();
 742                 int                     unpackAlignment;
 743
 744                 if (deIsPowerOfTwo32(pixelSize))
 745                         unpackAlignment = 8;
 746                 else
 747                         unpackAlignment = 1;
 748
 749                 glLog.glPixelStorei(GL_UNPACK_ALIGNMENT, unpackAlignment);
 750         }
 751
 752         if (src.getImageType() == TEXTURETYPE_BUFFER)
 753         {
 754                 glLog.glBindBuffer(GL_TEXTURE_BUFFER, textureBufGL);
 755                 glLog.glBufferData(GL_TEXTURE_BUFFER, src.getFormat().getPixelSize() * imageSize.x(), src.getAccess().getDataPtr(), GL_STATIC_DRAW);
 756         }
 757         else if (src.getImageType() == TEXTURETYPE_2D)
 758                 glLog.glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, imageSize.x(), imageSize.y(), transferFormat.format, transferFormat.dataType, src.getAccess().getDataPtr());
 759         else if (src.getImageType() == TEXTURETYPE_CUBE)
 760         {
 761                 for (int faceI = 0; faceI < tcu::CUBEFACE_LAST; faceI++)
 762                 {
 763                         const tcu::CubeFace face = (tcu::CubeFace)faceI;
 764                         glLog.glTexSubImage2D(cubeFaceToGLFace(face), 0, 0, 0, imageSize.x(), imageSize.y(), transferFormat.format, transferFormat.dataType, src.getCubeFaceAccess(face).getDataPtr());
 765                 }
 766         }
 767         else
 768         {
 769                 DE_ASSERT(src.getImageType() == TEXTURETYPE_3D || src.getImageType() == TEXTURETYPE_2D_ARRAY);
 770                 const deUint32 textureTarget = getGLTextureTarget(src.getImageType());
 771                 glLog.glTexSubImage3D(textureTarget, 0, 0, 0, 0, imageSize.x(), imageSize.y(), imageSize.z(), transferFormat.format, transferFormat.dataType, src.getAccess().getDataPtr());
 772         }
 773 }
 774
 775 static void readPixelsRGBAInteger32 (const PixelBufferAccess& dst, int originX, int originY, glu::CallLogWrapper& glLog)
 776 {
 777         DE_ASSERT(dst.getDepth() == 1);
 778
 779         if (isFormatTypeUnsignedInteger(dst.getFormat().type))
 780         {
 781                 vector<UVec4> data(dst.getWidth()*dst.getHeight());
 782
 783                 glLog.glReadPixels(originX, originY, dst.getWidth(), dst.getHeight(), GL_RGBA_INTEGER, GL_UNSIGNED_INT, &data[0]);
 784
 785                 for (int y = 0; y < dst.getHeight(); y++)
 786                 for (int x = 0; x < dst.getWidth(); x++)
 787                         dst.setPixel(data[y*dst.getWidth() + x], x, y);
 788         }
 789         else if (isFormatTypeSignedInteger(dst.getFormat().type))
 790         {
 791                 vector<IVec4> data(dst.getWidth()*dst.getHeight());
 792
 793                 glLog.glReadPixels(originX, originY, dst.getWidth(), dst.getHeight(), GL_RGBA_INTEGER, GL_INT, &data[0]);
 794
 795                 for (int y = 0; y < dst.getHeight(); y++)
 796                 for (int x = 0; x < dst.getWidth(); x++)
 797                         dst.setPixel(data[y*dst.getWidth() + x], x, y);
 798         }
 799         else
 800                 DE_ASSERT(false);
 801 }
 802
 803 //! Base for a functor for verifying and logging a 2d texture layer (2d image, cube face, 3d slice, 2d layer).
 804 class ImageLayerVerifier
 805 {
 806 public:
 807         virtual bool    operator()                              (TestLog&, const ConstPixelBufferAccess&, int sliceOrFaceNdx) const = 0;
 808         virtual                 ~ImageLayerVerifier             (void) {}
 809 };
 810
 811 static void setTexParameteri (glu::CallLogWrapper& glLog, deUint32 target)
 812 {
 813         if (target != GL_TEXTURE_BUFFER)
 814         {
 815                 glLog.glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 816                 glLog.glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 817         }
 818 }
 819
 820 //! Binds texture (one layer at a time) to color attachment of FBO and does glReadPixels(). Calls the verifier for each layer.
 821 //! \note Not for buffer textures.
 822 static bool readIntegerTextureViaFBOAndVerify (const RenderContext&                     renderCtx,
 823                                                                                            glu::CallLogWrapper&                 glLog,
 824                                                                                            deUint32                                             textureGL,
 825                                                                                            TextureType                                  textureType,
 826                                                                                            const TextureFormat&                 textureFormat,
 827                                                                                            const IVec3&                                 textureSize,
 828                                                                                            const ImageLayerVerifier&    verifyLayer)
 829 {
 830         DE_ASSERT(isFormatTypeInteger(textureFormat.type));
 831         DE_ASSERT(textureType != TEXTURETYPE_BUFFER);
 832
 833         TestLog& log = glLog.getLog();
 834
 835         const tcu::ScopedLogSection section(log, "Verification", "Result verification (bind texture layer-by-layer to FBO, read with glReadPixels())");
 836
 837         const int                       numSlicesOrFaces        = textureType == TEXTURETYPE_CUBE ? 6 : textureSize.z();
 838         const deUint32          textureTargetGL         = getGLTextureTarget(textureType);
 839         glu::Framebuffer        fbo                                     (renderCtx);
 840         tcu::TextureLevel       resultSlice                     (textureFormat, textureSize.x(), textureSize.y());
 841
 842         glLog.glBindFramebuffer(GL_FRAMEBUFFER, *fbo);
 843         GLU_EXPECT_NO_ERROR(renderCtx.getFunctions().getError(), "Bind FBO");
 844
 845         glLog.glMemoryBarrier(GL_FRAMEBUFFER_BARRIER_BIT);
 846         GLU_EXPECT_NO_ERROR(renderCtx.getFunctions().getError(), "glMemoryBarrier");
 847
 848         glLog.glActiveTexture(GL_TEXTURE0);
 849         glLog.glBindTexture(textureTargetGL, textureGL);
 850         setTexParameteri(glLog, textureTargetGL);
 851
 852         for (int sliceOrFaceNdx = 0; sliceOrFaceNdx < numSlicesOrFaces; sliceOrFaceNdx++)
 853         {
 854                 if (textureType == TEXTURETYPE_CUBE)
 855                         glLog.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, cubeFaceToGLFace(glslImageFuncZToCubeFace(sliceOrFaceNdx)), textureGL, 0);
 856                 else if (textureType == TEXTURETYPE_2D)
 857                         glLog.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, textureGL, 0);
 858                 else if (textureType == TEXTURETYPE_3D || textureType == TEXTURETYPE_2D_ARRAY)
 859                         glLog.glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, textureGL, 0, sliceOrFaceNdx);
 860                 else
 861                         DE_ASSERT(false);
 862
 863                 GLU_EXPECT_NO_ERROR(renderCtx.getFunctions().getError(), "Bind texture to framebuffer color attachment 0");
 864
 865                 TCU_CHECK(glLog.glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE);
 866
 867                 readPixelsRGBAInteger32(resultSlice.getAccess(), 0, 0, glLog);
 868                 GLU_EXPECT_NO_ERROR(renderCtx.getFunctions().getError(), "glReadPixels");
 869
 870                 if (!verifyLayer(log, resultSlice, sliceOrFaceNdx))
 871                         return false;
 872         }
 873
 874         return true;
 875 }
 876
 877 //! Reads texture with texture() in compute shader, one layer at a time, putting values into a SSBO and reading with a mapping. Calls the verifier for each layer.
 878 //! \note Not for buffer textures.
 879 static bool readFloatOrNormTextureWithLookupsAndVerify (const RenderContext&            renderCtx,
 880                                                                                                                 glu::CallLogWrapper&            glLog,
 881                                                                                                                 deUint32                                        textureGL,
 882                                                                                                                 TextureType                                     textureType,
 883                                                                                                                 const TextureFormat&            textureFormat,
 884                                                                                                                 const IVec3&                            textureSize,
 885                                                                                                                 const ImageLayerVerifier&       verifyLayer)
 886 {
 887         DE_ASSERT(!isFormatTypeInteger(textureFormat.type));
 888         DE_ASSERT(textureType != TEXTURETYPE_BUFFER);
 889
 890         TestLog& log = glLog.getLog();
 891
 892         const tcu::ScopedLogSection section(log, "Verification", "Result verification (read texture layer-by-layer in compute shader with texture() into SSBO)");
 893         const std::string                       glslVersionDeclaration = getGLSLVersionDeclaration(glu::getContextTypeGLSLVersion(renderCtx.getType()));
 894
 895         const glu::ShaderProgram program(renderCtx,
 896                 glu::ProgramSources() << glu::ComputeSource(glslVersionDeclaration + "\n"
 897                                                                                                         "layout (local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n"
 898                                                                                                         "layout (binding = 0) buffer Output\n"
 899                                                                                                         "{\n"
 900                                                                                                         "       vec4 color[" + toString(textureSize.x()*textureSize.y()) + "];\n"
 901                                                                                                         "} sb_out;\n"
 902                                                                                                         "\n"
 903                                                                                                         "precision highp " + getShaderSamplerType(textureFormat.type, textureType) + ";\n"
 904                                                                                                         "\n"
 905                                                                                                         "uniform highp " + getShaderSamplerType(textureFormat.type, textureType) + " u_texture;\n"
 906                                                                                                         "uniform highp vec3 u_texCoordLD;\n"
 907                                                                                                         "uniform highp vec3 u_texCoordRD;\n"
 908                                                                                                         "uniform highp vec3 u_texCoordLU;\n"
 909                                                                                                         "uniform highp vec3 u_texCoordRU;\n"
 910                                                                                                         "\n"
 911                                                                                                         "void main (void)\n"
 912                                                                                                         "{\n"
 913                                                                                                         "       int gx = int(gl_GlobalInvocationID.x);\n"
 914                                                                                                         "       int gy = int(gl_GlobalInvocationID.y);\n"
 915                                                                                                         "       highp float s = (float(gx) + 0.5) / float(" + toString(textureSize.x()) + ");\n"
 916                                                                                                         "       highp float t = (float(gy) + 0.5) / float(" + toString(textureType == TEXTURETYPE_CUBE ? textureSize.x() : textureSize.y()) + ");\n"
 917                                                                                                         "       highp vec3 texCoord = u_texCoordLD*(1.0-s)*(1.0-t)\n"
 918                                                                                                         "                           + u_texCoordRD*(    s)*(1.0-t)\n"
 919                                                                                                         "                           + u_texCoordLU*(1.0-s)*(    t)\n"
 920                                                                                                         "                           + u_texCoordRU*(    s)*(    t);\n"
 921                                                                                                         "       int ndx = gy*" + toString(textureSize.x()) + " + gx;\n"
 922                                                                                                         "       sb_out.color[ndx] = texture(u_texture, texCoord" + (textureType == TEXTURETYPE_2D ? ".xy" : "") + ");\n"
 923                                                                                                         "}\n"));
 924
 925         glLog.glUseProgram(program.getProgram());
 926
 927         log << program;
 928
 929         if (!program.isOk())
 930         {
 931                 log << TestLog::Message << "// Failure: failed to compile program" << TestLog::EndMessage;
 932                 TCU_FAIL("Program compilation failed");
 933         }
 934
 935         {
 936                 const deUint32                  textureTargetGL         = getGLTextureTarget(textureType);
 937                 const glu::Buffer               outputBuffer            (renderCtx);
 938                 UniformAccessLogger             uniforms                        (renderCtx.getFunctions(), log, program.getProgram());
 939
 940                 // Setup texture.
 941
 942                 glLog.glActiveTexture(GL_TEXTURE0);
 943                 glLog.glBindTexture(textureTargetGL, textureGL);
 944                 setTexParameteri(glLog, textureTargetGL);
 945
 946                 uniforms.assign1i("u_texture", 0);
 947
 948                 // Setup output buffer.
 949                 {
 950                         const deUint32          blockIndex              = glLog.glGetProgramResourceIndex(program.getProgram(), GL_SHADER_STORAGE_BLOCK, "Output");
 951                         const int                       blockSize               = glu::getProgramResourceInt(renderCtx.getFunctions(), program.getProgram(), GL_SHADER_STORAGE_BLOCK, blockIndex, GL_BUFFER_DATA_SIZE);
 952
 953                         log << TestLog::Message << "// Got buffer data size = " << blockSize << TestLog::EndMessage;
 954                         TCU_CHECK(blockSize > 0);
 955
 956                         glLog.glBindBuffer(GL_SHADER_STORAGE_BUFFER, *outputBuffer);
 957                         glLog.glBufferData(GL_SHADER_STORAGE_BUFFER, blockSize, DE_NULL, GL_STREAM_READ);
 958                         glLog.glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, *outputBuffer);
 959                         GLU_EXPECT_NO_ERROR(renderCtx.getFunctions().getError(), "SSB setup failed");
 960                 }
 961
 962                 // Dispatch one layer at a time, read back and verify.
 963                 {
 964                         const int                                                       numSlicesOrFaces        = textureType == TEXTURETYPE_CUBE ? 6 : textureSize.z();
 965                         tcu::TextureLevel                                       resultSlice                     (textureFormat, textureSize.x(), textureSize.y());
 966                         const PixelBufferAccess                         resultSliceAccess       = resultSlice.getAccess();
 967                         const deUint32                                          blockIndex                      = glLog.glGetProgramResourceIndex(program.getProgram(), GL_SHADER_STORAGE_BLOCK, "Output");
 968                         const int                                                       blockSize                       = glu::getProgramResourceInt(renderCtx.getFunctions(), program.getProgram(), GL_SHADER_STORAGE_BLOCK, blockIndex, GL_BUFFER_DATA_SIZE);
 969                         const deUint32                                          valueIndex                      = glLog.glGetProgramResourceIndex(program.getProgram(), GL_BUFFER_VARIABLE, "Output.color");
 970                         const glu::InterfaceVariableInfo        valueInfo                       = glu::getProgramInterfaceVariableInfo(renderCtx.getFunctions(), program.getProgram(), GL_BUFFER_VARIABLE, valueIndex);
 971
 972                         TCU_CHECK(valueInfo.arraySize == (deUint32)(textureSize.x()*textureSize.y()));
 973
 974                         glLog.glMemoryBarrier(GL_TEXTURE_FETCH_BARRIER_BIT);
 975
 976                         for (int sliceOrFaceNdx = 0; sliceOrFaceNdx < numSlicesOrFaces; sliceOrFaceNdx++)
 977                         {
 978                                 if (textureType == TEXTURETYPE_CUBE)
 979                                 {
 980                                         vector<float> coords;
 981                                         computeQuadTexCoordCube(coords, glslImageFuncZToCubeFace(sliceOrFaceNdx));
 982                                         uniforms.assign3f("u_texCoordLD", coords[3*0 + 0], coords[3*0 + 1], coords[3*0 + 2]);
 983                                         uniforms.assign3f("u_texCoordRD", coords[3*2 + 0], coords[3*2 + 1], coords[3*2 + 2]);
 984                                         uniforms.assign3f("u_texCoordLU", coords[3*1 + 0], coords[3*1 + 1], coords[3*1 + 2]);
 985                                         uniforms.assign3f("u_texCoordRU", coords[3*3 + 0], coords[3*3 + 1], coords[3*3 + 2]);
 986                                 }
 987                                 else
 988                                 {
 989                                         const float z = textureType == TEXTURETYPE_3D ?
 990                                                                                 ((float)sliceOrFaceNdx + 0.5f) / (float)numSlicesOrFaces :
 991                                                                                 (float)sliceOrFaceNdx;
 992                                         uniforms.assign3f("u_texCoordLD", 0.0f, 0.0f, z);
 993                                         uniforms.assign3f("u_texCoordRD", 1.0f, 0.0f, z);
 994                                         uniforms.assign3f("u_texCoordLU", 0.0f, 1.0f, z);
 995                                         uniforms.assign3f("u_texCoordRU", 1.0f, 1.0f, z);
 996                                 }
 997
 998                                 glLog.glDispatchCompute(textureSize.x(), textureSize.y(), 1);
 999
1000                                 {
1001                                         log << TestLog::Message << "// Note: mapping buffer and reading color values written" << TestLog::EndMessage;
1002
1003                                         const BufferMemMap bufMap(renderCtx.getFunctions(), GL_SHADER_STORAGE_BUFFER, 0, blockSize, GL_MAP_READ_BIT);
1004
1005                                         for (int y = 0; y < textureSize.y(); y++)
1006                                         for (int x = 0; x < textureSize.x(); x++)
1007                                         {
1008                                                 const int                               ndx                     = y*textureSize.x() + x;
1009                                                 const float* const              clrData         = (const float*)((const deUint8*)bufMap.getPtr() + valueInfo.offset + valueInfo.arrayStride*ndx);
1010
1011                                                 switch (textureFormat.order)
1012                                                 {
1013                                                         case TextureFormat::R:          resultSliceAccess.setPixel(Vec4(clrData[0]),                                                                                    x, y); break;
1014                                                         case TextureFormat::RGBA:       resultSliceAccess.setPixel(Vec4(clrData[0], clrData[1], clrData[2], clrData[3]),                x, y); break;
1015                                                         default:
1016                                                                 DE_ASSERT(false);
1017                                                 }
1018                                         }
1019                                 }
1020
1021                                 if (!verifyLayer(log, resultSliceAccess, sliceOrFaceNdx))
1022                                         return false;
1023                         }
1024                 }
1025
1026                 return true;
1027         }
1028 }
1029
1030 //! Read buffer texture by reading the corresponding buffer with a mapping.
1031 static bool readBufferTextureWithMappingAndVerify (const RenderContext&                 renderCtx,
1032                                                                                                    glu::CallLogWrapper&                 glLog,
1033                                                                                                    deUint32                                             bufferGL,
1034                                                                                                    const TextureFormat&                 textureFormat,
1035                                                                                                    int                                                  imageSize,
1036                                                                                                    const ImageLayerVerifier&    verifyLayer)
1037 {
1038         tcu::TextureLevel                       result                  (textureFormat, imageSize, 1);
1039         const PixelBufferAccess         resultAccess    = result.getAccess();
1040         const int                                       dataSize                = imageSize * textureFormat.getPixelSize();
1041
1042         const tcu::ScopedLogSection section(glLog.getLog(), "Verification", "Result verification (read texture's buffer with a mapping)");
1043         glLog.glBindBuffer(GL_TEXTURE_BUFFER, bufferGL);
1044
1045         {
1046                 const BufferMemMap bufMap(renderCtx.getFunctions(), GL_TEXTURE_BUFFER, 0, dataSize, GL_MAP_READ_BIT);
1047                 deMemcpy(resultAccess.getDataPtr(), bufMap.getPtr(), dataSize);
1048         }
1049
1050         return verifyLayer(glLog.getLog(), resultAccess, 0);
1051 }
1052
1053 //! Calls the appropriate texture verification function depending on texture format or type.
1054 static bool readTextureAndVerify (const RenderContext&                  renderCtx,
1055                                                                   glu::CallLogWrapper&                  glLog,
1056                                                                   deUint32                                              textureGL,
1057                                                                   deUint32                                              bufferGL,
1058                                                                   TextureType                                   textureType,
1059                                                                   const TextureFormat&                  textureFormat,
1060                                                                   const IVec3&                                  imageSize,
1061                                                                   const ImageLayerVerifier&             verifyLayer)
1062 {
1063         if (textureType == TEXTURETYPE_BUFFER)
1064                 return readBufferTextureWithMappingAndVerify(renderCtx, glLog, bufferGL, textureFormat, imageSize.x(), verifyLayer);
1065         else
1066                 return isFormatTypeInteger(textureFormat.type) ? readIntegerTextureViaFBOAndVerify                              (renderCtx, glLog, textureGL, textureType, textureFormat, imageSize, verifyLayer)
1067                                                                                                            : readFloatOrNormTextureWithLookupsAndVerify         (renderCtx, glLog, textureGL, textureType, textureFormat, imageSize, verifyLayer);
1068 }
1069
1070 //! An ImageLayerVerifier that simply compares the result slice to a slice in a reference image.
1071 //! \note Holds the reference image as a reference (no pun intended) instead of a copy; caller must be aware of lifetime issues.
1072 class ImageLayerComparer : public ImageLayerVerifier
1073 {
1074 public:
1075         ImageLayerComparer (const LayeredImage& reference,
1076                                                 const IVec2& relevantRegion = IVec2(0) /* If given, only check this region of each slice. */)
1077                 : m_reference           (reference)
1078                 , m_relevantRegion      (relevantRegion.x() > 0 && relevantRegion.y() > 0 ? relevantRegion : reference.getSize().swizzle(0, 1))
1079         {
1080         }
1081
1082         bool operator() (TestLog& log, const tcu::ConstPixelBufferAccess& resultSlice, int sliceOrFaceNdx) const
1083         {
1084                 const bool                                              isCube                          = m_reference.getImageType() == TEXTURETYPE_CUBE;
1085                 const ConstPixelBufferAccess    referenceSlice          = tcu::getSubregion(isCube ? m_reference.getCubeFaceAccess(glslImageFuncZToCubeFace(sliceOrFaceNdx))
1086                                                                                                                                                                            : m_reference.getSliceAccess(sliceOrFaceNdx),
1087                                                                                                                                                                 0, 0, m_relevantRegion.x(), m_relevantRegion.y());
1088
1089                 const string comparisonName = "Comparison" + toString(sliceOrFaceNdx);
1090                 const string comparisonDesc = "Image Comparison, "
1091                                                                         + (isCube ? "face " + string(glu::getCubeMapFaceName(cubeFaceToGLFace(glslImageFuncZToCubeFace(sliceOrFaceNdx))))
1092                                                                                           : "slice " + toString(sliceOrFaceNdx));
1093
1094                 if (isFormatTypeInteger(m_reference.getFormat().type))
1095                         return tcu::intThresholdCompare(log, comparisonName.c_str(), comparisonDesc.c_str(), referenceSlice, resultSlice, UVec4(0), tcu::COMPARE_LOG_RESULT);
1096                 else
1097                         return tcu::floatThresholdCompare(log, comparisonName.c_str(), comparisonDesc.c_str(), referenceSlice, resultSlice, Vec4(0.01f), tcu::COMPARE_LOG_RESULT);
1098         }
1099
1100 private:
1101         const LayeredImage&             m_reference;
1102         const IVec2                             m_relevantRegion;
1103 };
1104
1105 //! Case that just stores some computation results into an image.
1106 class ImageStoreCase : public TestCase
1107 {
1108 public:
1109         enum CaseFlag
1110         {
1111                 CASEFLAG_SINGLE_LAYER_BIND = 1 << 0 //!< If given, glBindImageTexture() is called with GL_FALSE <layered> argument, and for each layer the compute shader is separately dispatched.
1112         };
1113
1114         ImageStoreCase (Context& context, const char* name, const char* description, const TextureFormat& format, TextureType textureType, deUint32 caseFlags = 0)
1115                 : TestCase                              (context, name, description)
1116                 , m_format                              (format)
1117                 , m_textureType                 (textureType)
1118                 , m_singleLayerBind             ((caseFlags & CASEFLAG_SINGLE_LAYER_BIND) != 0)
1119         {
1120         }
1121
1122         void                    init            (void) { checkTextureTypeExtensions(m_context.getContextInfo(), m_textureType, m_context.getRenderContext()); }
1123         IterateResult   iterate         (void);
1124
1125 private:
1126         const TextureFormat             m_format;
1127         const TextureType               m_textureType;
1128         const bool                              m_singleLayerBind;
1129 };
1130
1131 ImageStoreCase::IterateResult ImageStoreCase::iterate (void)
1132 {
1133         const RenderContext&            renderCtx                               = m_context.getRenderContext();
1134         TestLog&                                        log                                             (m_testCtx.getLog());
1135         glu::CallLogWrapper                     glLog                                   (renderCtx.getFunctions(), log);
1136         const deUint32                          internalFormatGL                = glu::getInternalFormat(m_format);
1137         const deUint32                          textureTargetGL                 = getGLTextureTarget(m_textureType);
1138         const IVec3&                            imageSize                               = defaultImageSize(m_textureType);
1139         const int                                       numSlicesOrFaces                = m_textureType == TEXTURETYPE_CUBE ? 6 : imageSize.z();
1140         const int                                       maxImageDimension               = de::max(imageSize.x(), de::max(imageSize.y(), imageSize.z()));
1141         const float                                     storeColorScale                 = isFormatTypeUnorm(m_format.type) ? 1.0f / (float)(maxImageDimension - 1)
1142                                                                                                                 : isFormatTypeSnorm(m_format.type) ? 2.0f / (float)(maxImageDimension - 1)
1143                                                                                                                 : 1.0f;
1144         const float                                     storeColorBias                  = isFormatTypeSnorm(m_format.type) ? -1.0f : 0.0f;
1145         const glu::Buffer                       textureBuf                              (renderCtx); // \note Only really used if using buffer texture.
1146         const glu::Texture                      texture                                 (renderCtx);
1147
1148         glLog.enableLogging(true);
1149
1150         // Setup texture.
1151
1152         log << TestLog::Message << "// Created a texture (name " << *texture << ")" << TestLog::EndMessage;
1153         if (m_textureType == TEXTURETYPE_BUFFER)
1154                 log << TestLog::Message << "// Created a buffer for the texture (name " << *textureBuf << ")" << TestLog::EndMessage;
1155
1156         glLog.glActiveTexture(GL_TEXTURE0);
1157         glLog.glBindTexture(textureTargetGL, *texture);
1158         setTexParameteri(glLog, textureTargetGL);
1159         setTextureStorage(glLog, m_textureType, internalFormatGL, imageSize, *textureBuf);
1160
1161         // Perform image stores in compute shader.
1162
1163         {
1164                 // Generate compute shader.
1165
1166                 const string            shaderImageFormatStr    = getShaderImageFormatQualifier(m_format);
1167                 const TextureType       shaderImageType                 = m_singleLayerBind ? textureLayerType(m_textureType) : m_textureType;
1168                 const string            shaderImageTypeStr              = getShaderImageType(m_format.type, shaderImageType);
1169                 const bool                      isUintFormat                    = isFormatTypeUnsignedInteger(m_format.type);
1170                 const bool                      isIntFormat                             = isFormatTypeSignedInteger(m_format.type);
1171                 const string            colorBaseExpr                   = string(isUintFormat ? "u" : isIntFormat ? "i" : "") + "vec4(gx^gy^gz, "
1172                                                                                                                                                                                                                                  "(" + toString(imageSize.x()-1) + "-gx)^gy^gz, "
1173                                                                                                                                                                                                                                  "gx^(" + toString(imageSize.y()-1) + "-gy)^gz, "
1174                                                                                                                                                                                                                                  "(" + toString(imageSize.x()-1) + "-gx)^(" + toString(imageSize.y()-1) + "-gy)^gz)";
1175                 const string            colorExpr                               = colorBaseExpr + (storeColorScale == 1.0f ? "" : "*" + toString(storeColorScale))
1176                                                                                                                                         + (storeColorBias == 0.0f ? "" : " + float(" + toString(storeColorBias) + ")");
1177                 const std::string       glslVersionDeclaration  = glu::getGLSLVersionDeclaration(glu::getContextTypeGLSLVersion(renderCtx.getType()));
1178
1179                 const glu::ShaderProgram program(renderCtx,
1180                         glu::ProgramSources() << glu::ComputeSource(glslVersionDeclaration + "\n"
1181                                                                                                                 + textureTypeExtensionShaderRequires(shaderImageType, renderCtx) +
1182                                                                                                                 "\n"
1183                                                                                                                 "precision highp " + shaderImageTypeStr + ";\n"
1184                                                                                                                 "\n"
1185                                                                                                                 "layout (local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n"
1186                                                                                                                 "layout (" + shaderImageFormatStr + ", binding=0) writeonly uniform " + shaderImageTypeStr + " u_image;\n"
1187                                                                                                                 + (m_singleLayerBind ? "uniform int u_layerNdx;\n" : "") +
1188                                                                                                                 "\n"
1189                                                                                                                 "void main (void)\n"
1190                                                                                                                 "{\n"
1191                                                                                                                 "       int gx = int(gl_GlobalInvocationID.x);\n"
1192                                                                                                                 "       int gy = int(gl_GlobalInvocationID.y);\n"
1193                                                                                                                 "       int gz = " + (m_singleLayerBind ? "u_layerNdx" : "int(gl_GlobalInvocationID.z)") + ";\n"
1194                                                                                                                 + (shaderImageType == TEXTURETYPE_BUFFER ?
1195                                                                                                                         "       imageStore(u_image, gx, " + colorExpr + ");\n"
1196                                                                                                                  : shaderImageType == TEXTURETYPE_2D ?
1197                                                                                                                         "       imageStore(u_image, ivec2(gx, gy), " + colorExpr + ");\n"
1198                                                                                                                  : shaderImageType == TEXTURETYPE_3D || shaderImageType == TEXTURETYPE_CUBE || shaderImageType == TEXTURETYPE_2D_ARRAY ?
1199                                                                                                                         "       imageStore(u_image, ivec3(gx, gy, gz), " + colorExpr + ");\n"
1200                                                                                                                  : DE_NULL) +
1201                                                                                                                 "}\n"));
1202
1203                 UniformAccessLogger uniforms(renderCtx.getFunctions(), log, program.getProgram());
1204
1205                 log << program;
1206
1207                 if (!program.isOk())
1208                 {
1209                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Program compilation failed");
1210                         return STOP;
1211                 }
1212
1213                 // Setup and dispatch.
1214
1215                 glLog.glUseProgram(program.getProgram());
1216
1217                 if (m_singleLayerBind)
1218                 {
1219                         for (int layerNdx = 0; layerNdx < numSlicesOrFaces; layerNdx++)
1220                         {
1221                                 if (layerNdx > 0)
1222                                         glLog.glMemoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT);
1223
1224                                 uniforms.assign1i("u_layerNdx", layerNdx);
1225
1226                                 glLog.glBindImageTexture(0, *texture, 0, GL_FALSE, layerNdx, GL_WRITE_ONLY, internalFormatGL);
1227                                 GLU_EXPECT_NO_ERROR(renderCtx.getFunctions().getError(), "glBindImageTexture");
1228
1229                                 glLog.glDispatchCompute(imageSize.x(), imageSize.y(), 1);
1230                                 GLU_EXPECT_NO_ERROR(renderCtx.getFunctions().getError(), "glDispatchCompute");
1231                         }
1232                 }
1233                 else
1234                 {
1235                         glLog.glBindImageTexture(0, *texture, 0, GL_TRUE, 0, GL_WRITE_ONLY, internalFormatGL);
1236                         GLU_EXPECT_NO_ERROR(renderCtx.getFunctions().getError(), "glBindImageTexture");
1237
1238                         glLog.glDispatchCompute(imageSize.x(), imageSize.y(), numSlicesOrFaces);
1239                         GLU_EXPECT_NO_ERROR(renderCtx.getFunctions().getError(), "glDispatchCompute");
1240                 }
1241         }
1242
1243         // Create reference, read texture and compare to reference.
1244         {
1245                 const int               isIntegerFormat         = isFormatTypeInteger(m_format.type);
1246                 LayeredImage    reference                       (m_textureType, m_format, imageSize.x(), imageSize.y(), imageSize.z());
1247
1248                 DE_ASSERT(!isIntegerFormat || (storeColorScale == 1.0f && storeColorBias == 0.0f));
1249
1250                 for (int z = 0; z < numSlicesOrFaces; z++)
1251                 for (int y = 0; y < imageSize.y(); y++)
1252                 for (int x = 0; x < imageSize.x(); x++)
1253                 {
1254                         const IVec4 color(x^y^z, (imageSize.x()-1-x)^y^z, x^(imageSize.y()-1-y)^z, (imageSize.x()-1-x)^(imageSize.y()-1-y)^z);
1255
1256                         if (isIntegerFormat)
1257                                 reference.setPixel(x, y, z, color);
1258                         else
1259                                 reference.setPixel(x, y, z, color.asFloat()*storeColorScale + storeColorBias);
1260                 }
1261
1262                 const bool compareOk = readTextureAndVerify(renderCtx, glLog, *texture, *textureBuf, m_textureType, m_format, imageSize, ImageLayerComparer(reference));
1263
1264                 m_testCtx.setTestResult(compareOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL, compareOk ? "Pass" : "Image comparison failed");
1265                 return STOP;
1266         }
1267 }
1268
1269 //! Case that copies an image to another, using imageLoad() and imageStore(). Texture formats don't necessarily match image formats.
1270 class ImageLoadAndStoreCase : public TestCase
1271 {
1272 public:
1273         enum CaseFlag
1274         {
1275                 CASEFLAG_SINGLE_LAYER_BIND      = 1 << 0,       //!< If given, glBindImageTexture() is called with GL_FALSE <layered> argument, and for each layer the compute shader is separately dispatched.
1276                 CASEFLAG_RESTRICT_IMAGES        = 1 << 1        //!< If given, images in shader will be qualified with "restrict".
1277         };
1278
1279         ImageLoadAndStoreCase (Context& context, const char* name, const char* description, const TextureFormat& format, TextureType textureType, deUint32 caseFlags = 0)
1280                 : TestCase                              (context, name, description)
1281                 , m_textureFormat               (format)
1282                 , m_imageFormat                 (format)
1283                 , m_textureType                 (textureType)
1284                 , m_restrictImages              ((caseFlags & CASEFLAG_RESTRICT_IMAGES)         != 0)
1285                 , m_singleLayerBind             ((caseFlags & CASEFLAG_SINGLE_LAYER_BIND)       != 0)
1286         {
1287         }
1288
1289         ImageLoadAndStoreCase (Context& context, const char* name, const char* description, const TextureFormat& textureFormat, const TextureFormat& imageFormat, TextureType textureType, deUint32 caseFlags = 0)
1290                 : TestCase                              (context, name, description)
1291                 , m_textureFormat               (textureFormat)
1292                 , m_imageFormat                 (imageFormat)
1293                 , m_textureType                 (textureType)
1294                 , m_restrictImages              ((caseFlags & CASEFLAG_RESTRICT_IMAGES)         != 0)
1295                 , m_singleLayerBind             ((caseFlags & CASEFLAG_SINGLE_LAYER_BIND)       != 0)
1296         {
1297                 DE_ASSERT(textureFormat.getPixelSize() == imageFormat.getPixelSize());
1298         }
1299
1300         void                    init            (void) { checkTextureTypeExtensions(m_context.getContextInfo(), m_textureType, m_context.getRenderContext()); }
1301         IterateResult   iterate         (void);
1302
1303 private:
1304         template <TextureFormat::ChannelType ImageFormatType, typename TcuFloatType, typename TcuFloatStorageType>
1305         static void                                     replaceBadFloatReinterpretValues (LayeredImage& image, const TextureFormat& imageFormat);
1306
1307         const TextureFormat                     m_textureFormat;
1308         const TextureFormat                     m_imageFormat;
1309         const TextureType                       m_textureType;
1310         const bool                                      m_restrictImages;
1311         const bool                                      m_singleLayerBind;
1312 };
1313
1314 template <TextureFormat::ChannelType ImageFormatType, typename TcuFloatType, typename TcuFloatTypeStorageType>
1315 void ImageLoadAndStoreCase::replaceBadFloatReinterpretValues (LayeredImage& image, const TextureFormat& imageFormat)
1316 {
1317         // Find potential bad values, such as nan or inf, and replace with something else.
1318         const int               pixelSize                       = imageFormat.getPixelSize();
1319         const int               imageNumChannels        = imageFormat.order == tcu::TextureFormat::R    ? 1
1320                                                                                 : imageFormat.order == tcu::TextureFormat::RGBA ? 4
1321                                                                                 : 0;
1322         const IVec3             imageSize                       = image.getSize();
1323         const int               numSlicesOrFaces        = image.getImageType() == TEXTURETYPE_CUBE ? 6 : imageSize.z();
1324
1325         DE_ASSERT(pixelSize % imageNumChannels == 0);
1326
1327         for (int z = 0; z < numSlicesOrFaces; z++)
1328         {
1329                 const PixelBufferAccess         sliceAccess             = image.getImageType() == TEXTURETYPE_CUBE ? image.getCubeFaceAccess((tcu::CubeFace)z) : image.getSliceAccess(z);
1330                 const int                                       rowPitch                = sliceAccess.getRowPitch();
1331                 void *const                                     data                    = sliceAccess.getDataPtr();
1332
1333                 for (int y = 0; y < imageSize.y(); y++)
1334                 for (int x = 0; x < imageSize.x(); x++)
1335                 {
1336                         void *const pixelData = (deUint8*)data + y*rowPitch + x*pixelSize;
1337
1338                         for (int c = 0; c < imageNumChannels; c++)
1339                         {
1340                                 void *const                     channelData             = (deUint8*)pixelData + c*pixelSize/imageNumChannels;
1341                                 const TcuFloatType      f                               (*(TcuFloatTypeStorageType*)channelData);
1342
1343                                 if (f.isDenorm() || f.isInf() || f.isNaN())
1344                                         *(TcuFloatTypeStorageType*)channelData = TcuFloatType(0.0f).bits();
1345                         }
1346                 }
1347         }
1348 }
1349
1350 ImageLoadAndStoreCase::IterateResult ImageLoadAndStoreCase::iterate (void)
1351 {
1352         const RenderContext&            renderCtx                                       = m_context.getRenderContext();
1353         TestLog&                                        log                                                     (m_testCtx.getLog());
1354         glu::CallLogWrapper                     glLog                                           (renderCtx.getFunctions(), log);
1355         const deUint32                          textureInternalFormatGL         = glu::getInternalFormat(m_textureFormat);
1356         const deUint32                          imageInternalFormatGL           = glu::getInternalFormat(m_imageFormat);
1357         const deUint32                          textureTargetGL                         = getGLTextureTarget(m_textureType);
1358         const IVec3&                            imageSize                                       = defaultImageSize(m_textureType);
1359         const int                                       maxImageDimension                       = de::max(imageSize.x(), de::max(imageSize.y(), imageSize.z()));
1360         const float                                     storeColorScale                         = isFormatTypeUnorm(m_textureFormat.type) ? 1.0f / (float)(maxImageDimension - 1)
1361                                                                                                                         : isFormatTypeSnorm(m_textureFormat.type) ? 2.0f / (float)(maxImageDimension - 1)
1362                                                                                                                         : 1.0f;
1363         const float                                     storeColorBias                          = isFormatTypeSnorm(m_textureFormat.type) ? -1.0f : 0.0f;
1364         const int                                       numSlicesOrFaces                        = m_textureType == TEXTURETYPE_CUBE ? 6 : imageSize.z();
1365         const bool                                      isIntegerTextureFormat          = isFormatTypeInteger(m_textureFormat.type);
1366         const glu::Buffer                       texture0Buf                                     (renderCtx);
1367         const glu::Buffer                       texture1Buf                                     (renderCtx);
1368         const glu::Texture                      texture0                                        (renderCtx);
1369         const glu::Texture                      texture1                                        (renderCtx);
1370         LayeredImage                            reference                                       (m_textureType, m_textureFormat, imageSize.x(), imageSize.y(), imageSize.z());
1371
1372         glLog.enableLogging(true);
1373
1374         // Setup textures.
1375
1376         log << TestLog::Message << "// Created 2 textures (names " << *texture0 << " and " << *texture1 << ")" << TestLog::EndMessage;
1377         if (m_textureType == TEXTURETYPE_BUFFER)
1378                 log << TestLog::Message << "// Created buffers for the textures (names " << *texture0Buf << " and " << *texture1Buf << ")" << TestLog::EndMessage;
1379
1380         // First, fill reference with (a fairly arbitrary) initial pattern. This will be used as texture upload source data as well as for actual reference computation later on.
1381
1382         DE_ASSERT(!isIntegerTextureFormat || (storeColorScale == 1.0f && storeColorBias == 0.0f));
1383
1384         for (int z = 0; z < numSlicesOrFaces; z++)
1385         for (int y = 0; y < imageSize.y(); y++)
1386         for (int x = 0; x < imageSize.x(); x++)
1387         {
1388                 const IVec4 color(x^y^z, (imageSize.x()-1-x)^y^z, x^(imageSize.y()-1-y)^z, (imageSize.x()-1-x)^(imageSize.y()-1-y)^z);
1389
1390                 if (isIntegerTextureFormat)
1391                         reference.setPixel(x, y, z, color);
1392                 else
1393                         reference.setPixel(x, y, z, color.asFloat()*storeColorScale + storeColorBias);
1394         }
1395
1396         // If re-interpreting the texture contents as floating point values, need to get rid of inf, nan etc.
1397         if (m_imageFormat.type == TextureFormat::HALF_FLOAT && m_textureFormat.type != TextureFormat::HALF_FLOAT)
1398                 replaceBadFloatReinterpretValues<TextureFormat::HALF_FLOAT, tcu::Float16, deUint16>(reference, m_imageFormat);
1399         else if (m_imageFormat.type == TextureFormat::FLOAT && m_textureFormat.type != TextureFormat::FLOAT)
1400                 replaceBadFloatReinterpretValues<TextureFormat::FLOAT, tcu::Float32, deUint32>(reference, m_imageFormat);
1401
1402         // Upload initial pattern to texture 0.
1403
1404         glLog.glActiveTexture(GL_TEXTURE0);
1405         glLog.glBindTexture(textureTargetGL, *texture0);
1406         setTexParameteri(glLog, textureTargetGL);
1407
1408         log << TestLog::Message << "// Filling texture " << *texture0 << " with xor pattern" << TestLog::EndMessage;
1409
1410         uploadTexture(glLog, reference, *texture0Buf);
1411
1412         // Set storage for texture 1.
1413
1414         glLog.glActiveTexture(GL_TEXTURE1);
1415         glLog.glBindTexture(textureTargetGL, *texture1);
1416         setTexParameteri(glLog, textureTargetGL);
1417         setTextureStorage(glLog, m_textureType, textureInternalFormatGL, imageSize, *texture1Buf);
1418
1419         // Perform image loads and stores in compute shader and finalize reference computation.
1420
1421         {
1422                 // Generate compute shader.
1423
1424                 const char* const               maybeRestrict                   = m_restrictImages ? "restrict" : "";
1425                 const string                    shaderImageFormatStr    = getShaderImageFormatQualifier(m_imageFormat);
1426                 const TextureType               shaderImageType                 = m_singleLayerBind ? textureLayerType(m_textureType) : m_textureType;
1427                 const string                    shaderImageTypeStr              = getShaderImageType(m_imageFormat.type, shaderImageType);
1428                 const std::string               glslVersionDeclaration  = glu::getGLSLVersionDeclaration(glu::getContextTypeGLSLVersion(renderCtx.getType()));
1429
1430                 const glu::ShaderProgram program(renderCtx,
1431                         glu::ProgramSources() << glu::ComputeSource(glslVersionDeclaration + "\n"
1432                                                                                                                 + textureTypeExtensionShaderRequires(shaderImageType, renderCtx) +
1433                                                                                                                 "\n"
1434                                                                                                                 "precision highp " + shaderImageTypeStr + ";\n"
1435                                                                                                                 "\n"
1436                                                                                                                 "layout (local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n"
1437                                                                                                                 "layout (" + shaderImageFormatStr + ", binding=0) " + maybeRestrict + " readonly uniform " + shaderImageTypeStr + " u_image0;\n"
1438                                                                                                                 "layout (" + shaderImageFormatStr + ", binding=1) " + maybeRestrict + " writeonly uniform " + shaderImageTypeStr + " u_image1;\n"
1439                                                                                                                 "\n"
1440                                                                                                                 "void main (void)\n"
1441                                                                                                                 "{\n"
1442                                                                                                                 + (shaderImageType == TEXTURETYPE_BUFFER ?
1443                                                                                                                         "       int pos = int(gl_GlobalInvocationID.x);\n"
1444                                                                                                                         "       imageStore(u_image1, pos, imageLoad(u_image0, " + toString(imageSize.x()-1) + "-pos));\n"
1445                                                                                                                  : shaderImageType == TEXTURETYPE_2D ?
1446                                                                                                                         "       ivec2 pos = ivec2(gl_GlobalInvocationID.xy);\n"
1447                                                                                                                         "       imageStore(u_image1, pos, imageLoad(u_image0, ivec2(" + toString(imageSize.x()-1) + "-pos.x, pos.y)));\n"
1448                                                                                                                  : shaderImageType == TEXTURETYPE_3D || shaderImageType == TEXTURETYPE_CUBE || shaderImageType == TEXTURETYPE_2D_ARRAY ?
1449                                                                                                                         "       ivec3 pos = ivec3(gl_GlobalInvocationID);\n"
1450                                                                                                                         "       imageStore(u_image1, pos, imageLoad(u_image0, ivec3(" + toString(imageSize.x()-1) + "-pos.x, pos.y, pos.z)));\n"
1451                                                                                                                  : DE_NULL) +
1452                                                                                                                 "}\n"));
1453
1454                 UniformAccessLogger uniforms(renderCtx.getFunctions(), log, program.getProgram());
1455
1456                 log << program;
1457
1458                 if (!program.isOk())
1459                 {
1460                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Program compilation failed");
1461                         return STOP;
1462                 }
1463
1464                 // Setup and dispatch.
1465
1466                 glLog.glUseProgram(program.getProgram());
1467
1468                 if (m_singleLayerBind)
1469                 {
1470                         for (int layerNdx = 0; layerNdx < numSlicesOrFaces; layerNdx++)
1471                         {
1472                                 if (layerNdx > 0)
1473                                         glLog.glMemoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT);
1474
1475                                 glLog.glBindImageTexture(0, *texture0, 0, GL_FALSE, layerNdx, GL_READ_ONLY, imageInternalFormatGL);
1476                                 GLU_EXPECT_NO_ERROR(renderCtx.getFunctions().getError(), "glBindImageTexture");
1477
1478                                 glLog.glBindImageTexture(1, *texture1, 0, GL_FALSE, layerNdx, GL_WRITE_ONLY, imageInternalFormatGL);
1479                                 GLU_EXPECT_NO_ERROR(renderCtx.getFunctions().getError(), "glBindImageTexture");
1480
1481                                 glLog.glDispatchCompute(imageSize.x(), imageSize.y(), 1);
1482                                 GLU_EXPECT_NO_ERROR(renderCtx.getFunctions().getError(), "glDispatchCompute");
1483                         }
1484                 }
1485                 else
1486                 {
1487                         glLog.glBindImageTexture(0, *texture0, 0, GL_TRUE, 0, GL_READ_ONLY, imageInternalFormatGL);
1488                         GLU_EXPECT_NO_ERROR(renderCtx.getFunctions().getError(), "glBindImageTexture");
1489
1490                         glLog.glBindImageTexture(1, *texture1, 0, GL_TRUE, 0, GL_WRITE_ONLY, imageInternalFormatGL);
1491                         GLU_EXPECT_NO_ERROR(renderCtx.getFunctions().getError(), "glBindImageTexture");
1492
1493                         glLog.glDispatchCompute(imageSize.x(), imageSize.y(), numSlicesOrFaces);
1494                         GLU_EXPECT_NO_ERROR(renderCtx.getFunctions().getError(), "glDispatchCompute");
1495                 }
1496
1497                 // Finalize reference.
1498
1499                 if (m_textureFormat != m_imageFormat)
1500                 {
1501                         // Format re-interpretation case. Read data with image format and write back, with the same image format.
1502                         // We do this because the data may change a little during lookups (e.g. unorm8 -> float; not all unorms can be exactly represented as floats).
1503
1504                         const int                                       pixelSize               = m_imageFormat.getPixelSize();
1505                         tcu::TextureLevel                       scratch                 (m_imageFormat, 1, 1);
1506                         const PixelBufferAccess         scratchAccess   = scratch.getAccess();
1507
1508                         for (int z = 0; z < numSlicesOrFaces; z++)
1509                         {
1510                                 const PixelBufferAccess         sliceAccess             = m_textureType == TEXTURETYPE_CUBE ? reference.getCubeFaceAccess((tcu::CubeFace)z) : reference.getSliceAccess(z);
1511                                 const int                                       rowPitch                = sliceAccess.getRowPitch();
1512                                 void *const                                     data                    = sliceAccess.getDataPtr();
1513
1514                                 for (int y = 0; y < imageSize.y(); y++)
1515                                 for (int x = 0; x < imageSize.x(); x++)
1516                                 {
1517                                         void *const pixelData = (deUint8*)data + y*rowPitch + x*pixelSize;
1518
1519                                         deMemcpy(scratchAccess.getDataPtr(), pixelData, pixelSize);
1520
1521                                         if (isFormatTypeInteger(m_imageFormat.type))
1522                                                 scratchAccess.setPixel(scratchAccess.getPixelUint(0, 0), 0, 0);
1523                                         else
1524                                                 scratchAccess.setPixel(scratchAccess.getPixel(0, 0), 0, 0);
1525
1526                                         deMemcpy(pixelData, scratchAccess.getDataPtr(), pixelSize);
1527                                 }
1528                         }
1529                 }
1530
1531                 for (int z = 0; z < numSlicesOrFaces; z++)
1532                 for (int y = 0; y < imageSize.y(); y++)
1533                 for (int x = 0; x < imageSize.x()/2; x++)
1534                 {
1535                         if (isIntegerTextureFormat)
1536                         {
1537                                 const UVec4 temp = reference.getPixelUint(imageSize.x()-1-x, y, z);
1538                                 reference.setPixel(imageSize.x()-1-x, y, z, reference.getPixelUint(x, y, z));
1539                                 reference.setPixel(x, y, z, temp);
1540                         }
1541                         else
1542                         {
1543                                 const Vec4 temp = reference.getPixel(imageSize.x()-1-x, y, z);
1544                                 reference.setPixel(imageSize.x()-1-x, y, z, reference.getPixel(x, y, z));
1545                                 reference.setPixel(x, y, z, temp);
1546                         }
1547                 }
1548         }
1549
1550         // Read texture 1 and compare to reference.
1551
1552         const bool compareOk = readTextureAndVerify(renderCtx, glLog, *texture1, *texture1Buf, m_textureType, m_textureFormat, imageSize, ImageLayerComparer(reference));
1553
1554         m_testCtx.setTestResult(compareOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL, compareOk ? "Pass" : "Image comparison failed");
1555         return STOP;
1556 }
1557
1558 enum AtomicOperationCaseType
1559 {
1560         ATOMIC_OPERATION_CASE_TYPE_END_RESULT = 0,      //!< Atomic case checks the end result of the operations, and not the return values.
1561         ATOMIC_OPERATION_CASE_TYPE_RETURN_VALUES,       //!< Atomic case checks the return values of the atomic function, and not the end result.
1562
1563         ATOMIC_OPERATION_CASE_TYPE_LAST
1564 };
1565
1566 /*--------------------------------------------------------------------*//*!
1567  * \brief Binary atomic operation case.
1568  *
1569  * Case that performs binary atomic operations (i.e. any but compSwap) and
1570  * verifies according to the given AtomicOperationCaseType.
1571  *
1572  * For the "end result" case type, a single texture (and image) is created,
1573  * upon which the atomic operations operate. A compute shader is dispatched
1574  * with dimensions equal to the image size, except with a bigger X size
1575  * so that every pixel is operated on by multiple invocations. The end
1576  * results are verified in BinaryAtomicOperationCase::EndResultVerifier.
1577  * The return values of the atomic function calls are ignored.
1578  *
1579  * For the "return value" case type, the case does much the same operations
1580  * as in the "end result" case, but also creates an additional texture,
1581  * of size equal to the dispatch size, into which the return values of the
1582  * atomic functions are stored (with imageStore()). The return values are
1583  * verified in BinaryAtomicOperationCase::ReturnValueVerifier.
1584  * The end result values are not checked.
1585  *
1586  * The compute shader invocations contributing to a pixel (X, Y, Z) in the
1587  * end result image are the invocations with global IDs
1588  * (X, Y, Z), (X+W, Y, Z), (X+2*W, Y, Z), ..., (X+(N-1)*W, Y, W), where W
1589  * is the width of the end result image and N is
1590  * BinaryAtomicOperationCase::NUM_INVOCATIONS_PER_PIXEL.
1591  *//*--------------------------------------------------------------------*/
1592 class BinaryAtomicOperationCase : public TestCase
1593 {
1594 public:
1595                                                                         BinaryAtomicOperationCase               (Context& context, const char* name, const char* description, const TextureFormat& format, TextureType imageType, AtomicOperation operation, AtomicOperationCaseType caseType)
1596                 : TestCase              (context, name, description)
1597                 , m_format              (format)
1598                 , m_imageType   (imageType)
1599                 , m_operation   (operation)
1600                 , m_caseType    (caseType)
1601         {
1602                 DE_ASSERT(m_format == TextureFormat(TextureFormat::R, TextureFormat::UNSIGNED_INT32)    ||
1603                                   m_format == TextureFormat(TextureFormat::R, TextureFormat::SIGNED_INT32)              ||
1604                                   (m_format == TextureFormat(TextureFormat::R, TextureFormat::FLOAT) && m_operation == ATOMIC_OPERATION_EXCHANGE));
1605
1606                 DE_ASSERT(m_operation != ATOMIC_OPERATION_COMP_SWAP);
1607         }
1608
1609         void                                                    init                                                    (void);
1610         IterateResult                                   iterate                                                 (void);
1611
1612 private:
1613         class EndResultVerifier;
1614         class ReturnValueVerifier;
1615
1616         static int                                              getOperationInitialValue                (AtomicOperation op); //!< Appropriate value with which to initialize the texture.
1617         //! Compute the argument given to the atomic function at the given invocation ID, when the entire dispatch has the given width and height.
1618         static int                                              getAtomicFuncArgument                   (AtomicOperation op, const IVec3& invocationID, const IVec2& dispatchSizeXY);
1619         //! Generate the shader expression for the argument given to the atomic function. x, y and z are the identifiers for the invocation ID components.
1620         static string                                   getAtomicFuncArgumentShaderStr  (AtomicOperation op, const string& x, const string& y, const string& z, const IVec2& dispatchSizeXY);
1621
1622         static const int                                NUM_INVOCATIONS_PER_PIXEL = 5;
1623
1624         const TextureFormat                             m_format;
1625         const TextureType                               m_imageType;
1626         const AtomicOperation                   m_operation;
1627         const AtomicOperationCaseType   m_caseType;
1628 };
1629
1630 int BinaryAtomicOperationCase::getOperationInitialValue (AtomicOperation op)
1631 {
1632         switch (op)
1633         {
1634                 // \note 18 is just an arbitrary small nonzero value.
1635                 case ATOMIC_OPERATION_ADD:                      return 18;
1636                 case ATOMIC_OPERATION_MIN:                      return (1<<15) - 1;
1637                 case ATOMIC_OPERATION_MAX:                      return 18;
1638                 case ATOMIC_OPERATION_AND:                      return (1<<15) - 1;
1639                 case ATOMIC_OPERATION_OR:                       return 18;
1640                 case ATOMIC_OPERATION_XOR:                      return 18;
1641                 case ATOMIC_OPERATION_EXCHANGE:         return 18;
1642                 default:
1643                         DE_ASSERT(false);
1644                         return -1;
1645         }
1646 }
1647
1648 int BinaryAtomicOperationCase::getAtomicFuncArgument (AtomicOperation op, const IVec3& invocationID, const IVec2& dispatchSizeXY)
1649 {
1650         const int x             = invocationID.x();
1651         const int y             = invocationID.y();
1652         const int z             = invocationID.z();
1653         const int wid   = dispatchSizeXY.x();
1654         const int hei   = dispatchSizeXY.y();
1655
1656         switch (op)
1657         {
1658                 // \note Fall-throughs.
1659                 case ATOMIC_OPERATION_ADD:
1660                 case ATOMIC_OPERATION_MIN:
1661                 case ATOMIC_OPERATION_MAX:
1662                 case ATOMIC_OPERATION_AND:
1663                 case ATOMIC_OPERATION_OR:
1664                 case ATOMIC_OPERATION_XOR:
1665                         return x*x + y*y + z*z;
1666
1667                 case ATOMIC_OPERATION_EXCHANGE:
1668                         return (z*wid + x)*hei + y;
1669
1670                 default:
1671                         DE_ASSERT(false);
1672                         return -1;
1673         }
1674 }
1675
1676 string BinaryAtomicOperationCase::getAtomicFuncArgumentShaderStr (AtomicOperation op, const string& x, const string& y, const string& z, const IVec2& dispatchSizeXY)
1677 {
1678         switch (op)
1679         {
1680                 // \note Fall-throughs.
1681                 case ATOMIC_OPERATION_ADD:
1682                 case ATOMIC_OPERATION_MIN:
1683                 case ATOMIC_OPERATION_MAX:
1684                 case ATOMIC_OPERATION_AND:
1685                 case ATOMIC_OPERATION_OR:
1686                 case ATOMIC_OPERATION_XOR:
1687                         return "("+ x+"*"+x +" + "+ y+"*"+y +" + "+ z+"*"+z +")";
1688
1689                 case ATOMIC_OPERATION_EXCHANGE:
1690                         return "((" + z + "*" + toString(dispatchSizeXY.x()) + " + " + x + ")*" + toString(dispatchSizeXY.y()) + " + " + y + ")";
1691
1692                 default:
1693                         DE_ASSERT(false);
1694                         return DE_NULL;
1695         }
1696 }
1697
1698 class BinaryAtomicOperationCase::EndResultVerifier : public ImageLayerVerifier
1699 {
1700 public:
1701         EndResultVerifier (AtomicOperation operation, TextureType imageType) : m_operation(operation), m_imageType(imageType) {}
1702
1703         bool operator() (TestLog& log, const ConstPixelBufferAccess& resultSlice, int sliceOrFaceNdx) const
1704         {
1705                 const bool              isIntegerFormat         = isFormatTypeInteger(resultSlice.getFormat().type);
1706                 const IVec2             dispatchSizeXY          (NUM_INVOCATIONS_PER_PIXEL*resultSlice.getWidth(), resultSlice.getHeight());
1707
1708                 log << TestLog::Image("EndResults" + toString(sliceOrFaceNdx),
1709                                                           "Result Values, " + (m_imageType == TEXTURETYPE_CUBE ? "face " + string(glu::getCubeMapFaceName(cubeFaceToGLFace(glslImageFuncZToCubeFace(sliceOrFaceNdx))))
1710                                                                                                                                                                    : "slice " + toString(sliceOrFaceNdx)),
1711                                                           resultSlice);
1712
1713                 for (int y = 0; y < resultSlice.getHeight(); y++)
1714                 for (int x = 0; x < resultSlice.getWidth(); x++)
1715                 {
1716                         union
1717                         {
1718                                 int             i;
1719                                 float   f;
1720                         } result;
1721
1722                         if (isIntegerFormat)
1723                                 result.i = resultSlice.getPixelInt(x, y).x();
1724                         else
1725                                 result.f = resultSlice.getPixel(x, y).x();
1726
1727                         // Compute the arguments that were given to the atomic function in the invocations that contribute to this pixel.
1728
1729                         IVec3   invocationGlobalIDs[NUM_INVOCATIONS_PER_PIXEL];
1730                         int             atomicArgs[NUM_INVOCATIONS_PER_PIXEL];
1731
1732                         for (int i = 0; i < NUM_INVOCATIONS_PER_PIXEL; i++)
1733                         {
1734                                 const IVec3 gid(x + i*resultSlice.getWidth(), y, sliceOrFaceNdx);
1735
1736                                 invocationGlobalIDs[i]  = gid;
1737                                 atomicArgs[i]                   = getAtomicFuncArgument(m_operation, gid, dispatchSizeXY);
1738                         }
1739
1740                         if (isOrderIndependentAtomicOperation(m_operation))
1741                         {
1742                                 // Just accumulate the atomic args (and the initial value) according to the operation, and compare.
1743
1744                                 DE_ASSERT(isIntegerFormat);
1745
1746                                 int reference = getOperationInitialValue(m_operation);
1747
1748                                 for (int i = 0; i < NUM_INVOCATIONS_PER_PIXEL; i++)
1749                                         reference = computeBinaryAtomicOperationResult(m_operation, reference, atomicArgs[i]);
1750
1751                                 if (result.i != reference)
1752                                 {
1753                                         log << TestLog::Message << "// Failure: end result at pixel " << IVec2(x, y) << " of current layer is " << result.i << TestLog::EndMessage
1754                                                 << TestLog::Message << "// Note: relevant shader invocation global IDs are " << arrayStr(invocationGlobalIDs) << TestLog::EndMessage
1755                                                 << TestLog::Message << "// Note: data expression values for the IDs are " << arrayStr(atomicArgs) << TestLog::EndMessage
1756                                                 << TestLog::Message << "// Note: reference value is " << reference << TestLog::EndMessage;
1757                                         return false;
1758                                 }
1759                         }
1760                         else if (m_operation == ATOMIC_OPERATION_EXCHANGE)
1761                         {
1762                                 // Check that the end result equals one of the atomic args.
1763
1764                                 bool matchFound = false;
1765
1766                                 for (int i = 0; i < NUM_INVOCATIONS_PER_PIXEL && !matchFound; i++)
1767                                         matchFound = isIntegerFormat ? result.i == atomicArgs[i]
1768                                                                                                  : de::abs(result.f - (float)atomicArgs[i]) <= 0.01f;
1769
1770                                 if (!matchFound)
1771                                 {
1772                                         log << TestLog::Message << "// Failure: invalid value at pixel " << IVec2(x, y) << ": got " << (isIntegerFormat ? toString(result.i) : toString(result.f)) << TestLog::EndMessage
1773                                                                                         << TestLog::Message << "// Note: expected one of " << arrayStr(atomicArgs) << TestLog::EndMessage;
1774
1775                                         return false;
1776                                 }
1777                         }
1778                         else
1779                                 DE_ASSERT(false);
1780                 }
1781
1782                 return true;
1783         }
1784
1785 private:
1786         const AtomicOperation   m_operation;
1787         const TextureType               m_imageType;
1788 };
1789
1790 class BinaryAtomicOperationCase::ReturnValueVerifier : public ImageLayerVerifier
1791 {
1792 public:
1793         //! \note endResultImageLayerSize is (width, height) of the image operated on by the atomic ops, and not the size of the image where the return values are stored.
1794         ReturnValueVerifier (AtomicOperation operation, TextureType imageType, const IVec2& endResultImageLayerSize) : m_operation(operation), m_imageType(imageType), m_endResultImageLayerSize(endResultImageLayerSize) {}
1795
1796         bool operator() (TestLog& log, const ConstPixelBufferAccess& resultSlice, int sliceOrFaceNdx) const
1797         {
1798                 const bool              isIntegerFormat         (isFormatTypeInteger(resultSlice.getFormat().type));
1799                 const IVec2             dispatchSizeXY  (resultSlice.getWidth(), resultSlice.getHeight());
1800
1801                 DE_ASSERT(resultSlice.getWidth()        == NUM_INVOCATIONS_PER_PIXEL*m_endResultImageLayerSize.x()      &&
1802                                   resultSlice.getHeight()       == m_endResultImageLayerSize.y()                                                        &&
1803                                   resultSlice.getDepth()        == 1);
1804
1805                 log << TestLog::Image("ReturnValues" + toString(sliceOrFaceNdx),
1806                                                           "Per-Invocation Return Values, "
1807                                                                    + (m_imageType == TEXTURETYPE_CUBE ? "face " + string(glu::getCubeMapFaceName(cubeFaceToGLFace(glslImageFuncZToCubeFace(sliceOrFaceNdx))))
1808                                                                                                                                           : "slice " + toString(sliceOrFaceNdx)),
1809                                                           resultSlice);
1810
1811                 for (int y = 0; y < m_endResultImageLayerSize.y(); y++)
1812                 for (int x = 0; x < m_endResultImageLayerSize.x(); x++)
1813                 {
1814                         union IntFloatArr
1815                         {
1816                                 int             i[NUM_INVOCATIONS_PER_PIXEL];
1817                                 float   f[NUM_INVOCATIONS_PER_PIXEL];
1818                         };
1819
1820                         // Get the atomic function args and return values for all the invocations that contribute to the pixel (x, y) in the current end result slice.
1821
1822                         IntFloatArr             returnValues;
1823                         IntFloatArr             atomicArgs;
1824                         IVec3                   invocationGlobalIDs[NUM_INVOCATIONS_PER_PIXEL];
1825                         IVec2                   pixelCoords[NUM_INVOCATIONS_PER_PIXEL];
1826
1827                         for (int i = 0; i < NUM_INVOCATIONS_PER_PIXEL; i++)
1828                         {
1829                                 const IVec2 pixCoord    (x + i*m_endResultImageLayerSize.x(), y);
1830                                 const IVec3 gid                 (pixCoord.x(), pixCoord.y(), sliceOrFaceNdx);
1831
1832                                 invocationGlobalIDs[i]  = gid;
1833                                 pixelCoords[i]                  = pixCoord;
1834
1835                                 if (isIntegerFormat)
1836                                 {
1837                                         returnValues.i[i]       = resultSlice.getPixelInt(gid.x(), y).x();
1838                                         atomicArgs.i[i]         = getAtomicFuncArgument(m_operation, gid, dispatchSizeXY);
1839                                 }
1840                                 else
1841                                 {
1842                                         returnValues.f[i]       = resultSlice.getPixel(gid.x(), y).x();
1843                                         atomicArgs.f[i]         = (float)getAtomicFuncArgument(m_operation, gid, dispatchSizeXY);
1844                                 }
1845                         }
1846
1847                         // Verify that the return values form a valid sequence.
1848
1849                         {
1850                                 const bool success = isIntegerFormat ? verifyOperationAccumulationIntermediateValues(m_operation,
1851                                                                                                                                                                                                          getOperationInitialValue(m_operation),
1852                                                                                                                                                                                                          atomicArgs.i,
1853                                                                                                                                                                                                          returnValues.i)
1854
1855                                                                                                          : verifyOperationAccumulationIntermediateValues(m_operation,
1856                                                                                                                                                                                                          (float)getOperationInitialValue(m_operation),
1857                                                                                                                                                                                                          atomicArgs.f,
1858                                                                                                                                                                                                          returnValues.f);
1859
1860                                 if (!success)
1861                                 {
1862                                         log << TestLog::Message << "// Failure: intermediate return values at pixels " << arrayStr(pixelCoords) << " of current layer are "
1863                                                                                         << (isIntegerFormat ? arrayStr(returnValues.i) : arrayStr(returnValues.f)) << TestLog::EndMessage
1864                                                 << TestLog::Message << "// Note: relevant shader invocation global IDs are " << arrayStr(invocationGlobalIDs) << TestLog::EndMessage
1865                                                 << TestLog::Message << "// Note: data expression values for the IDs are "
1866                                                                                         << (isIntegerFormat ? arrayStr(atomicArgs.i) : arrayStr(atomicArgs.f))
1867                                                                                         << "; return values are not a valid result for any order of operations" << TestLog::EndMessage;
1868                                         return false;
1869                                 }
1870                         }
1871                 }
1872
1873                 return true;
1874         }
1875
1876 private:
1877         const AtomicOperation   m_operation;
1878         const TextureType               m_imageType;
1879         const IVec2                             m_endResultImageLayerSize;
1880
1881         //! Check whether there exists an ordering of args such that { init*A", init*A*B, ..., init*A*B*...*LAST } is the "returnValues" sequence, where { A, B, ..., LAST } is args, and * denotes the operation.
1882         //      That is, whether "returnValues" is a valid sequence of intermediate return values when "operation" has been accumulated on "args" (and "init") in some arbitrary order.
1883         template <typename T>
1884         static bool verifyOperationAccumulationIntermediateValues (AtomicOperation operation, T init, const T (&args)[NUM_INVOCATIONS_PER_PIXEL], const T (&returnValues)[NUM_INVOCATIONS_PER_PIXEL])
1885         {
1886                 bool argsUsed[NUM_INVOCATIONS_PER_PIXEL] = { false };
1887
1888                 return verifyRecursive(operation, 0, init, argsUsed, args, returnValues);
1889         }
1890
1891         static bool compare (int a, int b)              { return a == b; }
1892         static bool compare (float a, float b)  { return de::abs(a - b) <= 0.01f; }
1893
1894         //! Depth-first search for verifying the return value sequence.
1895         template <typename T>
1896         static bool verifyRecursive (AtomicOperation operation, int index, T valueSoFar, bool (&argsUsed)[NUM_INVOCATIONS_PER_PIXEL], const T (&args)[NUM_INVOCATIONS_PER_PIXEL], const T (&returnValues)[NUM_INVOCATIONS_PER_PIXEL])
1897         {
1898                 if (index < NUM_INVOCATIONS_PER_PIXEL)
1899                 {
1900                         for (int i = 0; i < NUM_INVOCATIONS_PER_PIXEL; i++)
1901                         {
1902                                 if (!argsUsed[i] && compare(returnValues[i], valueSoFar))
1903                                 {
1904                                         argsUsed[i] = true;
1905                                         if (verifyRecursive(operation, index+1, computeBinaryAtomicOperationResult(operation, valueSoFar, args[i]), argsUsed, args, returnValues))
1906                                                 return true;
1907                                         argsUsed[i] = false;
1908                                 }
1909                         }
1910
1911                         return false;
1912                 }
1913                 else
1914                         return true;
1915         }
1916 };
1917
1918 void BinaryAtomicOperationCase::init (void)
1919 {
1920         if (!m_context.getContextInfo().isExtensionSupported("GL_OES_shader_image_atomic") && !glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2)))
1921                 throw tcu::NotSupportedError("Test requires OES_shader_image_atomic extension");
1922
1923         checkTextureTypeExtensions(m_context.getContextInfo(), m_imageType, m_context.getRenderContext());
1924 }
1925
1926 BinaryAtomicOperationCase::IterateResult BinaryAtomicOperationCase::iterate (void)
1927 {
1928         const RenderContext&            renderCtx                               = m_context.getRenderContext();
1929         TestLog&                                        log                                             (m_testCtx.getLog());
1930         glu::CallLogWrapper                     glLog                                   (renderCtx.getFunctions(), log);
1931         const deUint32                          internalFormatGL                = glu::getInternalFormat(m_format);
1932         const deUint32                          textureTargetGL                 = getGLTextureTarget(m_imageType);
1933         const IVec3&                            imageSize                               = defaultImageSize(m_imageType);
1934         const int                                       numSlicesOrFaces                = m_imageType == TEXTURETYPE_CUBE ? 6 : imageSize.z();
1935         const bool                                      isUintFormat                    = isFormatTypeUnsignedInteger(m_format.type);
1936         const bool                                      isIntFormat                             = isFormatTypeSignedInteger(m_format.type);
1937         const glu::Buffer                       endResultTextureBuf             (renderCtx);
1938         const glu::Buffer                       returnValueTextureBuf   (renderCtx);
1939         const glu::Texture                      endResultTexture                (renderCtx); //!< Texture for the final result; i.e. the texture on which the atomic operations are done. Size imageSize.
1940         const glu::Texture                      returnValueTexture              (renderCtx); //!< Texture into which the return values are stored if m_caseType == CASETYPE_RETURN_VALUES.
1941                                                                                                                                          //       Size imageSize*IVec3(N, 1, 1) or, for cube maps, imageSize*IVec3(N, N, 1) where N is NUM_INVOCATIONS_PER_PIXEL.
1942
1943         glLog.enableLogging(true);
1944
1945         // Setup textures.
1946
1947         log << TestLog::Message << "// Created a texture (name " << *endResultTexture << ") to act as the target of atomic operations" << TestLog::EndMessage;
1948         if (m_imageType == TEXTURETYPE_BUFFER)
1949                 log << TestLog::Message << "// Created a buffer for the texture (name " << *endResultTextureBuf << ")" << TestLog::EndMessage;
1950
1951         if (m_caseType == ATOMIC_OPERATION_CASE_TYPE_RETURN_VALUES)
1952         {
1953                 log << TestLog::Message << "// Created a texture (name " << *returnValueTexture << ") to which the intermediate return values of the atomic operation are stored" << TestLog::EndMessage;
1954                 if (m_imageType == TEXTURETYPE_BUFFER)
1955                         log << TestLog::Message << "// Created a buffer for the texture (name " << *returnValueTextureBuf << ")" << TestLog::EndMessage;
1956         }
1957
1958         // Fill endResultTexture with initial pattern.
1959
1960         {
1961                 const LayeredImage imageData(m_imageType, m_format, imageSize.x(), imageSize.y(), imageSize.z());
1962
1963                 {
1964                         const IVec4 initial(getOperationInitialValue(m_operation));
1965
1966                         for (int z = 0; z < numSlicesOrFaces; z++)
1967                         for (int y = 0; y < imageSize.y(); y++)
1968                         for (int x = 0; x < imageSize.x(); x++)
1969                                 imageData.setPixel(x, y, z, initial);
1970                 }
1971
1972                 // Upload initial pattern to endResultTexture and bind to image.
1973
1974                 glLog.glActiveTexture(GL_TEXTURE0);
1975                 glLog.glBindTexture(textureTargetGL, *endResultTexture);
1976                 setTexParameteri(glLog, textureTargetGL);
1977
1978                 log << TestLog::Message << "// Filling end-result texture with initial pattern (initial value " << getOperationInitialValue(m_operation) << ")" << TestLog::EndMessage;
1979
1980                 uploadTexture(glLog, imageData, *endResultTextureBuf);
1981         }
1982
1983         glLog.glBindImageTexture(0, *endResultTexture, 0, GL_TRUE, 0, GL_READ_WRITE, internalFormatGL);
1984         GLU_EXPECT_NO_ERROR(renderCtx.getFunctions().getError(), "glBindImageTexture");
1985
1986         if (m_caseType == ATOMIC_OPERATION_CASE_TYPE_RETURN_VALUES)
1987         {
1988                 // Set storage for returnValueTexture and bind to image.
1989
1990                 glLog.glActiveTexture(GL_TEXTURE1);
1991                 glLog.glBindTexture(textureTargetGL, *returnValueTexture);
1992                 setTexParameteri(glLog, textureTargetGL);
1993
1994                 log << TestLog::Message << "// Setting storage of return-value texture" << TestLog::EndMessage;
1995                 setTextureStorage(glLog, m_imageType, internalFormatGL, imageSize * (m_imageType == TEXTURETYPE_CUBE ? IVec3(NUM_INVOCATIONS_PER_PIXEL, NUM_INVOCATIONS_PER_PIXEL,      1)
1996                                                                                                                                                                                                                          : IVec3(NUM_INVOCATIONS_PER_PIXEL, 1,                                                  1)),
1997                                                   *returnValueTextureBuf);
1998
1999                 glLog.glBindImageTexture(1, *returnValueTexture, 0, GL_TRUE, 0, GL_WRITE_ONLY, internalFormatGL);
2000                 GLU_EXPECT_NO_ERROR(renderCtx.getFunctions().getError(), "glBindImageTexture");
2001         }
2002
2003         // Perform image stores in compute shader and finalize reference computation.
2004
2005         {
2006                 // Generate compute shader.
2007
2008                 const string colorVecTypeName           = string(isUintFormat ? "u" : isIntFormat ? "i" : "") + "vec4";
2009                 const string atomicCoord                        = m_imageType == TEXTURETYPE_BUFFER             ? "gx % " + toString(imageSize.x())
2010                                                                                         : m_imageType == TEXTURETYPE_2D                 ? "ivec2(gx % " + toString(imageSize.x()) + ", gy)"
2011                                                                                         : "ivec3(gx % " + toString(imageSize.x()) + ", gy, gz)";
2012                 const string invocationCoord            = m_imageType == TEXTURETYPE_BUFFER             ? "gx"
2013                                                                                         : m_imageType == TEXTURETYPE_2D                 ? "ivec2(gx, gy)"
2014                                                                                         : "ivec3(gx, gy, gz)";
2015                 const string atomicArgExpr                      = (isUintFormat         ? "uint"
2016                                                                                          : isIntFormat          ? ""
2017                                                                                          : "float")
2018                                                                                                 + getAtomicFuncArgumentShaderStr(m_operation, "gx", "gy", "gz", IVec2(NUM_INVOCATIONS_PER_PIXEL*imageSize.x(), imageSize.y()));
2019                 const string atomicInvocation           = string() + getAtomicOperationShaderFuncName(m_operation) + "(u_results, " + atomicCoord + ", " + atomicArgExpr + ")";
2020                 const string shaderImageFormatStr       = getShaderImageFormatQualifier(m_format);
2021                 const string shaderImageTypeStr         = getShaderImageType(m_format.type, m_imageType);
2022                 const std::string               glslVersionDeclaration  = glu::getGLSLVersionDeclaration(glu::getContextTypeGLSLVersion(renderCtx.getType()));
2023
2024                 const glu::ShaderProgram program(renderCtx,
2025                         glu::ProgramSources() << glu::ComputeSource(glslVersionDeclaration + "\n"
2026                                                                                                                 + imageAtomicExtensionShaderRequires(renderCtx)
2027                                                                                                                 + textureTypeExtensionShaderRequires(m_imageType, renderCtx) +
2028                                                                                                                 "\n"
2029                                                                                                                 "precision highp " + shaderImageTypeStr + ";\n"
2030                                                                                                                 "\n"
2031                                                                                                                 "layout (local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n"
2032                                                                                                                 "layout (" + shaderImageFormatStr + ", binding=0) coherent uniform " + shaderImageTypeStr + " u_results;\n"
2033                                                                                                                 + (m_caseType == ATOMIC_OPERATION_CASE_TYPE_RETURN_VALUES ?
2034                                                                                                                           "layout (" + shaderImageFormatStr + ", binding=1) writeonly uniform " + shaderImageTypeStr + " u_returnValues;\n"
2035                                                                                                                         : "") +
2036                                                                                                                 "\n"
2037                                                                                                                 "void main (void)\n"
2038                                                                                                                 "{\n"
2039                                                                                                                 "       int gx = int(gl_GlobalInvocationID.x);\n"
2040                                                                                                                 "       int gy = int(gl_GlobalInvocationID.y);\n"
2041                                                                                                                 "       int gz = int(gl_GlobalInvocationID.z);\n"
2042                                                                                                                 + (m_caseType == ATOMIC_OPERATION_CASE_TYPE_RETURN_VALUES ?
2043                                                                                                                         "       imageStore(u_returnValues, " + invocationCoord + ", " + colorVecTypeName + "(" + atomicInvocation + "));\n"
2044                                                                                                                  : m_caseType == ATOMIC_OPERATION_CASE_TYPE_END_RESULT ?
2045                                                                                                                         "       " + atomicInvocation + ";\n"
2046                                                                                                                  : DE_NULL) +
2047                                                                                                                 "}\n"));
2048
2049                 UniformAccessLogger uniforms(renderCtx.getFunctions(), log, program.getProgram());
2050
2051                 log << program;
2052
2053                 if (!program.isOk())
2054                 {
2055                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Program compilation failed");
2056                         return STOP;
2057                 }
2058
2059                 // Setup and dispatch.
2060
2061                 glLog.glUseProgram(program.getProgram());
2062
2063                 glLog.glDispatchCompute(NUM_INVOCATIONS_PER_PIXEL*imageSize.x(), imageSize.y(), numSlicesOrFaces);
2064                 GLU_EXPECT_NO_ERROR(renderCtx.getFunctions().getError(), "glDispatchCompute");
2065         }
2066
2067         // Read texture and check.
2068
2069         {
2070                 const deUint32                                                          textureToCheckGL        = m_caseType == ATOMIC_OPERATION_CASE_TYPE_END_RESULT           ? *endResultTexture
2071                                                                                                                                                 : m_caseType == ATOMIC_OPERATION_CASE_TYPE_RETURN_VALUES        ? *returnValueTexture
2072                                                                                                                                                 : (deUint32)-1;
2073                 const deUint32                                                          textureToCheckBufGL     = m_caseType == ATOMIC_OPERATION_CASE_TYPE_END_RESULT           ? *endResultTextureBuf
2074                                                                                                                                                 : m_caseType == ATOMIC_OPERATION_CASE_TYPE_RETURN_VALUES        ? *returnValueTextureBuf
2075                                                                                                                                                 : (deUint32)-1;
2076
2077                 const IVec3                                                                     textureToCheckSize      = imageSize * IVec3(m_caseType == ATOMIC_OPERATION_CASE_TYPE_END_RESULT ? 1 : NUM_INVOCATIONS_PER_PIXEL, 1, 1);
2078                 const UniquePtr<const ImageLayerVerifier>       verifier                        (m_caseType == ATOMIC_OPERATION_CASE_TYPE_END_RESULT            ? new EndResultVerifier(m_operation, m_imageType)
2079                                                                                                                                            : m_caseType == ATOMIC_OPERATION_CASE_TYPE_RETURN_VALUES             ? new ReturnValueVerifier(m_operation, m_imageType, imageSize.swizzle(0, 1))
2080                                                                                                                                            : (ImageLayerVerifier*)DE_NULL);
2081
2082                 if (readTextureAndVerify(renderCtx, glLog, textureToCheckGL, textureToCheckBufGL, m_imageType, m_format, textureToCheckSize, *verifier))
2083                         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
2084                 else
2085                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image verification failed");
2086
2087                 return STOP;
2088         }
2089 }
2090
2091 /*--------------------------------------------------------------------*//*!
2092  * \brief Atomic compSwap operation case.
2093  *
2094  * Similar in principle to BinaryAtomicOperationCase, but separated for
2095  * convenience, since the atomic function is somewhat different. Like
2096  * BinaryAtomicOperationCase, this has separate cases for checking end
2097  * result and return values.
2098  *//*--------------------------------------------------------------------*/
2099 class AtomicCompSwapCase : public TestCase
2100 {
2101 public:
2102                                                                         AtomicCompSwapCase              (Context& context, const char* name, const char* description, const TextureFormat& format, TextureType imageType, AtomicOperationCaseType caseType)
2103                 : TestCase              (context, name, description)
2104                 , m_format              (format)
2105                 , m_imageType   (imageType)
2106                 , m_caseType    (caseType)
2107         {
2108                 DE_ASSERT(m_format == TextureFormat(TextureFormat::R, TextureFormat::UNSIGNED_INT32)    ||
2109                                   m_format == TextureFormat(TextureFormat::R, TextureFormat::SIGNED_INT32));
2110         }
2111
2112         void                                                    init                                    (void);
2113         IterateResult                                   iterate                                 (void);
2114
2115 private:
2116         class EndResultVerifier;
2117         class ReturnValueVerifier;
2118
2119         static int                                              getCompareArg                   (const IVec3& invocationID, int imageWidth);
2120         static int                                              getAssignArg                    (const IVec3& invocationID, int imageWidth);
2121         static string                                   getCompareArgShaderStr  (const string& x, const string& y, const string& z, int imageWidth);
2122         static string                                   getAssignArgShaderStr   (const string& x, const string& y, const string& z, int imageWidth);
2123
2124         static const int                                NUM_INVOCATIONS_PER_PIXEL = 5;
2125
2126         const TextureFormat                             m_format;
2127         const TextureType                               m_imageType;
2128         const AtomicOperationCaseType   m_caseType;
2129 };
2130
2131 int AtomicCompSwapCase::getCompareArg (const IVec3& invocationID, int imageWidth)
2132 {
2133         const int x                                                     = invocationID.x();
2134         const int y                                                     = invocationID.y();
2135         const int z                                                     = invocationID.z();
2136         const int wrapX                                         = x % imageWidth;
2137         const int curPixelInvocationNdx         = x / imageWidth;
2138
2139         return wrapX*wrapX + y*y + z*z + curPixelInvocationNdx*42;
2140 }
2141
2142 int AtomicCompSwapCase::getAssignArg (const IVec3& invocationID, int imageWidth)
2143 {
2144         return getCompareArg(IVec3(invocationID.x() + imageWidth, invocationID.y(), invocationID.z()), imageWidth);
2145 }
2146
2147 string AtomicCompSwapCase::getCompareArgShaderStr (const string& x, const string& y, const string& z, int imageWidth)
2148 {
2149         const string wrapX                                      = "(" + x + "%" + toString(imageWidth) + ")";
2150         const string curPixelInvocationNdx      = "(" + x + "/" + toString(imageWidth) + ")";
2151
2152         return "(" +wrapX+"*"+wrapX+ " + " +y+"*"+y+ " + " +z+"*"+z+ " + " + curPixelInvocationNdx + "*42)";
2153 }
2154
2155 string AtomicCompSwapCase::getAssignArgShaderStr (const string& x, const string& y, const string& z, int imageWidth)
2156 {
2157         const string wrapX                                      = "(" + x + "%" + toString(imageWidth) + ")";
2158         const string curPixelInvocationNdx      = "(" + x + "/" + toString(imageWidth) + " + 1)";
2159
2160         return "(" +wrapX+"*"+wrapX+ " + " +y+"*"+y+ " + " +z+"*"+z+ " + " + curPixelInvocationNdx + "*42)";
2161 }
2162
2163 void AtomicCompSwapCase::init (void)
2164 {
2165         if (!m_context.getContextInfo().isExtensionSupported("GL_OES_shader_image_atomic") && !glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2)))
2166                 throw tcu::NotSupportedError("Test requires OES_shader_image_atomic extension");
2167
2168         checkTextureTypeExtensions(m_context.getContextInfo(), m_imageType, m_context.getRenderContext());
2169 }
2170
2171 class AtomicCompSwapCase::EndResultVerifier : public ImageLayerVerifier
2172 {
2173 public:
2174         EndResultVerifier (TextureType imageType, int imageWidth) : m_imageType(imageType), m_imageWidth(imageWidth) {}
2175
2176         bool operator() (TestLog& log, const ConstPixelBufferAccess& resultSlice, int sliceOrFaceNdx) const
2177         {
2178                 DE_ASSERT(isFormatTypeInteger(resultSlice.getFormat().type));
2179                 DE_ASSERT(resultSlice.getWidth() == m_imageWidth);
2180
2181                 log << TestLog::Image("EndResults" + toString(sliceOrFaceNdx),
2182                                                           "Result Values, " + (m_imageType == TEXTURETYPE_CUBE ? "face " + string(glu::getCubeMapFaceName(cubeFaceToGLFace(glslImageFuncZToCubeFace(sliceOrFaceNdx))))
2183                                                                                                                                                                    : "slice " + toString(sliceOrFaceNdx)),
2184                                                           resultSlice);
2185
2186                 for (int y = 0; y < resultSlice.getHeight(); y++)
2187                 for (int x = 0; x < resultSlice.getWidth(); x++)
2188                 {
2189                         // Compute the value-to-assign arguments that were given to the atomic function in the invocations that contribute to this pixel.
2190                         // One of those should be the result.
2191
2192                         const int       result = resultSlice.getPixelInt(x, y).x();
2193                         IVec3           invocationGlobalIDs[NUM_INVOCATIONS_PER_PIXEL];
2194                         int                     assignArgs[NUM_INVOCATIONS_PER_PIXEL];
2195
2196                         for (int i = 0; i < NUM_INVOCATIONS_PER_PIXEL; i++)
2197                         {
2198                                 const IVec3 gid(x + i*resultSlice.getWidth(), y, sliceOrFaceNdx);
2199
2200                                 invocationGlobalIDs[i]  = gid;
2201                                 assignArgs[i]                   = getAssignArg(gid, m_imageWidth);
2202                         }
2203
2204                         {
2205                                 bool matchFound = false;
2206                                 for (int i = 0; i < NUM_INVOCATIONS_PER_PIXEL && !matchFound; i++)
2207                                         matchFound = result == assignArgs[i];
2208
2209                                 if (!matchFound)
2210                                 {
2211                                         log << TestLog::Message << "// Failure: invalid value at pixel " << IVec2(x, y) << ": got " << result << TestLog::EndMessage
2212                                                 << TestLog::Message << "// Note: relevant shader invocation global IDs are " << arrayStr(invocationGlobalIDs) << TestLog::EndMessage
2213                                                 << TestLog::Message << "// Note: expected one of " << arrayStr(assignArgs)
2214                                                                                         << " (those are the values given as the 'data' argument in the invocations that contribute to this pixel)"
2215                                                                                         << TestLog::EndMessage;
2216                                         return false;
2217                                 }
2218                         }
2219                 }
2220
2221                 return true;
2222         }
2223
2224 private:
2225         const TextureType       m_imageType;
2226         const int                       m_imageWidth;
2227 };
2228
2229 class AtomicCompSwapCase::ReturnValueVerifier : public ImageLayerVerifier
2230 {
2231 public:
2232         //! \note endResultImageLayerSize is (width, height) of the image operated on by the atomic ops, and not the size of the image where the return values are stored.
2233         ReturnValueVerifier (TextureType imageType, int endResultImageWidth) : m_imageType(imageType), m_endResultImageWidth(endResultImageWidth) {}
2234
2235         bool operator() (TestLog& log, const ConstPixelBufferAccess& resultSlice, int sliceOrFaceNdx) const
2236         {
2237                 DE_ASSERT(isFormatTypeInteger(resultSlice.getFormat().type));
2238                 DE_ASSERT(resultSlice.getWidth() == NUM_INVOCATIONS_PER_PIXEL*m_endResultImageWidth);
2239
2240                 log << TestLog::Image("ReturnValues" + toString(sliceOrFaceNdx),
2241                                                           "Per-Invocation Return Values, "
2242                                                                    + (m_imageType == TEXTURETYPE_CUBE ? "face " + string(glu::getCubeMapFaceName(cubeFaceToGLFace(glslImageFuncZToCubeFace(sliceOrFaceNdx))))
2243                                                                                                                                           : "slice " + toString(sliceOrFaceNdx)),
2244                                                           resultSlice);
2245
2246                 for (int y = 0; y < resultSlice.getHeight(); y++)
2247                 for (int x = 0; x < m_endResultImageWidth; x++)
2248                 {
2249                         // Get the atomic function args and return values for all the invocations that contribute to the pixel (x, y) in the current end result slice.
2250
2251                         int             returnValues[NUM_INVOCATIONS_PER_PIXEL];
2252                         int             compareArgs[NUM_INVOCATIONS_PER_PIXEL];
2253                         IVec3   invocationGlobalIDs[NUM_INVOCATIONS_PER_PIXEL];
2254                         IVec2   pixelCoords[NUM_INVOCATIONS_PER_PIXEL];
2255
2256                         for (int i = 0; i < NUM_INVOCATIONS_PER_PIXEL; i++)
2257                         {
2258                                 const IVec2 pixCoord    (x + i*m_endResultImageWidth, y);
2259                                 const IVec3 gid                 (pixCoord.x(), pixCoord.y(), sliceOrFaceNdx);
2260
2261                                 pixelCoords[i]                  = pixCoord;
2262                                 invocationGlobalIDs[i]  = gid;
2263                                 returnValues[i]                 = resultSlice.getPixelInt(gid.x(), y).x();
2264                                 compareArgs[i]                  = getCompareArg(gid, m_endResultImageWidth);
2265                         }
2266
2267                         // Verify that the return values form a valid sequence.
2268                         // Due to the way the compare and assign arguments to the atomic calls are organized
2269                         // among the different invocations contributing to the same pixel -- i.e. one invocation
2270                         // compares to A and assigns B, another compares to B and assigns C, and so on, where
2271                         // A<B<C etc -- the first value in the return value sequence must be A, and each following
2272                         // value must be either the same as or the smallest value (among A, B, C, ...) bigger than
2273                         // the one just before it. E.g. sequences A A A A A A A A, A B C D E F G H and
2274                         // A A B B B C D E are all valid sequences (if there were 8 invocations contributing
2275                         // to each pixel).
2276
2277                         {
2278                                 int failingNdx = -1;
2279
2280                                 {
2281                                         int currentAtomicValueNdx = 0;
2282                                         for (int i = 0; i < NUM_INVOCATIONS_PER_PIXEL; i++)
2283                                         {
2284                                                 if (returnValues[i] == compareArgs[currentAtomicValueNdx])
2285                                                         continue;
2286                                                 if (i > 0 && returnValues[i] == compareArgs[currentAtomicValueNdx+1])
2287                                                 {
2288                                                         currentAtomicValueNdx++;
2289                                                         continue;
2290                                                 }
2291                                                 failingNdx = i;
2292                                                 break;
2293                                         }
2294                                 }
2295
2296                                 if (failingNdx >= 0)
2297                                 {
2298                                         log << TestLog::Message << "// Failure: intermediate return values at pixels " << arrayStr(pixelCoords) << " of current layer are "
2299                                                                                         << arrayStr(returnValues) << TestLog::EndMessage
2300                                                 << TestLog::Message << "// Note: relevant shader invocation global IDs are " << arrayStr(invocationGlobalIDs) << TestLog::EndMessage
2301                                                 << TestLog::Message << "// Note: 'compare' argument values for the IDs are " << arrayStr(compareArgs) << TestLog::EndMessage
2302                                                 << TestLog::Message << "// Note: expected the return value sequence to fulfill the following conditions:\n"
2303                                                                                         << "// - first value is " << compareArgs[0] << "\n"
2304                                                                                         << "// - each value other than the first is either the same as the one just before it, or the smallest value (in the sequence "
2305                                                                                         << arrayStr(compareArgs) << ") bigger than the one just before it" << TestLog::EndMessage;
2306                                         if (failingNdx == 0)
2307                                                 log << TestLog::Message << "// Note: the first return value (" << returnValues[0] << ") isn't " << compareArgs[0] << TestLog::EndMessage;
2308                                         else
2309                                                 log << TestLog::Message << "// Note: the return value at index " << failingNdx << " (value " << returnValues[failingNdx] << ") "
2310                                                                                                 << "is neither " << returnValues[failingNdx-1] << " (the one just before it) "
2311                                                                                                 << "nor " << compareArgs[arrayIndexOf(compareArgs, returnValues[failingNdx-1])+1] << " (the smallest value bigger than the one just before it)"
2312                                                                                                 << TestLog::EndMessage;
2313
2314                                         return false;
2315                                 }
2316                         }
2317                 }
2318
2319                 return true;
2320         }
2321
2322 private:
2323         const TextureType       m_imageType;
2324         const int                       m_endResultImageWidth;
2325 };
2326
2327 AtomicCompSwapCase::IterateResult AtomicCompSwapCase::iterate (void)
2328 {
2329         const RenderContext&            renderCtx                               = m_context.getRenderContext();
2330         TestLog&                                        log                                             (m_testCtx.getLog());
2331         glu::CallLogWrapper                     glLog                                   (renderCtx.getFunctions(), log);
2332         const deUint32                          internalFormatGL                = glu::getInternalFormat(m_format);
2333         const deUint32                          textureTargetGL                 = getGLTextureTarget(m_imageType);
2334         const IVec3&                            imageSize                               = defaultImageSize(m_imageType);
2335         const int                                       numSlicesOrFaces                = m_imageType == TEXTURETYPE_CUBE ? 6 : imageSize.z();
2336         const bool                                      isUintFormat                    = isFormatTypeUnsignedInteger(m_format.type);
2337         const bool                                      isIntFormat                             = isFormatTypeSignedInteger(m_format.type);
2338         const glu::Buffer                       endResultTextureBuf             (renderCtx);
2339         const glu::Buffer                       returnValueTextureBuf   (renderCtx);
2340         const glu::Texture                      endResultTexture                (renderCtx); //!< Texture for the final result; i.e. the texture on which the atomic operations are done. Size imageSize.
2341         const glu::Texture                      returnValueTexture              (renderCtx); //!< Texture into which the return values are stored if m_caseType == CASETYPE_RETURN_VALUES.
2342                                                                                                                                          //       Size imageSize*IVec3(N, 1, 1) or, for cube maps, imageSize*IVec3(N, N, 1) where N is NUM_INVOCATIONS_PER_PIXEL.
2343
2344         DE_ASSERT(isUintFormat || isIntFormat);
2345
2346         glLog.enableLogging(true);
2347
2348         // Setup textures.
2349
2350         log << TestLog::Message << "// Created a texture (name " << *endResultTexture << ") to act as the target of atomic operations" << TestLog::EndMessage;
2351         if (m_imageType == TEXTURETYPE_BUFFER)
2352                 log << TestLog::Message << "// Created a buffer for the texture (name " << *endResultTextureBuf << ")" << TestLog::EndMessage;
2353
2354         if (m_caseType == ATOMIC_OPERATION_CASE_TYPE_RETURN_VALUES)
2355         {
2356                 log << TestLog::Message << "// Created a texture (name " << *returnValueTexture << ") to which the intermediate return values of the atomic operation are stored" << TestLog::EndMessage;
2357                 if (m_imageType == TEXTURETYPE_BUFFER)
2358                         log << TestLog::Message << "// Created a buffer for the texture (name " << *returnValueTextureBuf << ")" << TestLog::EndMessage;
2359         }
2360
2361         // Fill endResultTexture with initial pattern.
2362
2363         {
2364                 const LayeredImage imageData(m_imageType, m_format, imageSize.x(), imageSize.y(), imageSize.z());
2365
2366                 {
2367                         for (int z = 0; z < numSlicesOrFaces; z++)
2368                         for (int y = 0; y < imageSize.y(); y++)
2369                         for (int x = 0; x < imageSize.x(); x++)
2370                                 imageData.setPixel(x, y, z, IVec4(getCompareArg(IVec3(x, y, z), imageSize.x())));
2371                 }
2372
2373                 // Upload initial pattern to endResultTexture and bind to image.
2374
2375                 glLog.glActiveTexture(GL_TEXTURE0);
2376                 glLog.glBindTexture(textureTargetGL, *endResultTexture);
2377                 setTexParameteri(glLog, textureTargetGL);
2378
2379                 log << TestLog::Message << "// Filling end-result texture with initial pattern" << TestLog::EndMessage;
2380
2381                 uploadTexture(glLog, imageData, *endResultTextureBuf);
2382         }
2383
2384         glLog.glBindImageTexture(0, *endResultTexture, 0, GL_TRUE, 0, GL_READ_WRITE, internalFormatGL);
2385         GLU_EXPECT_NO_ERROR(renderCtx.getFunctions().getError(), "glBindImageTexture");
2386
2387         if (m_caseType == ATOMIC_OPERATION_CASE_TYPE_RETURN_VALUES)
2388         {
2389                 // Set storage for returnValueTexture and bind to image.
2390
2391                 glLog.glActiveTexture(GL_TEXTURE1);
2392                 glLog.glBindTexture(textureTargetGL, *returnValueTexture);
2393                 setTexParameteri(glLog, textureTargetGL);
2394
2395                 log << TestLog::Message << "// Setting storage of return-value texture" << TestLog::EndMessage;
2396                 setTextureStorage(glLog, m_imageType, internalFormatGL, imageSize * (m_imageType == TEXTURETYPE_CUBE ? IVec3(NUM_INVOCATIONS_PER_PIXEL, NUM_INVOCATIONS_PER_PIXEL,      1)
2397                                                                                                                                                                                                                          : IVec3(NUM_INVOCATIONS_PER_PIXEL, 1,                                                  1)),
2398                                                   *returnValueTextureBuf);
2399
2400                 glLog.glBindImageTexture(1, *returnValueTexture, 0, GL_TRUE, 0, GL_WRITE_ONLY, internalFormatGL);
2401                 GLU_EXPECT_NO_ERROR(renderCtx.getFunctions().getError(), "glBindImageTexture");
2402         }
2403
2404         // Perform atomics in compute shader.
2405
2406         {
2407                 // Generate compute shader.
2408
2409                 const string colorScalarTypeName        = isUintFormat ? "uint" : isIntFormat ? "int" : DE_NULL;
2410                 const string colorVecTypeName           = string(isUintFormat ? "u" : isIntFormat ? "i" : DE_NULL) + "vec4";
2411                 const string atomicCoord                        = m_imageType == TEXTURETYPE_BUFFER             ? "gx % " + toString(imageSize.x())
2412                                                                                         : m_imageType == TEXTURETYPE_2D                 ? "ivec2(gx % " + toString(imageSize.x()) + ", gy)"
2413                                                                                         : "ivec3(gx % " + toString(imageSize.x()) + ", gy, gz)";
2414                 const string invocationCoord            = m_imageType == TEXTURETYPE_BUFFER             ? "gx"
2415                                                                                         : m_imageType == TEXTURETYPE_2D                 ? "ivec2(gx, gy)"
2416                                                                                         : "ivec3(gx, gy, gz)";
2417                 const string shaderImageFormatStr       = getShaderImageFormatQualifier(m_format);
2418                 const string shaderImageTypeStr         = getShaderImageType(m_format.type, m_imageType);
2419                 const string glslVersionDeclaration     = glu::getGLSLVersionDeclaration(glu::getContextTypeGLSLVersion(renderCtx.getType()));
2420
2421                 const glu::ShaderProgram program(renderCtx,
2422                         glu::ProgramSources() << glu::ComputeSource(glslVersionDeclaration + "\n"
2423                                                                                                                 + imageAtomicExtensionShaderRequires(renderCtx)
2424                                                                                                                 + textureTypeExtensionShaderRequires(m_imageType, renderCtx) +
2425                                                                                                                 "\n"
2426                                                                                                                 "precision highp " + shaderImageTypeStr + ";\n"
2427                                                                                                                 "\n"
2428                                                                                                                 "layout (local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n"
2429                                                                                                                 "layout (" + shaderImageFormatStr + ", binding=0) coherent uniform " + shaderImageTypeStr + " u_results;\n"
2430                                                                                                                 + (m_caseType == ATOMIC_OPERATION_CASE_TYPE_RETURN_VALUES ?
2431                                                                                                                           "layout (" + shaderImageFormatStr + ", binding=1) writeonly uniform " + shaderImageTypeStr + " u_returnValues;\n"
2432                                                                                                                         : "") +
2433                                                                                                                 "\n"
2434                                                                                                                 "void main (void)\n"
2435                                                                                                                 "{\n"
2436                                                                                                                 "       int gx = int(gl_GlobalInvocationID.x);\n"
2437                                                                                                                 "       int gy = int(gl_GlobalInvocationID.y);\n"
2438                                                                                                                 "       int gz = int(gl_GlobalInvocationID.z);\n"
2439                                                                                                                 "       " + colorScalarTypeName + " compare = " + colorScalarTypeName + getCompareArgShaderStr("gx", "gy", "gz", imageSize.x()) + ";\n"
2440                                                                                                                 "       " + colorScalarTypeName + " data    = " + colorScalarTypeName + getAssignArgShaderStr("gx", "gy", "gz", imageSize.x()) + ";\n"
2441                                                                                                                 "       " + colorScalarTypeName + " status  = " + colorScalarTypeName + "(-1);\n"
2442                                                                                                                 "       status = imageAtomicCompSwap(u_results, " + atomicCoord + ", compare, data);\n"
2443                                                                                                                 + (m_caseType == ATOMIC_OPERATION_CASE_TYPE_RETURN_VALUES ?
2444                                                                                                                         "       imageStore(u_returnValues, " + invocationCoord + ", " + colorVecTypeName + "(status));\n" :
2445                                                                                                                         "") +
2446                                                                                                                 "}\n"));
2447
2448                 UniformAccessLogger uniforms(renderCtx.getFunctions(), log, program.getProgram());
2449
2450                 log << program;
2451
2452                 if (!program.isOk())
2453                 {
2454                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Program compilation failed");
2455                         return STOP;
2456                 }
2457
2458                 // Setup and dispatch.
2459
2460                 glLog.glUseProgram(program.getProgram());
2461
2462                 glLog.glDispatchCompute(NUM_INVOCATIONS_PER_PIXEL*imageSize.x(), imageSize.y(), numSlicesOrFaces);
2463                 GLU_EXPECT_NO_ERROR(renderCtx.getFunctions().getError(), "glDispatchCompute");
2464         }
2465
2466         // Create reference, read texture and compare.
2467
2468         {
2469                 const deUint32                                                          textureToCheckGL        = m_caseType == ATOMIC_OPERATION_CASE_TYPE_END_RESULT           ? *endResultTexture
2470                                                                                                                                                 : m_caseType == ATOMIC_OPERATION_CASE_TYPE_RETURN_VALUES        ? *returnValueTexture
2471                                                                                                                                                 : (deUint32)-1;
2472
2473                 const deUint32                                                          textureToCheckBufGL     = m_caseType == ATOMIC_OPERATION_CASE_TYPE_END_RESULT           ? *endResultTextureBuf
2474                                                                                                                                                 : m_caseType == ATOMIC_OPERATION_CASE_TYPE_RETURN_VALUES        ? *returnValueTextureBuf
2475                                                                                                                                                 : (deUint32)-1;
2476
2477                 // The relevant region of the texture being checked (potentially
2478                 // different from actual texture size for cube maps, because cube maps
2479                 // may have unused pixels due to square size restriction).
2480                 const IVec3                                                                     relevantRegion          = imageSize * (m_caseType == ATOMIC_OPERATION_CASE_TYPE_END_RESULT      ? IVec3(1,                                                      1,                                                      1)
2481                                                                                                                                                                          :                                                                                                                IVec3(NUM_INVOCATIONS_PER_PIXEL,      1,                                                      1));
2482
2483                 const UniquePtr<const ImageLayerVerifier>       verifier                        (m_caseType == ATOMIC_OPERATION_CASE_TYPE_END_RESULT            ? new EndResultVerifier(m_imageType, imageSize.x())
2484                                                                                                                                            : m_caseType == ATOMIC_OPERATION_CASE_TYPE_RETURN_VALUES             ? new ReturnValueVerifier(m_imageType, imageSize.x())
2485                                                                                                                                            : (ImageLayerVerifier*)DE_NULL);
2486
2487                 if (readTextureAndVerify(renderCtx, glLog, textureToCheckGL, textureToCheckBufGL, m_imageType, m_format, relevantRegion, *verifier))
2488                         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
2489                 else
2490                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image verification failed");
2491
2492                 return STOP;
2493         }
2494 }
2495
2496 //! Case testing the "coherent" or "volatile" qualifier, along with memoryBarrier() and barrier().
2497 class CoherenceCase : public TestCase
2498 {
2499 public:
2500         enum Qualifier
2501         {
2502                 QUALIFIER_COHERENT = 0,
2503                 QUALIFIER_VOLATILE,
2504
2505                 QUALIFIER_LAST
2506         };
2507
2508         CoherenceCase (Context& context, const char* name, const char* description, const TextureFormat& format, TextureType imageType, Qualifier qualifier)
2509                 : TestCase              (context, name, description)
2510                 , m_format              (format)
2511                 , m_imageType   (imageType)
2512                 , m_qualifier   (qualifier)
2513         {
2514                 DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(CoherenceCase::SHADER_READ_OFFSETS_Y) == DE_LENGTH_OF_ARRAY(CoherenceCase::SHADER_READ_OFFSETS_X) &&
2515                                                  DE_LENGTH_OF_ARRAY(CoherenceCase::SHADER_READ_OFFSETS_Z) == DE_LENGTH_OF_ARRAY(CoherenceCase::SHADER_READ_OFFSETS_X));
2516
2517                 DE_ASSERT(qualifier == QUALIFIER_COHERENT || qualifier == QUALIFIER_VOLATILE);
2518
2519                 DE_ASSERT(m_format == TextureFormat(TextureFormat::R, TextureFormat::UNSIGNED_INT32)    ||
2520                                   m_format == TextureFormat(TextureFormat::R, TextureFormat::SIGNED_INT32)              ||
2521                                   m_format == TextureFormat(TextureFormat::R, TextureFormat::FLOAT));
2522         }
2523
2524         void                    init            (void) { checkTextureTypeExtensions(m_context.getContextInfo(), m_imageType, m_context.getRenderContext()); }
2525         IterateResult   iterate         (void);
2526
2527 private:
2528         static const int                        SHADER_READ_OFFSETS_X[4];
2529         static const int                        SHADER_READ_OFFSETS_Y[4];
2530         static const int                        SHADER_READ_OFFSETS_Z[4];
2531         static const char* const        SHADER_READ_OFFSETS_X_STR;
2532         static const char* const        SHADER_READ_OFFSETS_Y_STR;
2533         static const char* const        SHADER_READ_OFFSETS_Z_STR;
2534
2535         const TextureFormat             m_format;
2536         const TextureType               m_imageType;
2537         const Qualifier                 m_qualifier;
2538 };
2539
2540 const int                       CoherenceCase::SHADER_READ_OFFSETS_X[4]         =               { 1, 4, 7, 10 };
2541 const int                       CoherenceCase::SHADER_READ_OFFSETS_Y[4]         =               { 2, 5, 8, 11 };
2542 const int                       CoherenceCase::SHADER_READ_OFFSETS_Z[4]         =               { 3, 6, 9, 12 };
2543 const char* const       CoherenceCase::SHADER_READ_OFFSETS_X_STR        = "int[]( 1, 4, 7, 10 )";
2544 const char* const       CoherenceCase::SHADER_READ_OFFSETS_Y_STR        = "int[]( 2, 5, 8, 11 )";
2545 const char* const       CoherenceCase::SHADER_READ_OFFSETS_Z_STR        = "int[]( 3, 6, 9, 12 )";
2546
2547 CoherenceCase::IterateResult CoherenceCase::iterate (void)
2548 {
2549         const RenderContext&            renderCtx                                       = m_context.getRenderContext();
2550         TestLog&                                        log                                                     (m_testCtx.getLog());
2551         glu::CallLogWrapper                     glLog                                           (renderCtx.getFunctions(), log);
2552         const deUint32                          internalFormatGL                        = glu::getInternalFormat(m_format);
2553         const deUint32                          textureTargetGL                         = getGLTextureTarget(m_imageType);
2554         const IVec3&                            imageSize                                       = defaultImageSize(m_imageType);
2555         const int                                       numSlicesOrFaces                        = m_imageType == TEXTURETYPE_CUBE ? 6 : imageSize.z();
2556         const bool                                      isUintFormat                            = isFormatTypeUnsignedInteger(m_format.type);
2557         const bool                                      isIntFormat                                     = isFormatTypeSignedInteger(m_format.type);
2558         const char* const                       qualifierName                           = m_qualifier == QUALIFIER_COHERENT ? "coherent"
2559                                                                                                                         : m_qualifier == QUALIFIER_VOLATILE ? "volatile"
2560                                                                                                                         : DE_NULL;
2561         const glu::Buffer                       textureBuf                                      (renderCtx);
2562         const glu::Texture                      texture                                         (renderCtx);
2563         const IVec3                                     numGroups                                       = IVec3(16, de::min(16, imageSize.y()), de::min(2, numSlicesOrFaces));
2564         const IVec3                                     workItemSize                            = IVec3(imageSize.x(), imageSize.y(), numSlicesOrFaces);
2565         const IVec3                                     localSize                                       = workItemSize / numGroups;
2566         const IVec3                                     minReqMaxLocalSize                      = IVec3(128, 128, 64);
2567         const int                                       minReqMaxLocalInvocations       = 128;
2568
2569         DE_ASSERT(workItemSize == localSize*numGroups);
2570         DE_ASSERT(tcu::boolAll(tcu::lessThanEqual(localSize, minReqMaxLocalSize)));
2571         DE_ASSERT(localSize.x()*localSize.y()*localSize.z() <= minReqMaxLocalInvocations);
2572         DE_UNREF(minReqMaxLocalSize);
2573         DE_UNREF(minReqMaxLocalInvocations);
2574
2575         glLog.enableLogging(true);
2576
2577         // Setup texture.
2578
2579         log << TestLog::Message << "// Created a texture (name " << *texture << ")" << TestLog::EndMessage;
2580         if (m_imageType == TEXTURETYPE_BUFFER)
2581                 log << TestLog::Message << "// Created a buffer for the texture (name " << *textureBuf << ")" << TestLog::EndMessage;
2582
2583         glLog.glActiveTexture(GL_TEXTURE0);
2584         glLog.glBindTexture(textureTargetGL, *texture);
2585         setTexParameteri(glLog, textureTargetGL);
2586         setTextureStorage(glLog, m_imageType, internalFormatGL, imageSize, *textureBuf);
2587         glLog.glBindImageTexture(0, *texture, 0, GL_TRUE, 0, GL_READ_WRITE, internalFormatGL);
2588         GLU_EXPECT_NO_ERROR(renderCtx.getFunctions().getError(), "glBindImageTexture");
2589
2590         // Perform computations in compute shader.
2591
2592         {
2593                 // Generate compute shader.
2594
2595                 const string            colorVecTypeName                = string(isUintFormat ? "u" : isIntFormat ? "i" : "") + "vec4";
2596                 const char* const       colorScalarTypeName             = isUintFormat ? "uint" : isIntFormat ? "int" : "float";
2597                 const string            invocationCoord                 = m_imageType == TEXTURETYPE_BUFFER             ? "gx"
2598                                                                                                         : m_imageType == TEXTURETYPE_2D                 ? "ivec2(gx, gy)"
2599                                                                                                         : "ivec3(gx, gy, gz)";
2600                 const string            shaderImageFormatStr    = getShaderImageFormatQualifier(m_format);
2601                 const string            shaderImageTypeStr              = getShaderImageType(m_format.type, m_imageType);
2602                 const string            localSizeX                              = de::toString(localSize.x());
2603                 const string            localSizeY                              = de::toString(localSize.y());
2604                 const string            localSizeZ                              = de::toString(localSize.z());
2605                 const std::string       glslVersionDeclaration  = glu::getGLSLVersionDeclaration(glu::getContextTypeGLSLVersion(renderCtx.getType()));
2606
2607
2608                 const glu::ShaderProgram program(renderCtx,
2609                         glu::ProgramSources() << glu::ComputeSource(glslVersionDeclaration + "\n"
2610                                                                                                                 + textureTypeExtensionShaderRequires(m_imageType, renderCtx) +
2611                                                                                                                 "\n"
2612                                                                                                                 "precision highp " + shaderImageTypeStr + ";\n"
2613                                                                                                                 "\n"
2614                                                                                                                 "layout (local_size_x = " + localSizeX
2615                                                                                                                         + ", local_size_y = " + localSizeY
2616                                                                                                                         + ", local_size_z = " + localSizeZ
2617                                                                                                                         + ") in;\n"
2618                                                                                                                 "layout (" + shaderImageFormatStr + ", binding=0) " + qualifierName + " uniform " + shaderImageTypeStr + " u_image;\n"
2619                                                                                                                 "void main (void)\n"
2620                                                                                                                 "{\n"
2621                                                                                                                 "       int gx = int(gl_GlobalInvocationID.x);\n"
2622                                                                                                                 "       int gy = int(gl_GlobalInvocationID.y);\n"
2623                                                                                                                 "       int gz = int(gl_GlobalInvocationID.z);\n"
2624                                                                                                                 "       imageStore(u_image, " + invocationCoord + ", " + colorVecTypeName + "(gx^gy^gz));\n"
2625                                                                                                                 "\n"
2626                                                                                                                 "       memoryBarrier();\n"
2627                                                                                                                 "       barrier();\n"
2628                                                                                                                 "\n"
2629                                                                                                                 "       " + colorScalarTypeName + " sum = " + colorScalarTypeName + "(0);\n"
2630                                                                                                                 "       int groupBaseX = gx/" + localSizeX + "*" + localSizeX + ";\n"
2631                                                                                                                 "       int groupBaseY = gy/" + localSizeY + "*" + localSizeY + ";\n"
2632                                                                                                                 "       int groupBaseZ = gz/" + localSizeZ + "*" + localSizeZ + ";\n"
2633                                                                                                                 "       int xOffsets[] = " + SHADER_READ_OFFSETS_X_STR + ";\n"
2634                                                                                                                 "       int yOffsets[] = " + SHADER_READ_OFFSETS_Y_STR + ";\n"
2635                                                                                                                 "       int zOffsets[] = " + SHADER_READ_OFFSETS_Z_STR + ";\n"
2636                                                                                                                 "       for (int i = 0; i < " + toString(DE_LENGTH_OF_ARRAY(SHADER_READ_OFFSETS_X)) + "; i++)\n"
2637                                                                                                                 "       {\n"
2638                                                                                                                 "               int readX = groupBaseX + (gx + xOffsets[i]) % " + localSizeX + ";\n"
2639                                                                                                                 "               int readY = groupBaseY + (gy + yOffsets[i]) % " + localSizeY + ";\n"
2640                                                                                                                 "               int readZ = groupBaseZ + (gz + zOffsets[i]) % " + localSizeZ + ";\n"
2641                                                                                                                 "               sum += imageLoad(u_image, " + (m_imageType == TEXTURETYPE_BUFFER        ? "readX"
2642                                                                                                                                                                                          : m_imageType == TEXTURETYPE_2D                ? "ivec2(readX, readY)"
2643                                                                                                                                                                                          : "ivec3(readX, readY, readZ)") + ").x;\n"
2644                                                                                                                 "       }\n"
2645                                                                                                                 "\n"
2646                                                                                                                 "       memoryBarrier();\n"
2647                                                                                                                 "       barrier();\n"
2648                                                                                                                 "\n"
2649                                                                                                                 "       imageStore(u_image, " + invocationCoord + ", " + colorVecTypeName + "(sum));\n"
2650                                                                                                                 "}\n"));
2651
2652                 UniformAccessLogger uniforms(renderCtx.getFunctions(), log, program.getProgram());
2653
2654                 log << program;
2655
2656                 if (!program.isOk())
2657                 {
2658                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Program compilation failed");
2659                         return STOP;
2660                 }
2661
2662                 // Setup and dispatch.
2663
2664                 glLog.glUseProgram(program.getProgram());
2665
2666                 glLog.glDispatchCompute(numGroups.x(), numGroups.y(), numGroups.z());
2667                 GLU_EXPECT_NO_ERROR(renderCtx.getFunctions().getError(), "glDispatchCompute");
2668         }
2669
2670         // Create reference, read texture and compare.
2671
2672         {
2673                 LayeredImage reference(m_imageType, m_format, imageSize.x(), imageSize.y(), imageSize.z());
2674
2675                 {
2676                         LayeredImage base(m_imageType, m_format, imageSize.x(), imageSize.y(), imageSize.z());
2677                         for (int z = 0; z < numSlicesOrFaces; z++)
2678                         for (int y = 0; y < imageSize.y(); y++)
2679                         for (int x = 0; x < imageSize.x(); x++)
2680                                 base.setPixel(x, y, z, IVec4(x^y^z));
2681
2682                         for (int z = 0; z < numSlicesOrFaces; z++)
2683                         for (int y = 0; y < imageSize.y(); y++)
2684                         for (int x = 0; x < imageSize.x(); x++)
2685                         {
2686                                 const int       groupBaseX      = x / localSize.x() * localSize.x();
2687                                 const int       groupBaseY      = y / localSize.y() * localSize.y();
2688                                 const int       groupBaseZ      = z / localSize.z() * localSize.z();
2689                                 int                     sum                     = 0;
2690                                 for (int i = 0; i < DE_LENGTH_OF_ARRAY(SHADER_READ_OFFSETS_X); i++)
2691                                         sum += base.getPixelInt(groupBaseX + (x + SHADER_READ_OFFSETS_X[i]) % localSize.x(),
2692                                                                                         groupBaseY + (y + SHADER_READ_OFFSETS_Y[i]) % localSize.y(),
2693                                                                                         groupBaseZ + (z + SHADER_READ_OFFSETS_Z[i]) % localSize.z()).x();
2694
2695                                 reference.setPixel(x, y, z, IVec4(sum));
2696                         }
2697                 }
2698
2699                 if (readTextureAndVerify(renderCtx, glLog, *texture, *textureBuf, m_imageType, m_format, imageSize, ImageLayerComparer(reference)))
2700                         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
2701                 else
2702                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image comparison failed");
2703
2704                 return STOP;
2705         }
2706 }
2707
2708 class R32UIImageSingleValueVerifier : public ImageLayerVerifier
2709 {
2710 public:
2711         R32UIImageSingleValueVerifier (const deUint32 value)                                    : m_min(value), m_max(value)    {}
2712         R32UIImageSingleValueVerifier (const deUint32 min, const deUint32 max)  : m_min(min),   m_max(max)              {}
2713
2714         bool operator() (TestLog& log, const ConstPixelBufferAccess& resultSlice, int) const
2715         {
2716                 DE_ASSERT(resultSlice.getWidth() == 1 && resultSlice.getHeight() == 1 && resultSlice.getDepth() == 1);
2717                 DE_ASSERT(resultSlice.getFormat() == TextureFormat(TextureFormat::R, TextureFormat::UNSIGNED_INT32));
2718
2719                 log << TestLog::Message << "// Note: expecting to get value " << (m_min == m_max ? toString(m_min) : "in range [" + toString(m_min) + ", " + toString(m_max) + "]") << TestLog::EndMessage;
2720
2721                 const deUint32 resultValue = resultSlice.getPixelUint(0, 0).x();
2722                 if (!de::inRange(resultValue, m_min, m_max))
2723                 {
2724                         log << TestLog::Message << "// Failure: got value " << resultValue << TestLog::EndMessage;
2725                         return false;
2726                 }
2727                 else
2728                 {
2729                         log << TestLog::Message << "// Success: got value " << resultValue << TestLog::EndMessage;
2730                         return true;
2731                 }
2732         }
2733
2734 private:
2735         const deUint32 m_min;
2736         const deUint32 m_max;
2737 };
2738
2739 //! Tests the imageSize() GLSL function. Stores result in a 1x1 R32UI image. The image with which imageSize() is called isn't read or written, and
2740 //  can thus be qualifier readonly, writeonly, or both.
2741 class ImageSizeCase : public TestCase
2742 {
2743 public:
2744         enum ImageAccess
2745         {
2746                 IMAGEACCESS_READ_ONLY = 0,
2747                 IMAGEACCESS_WRITE_ONLY,
2748                 IMAGEACCESS_READ_ONLY_WRITE_ONLY,
2749
2750                 IMAGEACCESS_LAST
2751         };
2752
2753         ImageSizeCase (Context& context, const char* name, const char* description, const TextureFormat& format, TextureType imageType, const IVec3& size, ImageAccess imageAccess)
2754                 : TestCase                      (context, name, description)
2755                 , m_format                      (format)
2756                 , m_imageType           (imageType)
2757                 , m_imageSize           (size)
2758                 , m_imageAccess         (imageAccess)
2759         {
2760         }
2761
2762         void                    init            (void) { checkTextureTypeExtensions(m_context.getContextInfo(), m_imageType, m_context.getRenderContext()); }
2763         IterateResult   iterate         (void);
2764
2765 private:
2766         const TextureFormat             m_format;
2767         const TextureType               m_imageType;
2768         const IVec3                             m_imageSize;
2769         const ImageAccess               m_imageAccess;
2770 };
2771
2772 ImageSizeCase::IterateResult ImageSizeCase::iterate (void)
2773 {
2774         const RenderContext&            renderCtx                               = m_context.getRenderContext();
2775         TestLog&                                        log                                             (m_testCtx.getLog());
2776         glu::CallLogWrapper                     glLog                                   (renderCtx.getFunctions(), log);
2777         const deUint32                          internalFormatGL                = glu::getInternalFormat(m_format);
2778         const deUint32                          textureTargetGL                 = getGLTextureTarget(m_imageType);
2779         const glu::Buffer                       mainTextureBuf                  (renderCtx);
2780         const glu::Texture                      mainTexture                             (renderCtx);
2781         const glu::Texture                      shaderOutResultTexture  (renderCtx);
2782
2783         glLog.enableLogging(true);
2784
2785         // Setup textures.
2786
2787         log << TestLog::Message << "// Created a texture (name " << *mainTexture << ")" << TestLog::EndMessage;
2788         if (m_imageType == TEXTURETYPE_BUFFER)
2789                 log << TestLog::Message << "// Created a buffer for the texture (name " << *mainTextureBuf << ")" << TestLog::EndMessage;
2790         log << TestLog::Message << "// Created a texture (name " << *shaderOutResultTexture << ") for storing the shader output" << TestLog::EndMessage;
2791
2792         glLog.glActiveTexture(GL_TEXTURE0);
2793         glLog.glBindTexture(textureTargetGL, *mainTexture);
2794         setTexParameteri(glLog, textureTargetGL);
2795         setTextureStorage(glLog, m_imageType, internalFormatGL, m_imageSize, *mainTextureBuf);
2796         glLog.glBindImageTexture(0, *mainTexture, 0, GL_TRUE, 0, GL_READ_WRITE, internalFormatGL);
2797         GLU_EXPECT_NO_ERROR(renderCtx.getFunctions().getError(), "glBindImageTexture");
2798
2799         glLog.glActiveTexture(GL_TEXTURE1);
2800         glLog.glBindTexture(GL_TEXTURE_2D, *shaderOutResultTexture);
2801         setTexParameteri(glLog, GL_TEXTURE_2D);
2802         setTextureStorage(glLog, TEXTURETYPE_2D, GL_R32UI, IVec3(1, 1, 1), 0 /* always 2d texture, no buffer needed */);
2803         glLog.glBindImageTexture(1, *shaderOutResultTexture, 0, GL_TRUE, 0, GL_WRITE_ONLY, GL_R32UI);
2804         GLU_EXPECT_NO_ERROR(renderCtx.getFunctions().getError(), "glBindImageTexture");
2805
2806         // Read texture size in compute shader.
2807
2808         {
2809                 // Generate compute shader.
2810
2811                 const char* const       shaderImageAccessStr    = m_imageAccess == IMAGEACCESS_READ_ONLY                        ? "readonly"
2812                                                                                                         : m_imageAccess == IMAGEACCESS_WRITE_ONLY                       ? "writeonly"
2813                                                                                                         : m_imageAccess == IMAGEACCESS_READ_ONLY_WRITE_ONLY     ? "readonly writeonly"
2814                                                                                                         : DE_NULL;
2815                 const string            shaderImageFormatStr    = getShaderImageFormatQualifier(m_format);
2816                 const string            shaderImageTypeStr              = getShaderImageType(m_format.type, m_imageType);
2817                 const string            glslVersionDeclaration  = glu::getGLSLVersionDeclaration(glu::getContextTypeGLSLVersion(renderCtx.getType()));
2818
2819                 const glu::ShaderProgram program(renderCtx,
2820                         glu::ProgramSources() << glu::ComputeSource(glslVersionDeclaration + "\n"
2821                                                                                                                 + textureTypeExtensionShaderRequires(m_imageType, renderCtx) +
2822                                                                                                                 "\n"
2823                                                                                                                 "precision highp " + shaderImageTypeStr + ";\n"
2824                                                                                                                 "precision highp uimage2D;\n"
2825                                                                                                                 "\n"
2826                                                                                                                 "layout (local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n"
2827                                                                                                                 "layout (" + shaderImageFormatStr + ", binding=0) " + shaderImageAccessStr + " uniform " + shaderImageTypeStr + " u_image;\n"
2828                                                                                                                 "layout (r32ui, binding=1) writeonly uniform uimage2D u_result;\n"
2829                                                                                                                 "void main (void)\n"
2830                                                                                                                 "{\n"
2831                                                                                                                 + (m_imageType == TEXTURETYPE_BUFFER ?
2832                                                                                                                         "       int result = imageSize(u_image);\n"
2833                                                                                                                  : m_imageType == TEXTURETYPE_2D || m_imageType == TEXTURETYPE_CUBE ?
2834                                                                                                                         "       ivec2 size = imageSize(u_image);\n"
2835                                                                                                                         "       int result = size.y*1000 + size.x;\n"
2836                                                                                                                  : m_imageType == TEXTURETYPE_3D || m_imageType == TEXTURETYPE_2D_ARRAY ?
2837                                                                                                                         "       ivec3 size = imageSize(u_image);\n"
2838                                                                                                                         "       int result = size.z*1000000 + size.y*1000 + size.x;\n"
2839                                                                                                                  : DE_NULL) +
2840                                                                                                                 "       imageStore(u_result, ivec2(0, 0), uvec4(result));\n"
2841                                                                                                                 "}\n"));
2842
2843                 UniformAccessLogger uniforms(renderCtx.getFunctions(), log, program.getProgram());
2844
2845                 log << program;
2846
2847                 if (!program.isOk())
2848                 {
2849                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Program compilation failed");
2850                         return STOP;
2851                 }
2852
2853                 // Setup and dispatch.
2854
2855                 glLog.glUseProgram(program.getProgram());
2856
2857                 glLog.glDispatchCompute(1, 1, 1);
2858                 GLU_EXPECT_NO_ERROR(renderCtx.getFunctions().getError(), "glDispatchCompute");
2859         }
2860
2861         // Read texture and compare to reference.
2862
2863         {
2864                 const deUint32  referenceOutput         = m_imageType == TEXTURETYPE_BUFFER                                                                             ? (deUint32)(                                                                                             m_imageSize.x())
2865                                                                                         : m_imageType == TEXTURETYPE_2D || m_imageType == TEXTURETYPE_CUBE              ? (deUint32)(                                              m_imageSize.y()*1000 + m_imageSize.x())
2866                                                                                         : m_imageType == TEXTURETYPE_3D || m_imageType == TEXTURETYPE_2D_ARRAY  ? (deUint32)(m_imageSize.z()*1000000 + m_imageSize.y()*1000 + m_imageSize.x())
2867                                                                                         : (deUint32)-1;
2868
2869                 if (readIntegerTextureViaFBOAndVerify(renderCtx, glLog, *shaderOutResultTexture, TEXTURETYPE_2D, TextureFormat(TextureFormat::R, TextureFormat::UNSIGNED_INT32),
2870                                                                                           IVec3(1, 1, 1), R32UIImageSingleValueVerifier(referenceOutput)))
2871                         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
2872                 else
2873                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got wrong value");
2874
2875                 return STOP;
2876         }
2877 }
2878
2879 //! Case testing the control over early/late fragment tests.
2880 class EarlyFragmentTestsCase : public TestCase
2881 {
2882 public:
2883         enum TestType
2884         {
2885                 TESTTYPE_DEPTH = 0,
2886                 TESTTYPE_STENCIL,
2887
2888                 TESTTYPE_LAST
2889         };
2890
2891         enum RenderTargetType
2892         {
2893                 RENDERTARGET_DEFAULT = 0,
2894                 RENDERTARGET_FBO,
2895                 RENDERTARGET_FBO_WITHOUT_TEST_ATTACHMENT,
2896
2897                 RENDERTARGET_LAST
2898         };
2899
2900
2901         EarlyFragmentTestsCase (Context& context, const char* name, const char* description, TestType type, bool useEarlyTests, RenderTargetType renderTarget)
2902                 : TestCase                      (context, name, description)
2903                 , m_type                        (type)
2904                 , m_useEarlyTests       (useEarlyTests)
2905                 , m_renderTarget        (renderTarget)
2906         {
2907         }
2908
2909         void init (void)
2910         {
2911                 if (m_context.getContextInfo().getInt(GL_MAX_FRAGMENT_IMAGE_UNIFORMS) == 0)
2912                         throw tcu::NotSupportedError("GL_MAX_FRAGMENT_IMAGE_UNIFORMS is zero");
2913
2914                 if (!m_context.getContextInfo().isExtensionSupported("GL_OES_shader_image_atomic") && !glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2)))
2915                         throw tcu::NotSupportedError("Test requires OES_shader_image_atomic extension");
2916
2917                 if (m_type == TESTTYPE_DEPTH                            &&
2918                         m_renderTarget == RENDERTARGET_DEFAULT  &&
2919                         m_context.getRenderTarget().getDepthBits() == 0)
2920                 {
2921                         throw tcu::NotSupportedError("Test requires depth buffer");
2922                 }
2923
2924                 if (m_type == TESTTYPE_STENCIL                          &&
2925                         m_renderTarget == RENDERTARGET_DEFAULT  &&
2926                         m_context.getRenderTarget().getStencilBits() == 0)
2927                 {
2928                         throw tcu::NotSupportedError("Test requires stencil buffer");
2929                 }
2930
2931                 if (m_renderTarget == RENDERTARGET_DEFAULT      &&
2932                         (m_context.getRenderTarget().getWidth() < RENDER_SIZE || m_context.getRenderTarget().getHeight() < RENDER_SIZE))
2933                         throw tcu::NotSupportedError("Render target must have at least " + toString(RENDER_SIZE) + " width and height");
2934         }
2935
2936         IterateResult iterate (void);
2937
2938 private:
2939         static const int                RENDER_SIZE;
2940
2941         const TestType                  m_type;
2942         const bool                              m_useEarlyTests;
2943         const RenderTargetType  m_renderTarget;
2944 };
2945
2946 const int EarlyFragmentTestsCase::RENDER_SIZE = 32;
2947
2948 EarlyFragmentTestsCase::IterateResult EarlyFragmentTestsCase::iterate (void)
2949 {
2950         const RenderContext&                    renderCtx                       = m_context.getRenderContext();
2951         TestLog&                                                log                                     (m_testCtx.getLog());
2952         glu::CallLogWrapper                             glLog                           (renderCtx.getFunctions(), log);
2953         de::Random                                              rnd                                     (deStringHash(getName()));
2954         const bool                                              expectPartialResult     = m_useEarlyTests && m_renderTarget != RENDERTARGET_FBO_WITHOUT_TEST_ATTACHMENT;
2955         const int                                               viewportWidth           = RENDER_SIZE;
2956         const int                                               viewportHeight          = RENDER_SIZE;
2957         const int                                               viewportX                       = (m_renderTarget == RENDERTARGET_DEFAULT) ? (rnd.getInt(0, renderCtx.getRenderTarget().getWidth() - viewportWidth))    : (0);
2958         const int                                               viewportY                       = (m_renderTarget == RENDERTARGET_DEFAULT) ? (rnd.getInt(0, renderCtx.getRenderTarget().getHeight() - viewportHeight))  : (0);
2959         const glu::Texture                              texture                         (renderCtx);
2960         de::MovePtr<glu::Framebuffer>   fbo;
2961         de::MovePtr<glu::Renderbuffer>  colorAttachment;
2962         de::MovePtr<glu::Renderbuffer>  testAttachment;
2963
2964         glLog.enableLogging(true);
2965
2966         // Setup texture.
2967
2968         log << TestLog::Message << "// Created a texture (name " << *texture << ")" << TestLog::EndMessage;
2969
2970         glLog.glActiveTexture(GL_TEXTURE0);
2971         glLog.glBindTexture(GL_TEXTURE_2D, *texture);
2972         setTexParameteri(glLog, GL_TEXTURE_2D);
2973         {
2974                 LayeredImage src(TEXTURETYPE_2D, TextureFormat(TextureFormat::R, TextureFormat::UNSIGNED_INT32), 1, 1, 1);
2975                 src.setPixel(0, 0, 0, IVec4(0));
2976                 uploadTexture(glLog, src, 0 /* always 2d texture, no buffer needed */);
2977         }
2978         glLog.glBindImageTexture(0, *texture, 0, GL_TRUE, 0, GL_READ_WRITE, GL_R32UI);
2979         GLU_EXPECT_NO_ERROR(renderCtx.getFunctions().getError(), "glBindImageTexture");
2980
2981         // Set up framebuffer
2982         if (m_renderTarget == RENDERTARGET_FBO ||
2983                 m_renderTarget == RENDERTARGET_FBO_WITHOUT_TEST_ATTACHMENT)
2984         {
2985                 fbo                             = de::MovePtr<glu::Framebuffer>(new glu::Framebuffer(renderCtx));
2986                 colorAttachment = de::MovePtr<glu::Renderbuffer>(new glu::Renderbuffer(renderCtx));
2987                 testAttachment  = de::MovePtr<glu::Renderbuffer>(new glu::Renderbuffer(renderCtx));
2988
2989                 glLog.glBindRenderbuffer(GL_RENDERBUFFER, **colorAttachment);
2990                 glLog.glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, RENDER_SIZE, RENDER_SIZE);
2991                 GLU_EXPECT_NO_ERROR(renderCtx.getFunctions().getError(), "gen color attachment rb");
2992
2993                 glLog.glBindFramebuffer(GL_FRAMEBUFFER, **fbo);
2994                 glLog.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, **colorAttachment);
2995                 GLU_EXPECT_NO_ERROR(renderCtx.getFunctions().getError(), "set fbo color attachment");
2996
2997                 if (m_renderTarget == RENDERTARGET_FBO && m_type == TESTTYPE_DEPTH)
2998                 {
2999                         glLog.glBindRenderbuffer(GL_RENDERBUFFER, **testAttachment);
3000                         glLog.glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, RENDER_SIZE, RENDER_SIZE);
3001                         GLU_EXPECT_NO_ERROR(renderCtx.getFunctions().getError(), "gen depth attachment rb");
3002
3003                         glLog.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, **testAttachment);
3004                         GLU_EXPECT_NO_ERROR(renderCtx.getFunctions().getError(), "set fbo depth attachment");
3005                 }
3006                 else if (m_renderTarget == RENDERTARGET_FBO && m_type == TESTTYPE_STENCIL)
3007                 {
3008                         glLog.glBindRenderbuffer(GL_RENDERBUFFER, **testAttachment);
3009                         glLog.glRenderbufferStorage(GL_RENDERBUFFER, GL_STENCIL_INDEX8, RENDER_SIZE, RENDER_SIZE);
3010                         GLU_EXPECT_NO_ERROR(renderCtx.getFunctions().getError(), "gen stencil attachment rb");
3011
3012                         glLog.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, **testAttachment);
3013                         GLU_EXPECT_NO_ERROR(renderCtx.getFunctions().getError(), "set fbo stencil attachment");
3014                 }
3015
3016                 glLog.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, **colorAttachment);
3017                 GLU_EXPECT_NO_ERROR(renderCtx.getFunctions().getError(), "setup fbo");
3018                 TCU_CHECK(glLog.glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE);
3019         }
3020
3021         // Set up appropriate conditions for the test.
3022
3023         glLog.glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
3024         glLog.glClear(GL_COLOR_BUFFER_BIT);
3025
3026         if (m_type == TESTTYPE_DEPTH)
3027         {
3028                 glLog.glClearDepthf(0.5f);
3029                 glLog.glClear(GL_DEPTH_BUFFER_BIT);
3030                 glLog.glEnable(GL_DEPTH_TEST);
3031         }
3032         else if (m_type == TESTTYPE_STENCIL)
3033         {
3034                 glLog.glClearStencil(0);
3035                 glLog.glClear(GL_STENCIL_BUFFER_BIT);
3036                 glLog.glScissor(viewportX, viewportY, viewportWidth/2, viewportHeight);
3037                 glLog.glEnable(GL_SCISSOR_TEST);
3038                 glLog.glClearStencil(1);
3039                 glLog.glClear(GL_STENCIL_BUFFER_BIT);
3040                 glLog.glDisable(GL_SCISSOR_TEST);
3041                 glLog.glStencilFunc(GL_EQUAL, 1, 1);
3042                 glLog.glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
3043                 glLog.glEnable(GL_STENCIL_TEST);
3044         }
3045         else
3046                 DE_ASSERT(false);
3047
3048         // Perform image stores in fragment shader.
3049
3050         {
3051                 const std::string glslVersionDeclaration = glu::getGLSLVersionDeclaration(glu::getContextTypeGLSLVersion(renderCtx.getType()));
3052
3053                 // Generate fragment shader.
3054
3055                 const glu::ShaderProgram program(renderCtx,
3056                         glu::ProgramSources() << glu::VertexSource(             glslVersionDeclaration + "\n"
3057                                                                                                                         "\n"
3058                                                                                                                         "highp in vec3 a_position;\n"
3059                                                                                                                         "\n"
3060                                                                                                                         "void main (void)\n"
3061                                                                                                                         "{\n"
3062                                                                                                                         "       gl_Position = vec4(a_position, 1.0);\n"
3063                                                                                                                         "}\n")
3064
3065                                                                   << glu::FragmentSource(       glslVersionDeclaration + "\n"
3066                                                                                                                         + imageAtomicExtensionShaderRequires(renderCtx) +
3067                                                                                                                         "\n"
3068                                                                                                                         + string(m_useEarlyTests ? "layout (early_fragment_tests) in;\n\n" : "") +
3069                                                                                                                         "layout (location = 0) out highp vec4 o_color;\n"
3070                                                                                                                         "\n"
3071                                                                                                                         "precision highp uimage2D;\n"
3072                                                                                                                         "\n"
3073                                                                                                                         "layout (r32ui, binding=0) coherent uniform uimage2D u_image;\n"
3074                                                                                                                         "\n"
3075                                                                                                                         "void main (void)\n"
3076                                                                                                                         "{\n"
3077                                                                                                                         "       imageAtomicAdd(u_image, ivec2(0, 0), uint(1));\n"
3078                                                                                                                         "       o_color = vec4(1.0);\n"
3079                                                                                                                         "}\n"));
3080
3081                 UniformAccessLogger uniforms(renderCtx.getFunctions(), log, program.getProgram());
3082
3083                 log << program;
3084
3085                 if (!program.isOk())
3086                 {
3087                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Program compilation failed");
3088                         return STOP;
3089                 }
3090
3091                 // Setup and draw full-viewport quad.
3092
3093                 glLog.glUseProgram(program.getProgram());
3094
3095                 {
3096                         static const float vertexPositions[4*3] =
3097                         {
3098                                 -1.0, -1.0, -1.0f,
3099                                  1.0, -1.0,  0.0f,
3100                                 -1.0,  1.0,  0.0f,
3101                                  1.0,  1.0,  1.0f,
3102                         };
3103
3104                         static const deUint16 indices[6] = { 0, 1, 2, 2, 1, 3 };
3105
3106                         const glu::VertexArrayBinding attrBindings[] =
3107                         {
3108                                 glu::va::Float("a_position", 3, 4, 0, &vertexPositions[0])
3109                         };
3110
3111                         glLog.glViewport(viewportX, viewportY, viewportWidth, viewportHeight);
3112
3113                         glu::draw(renderCtx, program.getProgram(), DE_LENGTH_OF_ARRAY(attrBindings), &attrBindings[0],
3114                                 glu::pr::Triangles(DE_LENGTH_OF_ARRAY(indices), &indices[0]));
3115                         GLU_EXPECT_NO_ERROR(renderCtx.getFunctions().getError(), "Draw failed");
3116                 }
3117         }
3118
3119         // Log rendered result for convenience.
3120         {
3121                 tcu::Surface rendered(viewportWidth, viewportHeight);
3122                 glu::readPixels(renderCtx, viewportX, viewportY, rendered.getAccess());
3123                 log << TestLog::Image("Rendered", "Rendered image", rendered);
3124         }
3125
3126         // Read counter value and check.
3127         {
3128                 const int numSamples            = de::max(1, renderCtx.getRenderTarget().getNumSamples());
3129                 const int expectedCounter       = expectPartialResult ? viewportWidth*viewportHeight/2                          : viewportWidth*viewportHeight;
3130                 const int tolerance                     = expectPartialResult ? de::max(viewportWidth, viewportHeight)*3        : 0;
3131                 const int expectedMin           = de::max(0, expectedCounter - tolerance);
3132                 const int expectedMax           = (expectedCounter + tolerance) * numSamples;
3133
3134                 if (readIntegerTextureViaFBOAndVerify(renderCtx, glLog, *texture, TEXTURETYPE_2D, TextureFormat(TextureFormat::R, TextureFormat::UNSIGNED_INT32),
3135                                                                                           IVec3(1, 1, 1), R32UIImageSingleValueVerifier(expectedMin, expectedMax)))
3136                         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
3137                 else
3138                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got wrong value");
3139
3140                 return STOP;
3141         }
3142 }
3143
3144 } // anonymous
3145
3146 ShaderImageLoadStoreTests::ShaderImageLoadStoreTests (Context& context)
3147         : TestCaseGroup(context, "image_load_store", "Shader Image Load & Store Tests")
3148 {
3149 }
3150
3151 ShaderImageLoadStoreTests::~ShaderImageLoadStoreTests (void)
3152 {
3153 }
3154
3155 void ShaderImageLoadStoreTests::init (void)
3156 {
3157         // Per-image-type tests.
3158
3159         {
3160                 static const TextureType imageTypes[] =
3161                 {
3162                         TEXTURETYPE_2D,
3163                         TEXTURETYPE_CUBE,
3164                         TEXTURETYPE_3D,
3165                         TEXTURETYPE_2D_ARRAY,
3166                         TEXTURETYPE_BUFFER
3167                 };
3168
3169                 static const TextureFormat formats[] =
3170                 {
3171                         TextureFormat(TextureFormat::RGBA,      TextureFormat::FLOAT),
3172                         TextureFormat(TextureFormat::RGBA,      TextureFormat::HALF_FLOAT),
3173                         TextureFormat(TextureFormat::R,         TextureFormat::FLOAT),
3174
3175                         TextureFormat(TextureFormat::RGBA,      TextureFormat::UNSIGNED_INT32),
3176                         TextureFormat(TextureFormat::RGBA,      TextureFormat::UNSIGNED_INT16),
3177                         TextureFormat(TextureFormat::RGBA,      TextureFormat::UNSIGNED_INT8),
3178                         TextureFormat(TextureFormat::R,         TextureFormat::UNSIGNED_INT32),
3179
3180                         TextureFormat(TextureFormat::RGBA,      TextureFormat::SIGNED_INT32),
3181                         TextureFormat(TextureFormat::RGBA,      TextureFormat::SIGNED_INT16),
3182                         TextureFormat(TextureFormat::RGBA,      TextureFormat::SIGNED_INT8),
3183                         TextureFormat(TextureFormat::R,         TextureFormat::SIGNED_INT32),
3184
3185                         TextureFormat(TextureFormat::RGBA,      TextureFormat::UNORM_INT8),
3186
3187                         TextureFormat(TextureFormat::RGBA,      TextureFormat::SNORM_INT8)
3188                 };
3189
3190                 for (int imageTypeNdx = 0; imageTypeNdx < DE_LENGTH_OF_ARRAY(imageTypes); imageTypeNdx++)
3191                 {
3192                         const TextureType               imageType                       = imageTypes[imageTypeNdx];
3193                         TestCaseGroup* const    imageTypeGroup          = new TestCaseGroup(m_context, getTextureTypeName(imageType), "");
3194                         addChild(imageTypeGroup);
3195
3196                         TestCaseGroup* const    storeGroup                      = new TestCaseGroup(m_context, "store",                                 "Plain imageStore() cases");
3197                         TestCaseGroup* const    loadStoreGroup          = new TestCaseGroup(m_context, "load_store",                    "Cases with imageLoad() followed by imageStore()");
3198                         TestCaseGroup* const    atomicGroup                     = new TestCaseGroup(m_context, "atomic",                                "Atomic image operation cases");
3199                         TestCaseGroup* const    qualifierGroup          = new TestCaseGroup(m_context, "qualifiers",                    "Coherent, volatile and restrict");
3200                         TestCaseGroup* const    reinterpretGroup        = new TestCaseGroup(m_context, "format_reinterpret",    "Cases with differing texture and image formats");
3201                         TestCaseGroup* const    imageSizeGroup          = new TestCaseGroup(m_context, "image_size",                    "imageSize() cases");
3202                         imageTypeGroup->addChild(storeGroup);
3203                         imageTypeGroup->addChild(loadStoreGroup);
3204                         imageTypeGroup->addChild(atomicGroup);
3205                         imageTypeGroup->addChild(qualifierGroup);
3206                         imageTypeGroup->addChild(reinterpretGroup);
3207                         imageTypeGroup->addChild(imageSizeGroup);
3208
3209                         for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(formats); formatNdx++)
3210                         {
3211                                 const TextureFormat&    format          = formats[formatNdx];
3212                                 const string                    formatName      = getShaderImageFormatQualifier(formats[formatNdx]);
3213
3214                                 if (imageType == TEXTURETYPE_BUFFER && !isFormatSupportedForTextureBuffer(format))
3215                                         continue;
3216
3217                                 // Store cases.
3218
3219                                 storeGroup->addChild(new ImageStoreCase(m_context, formatName.c_str(), "", format, imageType));
3220                                 if (textureLayerType(imageType) != imageType)
3221                                         storeGroup->addChild(new ImageStoreCase(m_context, (formatName + "_single_layer").c_str(), "", format, imageType, ImageStoreCase::CASEFLAG_SINGLE_LAYER_BIND));
3222
3223                                 // Load & store.
3224
3225                                 loadStoreGroup->addChild(new ImageLoadAndStoreCase(m_context, formatName.c_str(), "", format, imageType));
3226                                 if (textureLayerType(imageType) != imageType)
3227                                         loadStoreGroup->addChild(new ImageLoadAndStoreCase(m_context, (formatName + "_single_layer").c_str(), "", format, imageType, ImageLoadAndStoreCase::CASEFLAG_SINGLE_LAYER_BIND));
3228
3229                                 if (format.order == TextureFormat::R)
3230                                 {
3231                                         // Atomic operations.
3232
3233                                         for (int operationI = 0; operationI < ATOMIC_OPERATION_LAST; operationI++)
3234                                         {
3235                                                 for (int atomicCaseTypeI = 0; atomicCaseTypeI < ATOMIC_OPERATION_CASE_TYPE_LAST; atomicCaseTypeI++)
3236                                                 {
3237                                                         const AtomicOperation operation = (AtomicOperation)operationI;
3238
3239                                                         if (format.type == TextureFormat::FLOAT && operation != ATOMIC_OPERATION_EXCHANGE)
3240                                                                 continue;
3241
3242                                                         const AtomicOperationCaseType   caseType                = (AtomicOperationCaseType)atomicCaseTypeI;
3243                                                         const string                                    caseTypeName    = caseType == ATOMIC_OPERATION_CASE_TYPE_END_RESULT             ? "result"
3244                                                                                                                                                         : caseType == ATOMIC_OPERATION_CASE_TYPE_RETURN_VALUES  ? "return_value"
3245                                                                                                                                                         : DE_NULL;
3246                                                         const string                                    caseName                = string() + getAtomicOperationCaseName(operation) + "_" + formatName + "_" + caseTypeName;
3247
3248                                                         if (operation == ATOMIC_OPERATION_COMP_SWAP)
3249                                                                 atomicGroup->addChild(new AtomicCompSwapCase(m_context, caseName.c_str(), "", format, imageType, caseType));
3250                                                         else
3251                                                                 atomicGroup->addChild(new BinaryAtomicOperationCase(m_context, caseName.c_str(), "", format, imageType, operation, caseType));
3252                                                 }
3253                                         }
3254
3255                                         // Coherence.
3256
3257                                         for (int coherenceQualifierI = 0; coherenceQualifierI < CoherenceCase::QUALIFIER_LAST; coherenceQualifierI++)
3258                                         {
3259                                                 const CoherenceCase::Qualifier  coherenceQualifier              = (CoherenceCase::Qualifier)coherenceQualifierI;
3260                                                 const char* const                               coherenceQualifierName  = coherenceQualifier == CoherenceCase::QUALIFIER_COHERENT ? "coherent"
3261                                                                                                                                                                 : coherenceQualifier == CoherenceCase::QUALIFIER_VOLATILE ? "volatile"
3262                                                                                                                                                                 : DE_NULL;
3263                                                 const string                                    caseName                                = string() + coherenceQualifierName + "_" + formatName;
3264
3265                                                 qualifierGroup->addChild(new CoherenceCase(m_context, caseName.c_str(), "", format, imageType, coherenceQualifier));
3266                                         }
3267                                 }
3268                         }
3269
3270                         // Restrict.
3271                         qualifierGroup->addChild(new ImageLoadAndStoreCase(m_context, "restrict", "", TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT32), imageType, ImageLoadAndStoreCase::CASEFLAG_RESTRICT_IMAGES));
3272
3273                         // Format re-interpretation.
3274
3275                         for (int texFmtNdx = 0; texFmtNdx < DE_LENGTH_OF_ARRAY(formats); texFmtNdx++)
3276                         for (int imgFmtNdx = 0; imgFmtNdx < DE_LENGTH_OF_ARRAY(formats); imgFmtNdx++)
3277                         {
3278                                 const TextureFormat& texFmt = formats[texFmtNdx];
3279                                 const TextureFormat& imgFmt = formats[imgFmtNdx];
3280
3281                                 if (imageType == TEXTURETYPE_BUFFER && !isFormatSupportedForTextureBuffer(texFmt))
3282                                         continue;
3283
3284                                 if (texFmt != imgFmt && texFmt.getPixelSize() == imgFmt.getPixelSize())
3285                                         reinterpretGroup->addChild(new ImageLoadAndStoreCase(m_context,
3286                                                                                                                                                  (getShaderImageFormatQualifier(texFmt) + "_" + getShaderImageFormatQualifier(imgFmt)).c_str(), "",
3287                                                                                                                                                  texFmt, imgFmt, imageType));
3288                         }
3289
3290                         // imageSize().
3291
3292                         {
3293                                 static const IVec3 baseImageSizes[] =
3294                                 {
3295                                         IVec3(32, 32, 32),
3296                                         IVec3(12, 34, 56),
3297                                         IVec3(1,   1,  1),
3298                                         IVec3(7,   1,  1)
3299                                 };
3300
3301                                 for (int imageAccessI = 0; imageAccessI < ImageSizeCase::IMAGEACCESS_LAST; imageAccessI++)
3302                                 {
3303                                         const ImageSizeCase::ImageAccess        imageAccess             = (ImageSizeCase::ImageAccess)imageAccessI;
3304                                         const char* const                                       imageAccessStr  = imageAccess == ImageSizeCase::IMAGEACCESS_READ_ONLY                           ? "readonly"
3305                                                                                                                                                 : imageAccess == ImageSizeCase::IMAGEACCESS_WRITE_ONLY                          ? "writeonly"
3306                                                                                                                                                 : imageAccess == ImageSizeCase::IMAGEACCESS_READ_ONLY_WRITE_ONLY        ? "readonly_writeonly"
3307                                                                                                                                                 : DE_NULL;
3308
3309                                         for (int imageSizeNdx = 0; imageSizeNdx < DE_LENGTH_OF_ARRAY(baseImageSizes); imageSizeNdx++)
3310                                         {
3311                                                 const IVec3&    baseSize        = baseImageSizes[imageSizeNdx];
3312                                                 const IVec3             imageSize       = imageType == TEXTURETYPE_BUFFER               ? IVec3(baseSize.x(), 1, 1)
3313                                                                                                         : imageType == TEXTURETYPE_2D                   ? IVec3(baseSize.x(), baseSize.y(), 1)
3314                                                                                                         : imageType == TEXTURETYPE_CUBE                 ? IVec3(baseSize.x(), baseSize.x(), 1)
3315                                                                                                         : imageType == TEXTURETYPE_3D                   ? baseSize
3316                                                                                                         : imageType == TEXTURETYPE_2D_ARRAY             ? baseSize
3317                                                                                                         : IVec3(-1, -1, -1);
3318
3319                                                 const string    sizeStr         = imageType == TEXTURETYPE_BUFFER               ? toString(imageSize.x())
3320                                                                                                         : imageType == TEXTURETYPE_2D                   ? toString(imageSize.x()) + "x" + toString(imageSize.y())
3321                                                                                                         : imageType == TEXTURETYPE_CUBE                 ? toString(imageSize.x()) + "x" + toString(imageSize.y())
3322                                                                                                         : imageType == TEXTURETYPE_3D                   ? toString(imageSize.x()) + "x" + toString(imageSize.y()) + "x" + toString(imageSize.z())
3323                                                                                                         : imageType == TEXTURETYPE_2D_ARRAY             ? toString(imageSize.x()) + "x" + toString(imageSize.y()) + "x" + toString(imageSize.z())
3324                                                                                                         : DE_NULL;
3325
3326                                                 const string    caseName        = string() + imageAccessStr + "_" + sizeStr;
3327
3328                                                 imageSizeGroup->addChild(new ImageSizeCase(m_context, caseName.c_str(), "", TextureFormat(TextureFormat::RGBA, TextureFormat::FLOAT), imageType, imageSize, imageAccess));
3329                                         }
3330                                 }
3331                         }
3332                 }
3333         }
3334
3335         // early_fragment_tests cases.
3336
3337         {
3338                 TestCaseGroup* const earlyTestsGroup = new TestCaseGroup(m_context, "early_fragment_tests", "");
3339                 addChild(earlyTestsGroup);
3340
3341                 for (int testRenderTargetI = 0; testRenderTargetI < EarlyFragmentTestsCase::RENDERTARGET_LAST; testRenderTargetI++)
3342                 for (int useEarlyTestsI = 0; useEarlyTestsI <= 1; useEarlyTestsI++)
3343                 for (int testTypeI = 0; testTypeI < EarlyFragmentTestsCase::TESTTYPE_LAST; testTypeI++)
3344                 {
3345                         const EarlyFragmentTestsCase::RenderTargetType  targetType              = (EarlyFragmentTestsCase::RenderTargetType)testRenderTargetI;
3346                         const bool                                                                              useEarlyTests   = useEarlyTestsI != 0;
3347                         const EarlyFragmentTestsCase::TestType                  testType                = (EarlyFragmentTestsCase::TestType)testTypeI;
3348
3349                         const string                                                                    testTypeName    = testType == EarlyFragmentTestsCase::TESTTYPE_DEPTH    ? "depth"
3350                                                                                                                                                         : testType == EarlyFragmentTestsCase::TESTTYPE_STENCIL  ? "stencil"
3351                                                                                                                                                         : DE_NULL;
3352
3353                         const string                                                                    targetName              = targetType == EarlyFragmentTestsCase::RENDERTARGET_FBO                                                        ? (std::string("_fbo"))
3354                                                                                                                                                         : targetType == EarlyFragmentTestsCase::RENDERTARGET_FBO_WITHOUT_TEST_ATTACHMENT        ? (std::string("_fbo_with_no_") + testTypeName)
3355                                                                                                                                                         : std::string("");
3356
3357                         const string                                                                    caseName                = string(useEarlyTests ? "" : "no_") + "early_fragment_tests_" + testTypeName + targetName;
3358
3359                         const string                                                                    caseDesc                = string(useEarlyTests ? "Specify" : "Don't specify")
3360                                                                                                                                                         + " early_fragment_tests, use the " + testTypeName + " test"
3361                                                                                                                                                         + ((targetType == EarlyFragmentTestsCase::RENDERTARGET_FBO)                                                             ? (", render to fbo")
3362                                                                                                                                                            : (targetType == EarlyFragmentTestsCase::RENDERTARGET_FBO_WITHOUT_TEST_ATTACHMENT)   ? (", render to fbo without relevant buffer")
3363                                                                                                                                                            : (""));
3364
3365                         earlyTestsGroup->addChild(new EarlyFragmentTestsCase(m_context, caseName.c_str(), caseDesc.c_str(), testType, useEarlyTests, targetType));
3366                 }
3367         }
3368 }
3369
3370 } // Functional
3371 } // gles31
3372 } // deqp