external/vulkancts/modules/vulkan/binding_model/vktBindingShaderAccessTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * Vulkan Conformance Tests
   3  * ------------------------
   4  *
   5  * Copyright (c) 2015 Google Inc.
   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 Binding shader access tests
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "vktBindingShaderAccessTests.hpp"
  25
  26 #include "vktTestCase.hpp"
  27
  28 #include "vkDefs.hpp"
  29 #include "vkRef.hpp"
  30 #include "vkRefUtil.hpp"
  31 #include "vkPlatform.hpp"
  32 #include "vkPrograms.hpp"
  33 #include "vkMemUtil.hpp"
  34 #include "vkBuilderUtil.hpp"
  35 #include "vkQueryUtil.hpp"
  36 #include "vkImageUtil.hpp"
  37 #include "vkTypeUtil.hpp"
  38
  39 #include "tcuVector.hpp"
  40 #include "tcuVectorUtil.hpp"
  41 #include "tcuTexture.hpp"
  42 #include "tcuTextureUtil.hpp"
  43 #include "tcuResultCollector.hpp"
  44 #include "tcuTestLog.hpp"
  45 #include "tcuRGBA.hpp"
  46 #include "tcuSurface.hpp"
  47 #include "tcuImageCompare.hpp"
  48
  49 #include "deUniquePtr.hpp"
  50 #include "deSharedPtr.hpp"
  51 #include "deStringUtil.hpp"
  52 #include "deArrayUtil.hpp"
  53
  54 #include "qpInfo.h"
  55
  56 namespace vkt
  57 {
  58 namespace BindingModel
  59 {
  60 namespace
  61 {
  62
  63 enum ResourceFlag
  64 {
  65         RESOURCE_FLAG_IMMUTABLE_SAMPLER = (1u << 0u),
  66
  67         RESOURCE_FLAG_LAST                              = (1u << 1u)
  68 };
  69
  70 static const char* const s_quadrantGenVertexPosSource = "       highp int quadPhase = gl_VertexIndex % 6;\n"
  71                                                                                                                 "       highp int quadXcoord = int(quadPhase == 1 || quadPhase == 4 || quadPhase == 5);\n"
  72                                                                                                                 "       highp int quadYcoord = int(quadPhase == 2 || quadPhase == 3 || quadPhase == 5);\n"
  73                                                                                                                 "       highp int quadOriginX = (gl_VertexIndex / 6) % 2;\n"
  74                                                                                                                 "       highp int quadOriginY = (gl_VertexIndex / 6) / 2;\n"
  75                                                                                                                 "       quadrant_id = gl_VertexIndex / 6;\n"
  76                                                                                                                 "       result_position = vec4(float(quadOriginX + quadXcoord - 1), float(quadOriginY + quadYcoord - 1), 0.0, 1.0);\n";
  77
  78 bool isUniformDescriptorType (vk::VkDescriptorType type)
  79 {
  80         return type == vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER ||
  81                    type == vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC ||
  82                    type == vk::VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER;
  83 }
  84
  85 bool isDynamicDescriptorType (vk::VkDescriptorType type)
  86 {
  87         return type == vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC || type == vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC;
  88 }
  89
  90 void verifyDriverSupport(const vk::VkPhysicalDeviceFeatures&    deviceFeatures,
  91                                                  vk::VkDescriptorType                                   descType,
  92                                                  vk::VkShaderStageFlags                                 activeStages)
  93 {
  94         switch (descType)
  95         {
  96                 case vk::VK_DESCRIPTOR_TYPE_SAMPLER:
  97                 case vk::VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
  98                 case vk::VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
  99                 case vk::VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
 100                 case vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
 101                 case vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
 102                         // These are supported in all stages
 103                         return;
 104
 105                 case vk::VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
 106                 case vk::VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
 107                 case vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
 108                 case vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
 109                         if (activeStages & (vk::VK_SHADER_STAGE_VERTEX_BIT |
 110                                                                 vk::VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT |
 111                                                                 vk::VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT |
 112                                                                 vk::VK_SHADER_STAGE_GEOMETRY_BIT))
 113                         {
 114                                 if (!deviceFeatures.vertexPipelineStoresAndAtomics)
 115                                         TCU_THROW(NotSupportedError, (de::toString(descType) + " is not supported in the vertex pipeline").c_str());
 116                         }
 117
 118                         if (activeStages & vk::VK_SHADER_STAGE_FRAGMENT_BIT)
 119                         {
 120                                 if (!deviceFeatures.fragmentStoresAndAtomics)
 121                                         TCU_THROW(NotSupportedError, (de::toString(descType) + " is not supported in fragment shaders").c_str());
 122                         }
 123                         return;
 124
 125                 default:
 126                         DE_FATAL("Impossible");
 127         }
 128 }
 129
 130 vk::VkImageType viewTypeToImageType (vk::VkImageViewType type)
 131 {
 132         switch (type)
 133         {
 134                 case vk::VK_IMAGE_VIEW_TYPE_1D:
 135                 case vk::VK_IMAGE_VIEW_TYPE_1D_ARRAY:   return vk::VK_IMAGE_TYPE_1D;
 136                 case vk::VK_IMAGE_VIEW_TYPE_2D:
 137                 case vk::VK_IMAGE_VIEW_TYPE_2D_ARRAY:   return vk::VK_IMAGE_TYPE_2D;
 138                 case vk::VK_IMAGE_VIEW_TYPE_3D:                 return vk::VK_IMAGE_TYPE_3D;
 139                 case vk::VK_IMAGE_VIEW_TYPE_CUBE:
 140                 case vk::VK_IMAGE_VIEW_TYPE_CUBE_ARRAY: return vk::VK_IMAGE_TYPE_2D;
 141
 142                 default:
 143                         DE_FATAL("Impossible");
 144                         return (vk::VkImageType)0;
 145         }
 146 }
 147
 148 vk::VkImageLayout getImageLayoutForDescriptorType (vk::VkDescriptorType descType)
 149 {
 150         if (descType == vk::VK_DESCRIPTOR_TYPE_STORAGE_IMAGE)
 151                 return vk::VK_IMAGE_LAYOUT_GENERAL;
 152         else
 153                 return vk::VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
 154 }
 155
 156 deUint32 getTextureLevelPyramidDataSize (const tcu::TextureLevelPyramid& srcImage)
 157 {
 158         deUint32 dataSize = 0;
 159         for (int level = 0; level < srcImage.getNumLevels(); ++level)
 160         {
 161                 const tcu::ConstPixelBufferAccess srcAccess = srcImage.getLevel(level);
 162
 163                 // tightly packed
 164                 DE_ASSERT(srcAccess.getFormat().getPixelSize() == srcAccess.getPixelPitch());
 165
 166                 dataSize += srcAccess.getWidth() * srcAccess.getHeight() * srcAccess.getDepth() * srcAccess.getFormat().getPixelSize();
 167         }
 168         return dataSize;
 169 }
 170
 171 void writeTextureLevelPyramidData (void* dst, deUint32 dstLen, const tcu::TextureLevelPyramid& srcImage, vk::VkImageViewType viewType, std::vector<vk::VkBufferImageCopy>* copySlices)
 172 {
 173         // \note cube is copied face-by-face
 174         const deUint32  arraySize       = (viewType == vk::VK_IMAGE_VIEW_TYPE_1D || viewType == vk::VK_IMAGE_VIEW_TYPE_1D_ARRAY)                ? (srcImage.getLevel(0).getHeight()) :
 175                                                                   (viewType == vk::VK_IMAGE_VIEW_TYPE_2D || viewType == vk::VK_IMAGE_VIEW_TYPE_2D_ARRAY)                ? (srcImage.getLevel(0).getDepth()) :
 176                                                                   (viewType == vk::VK_IMAGE_VIEW_TYPE_3D)                                                                                                               ? (1) :
 177                                                                   (viewType == vk::VK_IMAGE_VIEW_TYPE_CUBE || viewType == vk::VK_IMAGE_VIEW_TYPE_CUBE_ARRAY)    ? (srcImage.getLevel(0).getDepth()) :
 178                                                                   ((deUint32)0);
 179         deUint32                levelOffset     = 0;
 180
 181         DE_ASSERT(arraySize != 0);
 182
 183         for (int level = 0; level < srcImage.getNumLevels(); ++level)
 184         {
 185                 const tcu::ConstPixelBufferAccess       srcAccess               = srcImage.getLevel(level);
 186                 const tcu::PixelBufferAccess            dstAccess               (srcAccess.getFormat(), srcAccess.getSize(), srcAccess.getPitch(), (deUint8*)dst + levelOffset);
 187                 const deUint32                                          dataSize                = srcAccess.getWidth() * srcAccess.getHeight() * srcAccess.getDepth() * srcAccess.getFormat().getPixelSize();
 188                 const deUint32                                          sliceDataSize   = dataSize / arraySize;
 189                 const deInt32                                           sliceHeight             = (viewType == vk::VK_IMAGE_VIEW_TYPE_1D || viewType == vk::VK_IMAGE_VIEW_TYPE_1D_ARRAY) ? (1) : (srcAccess.getHeight());
 190                 const deInt32                                           sliceDepth              = (viewType == vk::VK_IMAGE_VIEW_TYPE_3D) ? (srcAccess.getDepth()) : (1);
 191                 const tcu::IVec3                                        sliceSize               (srcAccess.getWidth(), sliceHeight, sliceDepth);
 192
 193                 // tightly packed
 194                 DE_ASSERT(srcAccess.getFormat().getPixelSize() == srcAccess.getPixelPitch());
 195
 196                 for (int sliceNdx = 0; sliceNdx < (int)arraySize; ++sliceNdx)
 197                 {
 198                         const vk::VkBufferImageCopy copySlice =
 199                         {
 200                                 (vk::VkDeviceSize)levelOffset + sliceNdx * sliceDataSize,       // bufferOffset
 201                                 (deUint32)sliceSize.x(),                                                                        // bufferRowLength
 202                                 (deUint32)sliceSize.y(),                                                                        // bufferImageHeight
 203                                 {
 204                                         vk::VK_IMAGE_ASPECT_COLOR_BIT,          // aspectMask
 205                                         (deUint32)level,                                        // mipLevel
 206                                         (deUint32)sliceNdx,                                     // arrayLayer
 207                                         1u,                                                                     // arraySize
 208                                 },                                                                                                                      // imageSubresource
 209                                 {
 210                                         0,
 211                                         0,
 212                                         0,
 213                                 },                                                                                                                      // imageOffset
 214                                 {
 215                                         (deUint32)sliceSize.x(),
 216                                         (deUint32)sliceSize.y(),
 217                                         (deUint32)sliceSize.z(),
 218                                 }                                                                                                                       // imageExtent
 219                         };
 220                         copySlices->push_back(copySlice);
 221                 }
 222
 223                 DE_ASSERT(arraySize * sliceDataSize == dataSize);
 224
 225                 tcu::copy(dstAccess, srcAccess);
 226                 levelOffset += dataSize;
 227         }
 228
 229         DE_ASSERT(dstLen == levelOffset);
 230         DE_UNREF(dstLen);
 231 }
 232
 233 de::MovePtr<vk::Allocation> allocateAndBindObjectMemory (const vk::DeviceInterface& vki, vk::VkDevice device, vk::Allocator& allocator, vk::VkBuffer buffer, vk::MemoryRequirement requirement)
 234 {
 235         const vk::VkMemoryRequirements  requirements    = vk::getBufferMemoryRequirements(vki, device, buffer);
 236         de::MovePtr<vk::Allocation>             allocation              = allocator.allocate(requirements, requirement);
 237
 238         VK_CHECK(vki.bindBufferMemory(device, buffer, allocation->getMemory(), allocation->getOffset()));
 239         return allocation;
 240 }
 241
 242 de::MovePtr<vk::Allocation> allocateAndBindObjectMemory (const vk::DeviceInterface& vki, vk::VkDevice device, vk::Allocator& allocator, vk::VkImage image, vk::MemoryRequirement requirement)
 243 {
 244         const vk::VkMemoryRequirements  requirements    = vk::getImageMemoryRequirements(vki, device, image);
 245         de::MovePtr<vk::Allocation>             allocation              = allocator.allocate(requirements, requirement);
 246
 247         VK_CHECK(vki.bindImageMemory(device, image, allocation->getMemory(), allocation->getOffset()));
 248         return allocation;
 249 }
 250
 251 vk::VkDescriptorImageInfo makeDescriptorImageInfo (vk::VkSampler sampler)
 252 {
 253         return vk::makeDescriptorImageInfo(sampler, (vk::VkImageView)0, (vk::VkImageLayout)0);
 254 }
 255
 256 vk::VkDescriptorImageInfo makeDescriptorImageInfo (vk::VkImageView imageView, vk::VkImageLayout layout)
 257 {
 258         return vk::makeDescriptorImageInfo((vk::VkSampler)0, imageView, layout);
 259 }
 260
 261 void drawQuadrantReferenceResult (const tcu::PixelBufferAccess& dst, const tcu::Vec4& c1, const tcu::Vec4& c2, const tcu::Vec4& c3, const tcu::Vec4& c4)
 262 {
 263         tcu::clear(tcu::getSubregion(dst, 0,                                    0,                                              dst.getWidth() / 2,                                             dst.getHeight() / 2),                                   c1);
 264         tcu::clear(tcu::getSubregion(dst, dst.getWidth() / 2,   0,                                              dst.getWidth() - dst.getWidth() / 2,    dst.getHeight() / 2),                                   c2);
 265         tcu::clear(tcu::getSubregion(dst, 0,                                    dst.getHeight() / 2,    dst.getWidth() / 2,                                             dst.getHeight() - dst.getHeight() / 2), c3);
 266         tcu::clear(tcu::getSubregion(dst, dst.getWidth() / 2,   dst.getHeight() / 2,    dst.getWidth() - dst.getWidth() / 2,    dst.getHeight() - dst.getHeight() / 2), c4);
 267 }
 268
 269 class SingleTargetRenderInstance : public vkt::TestInstance
 270 {
 271 public:
 272                                                                                         SingleTargetRenderInstance      (Context&                       context,
 273                                                                                                                                                  const tcu::UVec2&      size);
 274
 275 private:
 276         static vk::Move<vk::VkImage>                    createColorAttachment           (const vk::DeviceInterface&             vki,
 277                                                                                                                                                  vk::VkDevice                                   device,
 278                                                                                                                                                  vk::Allocator&                                 allocator,
 279                                                                                                                                                  const tcu::TextureFormat&              format,
 280                                                                                                                                                  const tcu::UVec2&                              size,
 281                                                                                                                                                  de::MovePtr<vk::Allocation>*   outAllocation);
 282
 283         static vk::Move<vk::VkImageView>                createColorAttachmentView       (const vk::DeviceInterface&     vki,
 284                                                                                                                                                  vk::VkDevice                           device,
 285                                                                                                                                                  const tcu::TextureFormat&      format,
 286                                                                                                                                                  vk::VkImage                            image);
 287
 288         static vk::Move<vk::VkRenderPass>               createRenderPass                        (const vk::DeviceInterface&     vki,
 289                                                                                                                                                  vk::VkDevice                           device,
 290                                                                                                                                                  const tcu::TextureFormat&      format);
 291
 292         static vk::Move<vk::VkFramebuffer>              createFramebuffer                       (const vk::DeviceInterface&     vki,
 293                                                                                                                                                  vk::VkDevice                           device,
 294                                                                                                                                                  vk::VkRenderPass                       renderpass,
 295                                                                                                                                                  vk::VkImageView                        colorAttachmentView,
 296                                                                                                                                                  const tcu::UVec2&                      size);
 297
 298         static vk::Move<vk::VkCommandPool>              createCommandPool                       (const vk::DeviceInterface&     vki,
 299                                                                                                                                                  vk::VkDevice                           device,
 300                                                                                                                                                  deUint32                                       queueFamilyIndex);
 301
 302         virtual void                                                    logTestPlan                                     (void) const = 0;
 303         virtual void                                                    renderToTarget                          (void) = 0;
 304         virtual tcu::TestStatus                                 verifyResultImage                       (const tcu::ConstPixelBufferAccess& result) const = 0;
 305
 306         void                                                                    readRenderTarget                        (tcu::TextureLevel& dst);
 307         tcu::TestStatus                                                 iterate                                         (void);
 308
 309 protected:
 310         const tcu::TextureFormat                                m_targetFormat;
 311         const tcu::UVec2                                                m_targetSize;
 312
 313         const vk::DeviceInterface&                              m_vki;
 314         const vk::VkDevice                                              m_device;
 315         const vk::VkQueue                                               m_queue;
 316         const deUint32                                                  m_queueFamilyIndex;
 317         vk::Allocator&                                                  m_allocator;
 318         de::MovePtr<vk::Allocation>                             m_colorAttachmentMemory;
 319         const vk::Unique<vk::VkImage>                   m_colorAttachmentImage;
 320         const vk::Unique<vk::VkImageView>               m_colorAttachmentView;
 321         const vk::Unique<vk::VkRenderPass>              m_renderPass;
 322         const vk::Unique<vk::VkFramebuffer>             m_framebuffer;
 323         const vk::Unique<vk::VkCommandPool>             m_cmdPool;
 324
 325         bool                                                                    m_firstIteration;
 326 };
 327
 328 SingleTargetRenderInstance::SingleTargetRenderInstance (Context&                        context,
 329                                                                                                                 const tcu::UVec2&       size)
 330         : vkt::TestInstance                     (context)
 331         , m_targetFormat                        (tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8)
 332         , m_targetSize                          (size)
 333         , m_vki                                         (context.getDeviceInterface())
 334         , m_device                                      (context.getDevice())
 335         , m_queue                                       (context.getUniversalQueue())
 336         , m_queueFamilyIndex            (context.getUniversalQueueFamilyIndex())
 337         , m_allocator                           (context.getDefaultAllocator())
 338         , m_colorAttachmentMemory       (DE_NULL)
 339         , m_colorAttachmentImage        (createColorAttachment(m_vki, m_device, m_allocator, m_targetFormat, m_targetSize, &m_colorAttachmentMemory))
 340         , m_colorAttachmentView         (createColorAttachmentView(m_vki, m_device, m_targetFormat, *m_colorAttachmentImage))
 341         , m_renderPass                          (createRenderPass(m_vki, m_device, m_targetFormat))
 342         , m_framebuffer                         (createFramebuffer(m_vki, m_device, *m_renderPass, *m_colorAttachmentView, m_targetSize))
 343         , m_cmdPool                                     (createCommandPool(m_vki, m_device, context.getUniversalQueueFamilyIndex()))
 344         , m_firstIteration                      (true)
 345 {
 346 }
 347
 348 vk::Move<vk::VkImage> SingleTargetRenderInstance::createColorAttachment (const vk::DeviceInterface&             vki,
 349                                                                                                                                                  vk::VkDevice                                   device,
 350                                                                                                                                                  vk::Allocator&                                 allocator,
 351                                                                                                                                                  const tcu::TextureFormat&              format,
 352                                                                                                                                                  const tcu::UVec2&                              size,
 353                                                                                                                                                  de::MovePtr<vk::Allocation>*   outAllocation)
 354 {
 355         const vk::VkImageCreateInfo     imageInfo       =
 356         {
 357                 vk::VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
 358                 DE_NULL,
 359                 (vk::VkImageCreateFlags)0,
 360                 vk::VK_IMAGE_TYPE_2D,                                                   // imageType
 361                 vk::mapTextureFormat(format),                                   // format
 362                 { size.x(), size.y(), 1u },                                             // extent
 363                 1,                                                                                              // mipLevels
 364                 1,                                                                                              // arraySize
 365                 vk::VK_SAMPLE_COUNT_1_BIT,                                              // samples
 366                 vk::VK_IMAGE_TILING_OPTIMAL,                                    // tiling
 367                 vk::VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | vk::VK_IMAGE_USAGE_TRANSFER_SRC_BIT,  // usage
 368                 vk::VK_SHARING_MODE_EXCLUSIVE,                                  // sharingMode
 369                 0u,                                                                                             // queueFamilyCount
 370                 DE_NULL,                                                                                // pQueueFamilyIndices
 371                 vk::VK_IMAGE_LAYOUT_UNDEFINED,                                  // initialLayout
 372         };
 373
 374         vk::Move<vk::VkImage>           image           (vk::createImage(vki, device, &imageInfo));
 375         de::MovePtr<vk::Allocation>     allocation      (allocateAndBindObjectMemory(vki, device, allocator, *image, vk::MemoryRequirement::Any));
 376
 377         *outAllocation = allocation;
 378         return image;
 379 }
 380
 381 vk::Move<vk::VkImageView> SingleTargetRenderInstance::createColorAttachmentView (const vk::DeviceInterface&     vki,
 382                                                                                                                                                                  vk::VkDevice                           device,
 383                                                                                                                                                                  const tcu::TextureFormat&      format,
 384                                                                                                                                                                  vk::VkImage                            image)
 385 {
 386         const vk::VkImageViewCreateInfo createInfo =
 387         {
 388                 vk::VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
 389                 DE_NULL,
 390                 (vk::VkImageViewCreateFlags)0,
 391                 image,                                                  // image
 392                 vk::VK_IMAGE_VIEW_TYPE_2D,              // viewType
 393                 vk::mapTextureFormat(format),   // format
 394                 vk::makeComponentMappingRGBA(),
 395                 {
 396                         vk::VK_IMAGE_ASPECT_COLOR_BIT,  // aspectMask
 397                         0u,                                                             // baseMipLevel
 398                         1u,                                                             // mipLevels
 399                         0u,                                                             // baseArrayLayer
 400                         1u,                                                             // arraySize
 401                 },
 402         };
 403
 404         return vk::createImageView(vki, device, &createInfo);
 405 }
 406
 407 vk::Move<vk::VkRenderPass> SingleTargetRenderInstance::createRenderPass (const vk::DeviceInterface&             vki,
 408                                                                                                                                                  vk::VkDevice                                   device,
 409                                                                                                                                                  const tcu::TextureFormat&              format)
 410 {
 411         const vk::VkAttachmentDescription       attachmentDescription   =
 412         {
 413                 (vk::VkAttachmentDescriptionFlags)0,
 414                 vk::mapTextureFormat(format),                                   // format
 415                 vk::VK_SAMPLE_COUNT_1_BIT,                                              // samples
 416                 vk::VK_ATTACHMENT_LOAD_OP_CLEAR,                                // loadOp
 417                 vk::VK_ATTACHMENT_STORE_OP_STORE,                               // storeOp
 418                 vk::VK_ATTACHMENT_LOAD_OP_DONT_CARE,                    // stencilLoadOp
 419                 vk::VK_ATTACHMENT_STORE_OP_DONT_CARE,                   // stencilStoreOp
 420                 vk::VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,   // initialLayout
 421                 vk::VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,   // finalLayout
 422         };
 423         const vk::VkAttachmentReference         colorAttachment                 =
 424         {
 425                 0u,                                                                                             // attachment
 426                 vk::VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL    // layout
 427         };
 428         const vk::VkAttachmentReference         depthStencilAttachment  =
 429         {
 430                 vk::VK_NO_ATTACHMENT,                                                   // attachment
 431                 vk::VK_IMAGE_LAYOUT_UNDEFINED                                   // layout
 432         };
 433         const vk::VkSubpassDescription          subpass                                 =
 434         {
 435                 (vk::VkSubpassDescriptionFlags)0,
 436                 vk::VK_PIPELINE_BIND_POINT_GRAPHICS,                    // pipelineBindPoint
 437                 0u,                                                                                             // inputAttachmentCount
 438                 DE_NULL,                                                                                // pInputAttachments
 439                 1u,                                                                                             // colorAttachmentCount
 440                 &colorAttachment,                                                               // pColorAttachments
 441                 DE_NULL,                                                                                // pResolveAttachments
 442                 &depthStencilAttachment,                                                // pDepthStencilAttachment
 443                 0u,                                                                                             // preserveAttachmentCount
 444                 DE_NULL                                                                                 // pPreserveAttachments
 445         };
 446         const vk::VkRenderPassCreateInfo        renderPassCreateInfo    =
 447         {
 448                 vk::VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
 449                 DE_NULL,
 450                 (vk::VkRenderPassCreateFlags)0,
 451                 1u,                                                                                             // attachmentCount
 452                 &attachmentDescription,                                                 // pAttachments
 453                 1u,                                                                                             // subpassCount
 454                 &subpass,                                                                               // pSubpasses
 455                 0u,                                                                                             // dependencyCount
 456                 DE_NULL,                                                                                // pDependencies
 457         };
 458
 459         return vk::createRenderPass(vki, device, &renderPassCreateInfo);
 460 }
 461
 462 vk::Move<vk::VkFramebuffer> SingleTargetRenderInstance::createFramebuffer (const vk::DeviceInterface&   vki,
 463                                                                                                                                                    vk::VkDevice                                 device,
 464                                                                                                                                                    vk::VkRenderPass                             renderpass,
 465                                                                                                                                                    vk::VkImageView                              colorAttachmentView,
 466                                                                                                                                                    const tcu::UVec2&                    size)
 467 {
 468         const vk::VkFramebufferCreateInfo       framebufferCreateInfo   =
 469         {
 470                 vk::VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
 471                 DE_NULL,
 472                 (vk::VkFramebufferCreateFlags)0,
 473                 renderpass,                             // renderPass
 474                 1u,                                             // attachmentCount
 475                 &colorAttachmentView,   // pAttachments
 476                 size.x(),                               // width
 477                 size.y(),                               // height
 478                 1,                                              // layers
 479         };
 480
 481         return vk::createFramebuffer(vki, device, &framebufferCreateInfo);
 482 }
 483
 484 vk::Move<vk::VkCommandPool> SingleTargetRenderInstance::createCommandPool (const vk::DeviceInterface&   vki,
 485                                                                                                                                                    vk::VkDevice                                 device,
 486                                                                                                                                                    deUint32                                             queueFamilyIndex)
 487 {
 488         const vk::VkCommandPoolCreateInfo createInfo =
 489         {
 490                 vk::VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
 491                 DE_NULL,
 492                 vk::VK_COMMAND_POOL_CREATE_TRANSIENT_BIT,       // flags
 493                 queueFamilyIndex,                                                       // queueFamilyIndex
 494         };
 495         return vk::createCommandPool(vki, device, &createInfo);
 496 }
 497
 498 void SingleTargetRenderInstance::readRenderTarget (tcu::TextureLevel& dst)
 499 {
 500         const deUint64                                                  pixelDataSize                           = (deUint64)(m_targetSize.x() * m_targetSize.y() * m_targetFormat.getPixelSize());
 501         const vk::VkBufferCreateInfo                    bufferCreateInfo                        =
 502         {
 503                 vk::VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
 504                 DE_NULL,
 505                 0u,                                                                                             // flags
 506                 pixelDataSize,                                                                  // size
 507                 vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT,                   // usage
 508                 vk::VK_SHARING_MODE_EXCLUSIVE,                                  // sharingMode
 509                 0u,                                                                                             // queueFamilyCount
 510                 DE_NULL,                                                                                // pQueueFamilyIndices
 511         };
 512         const vk::Unique<vk::VkBuffer>                  buffer                                          (vk::createBuffer(m_vki, m_device, &bufferCreateInfo));
 513         const vk::VkImageSubresourceRange               fullSubrange                            =
 514         {
 515                 vk::VK_IMAGE_ASPECT_COLOR_BIT,                                  // aspectMask
 516                 0u,                                                                                             // baseMipLevel
 517                 1u,                                                                                             // mipLevels
 518                 0u,                                                                                             // baseArraySlice
 519                 1u,                                                                                             // arraySize
 520         };
 521         const vk::VkImageMemoryBarrier                  imageBarrier                            =
 522         {
 523                 vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
 524                 DE_NULL,
 525                 vk::VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,               // srcAccessMask
 526                 vk::VK_ACCESS_TRANSFER_READ_BIT,                                // dstAccessMask
 527                 vk::VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,   // oldLayout
 528                 vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,               // newLayout
 529                 vk::VK_QUEUE_FAMILY_IGNORED,                                    // srcQueueFamilyIndex
 530                 vk::VK_QUEUE_FAMILY_IGNORED,                                    // destQueueFamilyIndex
 531                 *m_colorAttachmentImage,                                                // image
 532                 fullSubrange,                                                                   // subresourceRange
 533         };
 534         const vk::VkBufferMemoryBarrier                 memoryBarrier                           =
 535         {
 536                 vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
 537                 DE_NULL,
 538                 vk::VK_ACCESS_TRANSFER_WRITE_BIT,                               // srcAccessMask
 539                 vk::VK_ACCESS_HOST_READ_BIT,                                    // dstAccessMask
 540                 vk::VK_QUEUE_FAMILY_IGNORED,                                    // srcQueueFamilyIndex
 541                 vk::VK_QUEUE_FAMILY_IGNORED,                                    // destQueueFamilyIndex
 542                 *buffer,                                                                                // buffer
 543                 0u,                                                                                             // offset
 544                 (vk::VkDeviceSize)pixelDataSize                                 // size
 545         };
 546         const vk::VkCommandBufferAllocateInfo   cmdBufAllocInfo                         =
 547         {
 548                 vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
 549                 DE_NULL,
 550                 *m_cmdPool,                                                             // cmdPool
 551                 vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY,    // level
 552                 1u,                                                                             // bufferCount
 553         };
 554         const vk::VkFenceCreateInfo                             fenceCreateInfo                         =
 555         {
 556                 vk::VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
 557                 DE_NULL,
 558                 0u,                                                                                             // flags
 559         };
 560         const vk::VkCommandBufferBeginInfo              cmdBufBeginInfo                         =
 561         {
 562                 vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
 563                 DE_NULL,
 564                 vk::VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,        // flags
 565                 (const vk::VkCommandBufferInheritanceInfo*)DE_NULL,
 566         };
 567         const vk::VkImageSubresourceLayers              firstSlice                                      =
 568         {
 569                 vk::VK_IMAGE_ASPECT_COLOR_BIT,                                  // aspect
 570                 0,                                                                                              // mipLevel
 571                 0,                                                                                              // arrayLayer
 572                 1,                                                                                              // arraySize
 573         };
 574         const vk::VkBufferImageCopy                             copyRegion                                      =
 575         {
 576                 0u,                                                                                             // bufferOffset
 577                 m_targetSize.x(),                                                               // bufferRowLength
 578                 m_targetSize.y(),                                                               // bufferImageHeight
 579                 firstSlice,                                                                             // imageSubresource
 580                 { 0, 0, 0 },                                                                    // imageOffset
 581                 { m_targetSize.x(), m_targetSize.y(), 1u }              // imageExtent
 582         };
 583
 584         const de::MovePtr<vk::Allocation>               bufferMemory                            = allocateAndBindObjectMemory(m_vki, m_device, m_allocator, *buffer, vk::MemoryRequirement::HostVisible);
 585
 586         const vk::Unique<vk::VkCommandBuffer>   cmd                                                     (vk::allocateCommandBuffer(m_vki, m_device, &cmdBufAllocInfo));
 587         const vk::Unique<vk::VkFence>                   cmdCompleteFence                        (vk::createFence(m_vki, m_device, &fenceCreateInfo));
 588         const deUint64                                                  infiniteTimeout                         = ~(deUint64)0u;
 589
 590         // copy content to buffer
 591         VK_CHECK(m_vki.beginCommandBuffer(*cmd, &cmdBufBeginInfo));
 592         m_vki.cmdPipelineBarrier(*cmd, vk::VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, (vk::VkDependencyFlags)0,
 593                                                          0, (const vk::VkMemoryBarrier*)DE_NULL,
 594                                                          0, (const vk::VkBufferMemoryBarrier*)DE_NULL,
 595                                                          1, &imageBarrier);
 596         m_vki.cmdCopyImageToBuffer(*cmd, *m_colorAttachmentImage, vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *buffer, 1, &copyRegion);
 597         m_vki.cmdPipelineBarrier(*cmd, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (vk::VkDependencyFlags)0,
 598                                                          0, (const vk::VkMemoryBarrier*)DE_NULL,
 599                                                          1, &memoryBarrier,
 600                                                          0, (const vk::VkImageMemoryBarrier*)DE_NULL);
 601         VK_CHECK(m_vki.endCommandBuffer(*cmd));
 602
 603         // wait for transfer to complete
 604         {
 605                 const vk::VkSubmitInfo  submitInfo      =
 606                 {
 607                         vk::VK_STRUCTURE_TYPE_SUBMIT_INFO,
 608                         DE_NULL,
 609                         0u,
 610                         (const vk::VkSemaphore*)0,
 611                         (const vk::VkPipelineStageFlags*)DE_NULL,
 612                         1u,
 613                         &cmd.get(),
 614                         0u,
 615                         (const vk::VkSemaphore*)0,
 616                 };
 617
 618                 VK_CHECK(m_vki.queueSubmit(m_queue, 1, &submitInfo, *cmdCompleteFence));
 619         }
 620         VK_CHECK(m_vki.waitForFences(m_device, 1, &cmdCompleteFence.get(), 0u, infiniteTimeout)); // \note: timeout is failure
 621
 622         dst.setStorage(m_targetFormat, m_targetSize.x(), m_targetSize.y());
 623
 624         // copy data
 625         invalidateMappedMemoryRange(m_vki, m_device, bufferMemory->getMemory(), bufferMemory->getOffset(), pixelDataSize);
 626         tcu::copy(dst, tcu::ConstPixelBufferAccess(dst.getFormat(), dst.getSize(), bufferMemory->getHostPtr()));
 627 }
 628
 629 tcu::TestStatus SingleTargetRenderInstance::iterate (void)
 630 {
 631         tcu::TextureLevel resultImage;
 632
 633         // log
 634         if (m_firstIteration)
 635         {
 636                 logTestPlan();
 637                 m_firstIteration = false;
 638         }
 639
 640         // render
 641         {
 642                 // transition to VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
 643                 const vk::VkImageSubresourceRange               fullSubrange                            =
 644                 {
 645                         vk::VK_IMAGE_ASPECT_COLOR_BIT,                                  // aspectMask
 646                         0u,                                                                                             // baseMipLevel
 647                         1u,                                                                                             // mipLevels
 648                         0u,                                                                                             // baseArraySlice
 649                         1u,                                                                                             // arraySize
 650                 };
 651                 const vk::VkImageMemoryBarrier                  imageBarrier                            =
 652                 {
 653                         vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
 654                         DE_NULL,
 655                         0u,                                                                                             // srcAccessMask
 656                         vk::VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,               // dstAccessMask
 657                         vk::VK_IMAGE_LAYOUT_UNDEFINED,                                  // oldLayout
 658                         vk::VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,   // newLayout
 659                         vk::VK_QUEUE_FAMILY_IGNORED,                                    // srcQueueFamilyIndex
 660                         vk::VK_QUEUE_FAMILY_IGNORED,                                    // destQueueFamilyIndex
 661                         *m_colorAttachmentImage,                                                // image
 662                         fullSubrange,                                                                   // subresourceRange
 663                 };
 664                 const vk::VkCommandBufferAllocateInfo   cmdBufAllocInfo                         =
 665                 {
 666                         vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
 667                         DE_NULL,
 668                         *m_cmdPool,                                                                             // cmdPool
 669                         vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY,                    // level
 670                         1u,                                                                                             // count
 671                 };
 672                 const vk::VkCommandBufferBeginInfo              cmdBufBeginInfo                         =
 673                 {
 674                         vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
 675                         DE_NULL,
 676                         vk::VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,        // flags
 677                         (const vk::VkCommandBufferInheritanceInfo*)DE_NULL,
 678                 };
 679
 680                 const vk::Unique<vk::VkCommandBuffer>   cmd                                     (vk::allocateCommandBuffer(m_vki, m_device, &cmdBufAllocInfo));
 681
 682                 VK_CHECK(m_vki.beginCommandBuffer(*cmd, &cmdBufBeginInfo));
 683                 m_vki.cmdPipelineBarrier(*cmd, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (vk::VkDependencyFlags)0,
 684                                                                  0, (const vk::VkMemoryBarrier*)DE_NULL,
 685                                                                  0, (const vk::VkBufferMemoryBarrier*)DE_NULL,
 686                                                                  1, &imageBarrier);
 687                 VK_CHECK(m_vki.endCommandBuffer(*cmd));
 688
 689                 {
 690                         const vk::VkSubmitInfo  submitInfo      =
 691                         {
 692                                 vk::VK_STRUCTURE_TYPE_SUBMIT_INFO,
 693                                 DE_NULL,
 694                                 0u,
 695                                 (const vk::VkSemaphore*)0,
 696                                 (const vk::VkPipelineStageFlags*)DE_NULL,
 697                                 1u,
 698                                 &cmd.get(),
 699                                 0u,
 700                                 (const vk::VkSemaphore*)0,
 701                         };
 702
 703                         VK_CHECK(m_vki.queueSubmit(m_queue, 1, &submitInfo, (vk::VkFence)0));
 704                 }
 705
 706                 // and then render to
 707                 renderToTarget();
 708         }
 709
 710         // read and verify
 711         readRenderTarget(resultImage);
 712         return verifyResultImage(resultImage.getAccess());
 713 }
 714
 715 class RenderInstanceShaders
 716 {
 717 public:
 718                                                                                                                 RenderInstanceShaders           (const vk::DeviceInterface&                             vki,
 719                                                                                                                                                                          vk::VkDevice                                                   device,
 720                                                                                                                                                                          const vk::VkPhysicalDeviceFeatures&    deviceFeatures,
 721                                                                                                                                                                          const vk::BinaryCollection&                    programCollection);
 722
 723         inline bool                                                                                     hasTessellationStage            (void) const { return *m_tessCtrlShaderModule != 0 || *m_tessEvalShaderModule != 0;     }
 724         inline deUint32                                                                         getNumStages                            (void) const { return (deUint32)m_stageInfos.size();                                                            }
 725         inline const vk::VkPipelineShaderStageCreateInfo*       getStages                                       (void) const { return &m_stageInfos[0];                                                                                         }
 726
 727 private:
 728         void                                                                                            addStage                                        (const vk::DeviceInterface&                             vki,
 729                                                                                                                                                                          vk::VkDevice                                                   device,
 730                                                                                                                                                                          const vk::VkPhysicalDeviceFeatures&    deviceFeatures,
 731                                                                                                                                                                          const vk::BinaryCollection&                    programCollection,
 732                                                                                                                                                                          const char*                                                    name,
 733                                                                                                                                                                          vk::VkShaderStageFlagBits                              stage,
 734                                                                                                                                                                          vk::Move<vk::VkShaderModule>*                  outModule);
 735
 736         vk::VkPipelineShaderStageCreateInfo                                     getShaderStageCreateInfo        (vk::VkShaderStageFlagBits stage, vk::VkShaderModule shader) const;
 737
 738         vk::Move<vk::VkShaderModule>                                            m_vertexShaderModule;
 739         vk::Move<vk::VkShaderModule>                                            m_tessCtrlShaderModule;
 740         vk::Move<vk::VkShaderModule>                                            m_tessEvalShaderModule;
 741         vk::Move<vk::VkShaderModule>                                            m_geometryShaderModule;
 742         vk::Move<vk::VkShaderModule>                                            m_fragmentShaderModule;
 743         std::vector<vk::VkPipelineShaderStageCreateInfo>        m_stageInfos;
 744 };
 745
 746 RenderInstanceShaders::RenderInstanceShaders (const vk::DeviceInterface&                        vki,
 747                                                                                           vk::VkDevice                                                  device,
 748                                                                                           const vk::VkPhysicalDeviceFeatures&   deviceFeatures,
 749                                                                                           const vk::BinaryCollection&                   programCollection)
 750 {
 751         addStage(vki, device, deviceFeatures, programCollection, "vertex",              vk::VK_SHADER_STAGE_VERTEX_BIT,                                         &m_vertexShaderModule);
 752         addStage(vki, device, deviceFeatures, programCollection, "tess_ctrl",   vk::VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT,           &m_tessCtrlShaderModule);
 753         addStage(vki, device, deviceFeatures, programCollection, "tess_eval",   vk::VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT,        &m_tessEvalShaderModule);
 754         addStage(vki, device, deviceFeatures, programCollection, "geometry",    vk::VK_SHADER_STAGE_GEOMETRY_BIT,                                       &m_geometryShaderModule);
 755         addStage(vki, device, deviceFeatures, programCollection, "fragment",    vk::VK_SHADER_STAGE_FRAGMENT_BIT,                                       &m_fragmentShaderModule);
 756
 757         DE_ASSERT(!m_stageInfos.empty());
 758 }
 759
 760 void RenderInstanceShaders::addStage (const vk::DeviceInterface&                        vki,
 761                                                                           vk::VkDevice                                                  device,
 762                                                                           const vk::VkPhysicalDeviceFeatures&   deviceFeatures,
 763                                                                           const vk::BinaryCollection&                   programCollection,
 764                                                                           const char*                                                   name,
 765                                                                           vk::VkShaderStageFlagBits                             stage,
 766                                                                           vk::Move<vk::VkShaderModule>*                 outModule)
 767 {
 768         if (programCollection.contains(name))
 769         {
 770                 if (vk::isShaderStageSupported(deviceFeatures, stage))
 771                 {
 772                         vk::Move<vk::VkShaderModule>    module  = createShaderModule(vki, device, programCollection.get(name), (vk::VkShaderModuleCreateFlags)0);
 773
 774                         m_stageInfos.push_back(getShaderStageCreateInfo(stage, *module));
 775                         *outModule = module;
 776                 }
 777                 else
 778                 {
 779                         // Wait for the GPU to idle so that throwing the exception
 780                         // below doesn't free in-use GPU resource.
 781                         vki.deviceWaitIdle(device);
 782                         TCU_THROW(NotSupportedError, (de::toString(stage) + " is not supported").c_str());
 783                 }
 784         }
 785 }
 786
 787 vk::VkPipelineShaderStageCreateInfo RenderInstanceShaders::getShaderStageCreateInfo (vk::VkShaderStageFlagBits stage, vk::VkShaderModule shader) const
 788 {
 789         const vk::VkPipelineShaderStageCreateInfo       stageCreateInfo =
 790         {
 791                 vk::VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
 792                 DE_NULL,
 793                 (vk::VkPipelineShaderStageCreateFlags)0,
 794                 stage,                  // stage
 795                 shader,                 // shader
 796                 "main",
 797                 DE_NULL,                // pSpecializationInfo
 798         };
 799         return stageCreateInfo;
 800 }
 801
 802 class SingleCmdRenderInstance : public SingleTargetRenderInstance
 803 {
 804 public:
 805                                                                         SingleCmdRenderInstance (Context&                       context,
 806                                                                                                                          bool                           isPrimaryCmdBuf,
 807                                                                                                                          const tcu::UVec2&      renderSize);
 808
 809 private:
 810         vk::Move<vk::VkPipeline>                createPipeline                          (vk::VkPipelineLayout pipelineLayout);
 811
 812         virtual vk::VkPipelineLayout    getPipelineLayout                       (void) const = 0;
 813         virtual void                                    writeDrawCmdBuffer                      (vk::VkCommandBuffer cmd) const = 0;
 814
 815         void                                                    renderToTarget                          (void);
 816
 817         const bool                                              m_isPrimaryCmdBuf;
 818 };
 819
 820 SingleCmdRenderInstance::SingleCmdRenderInstance (Context&                      context,
 821                                                                                                   bool                          isPrimaryCmdBuf,
 822                                                                                                   const tcu::UVec2&     renderSize)
 823         : SingleTargetRenderInstance    (context, renderSize)
 824         , m_isPrimaryCmdBuf                             (isPrimaryCmdBuf)
 825 {
 826 }
 827
 828 vk::Move<vk::VkPipeline> SingleCmdRenderInstance::createPipeline (vk::VkPipelineLayout pipelineLayout)
 829 {
 830         const RenderInstanceShaders                                                     shaderStages            (m_vki, m_device, m_context.getDeviceFeatures(), m_context.getBinaryCollection());
 831         const vk::VkPrimitiveTopology                                           topology                        = shaderStages.hasTessellationStage() ? vk::VK_PRIMITIVE_TOPOLOGY_PATCH_LIST : vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
 832         const vk::VkPipelineVertexInputStateCreateInfo          vertexInputState        =
 833         {
 834                 vk::VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
 835                 DE_NULL,
 836                 (vk::VkPipelineVertexInputStateCreateFlags)0,
 837                 0u,                                                                                     // bindingCount
 838                 DE_NULL,                                                                        // pVertexBindingDescriptions
 839                 0u,                                                                                     // attributeCount
 840                 DE_NULL,                                                                        // pVertexAttributeDescriptions
 841         };
 842         const vk::VkPipelineInputAssemblyStateCreateInfo        iaState                         =
 843         {
 844                 vk::VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
 845                 DE_NULL,
 846                 (vk::VkPipelineInputAssemblyStateCreateFlags)0,
 847                 topology,                                                                       // topology
 848                 vk::VK_FALSE,                                                           // primitiveRestartEnable
 849         };
 850         const vk::VkPipelineTessellationStateCreateInfo         tessState                       =
 851         {
 852                 vk::VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO,
 853                 DE_NULL,
 854                 (vk::VkPipelineTessellationStateCreateFlags)0,
 855                 3u,                                                                                     // patchControlPoints
 856         };
 857         const vk::VkViewport                                                            viewport                        =
 858         {
 859                 0.0f,                                                                           // originX
 860                 0.0f,                                                                           // originY
 861                 float(m_targetSize.x()),                                        // width
 862                 float(m_targetSize.y()),                                        // height
 863                 0.0f,                                                                           // minDepth
 864                 1.0f,                                                                           // maxDepth
 865         };
 866         const vk::VkRect2D                                                                      renderArea                      =
 867         {
 868                 { 0, 0 },                                                                       // offset
 869                 { m_targetSize.x(), m_targetSize.y() },         // extent
 870         };
 871         const vk::VkPipelineViewportStateCreateInfo                     vpState                         =
 872         {
 873                 vk::VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
 874                 DE_NULL,
 875                 (vk::VkPipelineViewportStateCreateFlags)0,
 876                 1u,                                                                                     // viewportCount
 877                 &viewport,
 878                 1u,
 879                 &renderArea,
 880         };
 881         const vk::VkPipelineRasterizationStateCreateInfo        rsState                         =
 882         {
 883                 vk::VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
 884                 DE_NULL,
 885                 (vk::VkPipelineRasterizationStateCreateFlags)0,
 886                 vk::VK_TRUE,                                                            // depthClipEnable
 887                 vk::VK_FALSE,                                                           // rasterizerDiscardEnable
 888                 vk::VK_POLYGON_MODE_FILL,                                       // fillMode
 889                 vk::VK_CULL_MODE_NONE,                                          // cullMode
 890                 vk::VK_FRONT_FACE_COUNTER_CLOCKWISE,            // frontFace
 891                 vk::VK_FALSE,                                                           // depthBiasEnable
 892                 0.0f,                                                                           // depthBias
 893                 0.0f,                                                                           // depthBiasClamp
 894                 0.0f,                                                                           // slopeScaledDepthBias
 895                 1.0f,                                                                           // lineWidth
 896         };
 897         const vk::VkSampleMask                                                          sampleMask                      = 0x01u;
 898         const vk::VkPipelineMultisampleStateCreateInfo          msState                         =
 899         {
 900                 vk::VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
 901                 DE_NULL,
 902                 (vk::VkPipelineMultisampleStateCreateFlags)0,
 903                 vk::VK_SAMPLE_COUNT_1_BIT,                                      // rasterSamples
 904                 vk::VK_FALSE,                                                           // sampleShadingEnable
 905                 0.0f,                                                                           // minSampleShading
 906                 &sampleMask,                                                            // sampleMask
 907                 vk::VK_FALSE,                                                           // alphaToCoverageEnable
 908                 vk::VK_FALSE,                                                           // alphaToOneEnable
 909         };
 910         const vk::VkPipelineDepthStencilStateCreateInfo         dsState                         =
 911         {
 912                 vk::VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
 913                 DE_NULL,
 914                 (vk::VkPipelineDepthStencilStateCreateFlags)0,
 915                 vk::VK_FALSE,                                                           // depthTestEnable
 916                 vk::VK_FALSE,                                                           // depthWriteEnable
 917                 vk::VK_COMPARE_OP_ALWAYS,                                       // depthCompareOp
 918                 vk::VK_FALSE,                                                           // depthBoundsTestEnable
 919                 vk::VK_FALSE,                                                           // stencilTestEnable
 920                 { vk::VK_STENCIL_OP_KEEP, vk::VK_STENCIL_OP_KEEP, vk::VK_STENCIL_OP_KEEP, vk::VK_COMPARE_OP_ALWAYS, 0u, 0u, 0u },       // front
 921                 { vk::VK_STENCIL_OP_KEEP, vk::VK_STENCIL_OP_KEEP, vk::VK_STENCIL_OP_KEEP, vk::VK_COMPARE_OP_ALWAYS, 0u, 0u, 0u },       // back
 922                 -1.0f,                                                                          // minDepthBounds
 923                 +1.0f,                                                                          // maxDepthBounds
 924         };
 925         const vk::VkPipelineColorBlendAttachmentState           cbAttachment            =
 926         {
 927                 vk::VK_FALSE,                                                           // blendEnable
 928                 vk::VK_BLEND_FACTOR_ZERO,                                       // srcBlendColor
 929                 vk::VK_BLEND_FACTOR_ZERO,                                       // destBlendColor
 930                 vk::VK_BLEND_OP_ADD,                                            // blendOpColor
 931                 vk::VK_BLEND_FACTOR_ZERO,                                       // srcBlendAlpha
 932                 vk::VK_BLEND_FACTOR_ZERO,                                       // destBlendAlpha
 933                 vk::VK_BLEND_OP_ADD,                                            // blendOpAlpha
 934                 (vk::VK_COLOR_COMPONENT_R_BIT |
 935                  vk::VK_COLOR_COMPONENT_G_BIT |
 936                  vk::VK_COLOR_COMPONENT_B_BIT |
 937                  vk::VK_COLOR_COMPONENT_A_BIT),                         // channelWriteMask
 938         };
 939         const vk::VkPipelineColorBlendStateCreateInfo           cbState                         =
 940         {
 941                 vk::VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
 942                 DE_NULL,
 943                 (vk::VkPipelineColorBlendStateCreateFlags)0,
 944                 vk::VK_FALSE,                                                           // logicOpEnable
 945                 vk::VK_LOGIC_OP_CLEAR,                                          // logicOp
 946                 1u,                                                                                     // attachmentCount
 947                 &cbAttachment,                                                          // pAttachments
 948                 { 0.0f, 0.0f, 0.0f, 0.0f },                                     // blendConst
 949         };
 950         const vk::VkGraphicsPipelineCreateInfo createInfo =
 951         {
 952                 vk::VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
 953                 DE_NULL,
 954                 (vk::VkPipelineCreateFlags)0,
 955                 shaderStages.getNumStages(),                                                                    // stageCount
 956                 shaderStages.getStages(),                                                                               // pStages
 957                 &vertexInputState,                                                                                              // pVertexInputState
 958                 &iaState,                                                                                                               // pInputAssemblyState
 959                 (shaderStages.hasTessellationStage() ? &tessState : DE_NULL),   // pTessellationState
 960                 &vpState,                                                                                                               // pViewportState
 961                 &rsState,                                                                                                               // pRasterState
 962                 &msState,                                                                                                               // pMultisampleState
 963                 &dsState,                                                                                                               // pDepthStencilState
 964                 &cbState,                                                                                                               // pColorBlendState
 965                 (const vk::VkPipelineDynamicStateCreateInfo*)DE_NULL,                   // pDynamicState
 966                 pipelineLayout,                                                                                                 // layout
 967                 *m_renderPass,                                                                                                  // renderPass
 968                 0u,                                                                                                                             // subpass
 969                 (vk::VkPipeline)0,                                                                                              // basePipelineHandle
 970                 0u,                                                                                                                             // basePipelineIndex
 971         };
 972         return createGraphicsPipeline(m_vki, m_device, (vk::VkPipelineCache)0u, &createInfo);
 973 }
 974
 975 void SingleCmdRenderInstance::renderToTarget (void)
 976 {
 977         const vk::VkRect2D                                                                      renderArea                                              =
 978         {
 979                 { 0, 0 },                                                               // offset
 980                 { m_targetSize.x(), m_targetSize.y() }, // extent
 981         };
 982         const vk::VkCommandBufferAllocateInfo                           mainCmdBufCreateInfo                    =
 983         {
 984                 vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
 985                 DE_NULL,
 986                 *m_cmdPool,                                                             // cmdPool
 987                 vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY,    // level
 988                 1u,                                                                             // count
 989         };
 990         const vk::VkCommandBufferBeginInfo                                      mainCmdBufBeginInfo                             =
 991         {
 992                 vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
 993                 DE_NULL,
 994                 vk::VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,        // flags
 995                 (const vk::VkCommandBufferInheritanceInfo*)DE_NULL,
 996         };
 997         const vk::VkCommandBufferAllocateInfo                           passCmdBufCreateInfo                    =
 998         {
 999                 vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
1000                 DE_NULL,
1001                 *m_cmdPool,                                                             // cmdPool
1002                 vk::VK_COMMAND_BUFFER_LEVEL_SECONDARY,  // level
1003                 1u,                                                                             // count
1004         };
1005         const vk::VkCommandBufferInheritanceInfo                        passCmdBufInheritInfo                   =
1006         {
1007                 vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
1008                 DE_NULL,
1009                 (vk::VkRenderPass)*m_renderPass,                                                // renderPass
1010                 0u,                                                                                                             // subpass
1011                 (vk::VkFramebuffer)*m_framebuffer,                                              // framebuffer
1012                 vk::VK_FALSE,                                                                                   // occlusionQueryEnable
1013                 (vk::VkQueryControlFlags)0,
1014                 (vk::VkQueryPipelineStatisticFlags)0,
1015         };
1016         const vk::VkCommandBufferBeginInfo                                      passCmdBufBeginInfo                             =
1017         {
1018                 vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
1019                 DE_NULL,
1020                 vk::VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT |
1021                 vk::VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT,   // flags
1022                 &passCmdBufInheritInfo,
1023         };
1024         const vk::VkFenceCreateInfo                                                     fenceCreateInfo                         =
1025         {
1026                 vk::VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
1027                 DE_NULL,
1028                 0u,                     // flags
1029         };
1030         const vk::VkClearValue                                                          clearValue                                      = vk::makeClearValueColorF32(0.0f, 0.0f, 0.0f, 0.0f);
1031         const vk::VkRenderPassBeginInfo                                         renderPassBeginInfo                     =
1032         {
1033                 vk::VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
1034                 DE_NULL,
1035                 *m_renderPass,          // renderPass
1036                 *m_framebuffer,         // framebuffer
1037                 renderArea,                     // renderArea
1038                 1u,                                     // clearValueCount
1039                 &clearValue,            // pClearValues
1040         };
1041
1042         const vk::VkPipelineLayout                                                      pipelineLayout                          (getPipelineLayout());
1043         const vk::Unique<vk::VkPipeline>                                        pipeline                                        (createPipeline(pipelineLayout));
1044         const vk::Unique<vk::VkCommandBuffer>                           mainCmd                                         (vk::allocateCommandBuffer(m_vki, m_device, &mainCmdBufCreateInfo));
1045         const vk::Unique<vk::VkCommandBuffer>                           passCmd                                         ((m_isPrimaryCmdBuf) ? (vk::Move<vk::VkCommandBuffer>()) : (vk::allocateCommandBuffer(m_vki, m_device, &passCmdBufCreateInfo)));
1046         const vk::Unique<vk::VkFence>                                           fence                                           (vk::createFence(m_vki, m_device, &fenceCreateInfo));
1047         const deUint64                                                                          infiniteTimeout                         = ~(deUint64)0u;
1048         const vk::VkSubpassContents                                                     passContents                            = (m_isPrimaryCmdBuf) ? (vk::VK_SUBPASS_CONTENTS_INLINE) : (vk::VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS);
1049
1050         VK_CHECK(m_vki.beginCommandBuffer(*mainCmd, &mainCmdBufBeginInfo));
1051         m_vki.cmdBeginRenderPass(*mainCmd, &renderPassBeginInfo, passContents);
1052
1053         if (m_isPrimaryCmdBuf)
1054         {
1055                 m_vki.cmdBindPipeline(*mainCmd, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
1056                 writeDrawCmdBuffer(*mainCmd);
1057         }
1058         else
1059         {
1060                 VK_CHECK(m_vki.beginCommandBuffer(*passCmd, &passCmdBufBeginInfo));
1061                 m_vki.cmdBindPipeline(*passCmd, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
1062                 writeDrawCmdBuffer(*passCmd);
1063                 VK_CHECK(m_vki.endCommandBuffer(*passCmd));
1064
1065                 m_vki.cmdExecuteCommands(*mainCmd, 1, &passCmd.get());
1066         }
1067
1068         m_vki.cmdEndRenderPass(*mainCmd);
1069         VK_CHECK(m_vki.endCommandBuffer(*mainCmd));
1070
1071         // submit and wait for them to finish before exiting scope. (Killing in-flight objects is a no-no).
1072         {
1073                 const vk::VkSubmitInfo  submitInfo      =
1074                 {
1075                         vk::VK_STRUCTURE_TYPE_SUBMIT_INFO,
1076                         DE_NULL,
1077                         0u,
1078                         (const vk::VkSemaphore*)0,
1079                         (const vk::VkPipelineStageFlags*)DE_NULL,
1080                         1u,
1081                         &mainCmd.get(),
1082                         0u,
1083                         (const vk::VkSemaphore*)0,
1084                 };
1085                 VK_CHECK(m_vki.queueSubmit(m_queue, 1, &submitInfo, *fence));
1086         }
1087         VK_CHECK(m_vki.waitForFences(m_device, 1, &fence.get(), 0u, infiniteTimeout)); // \note: timeout is failure
1088 }
1089
1090 enum ShaderInputInterface
1091 {
1092         SHADER_INPUT_SINGLE_DESCRIPTOR = 0,                                     //!< one descriptor
1093         SHADER_INPUT_MULTIPLE_CONTIGUOUS_DESCRIPTORS,           //!< multiple descriptors with contiguous binding id's
1094         SHADER_INPUT_MULTIPLE_DISCONTIGUOUS_DESCRIPTORS,        //!< multiple descriptors with discontiguous binding id's
1095         SHADER_INPUT_DESCRIPTOR_ARRAY,                                          //!< descriptor array
1096
1097         SHADER_INPUT_LAST
1098 };
1099
1100 deUint32 getInterfaceNumResources (ShaderInputInterface shaderInterface)
1101 {
1102         switch (shaderInterface)
1103         {
1104                 case SHADER_INPUT_SINGLE_DESCRIPTOR:                                    return 1u;
1105                 case SHADER_INPUT_MULTIPLE_CONTIGUOUS_DESCRIPTORS:              return 2u;
1106                 case SHADER_INPUT_MULTIPLE_DISCONTIGUOUS_DESCRIPTORS:   return 2u;
1107                 case SHADER_INPUT_DESCRIPTOR_ARRAY:                                             return 2u;
1108
1109                 default:
1110                         DE_FATAL("Impossible");
1111                         return 0u;
1112         }
1113 }
1114
1115 class BufferRenderInstance : public SingleCmdRenderInstance
1116 {
1117 public:
1118                                                                                                         BufferRenderInstance            (Context&                                       context,
1119                                                                                                                                                                  bool                                           isPrimaryCmdBuf,
1120                                                                                                                                                                  vk::VkDescriptorType           descriptorType,
1121                                                                                                                                                                  vk::VkShaderStageFlags         stageFlags,
1122                                                                                                                                                                  ShaderInputInterface           shaderInterface,
1123                                                                                                                                                                  bool                                           viewOffset,
1124                                                                                                                                                                  bool                                           dynamicOffset,
1125                                                                                                                                                                  bool                                           dynamicOffsetNonZero);
1126
1127         static vk::Move<vk::VkBuffer>                                   createSourceBuffer                      (const vk::DeviceInterface&             vki,
1128                                                                                                                                                                  vk::VkDevice                                   device,
1129                                                                                                                                                                  vk::Allocator&                                 allocator,
1130                                                                                                                                                                  vk::VkDescriptorType                   descriptorType,
1131                                                                                                                                                                  deUint32                                               offset,
1132                                                                                                                                                                  deUint32                                               bufferSize,
1133                                                                                                                                                                  de::MovePtr<vk::Allocation>*   outMemory);
1134
1135         static vk::Move<vk::VkDescriptorPool>                   createDescriptorPool            (const vk::DeviceInterface&     vki,
1136                                                                                                                                                                  vk::VkDevice                           device,
1137                                                                                                                                                                  vk::VkDescriptorType           descriptorType,
1138                                                                                                                                                                  ShaderInputInterface           shaderInterface);
1139
1140         static vk::Move<vk::VkDescriptorSetLayout>              createDescriptorSetLayout       (const vk::DeviceInterface&     vki,
1141                                                                                                                                                                  vk::VkDevice                           device,
1142                                                                                                                                                                  vk::VkDescriptorType           descriptorType,
1143                                                                                                                                                                  ShaderInputInterface           shaderInterface,
1144                                                                                                                                                                  vk::VkShaderStageFlags         stageFlags);
1145
1146         static vk::Move<vk::VkDescriptorSet>                    createDescriptorSet                     (const vk::DeviceInterface&     vki,
1147                                                                                                                                                                  vk::VkDevice                           device,
1148                                                                                                                                                                  vk::VkDescriptorSetLayout      descriptorSetLayout,
1149                                                                                                                                                                  vk::VkDescriptorPool           descriptorPool,
1150                                                                                                                                                                  vk::VkDescriptorType           descriptorType,
1151                                                                                                                                                                  ShaderInputInterface           shaderInterface,
1152                                                                                                                                                                  vk::VkBuffer                           sourceBufferA,
1153                                                                                                                                                                  const deUint32                         viewOffsetA,
1154                                                                                                                                                                  vk::VkBuffer                           sourceBufferB,
1155                                                                                                                                                                  const deUint32                         viewOffsetB);
1156
1157         static vk::Move<vk::VkPipelineLayout>                   createPipelineLayout            (const vk::DeviceInterface&     vki,
1158                                                                                                                                                                  vk::VkDevice                           device,
1159                                                                                                                                                                  vk::VkDescriptorSetLayout      descriptorSetLayout);
1160
1161         void                                                                                    logTestPlan                                     (void) const;
1162         vk::VkPipelineLayout                                                    getPipelineLayout                       (void) const;
1163         void                                                                                    writeDrawCmdBuffer                      (vk::VkCommandBuffer cmd) const;
1164         tcu::TestStatus                                                                 verifyResultImage                       (const tcu::ConstPixelBufferAccess& result) const;
1165
1166         enum
1167         {
1168                 RENDER_SIZE                             = 128,
1169                 BUFFER_DATA_SIZE                = 8 * sizeof(float),
1170                 BUFFER_SIZE_A                   = 2048, //!< a lot more than required
1171                 BUFFER_SIZE_B                   = 2560, //!< a lot more than required
1172
1173                 STATIC_OFFSET_VALUE_A   = 256,
1174                 DYNAMIC_OFFSET_VALUE_A  = 512,
1175                 STATIC_OFFSET_VALUE_B   = 1024,
1176                 DYNAMIC_OFFSET_VALUE_B  = 768,
1177         };
1178
1179         const vk::VkDescriptorType                                              m_descriptorType;
1180         const ShaderInputInterface                                              m_shaderInterface;
1181         const bool                                                                              m_setViewOffset;
1182         const bool                                                                              m_setDynamicOffset;
1183         const bool                                                                              m_dynamicOffsetNonZero;
1184         const vk::VkShaderStageFlags                                    m_stageFlags;
1185
1186         const deUint32                                                                  m_viewOffsetA;
1187         const deUint32                                                                  m_viewOffsetB;
1188         const deUint32                                                                  m_dynamicOffsetA;
1189         const deUint32                                                                  m_dynamicOffsetB;
1190         const deUint32                                                                  m_effectiveOffsetA;
1191         const deUint32                                                                  m_effectiveOffsetB;
1192         const deUint32                                                                  m_bufferSizeA;
1193         const deUint32                                                                  m_bufferSizeB;
1194
1195         de::MovePtr<vk::Allocation>                                             m_bufferMemoryA;
1196         de::MovePtr<vk::Allocation>                                             m_bufferMemoryB;
1197         const vk::Unique<vk::VkBuffer>                                  m_sourceBufferA;
1198         const vk::Unique<vk::VkBuffer>                                  m_sourceBufferB;
1199         const vk::Unique<vk::VkDescriptorPool>                  m_descriptorPool;
1200         const vk::Unique<vk::VkDescriptorSetLayout>             m_descriptorSetLayout;
1201         const vk::Unique<vk::VkDescriptorSet>                   m_descriptorSet;
1202         const vk::Unique<vk::VkPipelineLayout>                  m_pipelineLayout;
1203 };
1204
1205 BufferRenderInstance::BufferRenderInstance      (Context&                               context,
1206                                                                                          bool                                   isPrimaryCmdBuf,
1207                                                                                          vk::VkDescriptorType   descriptorType,
1208                                                                                          vk::VkShaderStageFlags stageFlags,
1209                                                                                          ShaderInputInterface   shaderInterface,
1210                                                                                          bool                                   viewOffset,
1211                                                                                          bool                                   dynamicOffset,
1212                                                                                          bool                                   dynamicOffsetNonZero)
1213         : SingleCmdRenderInstance               (context, isPrimaryCmdBuf, tcu::UVec2(RENDER_SIZE, RENDER_SIZE))
1214         , m_descriptorType                              (descriptorType)
1215         , m_shaderInterface                             (shaderInterface)
1216         , m_setViewOffset                               (viewOffset)
1217         , m_setDynamicOffset                    (dynamicOffset)
1218         , m_dynamicOffsetNonZero                (dynamicOffsetNonZero)
1219         , m_stageFlags                                  (stageFlags)
1220         , m_viewOffsetA                                 ((m_setViewOffset) ? ((deUint32)STATIC_OFFSET_VALUE_A) : (0u))
1221         , m_viewOffsetB                                 ((m_setViewOffset) ? ((deUint32)STATIC_OFFSET_VALUE_B) : (0u))
1222         , m_dynamicOffsetA                              ((dynamicOffsetNonZero) ? ((deUint32)DYNAMIC_OFFSET_VALUE_A) : (0u))
1223         , m_dynamicOffsetB                              ((dynamicOffsetNonZero) ? ((deUint32)DYNAMIC_OFFSET_VALUE_B) : (0u))
1224         , m_effectiveOffsetA                    ((isDynamicDescriptorType(m_descriptorType)) ? (m_viewOffsetA + m_dynamicOffsetA) : (m_viewOffsetA))
1225         , m_effectiveOffsetB                    ((isDynamicDescriptorType(m_descriptorType)) ? (m_viewOffsetB + m_dynamicOffsetB) : (m_viewOffsetB))
1226         , m_bufferSizeA                                 (BUFFER_SIZE_A)
1227         , m_bufferSizeB                                 (BUFFER_SIZE_B)
1228         , m_bufferMemoryA                               (DE_NULL)
1229         , m_bufferMemoryB                               (DE_NULL)
1230         , m_sourceBufferA                               (createSourceBuffer(m_vki, m_device, m_allocator, m_descriptorType, m_effectiveOffsetA, m_bufferSizeA, &m_bufferMemoryA))
1231         , m_sourceBufferB                               ((getInterfaceNumResources(m_shaderInterface) == 1u)
1232                                                                                 ? vk::Move<vk::VkBuffer>()
1233                                                                                 : createSourceBuffer(m_vki, m_device, m_allocator, m_descriptorType, m_effectiveOffsetB, m_bufferSizeB, &m_bufferMemoryB))
1234         , m_descriptorPool                              (createDescriptorPool(m_vki, m_device, m_descriptorType, m_shaderInterface))
1235         , m_descriptorSetLayout                 (createDescriptorSetLayout(m_vki, m_device, m_descriptorType, m_shaderInterface, m_stageFlags))
1236         , m_descriptorSet                               (createDescriptorSet(m_vki, m_device, *m_descriptorSetLayout, *m_descriptorPool, m_descriptorType, m_shaderInterface, *m_sourceBufferA, m_viewOffsetA, *m_sourceBufferB, m_viewOffsetB))
1237         , m_pipelineLayout                              (createPipelineLayout(m_vki, m_device, *m_descriptorSetLayout))
1238 {
1239         if (m_setDynamicOffset)
1240                 DE_ASSERT(isDynamicDescriptorType(m_descriptorType));
1241         if (m_dynamicOffsetNonZero)
1242                 DE_ASSERT(m_setDynamicOffset);
1243 }
1244
1245 vk::Move<vk::VkBuffer> BufferRenderInstance::createSourceBuffer (const vk::DeviceInterface&             vki,
1246                                                                                                                                  vk::VkDevice                                   device,
1247                                                                                                                                  vk::Allocator&                                 allocator,
1248                                                                                                                                  vk::VkDescriptorType                   descriptorType,
1249                                                                                                                                  deUint32                                               offset,
1250                                                                                                                                  deUint32                                               bufferSize,
1251                                                                                                                                  de::MovePtr<vk::Allocation>*   outMemory)
1252 {
1253         static const float                              s_colors[]                      =
1254         {
1255                 0.0f, 1.0f, 0.0f, 1.0f,         // green
1256                 1.0f, 1.0f, 0.0f, 1.0f,         // yellow
1257         };
1258         DE_STATIC_ASSERT(sizeof(s_colors) == BUFFER_DATA_SIZE);
1259         DE_ASSERT(offset + BUFFER_DATA_SIZE <= bufferSize);
1260         DE_ASSERT(offset % sizeof(float) == 0);
1261         DE_ASSERT(bufferSize % sizeof(float) == 0);
1262
1263         const bool                                              isUniformBuffer         = isUniformDescriptorType(descriptorType);
1264         const vk::VkBufferUsageFlags    usageFlags                      = (isUniformBuffer) ? (vk::VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT) : (vk::VK_BUFFER_USAGE_STORAGE_BUFFER_BIT);
1265         const float                                             preGuardValue           = 0.5f;
1266         const float                                             postGuardValue          = 0.75f;
1267         const vk::VkBufferCreateInfo    bufferCreateInfo        =
1268         {
1269                 vk::VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
1270                 DE_NULL,
1271                 0u,                                                             // flags
1272                 bufferSize,                                             // size
1273                 usageFlags,                                             // usage
1274                 vk::VK_SHARING_MODE_EXCLUSIVE,  // sharingMode
1275                 0u,                                                             // queueFamilyCount
1276                 DE_NULL,                                                // pQueueFamilyIndices
1277         };
1278         vk::Move<vk::VkBuffer>                  buffer                          (vk::createBuffer(vki, device, &bufferCreateInfo));
1279         de::MovePtr<vk::Allocation>             bufferMemory            = allocateAndBindObjectMemory(vki, device, allocator, *buffer, vk::MemoryRequirement::HostVisible);
1280         void* const                                             mapPtr                          = bufferMemory->getHostPtr();
1281
1282         // guard with interesting values
1283         for (size_t preGuardOffset = 0; preGuardOffset + sizeof(float) <= (size_t)offset; preGuardOffset += sizeof(float))
1284                 deMemcpy((deUint8*)mapPtr + preGuardOffset, &preGuardValue, sizeof(float));
1285
1286         deMemcpy((deUint8*)mapPtr + offset, s_colors, sizeof(s_colors));
1287         for (size_t postGuardOffset = (size_t)offset + sizeof(s_colors); postGuardOffset + sizeof(float) <= (size_t)bufferSize; postGuardOffset += sizeof(float))
1288                 deMemcpy((deUint8*)mapPtr + postGuardOffset, &postGuardValue, sizeof(float));
1289         deMemset((deUint8*)mapPtr + offset + sizeof(s_colors), 0x5A, (size_t)bufferSize - (size_t)offset - sizeof(s_colors)); // fill with interesting pattern that produces valid floats
1290
1291         flushMappedMemoryRange(vki, device, bufferMemory->getMemory(), bufferMemory->getOffset(), bufferSize);
1292
1293         *outMemory = bufferMemory;
1294         return buffer;
1295 }
1296
1297 vk::Move<vk::VkDescriptorPool> BufferRenderInstance::createDescriptorPool (const vk::DeviceInterface&   vki,
1298                                                                                                                                                    vk::VkDevice                                 device,
1299                                                                                                                                                    vk::VkDescriptorType                 descriptorType,
1300                                                                                                                                                    ShaderInputInterface                 shaderInterface)
1301 {
1302         return vk::DescriptorPoolBuilder()
1303                 .addType(descriptorType, getInterfaceNumResources(shaderInterface))
1304                 .build(vki, device, vk::VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1);
1305 }
1306
1307 vk::Move<vk::VkDescriptorSetLayout> BufferRenderInstance::createDescriptorSetLayout (const vk::DeviceInterface& vki,
1308                                                                                                                                                                          vk::VkDevice                           device,
1309                                                                                                                                                                          vk::VkDescriptorType           descriptorType,
1310                                                                                                                                                                          ShaderInputInterface           shaderInterface,
1311                                                                                                                                                                          vk::VkShaderStageFlags         stageFlags)
1312 {
1313         vk::DescriptorSetLayoutBuilder builder;
1314
1315         switch (shaderInterface)
1316         {
1317                 case SHADER_INPUT_SINGLE_DESCRIPTOR:
1318                         builder.addSingleBinding(descriptorType, stageFlags);
1319                         break;
1320
1321                 case SHADER_INPUT_MULTIPLE_CONTIGUOUS_DESCRIPTORS:
1322                         builder.addSingleBinding(descriptorType, stageFlags);
1323                         builder.addSingleBinding(descriptorType, stageFlags);
1324                         break;
1325
1326                 case SHADER_INPUT_DESCRIPTOR_ARRAY:
1327                         builder.addArrayBinding(descriptorType, 2u, stageFlags);
1328                         break;
1329
1330                 default:
1331                         DE_FATAL("Impossible");
1332         }
1333
1334         return builder.build(vki, device);
1335 }
1336
1337 vk::Move<vk::VkDescriptorSet> BufferRenderInstance::createDescriptorSet (const vk::DeviceInterface&     vki,
1338                                                                                                                                                  vk::VkDevice                           device,
1339                                                                                                                                                  vk::VkDescriptorSetLayout      descriptorSetLayout,
1340                                                                                                                                                  vk::VkDescriptorPool           descriptorPool,
1341                                                                                                                                                  vk::VkDescriptorType           descriptorType,
1342                                                                                                                                                  ShaderInputInterface           shaderInterface,
1343                                                                                                                                                  vk::VkBuffer                           bufferA,
1344                                                                                                                                                  deUint32                                       offsetA,
1345                                                                                                                                                  vk::VkBuffer                           bufferB,
1346                                                                                                                                                  deUint32                                       offsetB)
1347 {
1348         const vk::VkDescriptorBufferInfo                bufferInfos[2]  =
1349         {
1350                 vk::makeDescriptorBufferInfo(bufferA, (vk::VkDeviceSize)offsetA, (vk::VkDeviceSize)BUFFER_DATA_SIZE),
1351                 vk::makeDescriptorBufferInfo(bufferB, (vk::VkDeviceSize)offsetB, (vk::VkDeviceSize)BUFFER_DATA_SIZE),
1352         };
1353         const vk::VkDescriptorSetAllocateInfo   allocInfo               =
1354         {
1355                 vk::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
1356                 DE_NULL,
1357                 descriptorPool,
1358                 1u,
1359                 &descriptorSetLayout
1360         };
1361
1362         vk::Move<vk::VkDescriptorSet>   descriptorSet   = allocateDescriptorSet(vki, device, &allocInfo);
1363         vk::DescriptorSetUpdateBuilder  builder;
1364
1365         switch (shaderInterface)
1366         {
1367                 case SHADER_INPUT_SINGLE_DESCRIPTOR:
1368                         builder.writeSingle(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(0u), descriptorType, &bufferInfos[0]);
1369                         break;
1370
1371                 case SHADER_INPUT_MULTIPLE_CONTIGUOUS_DESCRIPTORS:
1372                         builder.writeSingle(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(0u), descriptorType, &bufferInfos[0]);
1373                         builder.writeSingle(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(1u), descriptorType, &bufferInfos[1]);
1374                         break;
1375
1376                 case SHADER_INPUT_DESCRIPTOR_ARRAY:
1377                         builder.writeArray(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(0u), descriptorType, 2u, bufferInfos);
1378                         break;
1379
1380                 default:
1381                         DE_FATAL("Impossible");
1382         }
1383
1384         builder.update(vki, device);
1385         return descriptorSet;
1386 }
1387
1388 vk::Move<vk::VkPipelineLayout> BufferRenderInstance::createPipelineLayout (const vk::DeviceInterface&   vki,
1389                                                                                                                                                    vk::VkDevice                                 device,
1390                                                                                                                                                    vk::VkDescriptorSetLayout    descriptorSetLayout)
1391 {
1392         const vk::VkPipelineLayoutCreateInfo createInfo =
1393         {
1394                 vk::VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
1395                 DE_NULL,
1396                 (vk::VkPipelineLayoutCreateFlags)0,
1397                 1,                                              // descriptorSetCount
1398                 &descriptorSetLayout,   // pSetLayouts
1399                 0u,                                             // pushConstantRangeCount
1400                 DE_NULL,                                // pPushConstantRanges
1401         };
1402
1403         return vk::createPipelineLayout(vki, device, &createInfo);
1404 }
1405
1406 void BufferRenderInstance::logTestPlan (void) const
1407 {
1408         std::ostringstream msg;
1409
1410         msg << "Rendering 2x2 yellow-green grid.\n"
1411                 << "Single descriptor set. Descriptor set contains "
1412                         << ((m_shaderInterface == SHADER_INPUT_SINGLE_DESCRIPTOR) ? "single" :
1413                             (m_shaderInterface == SHADER_INPUT_MULTIPLE_CONTIGUOUS_DESCRIPTORS) ? "two" :
1414                             (m_shaderInterface == SHADER_INPUT_DESCRIPTOR_ARRAY) ? "an array (size 2) of" :
1415                             (const char*)DE_NULL)
1416                 << " descriptor(s) of type " << vk::getDescriptorTypeName(m_descriptorType) << "\n"
1417                 << "Buffer view(s) have " << ((m_setViewOffset) ? ("non-") : ("")) << "zero offset.\n";
1418
1419         if (isDynamicDescriptorType(m_descriptorType))
1420         {
1421                 if (m_setDynamicOffset)
1422                 {
1423                         msg << "Source buffer(s) are given a dynamic offset at bind time.\n"
1424                                 << "The supplied dynamic offset is " << ((m_dynamicOffsetNonZero) ? ("non-") : ("")) << "zero.\n";
1425                 }
1426                 else
1427                 {
1428                         msg << "Dynamic offset is not supplied at bind time. Expecting bind to offset 0.\n";
1429                 }
1430         }
1431
1432         if (m_stageFlags == 0u)
1433         {
1434                 msg << "Descriptors are not accessed in any shader stage.\n";
1435         }
1436         else
1437         {
1438                 msg << "Descriptors are accessed in {"
1439                         << (((m_stageFlags & vk::VK_SHADER_STAGE_VERTEX_BIT) != 0)                                      ? (" vertex")                   : (""))
1440                         << (((m_stageFlags & vk::VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) != 0)        ? (" tess_control")             : (""))
1441                         << (((m_stageFlags & vk::VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT) != 0)     ? (" tess_evaluation")  : (""))
1442                         << (((m_stageFlags & vk::VK_SHADER_STAGE_GEOMETRY_BIT) != 0)                            ? (" geometry")                 : (""))
1443                         << (((m_stageFlags & vk::VK_SHADER_STAGE_FRAGMENT_BIT) != 0)                            ? (" fragment")                 : (""))
1444                         << " } stages.\n";
1445         }
1446
1447         m_context.getTestContext().getLog()
1448                 << tcu::TestLog::Message
1449                 << msg.str()
1450                 << tcu::TestLog::EndMessage;
1451 }
1452
1453 vk::VkPipelineLayout BufferRenderInstance::getPipelineLayout (void) const
1454 {
1455         return *m_pipelineLayout;
1456 }
1457
1458 void BufferRenderInstance::writeDrawCmdBuffer (vk::VkCommandBuffer cmd) const
1459 {
1460         const bool                                                      isUniformBuffer         = isUniformDescriptorType(m_descriptorType);
1461
1462         // \note dynamic offset replaces the view offset, i.e. it is not offset relative to the view offset
1463         const deUint32                                          dynamicOffsets[]        =
1464         {
1465                 m_dynamicOffsetA,
1466                 m_dynamicOffsetB,
1467         };
1468         const deUint32                                          numOffsets                      = (!m_setDynamicOffset) ? (0u) : (getInterfaceNumResources(m_shaderInterface));
1469         const deUint32* const                           dynamicOffsetPtr        = (!m_setDynamicOffset) ? (DE_NULL) : (dynamicOffsets);
1470
1471         // make host writes device-visible
1472         const vk::VkAccessFlags                         inputBit                        = (isUniformBuffer) ? (vk::VK_ACCESS_UNIFORM_READ_BIT) : (vk::VK_ACCESS_SHADER_READ_BIT);
1473         const vk::VkBufferMemoryBarrier         memoryBarriers[]        =
1474         {
1475                 {
1476                         vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
1477                         DE_NULL,
1478                         vk::VK_ACCESS_HOST_WRITE_BIT,                           // outputMask
1479                         inputBit,                                                                       // inputMask
1480                         vk::VK_QUEUE_FAMILY_IGNORED,                            // srcQueueFamilyIndex
1481                         vk::VK_QUEUE_FAMILY_IGNORED,                            // destQueueFamilyIndex
1482                         *m_sourceBufferA,                                                       // buffer
1483                         0u,                                                                                     // offset
1484                         (vk::VkDeviceSize)m_bufferSizeA,                        // size
1485                 },
1486                 {
1487                         vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
1488                         DE_NULL,
1489                         vk::VK_ACCESS_HOST_WRITE_BIT,                           // outputMask
1490                         inputBit,                                                                       // inputMask
1491                         vk::VK_QUEUE_FAMILY_IGNORED,                            // srcQueueFamilyIndex
1492                         vk::VK_QUEUE_FAMILY_IGNORED,                            // destQueueFamilyIndex
1493                         *m_sourceBufferB,                                                       // buffer
1494                         0u,                                                                                     // offset
1495                         (vk::VkDeviceSize)m_bufferSizeB,                        // size
1496                 }
1497         };
1498         const deUint32                                          numMemoryBarriers       = getInterfaceNumResources(m_shaderInterface);
1499
1500         m_vki.cmdBindDescriptorSets(cmd, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, getPipelineLayout(), 0, 1, &m_descriptorSet.get(), numOffsets, dynamicOffsetPtr);
1501         m_vki.cmdPipelineBarrier(cmd, 0u, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, (vk::VkDependencyFlags)0,
1502                                                          0, (const vk::VkMemoryBarrier*)DE_NULL,
1503                                                          numMemoryBarriers, memoryBarriers,
1504                                                          0, (const vk::VkImageMemoryBarrier*)DE_NULL);
1505         m_vki.cmdDraw(cmd, 6 * 4, 1, 0, 0); // render four quads (two separate triangles)
1506 }
1507
1508 tcu::TestStatus BufferRenderInstance::verifyResultImage (const tcu::ConstPixelBufferAccess& result) const
1509 {
1510         const tcu::Vec4         green           (0.0f, 1.0f, 0.0f, 1.0f);
1511         const tcu::Vec4         yellow          (1.0f, 1.0f, 0.0f, 1.0f);
1512         tcu::Surface            reference       (m_targetSize.x(), m_targetSize.y());
1513
1514         drawQuadrantReferenceResult(reference.getAccess(), yellow, green, green, yellow);
1515
1516         if (!bilinearCompare(m_context.getTestContext().getLog(), "Compare", "Result comparison", reference.getAccess(), result, tcu::RGBA(1, 1, 1, 1), tcu::COMPARE_LOG_RESULT))
1517                 return tcu::TestStatus::fail("Image verification failed");
1518         else
1519                 return tcu::TestStatus::pass("Pass");
1520 }
1521
1522 class ComputeInstanceResultBuffer
1523 {
1524 public:
1525         enum
1526         {
1527                 DATA_SIZE = sizeof(tcu::Vec4[4])
1528         };
1529
1530                                                                                         ComputeInstanceResultBuffer     (const vk::DeviceInterface&             vki,
1531                                                                                                                                                  vk::VkDevice                                   device,
1532                                                                                                                                                  vk::Allocator&                                 allocator);
1533
1534         void                                                                    readResultContentsTo            (tcu::Vec4 (*results)[4]) const;
1535
1536         inline vk::VkBuffer                                             getBuffer                                       (void) const { return *m_buffer;                        }
1537         inline const vk::VkBufferMemoryBarrier* getResultReadBarrier            (void) const { return &m_bufferBarrier;         }
1538
1539 private:
1540         static vk::Move<vk::VkBuffer>                   createResultBuffer                      (const vk::DeviceInterface&             vki,
1541                                                                                                                                                  vk::VkDevice                                   device,
1542                                                                                                                                                  vk::Allocator&                                 allocator,
1543                                                                                                                                                  de::MovePtr<vk::Allocation>*   outAllocation);
1544
1545         static vk::VkBufferMemoryBarrier                createResultBufferBarrier       (vk::VkBuffer buffer);
1546
1547         const vk::DeviceInterface&                              m_vki;
1548         const vk::VkDevice                                              m_device;
1549
1550         de::MovePtr<vk::Allocation>                             m_bufferMem;
1551         const vk::Unique<vk::VkBuffer>                  m_buffer;
1552         const vk::VkBufferMemoryBarrier                 m_bufferBarrier;
1553 };
1554
1555 ComputeInstanceResultBuffer::ComputeInstanceResultBuffer (const vk::DeviceInterface&    vki,
1556                                                                                                                   vk::VkDevice                                  device,
1557                                                                                                                   vk::Allocator&                                allocator)
1558         : m_vki                         (vki)
1559         , m_device                      (device)
1560         , m_bufferMem           (DE_NULL)
1561         , m_buffer                      (createResultBuffer(m_vki, m_device, allocator, &m_bufferMem))
1562         , m_bufferBarrier       (createResultBufferBarrier(*m_buffer))
1563 {
1564 }
1565
1566 void ComputeInstanceResultBuffer::readResultContentsTo (tcu::Vec4 (*results)[4]) const
1567 {
1568         invalidateMappedMemoryRange(m_vki, m_device, m_bufferMem->getMemory(), m_bufferMem->getOffset(), sizeof(*results));
1569         deMemcpy(*results, m_bufferMem->getHostPtr(), sizeof(*results));
1570 }
1571
1572 vk::Move<vk::VkBuffer> ComputeInstanceResultBuffer::createResultBuffer (const vk::DeviceInterface&              vki,
1573                                                                                                                                                 vk::VkDevice                                    device,
1574                                                                                                                                                 vk::Allocator&                                  allocator,
1575                                                                                                                                                 de::MovePtr<vk::Allocation>*    outAllocation)
1576 {
1577         const vk::VkBufferCreateInfo    createInfo      =
1578         {
1579                 vk::VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
1580                 DE_NULL,
1581                 0u,                                                                                     // flags
1582                 (vk::VkDeviceSize)DATA_SIZE,                            // size
1583                 vk::VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,         // usage
1584                 vk::VK_SHARING_MODE_EXCLUSIVE,                          // sharingMode
1585                 0u,                                                                                     // queueFamilyCount
1586                 DE_NULL,                                                                        // pQueueFamilyIndices
1587         };
1588         vk::Move<vk::VkBuffer>                  buffer          (vk::createBuffer(vki, device, &createInfo));
1589         de::MovePtr<vk::Allocation>             allocation      (allocateAndBindObjectMemory(vki, device, allocator, *buffer, vk::MemoryRequirement::HostVisible));
1590         const float                                             clearValue      = -1.0f;
1591         void*                                                   mapPtr          = allocation->getHostPtr();
1592
1593         for (size_t offset = 0; offset < DATA_SIZE; offset += sizeof(float))
1594                 deMemcpy(((deUint8*)mapPtr) + offset, &clearValue, sizeof(float));
1595
1596         flushMappedMemoryRange(vki, device, allocation->getMemory(), allocation->getOffset(), (vk::VkDeviceSize)DATA_SIZE);
1597
1598         *outAllocation = allocation;
1599         return buffer;
1600 }
1601
1602 vk::VkBufferMemoryBarrier ComputeInstanceResultBuffer::createResultBufferBarrier (vk::VkBuffer buffer)
1603 {
1604         const vk::VkBufferMemoryBarrier bufferBarrier =
1605         {
1606                 vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
1607                 DE_NULL,
1608                 vk::VK_ACCESS_SHADER_WRITE_BIT,                         // outputMask
1609                 vk::VK_ACCESS_HOST_READ_BIT,                            // inputMask
1610                 vk::VK_QUEUE_FAMILY_IGNORED,                            // srcQueueFamilyIndex
1611                 vk::VK_QUEUE_FAMILY_IGNORED,                            // destQueueFamilyIndex
1612                 buffer,                                                                         // buffer
1613                 (vk::VkDeviceSize)0u,                                           // offset
1614                 DATA_SIZE,                                                                      // size
1615         };
1616         return bufferBarrier;
1617 }
1618
1619 class ComputePipeline
1620 {
1621 public:
1622                                                                                         ComputePipeline                 (const vk::DeviceInterface&                     vki,
1623                                                                                                                                          vk::VkDevice                                           device,
1624                                                                                                                                          const vk::BinaryCollection&            programCollection,
1625                                                                                                                                          deUint32                                                       numDescriptorSets,
1626                                                                                                                                          const vk::VkDescriptorSetLayout*       descriptorSetLayouts);
1627
1628         inline vk::VkPipeline                                   getPipeline                             (void) const { return *m_pipeline;                      };
1629         inline vk::VkPipelineLayout                             getPipelineLayout               (void) const { return *m_pipelineLayout;        };
1630
1631 private:
1632         static vk::Move<vk::VkPipelineLayout>   createPipelineLayout    (const vk::DeviceInterface&                     vki,
1633                                                                                                                                          vk::VkDevice                                           device,
1634                                                                                                                                          deUint32                                                       numDescriptorSets,
1635                                                                                                                                          const vk::VkDescriptorSetLayout*       descriptorSetLayouts);
1636
1637         static vk::Move<vk::VkPipeline>                 createPipeline                  (const vk::DeviceInterface&                     vki,
1638                                                                                                                                          vk::VkDevice                                           device,
1639                                                                                                                                          const vk::BinaryCollection&            programCollection,
1640                                                                                                                                          vk::VkPipelineLayout                           layout);
1641
1642         const vk::Unique<vk::VkPipelineLayout>  m_pipelineLayout;
1643         const vk::Unique<vk::VkPipeline>                m_pipeline;
1644 };
1645
1646 ComputePipeline::ComputePipeline (const vk::DeviceInterface&            vki,
1647                                                                   vk::VkDevice                                          device,
1648                                                                   const vk::BinaryCollection&           programCollection,
1649                                                                   deUint32                                                      numDescriptorSets,
1650                                                                   const vk::VkDescriptorSetLayout*      descriptorSetLayouts)
1651         : m_pipelineLayout      (createPipelineLayout(vki, device, numDescriptorSets, descriptorSetLayouts))
1652         , m_pipeline            (createPipeline(vki, device, programCollection, *m_pipelineLayout))
1653 {
1654 }
1655
1656 vk::Move<vk::VkPipelineLayout> ComputePipeline::createPipelineLayout (const vk::DeviceInterface&                vki,
1657                                                                                                                                           vk::VkDevice                                          device,
1658                                                                                                                                           deUint32                                                      numDescriptorSets,
1659                                                                                                                                           const vk::VkDescriptorSetLayout*      descriptorSetLayouts)
1660 {
1661         const vk::VkPipelineLayoutCreateInfo createInfo =
1662         {
1663                 vk::VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
1664                 DE_NULL,
1665                 (vk::VkPipelineLayoutCreateFlags)0,
1666                 numDescriptorSets,              // descriptorSetCount
1667                 descriptorSetLayouts,   // pSetLayouts
1668                 0u,                                             // pushConstantRangeCount
1669                 DE_NULL,                                // pPushConstantRanges
1670         };
1671         return vk::createPipelineLayout(vki, device, &createInfo);
1672 }
1673
1674 vk::Move<vk::VkPipeline> ComputePipeline::createPipeline (const vk::DeviceInterface&    vki,
1675                                                                                                                   vk::VkDevice                                  device,
1676                                                                                                                   const vk::BinaryCollection&   programCollection,
1677                                                                                                                   vk::VkPipelineLayout                  layout)
1678 {
1679         const vk::Unique<vk::VkShaderModule>            computeModule           (vk::createShaderModule(vki, device, programCollection.get("compute"), (vk::VkShaderModuleCreateFlags)0u));
1680         const vk::VkPipelineShaderStageCreateInfo       cs                                      =
1681         {
1682                 vk::VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
1683                 DE_NULL,
1684                 (vk::VkPipelineShaderStageCreateFlags)0,
1685                 vk::VK_SHADER_STAGE_COMPUTE_BIT,        // stage
1686                 *computeModule,                                         // shader
1687                 "main",
1688                 DE_NULL,                                                        // pSpecializationInfo
1689         };
1690         const vk::VkComputePipelineCreateInfo           createInfo                      =
1691         {
1692                 vk::VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
1693                 DE_NULL,
1694                 0u,                                                             // flags
1695                 cs,                                                             // cs
1696                 layout,                                                 // layout
1697                 (vk::VkPipeline)0,                              // basePipelineHandle
1698                 0u,                                                             // basePipelineIndex
1699         };
1700         return createComputePipeline(vki, device, (vk::VkPipelineCache)0u, &createInfo);
1701 }
1702
1703 class ComputeCommand
1704 {
1705 public:
1706                                                                                         ComputeCommand  (const vk::DeviceInterface&                     vki,
1707                                                                                                                          vk::VkDevice                                           device,
1708                                                                                                                          vk::VkPipeline                                         pipeline,
1709                                                                                                                          vk::VkPipelineLayout                           pipelineLayout,
1710                                                                                                                          const tcu::UVec3&                                      numWorkGroups,
1711                                                                                                                          int                                                            numDescriptorSets,
1712                                                                                                                          const vk::VkDescriptorSet*                     descriptorSets,
1713                                                                                                                          int                                                            numDynamicOffsets,
1714                                                                                                                          const deUint32*                                        dynamicOffsets,
1715                                                                                                                          int                                                            numPreBarriers,
1716                                                                                                                          const vk::VkBufferMemoryBarrier*       preBarriers,
1717                                                                                                                          int                                                            numPostBarriers,
1718                                                                                                                          const vk::VkBufferMemoryBarrier*       postBarriers);
1719
1720         void                                                                    submitAndWait   (deUint32 queueFamilyIndex, vk::VkQueue queue) const;
1721
1722 private:
1723         const vk::DeviceInterface&                              m_vki;
1724         const vk::VkDevice                                              m_device;
1725         const vk::VkPipeline                                    m_pipeline;
1726         const vk::VkPipelineLayout                              m_pipelineLayout;
1727         const tcu::UVec3                                                m_numWorkGroups;
1728         const int                                                               m_numDescriptorSets;
1729         const vk::VkDescriptorSet* const                m_descriptorSets;
1730         const int                                                               m_numDynamicOffsets;
1731         const deUint32* const                                   m_dynamicOffsets;
1732         const int                                                               m_numPreBarriers;
1733         const vk::VkBufferMemoryBarrier* const  m_preBarriers;
1734         const int                                                               m_numPostBarriers;
1735         const vk::VkBufferMemoryBarrier* const  m_postBarriers;
1736 };
1737
1738 ComputeCommand::ComputeCommand (const vk::DeviceInterface&                      vki,
1739                                                                 vk::VkDevice                                            device,
1740                                                                 vk::VkPipeline                                          pipeline,
1741                                                                 vk::VkPipelineLayout                            pipelineLayout,
1742                                                                 const tcu::UVec3&                                       numWorkGroups,
1743                                                                 int                                                                     numDescriptorSets,
1744                                                                 const vk::VkDescriptorSet*                      descriptorSets,
1745                                                                 int                                                                     numDynamicOffsets,
1746                                                                 const deUint32*                                         dynamicOffsets,
1747                                                                 int                                                                     numPreBarriers,
1748                                                                 const vk::VkBufferMemoryBarrier*        preBarriers,
1749                                                                 int                                                                     numPostBarriers,
1750                                                                 const vk::VkBufferMemoryBarrier*        postBarriers)
1751         : m_vki                                 (vki)
1752         , m_device                              (device)
1753         , m_pipeline                    (pipeline)
1754         , m_pipelineLayout              (pipelineLayout)
1755         , m_numWorkGroups               (numWorkGroups)
1756         , m_numDescriptorSets   (numDescriptorSets)
1757         , m_descriptorSets              (descriptorSets)
1758         , m_numDynamicOffsets   (numDynamicOffsets)
1759         , m_dynamicOffsets              (dynamicOffsets)
1760         , m_numPreBarriers              (numPreBarriers)
1761         , m_preBarriers                 (preBarriers)
1762         , m_numPostBarriers             (numPostBarriers)
1763         , m_postBarriers                (postBarriers)
1764 {
1765 }
1766
1767 void ComputeCommand::submitAndWait (deUint32 queueFamilyIndex, vk::VkQueue queue) const
1768 {
1769         const vk::VkCommandPoolCreateInfo                               cmdPoolCreateInfo       =
1770         {
1771                 vk::VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
1772                 DE_NULL,
1773                 vk::VK_COMMAND_POOL_CREATE_TRANSIENT_BIT,                       // flags
1774                 queueFamilyIndex,                                                                       // queueFamilyIndex
1775         };
1776         const vk::Unique<vk::VkCommandPool>                             cmdPool                         (vk::createCommandPool(m_vki, m_device, &cmdPoolCreateInfo));
1777
1778         const vk::VkFenceCreateInfo                                             fenceCreateInfo         =
1779         {
1780                 vk::VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
1781                 DE_NULL,
1782                 0u,                     // flags
1783         };
1784
1785         const vk::VkCommandBufferAllocateInfo                   cmdBufCreateInfo        =
1786         {
1787                 vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
1788                 DE_NULL,
1789                 *cmdPool,                                                                                       // cmdPool
1790                 vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY,                            // level
1791                 1u,                                                                                                     // count
1792         };
1793         const vk::VkCommandBufferBeginInfo                              cmdBufBeginInfo         =
1794         {
1795                 vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
1796                 DE_NULL,
1797                 vk::VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,        // flags
1798                 (const vk::VkCommandBufferInheritanceInfo*)DE_NULL,
1799         };
1800
1801         const vk::Unique<vk::VkFence>                                   cmdCompleteFence        (vk::createFence(m_vki, m_device, &fenceCreateInfo));
1802         const vk::Unique<vk::VkCommandBuffer>                   cmd                                     (vk::allocateCommandBuffer(m_vki, m_device, &cmdBufCreateInfo));
1803         const deUint64                                                                  infiniteTimeout         = ~(deUint64)0u;
1804
1805         VK_CHECK(m_vki.beginCommandBuffer(*cmd, &cmdBufBeginInfo));
1806
1807         m_vki.cmdBindPipeline(*cmd, vk::VK_PIPELINE_BIND_POINT_COMPUTE, m_pipeline);
1808         m_vki.cmdBindDescriptorSets(*cmd, vk::VK_PIPELINE_BIND_POINT_COMPUTE, m_pipelineLayout, 0, m_numDescriptorSets, m_descriptorSets, m_numDynamicOffsets, m_dynamicOffsets);
1809
1810         if (m_numPreBarriers)
1811                 m_vki.cmdPipelineBarrier(*cmd, 0u, vk::VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, (vk::VkDependencyFlags)0,
1812                                                                  0, (const vk::VkMemoryBarrier*)DE_NULL,
1813                                                                  m_numPreBarriers, m_preBarriers,
1814                                                                  0, (const vk::VkImageMemoryBarrier*)DE_NULL);
1815
1816         m_vki.cmdDispatch(*cmd, m_numWorkGroups.x(), m_numWorkGroups.y(), m_numWorkGroups.z());
1817         m_vki.cmdPipelineBarrier(*cmd, vk::VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (vk::VkDependencyFlags)0,
1818                                                          0, (const vk::VkMemoryBarrier*)DE_NULL,
1819                                                          m_numPostBarriers, m_postBarriers,
1820                                                          0, (const vk::VkImageMemoryBarrier*)DE_NULL);
1821         VK_CHECK(m_vki.endCommandBuffer(*cmd));
1822
1823         // run
1824         {
1825                 const vk::VkSubmitInfo  submitInfo      =
1826                 {
1827                         vk::VK_STRUCTURE_TYPE_SUBMIT_INFO,
1828                         DE_NULL,
1829                         0u,
1830                         (const vk::VkSemaphore*)0,
1831                         (const vk::VkPipelineStageFlags*)DE_NULL,
1832                         1u,
1833                         &cmd.get(),
1834                         0u,
1835                         (const vk::VkSemaphore*)0,
1836                 };
1837                 VK_CHECK(m_vki.queueSubmit(queue, 1, &submitInfo, *cmdCompleteFence));
1838         }
1839         VK_CHECK(m_vki.waitForFences(m_device, 1, &cmdCompleteFence.get(), 0u, infiniteTimeout)); // \note: timeout is failure
1840 }
1841
1842 class BufferComputeInstance : public vkt::TestInstance
1843 {
1844 public:
1845                                                                                         BufferComputeInstance           (Context&                               context,
1846                                                                                                                                                  vk::VkDescriptorType   descriptorType,
1847                                                                                                                                                  ShaderInputInterface   shaderInterface,
1848                                                                                                                                                  bool                                   viewOffset,
1849                                                                                                                                                  bool                                   dynamicOffset,
1850                                                                                                                                                  bool                                   dynamicOffsetNonZero);
1851
1852 private:
1853         vk::Move<vk::VkBuffer>                                  createColorDataBuffer           (deUint32 offset, deUint32 bufferSize, const tcu::Vec4& value1, const tcu::Vec4& value2, de::MovePtr<vk::Allocation>* outAllocation);
1854         vk::Move<vk::VkBufferView>                              createBufferView                        (vk::VkBuffer buffer, deUint32 offset) const;
1855         vk::Move<vk::VkDescriptorSetLayout>             createDescriptorSetLayout       (void) const;
1856         vk::Move<vk::VkDescriptorPool>                  createDescriptorPool            (void) const;
1857         vk::Move<vk::VkDescriptorSet>                   createDescriptorSet                     (vk::VkDescriptorPool pool, vk::VkDescriptorSetLayout layout, vk::VkBuffer viewA, deUint32 offsetA, vk::VkBuffer viewB, deUint32 offsetB, vk::VkBuffer resBuf) const;
1858
1859         tcu::TestStatus                                                 iterate                                         (void);
1860         void                                                                    logTestPlan                                     (void) const;
1861         tcu::TestStatus                                                 testResourceAccess                      (void);
1862
1863         enum
1864         {
1865                 STATIC_OFFSET_VALUE_A   = 256,
1866                 DYNAMIC_OFFSET_VALUE_A  = 512,
1867                 STATIC_OFFSET_VALUE_B   = 1024,
1868                 DYNAMIC_OFFSET_VALUE_B  = 768,
1869         };
1870
1871         const vk::VkDescriptorType                              m_descriptorType;
1872         const ShaderInputInterface                              m_shaderInterface;
1873         const bool                                                              m_setViewOffset;
1874         const bool                                                              m_setDynamicOffset;
1875         const bool                                                              m_dynamicOffsetNonZero;
1876
1877         const vk::DeviceInterface&                              m_vki;
1878         const vk::VkDevice                                              m_device;
1879         const vk::VkQueue                                               m_queue;
1880         const deUint32                                                  m_queueFamilyIndex;
1881         vk::Allocator&                                                  m_allocator;
1882
1883         const ComputeInstanceResultBuffer               m_result;
1884 };
1885
1886 BufferComputeInstance::BufferComputeInstance (Context&                                  context,
1887                                                                                           vk::VkDescriptorType          descriptorType,
1888                                                                                           ShaderInputInterface          shaderInterface,
1889                                                                                           bool                                          viewOffset,
1890                                                                                           bool                                          dynamicOffset,
1891                                                                                           bool                                          dynamicOffsetNonZero)
1892         : vkt::TestInstance                     (context)
1893         , m_descriptorType                      (descriptorType)
1894         , m_shaderInterface                     (shaderInterface)
1895         , m_setViewOffset                       (viewOffset)
1896         , m_setDynamicOffset            (dynamicOffset)
1897         , m_dynamicOffsetNonZero        (dynamicOffsetNonZero)
1898         , m_vki                                         (context.getDeviceInterface())
1899         , m_device                                      (context.getDevice())
1900         , m_queue                                       (context.getUniversalQueue())
1901         , m_queueFamilyIndex            (context.getUniversalQueueFamilyIndex())
1902         , m_allocator                           (context.getDefaultAllocator())
1903         , m_result                                      (m_vki, m_device, m_allocator)
1904 {
1905         if (m_dynamicOffsetNonZero)
1906                 DE_ASSERT(m_setDynamicOffset);
1907 }
1908
1909 vk::Move<vk::VkBuffer> BufferComputeInstance::createColorDataBuffer (deUint32 offset, deUint32 bufferSize, const tcu::Vec4& value1, const tcu::Vec4& value2, de::MovePtr<vk::Allocation>* outAllocation)
1910 {
1911         DE_ASSERT(offset + sizeof(tcu::Vec4[2]) <= bufferSize);
1912
1913         const bool                                              isUniformBuffer         = isUniformDescriptorType(m_descriptorType);
1914         const vk::VkBufferUsageFlags    usageFlags                      = (isUniformBuffer) ? (vk::VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT) : (vk::VK_BUFFER_USAGE_STORAGE_BUFFER_BIT);
1915         const vk::VkBufferCreateInfo    createInfo =
1916         {
1917                 vk::VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
1918                 DE_NULL,
1919                 0u,                                                             // flags
1920                 (vk::VkDeviceSize)bufferSize,   // size
1921                 usageFlags,                                             // usage
1922                 vk::VK_SHARING_MODE_EXCLUSIVE,  // sharingMode
1923                 0u,                                                             // queueFamilyCount
1924                 DE_NULL,                                                // pQueueFamilyIndices
1925         };
1926         vk::Move<vk::VkBuffer>                  buffer                          (vk::createBuffer(m_vki, m_device, &createInfo));
1927         de::MovePtr<vk::Allocation>             allocation                      (allocateAndBindObjectMemory(m_vki, m_device, m_allocator, *buffer, vk::MemoryRequirement::HostVisible));
1928         void*                                                   mapPtr                          = allocation->getHostPtr();
1929
1930         if (offset)
1931                 deMemset(mapPtr, 0x5A, (size_t)offset);
1932         deMemcpy((deUint8*)mapPtr + offset, value1.getPtr(), sizeof(tcu::Vec4));
1933         deMemcpy((deUint8*)mapPtr + offset + sizeof(tcu::Vec4), value2.getPtr(), sizeof(tcu::Vec4));
1934         deMemset((deUint8*)mapPtr + offset + 2 * sizeof(tcu::Vec4), 0x5A, (size_t)bufferSize - (size_t)offset - 2 * sizeof(tcu::Vec4));
1935
1936         flushMappedMemoryRange(m_vki, m_device, allocation->getMemory(), allocation->getOffset(), bufferSize);
1937
1938         *outAllocation = allocation;
1939         return buffer;
1940 }
1941
1942 vk::Move<vk::VkDescriptorSetLayout> BufferComputeInstance::createDescriptorSetLayout (void) const
1943 {
1944         vk::DescriptorSetLayoutBuilder builder;
1945
1946         builder.addSingleBinding(vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, vk::VK_SHADER_STAGE_COMPUTE_BIT);
1947
1948         switch (m_shaderInterface)
1949         {
1950                 case SHADER_INPUT_SINGLE_DESCRIPTOR:
1951                         builder.addSingleBinding(m_descriptorType, vk::VK_SHADER_STAGE_COMPUTE_BIT);
1952                         break;
1953
1954                 case SHADER_INPUT_MULTIPLE_CONTIGUOUS_DESCRIPTORS:
1955                         builder.addSingleBinding(m_descriptorType, vk::VK_SHADER_STAGE_COMPUTE_BIT);
1956                         builder.addSingleBinding(m_descriptorType, vk::VK_SHADER_STAGE_COMPUTE_BIT);
1957                         break;
1958
1959                 case SHADER_INPUT_DESCRIPTOR_ARRAY:
1960                         builder.addArrayBinding(m_descriptorType, 2u, vk::VK_SHADER_STAGE_COMPUTE_BIT);
1961                         break;
1962
1963                 default:
1964                         DE_FATAL("Impossible");
1965         };
1966
1967         return builder.build(m_vki, m_device);
1968 }
1969
1970 vk::Move<vk::VkDescriptorPool> BufferComputeInstance::createDescriptorPool (void) const
1971 {
1972         return vk::DescriptorPoolBuilder()
1973                 .addType(vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER)
1974                 .addType(m_descriptorType, getInterfaceNumResources(m_shaderInterface))
1975                 .build(m_vki, m_device, vk::VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1);
1976 }
1977
1978 vk::Move<vk::VkDescriptorSet> BufferComputeInstance::createDescriptorSet (vk::VkDescriptorPool pool, vk::VkDescriptorSetLayout layout, vk::VkBuffer viewA, deUint32 offsetA, vk::VkBuffer viewB, deUint32 offsetB, vk::VkBuffer resBuf) const
1979 {
1980         const vk::VkDescriptorBufferInfo                resultInfo              = vk::makeDescriptorBufferInfo(resBuf, 0u, (vk::VkDeviceSize)ComputeInstanceResultBuffer::DATA_SIZE);
1981         const vk::VkDescriptorBufferInfo                bufferInfos[2]  =
1982         {
1983                 vk::makeDescriptorBufferInfo(viewA, (vk::VkDeviceSize)offsetA, (vk::VkDeviceSize)sizeof(tcu::Vec4[2])),
1984                 vk::makeDescriptorBufferInfo(viewB, (vk::VkDeviceSize)offsetB, (vk::VkDeviceSize)sizeof(tcu::Vec4[2])),
1985         };
1986         const vk::VkDescriptorSetAllocateInfo   allocInfo               =
1987         {
1988                 vk::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
1989                 DE_NULL,
1990                 pool,
1991                 1u,
1992                 &layout
1993         };
1994
1995         vk::Move<vk::VkDescriptorSet>   descriptorSet   = allocateDescriptorSet(m_vki, m_device, &allocInfo);
1996         vk::DescriptorSetUpdateBuilder  builder;
1997
1998         // result
1999         builder.writeSingle(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(0u), vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &resultInfo);
2000
2001         // buffers
2002         switch (m_shaderInterface)
2003         {
2004                 case SHADER_INPUT_SINGLE_DESCRIPTOR:
2005                         builder.writeSingle(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(1u), m_descriptorType, &bufferInfos[0]);
2006                         break;
2007
2008                 case SHADER_INPUT_MULTIPLE_CONTIGUOUS_DESCRIPTORS:
2009                         builder.writeSingle(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(1u), m_descriptorType, &bufferInfos[0]);
2010                         builder.writeSingle(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(2u), m_descriptorType, &bufferInfos[1]);
2011                         break;
2012
2013                 case SHADER_INPUT_DESCRIPTOR_ARRAY:
2014                         builder.writeArray(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(1u), m_descriptorType, 2u, bufferInfos);
2015                         break;
2016
2017                 default:
2018                         DE_FATAL("Impossible");
2019         }
2020
2021         builder.update(m_vki, m_device);
2022         return descriptorSet;
2023 }
2024
2025 tcu::TestStatus BufferComputeInstance::iterate (void)
2026 {
2027         logTestPlan();
2028         return testResourceAccess();
2029 }
2030
2031 void BufferComputeInstance::logTestPlan (void) const
2032 {
2033         std::ostringstream msg;
2034
2035         msg << "Accessing resource in a compute program.\n"
2036                 << "Single descriptor set. Descriptor set contains "
2037                         << ((m_shaderInterface == SHADER_INPUT_SINGLE_DESCRIPTOR) ? "single" :
2038                                 (m_shaderInterface == SHADER_INPUT_MULTIPLE_CONTIGUOUS_DESCRIPTORS) ? "two" :
2039                                 (m_shaderInterface == SHADER_INPUT_DESCRIPTOR_ARRAY) ? "an array (size 2) of" :
2040                                 (const char*)DE_NULL)
2041                 << " source descriptor(s) of type " << vk::getDescriptorTypeName(m_descriptorType)
2042                 << " and one destination VK_DESCRIPTOR_TYPE_STORAGE_BUFFER to store results to.\n"
2043                 << "Source descriptor buffer view(s) have " << ((m_setViewOffset) ? ("non-") : ("")) << "zero offset.\n";
2044
2045         if (isDynamicDescriptorType(m_descriptorType))
2046         {
2047                 if (m_setDynamicOffset)
2048                 {
2049                         msg << "Source buffer(s) are given a dynamic offset at bind time.\n"
2050                                 << "The supplied dynamic offset is " << ((m_dynamicOffsetNonZero) ? ("non-") : ("")) << "zero.\n";
2051                 }
2052                 else
2053                 {
2054                         msg << "Dynamic offset is not supplied at bind time. Expecting bind to offset 0.\n";
2055                 }
2056         }
2057
2058         msg << "Destination buffer is pre-initialized to -1.\n";
2059
2060         m_context.getTestContext().getLog()
2061                 << tcu::TestLog::Message
2062                 << msg.str()
2063                 << tcu::TestLog::EndMessage;
2064 }
2065
2066 tcu::TestStatus BufferComputeInstance::testResourceAccess (void)
2067 {
2068         enum
2069         {
2070                 ADDRESSABLE_SIZE = 256, // allocate a lot more than required
2071         };
2072
2073         const bool                                                                              isDynamicCase           = isDynamicDescriptorType(m_descriptorType);
2074         const bool                                                                              isUniformBuffer         = isUniformDescriptorType(m_descriptorType);
2075         const deUint32                                                                  bindTimeOffsets[]       =
2076         {
2077                 (m_dynamicOffsetNonZero) ? ((deUint32)DYNAMIC_OFFSET_VALUE_A) : (0u),
2078                 (m_dynamicOffsetNonZero) ? ((deUint32)DYNAMIC_OFFSET_VALUE_B) : (0u),
2079         };
2080
2081         const tcu::Vec4                                                                 colorA1                         = tcu::Vec4(0.0f, 1.0f, 0.0f, 1.0f);
2082         const tcu::Vec4                                                                 colorA2                         = tcu::Vec4(1.0f, 1.0f, 0.0f, 1.0f);
2083         const tcu::Vec4                                                                 colorB1                         = tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f);
2084         const tcu::Vec4                                                                 colorB2                         = tcu::Vec4(0.0f, 0.0f, 1.0f, 1.0f);
2085
2086         const deUint32                                                                  dataOffsetA                     = ((isDynamicCase) ? (bindTimeOffsets[0]) : 0) + ((m_setViewOffset) ? ((deUint32)STATIC_OFFSET_VALUE_A) : (0u));
2087         const deUint32                                                                  dataOffsetB                     = ((isDynamicCase) ? (bindTimeOffsets[1]) : 0) + ((m_setViewOffset) ? ((deUint32)STATIC_OFFSET_VALUE_B) : (0u));
2088         const deUint32                                                                  viewOffsetA                     = (m_setViewOffset) ? ((deUint32)STATIC_OFFSET_VALUE_A) : (0u);
2089         const deUint32                                                                  viewOffsetB                     = (m_setViewOffset) ? ((deUint32)STATIC_OFFSET_VALUE_B) : (0u);
2090         const deUint32                                                                  bufferSizeA                     = dataOffsetA + ADDRESSABLE_SIZE;
2091         const deUint32                                                                  bufferSizeB                     = dataOffsetB + ADDRESSABLE_SIZE;
2092
2093         de::MovePtr<vk::Allocation>                                             bufferMemA;
2094         const vk::Unique<vk::VkBuffer>                                  bufferA                         (createColorDataBuffer(dataOffsetA, bufferSizeA, colorA1, colorA2, &bufferMemA));
2095
2096         de::MovePtr<vk::Allocation>                                             bufferMemB;
2097         const vk::Unique<vk::VkBuffer>                                  bufferB                         ((getInterfaceNumResources(m_shaderInterface) == 1u)
2098                                                                                                                                                         ? (vk::Move<vk::VkBuffer>())
2099                                                                                                                                                         : (createColorDataBuffer(dataOffsetB, bufferSizeB, colorB1, colorB2, &bufferMemB)));
2100
2101         const vk::Unique<vk::VkDescriptorSetLayout>             descriptorSetLayout     (createDescriptorSetLayout());
2102         const vk::Unique<vk::VkDescriptorPool>                  descriptorPool          (createDescriptorPool());
2103         const vk::Unique<vk::VkDescriptorSet>                   descriptorSet           (createDescriptorSet(*descriptorPool, *descriptorSetLayout, *bufferA, viewOffsetA, *bufferB, viewOffsetB, m_result.getBuffer()));
2104         const ComputePipeline                                                   pipeline                        (m_vki, m_device, m_context.getBinaryCollection(), 1, &descriptorSetLayout.get());
2105
2106         const vk::VkAccessFlags                                                 inputBit                        = (isUniformBuffer) ? (vk::VK_ACCESS_UNIFORM_READ_BIT) : (vk::VK_ACCESS_SHADER_READ_BIT);
2107         const vk::VkBufferMemoryBarrier                                 bufferBarriers[]        =
2108         {
2109                 {
2110                         vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
2111                         DE_NULL,
2112                         vk::VK_ACCESS_HOST_WRITE_BIT,                           // outputMask
2113                         inputBit,                                                                       // inputMask
2114                         vk::VK_QUEUE_FAMILY_IGNORED,                            // srcQueueFamilyIndex
2115                         vk::VK_QUEUE_FAMILY_IGNORED,                            // destQueueFamilyIndex
2116                         *bufferA,                                                                       // buffer
2117                         (vk::VkDeviceSize)0u,                                           // offset
2118                         (vk::VkDeviceSize)bufferSizeA,                          // size
2119                 },
2120                 {
2121                         vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
2122                         DE_NULL,
2123                         vk::VK_ACCESS_HOST_WRITE_BIT,                           // outputMask
2124                         inputBit,                                                                       // inputMask
2125                         vk::VK_QUEUE_FAMILY_IGNORED,                            // srcQueueFamilyIndex
2126                         vk::VK_QUEUE_FAMILY_IGNORED,                            // destQueueFamilyIndex
2127                         *bufferB,                                                                       // buffer
2128                         (vk::VkDeviceSize)0u,                                           // offset
2129                         (vk::VkDeviceSize)bufferSizeB,                          // size
2130                 }
2131         };
2132
2133         const deUint32                                                                  numSrcBuffers           = getInterfaceNumResources(m_shaderInterface);
2134
2135         const vk::VkDescriptorSet                                               descriptorSets[]        = { *descriptorSet };
2136         const int                                                                               numDescriptorSets       = DE_LENGTH_OF_ARRAY(descriptorSets);
2137         const deUint32* const                                                   dynamicOffsets          = (m_setDynamicOffset) ? (bindTimeOffsets) : (DE_NULL);
2138         const deUint32                                                                  numDynamicOffsets       = (m_setDynamicOffset) ? (numSrcBuffers) : (0);
2139         const vk::VkBufferMemoryBarrier* const                  preBarriers                     = bufferBarriers;
2140         const int                                                                               numPreBarriers          = numSrcBuffers;
2141         const vk::VkBufferMemoryBarrier* const                  postBarriers            = m_result.getResultReadBarrier();
2142         const int                                                                               numPostBarriers         = 1;
2143
2144         const ComputeCommand                                                    compute                         (m_vki,
2145                                                                                                                                                  m_device,
2146                                                                                                                                                  pipeline.getPipeline(),
2147                                                                                                                                                  pipeline.getPipelineLayout(),
2148                                                                                                                                                  tcu::UVec3(4, 1, 1),
2149                                                                                                                                                  numDescriptorSets,     descriptorSets,
2150                                                                                                                                                  numDynamicOffsets,     dynamicOffsets,
2151                                                                                                                                                  numPreBarriers,        preBarriers,
2152                                                                                                                                                  numPostBarriers,       postBarriers);
2153
2154         const tcu::Vec4                                                                 refQuadrantValue14      = (m_shaderInterface == SHADER_INPUT_SINGLE_DESCRIPTOR)                                         ? (colorA2) :
2155                                                                                                                                                   (m_shaderInterface == SHADER_INPUT_MULTIPLE_CONTIGUOUS_DESCRIPTORS)           ? (colorB2) :
2156                                                                                                                                                   (m_shaderInterface == SHADER_INPUT_DESCRIPTOR_ARRAY)                                          ? (colorB2) :
2157                                                                                                                                                                                                                                                                                                         (tcu::Vec4(-2.0f));
2158         const tcu::Vec4                                                                 refQuadrantValue23      = (m_shaderInterface == SHADER_INPUT_SINGLE_DESCRIPTOR)                                         ? (colorA1) :
2159                                                                                                                                                   (m_shaderInterface == SHADER_INPUT_MULTIPLE_CONTIGUOUS_DESCRIPTORS)           ? (colorA1) :
2160                                                                                                                                                   (m_shaderInterface == SHADER_INPUT_DESCRIPTOR_ARRAY)                                          ? (colorA1) :
2161                                                                                                                                                                                                                                                                                                         (tcu::Vec4(-2.0f));
2162         const tcu::Vec4                                                                 references[4]           =
2163         {
2164                 refQuadrantValue14,
2165                 refQuadrantValue23,
2166                 refQuadrantValue23,
2167                 refQuadrantValue14,
2168         };
2169         tcu::Vec4                                                                               results[4];
2170
2171         compute.submitAndWait(m_queueFamilyIndex, m_queue);
2172         m_result.readResultContentsTo(&results);
2173
2174         // verify
2175         if (results[0] == references[0] &&
2176                 results[1] == references[1] &&
2177                 results[2] == references[2] &&
2178                 results[3] == references[3])
2179         {
2180                 return tcu::TestStatus::pass("Pass");
2181         }
2182         else if (results[0] == tcu::Vec4(-1.0f) &&
2183                          results[1] == tcu::Vec4(-1.0f) &&
2184                          results[2] == tcu::Vec4(-1.0f) &&
2185                          results[3] == tcu::Vec4(-1.0f))
2186         {
2187                 m_context.getTestContext().getLog()
2188                         << tcu::TestLog::Message
2189                         << "Result buffer was not written to."
2190                         << tcu::TestLog::EndMessage;
2191                 return tcu::TestStatus::fail("Result buffer was not written to");
2192         }
2193         else
2194         {
2195                 m_context.getTestContext().getLog()
2196                         << tcu::TestLog::Message
2197                         << "Error expected ["
2198                                 << references[0] << ", "
2199                                 << references[1] << ", "
2200                                 << references[2] << ", "
2201                                 << references[3] << "], got ["
2202                                 << results[0] << ", "
2203                                 << results[1] << ", "
2204                                 << results[2] << ", "
2205                                 << results[3] << "]"
2206                         << tcu::TestLog::EndMessage;
2207                 return tcu::TestStatus::fail("Invalid result values");
2208         }
2209 }
2210
2211 class QuadrantRendederCase : public vkt::TestCase
2212 {
2213 public:
2214                                                                         QuadrantRendederCase            (tcu::TestContext&              testCtx,
2215                                                                                                                                  const char*                    name,
2216                                                                                                                                  const char*                    description,
2217                                                                                                                                  glu::GLSLVersion               glslVersion,
2218                                                                                                                                  vk::VkShaderStageFlags exitingStages,
2219                                                                                                                                  vk::VkShaderStageFlags activeStages);
2220 private:
2221         virtual std::string                             genExtensionDeclarations        (vk::VkShaderStageFlagBits stage) const = 0;
2222         virtual std::string                             genResourceDeclarations         (vk::VkShaderStageFlagBits stage, int numUsedBindings) const = 0;
2223         virtual std::string                             genResourceAccessSource         (vk::VkShaderStageFlagBits stage) const = 0;
2224         virtual std::string                             genNoAccessSource                       (void) const = 0;
2225
2226         std::string                                             genVertexSource                         (void) const;
2227         std::string                                             genTessCtrlSource                       (void) const;
2228         std::string                                             genTessEvalSource                       (void) const;
2229         std::string                                             genGeometrySource                       (void) const;
2230         std::string                                             genFragmentSource                       (void) const;
2231         std::string                                             genComputeSource                        (void) const;
2232
2233         void                                                    initPrograms                            (vk::SourceCollections& programCollection) const;
2234
2235 protected:
2236         const glu::GLSLVersion                  m_glslVersion;
2237         const vk::VkShaderStageFlags    m_exitingStages;
2238         const vk::VkShaderStageFlags    m_activeStages;
2239 };
2240
2241 QuadrantRendederCase::QuadrantRendederCase (tcu::TestContext&           testCtx,
2242                                                                                         const char*                             name,
2243                                                                                         const char*                             description,
2244                                                                                         glu::GLSLVersion                glslVersion,
2245                                                                                         vk::VkShaderStageFlags  exitingStages,
2246                                                                                         vk::VkShaderStageFlags  activeStages)
2247         : vkt::TestCase         (testCtx, name, description)
2248         , m_glslVersion         (glslVersion)
2249         , m_exitingStages       (exitingStages)
2250         , m_activeStages        (activeStages)
2251 {
2252         DE_ASSERT((m_exitingStages & m_activeStages) == m_activeStages);
2253 }
2254
2255 std::string QuadrantRendederCase::genVertexSource (void) const
2256 {
2257         const char* const       nextStageName   = ((m_exitingStages & vk::VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) != 0u)      ? ("tsc")
2258                                                                                 : ((m_exitingStages & vk::VK_SHADER_STAGE_GEOMETRY_BIT) != 0u)                          ? ("geo")
2259                                                                                 : ((m_exitingStages & vk::VK_SHADER_STAGE_FRAGMENT_BIT) != 0u)                          ? ("frag")
2260                                                                                 : (DE_NULL);
2261         const char* const       versionDecl             = glu::getGLSLVersionDeclaration(m_glslVersion);
2262         std::ostringstream      buf;
2263
2264         if ((m_activeStages & vk::VK_SHADER_STAGE_VERTEX_BIT) != 0u)
2265         {
2266                 // active vertex shader
2267                 buf << versionDecl << "\n"
2268                         << genExtensionDeclarations(vk::VK_SHADER_STAGE_VERTEX_BIT)
2269                         << genResourceDeclarations(vk::VK_SHADER_STAGE_VERTEX_BIT, 0)
2270                         << "layout(location = 0) out highp vec4 " << nextStageName << "_color;\n"
2271                         << "layout(location = 1) flat out highp int " << nextStageName << "_quadrant_id;\n"
2272                         << "void main (void)\n"
2273                         << "{\n"
2274                         << "    highp vec4 result_position;\n"
2275                         << "    highp int quadrant_id;\n"
2276                         << s_quadrantGenVertexPosSource
2277                         << "    gl_Position = result_position;\n"
2278                         << "    " << nextStageName << "_quadrant_id = quadrant_id;\n"
2279                         << "\n"
2280                         << "    highp vec4 result_color;\n"
2281                         << genResourceAccessSource(vk::VK_SHADER_STAGE_VERTEX_BIT)
2282                         << "    " << nextStageName << "_color = result_color;\n"
2283                         << "}\n";
2284         }
2285         else
2286         {
2287                 // do nothing
2288                 buf << versionDecl << "\n"
2289                         << genExtensionDeclarations(vk::VK_SHADER_STAGE_VERTEX_BIT)
2290                         << "layout(location = 1) flat out highp int " << nextStageName << "_quadrant_id;\n"
2291                         << "void main (void)\n"
2292                         << "{\n"
2293                         << "    highp vec4 result_position;\n"
2294                         << "    highp int quadrant_id;\n"
2295                         << s_quadrantGenVertexPosSource
2296                         << "    gl_Position = result_position;\n"
2297                         << "    " << nextStageName << "_quadrant_id = quadrant_id;\n"
2298                         << "}\n";
2299         }
2300
2301         return buf.str();
2302 }
2303
2304 std::string QuadrantRendederCase::genTessCtrlSource (void) const
2305 {
2306         const char* const       versionDecl             = glu::getGLSLVersionDeclaration(m_glslVersion);
2307         const bool                      extRequired             = glu::glslVersionIsES(m_glslVersion) && m_glslVersion <= glu::GLSL_VERSION_310_ES;
2308         const char* const       tessExtDecl             = extRequired ? "#extension GL_EXT_tessellation_shader : require\n" : "";
2309         std::ostringstream      buf;
2310
2311         if ((m_activeStages & vk::VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) != 0u)
2312         {
2313                 // contributing not implemented
2314                 DE_ASSERT(m_activeStages == vk::VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT);
2315
2316                 // active tc shader
2317                 buf << versionDecl << "\n"
2318                         << tessExtDecl
2319                         << genExtensionDeclarations(vk::VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT)
2320                         << "layout(vertices=3) out;\n"
2321                         << genResourceDeclarations(vk::VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, 0)
2322                         << "layout(location = 1) flat in highp int tsc_quadrant_id[];\n"
2323                         << "layout(location = 0) out highp vec4 tes_color[];\n"
2324                         << "void main (void)\n"
2325                         << "{\n"
2326                         << "    highp vec4 result_color;\n"
2327                         << "    highp int quadrant_id = tsc_quadrant_id[gl_InvocationID];\n"
2328                         << genResourceAccessSource(vk::VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT)
2329                         << "\n"
2330                         << "    tes_color[gl_InvocationID] = result_color;\n"
2331                         << "\n"
2332                         << "    // no dynamic input block indexing\n"
2333                         << "    highp vec4 position;\n"
2334                         << "    if (gl_InvocationID == 0)\n"
2335                         << "            position = gl_in[0].gl_Position;\n"
2336                         << "    else if (gl_InvocationID == 1)\n"
2337                         << "            position = gl_in[1].gl_Position;\n"
2338                         << "    else\n"
2339                         << "            position = gl_in[2].gl_Position;\n"
2340                         << "    gl_out[gl_InvocationID].gl_Position = position;\n"
2341                         << "    gl_TessLevelInner[0] = 2.8;\n"
2342                         << "    gl_TessLevelInner[1] = 2.8;\n"
2343                         << "    gl_TessLevelOuter[0] = 2.8;\n"
2344                         << "    gl_TessLevelOuter[1] = 2.8;\n"
2345                         << "    gl_TessLevelOuter[2] = 2.8;\n"
2346                         << "    gl_TessLevelOuter[3] = 2.8;\n"
2347                         << "}\n";
2348         }
2349         else if ((m_activeStages & vk::VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT) != 0u)
2350         {
2351                 // active te shader, tc passthru
2352                 buf << versionDecl << "\n"
2353                         << tessExtDecl
2354                         << "layout(vertices=3) out;\n"
2355                         << "layout(location = 1) flat in highp int tsc_quadrant_id[];\n"
2356                         << "layout(location = 1) flat out highp int tes_quadrant_id[];\n"
2357                         << "void main (void)\n"
2358                         << "{\n"
2359                         << "    tes_quadrant_id[gl_InvocationID] = tsc_quadrant_id[0];\n"
2360                         << "\n"
2361                         << "    // no dynamic input block indexing\n"
2362                         << "    highp vec4 position;\n"
2363                         << "    if (gl_InvocationID == 0)\n"
2364                         << "            position = gl_in[0].gl_Position;\n"
2365                         << "    else if (gl_InvocationID == 1)\n"
2366                         << "            position = gl_in[1].gl_Position;\n"
2367                         << "    else\n"
2368                         << "            position = gl_in[2].gl_Position;\n"
2369                         << "    gl_out[gl_InvocationID].gl_Position = position;\n"
2370                         << "    gl_TessLevelInner[0] = 2.8;\n"
2371                         << "    gl_TessLevelInner[1] = 2.8;\n"
2372                         << "    gl_TessLevelOuter[0] = 2.8;\n"
2373                         << "    gl_TessLevelOuter[1] = 2.8;\n"
2374                         << "    gl_TessLevelOuter[2] = 2.8;\n"
2375                         << "    gl_TessLevelOuter[3] = 2.8;\n"
2376                         << "}\n";
2377         }
2378         else
2379         {
2380                 // passthrough not implemented
2381                 DE_FATAL("not implemented");
2382         }
2383
2384         return buf.str();
2385 }
2386
2387 std::string QuadrantRendederCase::genTessEvalSource (void) const
2388 {
2389         const char* const       versionDecl             = glu::getGLSLVersionDeclaration(m_glslVersion);
2390         const bool                      extRequired             = glu::glslVersionIsES(m_glslVersion) && m_glslVersion <= glu::GLSL_VERSION_310_ES;
2391         const char* const       tessExtDecl             = extRequired ? "#extension GL_EXT_tessellation_shader : require\n" : "";
2392         std::ostringstream      buf;
2393
2394         if ((m_activeStages & vk::VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT) != 0u)
2395         {
2396                 // contributing not implemented
2397                 DE_ASSERT(m_activeStages == vk::VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT);
2398
2399                 // active te shader
2400                 buf << versionDecl << "\n"
2401                         << tessExtDecl
2402                         << genExtensionDeclarations(vk::VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)
2403                         << "layout(triangles) in;\n"
2404                         << genResourceDeclarations(vk::VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, 0)
2405                         << "layout(location = 1) flat in highp int tes_quadrant_id[];\n"
2406                         << "layout(location = 0) out highp vec4 frag_color;\n"
2407                         << "void main (void)\n"
2408                         << "{\n"
2409                         << "    highp vec4 result_color;\n"
2410                         << "    highp int quadrant_id = tes_quadrant_id[0];\n"
2411                         << genResourceAccessSource(vk::VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)
2412                         << "\n"
2413                         << "    frag_color = result_color;\n"
2414                         << "    gl_Position = gl_TessCoord.x * gl_in[0].gl_Position + gl_TessCoord.y * gl_in[1].gl_Position + gl_TessCoord.z * gl_in[2].gl_Position;\n"
2415                         << "}\n";
2416         }
2417         else if ((m_activeStages & vk::VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) != 0u)
2418         {
2419                 // contributing not implemented
2420                 DE_ASSERT(m_activeStages == vk::VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT);
2421
2422                 // active tc shader, te is passthru
2423                 buf << versionDecl << "\n"
2424                         << tessExtDecl
2425                         << "layout(triangles) in;\n"
2426                         << "layout(location = 0) in highp vec4 tes_color[];\n"
2427                         << "layout(location = 0) out highp vec4 frag_color;\n"
2428                         << "void main (void)\n"
2429                         << "{\n"
2430                         << "    frag_color = tes_color[0];\n"
2431                         << "    gl_Position = gl_TessCoord.x * gl_in[0].gl_Position + gl_TessCoord.y * gl_in[1].gl_Position + gl_TessCoord.z * gl_in[2].gl_Position;\n"
2432                         << "}\n";
2433         }
2434         else
2435         {
2436                 // passthrough not implemented
2437                 DE_FATAL("not implemented");
2438         }
2439
2440         return buf.str();
2441 }
2442
2443 std::string QuadrantRendederCase::genGeometrySource (void) const
2444 {
2445         const char* const       versionDecl             = glu::getGLSLVersionDeclaration(m_glslVersion);
2446         const bool                      extRequired             = glu::glslVersionIsES(m_glslVersion) && m_glslVersion <= glu::GLSL_VERSION_310_ES;
2447         const char* const       geomExtDecl             = extRequired ? "#extension GL_EXT_geometry_shader : require\n" : "";
2448         std::ostringstream      buf;
2449
2450         if ((m_activeStages & vk::VK_SHADER_STAGE_GEOMETRY_BIT) != 0u)
2451         {
2452                 // contributing not implemented
2453                 DE_ASSERT(m_activeStages == vk::VK_SHADER_STAGE_GEOMETRY_BIT);
2454
2455                 // active geometry shader
2456                 buf << versionDecl << "\n"
2457                         << geomExtDecl
2458                         << genExtensionDeclarations(vk::VK_SHADER_STAGE_GEOMETRY_BIT)
2459                         << "layout(triangles) in;\n"
2460                         << "layout(triangle_strip, max_vertices=4) out;\n"
2461                         << genResourceDeclarations(vk::VK_SHADER_STAGE_GEOMETRY_BIT, 0)
2462                         << "layout(location = 1) flat in highp int geo_quadrant_id[];\n"
2463                         << "layout(location = 0) out highp vec4 frag_color;\n"
2464                         << "void main (void)\n"
2465                         << "{\n"
2466                         << "    highp int quadrant_id;\n"
2467                         << "    highp vec4 result_color;\n"
2468                         << "\n"
2469                         << "    quadrant_id = geo_quadrant_id[0];\n"
2470                         << genResourceAccessSource(vk::VK_SHADER_STAGE_GEOMETRY_BIT)
2471                         << "    frag_color = result_color;\n"
2472                         << "    gl_Position = gl_in[0].gl_Position;\n"
2473                         << "    EmitVertex();\n"
2474                         << "\n"
2475                         << "    quadrant_id = geo_quadrant_id[1];\n"
2476                         << genResourceAccessSource(vk::VK_SHADER_STAGE_GEOMETRY_BIT)
2477                         << "    frag_color = result_color;\n"
2478                         << "    gl_Position = gl_in[1].gl_Position;\n"
2479                         << "    EmitVertex();\n"
2480                         << "\n"
2481                         << "    quadrant_id = geo_quadrant_id[2];\n"
2482                         << genResourceAccessSource(vk::VK_SHADER_STAGE_GEOMETRY_BIT)
2483                         << "    frag_color = result_color;\n"
2484                         << "    gl_Position = gl_in[0].gl_Position * 0.5 + gl_in[2].gl_Position * 0.5;\n"
2485                         << "    EmitVertex();\n"
2486                         << "\n"
2487                         << "    quadrant_id = geo_quadrant_id[0];\n"
2488                         << genResourceAccessSource(vk::VK_SHADER_STAGE_GEOMETRY_BIT)
2489                         << "    frag_color = result_color;\n"
2490                         << "    gl_Position = gl_in[2].gl_Position;\n"
2491                         << "    EmitVertex();\n"
2492                         << "}\n";
2493         }
2494         else
2495         {
2496                 // passthrough not implemented
2497                 DE_FATAL("not implemented");
2498         }
2499
2500         return buf.str();
2501 }
2502
2503 std::string QuadrantRendederCase::genFragmentSource (void) const
2504 {
2505         const char* const       versionDecl             = glu::getGLSLVersionDeclaration(m_glslVersion);
2506         std::ostringstream      buf;
2507
2508         if ((m_activeStages & vk::VK_SHADER_STAGE_FRAGMENT_BIT) != 0u)
2509         {
2510                 buf << versionDecl << "\n"
2511                         << genExtensionDeclarations(vk::VK_SHADER_STAGE_GEOMETRY_BIT)
2512                         << genResourceDeclarations(vk::VK_SHADER_STAGE_FRAGMENT_BIT, 0);
2513
2514                 if (m_activeStages != vk::VK_SHADER_STAGE_FRAGMENT_BIT)
2515                 {
2516                         // there are other stages, this is just a contributor
2517                         buf << "layout(location = 0) in mediump vec4 frag_color;\n";
2518                 }
2519
2520                 buf << "layout(location = 1) flat in highp int frag_quadrant_id;\n"
2521                         << "layout(location = 0) out mediump vec4 o_color;\n"
2522                         << "void main (void)\n"
2523                         << "{\n"
2524                         << "    highp int quadrant_id = frag_quadrant_id;\n"
2525                         << "    highp vec4 result_color;\n"
2526                         << genResourceAccessSource(vk::VK_SHADER_STAGE_FRAGMENT_BIT);
2527
2528                 if (m_activeStages != vk::VK_SHADER_STAGE_FRAGMENT_BIT)
2529                 {
2530                         // just contributor
2531                         buf     << "    if (frag_quadrant_id < 2)\n"
2532                                 << "            o_color = result_color;\n"
2533                                 << "    else\n"
2534                                 << "            o_color = frag_color;\n";
2535                 }
2536                 else
2537                         buf << "        o_color = result_color;\n";
2538
2539                 buf << "}\n";
2540         }
2541         else if (m_activeStages == 0u)
2542         {
2543                 // special case, no active stages
2544                 buf << versionDecl << "\n"
2545                         << "layout(location = 1) flat in highp int frag_quadrant_id;\n"
2546                         << "layout(location = 0) out mediump vec4 o_color;\n"
2547                         << "void main (void)\n"
2548                         << "{\n"
2549                         << "    highp int quadrant_id = frag_quadrant_id;\n"
2550                         << "    highp vec4 result_color;\n"
2551                         << genNoAccessSource()
2552                         << "    o_color = result_color;\n"
2553                         << "}\n";
2554         }
2555         else
2556         {
2557                 // passthrough
2558                 buf <<  versionDecl << "\n"
2559                         <<      "layout(location = 0) in mediump vec4 frag_color;\n"
2560                                 "layout(location = 0) out mediump vec4 o_color;\n"
2561                                 "void main (void)\n"
2562                                 "{\n"
2563                                 "       o_color = frag_color;\n"
2564                                 "}\n";
2565         }
2566
2567         return buf.str();
2568 }
2569
2570 std::string QuadrantRendederCase::genComputeSource (void) const
2571 {
2572         const char* const       versionDecl             = glu::getGLSLVersionDeclaration(m_glslVersion);
2573         std::ostringstream      buf;
2574
2575         buf     << versionDecl << "\n"
2576                 << genExtensionDeclarations(vk::VK_SHADER_STAGE_COMPUTE_BIT)
2577                 << "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n"
2578                 << genResourceDeclarations(vk::VK_SHADER_STAGE_COMPUTE_BIT, 1)
2579                 << "layout(set = 0, binding = 0, std140) writeonly buffer OutBuf\n"
2580                 << "{\n"
2581                 << "    highp vec4 read_colors[4];\n"
2582                 << "} b_out;\n"
2583                 << "void main(void)\n"
2584                 << "{\n"
2585                 << "    highp int quadrant_id = int(gl_WorkGroupID.x);\n"
2586                 << "    highp vec4 result_color;\n"
2587                 << genResourceAccessSource(vk::VK_SHADER_STAGE_COMPUTE_BIT)
2588                 << "    b_out.read_colors[gl_WorkGroupID.x] = result_color;\n"
2589                 << "}\n";
2590
2591         return buf.str();
2592 }
2593
2594 void QuadrantRendederCase::initPrograms (vk::SourceCollections& programCollection) const
2595 {
2596         if ((m_exitingStages & vk::VK_SHADER_STAGE_VERTEX_BIT) != 0u)
2597                 programCollection.glslSources.add("vertex") << glu::VertexSource(genVertexSource());
2598
2599         if ((m_exitingStages & vk::VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) != 0u)
2600                 programCollection.glslSources.add("tess_ctrl") << glu::TessellationControlSource(genTessCtrlSource());
2601
2602         if ((m_exitingStages & vk::VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT) != 0u)
2603                 programCollection.glslSources.add("tess_eval") << glu::TessellationEvaluationSource(genTessEvalSource());
2604
2605         if ((m_exitingStages & vk::VK_SHADER_STAGE_GEOMETRY_BIT) != 0u)
2606                 programCollection.glslSources.add("geometry") << glu::GeometrySource(genGeometrySource());
2607
2608         if ((m_exitingStages & vk::VK_SHADER_STAGE_FRAGMENT_BIT) != 0u)
2609                 programCollection.glslSources.add("fragment") << glu::FragmentSource(genFragmentSource());
2610
2611         if ((m_exitingStages & vk::VK_SHADER_STAGE_COMPUTE_BIT) != 0u)
2612                 programCollection.glslSources.add("compute") << glu::ComputeSource(genComputeSource());
2613 }
2614
2615 class BufferDescriptorCase : public QuadrantRendederCase
2616 {
2617 public:
2618         enum
2619         {
2620                 FLAG_VIEW_OFFSET                        = (1u << 1u),
2621                 FLAG_DYNAMIC_OFFSET_ZERO        = (1u << 2u),
2622                 FLAG_DYNAMIC_OFFSET_NONZERO     = (1u << 3u),
2623         };
2624         // enum continues where resource flags ends
2625         DE_STATIC_ASSERT((deUint32)FLAG_VIEW_OFFSET == (deUint32)RESOURCE_FLAG_LAST);
2626
2627                                                                         BufferDescriptorCase            (tcu::TestContext&              testCtx,
2628                                                                                                                                  const char*                    name,
2629                                                                                                                                  const char*                    description,
2630                                                                                                                                  bool                                   isPrimaryCmdBuf,
2631                                                                                                                                  vk::VkDescriptorType   descriptorType,
2632                                                                                                                                  vk::VkShaderStageFlags exitingStages,
2633                                                                                                                                  vk::VkShaderStageFlags activeStages,
2634                                                                                                                                  ShaderInputInterface   shaderInterface,
2635                                                                                                                                  deUint32                               flags);
2636
2637 private:
2638         std::string                                             genExtensionDeclarations        (vk::VkShaderStageFlagBits stage) const;
2639         std::string                                             genResourceDeclarations         (vk::VkShaderStageFlagBits stage, int numUsedBindings) const;
2640         std::string                                             genResourceAccessSource         (vk::VkShaderStageFlagBits stage) const;
2641         std::string                                             genNoAccessSource                       (void) const;
2642
2643         vkt::TestInstance*                              createInstance                          (vkt::Context& context) const;
2644
2645         const bool                                              m_viewOffset;
2646         const bool                                              m_dynamicOffsetSet;
2647         const bool                                              m_dynamicOffsetNonZero;
2648         const bool                                              m_isPrimaryCmdBuf;
2649         const vk::VkDescriptorType              m_descriptorType;
2650         const ShaderInputInterface              m_shaderInterface;
2651 };
2652
2653 BufferDescriptorCase::BufferDescriptorCase (tcu::TestContext&           testCtx,
2654                                                                                         const char*                             name,
2655                                                                                         const char*                             description,
2656                                                                                         bool                                    isPrimaryCmdBuf,
2657                                                                                         vk::VkDescriptorType    descriptorType,
2658                                                                                         vk::VkShaderStageFlags  exitingStages,
2659                                                                                         vk::VkShaderStageFlags  activeStages,
2660                                                                                         ShaderInputInterface    shaderInterface,
2661                                                                                         deUint32                                flags)
2662         : QuadrantRendederCase          (testCtx, name, description, glu::GLSL_VERSION_310_ES, exitingStages, activeStages)
2663         , m_viewOffset                          ((flags & FLAG_VIEW_OFFSET) != 0u)
2664         , m_dynamicOffsetSet            ((flags & (FLAG_DYNAMIC_OFFSET_ZERO | FLAG_DYNAMIC_OFFSET_NONZERO)) != 0u)
2665         , m_dynamicOffsetNonZero        ((flags & FLAG_DYNAMIC_OFFSET_NONZERO) != 0u)
2666         , m_isPrimaryCmdBuf                     (isPrimaryCmdBuf)
2667         , m_descriptorType                      (descriptorType)
2668         , m_shaderInterface                     (shaderInterface)
2669 {
2670 }
2671
2672 std::string BufferDescriptorCase::genExtensionDeclarations (vk::VkShaderStageFlagBits stage) const
2673 {
2674         DE_UNREF(stage);
2675         return "";
2676 }
2677
2678 std::string BufferDescriptorCase::genResourceDeclarations (vk::VkShaderStageFlagBits stage, int numUsedBindings) const
2679 {
2680         DE_UNREF(stage);
2681
2682         const bool                      isUniform               = isUniformDescriptorType(m_descriptorType);
2683         const char* const       storageType             = (isUniform) ? ("uniform") : ("buffer");
2684         std::ostringstream      buf;
2685
2686         switch (m_shaderInterface)
2687         {
2688                 case SHADER_INPUT_SINGLE_DESCRIPTOR:
2689                         buf     << "layout(set = 0, binding = " << (numUsedBindings) << ", std140) " << storageType << " BufferName\n"
2690                                 << "{\n"
2691                                 << "    highp vec4 colorA;\n"
2692                                 << "    highp vec4 colorB;\n"
2693                                 << "} b_instance;\n";
2694                         break;
2695
2696                 case SHADER_INPUT_MULTIPLE_CONTIGUOUS_DESCRIPTORS:
2697                         buf     << "layout(set = 0, binding = " << (numUsedBindings) << ", std140) " << storageType << " BufferNameA\n"
2698                                 << "{\n"
2699                                 << "    highp vec4 colorA;\n"
2700                                 << "    highp vec4 colorB;\n"
2701                                 << "} b_instanceA;\n"
2702                                 << "layout(set = 0, binding = " << (numUsedBindings+1) << ", std140) " << storageType << " BufferNameB\n"
2703                                 << "{\n"
2704                                 << "    highp vec4 colorA;\n"
2705                                 << "    highp vec4 colorB;\n"
2706                                 << "} b_instanceB;\n";
2707                         break;
2708
2709                 case SHADER_INPUT_DESCRIPTOR_ARRAY:
2710                         buf     << "layout(set = 0, binding = " << (numUsedBindings) << ", std140) " << storageType << " BufferName\n"
2711                                 << "{\n"
2712                                 << "    highp vec4 colorA;\n"
2713                                 << "    highp vec4 colorB;\n"
2714                                 << "} b_instances[2];\n";
2715                         break;
2716
2717                 default:
2718                         DE_FATAL("Impossible");
2719         }
2720
2721         return buf.str();
2722 }
2723
2724 std::string BufferDescriptorCase::genResourceAccessSource (vk::VkShaderStageFlagBits stage) const
2725 {
2726         DE_UNREF(stage);
2727
2728         std::ostringstream buf;
2729
2730         switch (m_shaderInterface)
2731         {
2732                 case SHADER_INPUT_SINGLE_DESCRIPTOR:
2733                         buf << "        if (quadrant_id == 1 || quadrant_id == 2)\n"
2734                                 << "            result_color = b_instance.colorA;\n"
2735                                 << "    else\n"
2736                                 << "            result_color = b_instance.colorB;\n";
2737                         break;
2738
2739                 case SHADER_INPUT_MULTIPLE_CONTIGUOUS_DESCRIPTORS:
2740                         buf << "        if (quadrant_id == 1 || quadrant_id == 2)\n"
2741                                 << "            result_color = b_instanceA.colorA;\n"
2742                                 << "    else\n"
2743                                 << "            result_color = b_instanceB.colorB;\n";
2744                         break;
2745
2746                 case SHADER_INPUT_DESCRIPTOR_ARRAY:
2747                         buf << "        if (quadrant_id == 1 || quadrant_id == 2)\n"
2748                                 << "            result_color = b_instances[0].colorA;\n"
2749                                 << "    else\n"
2750                                 << "            result_color = b_instances[1].colorB;\n";
2751                         break;
2752
2753                 default:
2754                         DE_FATAL("Impossible");
2755         }
2756
2757         return buf.str();
2758 }
2759
2760 std::string BufferDescriptorCase::genNoAccessSource (void) const
2761 {
2762         return "        if (quadrant_id == 1 || quadrant_id == 2)\n"
2763                    "            result_color = vec4(0.0, 1.0, 0.0, 1.0);\n"
2764                    "    else\n"
2765                    "            result_color = vec4(1.0, 1.0, 0.0, 1.0);\n";
2766 }
2767
2768 vkt::TestInstance* BufferDescriptorCase::createInstance (vkt::Context& context) const
2769 {
2770         verifyDriverSupport(context.getDeviceFeatures(), m_descriptorType, m_activeStages);
2771
2772         if (m_exitingStages == vk::VK_SHADER_STAGE_COMPUTE_BIT)
2773         {
2774                 DE_ASSERT(m_isPrimaryCmdBuf); // secondaries are only valid within renderpass
2775                 return new BufferComputeInstance(context, m_descriptorType, m_shaderInterface, m_viewOffset, m_dynamicOffsetSet, m_dynamicOffsetNonZero);
2776         }
2777         else
2778                 return new BufferRenderInstance(context, m_isPrimaryCmdBuf, m_descriptorType, m_activeStages, m_shaderInterface, m_viewOffset, m_dynamicOffsetSet, m_dynamicOffsetNonZero);
2779 }
2780
2781 class ImageInstanceImages
2782 {
2783 public:
2784                                                                                 ImageInstanceImages             (const vk::DeviceInterface&             vki,
2785                                                                                                                                  vk::VkDevice                                   device,
2786                                                                                                                                  deUint32                                               queueFamilyIndex,
2787                                                                                                                                  vk::VkQueue                                    queue,
2788                                                                                                                                  vk::Allocator&                                 allocator,
2789                                                                                                                                  vk::VkDescriptorType                   descriptorType,
2790                                                                                                                                  vk::VkImageViewType                    viewType,
2791                                                                                                                                  int                                                    numImages,
2792                                                                                                                                  deUint32                                               baseMipLevel,
2793                                                                                                                                  deUint32                                               baseArraySlice);
2794
2795 private:
2796         static vk::Move<vk::VkImage>            createImage                             (const vk::DeviceInterface&                     vki,
2797                                                                                                                                  vk::VkDevice                                           device,
2798                                                                                                                                  vk::Allocator&                                         allocator,
2799                                                                                                                                  vk::VkDescriptorType                           descriptorType,
2800                                                                                                                                  vk::VkImageViewType                            viewType,
2801                                                                                                                                  const tcu::TextureLevelPyramid&        sourceImage,
2802                                                                                                                                  de::MovePtr<vk::Allocation>*           outAllocation);
2803
2804         static vk::Move<vk::VkImageView>        createImageView                 (const vk::DeviceInterface&                     vki,
2805                                                                                                                                  vk::VkDevice                                           device,
2806                                                                                                                                  vk::VkImageViewType                            viewType,
2807                                                                                                                                  const tcu::TextureLevelPyramid&        sourceImage,
2808                                                                                                                                  vk::VkImage                                            image,
2809                                                                                                                                  deUint32                                                       baseMipLevel,
2810                                                                                                                                  deUint32                                                       baseArraySlice);
2811
2812         void                                                            populateSourceImage             (tcu::TextureLevelPyramid*                      dst,
2813                                                                                                                                  bool                                                           isFirst) const;
2814
2815         void                                                            uploadImage                             (const vk::DeviceInterface&                     vki,
2816                                                                                                                                  vk::VkDevice                                           device,
2817                                                                                                                                  deUint32                                                       queueFamilyIndex,
2818                                                                                                                                  vk::VkQueue                                            queue,
2819                                                                                                                                  vk::Allocator&                                         allocator,
2820                                                                                                                                  vk::VkImage                                            image,
2821                                                                                                                                  vk::VkImageLayout                                      layout,
2822                                                                                                                                  const tcu::TextureLevelPyramid&        data);
2823
2824 protected:
2825         enum
2826         {
2827                 IMAGE_SIZE              = 64,
2828                 NUM_MIP_LEVELS  = 2,
2829                 ARRAY_SIZE              = 2,
2830         };
2831
2832         const vk::VkImageViewType                       m_viewType;
2833         const deUint32                                          m_baseMipLevel;
2834         const deUint32                                          m_baseArraySlice;
2835
2836         const tcu::TextureFormat                        m_imageFormat;
2837         tcu::TextureLevelPyramid                        m_sourceImageA;
2838         tcu::TextureLevelPyramid                        m_sourceImageB;
2839
2840         de::MovePtr<vk::Allocation>                     m_imageMemoryA;
2841         de::MovePtr<vk::Allocation>                     m_imageMemoryB;
2842         vk::Move<vk::VkImage>                           m_imageA;
2843         vk::Move<vk::VkImage>                           m_imageB;
2844         vk::Move<vk::VkImageView>                       m_imageViewA;
2845         vk::Move<vk::VkImageView>                       m_imageViewB;
2846 };
2847
2848 ImageInstanceImages::ImageInstanceImages (const vk::DeviceInterface&    vki,
2849                                                                                   vk::VkDevice                                  device,
2850                                                                                   deUint32                                              queueFamilyIndex,
2851                                                                                   vk::VkQueue                                   queue,
2852                                                                                   vk::Allocator&                                allocator,
2853                                                                                   vk::VkDescriptorType                  descriptorType,
2854                                                                                   vk::VkImageViewType                   viewType,
2855                                                                                   int                                                   numImages,
2856                                                                                   deUint32                                              baseMipLevel,
2857                                                                                   deUint32                                              baseArraySlice)
2858         : m_viewType            (viewType)
2859         , m_baseMipLevel        (baseMipLevel)
2860         , m_baseArraySlice      (baseArraySlice)
2861         , m_imageFormat         (tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8)
2862         , m_sourceImageA        (m_imageFormat, NUM_MIP_LEVELS)
2863         , m_sourceImageB        (m_imageFormat, NUM_MIP_LEVELS)
2864         , m_imageMemoryA        (DE_NULL)
2865         , m_imageMemoryB        (DE_NULL)
2866         , m_imageA                      (vk::Move<vk::VkImage>())
2867         , m_imageB                      (vk::Move<vk::VkImage>())
2868         , m_imageViewA          (vk::Move<vk::VkImageView>())
2869         , m_imageViewB          (vk::Move<vk::VkImageView>())
2870 {
2871         const vk::VkImageLayout layout  = getImageLayoutForDescriptorType(descriptorType);
2872
2873         DE_ASSERT(numImages == 1 || numImages == 2);
2874
2875         populateSourceImage(&m_sourceImageA, true);
2876         m_imageA = createImage(vki, device, allocator, descriptorType, viewType, m_sourceImageA, &m_imageMemoryA);
2877         m_imageViewA = createImageView(vki, device, viewType, m_sourceImageA, *m_imageA, m_baseMipLevel, m_baseArraySlice);
2878         uploadImage(vki, device, queueFamilyIndex, queue, allocator, *m_imageA, layout, m_sourceImageA);
2879
2880         if (numImages == 2)
2881         {
2882                 populateSourceImage(&m_sourceImageB, false);
2883                 m_imageB = createImage(vki, device, allocator, descriptorType, viewType, m_sourceImageB, &m_imageMemoryB);
2884                 m_imageViewB = createImageView(vki, device, viewType, m_sourceImageB, *m_imageB, m_baseMipLevel, m_baseArraySlice);
2885                 uploadImage(vki, device, queueFamilyIndex, queue, allocator, *m_imageB, layout, m_sourceImageB);
2886         }
2887 }
2888
2889 vk::Move<vk::VkImage> ImageInstanceImages::createImage (const vk::DeviceInterface&                      vki,
2890                                                                                                                 vk::VkDevice                                            device,
2891                                                                                                                 vk::Allocator&                                          allocator,
2892                                                                                                                 vk::VkDescriptorType                            descriptorType,
2893                                                                                                                 vk::VkImageViewType                                     viewType,
2894                                                                                                                 const tcu::TextureLevelPyramid&         sourceImage,
2895                                                                                                                 de::MovePtr<vk::Allocation>*            outAllocation)
2896 {
2897         const tcu::ConstPixelBufferAccess       baseLevel       = sourceImage.getLevel(0);
2898         const bool                                                      isCube          = (viewType == vk::VK_IMAGE_VIEW_TYPE_CUBE || viewType == vk::VK_IMAGE_VIEW_TYPE_CUBE_ARRAY);
2899         const bool                                                      isStorage       = (descriptorType == vk::VK_DESCRIPTOR_TYPE_STORAGE_IMAGE);
2900         const deUint32                                          readUsage       = (isStorage) ? (vk::VK_IMAGE_USAGE_STORAGE_BIT) : (vk::VK_IMAGE_USAGE_SAMPLED_BIT);
2901         const deUint32                                          arraySize       = (viewType == vk::VK_IMAGE_VIEW_TYPE_1D || viewType == vk::VK_IMAGE_VIEW_TYPE_1D_ARRAY)                ? (baseLevel.getHeight())
2902                                                                                                         : (viewType == vk::VK_IMAGE_VIEW_TYPE_2D || viewType == vk::VK_IMAGE_VIEW_TYPE_2D_ARRAY)                ? (baseLevel.getDepth())
2903                                                                                                         : (viewType == vk::VK_IMAGE_VIEW_TYPE_3D)                                                                                                               ? (1)
2904                                                                                                         : (viewType == vk::VK_IMAGE_VIEW_TYPE_CUBE || viewType == vk::VK_IMAGE_VIEW_TYPE_CUBE_ARRAY)    ? (baseLevel.getDepth()) // cube: numFaces * numLayers
2905                                                                                                                                                                                                                                                                                                         : (0);
2906         const vk::VkExtent3D                            extent          =
2907         {
2908                 // x
2909                 (deUint32)baseLevel.getWidth(),
2910
2911                 // y
2912                 (viewType == vk::VK_IMAGE_VIEW_TYPE_1D || viewType == vk::VK_IMAGE_VIEW_TYPE_1D_ARRAY) ? (1u) : (deUint32)baseLevel.getHeight(),
2913
2914                 // z
2915                 (viewType == vk::VK_IMAGE_VIEW_TYPE_3D) ? ((deUint32)baseLevel.getDepth()) : (1u),
2916         };
2917         const vk::VkImageCreateInfo                     createInfo      =
2918         {
2919                 vk::VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
2920                 DE_NULL,
2921                 isCube ? (vk::VkImageCreateFlags)vk::VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT : (vk::VkImageCreateFlags)0,
2922                 viewTypeToImageType(viewType),                                                                                  // imageType
2923                 vk::mapTextureFormat(baseLevel.getFormat()),                                                    // format
2924                 extent,                                                                                                                                 // extent
2925                 (deUint32)sourceImage.getNumLevels(),                                                                   // mipLevels
2926                 arraySize,                                                                                                                              // arraySize
2927                 vk::VK_SAMPLE_COUNT_1_BIT,                                                                                              // samples
2928                 vk::VK_IMAGE_TILING_OPTIMAL,                                                                                    // tiling
2929                 readUsage | vk::VK_IMAGE_USAGE_TRANSFER_DST_BIT,                                                // usage
2930                 vk::VK_SHARING_MODE_EXCLUSIVE,                                                                                  // sharingMode
2931                 0u,                                                                                                                                             // queueFamilyCount
2932                 DE_NULL,                                                                                                                                // pQueueFamilyIndices
2933                 vk::VK_IMAGE_LAYOUT_UNDEFINED,                                                                                  // initialLayout
2934         };
2935         vk::Move<vk::VkImage>                           image           (vk::createImage(vki, device, &createInfo));
2936
2937         *outAllocation = allocateAndBindObjectMemory(vki, device, allocator, *image, vk::MemoryRequirement::Any);
2938         return image;
2939 }
2940
2941 vk::Move<vk::VkImageView> ImageInstanceImages::createImageView (const vk::DeviceInterface&                      vki,
2942                                                                                                                                 vk::VkDevice                                            device,
2943                                                                                                                                 vk::VkImageViewType                                     viewType,
2944                                                                                                                                 const tcu::TextureLevelPyramid&         sourceImage,
2945                                                                                                                                 vk::VkImage                                                     image,
2946                                                                                                                                 deUint32                                                        baseMipLevel,
2947                                                                                                                                 deUint32                                                        baseArraySlice)
2948 {
2949         const tcu::ConstPixelBufferAccess       baseLevel                       = sourceImage.getLevel(0);
2950         const deUint32                                          viewTypeBaseSlice       = (viewType == vk::VK_IMAGE_VIEW_TYPE_CUBE || viewType == vk::VK_IMAGE_VIEW_TYPE_CUBE_ARRAY) ? (6 * baseArraySlice) : (baseArraySlice);
2951         const deUint32                                          viewArraySize           = (viewType == vk::VK_IMAGE_VIEW_TYPE_1D)                       ? (1)
2952                                                                                                                         : (viewType == vk::VK_IMAGE_VIEW_TYPE_1D_ARRAY)         ? (baseLevel.getHeight() - viewTypeBaseSlice)
2953                                                                                                                         : (viewType == vk::VK_IMAGE_VIEW_TYPE_2D)                       ? (1)
2954                                                                                                                         : (viewType == vk::VK_IMAGE_VIEW_TYPE_2D_ARRAY)         ? (baseLevel.getDepth() - viewTypeBaseSlice)
2955                                                                                                                         : (viewType == vk::VK_IMAGE_VIEW_TYPE_3D)                       ? (1)
2956                                                                                                                         : (viewType == vk::VK_IMAGE_VIEW_TYPE_CUBE)                     ? (6)
2957                                                                                                                         : (viewType == vk::VK_IMAGE_VIEW_TYPE_CUBE_ARRAY)       ? (baseLevel.getDepth() - viewTypeBaseSlice) // cube: numFaces * numLayers
2958                                                                                                                                                                                                                                 : (0);
2959
2960         DE_ASSERT(viewArraySize > 0);
2961
2962         const vk::VkImageSubresourceRange       resourceRange   =
2963         {
2964                 vk::VK_IMAGE_ASPECT_COLOR_BIT,                                  // aspectMask
2965                 baseMipLevel,                                                                   // baseMipLevel
2966                 sourceImage.getNumLevels() - baseMipLevel,              // mipLevels
2967                 viewTypeBaseSlice,                                                              // baseArraySlice
2968                 viewArraySize,                                                                  // arraySize
2969         };
2970         const vk::VkImageViewCreateInfo         createInfo              =
2971         {
2972                 vk::VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
2973                 DE_NULL,
2974                 (vk::VkImageViewCreateFlags)0,
2975                 image,                                                                                  // image
2976                 viewType,                                                                               // viewType
2977                 vk::mapTextureFormat(baseLevel.getFormat()),    // format
2978                 {
2979                         vk::VK_COMPONENT_SWIZZLE_R,
2980                         vk::VK_COMPONENT_SWIZZLE_G,
2981                         vk::VK_COMPONENT_SWIZZLE_B,
2982                         vk::VK_COMPONENT_SWIZZLE_A
2983                 },                                                                                              // channels
2984                 resourceRange,                                                                  // subresourceRange
2985         };
2986         return vk::createImageView(vki, device, &createInfo);
2987 }
2988
2989 void ImageInstanceImages::populateSourceImage (tcu::TextureLevelPyramid* dst, bool isFirst) const
2990 {
2991         const int numLevels = dst->getNumLevels();
2992
2993         for (int level = 0; level < numLevels; ++level)
2994         {
2995                 const int       width   = IMAGE_SIZE >> level;
2996                 const int       height  = (m_viewType == vk::VK_IMAGE_VIEW_TYPE_1D || m_viewType == vk::VK_IMAGE_VIEW_TYPE_1D_ARRAY)            ? (ARRAY_SIZE)
2997                                                                                                                                                                                                                                                                 : (IMAGE_SIZE >> level);
2998                 const int       depth   = (m_viewType == vk::VK_IMAGE_VIEW_TYPE_1D || m_viewType == vk::VK_IMAGE_VIEW_TYPE_1D_ARRAY)            ? (1)
2999                                                         : (m_viewType == vk::VK_IMAGE_VIEW_TYPE_2D || m_viewType == vk::VK_IMAGE_VIEW_TYPE_2D_ARRAY)            ? (ARRAY_SIZE)
3000                                                         : (m_viewType == vk::VK_IMAGE_VIEW_TYPE_CUBE || m_viewType == vk::VK_IMAGE_VIEW_TYPE_CUBE_ARRAY)        ? (6 * ARRAY_SIZE)
3001                                                         : (m_viewType == vk::VK_IMAGE_VIEW_TYPE_3D)                                                                                                                     ? (IMAGE_SIZE >> level)
3002                                                                                                                                                                                                                                                                 : (1);
3003
3004                 dst->allocLevel(level, width, height, depth);
3005
3006                 {
3007                         const tcu::PixelBufferAccess levelAccess = dst->getLevel(level);
3008
3009                         for (int z = 0; z < depth; ++z)
3010                         for (int y = 0; y < height; ++y)
3011                         for (int x = 0; x < width; ++x)
3012                         {
3013                                 const int                       gradPos = x + y + z;
3014                                 const int                       gradMax = width + height + depth - 3;
3015
3016                                 const int                       red             = 255 * gradPos / gradMax;                                                                                                      //!< gradient from 0 -> max (detects large offset errors)
3017                                 const int                       green   = ((gradPos % 2 == 0) ? (127) : (0)) + ((gradPos % 4 < 3) ? (128) : (0));       //!< 3-level M pattern (detects small offset errors)
3018                                 const int                       blue    = (128 * level / numLevels) + (isFirst ? 127 : 0);                                                      //!< level and image index (detects incorrect lod / image)
3019
3020                                 DE_ASSERT(de::inRange(red, 0, 255));
3021                                 DE_ASSERT(de::inRange(green, 0, 255));
3022                                 DE_ASSERT(de::inRange(blue, 0, 255));
3023
3024                                 levelAccess.setPixel(tcu::IVec4(red, green, blue, 255), x, y, z);
3025                         }
3026                 }
3027         }
3028 }
3029
3030 void ImageInstanceImages::uploadImage (const vk::DeviceInterface&               vki,
3031                                                                            vk::VkDevice                                         device,
3032                                                                            deUint32                                                     queueFamilyIndex,
3033                                                                            vk::VkQueue                                          queue,
3034                                                                            vk::Allocator&                                       allocator,
3035                                                                            vk::VkImage                                          image,
3036                                                                            vk::VkImageLayout                            layout,
3037                                                                            const tcu::TextureLevelPyramid&      data)
3038 {
3039         const deUint32                                          arraySize                                       = (m_viewType == vk::VK_IMAGE_VIEW_TYPE_3D) ? (1) :
3040                                                                                                                                           (m_viewType == vk::VK_IMAGE_VIEW_TYPE_CUBE || m_viewType == vk::VK_IMAGE_VIEW_TYPE_CUBE_ARRAY) ? (6 * (deUint32)ARRAY_SIZE) :
3041                                                                                                                                           ((deUint32)ARRAY_SIZE);
3042         const deUint32                                          dataBufferSize                          = getTextureLevelPyramidDataSize(data);
3043         const vk::VkBufferCreateInfo            bufferCreateInfo                        =
3044         {
3045                 vk::VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
3046                 DE_NULL,
3047                 0u,                                                                                                     // flags
3048                 dataBufferSize,                                                                         // size
3049                 vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT,                           // usage
3050                 vk::VK_SHARING_MODE_EXCLUSIVE,                                          // sharingMode
3051                 0u,                                                                                                     // queueFamilyCount
3052                 DE_NULL,                                                                                        // pQueueFamilyIndices
3053         };
3054         const vk::Unique<vk::VkBuffer>          dataBuffer                                      (vk::createBuffer(vki, device, &bufferCreateInfo));
3055         const de::MovePtr<vk::Allocation>       dataBufferMemory                        = allocateAndBindObjectMemory(vki, device, allocator, *dataBuffer, vk::MemoryRequirement::HostVisible);
3056         const vk::VkFenceCreateInfo                     fenceCreateInfo                         =
3057         {
3058                 vk::VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
3059                 DE_NULL,
3060                 0u,                                                                                                     // flags
3061         };
3062         const vk::VkBufferMemoryBarrier         preMemoryBarrier                        =
3063         {
3064                 vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
3065                 DE_NULL,
3066                 vk::VK_ACCESS_HOST_WRITE_BIT,                                   // outputMask
3067                 vk::VK_ACCESS_TRANSFER_READ_BIT,                                        // inputMask
3068                 vk::VK_QUEUE_FAMILY_IGNORED,                                            // srcQueueFamilyIndex
3069                 vk::VK_QUEUE_FAMILY_IGNORED,                                            // destQueueFamilyIndex
3070                 *dataBuffer,                                                                            // buffer
3071                 0u,                                                                                                     // offset
3072                 dataBufferSize,                                                                         // size
3073         };
3074         const vk::VkImageSubresourceRange       fullSubrange                            =
3075         {
3076                 vk::VK_IMAGE_ASPECT_COLOR_BIT,                                          // aspectMask
3077                 0u,                                                                                                     // baseMipLevel
3078                 (deUint32)data.getNumLevels(),                                          // mipLevels
3079                 0u,                                                                                                     // baseArraySlice
3080                 arraySize,                                                                                      // arraySize
3081         };
3082         const vk::VkImageMemoryBarrier          preImageBarrier                         =
3083         {
3084                 vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
3085                 DE_NULL,
3086                 0u,                                                                                                     // outputMask
3087                 0u,                                                                                                     // inputMask
3088                 vk::VK_IMAGE_LAYOUT_UNDEFINED,                                          // oldLayout
3089                 vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,                       // newLayout
3090                 vk::VK_QUEUE_FAMILY_IGNORED,                                            // srcQueueFamilyIndex
3091                 vk::VK_QUEUE_FAMILY_IGNORED,                                            // destQueueFamilyIndex
3092                 image,                                                                                          // image
3093                 fullSubrange                                                                            // subresourceRange
3094         };
3095         const vk::VkImageMemoryBarrier          postImageBarrier                        =
3096         {
3097                 vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
3098                 DE_NULL,
3099                 vk::VK_ACCESS_TRANSFER_WRITE_BIT,                                       // outputMask
3100                 vk::VK_ACCESS_SHADER_READ_BIT,                                          // inputMask
3101                 vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,                       // oldLayout
3102                 layout,                                                                                         // newLayout
3103                 vk::VK_QUEUE_FAMILY_IGNORED,                                            // srcQueueFamilyIndex
3104                 vk::VK_QUEUE_FAMILY_IGNORED,                                            // destQueueFamilyIndex
3105                 image,                                                                                          // image
3106                 fullSubrange                                                                            // subresourceRange
3107         };
3108         const vk::VkCommandPoolCreateInfo               cmdPoolCreateInfo                       =
3109         {
3110                 vk::VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
3111                 DE_NULL,
3112                 vk::VK_COMMAND_POOL_CREATE_TRANSIENT_BIT,                       // flags
3113                 queueFamilyIndex,                                                                       // queueFamilyIndex
3114         };
3115         const vk::Unique<vk::VkCommandPool>             cmdPool                                         (vk::createCommandPool(vki, device, &cmdPoolCreateInfo));
3116         const vk::VkCommandBufferAllocateInfo   cmdBufCreateInfo                        =
3117         {
3118                 vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
3119                 DE_NULL,
3120                 *cmdPool,                                                                                       // cmdPool
3121                 vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY,                            // level
3122                 1u,                                                                                                     // count
3123         };
3124         const vk::VkCommandBufferBeginInfo              cmdBufBeginInfo                         =
3125         {
3126                 vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
3127                 DE_NULL,
3128                 vk::VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,        // flags
3129                 (const vk::VkCommandBufferInheritanceInfo*)DE_NULL,
3130         };
3131
3132         const vk::Unique<vk::VkCommandBuffer>   cmd                                                     (vk::allocateCommandBuffer(vki, device, &cmdBufCreateInfo));
3133         const vk::Unique<vk::VkFence>                   cmdCompleteFence                        (vk::createFence(vki, device, &fenceCreateInfo));
3134         const deUint64                                                  infiniteTimeout                         = ~(deUint64)0u;
3135         std::vector<vk::VkBufferImageCopy>              copySlices;
3136
3137         // copy data to buffer
3138         writeTextureLevelPyramidData(dataBufferMemory->getHostPtr(), dataBufferSize, data, m_viewType , &copySlices);
3139         flushMappedMemoryRange(vki, device, dataBufferMemory->getMemory(), dataBufferMemory->getOffset(), dataBufferSize);
3140
3141         // record command buffer
3142         VK_CHECK(vki.beginCommandBuffer(*cmd, &cmdBufBeginInfo));
3143         vki.cmdPipelineBarrier(*cmd, 0u, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, (vk::VkDependencyFlags)0,
3144                                                    0, (const vk::VkMemoryBarrier*)DE_NULL,
3145                                                    1, &preMemoryBarrier,
3146                                                    1, &preImageBarrier);
3147         vki.cmdCopyBufferToImage(*cmd, *dataBuffer, image, vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, (deUint32)copySlices.size(), &copySlices[0]);
3148         vki.cmdPipelineBarrier(*cmd, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (vk::VkDependencyFlags)0,
3149                                                    0, (const vk::VkMemoryBarrier*)DE_NULL,
3150                                                    0, (const vk::VkBufferMemoryBarrier*)DE_NULL,
3151                                                    1, &postImageBarrier);
3152         VK_CHECK(vki.endCommandBuffer(*cmd));
3153
3154         // submit and wait for command buffer to complete before killing it
3155         {
3156                 const vk::VkSubmitInfo  submitInfo      =
3157                 {
3158                         vk::VK_STRUCTURE_TYPE_SUBMIT_INFO,
3159                         DE_NULL,
3160                         0u,
3161                         (const vk::VkSemaphore*)0,
3162                         (const vk::VkPipelineStageFlags*)DE_NULL,
3163                         1u,
3164                         &cmd.get(),
3165                         0u,
3166                         (const vk::VkSemaphore*)0,
3167                 };
3168                 VK_CHECK(vki.queueSubmit(queue, 1, &submitInfo, *cmdCompleteFence));
3169         }
3170         VK_CHECK(vki.waitForFences(device, 1, &cmdCompleteFence.get(), 0u, infiniteTimeout)); // \note: timeout is failure
3171 }
3172
3173 class ImageFetchInstanceImages : private ImageInstanceImages
3174 {
3175 public:
3176                                                                 ImageFetchInstanceImages        (const vk::DeviceInterface&             vki,
3177                                                                                                                          vk::VkDevice                                   device,
3178                                                                                                                          deUint32                                               queueFamilyIndex,
3179                                                                                                                          vk::VkQueue                                    queue,
3180                                                                                                                          vk::Allocator&                                 allocator,
3181                                                                                                                          vk::VkDescriptorType                   descriptorType,
3182                                                                                                                          ShaderInputInterface                   shaderInterface,
3183                                                                                                                          vk::VkImageViewType                    viewType,
3184                                                                                                                          deUint32                                               baseMipLevel,
3185                                                                                                                          deUint32                                               baseArraySlice);
3186
3187         static tcu::IVec3                       getFetchPos                                     (vk::VkImageViewType viewType, deUint32 baseMipLevel, deUint32 baseArraySlice, int fetchPosNdx);
3188         tcu::Vec4                                       fetchImageValue                         (int fetchPosNdx) const;
3189
3190         inline vk::VkImageView          getImageViewA                           (void) const { return *m_imageViewA; }
3191         inline vk::VkImageView          getImageViewB                           (void) const { return *m_imageViewB; }
3192
3193 private:
3194         enum
3195         {
3196                 // some arbitrary sample points for all four quadrants
3197                 SAMPLE_POINT_0_X = 6,
3198                 SAMPLE_POINT_0_Y = 13,
3199                 SAMPLE_POINT_0_Z = 49,
3200
3201                 SAMPLE_POINT_1_X = 51,
3202                 SAMPLE_POINT_1_Y = 40,
3203                 SAMPLE_POINT_1_Z = 44,
3204
3205                 SAMPLE_POINT_2_X = 42,
3206                 SAMPLE_POINT_2_Y = 26,
3207                 SAMPLE_POINT_2_Z = 19,
3208
3209                 SAMPLE_POINT_3_X = 25,
3210                 SAMPLE_POINT_3_Y = 25,
3211                 SAMPLE_POINT_3_Z = 18,
3212         };
3213
3214         const ShaderInputInterface      m_shaderInterface;
3215 };
3216
3217 ImageFetchInstanceImages::ImageFetchInstanceImages (const vk::DeviceInterface&  vki,
3218                                                                                                         vk::VkDevice                            device,
3219                                                                                                         deUint32                                        queueFamilyIndex,
3220                                                                                                         vk::VkQueue                                     queue,
3221                                                                                                         vk::Allocator&                          allocator,
3222                                                                                                         vk::VkDescriptorType            descriptorType,
3223                                                                                                         ShaderInputInterface            shaderInterface,
3224                                                                                                         vk::VkImageViewType                     viewType,
3225                                                                                                         deUint32                                        baseMipLevel,
3226                                                                                                         deUint32                                        baseArraySlice)
3227         : ImageInstanceImages   (vki,
3228                                                          device,
3229                                                          queueFamilyIndex,
3230                                                          queue,
3231                                                          allocator,
3232                                                          descriptorType,
3233                                                          viewType,
3234                                                          getInterfaceNumResources(shaderInterface),     // numImages
3235                                                          baseMipLevel,
3236                                                          baseArraySlice)
3237         , m_shaderInterface             (shaderInterface)
3238 {
3239 }
3240
3241 bool isImageViewTypeArray (vk::VkImageViewType type)
3242 {
3243         return type == vk::VK_IMAGE_VIEW_TYPE_1D_ARRAY || type == vk::VK_IMAGE_VIEW_TYPE_2D_ARRAY || type == vk::VK_IMAGE_VIEW_TYPE_CUBE_ARRAY;
3244 }
3245
3246 tcu::IVec3 ImageFetchInstanceImages::getFetchPos (vk::VkImageViewType viewType, deUint32 baseMipLevel, deUint32 baseArraySlice, int fetchPosNdx)
3247 {
3248         const tcu::IVec3        fetchPositions[4]       =
3249         {
3250                 tcu::IVec3(SAMPLE_POINT_0_X, SAMPLE_POINT_0_Y, SAMPLE_POINT_0_Z),
3251                 tcu::IVec3(SAMPLE_POINT_1_X, SAMPLE_POINT_1_Y, SAMPLE_POINT_1_Z),
3252                 tcu::IVec3(SAMPLE_POINT_2_X, SAMPLE_POINT_2_Y, SAMPLE_POINT_2_Z),
3253                 tcu::IVec3(SAMPLE_POINT_3_X, SAMPLE_POINT_3_Y, SAMPLE_POINT_3_Z),
3254         };
3255         const tcu::IVec3        coord                           = de::getSizedArrayElement<4>(fetchPositions, fetchPosNdx);
3256         const deUint32          imageSize                       = (deUint32)IMAGE_SIZE >> baseMipLevel;
3257         const deUint32          arraySize                       = isImageViewTypeArray(viewType) ? ARRAY_SIZE - baseArraySlice : 1;
3258
3259         switch (viewType)
3260         {
3261                 case vk::VK_IMAGE_VIEW_TYPE_1D:
3262                 case vk::VK_IMAGE_VIEW_TYPE_1D_ARRAY:   return tcu::IVec3(coord.x() % imageSize, coord.y() % arraySize, 0);
3263                 case vk::VK_IMAGE_VIEW_TYPE_2D:
3264                 case vk::VK_IMAGE_VIEW_TYPE_2D_ARRAY:   return tcu::IVec3(coord.x() % imageSize, coord.y() % imageSize, coord.z() % arraySize);
3265                 case vk::VK_IMAGE_VIEW_TYPE_CUBE:
3266                 case vk::VK_IMAGE_VIEW_TYPE_CUBE_ARRAY: return tcu::IVec3(coord.x() % imageSize, coord.y() % imageSize, coord.z() % (arraySize * 6));
3267                 case vk::VK_IMAGE_VIEW_TYPE_3D:                 return tcu::IVec3(coord.x() % imageSize, coord.y() % imageSize, coord.z() % imageSize);
3268                 default:
3269                         DE_FATAL("Impossible");
3270                         return tcu::IVec3();
3271         }
3272 }
3273
3274 tcu::Vec4 ImageFetchInstanceImages::fetchImageValue (int fetchPosNdx) const
3275 {
3276         DE_ASSERT(de::inBounds(fetchPosNdx, 0, 4));
3277
3278         const tcu::TextureLevelPyramid& fetchSrcA       = m_sourceImageA;
3279         const tcu::TextureLevelPyramid& fetchSrcB       = (m_shaderInterface == SHADER_INPUT_SINGLE_DESCRIPTOR) ? (m_sourceImageA) : (m_sourceImageB);
3280         const tcu::TextureLevelPyramid& fetchSrc        = ((fetchPosNdx % 2) == 0) ? (fetchSrcA) : (fetchSrcB); // sampling order is ABAB
3281         tcu::IVec3                                              fetchPos        = getFetchPos(m_viewType, m_baseMipLevel, m_baseArraySlice, fetchPosNdx);
3282
3283         // add base array layer into the appropriate coordinate, based on the view type
3284         if (m_viewType == vk::VK_IMAGE_VIEW_TYPE_CUBE || m_viewType == vk::VK_IMAGE_VIEW_TYPE_CUBE_ARRAY)
3285                 fetchPos.z() += 6 * m_baseArraySlice;
3286         else if (m_viewType == vk::VK_IMAGE_VIEW_TYPE_1D || m_viewType == vk::VK_IMAGE_VIEW_TYPE_1D_ARRAY)
3287                 fetchPos.y() += m_baseArraySlice;
3288         else
3289                 fetchPos.z() += m_baseArraySlice;
3290
3291         return fetchSrc.getLevel(m_baseMipLevel).getPixel(fetchPos.x(), fetchPos.y(), fetchPos.z());
3292 }
3293
3294 class ImageFetchRenderInstance : public SingleCmdRenderInstance
3295 {
3296 public:
3297                                                                                                         ImageFetchRenderInstance        (vkt::Context&                  context,
3298                                                                                                                                                                  bool                                   isPrimaryCmdBuf,
3299                                                                                                                                                                  vk::VkDescriptorType   descriptorType,
3300                                                                                                                                                                  vk::VkShaderStageFlags stageFlags,
3301                                                                                                                                                                  ShaderInputInterface   shaderInterface,
3302                                                                                                                                                                  vk::VkImageViewType    viewType,
3303                                                                                                                                                                  deUint32                               baseMipLevel,
3304                                                                                                                                                                  deUint32                               baseArraySlice);
3305
3306 private:
3307         static vk::Move<vk::VkDescriptorSetLayout>              createDescriptorSetLayout       (const vk::DeviceInterface&     vki,
3308                                                                                                                                                                  vk::VkDevice                           device,
3309                                                                                                                                                                  vk::VkDescriptorType           descriptorType,
3310                                                                                                                                                                  ShaderInputInterface           shaderInterface,
3311                                                                                                                                                                  vk::VkShaderStageFlags         stageFlags);
3312
3313         static vk::Move<vk::VkPipelineLayout>                   createPipelineLayout            (const vk::DeviceInterface&     vki,
3314                                                                                                                                                                  vk::VkDevice                           device,
3315                                                                                                                                                                  vk::VkDescriptorSetLayout      descriptorSetLayout);
3316
3317         static vk::Move<vk::VkDescriptorPool>                   createDescriptorPool            (const vk::DeviceInterface&     vki,
3318                                                                                                                                                                  vk::VkDevice                           device,
3319                                                                                                                                                                  vk::VkDescriptorType           descriptorType,
3320                                                                                                                                                                  ShaderInputInterface           shaderInterface);
3321
3322         static vk::Move<vk::VkDescriptorSet>                    createDescriptorSet                     (const vk::DeviceInterface&     vki,
3323                                                                                                                                                                  vk::VkDevice                           device,
3324                                                                                                                                                                  vk::VkDescriptorType           descriptorType,
3325                                                                                                                                                                  ShaderInputInterface           shaderInterface,
3326                                                                                                                                                                  vk::VkDescriptorSetLayout      layout,
3327                                                                                                                                                                  vk::VkDescriptorPool           pool,
3328                                                                                                                                                                  vk::VkImageView                        viewA,
3329                                                                                                                                                                  vk::VkImageView                        viewB);
3330
3331         void                                                                                    logTestPlan                                     (void) const;
3332         vk::VkPipelineLayout                                                    getPipelineLayout                       (void) const;
3333         void                                                                                    writeDrawCmdBuffer                      (vk::VkCommandBuffer cmd) const;
3334         tcu::TestStatus                                                                 verifyResultImage                       (const tcu::ConstPixelBufferAccess& result) const;
3335
3336         enum
3337         {
3338                 RENDER_SIZE = 128,
3339         };
3340
3341         const vk::VkDescriptorType                                              m_descriptorType;
3342         const vk::VkShaderStageFlags                                    m_stageFlags;
3343         const ShaderInputInterface                                              m_shaderInterface;
3344         const vk::VkImageViewType                                               m_viewType;
3345         const deUint32                                                                  m_baseMipLevel;
3346         const deUint32                                                                  m_baseArraySlice;
3347
3348         const vk::Unique<vk::VkDescriptorSetLayout>             m_descriptorSetLayout;
3349         const vk::Unique<vk::VkPipelineLayout>                  m_pipelineLayout;
3350         const ImageFetchInstanceImages                                  m_images;
3351         const vk::Unique<vk::VkDescriptorPool>                  m_descriptorPool;
3352         const vk::Unique<vk::VkDescriptorSet>                   m_descriptorSet;
3353 };
3354
3355 ImageFetchRenderInstance::ImageFetchRenderInstance      (vkt::Context&                  context,
3356                                                                                                          bool                                   isPrimaryCmdBuf,
3357                                                                                                          vk::VkDescriptorType   descriptorType,
3358                                                                                                          vk::VkShaderStageFlags stageFlags,
3359                                                                                                          ShaderInputInterface   shaderInterface,
3360                                                                                                          vk::VkImageViewType    viewType,
3361                                                                                                          deUint32                               baseMipLevel,
3362                                                                                                          deUint32                               baseArraySlice)
3363         : SingleCmdRenderInstance       (context, isPrimaryCmdBuf, tcu::UVec2(RENDER_SIZE, RENDER_SIZE))
3364         , m_descriptorType                      (descriptorType)
3365         , m_stageFlags                          (stageFlags)
3366         , m_shaderInterface                     (shaderInterface)
3367         , m_viewType                            (viewType)
3368         , m_baseMipLevel                        (baseMipLevel)
3369         , m_baseArraySlice                      (baseArraySlice)
3370         , m_descriptorSetLayout         (createDescriptorSetLayout(m_vki, m_device, m_descriptorType, m_shaderInterface, m_stageFlags))
3371         , m_pipelineLayout                      (createPipelineLayout(m_vki, m_device, *m_descriptorSetLayout))
3372         , m_images                                      (m_vki, m_device, m_queueFamilyIndex, m_queue, m_allocator, m_descriptorType, m_shaderInterface, m_viewType, m_baseMipLevel, m_baseArraySlice)
3373         , m_descriptorPool                      (createDescriptorPool(m_vki, m_device, m_descriptorType, m_shaderInterface))
3374         , m_descriptorSet                       (createDescriptorSet(m_vki, m_device, m_descriptorType, m_shaderInterface, *m_descriptorSetLayout, *m_descriptorPool, m_images.getImageViewA(), m_images.getImageViewB()))
3375 {
3376 }
3377
3378 vk::Move<vk::VkDescriptorSetLayout> ImageFetchRenderInstance::createDescriptorSetLayout (const vk::DeviceInterface&             vki,
3379                                                                                                                                                                                  vk::VkDevice                                   device,
3380                                                                                                                                                                                  vk::VkDescriptorType                   descriptorType,
3381                                                                                                                                                                                  ShaderInputInterface                   shaderInterface,
3382                                                                                                                                                                                  vk::VkShaderStageFlags                 stageFlags)
3383 {
3384         vk::DescriptorSetLayoutBuilder builder;
3385
3386         switch (shaderInterface)
3387         {
3388                 case SHADER_INPUT_SINGLE_DESCRIPTOR:
3389                         builder.addSingleBinding(descriptorType, stageFlags);
3390                         break;
3391
3392                 case SHADER_INPUT_MULTIPLE_CONTIGUOUS_DESCRIPTORS:
3393                         builder.addSingleBinding(descriptorType, stageFlags);
3394                         builder.addSingleBinding(descriptorType, stageFlags);
3395                         break;
3396
3397                 case SHADER_INPUT_DESCRIPTOR_ARRAY:
3398                         builder.addArrayBinding(descriptorType, 2u, stageFlags);
3399                         break;
3400
3401                 default:
3402                         DE_FATAL("Impossible");
3403         }
3404
3405         return builder.build(vki, device);
3406 }
3407
3408 vk::Move<vk::VkPipelineLayout> ImageFetchRenderInstance::createPipelineLayout (const vk::DeviceInterface&       vki,
3409                                                                                                                                                            vk::VkDevice                                 device,
3410                                                                                                                                                            vk::VkDescriptorSetLayout    descriptorSetLayout)
3411 {
3412         const vk::VkPipelineLayoutCreateInfo createInfo =
3413         {
3414                 vk::VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
3415                 DE_NULL,
3416                 (vk::VkPipelineLayoutCreateFlags)0,
3417                 1,                                              // descriptorSetCount
3418                 &descriptorSetLayout,   // pSetLayouts
3419                 0u,                                             // pushConstantRangeCount
3420                 DE_NULL,                                // pPushConstantRanges
3421         };
3422         return vk::createPipelineLayout(vki, device, &createInfo);
3423 }
3424
3425 vk::Move<vk::VkDescriptorPool> ImageFetchRenderInstance::createDescriptorPool (const vk::DeviceInterface&       vki,
3426                                                                                                                                                            vk::VkDevice                                 device,
3427                                                                                                                                                            vk::VkDescriptorType                 descriptorType,
3428                                                                                                                                                            ShaderInputInterface                 shaderInterface)
3429 {
3430         return vk::DescriptorPoolBuilder()
3431                 .addType(descriptorType, getInterfaceNumResources(shaderInterface))
3432                 .build(vki, device, vk::VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1);
3433 }
3434
3435 vk::Move<vk::VkDescriptorSet> ImageFetchRenderInstance::createDescriptorSet (const vk::DeviceInterface&         vki,
3436                                                                                                                                                          vk::VkDevice                                   device,
3437                                                                                                                                                          vk::VkDescriptorType                   descriptorType,
3438                                                                                                                                                          ShaderInputInterface                   shaderInterface,
3439                                                                                                                                                          vk::VkDescriptorSetLayout              layout,
3440                                                                                                                                                          vk::VkDescriptorPool                   pool,
3441                                                                                                                                                          vk::VkImageView                                viewA,
3442                                                                                                                                                          vk::VkImageView                                viewB)
3443 {
3444         const vk::VkImageLayout                                 imageLayout             = getImageLayoutForDescriptorType(descriptorType);
3445         const vk::VkDescriptorImageInfo                 imageInfos[2]   =
3446         {
3447                 makeDescriptorImageInfo(viewA, imageLayout),
3448                 makeDescriptorImageInfo(viewB, imageLayout),
3449         };
3450         const vk::VkDescriptorSetAllocateInfo   allocInfo               =
3451         {
3452                 vk::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
3453                 DE_NULL,
3454                 pool,
3455                 1u,
3456                 &layout
3457         };
3458
3459         vk::Move<vk::VkDescriptorSet>                   descriptorSet   = allocateDescriptorSet(vki, device, &allocInfo);
3460         vk::DescriptorSetUpdateBuilder                  builder;
3461
3462         switch (shaderInterface)
3463         {
3464                 case SHADER_INPUT_SINGLE_DESCRIPTOR:
3465                         builder.writeSingle(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(0u), descriptorType, &imageInfos[0]);
3466                         break;
3467
3468                 case SHADER_INPUT_MULTIPLE_CONTIGUOUS_DESCRIPTORS:
3469                         builder.writeSingle(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(0u), descriptorType, &imageInfos[0]);
3470                         builder.writeSingle(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(1u), descriptorType, &imageInfos[1]);
3471                         break;
3472
3473                 case SHADER_INPUT_DESCRIPTOR_ARRAY:
3474                         builder.writeArray(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(0u), descriptorType, 2u, imageInfos);
3475                         break;
3476
3477                 default:
3478                         DE_FATAL("Impossible");
3479         }
3480
3481         builder.update(vki, device);
3482         return descriptorSet;
3483 }
3484
3485 void ImageFetchRenderInstance::logTestPlan (void) const
3486 {
3487         std::ostringstream msg;
3488
3489         msg << "Rendering 2x2 grid.\n"
3490                 << "Single descriptor set. Descriptor set contains "
3491                         << ((m_shaderInterface == SHADER_INPUT_SINGLE_DESCRIPTOR) ? "single" :
3492                             (m_shaderInterface == SHADER_INPUT_MULTIPLE_CONTIGUOUS_DESCRIPTORS) ? "two" :
3493                             (m_shaderInterface == SHADER_INPUT_DESCRIPTOR_ARRAY) ? "an array (size 2) of" :
3494                             (const char*)DE_NULL)
3495                 << " descriptor(s) of type " << vk::getDescriptorTypeName(m_descriptorType) << "\n"
3496                 << "Image view type is " << vk::getImageViewTypeName(m_viewType) << "\n";
3497
3498         if (m_baseMipLevel)
3499                 msg << "Image view base mip level = " << m_baseMipLevel << "\n";
3500         if (m_baseArraySlice)
3501                 msg << "Image view base array slice = " << m_baseArraySlice << "\n";
3502
3503         if (m_stageFlags == 0u)
3504         {
3505                 msg << "Descriptors are not accessed in any shader stage.\n";
3506         }
3507         else
3508         {
3509                 msg << "Color in each cell is fetched using the descriptor(s):\n";
3510
3511                 for (int resultNdx = 0; resultNdx < 4; ++resultNdx)
3512                 {
3513                         msg << "Test sample " << resultNdx << ": fetching at position " << m_images.getFetchPos(m_viewType, m_baseMipLevel, m_baseArraySlice, resultNdx);
3514
3515                         if (m_shaderInterface != SHADER_INPUT_SINGLE_DESCRIPTOR)
3516                         {
3517                                 const int srcResourceNdx = (resultNdx % 2); // ABAB source
3518                                 msg << " from descriptor " << srcResourceNdx;
3519                         }
3520
3521                         msg << "\n";
3522                 }
3523
3524                 msg << "Descriptors are accessed in {"
3525                         << (((m_stageFlags & vk::VK_SHADER_STAGE_VERTEX_BIT) != 0)                                      ? (" vertex")                   : (""))
3526                         << (((m_stageFlags & vk::VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) != 0)        ? (" tess_control")             : (""))
3527                         << (((m_stageFlags & vk::VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT) != 0)     ? (" tess_evaluation")  : (""))
3528                         << (((m_stageFlags & vk::VK_SHADER_STAGE_GEOMETRY_BIT) != 0)                            ? (" geometry")                 : (""))
3529                         << (((m_stageFlags & vk::VK_SHADER_STAGE_FRAGMENT_BIT) != 0)                            ? (" fragment")                 : (""))
3530                         << " } stages.";
3531         }
3532
3533         m_context.getTestContext().getLog()
3534                 << tcu::TestLog::Message
3535                 << msg.str()
3536                 << tcu::TestLog::EndMessage;
3537 }
3538
3539 vk::VkPipelineLayout ImageFetchRenderInstance::getPipelineLayout (void) const
3540 {
3541         return *m_pipelineLayout;
3542 }
3543
3544 void ImageFetchRenderInstance::writeDrawCmdBuffer (vk::VkCommandBuffer cmd) const
3545 {
3546         m_vki.cmdBindDescriptorSets(cmd, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, getPipelineLayout(), 0, 1, &m_descriptorSet.get(), 0, DE_NULL);
3547         m_vki.cmdDraw(cmd, 6 * 4, 1, 0, 0); // render four quads (two separate triangles)
3548 }
3549
3550 tcu::TestStatus ImageFetchRenderInstance::verifyResultImage (const tcu::ConstPixelBufferAccess& result) const
3551 {
3552         const tcu::Vec4         green           (0.0f, 1.0f, 0.0f, 1.0f);
3553         const tcu::Vec4         yellow          (1.0f, 1.0f, 0.0f, 1.0f);
3554         const bool                      doFetch         = (m_stageFlags != 0u); // no active stages? Then don't fetch
3555         const tcu::Vec4         sample0         = (!doFetch) ? (yellow) : (m_images.fetchImageValue(0));
3556         const tcu::Vec4         sample1         = (!doFetch) ? (green)  : (m_images.fetchImageValue(1));
3557         const tcu::Vec4         sample2         = (!doFetch) ? (green)  : (m_images.fetchImageValue(2));
3558         const tcu::Vec4         sample3         = (!doFetch) ? (yellow) : (m_images.fetchImageValue(3));
3559         tcu::Surface            reference       (m_targetSize.x(), m_targetSize.y());
3560
3561         drawQuadrantReferenceResult(reference.getAccess(), sample0, sample1, sample2, sample3);
3562
3563         if (!bilinearCompare(m_context.getTestContext().getLog(), "Compare", "Result comparison", reference.getAccess(), result, tcu::RGBA(1, 1, 1, 1), tcu::COMPARE_LOG_RESULT))
3564                 return tcu::TestStatus::fail("Image verification failed");
3565         else
3566                 return tcu::TestStatus::pass("Pass");
3567 }
3568
3569 class ImageFetchComputeInstance : public vkt::TestInstance
3570 {
3571 public:
3572                                                                                         ImageFetchComputeInstance       (vkt::Context&                  context,
3573                                                                                                                                                  vk::VkDescriptorType   descriptorType,
3574                                                                                                                                                  ShaderInputInterface   shaderInterface,
3575                                                                                                                                                  vk::VkImageViewType    viewType,
3576                                                                                                                                                  deUint32                               baseMipLevel,
3577                                                                                                                                                  deUint32                               baseArraySlice);
3578
3579 private:
3580         vk::Move<vk::VkDescriptorSetLayout>             createDescriptorSetLayout       (void) const;
3581         vk::Move<vk::VkDescriptorPool>                  createDescriptorPool            (void) const;
3582         vk::Move<vk::VkDescriptorSet>                   createDescriptorSet                     (vk::VkDescriptorPool pool, vk::VkDescriptorSetLayout layout) const;
3583
3584         tcu::TestStatus                                                 iterate                                         (void);
3585         void                                                                    logTestPlan                                     (void) const;
3586         tcu::TestStatus                                                 testResourceAccess                      (void);
3587
3588         const vk::VkDescriptorType                              m_descriptorType;
3589         const ShaderInputInterface                              m_shaderInterface;
3590         const vk::VkImageViewType                               m_viewType;
3591         const deUint32                                                  m_baseMipLevel;
3592         const deUint32                                                  m_baseArraySlice;
3593
3594         const vk::DeviceInterface&                              m_vki;
3595         const vk::VkDevice                                              m_device;
3596         const vk::VkQueue                                               m_queue;
3597         const deUint32                                                  m_queueFamilyIndex;
3598         vk::Allocator&                                                  m_allocator;
3599
3600         const ComputeInstanceResultBuffer               m_result;
3601         const ImageFetchInstanceImages                  m_images;
3602 };
3603
3604 ImageFetchComputeInstance::ImageFetchComputeInstance (Context&                          context,
3605                                                                                                           vk::VkDescriptorType  descriptorType,
3606                                                                                                           ShaderInputInterface  shaderInterface,
3607                                                                                                           vk::VkImageViewType   viewType,
3608                                                                                                           deUint32                              baseMipLevel,
3609                                                                                                           deUint32                              baseArraySlice)
3610         : vkt::TestInstance             (context)
3611         , m_descriptorType              (descriptorType)
3612         , m_shaderInterface             (shaderInterface)
3613         , m_viewType                    (viewType)
3614         , m_baseMipLevel                (baseMipLevel)
3615         , m_baseArraySlice              (baseArraySlice)
3616         , m_vki                                 (context.getDeviceInterface())
3617         , m_device                              (context.getDevice())
3618         , m_queue                               (context.getUniversalQueue())
3619         , m_queueFamilyIndex    (context.getUniversalQueueFamilyIndex())
3620         , m_allocator                   (context.getDefaultAllocator())
3621         , m_result                              (m_vki, m_device, m_allocator)
3622         , m_images                              (m_vki, m_device, m_queueFamilyIndex, m_queue, m_allocator, m_descriptorType, m_shaderInterface, m_viewType, m_baseMipLevel, m_baseArraySlice)
3623 {
3624 }
3625
3626 vk::Move<vk::VkDescriptorSetLayout> ImageFetchComputeInstance::createDescriptorSetLayout (void) const
3627 {
3628         vk::DescriptorSetLayoutBuilder builder;
3629
3630         builder.addSingleBinding(vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, vk::VK_SHADER_STAGE_COMPUTE_BIT);
3631
3632         switch (m_shaderInterface)
3633         {
3634                 case SHADER_INPUT_SINGLE_DESCRIPTOR:
3635                         builder.addSingleBinding(m_descriptorType, vk::VK_SHADER_STAGE_COMPUTE_BIT);
3636                         break;
3637
3638                 case SHADER_INPUT_MULTIPLE_CONTIGUOUS_DESCRIPTORS:
3639                         builder.addSingleBinding(m_descriptorType, vk::VK_SHADER_STAGE_COMPUTE_BIT);
3640                         builder.addSingleBinding(m_descriptorType, vk::VK_SHADER_STAGE_COMPUTE_BIT);
3641                         break;
3642
3643                 case SHADER_INPUT_DESCRIPTOR_ARRAY:
3644                         builder.addArrayBinding(m_descriptorType, 2u, vk::VK_SHADER_STAGE_COMPUTE_BIT);
3645                         break;
3646
3647                 default:
3648                         DE_FATAL("Impossible");
3649         };
3650
3651         return builder.build(m_vki, m_device);
3652 }
3653
3654 vk::Move<vk::VkDescriptorPool> ImageFetchComputeInstance::createDescriptorPool (void) const
3655 {
3656         return vk::DescriptorPoolBuilder()
3657                 .addType(vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER)
3658                 .addType(m_descriptorType, getInterfaceNumResources(m_shaderInterface))
3659                 .build(m_vki, m_device, vk::VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1);
3660 }
3661
3662 vk::Move<vk::VkDescriptorSet> ImageFetchComputeInstance::createDescriptorSet (vk::VkDescriptorPool pool, vk::VkDescriptorSetLayout layout) const
3663 {
3664         const vk::VkDescriptorBufferInfo                resultInfo              = vk::makeDescriptorBufferInfo(m_result.getBuffer(), 0u, (vk::VkDeviceSize)ComputeInstanceResultBuffer::DATA_SIZE);
3665         const vk::VkImageLayout                                 imageLayout             = getImageLayoutForDescriptorType(m_descriptorType);
3666         const vk::VkDescriptorImageInfo                 imageInfos[2]   =
3667         {
3668                 makeDescriptorImageInfo(m_images.getImageViewA(), imageLayout),
3669                 makeDescriptorImageInfo(m_images.getImageViewB(), imageLayout),
3670         };
3671         const vk::VkDescriptorSetAllocateInfo   allocInfo               =
3672         {
3673                 vk::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
3674                 DE_NULL,
3675                 pool,
3676                 1u,
3677                 &layout
3678         };
3679
3680         vk::Move<vk::VkDescriptorSet>                   descriptorSet   = allocateDescriptorSet(m_vki, m_device, &allocInfo);
3681         vk::DescriptorSetUpdateBuilder                  builder;
3682
3683         // result
3684         builder.writeSingle(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(0u), vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &resultInfo);
3685
3686         // images
3687         switch (m_shaderInterface)
3688         {
3689                 case SHADER_INPUT_SINGLE_DESCRIPTOR:
3690                         builder.writeSingle(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(1u), m_descriptorType, &imageInfos[0]);
3691                         break;
3692
3693                 case SHADER_INPUT_MULTIPLE_CONTIGUOUS_DESCRIPTORS:
3694                         builder.writeSingle(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(1u), m_descriptorType, &imageInfos[0]);
3695                         builder.writeSingle(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(2u), m_descriptorType, &imageInfos[1]);
3696                         break;
3697
3698                 case SHADER_INPUT_DESCRIPTOR_ARRAY:
3699                         builder.writeArray(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(1u), m_descriptorType, 2u, imageInfos);
3700                         break;
3701
3702                 default:
3703                         DE_FATAL("Impossible");
3704         }
3705
3706         builder.update(m_vki, m_device);
3707         return descriptorSet;
3708 }
3709
3710 tcu::TestStatus ImageFetchComputeInstance::iterate (void)
3711 {
3712         logTestPlan();
3713         return testResourceAccess();
3714 }
3715
3716 void ImageFetchComputeInstance::logTestPlan (void) const
3717 {
3718         std::ostringstream msg;
3719
3720         msg << "Fetching 4 values from image in compute shader.\n"
3721                 << "Single descriptor set. Descriptor set contains "
3722                         << ((m_shaderInterface == SHADER_INPUT_SINGLE_DESCRIPTOR) ? "single" :
3723                             (m_shaderInterface == SHADER_INPUT_MULTIPLE_CONTIGUOUS_DESCRIPTORS) ? "two" :
3724                             (m_shaderInterface == SHADER_INPUT_DESCRIPTOR_ARRAY) ? "an array (size 2) of" :
3725                             (const char*)DE_NULL)
3726                 << " descriptor(s) of type " << vk::getDescriptorTypeName(m_descriptorType) << "\n"
3727                 << "Image view type is " << vk::getImageViewTypeName(m_viewType) << "\n";
3728
3729         if (m_baseMipLevel)
3730                 msg << "Image view base mip level = " << m_baseMipLevel << "\n";
3731         if (m_baseArraySlice)
3732                 msg << "Image view base array slice = " << m_baseArraySlice << "\n";
3733
3734         for (int resultNdx = 0; resultNdx < 4; ++resultNdx)
3735         {
3736                 msg << "Test sample " << resultNdx << ": fetch at position " << m_images.getFetchPos(m_viewType, m_baseMipLevel, m_baseArraySlice, resultNdx);
3737
3738                 if (m_shaderInterface != SHADER_INPUT_SINGLE_DESCRIPTOR)
3739                 {
3740                         const int srcResourceNdx = (resultNdx % 2); // ABAB source
3741                         msg << " from descriptor " << srcResourceNdx;
3742                 }
3743
3744                 msg << "\n";
3745         }
3746
3747         m_context.getTestContext().getLog()
3748                 << tcu::TestLog::Message
3749                 << msg.str()
3750                 << tcu::TestLog::EndMessage;
3751 }
3752
3753 tcu::TestStatus ImageFetchComputeInstance::testResourceAccess (void)
3754 {
3755         const vk::Unique<vk::VkDescriptorSetLayout>             descriptorSetLayout     (createDescriptorSetLayout());
3756         const vk::Unique<vk::VkDescriptorPool>                  descriptorPool          (createDescriptorPool());
3757         const vk::Unique<vk::VkDescriptorSet>                   descriptorSet           (createDescriptorSet(*descriptorPool, *descriptorSetLayout));
3758         const ComputePipeline                                                   pipeline                        (m_vki, m_device, m_context.getBinaryCollection(), 1, &descriptorSetLayout.get());
3759
3760         const vk::VkDescriptorSet                                               descriptorSets[]        = { *descriptorSet };
3761         const int                                                                               numDescriptorSets       = DE_LENGTH_OF_ARRAY(descriptorSets);
3762         const deUint32* const                                                   dynamicOffsets          = DE_NULL;
3763         const int                                                                               numDynamicOffsets       = 0;
3764         const vk::VkBufferMemoryBarrier* const                  preBarriers                     = DE_NULL;
3765         const int                                                                               numPreBarriers          = 0;
3766         const vk::VkBufferMemoryBarrier* const                  postBarriers            = m_result.getResultReadBarrier();
3767         const int                                                                               numPostBarriers         = 1;
3768
3769         const ComputeCommand                                                    compute                         (m_vki,
3770                                                                                                                                                  m_device,
3771                                                                                                                                                  pipeline.getPipeline(),
3772                                                                                                                                                  pipeline.getPipelineLayout(),
3773                                                                                                                                                  tcu::UVec3(4, 1, 1),
3774                                                                                                                                                  numDescriptorSets,     descriptorSets,
3775                                                                                                                                                  numDynamicOffsets,     dynamicOffsets,
3776                                                                                                                                                  numPreBarriers,        preBarriers,
3777                                                                                                                                                  numPostBarriers,       postBarriers);
3778
3779         tcu::Vec4                                                                               results[4];
3780         bool                                                                                    anyResultSet            = false;
3781         bool                                                                                    allResultsOk            = true;
3782
3783         compute.submitAndWait(m_queueFamilyIndex, m_queue);
3784         m_result.readResultContentsTo(&results);
3785
3786         // verify
3787         for (int resultNdx = 0; resultNdx < 4; ++resultNdx)
3788         {
3789                 const tcu::Vec4 result                          = results[resultNdx];
3790                 const tcu::Vec4 reference                       = m_images.fetchImageValue(resultNdx);
3791                 const tcu::Vec4 conversionThreshold     = tcu::Vec4(1.0f / 255.0f);
3792
3793                 if (result != tcu::Vec4(-1.0f))
3794                         anyResultSet = true;
3795
3796                 if (tcu::boolAny(tcu::greaterThan(tcu::abs(result - reference), conversionThreshold)))
3797                 {
3798                         allResultsOk = false;
3799
3800                         m_context.getTestContext().getLog()
3801                                 << tcu::TestLog::Message
3802                                 << "Test sample " << resultNdx << ": Expected " << reference << ", got " << result
3803                                 << tcu::TestLog::EndMessage;
3804                 }
3805         }
3806
3807         // read back and verify
3808         if (allResultsOk)
3809                 return tcu::TestStatus::pass("Pass");
3810         else if (anyResultSet)
3811                 return tcu::TestStatus::fail("Invalid result values");
3812         else
3813         {
3814                 m_context.getTestContext().getLog()
3815                         << tcu::TestLog::Message
3816                         << "Result buffer was not written to."
3817                         << tcu::TestLog::EndMessage;
3818                 return tcu::TestStatus::fail("Result buffer was not written to");
3819         }
3820 }
3821
3822 class ImageSampleInstanceImages : private ImageInstanceImages
3823 {
3824 public:
3825                                                                                 ImageSampleInstanceImages       (const vk::DeviceInterface&             vki,
3826                                                                                                                                          vk::VkDevice                                   device,
3827                                                                                                                                          deUint32                                               queueFamilyIndex,
3828                                                                                                                                          vk::VkQueue                                    queue,
3829                                                                                                                                          vk::Allocator&                                 allocator,
3830                                                                                                                                          vk::VkDescriptorType                   descriptorType,
3831                                                                                                                                          ShaderInputInterface                   shaderInterface,
3832                                                                                                                                          vk::VkImageViewType                    viewType,
3833                                                                                                                                          deUint32                                               baseMipLevel,
3834                                                                                                                                          deUint32                                               baseArraySlice,
3835                                                                                                                                          bool                                                   immutable);
3836
3837         static tcu::Vec4                                        getSamplePos                            (vk::VkImageViewType viewType, deUint32 baseMipLevel, deUint32 baseArraySlice, int samplePosNdx);
3838         tcu::Vec4                                                       fetchSampleValue                        (int samplePosNdx) const;
3839
3840         inline vk::VkImageView                          getImageViewA                           (void) const { return *m_imageViewA;    }
3841         inline vk::VkImageView                          getImageViewB                           (void) const { return *m_imageViewB;    }
3842         inline vk::VkSampler                            getSamplerA                                     (void) const { return *m_samplerA;              }
3843         inline vk::VkSampler                            getSamplerB                                     (void) const { return *m_samplerB;              }
3844         inline bool                                                     isImmutable                                     (void) const { return m_isImmutable;    }
3845
3846 private:
3847         static int                                                      getNumImages                            (vk::VkDescriptorType descriptorType, ShaderInputInterface shaderInterface);
3848         static tcu::Sampler                                     createRefSampler                        (bool isFirst);
3849         static vk::Move<vk::VkSampler>          createSampler                           (const vk::DeviceInterface& vki, vk::VkDevice device, const tcu::Sampler& sampler, const tcu::TextureFormat& format);
3850
3851         static tcu::Texture1DArrayView          getRef1DView                            (const tcu::TextureLevelPyramid& source, deUint32 baseMipLevel, deUint32 baseArraySlice, std::vector<tcu::ConstPixelBufferAccess>* levelStorage);
3852         static tcu::Texture2DArrayView          getRef2DView                            (const tcu::TextureLevelPyramid& source, deUint32 baseMipLevel, deUint32 baseArraySlice, std::vector<tcu::ConstPixelBufferAccess>* levelStorage);
3853         static tcu::Texture3DView                       getRef3DView                            (const tcu::TextureLevelPyramid& source, deUint32 baseMipLevel, deUint32 baseArraySlice, std::vector<tcu::ConstPixelBufferAccess>* levelStorage);
3854         static tcu::TextureCubeArrayView        getRefCubeView                          (const tcu::TextureLevelPyramid& source, deUint32 baseMipLevel, deUint32 baseArraySlice, std::vector<tcu::ConstPixelBufferAccess>* levelStorage);
3855
3856         const vk::VkDescriptorType                      m_descriptorType;
3857         const ShaderInputInterface                      m_shaderInterface;
3858         const bool                                                      m_isImmutable;
3859
3860         const tcu::Sampler                                      m_refSamplerA;
3861         const tcu::Sampler                                      m_refSamplerB;
3862         const vk::Unique<vk::VkSampler>         m_samplerA;
3863         const vk::Unique<vk::VkSampler>         m_samplerB;
3864 };
3865
3866 ImageSampleInstanceImages::ImageSampleInstanceImages (const vk::DeviceInterface&        vki,
3867                                                                                                           vk::VkDevice                                  device,
3868                                                                                                           deUint32                                              queueFamilyIndex,
3869                                                                                                           vk::VkQueue                                   queue,
3870                                                                                                           vk::Allocator&                                allocator,
3871                                                                                                           vk::VkDescriptorType                  descriptorType,
3872                                                                                                           ShaderInputInterface                  shaderInterface,
3873                                                                                                           vk::VkImageViewType                   viewType,
3874                                                                                                           deUint32                                              baseMipLevel,
3875                                                                                                           deUint32                                              baseArraySlice,
3876                                                                                                           bool                                                  immutable)
3877         : ImageInstanceImages   (vki,
3878                                                          device,
3879                                                          queueFamilyIndex,
3880                                                          queue,
3881                                                          allocator,
3882                                                          descriptorType,
3883                                                          viewType,
3884                                                          getNumImages(descriptorType, shaderInterface),
3885                                                          baseMipLevel,
3886                                                          baseArraySlice)
3887         , m_descriptorType              (descriptorType)
3888         , m_shaderInterface             (shaderInterface)
3889         , m_isImmutable                 (immutable)
3890         , m_refSamplerA                 (createRefSampler(true))
3891         , m_refSamplerB                 (createRefSampler(false))
3892         , m_samplerA                    (createSampler(vki, device, m_refSamplerA, m_imageFormat))
3893         , m_samplerB                    ((getInterfaceNumResources(m_shaderInterface) == 1u)
3894                                                                 ? vk::Move<vk::VkSampler>()
3895                                                                 : createSampler(vki, device, m_refSamplerB, m_imageFormat))
3896 {
3897 }
3898
3899 tcu::Vec4 ImageSampleInstanceImages::getSamplePos (vk::VkImageViewType viewType, deUint32 baseMipLevel, deUint32 baseArraySlice, int samplePosNdx)
3900 {
3901         DE_ASSERT(de::inBounds(samplePosNdx, 0, 4));
3902
3903         const deUint32  imageSize       = (deUint32)IMAGE_SIZE >> baseMipLevel;
3904         const deUint32  arraySize       = isImageViewTypeArray(viewType) ? ARRAY_SIZE - baseArraySlice : 1;
3905
3906         // choose arbitrary values that are not ambiguous with NEAREST filtering
3907
3908         switch (viewType)
3909         {
3910                 case vk::VK_IMAGE_VIEW_TYPE_1D:
3911                 case vk::VK_IMAGE_VIEW_TYPE_1D_ARRAY:
3912                 case vk::VK_IMAGE_VIEW_TYPE_2D:
3913                 case vk::VK_IMAGE_VIEW_TYPE_2D_ARRAY:
3914                 case vk::VK_IMAGE_VIEW_TYPE_3D:
3915                 {
3916                         const tcu::Vec3 coords[4]       =
3917                         {
3918                                 tcu::Vec3(0.75f,
3919                                                   0.5f,
3920                                                   (float)(12u % imageSize) + 0.25f),
3921
3922                                 tcu::Vec3((float)(23u % imageSize) + 0.25f,
3923                                                   (float)(73u % imageSize) + 0.5f,
3924                                                   (float)(16u % imageSize) + 0.5f + (float)imageSize),
3925
3926                                 tcu::Vec3(-(float)(43u % imageSize) + 0.25f,
3927                                                   (float)(84u % imageSize) + 0.5f + (float)imageSize,
3928                                                   (float)(117u % imageSize) + 0.75f),
3929
3930                                 tcu::Vec3((float)imageSize + 0.5f,
3931                                                   (float)(75u % imageSize) + 0.25f,
3932                                                   (float)(83u % imageSize) + 0.25f + (float)imageSize),
3933                         };
3934                         const deUint32  slices[4]       =
3935                         {
3936                                 0u % arraySize,
3937                                 4u % arraySize,
3938                                 9u % arraySize,
3939                                 2u % arraySize,
3940                         };
3941
3942                         if (viewType == vk::VK_IMAGE_VIEW_TYPE_1D || viewType == vk::VK_IMAGE_VIEW_TYPE_1D_ARRAY)
3943                                 return tcu::Vec4(coords[samplePosNdx].x() / (float)imageSize,
3944                                                                  (float)slices[samplePosNdx],
3945                                                                  0.0f,
3946                                                                  0.0f);
3947                         else if (viewType == vk::VK_IMAGE_VIEW_TYPE_2D || viewType == vk::VK_IMAGE_VIEW_TYPE_2D_ARRAY)
3948                                 return tcu::Vec4(coords[samplePosNdx].x() / (float)imageSize,
3949                                                                  coords[samplePosNdx].y() / (float)imageSize,
3950                                                                  (float)slices[samplePosNdx],
3951                                                                  0.0f);
3952                         else if (viewType == vk::VK_IMAGE_VIEW_TYPE_3D)
3953                                 return tcu::Vec4(coords[samplePosNdx].x() / (float)imageSize,
3954                                                                  coords[samplePosNdx].y() / (float)imageSize,
3955                                                                  coords[samplePosNdx].z() / (float)imageSize,
3956                                                                  0.0f);
3957                         else
3958                         {
3959                                 DE_FATAL("Impossible");
3960                                 return tcu::Vec4();
3961                         }
3962                 }
3963
3964                 case vk::VK_IMAGE_VIEW_TYPE_CUBE:
3965                 case vk::VK_IMAGE_VIEW_TYPE_CUBE_ARRAY:
3966                 {
3967                         // \note these values are in [0, texSize]*3 space for convenience
3968                         const tcu::Vec3 coords[4]       =
3969                         {
3970                                 tcu::Vec3(0.75f,
3971                                                   0.5f,
3972                                                   (float)imageSize),
3973
3974                                 tcu::Vec3((float)(13u % imageSize) + 0.25f,
3975                                                   0.0f,
3976                                                   (float)(16u % imageSize) + 0.5f),
3977
3978                                 tcu::Vec3(0.0f,
3979                                                   (float)(84u % imageSize) + 0.5f,
3980                                                   (float)(10u % imageSize) + 0.75f),
3981
3982                                 tcu::Vec3((float)imageSize,
3983                                                   (float)(75u % imageSize) + 0.25f,
3984                                                   (float)(83u % imageSize) + 0.75f),
3985                         };
3986                         const deUint32  slices[4]       =
3987                         {
3988                                 1u % arraySize,
3989                                 2u % arraySize,
3990                                 9u % arraySize,
3991                                 5u % arraySize,
3992                         };
3993
3994                         DE_ASSERT(de::inRange(coords[samplePosNdx].x(), 0.0f, (float)imageSize));
3995                         DE_ASSERT(de::inRange(coords[samplePosNdx].y(), 0.0f, (float)imageSize));
3996                         DE_ASSERT(de::inRange(coords[samplePosNdx].z(), 0.0f, (float)imageSize));
3997
3998                         // map to [-1, 1]*3 space
3999                         return tcu::Vec4(coords[samplePosNdx].x() / (float)imageSize * 2.0f - 1.0f,
4000                                                          coords[samplePosNdx].y() / (float)imageSize * 2.0f - 1.0f,
4001                                                          coords[samplePosNdx].z() / (float)imageSize * 2.0f - 1.0f,
4002                                                          (float)slices[samplePosNdx]);
4003                 }
4004
4005                 default:
4006                         DE_FATAL("Impossible");
4007                         return tcu::Vec4();
4008         }
4009 }
4010
4011 tcu::Vec4 ImageSampleInstanceImages::fetchSampleValue (int samplePosNdx) const
4012 {
4013         DE_ASSERT(de::inBounds(samplePosNdx, 0, 4));
4014
4015         // texture order is ABAB
4016         const bool                                                                      isSamplerCase   = (m_descriptorType == vk::VK_DESCRIPTOR_TYPE_SAMPLER);
4017         const tcu::TextureLevelPyramid&                         sampleSrcA              = m_sourceImageA;
4018         const tcu::TextureLevelPyramid&                         sampleSrcB              = (m_shaderInterface == SHADER_INPUT_SINGLE_DESCRIPTOR) ? (m_sourceImageA) : (m_sourceImageB);
4019         const tcu::TextureLevelPyramid&                         sampleSrc               = (isSamplerCase) ? (sampleSrcA) : ((samplePosNdx % 2) == 0) ? (sampleSrcA) : (sampleSrcB);
4020
4021         // sampler order is ABAB
4022         const tcu::Sampler&                                                     samplerA                = m_refSamplerA;
4023         const tcu::Sampler&                                                     samplerB                = (m_shaderInterface == SHADER_INPUT_SINGLE_DESCRIPTOR) ? (m_refSamplerA) : (m_refSamplerB);
4024         const tcu::Sampler&                                                     sampler                 = ((samplePosNdx % 2) == 0) ? (samplerA) : (samplerB);
4025
4026         const tcu::Vec4                                                         samplePos               = getSamplePos(m_viewType, m_baseMipLevel, m_baseArraySlice, samplePosNdx);
4027         const float                                                                     lod                             = 0.0f;
4028         std::vector<tcu::ConstPixelBufferAccess>        levelStorage;
4029
4030         switch (m_viewType)
4031         {
4032                 case vk::VK_IMAGE_VIEW_TYPE_1D:
4033                 case vk::VK_IMAGE_VIEW_TYPE_1D_ARRAY:   return getRef1DView(sampleSrc, m_baseMipLevel, m_baseArraySlice, &levelStorage).sample(sampler, samplePos.x(), samplePos.y(), lod);
4034                 case vk::VK_IMAGE_VIEW_TYPE_2D:
4035                 case vk::VK_IMAGE_VIEW_TYPE_2D_ARRAY:   return getRef2DView(sampleSrc, m_baseMipLevel, m_baseArraySlice, &levelStorage).sample(sampler, samplePos.x(), samplePos.y(), samplePos.z(), lod);
4036                 case vk::VK_IMAGE_VIEW_TYPE_3D:                 return getRef3DView(sampleSrc, m_baseMipLevel, m_baseArraySlice, &levelStorage).sample(sampler, samplePos.x(), samplePos.y(), samplePos.z(), lod);
4037                 case vk::VK_IMAGE_VIEW_TYPE_CUBE:
4038                 case vk::VK_IMAGE_VIEW_TYPE_CUBE_ARRAY: return getRefCubeView(sampleSrc, m_baseMipLevel, m_baseArraySlice, &levelStorage).sample(sampler, samplePos.x(), samplePos.y(), samplePos.z(), samplePos.w(), lod);
4039
4040                 default:
4041                 {
4042                         DE_FATAL("Impossible");
4043                         return tcu::Vec4();
4044                 }
4045         }
4046 }
4047
4048 int ImageSampleInstanceImages::getNumImages (vk::VkDescriptorType descriptorType, ShaderInputInterface shaderInterface)
4049 {
4050         // If we are testing separate samplers, just one image is enough
4051         if (descriptorType == vk::VK_DESCRIPTOR_TYPE_SAMPLER)
4052                 return 1;
4053         else if (descriptorType == vk::VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER)
4054         {
4055                 // combined: numImages == numSamplers
4056                 return getInterfaceNumResources(shaderInterface);
4057         }
4058         else
4059         {
4060                 DE_FATAL("Impossible");
4061                 return 0;
4062         }
4063 }
4064
4065 tcu::Sampler ImageSampleInstanceImages::createRefSampler (bool isFirst)
4066 {
4067         if (isFirst)
4068         {
4069                 // linear, wrapping
4070                 return tcu::Sampler(tcu::Sampler::REPEAT_GL, tcu::Sampler::REPEAT_GL, tcu::Sampler::REPEAT_GL, tcu::Sampler::LINEAR, tcu::Sampler::LINEAR);
4071         }
4072         else
4073         {
4074                 // nearest, clamping
4075                 return tcu::Sampler(tcu::Sampler::CLAMP_TO_EDGE, tcu::Sampler::CLAMP_TO_EDGE, tcu::Sampler::CLAMP_TO_EDGE, tcu::Sampler::NEAREST, tcu::Sampler::NEAREST);
4076         }
4077 }
4078
4079 vk::Move<vk::VkSampler> ImageSampleInstanceImages::createSampler (const vk::DeviceInterface& vki, vk::VkDevice device, const tcu::Sampler& sampler, const tcu::TextureFormat& format)
4080 {
4081         const vk::VkSamplerCreateInfo   createInfo              = vk::mapSampler(sampler, format);
4082
4083         return vk::createSampler(vki, device, &createInfo);
4084 }
4085
4086 tcu::Texture1DArrayView ImageSampleInstanceImages::getRef1DView (const tcu::TextureLevelPyramid& source, deUint32 baseMipLevel, deUint32 baseArraySlice, std::vector<tcu::ConstPixelBufferAccess>* levelStorage)
4087 {
4088         DE_ASSERT(levelStorage->empty());
4089
4090         const deUint32 numSlices = (deUint32)source.getLevel(0).getHeight();
4091         const deUint32 numLevels = (deUint32)source.getNumLevels();
4092
4093         // cut pyramid from baseMipLevel
4094         for (deUint32 level = baseMipLevel; level < numLevels; ++level)
4095         {
4096                 // cut levels from baseArraySlice
4097                 const tcu::ConstPixelBufferAccess wholeLevel    = source.getLevel(level);
4098                 const tcu::ConstPixelBufferAccess cutLevel              = tcu::getSubregion(wholeLevel, 0, baseArraySlice, wholeLevel.getWidth(), numSlices - baseArraySlice);
4099                 levelStorage->push_back(cutLevel);
4100         }
4101
4102         return tcu::Texture1DArrayView((int)levelStorage->size(), &levelStorage->front());
4103 }
4104
4105 tcu::Texture2DArrayView ImageSampleInstanceImages::getRef2DView (const tcu::TextureLevelPyramid& source, deUint32 baseMipLevel, deUint32 baseArraySlice, std::vector<tcu::ConstPixelBufferAccess>* levelStorage)
4106 {
4107         DE_ASSERT(levelStorage->empty());
4108
4109         const deUint32 numSlices = (deUint32)source.getLevel(0).getDepth();
4110         const deUint32 numLevels = (deUint32)source.getNumLevels();
4111
4112         // cut pyramid from baseMipLevel
4113         for (deUint32 level = baseMipLevel; level < numLevels; ++level)
4114         {
4115                 // cut levels from baseArraySlice
4116                 const tcu::ConstPixelBufferAccess wholeLevel    = source.getLevel(level);
4117                 const tcu::ConstPixelBufferAccess cutLevel              = tcu::getSubregion(wholeLevel, 0, 0, baseArraySlice, wholeLevel.getWidth(), wholeLevel.getHeight(), numSlices - baseArraySlice);
4118                 levelStorage->push_back(cutLevel);
4119         }
4120
4121         return tcu::Texture2DArrayView((int)levelStorage->size(), &levelStorage->front());
4122 }
4123
4124 tcu::Texture3DView ImageSampleInstanceImages::getRef3DView (const tcu::TextureLevelPyramid& source, deUint32 baseMipLevel, deUint32 baseArraySlice, std::vector<tcu::ConstPixelBufferAccess>* levelStorage)
4125 {
4126         DE_ASSERT(levelStorage->empty());
4127         DE_ASSERT(baseArraySlice == 0);
4128         DE_UNREF(baseArraySlice);
4129
4130         const deUint32 numLevels = (deUint32)source.getNumLevels();
4131
4132         // cut pyramid from baseMipLevel
4133         for (deUint32 level = baseMipLevel; level < numLevels; ++level)
4134                 levelStorage->push_back(source.getLevel(level));
4135
4136         return tcu::Texture3DView((int)levelStorage->size(), &levelStorage->front());
4137 }
4138
4139 tcu::TextureCubeArrayView ImageSampleInstanceImages::getRefCubeView (const tcu::TextureLevelPyramid& source, deUint32 baseMipLevel, deUint32 baseArraySlice, std::vector<tcu::ConstPixelBufferAccess>* levelStorage)
4140 {
4141         DE_ASSERT(levelStorage->empty());
4142
4143         const deUint32 numSlices = (deUint32)source.getLevel(0).getDepth() / 6;
4144         const deUint32 numLevels = (deUint32)source.getNumLevels();
4145
4146         // cut pyramid from baseMipLevel
4147         for (deUint32 level = baseMipLevel; level < numLevels; ++level)
4148         {
4149                 // cut levels from baseArraySlice
4150                 const tcu::ConstPixelBufferAccess wholeLevel    = source.getLevel(level);
4151                 const tcu::ConstPixelBufferAccess cutLevel              = tcu::getSubregion(wholeLevel, 0, 0, baseArraySlice * 6, wholeLevel.getWidth(), wholeLevel.getHeight(), (numSlices - baseArraySlice) * 6);
4152                 levelStorage->push_back(cutLevel);
4153         }
4154
4155         return tcu::TextureCubeArrayView((int)levelStorage->size(), &levelStorage->front());
4156 }
4157
4158 class ImageSampleRenderInstance : public SingleCmdRenderInstance
4159 {
4160 public:
4161                                                                                                         ImageSampleRenderInstance               (vkt::Context&                  context,
4162                                                                                                                                                                          bool                                   isPrimaryCmdBuf,
4163                                                                                                                                                                          vk::VkDescriptorType   descriptorType,
4164                                                                                                                                                                          vk::VkShaderStageFlags stageFlags,
4165                                                                                                                                                                          ShaderInputInterface   shaderInterface,
4166                                                                                                                                                                          vk::VkImageViewType    viewType,
4167                                                                                                                                                                          deUint32                               baseMipLevel,
4168                                                                                                                                                                          deUint32                               baseArraySlice,
4169                                                                                                                                                                          bool                                   isImmutable);
4170
4171 private:
4172         static vk::Move<vk::VkDescriptorSetLayout>              createDescriptorSetLayout               (const vk::DeviceInterface&                     vki,
4173                                                                                                                                                                          vk::VkDevice                                           device,
4174                                                                                                                                                                          vk::VkDescriptorType                           descriptorType,
4175                                                                                                                                                                          ShaderInputInterface                           shaderInterface,
4176                                                                                                                                                                          vk::VkShaderStageFlags                         stageFlags,
4177                                                                                                                                                                          const ImageSampleInstanceImages&       images);
4178
4179         static vk::Move<vk::VkPipelineLayout>                   createPipelineLayout                    (const vk::DeviceInterface&     vki,
4180                                                                                                                                                                          vk::VkDevice                           device,
4181                                                                                                                                                                          vk::VkDescriptorSetLayout      descriptorSetLayout);
4182
4183         static vk::Move<vk::VkDescriptorPool>                   createDescriptorPool                    (const vk::DeviceInterface&     vki,
4184                                                                                                                                                                          vk::VkDevice                           device,
4185                                                                                                                                                                          vk::VkDescriptorType           descriptorType,
4186                                                                                                                                                                          ShaderInputInterface           shaderInterface);
4187
4188         static vk::Move<vk::VkDescriptorSet>                    createDescriptorSet                             (const vk::DeviceInterface&                     vki,
4189                                                                                                                                                                          vk::VkDevice                                           device,
4190                                                                                                                                                                          vk::VkDescriptorType                           descriptorType,
4191                                                                                                                                                                          ShaderInputInterface                           shaderInterface,
4192                                                                                                                                                                          vk::VkDescriptorSetLayout                      layout,
4193                                                                                                                                                                          vk::VkDescriptorPool                           pool,
4194                                                                                                                                                                          bool                                                           isImmutable,
4195                                                                                                                                                                          const ImageSampleInstanceImages&       images);
4196
4197         static void                                                                             writeSamplerDescriptorSet               (const vk::DeviceInterface&                     vki,
4198                                                                                                                                                                          vk::VkDevice                                           device,
4199                                                                                                                                                                          ShaderInputInterface                           shaderInterface,
4200                                                                                                                                                                          bool                                                           isImmutable,
4201                                                                                                                                                                          const ImageSampleInstanceImages&       images,
4202                                                                                                                                                                          vk::VkDescriptorSet                            descriptorSet);
4203
4204         static void                                                                             writeImageSamplerDescriptorSet  (const vk::DeviceInterface&                     vki,
4205                                                                                                                                                                          vk::VkDevice                                           device,
4206                                                                                                                                                                          ShaderInputInterface                           shaderInterface,
4207                                                                                                                                                                          bool                                                           isImmutable,
4208                                                                                                                                                                          const ImageSampleInstanceImages&       images,
4209                                                                                                                                                                          vk::VkDescriptorSet                            descriptorSet);
4210
4211         void                                                                                    logTestPlan                                             (void) const;
4212         vk::VkPipelineLayout                                                    getPipelineLayout                               (void) const;
4213         void                                                                                    writeDrawCmdBuffer                              (vk::VkCommandBuffer cmd) const;
4214         tcu::TestStatus                                                                 verifyResultImage                               (const tcu::ConstPixelBufferAccess& result) const;
4215
4216         enum
4217         {
4218                 RENDER_SIZE = 128,
4219         };
4220
4221         const vk::VkDescriptorType                                              m_descriptorType;
4222         const vk::VkShaderStageFlags                                    m_stageFlags;
4223         const ShaderInputInterface                                              m_shaderInterface;
4224         const vk::VkImageViewType                                               m_viewType;
4225         const deUint32                                                                  m_baseMipLevel;
4226         const deUint32                                                                  m_baseArraySlice;
4227
4228         const ImageSampleInstanceImages                                 m_images;
4229         const vk::Unique<vk::VkDescriptorSetLayout>             m_descriptorSetLayout;
4230         const vk::Unique<vk::VkPipelineLayout>                  m_pipelineLayout;
4231         const vk::Unique<vk::VkDescriptorPool>                  m_descriptorPool;
4232         const vk::Unique<vk::VkDescriptorSet>                   m_descriptorSet;
4233 };
4234
4235 ImageSampleRenderInstance::ImageSampleRenderInstance (vkt::Context&                             context,
4236                                                                                                           bool                                          isPrimaryCmdBuf,
4237                                                                                                           vk::VkDescriptorType          descriptorType,
4238                                                                                                           vk::VkShaderStageFlags        stageFlags,
4239                                                                                                           ShaderInputInterface          shaderInterface,
4240                                                                                                           vk::VkImageViewType           viewType,
4241                                                                                                           deUint32                                      baseMipLevel,
4242                                                                                                           deUint32                                      baseArraySlice,
4243                                                                                                           bool                                          isImmutable)
4244         : SingleCmdRenderInstance       (context, isPrimaryCmdBuf, tcu::UVec2(RENDER_SIZE, RENDER_SIZE))
4245         , m_descriptorType                      (descriptorType)
4246         , m_stageFlags                          (stageFlags)
4247         , m_shaderInterface                     (shaderInterface)
4248         , m_viewType                            (viewType)
4249         , m_baseMipLevel                        (baseMipLevel)
4250         , m_baseArraySlice                      (baseArraySlice)
4251         , m_images                                      (m_vki, m_device, m_queueFamilyIndex, m_queue, m_allocator, m_descriptorType, m_shaderInterface, m_viewType, m_baseMipLevel, m_baseArraySlice, isImmutable)
4252         , m_descriptorSetLayout         (createDescriptorSetLayout(m_vki, m_device, m_descriptorType, m_shaderInterface, m_stageFlags, m_images))
4253         , m_pipelineLayout                      (createPipelineLayout(m_vki, m_device, *m_descriptorSetLayout))
4254         , m_descriptorPool                      (createDescriptorPool(m_vki, m_device, m_descriptorType, m_shaderInterface))
4255         , m_descriptorSet                       (createDescriptorSet(m_vki, m_device, m_descriptorType, m_shaderInterface, *m_descriptorSetLayout, *m_descriptorPool, isImmutable, m_images))
4256 {
4257 }
4258
4259 vk::Move<vk::VkDescriptorSetLayout> ImageSampleRenderInstance::createDescriptorSetLayout (const vk::DeviceInterface&            vki,
4260                                                                                                                                                                                   vk::VkDevice                                          device,
4261                                                                                                                                                                                   vk::VkDescriptorType                          descriptorType,
4262                                                                                                                                                                                   ShaderInputInterface                          shaderInterface,
4263                                                                                                                                                                                   vk::VkShaderStageFlags                        stageFlags,
4264                                                                                                                                                                                   const ImageSampleInstanceImages&      images)
4265 {
4266         const vk::VkSampler                             samplers[2] =
4267         {
4268                 images.getSamplerA(),
4269                 images.getSamplerB(),
4270         };
4271
4272         vk::DescriptorSetLayoutBuilder  builder;
4273         const bool                                              addSeparateImage        = descriptorType == vk::VK_DESCRIPTOR_TYPE_SAMPLER;
4274
4275         // (combined)samplers follow
4276         switch (shaderInterface)
4277         {
4278                 case SHADER_INPUT_SINGLE_DESCRIPTOR:
4279                         if (addSeparateImage)
4280                                 builder.addSingleBinding(vk::VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, stageFlags);
4281                         builder.addSingleSamplerBinding(descriptorType, stageFlags, (images.isImmutable()) ? (&samplers[0]) : (DE_NULL));
4282                         break;
4283
4284                 case SHADER_INPUT_MULTIPLE_CONTIGUOUS_DESCRIPTORS:
4285                         if (addSeparateImage)
4286                                 builder.addSingleBinding(vk::VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, stageFlags);
4287                         builder.addSingleSamplerBinding(descriptorType, stageFlags, (images.isImmutable()) ? (&samplers[0]) : (DE_NULL));
4288                         builder.addSingleSamplerBinding(descriptorType, stageFlags, (images.isImmutable()) ? (&samplers[1]) : (DE_NULL));
4289                         break;
4290
4291                 case SHADER_INPUT_MULTIPLE_DISCONTIGUOUS_DESCRIPTORS:
4292                         builder.addSingleSamplerBinding(descriptorType, stageFlags, (images.isImmutable()) ? (&samplers[0]) : (DE_NULL));
4293                         if (addSeparateImage)
4294                                 builder.addSingleBinding(vk::VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, stageFlags);
4295                         builder.addSingleSamplerBinding(descriptorType, stageFlags, (images.isImmutable()) ? (&samplers[1]) : (DE_NULL));
4296                         break;
4297
4298                 case SHADER_INPUT_DESCRIPTOR_ARRAY:
4299                         if (addSeparateImage)
4300                                 builder.addSingleBinding(vk::VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, stageFlags);
4301                         builder.addArraySamplerBinding(descriptorType, 2u, stageFlags, (images.isImmutable()) ? (samplers) : (DE_NULL));
4302                         break;
4303
4304                 default:
4305                         DE_FATAL("Impossible");
4306         }
4307
4308         return builder.build(vki, device);
4309 }
4310
4311 vk::Move<vk::VkPipelineLayout> ImageSampleRenderInstance::createPipelineLayout (const vk::DeviceInterface&      vki,
4312                                                                                                                                                                 vk::VkDevice                            device,
4313                                                                                                                                                                 vk::VkDescriptorSetLayout       descriptorSetLayout)
4314 {
4315         const vk::VkPipelineLayoutCreateInfo createInfo =
4316         {
4317                 vk::VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
4318                 DE_NULL,
4319                 (vk::VkPipelineLayoutCreateFlags)0,
4320                 1,                                              // descriptorSetCount
4321                 &descriptorSetLayout,   // pSetLayouts
4322                 0u,                                             // pushConstantRangeCount
4323                 DE_NULL,                                // pPushConstantRanges
4324         };
4325         return vk::createPipelineLayout(vki, device, &createInfo);
4326 }
4327
4328 vk::Move<vk::VkDescriptorPool> ImageSampleRenderInstance::createDescriptorPool (const vk::DeviceInterface&      vki,
4329                                                                                                                                                                 vk::VkDevice                            device,
4330                                                                                                                                                                 vk::VkDescriptorType            descriptorType,
4331                                                                                                                                                                 ShaderInputInterface            shaderInterface)
4332 {
4333         vk::DescriptorPoolBuilder builder;
4334
4335         if (descriptorType == vk::VK_DESCRIPTOR_TYPE_SAMPLER)
4336         {
4337                 // separate samplers need image to sample
4338                 builder.addType(vk::VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE);
4339
4340                 // also need sample to use, indifferent of whether immutable or not
4341                 builder.addType(vk::VK_DESCRIPTOR_TYPE_SAMPLER, getInterfaceNumResources(shaderInterface));
4342         }
4343         else if (descriptorType == vk::VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER)
4344         {
4345                 // combined image samplers
4346                 builder.addType(vk::VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, getInterfaceNumResources(shaderInterface));
4347         }
4348         else
4349                 DE_FATAL("Impossible");
4350
4351         return builder.build(vki, device, vk::VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1);
4352 }
4353
4354 vk::Move<vk::VkDescriptorSet> ImageSampleRenderInstance::createDescriptorSet (const vk::DeviceInterface&                vki,
4355                                                                                                                                                           vk::VkDevice                                          device,
4356                                                                                                                                                           vk::VkDescriptorType                          descriptorType,
4357                                                                                                                                                           ShaderInputInterface                          shaderInterface,
4358                                                                                                                                                           vk::VkDescriptorSetLayout                     layout,
4359                                                                                                                                                           vk::VkDescriptorPool                          pool,
4360                                                                                                                                                           bool                                                          isImmutable,
4361                                                                                                                                                           const ImageSampleInstanceImages&      images)
4362 {
4363         const vk::VkDescriptorSetAllocateInfo   allocInfo               =
4364         {
4365                 vk::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
4366                 DE_NULL,
4367                 pool,
4368                 1u,
4369                 &layout
4370         };
4371
4372         vk::Move<vk::VkDescriptorSet>                   descriptorSet   = allocateDescriptorSet(vki, device, &allocInfo);
4373
4374         if (descriptorType == vk::VK_DESCRIPTOR_TYPE_SAMPLER)
4375                 writeSamplerDescriptorSet(vki, device,  shaderInterface, isImmutable, images, *descriptorSet);
4376         else if (descriptorType == vk::VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER)
4377                 writeImageSamplerDescriptorSet(vki, device, shaderInterface, isImmutable, images, *descriptorSet);
4378         else
4379                 DE_FATAL("Impossible");
4380
4381         return descriptorSet;
4382 }
4383
4384 void ImageSampleRenderInstance::writeSamplerDescriptorSet (const vk::DeviceInterface&           vki,
4385                                                                                                                    vk::VkDevice                                         device,
4386                                                                                                                    ShaderInputInterface                         shaderInterface,
4387                                                                                                                    bool                                                         isImmutable,
4388                                                                                                                    const ImageSampleInstanceImages&     images,
4389                                                                                                                    vk::VkDescriptorSet                          descriptorSet)
4390 {
4391         const vk::VkDescriptorImageInfo         imageInfo                       = makeDescriptorImageInfo(images.getImageViewA(), vk::VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
4392         const vk::VkDescriptorImageInfo         samplersInfos[2]        =
4393         {
4394                 makeDescriptorImageInfo(images.getSamplerA()),
4395                 makeDescriptorImageInfo(images.getSamplerB()),
4396         };
4397
4398         vk::DescriptorSetUpdateBuilder          builder;
4399         const deUint32                                          samplerLocation         = shaderInterface == SHADER_INPUT_MULTIPLE_DISCONTIGUOUS_DESCRIPTORS ? 1u : 0u;
4400
4401         // stand alone texture
4402         builder.writeSingle(descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(samplerLocation), vk::VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, &imageInfo);
4403
4404         // samplers
4405         if (!isImmutable)
4406         {
4407                 switch (shaderInterface)
4408                 {
4409                         case SHADER_INPUT_SINGLE_DESCRIPTOR:
4410                                 builder.writeSingle(descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(1u), vk::VK_DESCRIPTOR_TYPE_SAMPLER, &samplersInfos[0]);
4411                                 break;
4412
4413                         case SHADER_INPUT_MULTIPLE_CONTIGUOUS_DESCRIPTORS:
4414                                 builder.writeSingle(descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(1u), vk::VK_DESCRIPTOR_TYPE_SAMPLER, &samplersInfos[0]);
4415                                 builder.writeSingle(descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(2u), vk::VK_DESCRIPTOR_TYPE_SAMPLER, &samplersInfos[1]);
4416                                 break;
4417
4418                         case SHADER_INPUT_MULTIPLE_DISCONTIGUOUS_DESCRIPTORS:
4419                                 builder.writeSingle(descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(0u), vk::VK_DESCRIPTOR_TYPE_SAMPLER, &samplersInfos[0]);
4420                                 builder.writeSingle(descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(2u), vk::VK_DESCRIPTOR_TYPE_SAMPLER, &samplersInfos[1]);
4421                                 break;
4422
4423                         case SHADER_INPUT_DESCRIPTOR_ARRAY:
4424                                 builder.writeArray(descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(1u), vk::VK_DESCRIPTOR_TYPE_SAMPLER, 2u, samplersInfos);
4425                                 break;
4426
4427                         default:
4428                                 DE_FATAL("Impossible");
4429                 }
4430         }
4431
4432         builder.update(vki, device);
4433 }
4434
4435 void ImageSampleRenderInstance::writeImageSamplerDescriptorSet (const vk::DeviceInterface&                      vki,
4436                                                                                                                                 vk::VkDevice                                            device,
4437                                                                                                                                 ShaderInputInterface                            shaderInterface,
4438                                                                                                                                 bool                                                            isImmutable,
4439                                                                                                                                 const ImageSampleInstanceImages&        images,
4440                                                                                                                                 vk::VkDescriptorSet                                     descriptorSet)
4441 {
4442         const vk::VkSampler                                     samplers[2]                     =
4443         {
4444                 (isImmutable) ? (0) : (images.getSamplerA()),
4445                 (isImmutable) ? (0) : (images.getSamplerB()),
4446         };
4447         const vk::VkDescriptorImageInfo         imageSamplers[2]        =
4448         {
4449                 vk::makeDescriptorImageInfo(samplers[0], images.getImageViewA(), vk::VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL),
4450                 vk::makeDescriptorImageInfo(samplers[1], images.getImageViewB(), vk::VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL),
4451         };
4452
4453         vk::DescriptorSetUpdateBuilder          builder;
4454
4455         // combined image samplers
4456         switch (shaderInterface)
4457         {
4458                 case SHADER_INPUT_SINGLE_DESCRIPTOR:
4459                         builder.writeSingle(descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(0u), vk::VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, &imageSamplers[0]);
4460                         break;
4461
4462                 case SHADER_INPUT_MULTIPLE_CONTIGUOUS_DESCRIPTORS:
4463                         builder.writeSingle(descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(0u), vk::VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, &imageSamplers[0]);
4464                         builder.writeSingle(descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(1u), vk::VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, &imageSamplers[1]);
4465                         break;
4466
4467                 case SHADER_INPUT_DESCRIPTOR_ARRAY:
4468                         builder.writeArray(descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(0u), vk::VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 2u, imageSamplers);
4469                         break;
4470
4471                 default:
4472                         DE_FATAL("Impossible");
4473         }
4474
4475         builder.update(vki, device);
4476 }
4477
4478 void ImageSampleRenderInstance::logTestPlan (void) const
4479 {
4480         std::ostringstream msg;
4481
4482         msg << "Rendering 2x2 grid.\n";
4483
4484         if (m_descriptorType == vk::VK_DESCRIPTOR_TYPE_SAMPLER)
4485         {
4486                 msg << "Single descriptor set. Descriptor set contains "
4487                         << ((m_shaderInterface == SHADER_INPUT_SINGLE_DESCRIPTOR) ? "single" :
4488                             (m_shaderInterface == SHADER_INPUT_MULTIPLE_CONTIGUOUS_DESCRIPTORS) ? "two" :
4489                                 (m_shaderInterface == SHADER_INPUT_MULTIPLE_DISCONTIGUOUS_DESCRIPTORS) ? "two" :
4490                             (m_shaderInterface == SHADER_INPUT_DESCRIPTOR_ARRAY) ? "an array (size 2) of" :
4491                             (const char*)DE_NULL)
4492                         << " VK_DESCRIPTOR_TYPE_SAMPLER descriptor(s) and a single texture.\n";
4493         }
4494         else if (m_descriptorType == vk::VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER)
4495         {
4496                 msg << "Single descriptor set. Descriptor set contains "
4497                         << ((m_shaderInterface == SHADER_INPUT_SINGLE_DESCRIPTOR) ? "single" :
4498                             (m_shaderInterface == SHADER_INPUT_MULTIPLE_CONTIGUOUS_DESCRIPTORS) ? "two" :
4499                                 (m_shaderInterface == SHADER_INPUT_MULTIPLE_DISCONTIGUOUS_DESCRIPTORS) ? "two" :
4500                             (m_shaderInterface == SHADER_INPUT_DESCRIPTOR_ARRAY) ? "an array (size 2) of" :
4501                             (const char*)DE_NULL)
4502                         << " VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER descriptor(s).\n";
4503         }
4504         else
4505                 DE_FATAL("Impossible");
4506
4507         msg << "Image view type is " << vk::getImageViewTypeName(m_viewType) << "\n";
4508
4509         if (m_baseMipLevel)
4510                 msg << "Image view base mip level = " << m_baseMipLevel << "\n";
4511         if (m_baseArraySlice)
4512                 msg << "Image view base array slice = " << m_baseArraySlice << "\n";
4513
4514         if (m_shaderInterface == SHADER_INPUT_SINGLE_DESCRIPTOR)
4515                 msg << "Sampler mode is LINEAR, with WRAP\n";
4516         else
4517                 msg << "Sampler 0 mode is LINEAR, with WRAP\nSampler 1 mode is NEAREST with CLAMP\n";
4518
4519         if (m_stageFlags == 0u)
4520         {
4521                 msg << "Descriptors are not accessed in any shader stage.\n";
4522         }
4523         else
4524         {
4525                 msg << "Color in each cell is fetched using the descriptor(s):\n";
4526
4527                 for (int resultNdx = 0; resultNdx < 4; ++resultNdx)
4528                 {
4529                         msg << "Test sample " << resultNdx << ": sample at position " << m_images.getSamplePos(m_viewType, m_baseMipLevel, m_baseArraySlice, resultNdx);
4530
4531                         if (m_shaderInterface != SHADER_INPUT_SINGLE_DESCRIPTOR)
4532                         {
4533                                 const int srcResourceNdx = (resultNdx % 2); // ABAB source
4534
4535                                 if (m_descriptorType == vk::VK_DESCRIPTOR_TYPE_SAMPLER)
4536                                         msg << " using sampler " << srcResourceNdx;
4537                                 else if (m_descriptorType == vk::VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER)
4538                                         msg << " from combined image sampler " << srcResourceNdx;
4539                                 else
4540                                         DE_FATAL("Impossible");
4541                         }
4542                         msg << "\n";
4543                 }
4544
4545                 msg << "Descriptors are accessed in {"
4546                         << (((m_stageFlags & vk::VK_SHADER_STAGE_VERTEX_BIT) != 0)                                      ? (" vertex")                   : (""))
4547                         << (((m_stageFlags & vk::VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) != 0)        ? (" tess_control")             : (""))
4548                         << (((m_stageFlags & vk::VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT) != 0)     ? (" tess_evaluation")  : (""))
4549                         << (((m_stageFlags & vk::VK_SHADER_STAGE_GEOMETRY_BIT) != 0)                            ? (" geometry")                 : (""))
4550                         << (((m_stageFlags & vk::VK_SHADER_STAGE_FRAGMENT_BIT) != 0)                            ? (" fragment")                 : (""))
4551                         << " } stages.";
4552         }
4553
4554         m_context.getTestContext().getLog()
4555                 << tcu::TestLog::Message
4556                 << msg.str()
4557                 << tcu::TestLog::EndMessage;
4558 }
4559
4560 vk::VkPipelineLayout ImageSampleRenderInstance::getPipelineLayout (void) const
4561 {
4562         return *m_pipelineLayout;
4563 }
4564
4565 void ImageSampleRenderInstance::writeDrawCmdBuffer (vk::VkCommandBuffer cmd) const
4566 {
4567         m_vki.cmdBindDescriptorSets(cmd, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, getPipelineLayout(), 0u, 1u, &m_descriptorSet.get(), 0u, DE_NULL);
4568         m_vki.cmdDraw(cmd, 6u * 4u, 1u, 0u, 0u); // render four quads (two separate triangles)
4569 }
4570
4571 tcu::TestStatus ImageSampleRenderInstance::verifyResultImage (const tcu::ConstPixelBufferAccess& result) const
4572 {
4573         const tcu::Vec4         green           (0.0f, 1.0f, 0.0f, 1.0f);
4574         const tcu::Vec4         yellow          (1.0f, 1.0f, 0.0f, 1.0f);
4575         const bool                      doFetch         = (m_stageFlags != 0u); // no active stages? Then don't fetch
4576         const tcu::Vec4         sample0         = (!doFetch) ? (yellow) : (m_images.fetchSampleValue(0));
4577         const tcu::Vec4         sample1         = (!doFetch) ? (green)  : (m_images.fetchSampleValue(1));
4578         const tcu::Vec4         sample2         = (!doFetch) ? (green)  : (m_images.fetchSampleValue(2));
4579         const tcu::Vec4         sample3         = (!doFetch) ? (yellow) : (m_images.fetchSampleValue(3));
4580         const tcu::RGBA         threshold       = tcu::RGBA(8, 8, 8, 8); // source image is high-frequency so the threshold is quite large to tolerate sampling errors
4581         tcu::Surface            reference       (m_targetSize.x(), m_targetSize.y());
4582
4583         drawQuadrantReferenceResult(reference.getAccess(), sample0, sample1, sample2, sample3);
4584
4585         if (!bilinearCompare(m_context.getTestContext().getLog(), "Compare", "Result comparison", reference.getAccess(), result, threshold, tcu::COMPARE_LOG_RESULT))
4586                 return tcu::TestStatus::fail("Image verification failed");
4587         else
4588                 return tcu::TestStatus::pass("Pass");
4589 }
4590
4591 class ImageSampleComputeInstance : public vkt::TestInstance
4592 {
4593 public:
4594                                                                                         ImageSampleComputeInstance              (vkt::Context&                  context,
4595                                                                                                                                                          vk::VkDescriptorType   descriptorType,
4596                                                                                                                                                          ShaderInputInterface   shaderInterface,
4597                                                                                                                                                          vk::VkImageViewType    viewType,
4598                                                                                                                                                          deUint32                               baseMipLevel,
4599                                                                                                                                                          deUint32                               baseArraySlice,
4600                                                                                                                                                          bool                                   isImmutableSampler);
4601
4602 private:
4603         vk::Move<vk::VkDescriptorSetLayout>             createDescriptorSetLayout               (void) const;
4604         vk::Move<vk::VkDescriptorPool>                  createDescriptorPool                    (void) const;
4605         vk::Move<vk::VkDescriptorSet>                   createDescriptorSet                             (vk::VkDescriptorPool pool, vk::VkDescriptorSetLayout layout) const;
4606         void                                                                    writeImageSamplerDescriptorSet  (vk::VkDescriptorSet descriptorSet) const;
4607         void                                                                    writeSamplerDescriptorSet               (vk::VkDescriptorSet descriptorSet) const;
4608
4609         tcu::TestStatus                                                 iterate                                                 (void);
4610         void                                                                    logTestPlan                                             (void) const;
4611         tcu::TestStatus                                                 testResourceAccess                              (void);
4612
4613         const vk::VkDescriptorType                              m_descriptorType;
4614         const ShaderInputInterface                              m_shaderInterface;
4615         const vk::VkImageViewType                               m_viewType;
4616         const deUint32                                                  m_baseMipLevel;
4617         const deUint32                                                  m_baseArraySlice;
4618         const bool                                                              m_isImmutableSampler;
4619
4620         const vk::DeviceInterface&                              m_vki;
4621         const vk::VkDevice                                              m_device;
4622         const vk::VkQueue                                               m_queue;
4623         const deUint32                                                  m_queueFamilyIndex;
4624         vk::Allocator&                                                  m_allocator;
4625
4626         const ComputeInstanceResultBuffer               m_result;
4627         const ImageSampleInstanceImages                 m_images;
4628 };
4629
4630 ImageSampleComputeInstance::ImageSampleComputeInstance (Context&                                context,
4631                                                                                                                 vk::VkDescriptorType    descriptorType,
4632                                                                                                                 ShaderInputInterface    shaderInterface,
4633                                                                                                                 vk::VkImageViewType             viewType,
4634                                                                                                                 deUint32                                baseMipLevel,
4635                                                                                                                 deUint32                                baseArraySlice,
4636                                                                                                                 bool                                    isImmutableSampler)
4637         : vkt::TestInstance             (context)
4638         , m_descriptorType              (descriptorType)
4639         , m_shaderInterface             (shaderInterface)
4640         , m_viewType                    (viewType)
4641         , m_baseMipLevel                (baseMipLevel)
4642         , m_baseArraySlice              (baseArraySlice)
4643         , m_isImmutableSampler  (isImmutableSampler)
4644         , m_vki                                 (context.getDeviceInterface())
4645         , m_device                              (context.getDevice())
4646         , m_queue                               (context.getUniversalQueue())
4647         , m_queueFamilyIndex    (context.getUniversalQueueFamilyIndex())
4648         , m_allocator                   (context.getDefaultAllocator())
4649         , m_result                              (m_vki, m_device, m_allocator)
4650         , m_images                              (m_vki, m_device, m_queueFamilyIndex, m_queue, m_allocator, m_descriptorType, m_shaderInterface, m_viewType, m_baseMipLevel, m_baseArraySlice, isImmutableSampler)
4651 {
4652 }
4653
4654 vk::Move<vk::VkDescriptorSetLayout> ImageSampleComputeInstance::createDescriptorSetLayout (void) const
4655 {
4656         const vk::VkSampler                             samplers[2] =
4657         {
4658                 m_images.getSamplerA(),
4659                 m_images.getSamplerB(),
4660         };
4661
4662         vk::DescriptorSetLayoutBuilder  builder;
4663
4664         // result buffer
4665         builder.addSingleBinding(vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, vk::VK_SHADER_STAGE_COMPUTE_BIT);
4666
4667         // with samplers, separate texture at binding 0
4668         if (m_descriptorType == vk::VK_DESCRIPTOR_TYPE_SAMPLER)
4669                 builder.addSingleBinding(vk::VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, vk::VK_SHADER_STAGE_COMPUTE_BIT);
4670
4671         // (combined)samplers follow
4672         switch (m_shaderInterface)
4673         {
4674                 case SHADER_INPUT_SINGLE_DESCRIPTOR:
4675                         builder.addSingleSamplerBinding(m_descriptorType, vk::VK_SHADER_STAGE_COMPUTE_BIT, (m_images.isImmutable()) ? (&samplers[0]) : (DE_NULL));
4676                         break;
4677
4678                 case SHADER_INPUT_MULTIPLE_CONTIGUOUS_DESCRIPTORS:
4679                         builder.addSingleSamplerBinding(m_descriptorType, vk::VK_SHADER_STAGE_COMPUTE_BIT, (m_images.isImmutable()) ? (&samplers[0]) : (DE_NULL));
4680                         builder.addSingleSamplerBinding(m_descriptorType, vk::VK_SHADER_STAGE_COMPUTE_BIT, (m_images.isImmutable()) ? (&samplers[1]) : (DE_NULL));
4681                         break;
4682
4683                 case SHADER_INPUT_DESCRIPTOR_ARRAY:
4684                         builder.addArraySamplerBinding(m_descriptorType, 2u, vk::VK_SHADER_STAGE_COMPUTE_BIT, (m_images.isImmutable()) ? (samplers) : (DE_NULL));
4685                         break;
4686
4687                 default:
4688                         DE_FATAL("Impossible");
4689         };
4690
4691         return builder.build(m_vki, m_device);
4692 }
4693
4694 vk::Move<vk::VkDescriptorPool> ImageSampleComputeInstance::createDescriptorPool (void) const
4695 {
4696         vk::DescriptorPoolBuilder builder;
4697
4698         builder.addType(vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER);
4699         builder.addType(m_descriptorType, getInterfaceNumResources(m_shaderInterface));
4700
4701         if (m_descriptorType == vk::VK_DESCRIPTOR_TYPE_SAMPLER)
4702                 builder.addType(vk::VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE);
4703
4704         return builder.build(m_vki, m_device, vk::VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1);
4705 }
4706
4707 vk::Move<vk::VkDescriptorSet> ImageSampleComputeInstance::createDescriptorSet (vk::VkDescriptorPool pool, vk::VkDescriptorSetLayout layout) const
4708 {
4709         const vk::VkDescriptorSetAllocateInfo   allocInfo               =
4710         {
4711                 vk::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
4712                 DE_NULL,
4713                 pool,
4714                 1u,
4715                 &layout
4716         };
4717
4718         vk::Move<vk::VkDescriptorSet>                   descriptorSet   = allocateDescriptorSet(m_vki, m_device, &allocInfo);
4719
4720         if (m_descriptorType == vk::VK_DESCRIPTOR_TYPE_SAMPLER)
4721                 writeSamplerDescriptorSet(*descriptorSet);
4722         else if (m_descriptorType == vk::VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER)
4723                 writeImageSamplerDescriptorSet(*descriptorSet);
4724         else
4725                 DE_FATAL("Impossible");
4726
4727         return descriptorSet;
4728 }
4729
4730 void ImageSampleComputeInstance::writeSamplerDescriptorSet (vk::VkDescriptorSet descriptorSet) const
4731 {
4732         const vk::VkDescriptorBufferInfo        resultInfo                      = vk::makeDescriptorBufferInfo(m_result.getBuffer(), 0u, (vk::VkDeviceSize)ComputeInstanceResultBuffer::DATA_SIZE);
4733         const vk::VkDescriptorImageInfo         imageInfo                       = makeDescriptorImageInfo(m_images.getImageViewA(), vk::VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
4734         const vk::VkDescriptorImageInfo         samplersInfos[2]        =
4735         {
4736                 makeDescriptorImageInfo(m_images.getSamplerA()),
4737                 makeDescriptorImageInfo(m_images.getSamplerB()),
4738         };
4739
4740         vk::DescriptorSetUpdateBuilder          builder;
4741
4742         // result
4743         builder.writeSingle(descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(0u), vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &resultInfo);
4744
4745         // stand alone texture
4746         builder.writeSingle(descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(1u), vk::VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, &imageInfo);
4747
4748         // samplers
4749         if (!m_isImmutableSampler)
4750         {
4751                 switch (m_shaderInterface)
4752                 {
4753                         case SHADER_INPUT_SINGLE_DESCRIPTOR:
4754                                 builder.writeSingle(descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(2u), vk::VK_DESCRIPTOR_TYPE_SAMPLER, &samplersInfos[0]);
4755                                 break;
4756
4757                         case SHADER_INPUT_MULTIPLE_CONTIGUOUS_DESCRIPTORS:
4758                                 builder.writeSingle(descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(2u), vk::VK_DESCRIPTOR_TYPE_SAMPLER, &samplersInfos[0]);
4759                                 builder.writeSingle(descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(3u), vk::VK_DESCRIPTOR_TYPE_SAMPLER, &samplersInfos[1]);
4760                                 break;
4761
4762                         case SHADER_INPUT_DESCRIPTOR_ARRAY:
4763                                 builder.writeArray(descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(2u), vk::VK_DESCRIPTOR_TYPE_SAMPLER, 2u, samplersInfos);
4764                                 break;
4765
4766                         default:
4767                                 DE_FATAL("Impossible");
4768                 }
4769         }
4770
4771         builder.update(m_vki, m_device);
4772 }
4773
4774 void ImageSampleComputeInstance::writeImageSamplerDescriptorSet (vk::VkDescriptorSet descriptorSet) const
4775 {
4776         const vk::VkDescriptorBufferInfo        resultInfo                      = vk::makeDescriptorBufferInfo(m_result.getBuffer(), 0u, (vk::VkDeviceSize)ComputeInstanceResultBuffer::DATA_SIZE);
4777         const vk::VkSampler                                     samplers[2]                     =
4778         {
4779                 (m_isImmutableSampler) ? (0) : (m_images.getSamplerA()),
4780                 (m_isImmutableSampler) ? (0) : (m_images.getSamplerB()),
4781         };
4782         const vk::VkDescriptorImageInfo         imageSamplers[2]        =
4783         {
4784                 makeDescriptorImageInfo(samplers[0], m_images.getImageViewA(), vk::VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL),
4785                 makeDescriptorImageInfo(samplers[1], m_images.getImageViewB(), vk::VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL),
4786         };
4787
4788         vk::DescriptorSetUpdateBuilder          builder;
4789
4790         // result
4791         builder.writeSingle(descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(0u), vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &resultInfo);
4792
4793         // combined image samplers
4794         switch (m_shaderInterface)
4795         {
4796                 case SHADER_INPUT_SINGLE_DESCRIPTOR:
4797                         builder.writeSingle(descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(1u), vk::VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, &imageSamplers[0]);
4798                         break;
4799
4800                 case SHADER_INPUT_MULTIPLE_CONTIGUOUS_DESCRIPTORS:
4801                         builder.writeSingle(descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(1u), vk::VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, &imageSamplers[0]);
4802                         builder.writeSingle(descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(2u), vk::VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, &imageSamplers[1]);
4803                         break;
4804
4805                 case SHADER_INPUT_DESCRIPTOR_ARRAY:
4806                         builder.writeArray(descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(1u), vk::VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 2u, imageSamplers);
4807                         break;
4808
4809                 default:
4810                         DE_FATAL("Impossible");
4811         }
4812
4813         builder.update(m_vki, m_device);
4814 }
4815
4816 tcu::TestStatus ImageSampleComputeInstance::iterate (void)
4817 {
4818         logTestPlan();
4819         return testResourceAccess();
4820 }
4821
4822 void ImageSampleComputeInstance::logTestPlan (void) const
4823 {
4824         std::ostringstream msg;
4825
4826         msg << "Accessing resource in a compute program.\n";
4827
4828         if (m_descriptorType == vk::VK_DESCRIPTOR_TYPE_SAMPLER)
4829         {
4830                 msg << "Single descriptor set. Descriptor set contains "
4831                         << ((m_shaderInterface == SHADER_INPUT_SINGLE_DESCRIPTOR) ? "single" :
4832                             (m_shaderInterface == SHADER_INPUT_MULTIPLE_CONTIGUOUS_DESCRIPTORS) ? "two" :
4833                             (m_shaderInterface == SHADER_INPUT_DESCRIPTOR_ARRAY) ? "an array (size 2) of" :
4834                             (const char*)DE_NULL)
4835                         << " VK_DESCRIPTOR_TYPE_SAMPLER descriptor(s) and a single texture.\n";
4836         }
4837         else if (m_descriptorType == vk::VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER)
4838         {
4839                 msg << "Single descriptor set. Descriptor set contains "
4840                         << ((m_shaderInterface == SHADER_INPUT_SINGLE_DESCRIPTOR) ? "single" :
4841                             (m_shaderInterface == SHADER_INPUT_MULTIPLE_CONTIGUOUS_DESCRIPTORS) ? "two" :
4842                             (m_shaderInterface == SHADER_INPUT_DESCRIPTOR_ARRAY) ? "an array (size 2) of" :
4843                             (const char*)DE_NULL)
4844                         << " VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER descriptor(s).\n";
4845         }
4846         else
4847                 DE_FATAL("Impossible");
4848
4849         msg << "Image view type is " << vk::getImageViewTypeName(m_viewType) << "\n";
4850
4851         if (m_baseMipLevel)
4852                 msg << "Image view base mip level = " << m_baseMipLevel << "\n";
4853         if (m_baseArraySlice)
4854                 msg << "Image view base array slice = " << m_baseArraySlice << "\n";
4855
4856         if (m_shaderInterface == SHADER_INPUT_SINGLE_DESCRIPTOR)
4857                 msg << "Sampler mode is LINEAR, with WRAP\n";
4858         else
4859                 msg << "Sampler 0 mode is LINEAR, with WRAP\nSampler 1 mode is NEAREST with CLAMP\n";
4860
4861         for (int resultNdx = 0; resultNdx < 4; ++resultNdx)
4862         {
4863                 msg << "Test sample " << resultNdx << ": sample at position " << m_images.getSamplePos(m_viewType, m_baseMipLevel, m_baseArraySlice, resultNdx);
4864
4865                 if (m_shaderInterface != SHADER_INPUT_SINGLE_DESCRIPTOR)
4866                 {
4867                         const int srcResourceNdx = (resultNdx % 2); // ABAB source
4868
4869                         if (m_descriptorType == vk::VK_DESCRIPTOR_TYPE_SAMPLER)
4870                                 msg << " using sampler " << srcResourceNdx;
4871                         else if (m_descriptorType == vk::VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER)
4872                                 msg << " from combined image sampler " << srcResourceNdx;
4873                         else
4874                                 DE_FATAL("Impossible");
4875                 }
4876                 msg << "\n";
4877         }
4878
4879         m_context.getTestContext().getLog()
4880                 << tcu::TestLog::Message
4881                 << msg.str()
4882                 << tcu::TestLog::EndMessage;
4883 }
4884
4885 tcu::TestStatus ImageSampleComputeInstance::testResourceAccess (void)
4886 {
4887         const vk::Unique<vk::VkDescriptorSetLayout>             descriptorSetLayout     (createDescriptorSetLayout());
4888         const vk::Unique<vk::VkDescriptorPool>                  descriptorPool          (createDescriptorPool());
4889         const vk::Unique<vk::VkDescriptorSet>                   descriptorSet           (createDescriptorSet(*descriptorPool, *descriptorSetLayout));
4890         const ComputePipeline                                                   pipeline                        (m_vki, m_device, m_context.getBinaryCollection(), 1, &descriptorSetLayout.get());
4891
4892         const vk::VkDescriptorSet                                               descriptorSets[]        = { *descriptorSet };
4893         const int                                                                               numDescriptorSets       = DE_LENGTH_OF_ARRAY(descriptorSets);
4894         const deUint32* const                                                   dynamicOffsets          = DE_NULL;
4895         const int                                                                               numDynamicOffsets       = 0;
4896         const vk::VkBufferMemoryBarrier* const                  preBarriers                     = DE_NULL;
4897         const int                                                                               numPreBarriers          = 0;
4898         const vk::VkBufferMemoryBarrier* const                  postBarriers            = m_result.getResultReadBarrier();
4899         const int                                                                               numPostBarriers         = 1;
4900
4901         const ComputeCommand                                                    compute                         (m_vki,
4902                                                                                                                                                  m_device,
4903                                                                                                                                                  pipeline.getPipeline(),
4904                                                                                                                                                  pipeline.getPipelineLayout(),
4905                                                                                                                                                  tcu::UVec3(4, 1, 1),
4906                                                                                                                                                  numDescriptorSets,     descriptorSets,
4907                                                                                                                                                  numDynamicOffsets,     dynamicOffsets,
4908                                                                                                                                                  numPreBarriers,        preBarriers,
4909                                                                                                                                                  numPostBarriers,       postBarriers);
4910
4911         tcu::Vec4                                                                               results[4];
4912         bool                                                                                    anyResultSet            = false;
4913         bool                                                                                    allResultsOk            = true;
4914
4915         compute.submitAndWait(m_queueFamilyIndex, m_queue);
4916         m_result.readResultContentsTo(&results);
4917
4918         // verify
4919         for (int resultNdx = 0; resultNdx < 4; ++resultNdx)
4920         {
4921                 const tcu::Vec4 result                          = results[resultNdx];
4922                 const tcu::Vec4 reference                       = m_images.fetchSampleValue(resultNdx);
4923
4924                 // source image is high-frequency so the threshold is quite large to tolerate sampling errors
4925                 const tcu::Vec4 samplingThreshold       = tcu::Vec4(8.0f / 255.0f);
4926
4927                 if (result != tcu::Vec4(-1.0f))
4928                         anyResultSet = true;
4929
4930                 if (tcu::boolAny(tcu::greaterThan(tcu::abs(result - reference), samplingThreshold)))
4931                 {
4932                         allResultsOk = false;
4933
4934                         m_context.getTestContext().getLog()
4935                                 << tcu::TestLog::Message
4936                                 << "Test sample " << resultNdx << ":\n"
4937                                 << "\tSampling at " << m_images.getSamplePos(m_viewType, m_baseMipLevel, m_baseArraySlice, resultNdx) << "\n"
4938                                 << "\tError expected " << reference << ", got " << result
4939                                 << tcu::TestLog::EndMessage;
4940                 }
4941         }
4942
4943         // read back and verify
4944         if (allResultsOk)
4945                 return tcu::TestStatus::pass("Pass");
4946         else if (anyResultSet)
4947                 return tcu::TestStatus::fail("Invalid result values");
4948         else
4949         {
4950                 m_context.getTestContext().getLog()
4951                         << tcu::TestLog::Message
4952                         << "Result buffer was not written to."
4953                         << tcu::TestLog::EndMessage;
4954                 return tcu::TestStatus::fail("Result buffer was not written to");
4955         }
4956 }
4957
4958 class ImageDescriptorCase : public QuadrantRendederCase
4959 {
4960 public:
4961         enum
4962         {
4963                 FLAG_BASE_MIP   = (1u << 1u),
4964                 FLAG_BASE_SLICE = (1u << 2u),
4965         };
4966         // enum continues where resource flags ends
4967         DE_STATIC_ASSERT((deUint32)FLAG_BASE_MIP == (deUint32)RESOURCE_FLAG_LAST);
4968
4969                                                                 ImageDescriptorCase                     (tcu::TestContext&              testCtx,
4970                                                                                                                          const char*                    name,
4971                                                                                                                          const char*                    description,
4972                                                                                                                          bool                                   isPrimaryCmdBuf,
4973                                                                                                                          vk::VkDescriptorType   descriptorType,
4974                                                                                                                          vk::VkShaderStageFlags exitingStages,
4975                                                                                                                          vk::VkShaderStageFlags activeStages,
4976                                                                                                                          ShaderInputInterface   shaderInterface,
4977                                                                                                                          vk::VkImageViewType    viewType,
4978                                                                                                                          deUint32                               flags);
4979
4980 private:
4981         std::string                                     genExtensionDeclarations        (vk::VkShaderStageFlagBits stage) const;
4982         std::string                                     genResourceDeclarations         (vk::VkShaderStageFlagBits stage, int numUsedBindings) const;
4983         std::string                                     genFetchCoordStr                        (int fetchPosNdx) const;
4984         std::string                                     genSampleCoordStr                       (int samplePosNdx) const;
4985         std::string                                     genResourceAccessSource         (vk::VkShaderStageFlagBits stage) const;
4986         std::string                                     genNoAccessSource                       (void) const;
4987
4988         vkt::TestInstance*                      createInstance                          (vkt::Context& context) const;
4989
4990 private:
4991         const bool                                      m_isPrimaryCmdBuf;
4992         const vk::VkDescriptorType      m_descriptorType;
4993         const ShaderInputInterface      m_shaderInterface;
4994         const vk::VkImageViewType       m_viewType;
4995         const deUint32                          m_baseMipLevel;
4996         const deUint32                          m_baseArraySlice;
4997         const bool                                      m_isImmutableSampler;
4998 };
4999
5000 ImageDescriptorCase::ImageDescriptorCase (tcu::TestContext&                     testCtx,
5001                                                                                   const char*                           name,
5002                                                                                   const char*                           description,
5003                                                                                   bool                                          isPrimaryCmdBuf,
5004                                                                                   vk::VkDescriptorType          descriptorType,
5005                                                                                   vk::VkShaderStageFlags        exitingStages,
5006                                                                                   vk::VkShaderStageFlags        activeStages,
5007                                                                                   ShaderInputInterface          shaderInterface,
5008                                                                                   vk::VkImageViewType           viewType,
5009                                                                                   deUint32                                      flags)
5010         : QuadrantRendederCase  (testCtx, name, description,
5011                                                          // \note 1D textures are not supported in ES
5012                                                          (viewType == vk::VK_IMAGE_VIEW_TYPE_1D || viewType == vk::VK_IMAGE_VIEW_TYPE_1D_ARRAY) ? glu::GLSL_VERSION_440 : glu::GLSL_VERSION_310_ES,
5013                                                          exitingStages, activeStages)
5014         , m_isPrimaryCmdBuf             (isPrimaryCmdBuf)
5015         , m_descriptorType              (descriptorType)
5016         , m_shaderInterface             (shaderInterface)
5017         , m_viewType                    (viewType)
5018         , m_baseMipLevel                (((flags & FLAG_BASE_MIP) != 0) ? (1u) : (0u))
5019         , m_baseArraySlice              (((flags & FLAG_BASE_SLICE) != 0) ? (1u) : (0u))
5020         , m_isImmutableSampler  ((flags & RESOURCE_FLAG_IMMUTABLE_SAMPLER) != 0)
5021 {
5022 }
5023
5024 std::string ImageDescriptorCase::genExtensionDeclarations (vk::VkShaderStageFlagBits stage) const
5025 {
5026         DE_UNREF(stage);
5027
5028         if (m_viewType == vk::VK_IMAGE_VIEW_TYPE_CUBE_ARRAY)
5029                 return "#extension GL_OES_texture_cube_map_array : require\n";
5030         else
5031                 return "";
5032 }
5033
5034 std::string ImageDescriptorCase::genResourceDeclarations (vk::VkShaderStageFlagBits stage, int numUsedBindings) const
5035 {
5036         DE_UNREF(stage);
5037
5038         // Vulkan-style resources are arrays implicitly, OpenGL-style are not
5039         const std::string       dimensionBase   = (m_viewType == vk::VK_IMAGE_VIEW_TYPE_1D || m_viewType == vk::VK_IMAGE_VIEW_TYPE_1D_ARRAY)            ? ("1D")
5040                                                                                 : (m_viewType == vk::VK_IMAGE_VIEW_TYPE_2D || m_viewType == vk::VK_IMAGE_VIEW_TYPE_2D_ARRAY)            ? ("2D")
5041                                                                                 : (m_viewType == vk::VK_IMAGE_VIEW_TYPE_3D)                                                                                                                     ? ("3D")
5042                                                                                 : (m_viewType == vk::VK_IMAGE_VIEW_TYPE_CUBE || m_viewType == vk::VK_IMAGE_VIEW_TYPE_CUBE_ARRAY)        ? ("Cube")
5043                                                                                 : (DE_NULL);
5044         const std::string       dimensionArray  = (m_viewType == vk::VK_IMAGE_VIEW_TYPE_1D || m_viewType == vk::VK_IMAGE_VIEW_TYPE_1D_ARRAY)            ? ("1DArray")
5045                                                                                 : (m_viewType == vk::VK_IMAGE_VIEW_TYPE_2D || m_viewType == vk::VK_IMAGE_VIEW_TYPE_2D_ARRAY)            ? ("2DArray")
5046                                                                                 : (m_viewType == vk::VK_IMAGE_VIEW_TYPE_3D)                                                                                                                     ? ("3D")
5047                                                                                 : (m_viewType == vk::VK_IMAGE_VIEW_TYPE_CUBE || m_viewType == vk::VK_IMAGE_VIEW_TYPE_CUBE_ARRAY)        ? ("CubeArray")
5048                                                                                 : (DE_NULL);
5049         const std::string       dimension               = isImageViewTypeArray(m_viewType) ? dimensionArray : dimensionBase;
5050
5051         if (m_shaderInterface == SHADER_INPUT_MULTIPLE_DISCONTIGUOUS_DESCRIPTORS)
5052                 DE_ASSERT(m_descriptorType == vk::VK_DESCRIPTOR_TYPE_SAMPLER);
5053
5054         switch (m_shaderInterface)
5055         {
5056                 case SHADER_INPUT_SINGLE_DESCRIPTOR:
5057                 {
5058                         switch (m_descriptorType)
5059                         {
5060                                 case vk::VK_DESCRIPTOR_TYPE_SAMPLER:
5061                                         return "layout(set = 0, binding = " + de::toString(numUsedBindings) + ") uniform highp texture" + dimension + " u_separateTexture;\n"
5062                                                    "layout(set = 0, binding = " + de::toString(numUsedBindings+1) + ") uniform highp sampler u_separateSampler;\n";
5063                                 case vk::VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
5064                                         return "layout(set = 0, binding = " + de::toString(numUsedBindings) + ") uniform highp sampler" + dimension + " u_combinedTextureSampler;\n";
5065                                 case vk::VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
5066                                         return "layout(set = 0, binding = " + de::toString(numUsedBindings) + ") uniform highp texture" + dimensionBase + " u_separateTexture;\n";
5067                                 case vk::VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
5068                                         return "layout(set = 0, binding = " + de::toString(numUsedBindings) + ", rgba8) readonly uniform highp image" + dimension + " u_image;\n";
5069                                 default:
5070                                         DE_FATAL("invalid descriptor");
5071                                         return "";
5072                         }
5073                 }
5074
5075                 case SHADER_INPUT_MULTIPLE_CONTIGUOUS_DESCRIPTORS:
5076                 case SHADER_INPUT_MULTIPLE_DISCONTIGUOUS_DESCRIPTORS:
5077                         switch (m_descriptorType)
5078                         {
5079                                 case vk::VK_DESCRIPTOR_TYPE_SAMPLER:
5080                                         if (m_shaderInterface == SHADER_INPUT_MULTIPLE_CONTIGUOUS_DESCRIPTORS)
5081                                                 return "layout(set = 0, binding = " + de::toString(numUsedBindings) + ") uniform highp texture" + dimension + " u_separateTexture;\n"
5082                                                                 "layout(set = 0, binding = " + de::toString(numUsedBindings+1) + ") uniform highp sampler u_separateSamplerA;\n"
5083                                                                 "layout(set = 0, binding = " + de::toString(numUsedBindings+2) + ") uniform highp sampler u_separateSamplerB;\n";
5084                                         else
5085                                                 return "layout(set = 0, binding = " + de::toString(numUsedBindings) + ") uniform highp sampler u_separateSamplerA;\n"
5086                                                                 "layout(set = 0, binding = " + de::toString(numUsedBindings+1) + ") uniform highp texture" + dimension + " u_separateTexture;\n"
5087                                                                 "layout(set = 0, binding = " + de::toString(numUsedBindings+2) + ") uniform highp sampler u_separateSamplerB;\n";
5088                                 case vk::VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
5089                                         return "layout(set = 0, binding = " + de::toString(numUsedBindings) + ") uniform highp sampler" + dimension + " u_combinedTextureSamplerA;\n"
5090                                                    "layout(set = 0, binding = " + de::toString(numUsedBindings+1) + ") uniform highp sampler" + dimension + " u_combinedTextureSamplerB;\n";
5091                                 case vk::VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
5092                                         return "layout(set = 0, binding = " + de::toString(numUsedBindings) + ") uniform highp texture" + dimensionBase + " u_separateTextureA;\n"
5093                                                    "layout(set = 0, binding = " + de::toString(numUsedBindings+1) + ") uniform highp texture" + dimensionBase + " u_separateTextureB;\n";
5094                                 case vk::VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
5095                                         return "layout(set = 0, binding = " + de::toString(numUsedBindings) + ", rgba8) readonly uniform highp image" + dimension + " u_imageA;\n"
5096                                                    "layout(set = 0, binding = " + de::toString(numUsedBindings+1) + ", rgba8) readonly uniform highp image" + dimension + " u_imageB;\n";
5097                                 default:
5098                                         DE_FATAL("invalid descriptor");
5099                                         return "";
5100                         }
5101
5102                 case SHADER_INPUT_DESCRIPTOR_ARRAY:
5103                         switch (m_descriptorType)
5104                         {
5105                                 case vk::VK_DESCRIPTOR_TYPE_SAMPLER:
5106                                         return "layout(set = 0, binding = " + de::toString(numUsedBindings) + ") uniform highp texture" + dimension + " u_separateTexture;\n"
5107                                                    "layout(set = 0, binding = " + de::toString(numUsedBindings+1) + ") uniform highp sampler u_separateSampler[2];\n";
5108                                 case vk::VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
5109                                         return "layout(set = 0, binding = " + de::toString(numUsedBindings) + ") uniform highp sampler" + dimension + " u_combinedTextureSampler[2];\n";
5110                                 case vk::VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
5111                                         return "layout(set = 0, binding = " + de::toString(numUsedBindings) + ") uniform highp texture" + dimensionBase + " u_separateTexture[2];\n";
5112                                 case vk::VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
5113                                         return "layout(set = 0, binding = " + de::toString(numUsedBindings) + ", rgba8) readonly uniform highp image" + dimension + " u_image[2];\n";
5114                                 default:
5115                                         DE_FATAL("invalid descriptor");
5116                                         return "";
5117                         }
5118
5119                 default:
5120                         DE_FATAL("Impossible");
5121                         return "";
5122         }
5123 }
5124
5125 std::string ImageDescriptorCase::genFetchCoordStr (int fetchPosNdx) const
5126 {
5127         DE_ASSERT(m_descriptorType == vk::VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE || m_descriptorType == vk::VK_DESCRIPTOR_TYPE_STORAGE_IMAGE);
5128         const tcu::IVec3 fetchPos = ImageFetchInstanceImages::getFetchPos(m_viewType, m_baseMipLevel, m_baseArraySlice, fetchPosNdx);
5129
5130         if (m_viewType == vk::VK_IMAGE_VIEW_TYPE_1D)
5131         {
5132                 return de::toString(fetchPos.x());
5133         }
5134         else if (m_viewType == vk::VK_IMAGE_VIEW_TYPE_1D_ARRAY || m_viewType == vk::VK_IMAGE_VIEW_TYPE_2D)
5135         {
5136                 std::ostringstream buf;
5137                 buf << "ivec2(" << fetchPos.x() << ", " << fetchPos.y() << ")";
5138                 return buf.str();
5139         }
5140         else
5141         {
5142                 std::ostringstream buf;
5143                 buf << "ivec3(" << fetchPos.x() << ", " << fetchPos.y() << ", " << fetchPos.z() << ")";
5144                 return buf.str();
5145         }
5146 }
5147
5148 std::string ImageDescriptorCase::genSampleCoordStr (int samplePosNdx) const
5149 {
5150         DE_ASSERT(m_descriptorType == vk::VK_DESCRIPTOR_TYPE_SAMPLER || m_descriptorType == vk::VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER);
5151         const tcu::Vec4 fetchPos = ImageSampleInstanceImages::getSamplePos(m_viewType, m_baseMipLevel, m_baseArraySlice, samplePosNdx);
5152
5153         if (m_viewType == vk::VK_IMAGE_VIEW_TYPE_1D)
5154         {
5155                 std::ostringstream buf;
5156                 buf << "float(" << fetchPos.x() << ")";
5157                 return buf.str();
5158         }
5159         else if (m_viewType == vk::VK_IMAGE_VIEW_TYPE_1D_ARRAY || m_viewType == vk::VK_IMAGE_VIEW_TYPE_2D)
5160         {
5161                 std::ostringstream buf;
5162                 buf << "vec2(float(" << fetchPos.x() << "), float(" << fetchPos.y() << "))";
5163                 return buf.str();
5164         }
5165         else if (m_viewType == vk::VK_IMAGE_VIEW_TYPE_CUBE_ARRAY)
5166         {
5167                 std::ostringstream buf;
5168                 buf << "vec4(float(" << fetchPos.x() << "), float(" << fetchPos.y() << "), float(" << fetchPos.z() << "), float(" << fetchPos.w() << "))";
5169                 return buf.str();
5170         }
5171         else
5172         {
5173                 std::ostringstream buf;
5174                 buf << "vec3(float(" << fetchPos.x() << "), float(" << fetchPos.y() << "), float(" << fetchPos.z() << "))";
5175                 return buf.str();
5176         }
5177 }
5178
5179 std::string ImageDescriptorCase::genResourceAccessSource (vk::VkShaderStageFlagBits stage) const
5180 {
5181         DE_UNREF(stage);
5182
5183         const char* const       dimension               = (m_viewType == vk::VK_IMAGE_VIEW_TYPE_1D)                     ? ("1D")
5184                                                                                 : (m_viewType == vk::VK_IMAGE_VIEW_TYPE_1D_ARRAY)       ? ("1DArray")
5185                                                                                 : (m_viewType == vk::VK_IMAGE_VIEW_TYPE_2D)                     ? ("2D")
5186                                                                                 : (m_viewType == vk::VK_IMAGE_VIEW_TYPE_2D_ARRAY)       ? ("2DArray")
5187                                                                                 : (m_viewType == vk::VK_IMAGE_VIEW_TYPE_3D)                     ? ("3D")
5188                                                                                 : (m_viewType == vk::VK_IMAGE_VIEW_TYPE_CUBE)           ? ("Cube")
5189                                                                                 : (m_viewType == vk::VK_IMAGE_VIEW_TYPE_CUBE_ARRAY)     ? ("CubeArray")
5190                                                                                 : (DE_NULL);
5191         const char* const       accessPostfixA  = (m_shaderInterface == SHADER_INPUT_SINGLE_DESCRIPTOR)                                         ? ("")
5192                                                                                 : (m_shaderInterface == SHADER_INPUT_MULTIPLE_CONTIGUOUS_DESCRIPTORS)           ? ("A")
5193                                                                                 : (m_shaderInterface == SHADER_INPUT_MULTIPLE_DISCONTIGUOUS_DESCRIPTORS)        ? ("A")
5194                                                                                 : (m_shaderInterface == SHADER_INPUT_DESCRIPTOR_ARRAY)                                          ? ("[0]")
5195                                                                                 : (DE_NULL);
5196         const char* const       accessPostfixB  = (m_shaderInterface == SHADER_INPUT_SINGLE_DESCRIPTOR)                                         ? ("")
5197                                                                                 : (m_shaderInterface == SHADER_INPUT_MULTIPLE_CONTIGUOUS_DESCRIPTORS)           ? ("B")
5198                                                                                 : (m_shaderInterface == SHADER_INPUT_MULTIPLE_DISCONTIGUOUS_DESCRIPTORS)        ? ("B")
5199                                                                                 : (m_shaderInterface == SHADER_INPUT_DESCRIPTOR_ARRAY)                                          ? ("[1]")
5200                                                                                 : (DE_NULL);
5201
5202         switch (m_descriptorType)
5203         {
5204                 case vk::VK_DESCRIPTOR_TYPE_SAMPLER:
5205                 case vk::VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
5206                 {
5207                         const std::string       coodStr[4]      =
5208                         {
5209                                 genSampleCoordStr(0),
5210                                 genSampleCoordStr(1),
5211                                 genSampleCoordStr(2),
5212                                 genSampleCoordStr(3),
5213                         };
5214                         std::ostringstream      buf;
5215
5216                         if (m_descriptorType == vk::VK_DESCRIPTOR_TYPE_SAMPLER)
5217                         {
5218                                 buf << "        if (quadrant_id == 0)\n"
5219                                         << "            result_color = textureLod(sampler" << dimension << "(u_separateTexture, u_separateSampler" << accessPostfixA << "), " << coodStr[0] << ", 0.0);\n"
5220                                         << "    else if (quadrant_id == 1)\n"
5221                                         << "            result_color = textureLod(sampler" << dimension << "(u_separateTexture, u_separateSampler" << accessPostfixB << "), " << coodStr[1] << ", 0.0);\n"
5222                                         << "    else if (quadrant_id == 2)\n"
5223                                         << "            result_color = textureLod(sampler" << dimension << "(u_separateTexture, u_separateSampler" << accessPostfixA << "), " << coodStr[2] << ", 0.0);\n"
5224                                         << "    else\n"
5225                                         << "            result_color = textureLod(sampler" << dimension << "(u_separateTexture, u_separateSampler" << accessPostfixB << "), " << coodStr[3] << ", 0.0);\n";
5226                         }
5227                         else
5228                         {
5229                                 buf << "        if (quadrant_id == 0)\n"
5230                                         << "            result_color = textureLod(u_combinedTextureSampler" << accessPostfixA << ", " << coodStr[0] << ", 0.0);\n"
5231                                         << "    else if (quadrant_id == 1)\n"
5232                                         << "            result_color = textureLod(u_combinedTextureSampler" << accessPostfixB << ", " << coodStr[1] << ", 0.0);\n"
5233                                         << "    else if (quadrant_id == 2)\n"
5234                                         << "            result_color = textureLod(u_combinedTextureSampler" << accessPostfixA << ", " << coodStr[2] << ", 0.0);\n"
5235                                         << "    else\n"
5236                                         << "            result_color = textureLod(u_combinedTextureSampler" << accessPostfixB << ", " << coodStr[3] << ", 0.0);\n";
5237                         }
5238
5239                         return buf.str();
5240                 }
5241
5242                 case vk::VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
5243                 {
5244                         const std::string       coodStr[4]      =
5245                         {
5246                                 genFetchCoordStr(0),
5247                                 genFetchCoordStr(1),
5248                                 genFetchCoordStr(2),
5249                                 genFetchCoordStr(3),
5250                         };
5251                         std::ostringstream      buf;
5252
5253                         buf << "        if (quadrant_id == 0)\n"
5254                                 << "            result_color = imageLoad(u_image" << accessPostfixA << ", " << coodStr[0] << ");\n"
5255                                 << "    else if (quadrant_id == 1)\n"
5256                                 << "            result_color = imageLoad(u_image" << accessPostfixB << ", " << coodStr[1] << ");\n"
5257                                 << "    else if (quadrant_id == 2)\n"
5258                                 << "            result_color = imageLoad(u_image" << accessPostfixA << ", " << coodStr[2] << ");\n"
5259                                 << "    else\n"
5260                                 << "            result_color = imageLoad(u_image" << accessPostfixB << ", " << coodStr[3] << ");\n";
5261
5262                         return buf.str();
5263                 }
5264
5265                 default:
5266                         DE_FATAL("invalid descriptor");
5267                         return "";
5268         }
5269 }
5270
5271 std::string ImageDescriptorCase::genNoAccessSource (void) const
5272 {
5273         return "        if (quadrant_id == 1 || quadrant_id == 2)\n"
5274                         "               result_color = vec4(0.0, 1.0, 0.0, 1.0);\n"
5275                         "       else\n"
5276                         "               result_color = vec4(1.0, 1.0, 0.0, 1.0);\n";
5277 }
5278
5279 vkt::TestInstance* ImageDescriptorCase::createInstance (vkt::Context& context) const
5280 {
5281         verifyDriverSupport(context.getDeviceFeatures(), m_descriptorType, m_activeStages);
5282
5283         switch (m_descriptorType)
5284         {
5285                 case vk::VK_DESCRIPTOR_TYPE_SAMPLER:
5286                 case vk::VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
5287                         if (m_exitingStages == vk::VK_SHADER_STAGE_COMPUTE_BIT)
5288                         {
5289                                 DE_ASSERT(m_isPrimaryCmdBuf);
5290                                 return new ImageSampleComputeInstance(context, m_descriptorType, m_shaderInterface, m_viewType, m_baseMipLevel, m_baseArraySlice, m_isImmutableSampler);
5291                         }
5292                         else
5293                                 return new ImageSampleRenderInstance(context, m_isPrimaryCmdBuf, m_descriptorType, m_activeStages, m_shaderInterface, m_viewType, m_baseMipLevel, m_baseArraySlice, m_isImmutableSampler);
5294
5295                 case vk::VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
5296                 case vk::VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
5297                         if (m_exitingStages == vk::VK_SHADER_STAGE_COMPUTE_BIT)
5298                         {
5299                                 DE_ASSERT(m_isPrimaryCmdBuf);
5300                                 return new ImageFetchComputeInstance(context, m_descriptorType, m_shaderInterface, m_viewType, m_baseMipLevel, m_baseArraySlice);
5301                         }
5302                         else
5303                                 return new ImageFetchRenderInstance(context, m_isPrimaryCmdBuf, m_descriptorType, m_activeStages, m_shaderInterface, m_viewType, m_baseMipLevel, m_baseArraySlice);
5304
5305                 default:
5306                         DE_FATAL("Impossible");
5307                         return DE_NULL;
5308         }
5309 }
5310
5311 class TexelBufferInstanceBuffers
5312 {
5313 public:
5314                                                                                         TexelBufferInstanceBuffers      (const vk::DeviceInterface&             vki,
5315                                                                                                                                                  vk::VkDevice                                   device,
5316                                                                                                                                                  vk::Allocator&                                 allocator,
5317                                                                                                                                                  vk::VkDescriptorType                   descriptorType,
5318                                                                                                                                                  int                                                    numTexelBuffers,
5319                                                                                                                                                  bool                                                   hasViewOffset);
5320
5321 private:
5322         static vk::Move<vk::VkBuffer>                   createBuffer                            (const vk::DeviceInterface&             vki,
5323                                                                                                                                                  vk::VkDevice                                   device,
5324                                                                                                                                                  vk::Allocator&                                 allocator,
5325                                                                                                                                                  vk::VkDescriptorType                   descriptorType,
5326                                                                                                                                                  de::MovePtr<vk::Allocation>    *outAllocation);
5327
5328         static vk::Move<vk::VkBufferView>               createBufferView                        (const vk::DeviceInterface&             vki,
5329                                                                                                                                                  vk::VkDevice                                   device,
5330                                                                                                                                                  const tcu::TextureFormat&              textureFormat,
5331                                                                                                                                                  deUint32                                               offset,
5332                                                                                                                                                  vk::VkBuffer                                   buffer);
5333
5334         static vk::VkBufferMemoryBarrier                createBarrier                           (vk::VkDescriptorType descriptorType, vk::VkBuffer buffer);
5335
5336         void                                                                    populateSourceBuffer            (const tcu::PixelBufferAccess& access);
5337         void                                                                    uploadData                                      (const vk::DeviceInterface& vki, vk::VkDevice device, const vk::Allocation& memory, const de::ArrayBuffer<deUint8>& data);
5338
5339 public:
5340         static int                                                              getFetchPos                                     (int fetchPosNdx);
5341         tcu::Vec4                                                               fetchTexelValue                         (int fetchPosNdx) const;
5342
5343         inline int                                                              getNumTexelBuffers                      (void) const { return m_numTexelBuffers;        }
5344         const tcu::TextureFormat&                               getTextureFormat                        (void) const { return m_imageFormat;            }
5345         inline vk::VkBufferView                                 getBufferViewA                          (void) const { return *m_bufferViewA;           }
5346         inline vk::VkBufferView                                 getBufferViewB                          (void) const { return *m_bufferViewB;           }
5347         inline const vk::VkBufferMemoryBarrier* getBufferInitBarriers           (void) const { return m_bufferBarriers;         }
5348
5349 private:
5350         enum
5351         {
5352                 BUFFER_SIZE                     = 512,
5353                 VIEW_OFFSET_VALUE       = 256,
5354                 VIEW_DATA_SIZE          = 256,  //!< size in bytes
5355                 VIEW_WIDTH                      = 64,   //!< size in pixels
5356         };
5357         enum
5358         {
5359                 // some arbitrary points
5360                 SAMPLE_POINT_0 = 6,
5361                 SAMPLE_POINT_1 = 51,
5362                 SAMPLE_POINT_2 = 42,
5363                 SAMPLE_POINT_3 = 25,
5364         };
5365
5366         const deUint32                                                  m_numTexelBuffers;
5367         const tcu::TextureFormat                                m_imageFormat;
5368         const deUint32                                                  m_viewOffset;
5369
5370         de::ArrayBuffer<deUint8>                                m_sourceBufferA;
5371         de::ArrayBuffer<deUint8>                                m_sourceBufferB;
5372         const tcu::ConstPixelBufferAccess               m_sourceViewA;
5373         const tcu::ConstPixelBufferAccess               m_sourceViewB;
5374
5375         de::MovePtr<vk::Allocation>                             m_bufferMemoryA;
5376         de::MovePtr<vk::Allocation>                             m_bufferMemoryB;
5377         const vk::Unique<vk::VkBuffer>                  m_bufferA;
5378         const vk::Unique<vk::VkBuffer>                  m_bufferB;
5379         const vk::Unique<vk::VkBufferView>              m_bufferViewA;
5380         const vk::Unique<vk::VkBufferView>              m_bufferViewB;
5381         vk::VkBufferMemoryBarrier                               m_bufferBarriers[2];
5382 };
5383
5384 TexelBufferInstanceBuffers::TexelBufferInstanceBuffers (const vk::DeviceInterface&              vki,
5385                                                                                                                 vk::VkDevice                                    device,
5386                                                                                                                 vk::Allocator&                                  allocator,
5387                                                                                                                 vk::VkDescriptorType                    descriptorType,
5388                                                                                                                 int                                                             numTexelBuffers,
5389                                                                                                                 bool                                                    hasViewOffset)
5390         : m_numTexelBuffers     (numTexelBuffers)
5391         , m_imageFormat         (tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8)
5392         , m_viewOffset          ((hasViewOffset) ? ((deUint32)VIEW_OFFSET_VALUE) : (0u))
5393         , m_sourceBufferA       (BUFFER_SIZE)
5394         , m_sourceBufferB       ((numTexelBuffers == 1)
5395                                                         ? (0u)
5396                                                         : ((size_t)BUFFER_SIZE))
5397         , m_sourceViewA         (m_imageFormat, tcu::IVec3(VIEW_WIDTH, 1, 1), m_sourceBufferA.getElementPtr(m_viewOffset))
5398         , m_sourceViewB         (m_imageFormat, tcu::IVec3(VIEW_WIDTH, 1, 1), m_sourceBufferB.getElementPtr(m_viewOffset))
5399         , m_bufferMemoryA       (DE_NULL)
5400         , m_bufferMemoryB       (DE_NULL)
5401         , m_bufferA                     (createBuffer(vki, device, allocator, descriptorType, &m_bufferMemoryA))
5402         , m_bufferB                     ((numTexelBuffers == 1)
5403                                                         ? vk::Move<vk::VkBuffer>()
5404                                                         : createBuffer(vki, device, allocator, descriptorType, &m_bufferMemoryB))
5405         , m_bufferViewA         (createBufferView(vki, device, m_imageFormat, m_viewOffset, *m_bufferA))
5406         , m_bufferViewB         ((numTexelBuffers == 1)
5407                                                         ? vk::Move<vk::VkBufferView>()
5408                                                         : createBufferView(vki, device, m_imageFormat, m_viewOffset, *m_bufferB))
5409 {
5410         DE_ASSERT(numTexelBuffers == 1 || numTexelBuffers == 2);
5411         DE_ASSERT(VIEW_WIDTH * m_imageFormat.getPixelSize() == VIEW_DATA_SIZE);
5412         DE_ASSERT(BUFFER_SIZE % m_imageFormat.getPixelSize() == 0);
5413
5414         // specify and upload
5415
5416         populateSourceBuffer(tcu::PixelBufferAccess(m_imageFormat, tcu::IVec3(BUFFER_SIZE / m_imageFormat.getPixelSize(), 1, 1), m_sourceBufferA.getPtr()));
5417         uploadData(vki, device, *m_bufferMemoryA, m_sourceBufferA);
5418
5419         if (numTexelBuffers == 2)
5420         {
5421                 populateSourceBuffer(tcu::PixelBufferAccess(m_imageFormat, tcu::IVec3(BUFFER_SIZE / m_imageFormat.getPixelSize(), 1, 1), m_sourceBufferB.getPtr()));
5422                 uploadData(vki, device, *m_bufferMemoryB, m_sourceBufferB);
5423         }
5424
5425         m_bufferBarriers[0] = createBarrier(descriptorType, *m_bufferA);
5426         m_bufferBarriers[1] = createBarrier(descriptorType, *m_bufferB);
5427 }
5428
5429 vk::Move<vk::VkBuffer> TexelBufferInstanceBuffers::createBuffer (const vk::DeviceInterface&             vki,
5430                                                                                                                                  vk::VkDevice                                   device,
5431                                                                                                                                  vk::Allocator&                                 allocator,
5432                                                                                                                                  vk::VkDescriptorType                   descriptorType,
5433                                                                                                                                  de::MovePtr<vk::Allocation>    *outAllocation)
5434 {
5435         const vk::VkBufferUsageFlags    usage           = (isUniformDescriptorType(descriptorType)) ? (vk::VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT) : (vk::VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT);
5436         const vk::VkBufferCreateInfo    createInfo      =
5437         {
5438                 vk::VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
5439                 DE_NULL,
5440                 0u,                                                                     // flags
5441                 (vk::VkDeviceSize)BUFFER_SIZE,          // size
5442                 usage,                                                          // usage
5443                 vk::VK_SHARING_MODE_EXCLUSIVE,          // sharingMode
5444                 0u,                                                                     // queueFamilyCount
5445                 DE_NULL,                                                        // pQueueFamilyIndices
5446         };
5447         vk::Move<vk::VkBuffer>                  buffer          (vk::createBuffer(vki, device, &createInfo));
5448         de::MovePtr<vk::Allocation>             allocation      (allocateAndBindObjectMemory(vki, device, allocator, *buffer, vk::MemoryRequirement::HostVisible));
5449
5450         *outAllocation = allocation;
5451         return buffer;
5452 }
5453
5454 vk::Move<vk::VkBufferView> TexelBufferInstanceBuffers::createBufferView (const vk::DeviceInterface&             vki,
5455                                                                                                                                                  vk::VkDevice                                   device,
5456                                                                                                                                                  const tcu::TextureFormat&              textureFormat,
5457                                                                                                                                                  deUint32                                               offset,
5458                                                                                                                                                  vk::VkBuffer                                   buffer)
5459 {
5460         const vk::VkBufferViewCreateInfo createInfo =
5461         {
5462                 vk::VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO,
5463                 DE_NULL,
5464                 (vk::VkBufferViewCreateFlags)0,
5465                 buffer,                                                                 // buffer
5466                 vk::mapTextureFormat(textureFormat),    // format
5467                 (vk::VkDeviceSize)offset,                               // offset
5468                 (vk::VkDeviceSize)VIEW_DATA_SIZE                // range
5469         };
5470         return vk::createBufferView(vki, device, &createInfo);
5471 }
5472
5473 vk::VkBufferMemoryBarrier TexelBufferInstanceBuffers::createBarrier (vk::VkDescriptorType descriptorType, vk::VkBuffer buffer)
5474 {
5475         const vk::VkAccessFlags                 inputBit        = (isUniformDescriptorType(descriptorType)) ? (vk::VK_ACCESS_UNIFORM_READ_BIT) : (vk::VK_ACCESS_SHADER_READ_BIT);
5476         const vk::VkBufferMemoryBarrier barrier         =
5477         {
5478                 vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
5479                 DE_NULL,
5480                 vk::VK_ACCESS_HOST_WRITE_BIT,                   // outputMask
5481                 inputBit,                                                               // inputMask
5482                 vk::VK_QUEUE_FAMILY_IGNORED,                    // srcQueueFamilyIndex
5483                 vk::VK_QUEUE_FAMILY_IGNORED,                    // destQueueFamilyIndex
5484                 buffer  ,                                                               // buffer
5485                 0u,                                                                             // offset
5486                 (vk::VkDeviceSize)BUFFER_SIZE                   // size
5487         };
5488         return barrier;
5489 }
5490
5491 void TexelBufferInstanceBuffers::populateSourceBuffer (const tcu::PixelBufferAccess& access)
5492 {
5493         DE_ASSERT(access.getHeight() == 1);
5494         DE_ASSERT(access.getDepth() == 1);
5495
5496         const deInt32 width = access.getWidth();
5497
5498         for (int x = 0; x < width; ++x)
5499         {
5500                 const int                       red             = 255 * x / width;                                                                                              //!< gradient from 0 -> max (detects large offset errors)
5501                 const int                       green   = ((x % 2 == 0) ? (127) : (0)) + ((x % 4 < 3) ? (128) : (0));   //!< 3-level M pattern (detects small offset errors)
5502                 const int                       blue    = 16 * (x % 16);                                                                                                //!< 16-long triangle wave
5503
5504                 DE_ASSERT(de::inRange(red, 0, 255));
5505                 DE_ASSERT(de::inRange(green, 0, 255));
5506                 DE_ASSERT(de::inRange(blue, 0, 255));
5507
5508                 access.setPixel(tcu::IVec4(red, green, blue, 255), x, 0, 0);
5509         }
5510 }
5511
5512 void TexelBufferInstanceBuffers::uploadData (const vk::DeviceInterface& vki, vk::VkDevice device, const vk::Allocation& memory, const de::ArrayBuffer<deUint8>& data)
5513 {
5514         deMemcpy(memory.getHostPtr(), data.getPtr(), data.size());
5515         flushMappedMemoryRange(vki, device, memory.getMemory(), memory.getOffset(), data.size());
5516 }
5517
5518 int TexelBufferInstanceBuffers::getFetchPos (int fetchPosNdx)
5519 {
5520         static const int fetchPositions[4] =
5521         {
5522                 SAMPLE_POINT_0,
5523                 SAMPLE_POINT_1,
5524                 SAMPLE_POINT_2,
5525                 SAMPLE_POINT_3,
5526         };
5527         return de::getSizedArrayElement<4>(fetchPositions, fetchPosNdx);
5528 }
5529
5530 tcu::Vec4 TexelBufferInstanceBuffers::fetchTexelValue (int fetchPosNdx) const
5531 {
5532         // source order is ABAB
5533         const tcu::ConstPixelBufferAccess&      texelSrcA       = m_sourceViewA;
5534         const tcu::ConstPixelBufferAccess&      texelSrcB       = (m_numTexelBuffers == 1) ? (m_sourceViewA) : (m_sourceViewB);
5535         const tcu::ConstPixelBufferAccess&      texelSrc        = ((fetchPosNdx % 2) == 0) ? (texelSrcA) : (texelSrcB);
5536
5537         return texelSrc.getPixel(getFetchPos(fetchPosNdx), 0, 0);
5538 }
5539
5540 class TexelBufferRenderInstance : public SingleCmdRenderInstance
5541 {
5542 public:
5543                                                                                                         TexelBufferRenderInstance       (vkt::Context&                  context,
5544                                                                                                                                                                  bool                                   isPrimaryCmdBuf,
5545                                                                                                                                                                  vk::VkDescriptorType   descriptorType,
5546                                                                                                                                                                  vk::VkShaderStageFlags stageFlags,
5547                                                                                                                                                                  ShaderInputInterface   shaderInterface,
5548                                                                                                                                                                  bool                                   nonzeroViewOffset);
5549
5550 private:
5551         static vk::Move<vk::VkDescriptorSetLayout>              createDescriptorSetLayout       (const vk::DeviceInterface&     vki,
5552                                                                                                                                                                  vk::VkDevice                           device,
5553                                                                                                                                                                  vk::VkDescriptorType           descriptorType,
5554                                                                                                                                                                  ShaderInputInterface           shaderInterface,
5555                                                                                                                                                                  vk::VkShaderStageFlags         stageFlags);
5556
5557         static vk::Move<vk::VkPipelineLayout>                   createPipelineLayout            (const vk::DeviceInterface&     vki,
5558                                                                                                                                                                  vk::VkDevice                           device,
5559                                                                                                                                                                  vk::VkDescriptorSetLayout      descriptorSetLayout);
5560
5561         static vk::Move<vk::VkDescriptorPool>                   createDescriptorPool            (const vk::DeviceInterface&     vki,
5562                                                                                                                                                                  vk::VkDevice                           device,
5563                                                                                                                                                                  vk::VkDescriptorType           descriptorType,
5564                                                                                                                                                                  ShaderInputInterface           shaderInterface);
5565
5566         static vk::Move<vk::VkDescriptorSet>                    createDescriptorSet                     (const vk::DeviceInterface&     vki,
5567                                                                                                                                                                  vk::VkDevice                           device,
5568                                                                                                                                                                  vk::VkDescriptorType           descriptorType,
5569                                                                                                                                                                  ShaderInputInterface           shaderInterface,
5570                                                                                                                                                                  vk::VkDescriptorSetLayout      layout,
5571                                                                                                                                                                  vk::VkDescriptorPool           pool,
5572                                                                                                                                                                  vk::VkBufferView                       viewA,
5573                                                                                                                                                                  vk::VkBufferView                       viewB);
5574
5575         void                                                                                    logTestPlan                                     (void) const;
5576         vk::VkPipelineLayout                                                    getPipelineLayout                       (void) const;
5577         void                                                                                    writeDrawCmdBuffer                      (vk::VkCommandBuffer cmd) const;
5578         tcu::TestStatus                                                                 verifyResultImage                       (const tcu::ConstPixelBufferAccess& result) const;
5579
5580         enum
5581         {
5582                 RENDER_SIZE = 128,
5583         };
5584
5585         const vk::VkDescriptorType                                              m_descriptorType;
5586         const vk::VkShaderStageFlags                                    m_stageFlags;
5587         const ShaderInputInterface                                              m_shaderInterface;
5588         const bool                                                                              m_nonzeroViewOffset;
5589
5590         const vk::Unique<vk::VkDescriptorSetLayout>             m_descriptorSetLayout;
5591         const vk::Unique<vk::VkPipelineLayout>                  m_pipelineLayout;
5592         const TexelBufferInstanceBuffers                                m_texelBuffers;
5593         const vk::Unique<vk::VkDescriptorPool>                  m_descriptorPool;
5594         const vk::Unique<vk::VkDescriptorSet>                   m_descriptorSet;
5595 };
5596
5597 TexelBufferRenderInstance::TexelBufferRenderInstance (vkt::Context&                             context,
5598                                                                                                           bool                                          isPrimaryCmdBuf,
5599                                                                                                           vk::VkDescriptorType          descriptorType,
5600                                                                                                           vk::VkShaderStageFlags        stageFlags,
5601                                                                                                           ShaderInputInterface          shaderInterface,
5602                                                                                                           bool                                          nonzeroViewOffset)
5603         : SingleCmdRenderInstance       (context, isPrimaryCmdBuf, tcu::UVec2(RENDER_SIZE, RENDER_SIZE))
5604         , m_descriptorType                      (descriptorType)
5605         , m_stageFlags                          (stageFlags)
5606         , m_shaderInterface                     (shaderInterface)
5607         , m_nonzeroViewOffset           (nonzeroViewOffset)
5608         , m_descriptorSetLayout         (createDescriptorSetLayout(m_vki, m_device, m_descriptorType, m_shaderInterface, m_stageFlags))
5609         , m_pipelineLayout                      (createPipelineLayout(m_vki, m_device, *m_descriptorSetLayout))
5610         , m_texelBuffers                        (m_vki, m_device, m_allocator, m_descriptorType, getInterfaceNumResources(m_shaderInterface), m_nonzeroViewOffset)
5611         , m_descriptorPool                      (createDescriptorPool(m_vki, m_device, m_descriptorType, m_shaderInterface))
5612         , m_descriptorSet                       (createDescriptorSet(m_vki, m_device, m_descriptorType, m_shaderInterface, *m_descriptorSetLayout, *m_descriptorPool, m_texelBuffers.getBufferViewA(), m_texelBuffers.getBufferViewB()))
5613 {
5614 }
5615
5616 vk::Move<vk::VkDescriptorSetLayout> TexelBufferRenderInstance::createDescriptorSetLayout (const vk::DeviceInterface&    vki,
5617                                                                                                                                                                                   vk::VkDevice                                  device,
5618                                                                                                                                                                                   vk::VkDescriptorType                  descriptorType,
5619                                                                                                                                                                                   ShaderInputInterface                  shaderInterface,
5620                                                                                                                                                                                   vk::VkShaderStageFlags                stageFlags)
5621 {
5622         vk::DescriptorSetLayoutBuilder builder;
5623
5624         switch (shaderInterface)
5625         {
5626                 case SHADER_INPUT_SINGLE_DESCRIPTOR:
5627                         builder.addSingleBinding(descriptorType, stageFlags);
5628                         break;
5629
5630                 case SHADER_INPUT_MULTIPLE_CONTIGUOUS_DESCRIPTORS:
5631                         builder.addSingleBinding(descriptorType, stageFlags);
5632                         builder.addSingleBinding(descriptorType, stageFlags);
5633                         break;
5634
5635                 case SHADER_INPUT_DESCRIPTOR_ARRAY:
5636                         builder.addArrayBinding(descriptorType, 2u, stageFlags);
5637                         break;
5638
5639                 default:
5640                         DE_FATAL("Impossible");
5641         }
5642
5643         return builder.build(vki, device);
5644 }
5645
5646 vk::Move<vk::VkPipelineLayout> TexelBufferRenderInstance::createPipelineLayout (const vk::DeviceInterface&      vki,
5647                                                                                                                                                                 vk::VkDevice                            device,
5648                                                                                                                                                                 vk::VkDescriptorSetLayout       descriptorSetLayout)
5649 {
5650         const vk::VkPipelineLayoutCreateInfo createInfo =
5651         {
5652                 vk::VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
5653                 DE_NULL,
5654                 (vk::VkPipelineLayoutCreateFlags)0,
5655                 1,                                              // descriptorSetCount
5656                 &descriptorSetLayout,   // pSetLayouts
5657                 0u,                                             // pushConstantRangeCount
5658                 DE_NULL,                                // pPushConstantRanges
5659         };
5660         return vk::createPipelineLayout(vki, device, &createInfo);
5661 }
5662
5663 vk::Move<vk::VkDescriptorPool> TexelBufferRenderInstance::createDescriptorPool (const vk::DeviceInterface&      vki,
5664                                                                                                                                                                 vk::VkDevice                                    device,
5665                                                                                                                                                                 vk::VkDescriptorType                    descriptorType,
5666                                                                                                                                                                 ShaderInputInterface                    shaderInterface)
5667 {
5668         return vk::DescriptorPoolBuilder()
5669                 .addType(descriptorType, getInterfaceNumResources(shaderInterface))
5670                 .build(vki, device, vk::VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1);
5671 }
5672
5673 vk::Move<vk::VkDescriptorSet> TexelBufferRenderInstance::createDescriptorSet (const vk::DeviceInterface&        vki,
5674                                                                                                                                                           vk::VkDevice                                  device,
5675                                                                                                                                                           vk::VkDescriptorType                  descriptorType,
5676                                                                                                                                                           ShaderInputInterface                  shaderInterface,
5677                                                                                                                                                           vk::VkDescriptorSetLayout             layout,
5678                                                                                                                                                           vk::VkDescriptorPool                  pool,
5679                                                                                                                                                           vk::VkBufferView                              viewA,
5680                                                                                                                                                           vk::VkBufferView                              viewB)
5681 {
5682         const vk::VkBufferView                                  texelBufferInfos[2]     =
5683         {
5684                 viewA,
5685                 viewB,
5686         };
5687         const vk::VkDescriptorSetAllocateInfo   allocInfo                       =
5688         {
5689                 vk::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
5690                 DE_NULL,
5691                 pool,
5692                 1u,
5693                 &layout
5694         };
5695
5696         vk::Move<vk::VkDescriptorSet>                   descriptorSet           = allocateDescriptorSet(vki, device, &allocInfo);
5697         vk::DescriptorSetUpdateBuilder                  builder;
5698
5699         switch (shaderInterface)
5700         {
5701                 case SHADER_INPUT_SINGLE_DESCRIPTOR:
5702                         builder.writeSingle(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(0u), descriptorType, &texelBufferInfos[0]);
5703                         break;
5704
5705                 case SHADER_INPUT_MULTIPLE_CONTIGUOUS_DESCRIPTORS:
5706                         builder.writeSingle(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(0u), descriptorType, &texelBufferInfos[0]);
5707                         builder.writeSingle(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(1u), descriptorType, &texelBufferInfos[1]);
5708                         break;
5709
5710                 case SHADER_INPUT_DESCRIPTOR_ARRAY:
5711                         builder.writeArray(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(0u), descriptorType, 2u, texelBufferInfos);
5712                         break;
5713
5714                 default:
5715                         DE_FATAL("Impossible");
5716         }
5717
5718         builder.update(vki, device);
5719         return descriptorSet;
5720 }
5721
5722 void TexelBufferRenderInstance::logTestPlan (void) const
5723 {
5724         std::ostringstream msg;
5725
5726         msg << "Rendering 2x2 grid.\n"
5727                 << "Single descriptor set. Descriptor set contains "
5728                         << ((m_shaderInterface == SHADER_INPUT_SINGLE_DESCRIPTOR) ? "single" :
5729                             (m_shaderInterface == SHADER_INPUT_MULTIPLE_CONTIGUOUS_DESCRIPTORS) ? "two" :
5730                             (m_shaderInterface == SHADER_INPUT_DESCRIPTOR_ARRAY) ? "an array (size 2) of" :
5731                             (const char*)DE_NULL)
5732                 << " descriptor(s) of type " << vk::getDescriptorTypeName(m_descriptorType) << "\n"
5733                 << "Buffer view is created with a " << ((m_nonzeroViewOffset) ? ("non-zero") : ("zero")) << " offset.\n"
5734                 << "Buffer format is " << vk::getFormatName(vk::mapTextureFormat(m_texelBuffers.getTextureFormat())) << ".\n";
5735
5736         if (m_stageFlags == 0u)
5737         {
5738                 msg << "Descriptors are not accessed in any shader stage.\n";
5739         }
5740         else
5741         {
5742                 msg << "Color in each cell is fetched using the descriptor(s):\n";
5743
5744                 for (int resultNdx = 0; resultNdx < 4; ++resultNdx)
5745                 {
5746                         msg << "Test sample " << resultNdx << ": fetch at position " << m_texelBuffers.getFetchPos(resultNdx);
5747
5748                         if (m_shaderInterface != SHADER_INPUT_SINGLE_DESCRIPTOR)
5749                         {
5750                                 const int srcResourceNdx = (resultNdx % 2); // ABAB source
5751                                 msg << " from texelBuffer " << srcResourceNdx;
5752                         }
5753
5754                         msg << "\n";
5755                 }
5756
5757                 msg << "Descriptors are accessed in {"
5758                         << (((m_stageFlags & vk::VK_SHADER_STAGE_VERTEX_BIT) != 0)                                      ? (" vertex")                   : (""))
5759                         << (((m_stageFlags & vk::VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) != 0)        ? (" tess_control")             : (""))
5760                         << (((m_stageFlags & vk::VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT) != 0)     ? (" tess_evaluation")  : (""))
5761                         << (((m_stageFlags & vk::VK_SHADER_STAGE_GEOMETRY_BIT) != 0)                            ? (" geometry")                 : (""))
5762                         << (((m_stageFlags & vk::VK_SHADER_STAGE_FRAGMENT_BIT) != 0)                            ? (" fragment")                 : (""))
5763                         << " } stages.";
5764         }
5765
5766         m_context.getTestContext().getLog()
5767                 << tcu::TestLog::Message
5768                 << msg.str()
5769                 << tcu::TestLog::EndMessage;
5770 }
5771
5772 vk::VkPipelineLayout TexelBufferRenderInstance::getPipelineLayout (void) const
5773 {
5774         return *m_pipelineLayout;
5775 }
5776
5777 void TexelBufferRenderInstance::writeDrawCmdBuffer (vk::VkCommandBuffer cmd) const
5778 {
5779         m_vki.cmdBindDescriptorSets(cmd, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, getPipelineLayout(), 0, 1, &m_descriptorSet.get(), 0, DE_NULL);
5780         m_vki.cmdDraw(cmd, 6 * 4, 1, 0, 0); // render four quads (two separate triangles)
5781 }
5782
5783 tcu::TestStatus TexelBufferRenderInstance::verifyResultImage (const tcu::ConstPixelBufferAccess& result) const
5784 {
5785         const tcu::Vec4         green           (0.0f, 1.0f, 0.0f, 1.0f);
5786         const tcu::Vec4         yellow          (1.0f, 1.0f, 0.0f, 1.0f);
5787         const bool                      doFetch         = (m_stageFlags != 0u); // no active stages? Then don't fetch
5788         const tcu::Vec4         sample0         = (!doFetch) ? (yellow) : (m_texelBuffers.fetchTexelValue(0));
5789         const tcu::Vec4         sample1         = (!doFetch) ? (green)  : (m_texelBuffers.fetchTexelValue(1));
5790         const tcu::Vec4         sample2         = (!doFetch) ? (green)  : (m_texelBuffers.fetchTexelValue(2));
5791         const tcu::Vec4         sample3         = (!doFetch) ? (yellow) : (m_texelBuffers.fetchTexelValue(3));
5792         tcu::Surface            reference       (m_targetSize.x(), m_targetSize.y());
5793
5794         drawQuadrantReferenceResult(reference.getAccess(), sample0, sample1, sample2, sample3);
5795
5796         if (!bilinearCompare(m_context.getTestContext().getLog(), "Compare", "Result comparison", reference.getAccess(), result, tcu::RGBA(1, 1, 1, 1), tcu::COMPARE_LOG_RESULT))
5797                 return tcu::TestStatus::fail("Image verification failed");
5798         else
5799                 return tcu::TestStatus::pass("Pass");
5800 }
5801
5802 class TexelBufferComputeInstance : public vkt::TestInstance
5803 {
5804 public:
5805                                                                                         TexelBufferComputeInstance      (vkt::Context&                  context,
5806                                                                                                                                                  vk::VkDescriptorType   descriptorType,
5807                                                                                                                                                  ShaderInputInterface   shaderInterface,
5808                                                                                                                                                  bool                                   nonzeroViewOffset);
5809
5810 private:
5811         vk::Move<vk::VkDescriptorSetLayout>             createDescriptorSetLayout       (void) const;
5812         vk::Move<vk::VkDescriptorPool>                  createDescriptorPool            (void) const;
5813         vk::Move<vk::VkDescriptorSet>                   createDescriptorSet                     (vk::VkDescriptorPool pool, vk::VkDescriptorSetLayout layout) const;
5814
5815         tcu::TestStatus                                                 iterate                                         (void);
5816         void                                                                    logTestPlan                                     (void) const;
5817         tcu::TestStatus                                                 testResourceAccess                      (void);
5818
5819         const vk::VkDescriptorType                              m_descriptorType;
5820         const ShaderInputInterface                              m_shaderInterface;
5821         const bool                                                              m_nonzeroViewOffset;
5822
5823         const vk::DeviceInterface&                              m_vki;
5824         const vk::VkDevice                                              m_device;
5825         const vk::VkQueue                                               m_queue;
5826         const deUint32                                                  m_queueFamilyIndex;
5827         vk::Allocator&                                                  m_allocator;
5828
5829         const ComputeInstanceResultBuffer               m_result;
5830         const TexelBufferInstanceBuffers                m_texelBuffers;
5831 };
5832
5833 TexelBufferComputeInstance::TexelBufferComputeInstance (Context&                                context,
5834                                                                                                                 vk::VkDescriptorType    descriptorType,
5835                                                                                                                 ShaderInputInterface    shaderInterface,
5836                                                                                                                 bool                                    nonzeroViewOffset)
5837         : vkt::TestInstance             (context)
5838         , m_descriptorType              (descriptorType)
5839         , m_shaderInterface             (shaderInterface)
5840         , m_nonzeroViewOffset   (nonzeroViewOffset)
5841         , m_vki                                 (context.getDeviceInterface())
5842         , m_device                              (context.getDevice())
5843         , m_queue                               (context.getUniversalQueue())
5844         , m_queueFamilyIndex    (context.getUniversalQueueFamilyIndex())
5845         , m_allocator                   (context.getDefaultAllocator())
5846         , m_result                              (m_vki, m_device, m_allocator)
5847         , m_texelBuffers                (m_vki, m_device, m_allocator, m_descriptorType, getInterfaceNumResources(m_shaderInterface), m_nonzeroViewOffset)
5848 {
5849 }
5850
5851 vk::Move<vk::VkDescriptorSetLayout> TexelBufferComputeInstance::createDescriptorSetLayout (void) const
5852 {
5853         vk::DescriptorSetLayoutBuilder builder;
5854
5855         builder.addSingleBinding(vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, vk::VK_SHADER_STAGE_COMPUTE_BIT);
5856
5857         switch (m_shaderInterface)
5858         {
5859                 case SHADER_INPUT_SINGLE_DESCRIPTOR:
5860                         builder.addSingleBinding(m_descriptorType, vk::VK_SHADER_STAGE_COMPUTE_BIT);
5861                         break;
5862
5863                 case SHADER_INPUT_MULTIPLE_CONTIGUOUS_DESCRIPTORS:
5864                         builder.addSingleBinding(m_descriptorType, vk::VK_SHADER_STAGE_COMPUTE_BIT);
5865                         builder.addSingleBinding(m_descriptorType, vk::VK_SHADER_STAGE_COMPUTE_BIT);
5866                         break;
5867
5868                 case SHADER_INPUT_DESCRIPTOR_ARRAY:
5869                         builder.addArrayBinding(m_descriptorType, 2u, vk::VK_SHADER_STAGE_COMPUTE_BIT);
5870                         break;
5871
5872                 default:
5873                         DE_FATAL("Impossible");
5874         };
5875
5876         return builder.build(m_vki, m_device);
5877 }
5878
5879 vk::Move<vk::VkDescriptorPool> TexelBufferComputeInstance::createDescriptorPool (void) const
5880 {
5881         return vk::DescriptorPoolBuilder()
5882                 .addType(vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER)
5883                 .addType(m_descriptorType, getInterfaceNumResources(m_shaderInterface))
5884                 .build(m_vki, m_device, vk::VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1);
5885 }
5886
5887 vk::Move<vk::VkDescriptorSet> TexelBufferComputeInstance::createDescriptorSet (vk::VkDescriptorPool pool, vk::VkDescriptorSetLayout layout) const
5888 {
5889         const vk::VkDescriptorBufferInfo                resultInfo                      = vk::makeDescriptorBufferInfo(m_result.getBuffer(), 0u, (vk::VkDeviceSize)ComputeInstanceResultBuffer::DATA_SIZE);
5890         const vk::VkBufferView                                  texelBufferInfos[2]     =
5891         {
5892                 m_texelBuffers.getBufferViewA(),
5893                 m_texelBuffers.getBufferViewB(),
5894         };
5895         const vk::VkDescriptorSetAllocateInfo   allocInfo                       =
5896         {
5897                 vk::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
5898                 DE_NULL,
5899                 pool,
5900                 1u,
5901                 &layout
5902         };
5903
5904         vk::Move<vk::VkDescriptorSet>                   descriptorSet           = allocateDescriptorSet(m_vki, m_device, &allocInfo);
5905         vk::DescriptorSetUpdateBuilder                  builder;
5906
5907         // result
5908         builder.writeSingle(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(0u), vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &resultInfo);
5909
5910         // texel buffers
5911         switch (m_shaderInterface)
5912         {
5913                 case SHADER_INPUT_SINGLE_DESCRIPTOR:
5914                         builder.writeSingle(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(1u), m_descriptorType, &texelBufferInfos[0]);
5915                         break;
5916
5917                 case SHADER_INPUT_MULTIPLE_CONTIGUOUS_DESCRIPTORS:
5918                         builder.writeSingle(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(1u), m_descriptorType, &texelBufferInfos[0]);
5919                         builder.writeSingle(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(2u), m_descriptorType, &texelBufferInfos[1]);
5920                         break;
5921
5922                 case SHADER_INPUT_DESCRIPTOR_ARRAY:
5923                         builder.writeArray(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(1u), m_descriptorType, 2u, texelBufferInfos);
5924                         break;
5925
5926                 default:
5927                         DE_FATAL("Impossible");
5928         }
5929
5930         builder.update(m_vki, m_device);
5931         return descriptorSet;
5932 }
5933
5934 tcu::TestStatus TexelBufferComputeInstance::iterate (void)
5935 {
5936         logTestPlan();
5937         return testResourceAccess();
5938 }
5939
5940 void TexelBufferComputeInstance::logTestPlan (void) const
5941 {
5942         std::ostringstream msg;
5943
5944         msg << "Fetching 4 values from image in compute shader.\n"
5945                 << "Single descriptor set. Descriptor set contains "
5946                         << ((m_shaderInterface == SHADER_INPUT_SINGLE_DESCRIPTOR) ? "single" :
5947                             (m_shaderInterface == SHADER_INPUT_MULTIPLE_CONTIGUOUS_DESCRIPTORS) ? "two" :
5948                             (m_shaderInterface == SHADER_INPUT_DESCRIPTOR_ARRAY) ? "an array (size 2) of" :
5949                             (const char*)DE_NULL)
5950                 << " descriptor(s) of type " << vk::getDescriptorTypeName(m_descriptorType) << "\n"
5951                 << "Buffer view is created with a " << ((m_nonzeroViewOffset) ? ("non-zero") : ("zero")) << " offset.\n"
5952                 << "Buffer format is " << vk::getFormatName(vk::mapTextureFormat(m_texelBuffers.getTextureFormat())) << ".\n";
5953
5954         for (int resultNdx = 0; resultNdx < 4; ++resultNdx)
5955         {
5956                 msg << "Test sample " << resultNdx << ": fetch at position " << m_texelBuffers.getFetchPos(resultNdx);
5957
5958                 if (m_shaderInterface != SHADER_INPUT_SINGLE_DESCRIPTOR)
5959                 {
5960                         const int srcResourceNdx = (resultNdx % 2); // ABAB source
5961                         msg << " from texelBuffer " << srcResourceNdx;
5962                 }
5963
5964                 msg << "\n";
5965         }
5966
5967         m_context.getTestContext().getLog()
5968                 << tcu::TestLog::Message
5969                 << msg.str()
5970                 << tcu::TestLog::EndMessage;
5971 }
5972
5973 tcu::TestStatus TexelBufferComputeInstance::testResourceAccess (void)
5974 {
5975         const vk::Unique<vk::VkDescriptorSetLayout>             descriptorSetLayout     (createDescriptorSetLayout());
5976         const vk::Unique<vk::VkDescriptorPool>                  descriptorPool          (createDescriptorPool());
5977         const vk::Unique<vk::VkDescriptorSet>                   descriptorSet           (createDescriptorSet(*descriptorPool, *descriptorSetLayout));
5978         const ComputePipeline                                                   pipeline                        (m_vki, m_device, m_context.getBinaryCollection(), 1, &descriptorSetLayout.get());
5979
5980         const vk::VkDescriptorSet                                               descriptorSets[]        = { *descriptorSet };
5981         const int                                                                               numDescriptorSets       = DE_LENGTH_OF_ARRAY(descriptorSets);
5982         const deUint32* const                                                   dynamicOffsets          = DE_NULL;
5983         const int                                                                               numDynamicOffsets       = 0;
5984         const vk::VkBufferMemoryBarrier* const                  preBarriers                     = m_texelBuffers.getBufferInitBarriers();
5985         const int                                                                               numPreBarriers          = m_texelBuffers.getNumTexelBuffers();
5986         const vk::VkBufferMemoryBarrier* const                  postBarriers            = m_result.getResultReadBarrier();
5987         const int                                                                               numPostBarriers         = 1;
5988
5989         const ComputeCommand                                                    compute                         (m_vki,
5990                                                                                                                                                  m_device,
5991                                                                                                                                                  pipeline.getPipeline(),
5992                                                                                                                                                  pipeline.getPipelineLayout(),
5993                                                                                                                                                  tcu::UVec3(4, 1, 1),
5994                                                                                                                                                  numDescriptorSets,     descriptorSets,
5995                                                                                                                                                  numDynamicOffsets,     dynamicOffsets,
5996                                                                                                                                                  numPreBarriers,        preBarriers,
5997                                                                                                                                                  numPostBarriers,       postBarriers);
5998
5999         tcu::Vec4                                                                               results[4];
6000         bool                                                                                    anyResultSet            = false;
6001         bool                                                                                    allResultsOk            = true;
6002
6003         compute.submitAndWait(m_queueFamilyIndex, m_queue);
6004         m_result.readResultContentsTo(&results);
6005
6006         // verify
6007         for (int resultNdx = 0; resultNdx < 4; ++resultNdx)
6008         {
6009                 const tcu::Vec4 result                          = results[resultNdx];
6010                 const tcu::Vec4 reference                       = m_texelBuffers.fetchTexelValue(resultNdx);
6011                 const tcu::Vec4 conversionThreshold     = tcu::Vec4(1.0f / 255.0f);
6012
6013                 if (result != tcu::Vec4(-1.0f))
6014                         anyResultSet = true;
6015
6016                 if (tcu::boolAny(tcu::greaterThan(tcu::abs(result - reference), conversionThreshold)))
6017                 {
6018                         allResultsOk = false;
6019
6020                         m_context.getTestContext().getLog()
6021                                 << tcu::TestLog::Message
6022                                 << "Test sample " << resultNdx << ": Expected " << reference << ", got " << result
6023                                 << tcu::TestLog::EndMessage;
6024                 }
6025         }
6026
6027         // read back and verify
6028         if (allResultsOk)
6029                 return tcu::TestStatus::pass("Pass");
6030         else if (anyResultSet)
6031                 return tcu::TestStatus::fail("Invalid result values");
6032         else
6033         {
6034                 m_context.getTestContext().getLog()
6035                         << tcu::TestLog::Message
6036                         << "Result buffer was not written to."
6037                         << tcu::TestLog::EndMessage;
6038                 return tcu::TestStatus::fail("Result buffer was not written to");
6039         }
6040 }
6041
6042 class TexelBufferDescriptorCase : public QuadrantRendederCase
6043 {
6044 public:
6045         enum
6046         {
6047                 FLAG_VIEW_OFFSET = (1u << 1u),
6048         };
6049         // enum continues where resource flags ends
6050         DE_STATIC_ASSERT((deUint32)FLAG_VIEW_OFFSET == (deUint32)RESOURCE_FLAG_LAST);
6051
6052                                                                 TexelBufferDescriptorCase       (tcu::TestContext&              testCtx,
6053                                                                                                                          const char*                    name,
6054                                                                                                                          const char*                    description,
6055                                                                                                                          bool                                   isPrimaryCmdBuf,
6056                                                                                                                          vk::VkDescriptorType   descriptorType,
6057                                                                                                                          vk::VkShaderStageFlags exitingStages,
6058                                                                                                                          vk::VkShaderStageFlags activeStages,
6059                                                                                                                          ShaderInputInterface   shaderInterface,
6060                                                                                                                          deUint32                               flags);
6061
6062 private:
6063         std::string                                     genExtensionDeclarations        (vk::VkShaderStageFlagBits stage) const;
6064         std::string                                     genResourceDeclarations         (vk::VkShaderStageFlagBits stage, int numUsedBindings) const;
6065         std::string                                     genResourceAccessSource         (vk::VkShaderStageFlagBits stage) const;
6066         std::string                                     genNoAccessSource                       (void) const;
6067
6068         vkt::TestInstance*                      createInstance                          (vkt::Context& context) const;
6069
6070         const bool                                      m_isPrimaryCmdBuf;
6071         const vk::VkDescriptorType      m_descriptorType;
6072         const ShaderInputInterface      m_shaderInterface;
6073         const bool                                      m_nonzeroViewOffset;
6074 };
6075
6076 TexelBufferDescriptorCase::TexelBufferDescriptorCase (tcu::TestContext&                 testCtx,
6077                                                                                                           const char*                           name,
6078                                                                                                           const char*                           description,
6079                                                                                                           bool                                          isPrimaryCmdBuf,
6080                                                                                                           vk::VkDescriptorType          descriptorType,
6081                                                                                                           vk::VkShaderStageFlags        exitingStages,
6082                                                                                                           vk::VkShaderStageFlags        activeStages,
6083                                                                                                           ShaderInputInterface          shaderInterface,
6084                                                                                                           deUint32                                      flags)
6085         : QuadrantRendederCase  (testCtx, name, description, glu::GLSL_VERSION_310_ES, exitingStages, activeStages)
6086         , m_isPrimaryCmdBuf             (isPrimaryCmdBuf)
6087         , m_descriptorType              (descriptorType)
6088         , m_shaderInterface             (shaderInterface)
6089         , m_nonzeroViewOffset   (((flags & FLAG_VIEW_OFFSET) != 0) ? (1u) : (0u))
6090 {
6091 }
6092
6093 std::string TexelBufferDescriptorCase::genExtensionDeclarations (vk::VkShaderStageFlagBits stage) const
6094 {
6095         DE_UNREF(stage);
6096         return "#extension GL_EXT_texture_buffer : require\n";
6097 }
6098
6099 std::string TexelBufferDescriptorCase::genResourceDeclarations (vk::VkShaderStageFlagBits stage, int numUsedBindings) const
6100 {
6101         DE_UNREF(stage);
6102
6103         const bool                      isUniform               = isUniformDescriptorType(m_descriptorType);
6104         const char* const       storageType             = (isUniform) ? ("samplerBuffer ") : ("readonly imageBuffer ");
6105         const char* const       formatQualifier = (isUniform) ? ("") : (", rgba8");
6106
6107         switch (m_shaderInterface)
6108         {
6109                 case SHADER_INPUT_SINGLE_DESCRIPTOR:
6110                         return "layout(set = 0, binding = " + de::toString(numUsedBindings) + formatQualifier + ") uniform highp " + storageType + " u_texelBuffer;\n";
6111
6112                 case SHADER_INPUT_MULTIPLE_CONTIGUOUS_DESCRIPTORS:
6113                         return "layout(set = 0, binding = " + de::toString(numUsedBindings) + formatQualifier + ") uniform highp " + storageType + " u_texelBufferA;\n"
6114                                    "layout(set = 0, binding = " + de::toString(numUsedBindings+1) + formatQualifier + ") uniform highp " + storageType + " u_texelBufferB;\n";
6115
6116                 case SHADER_INPUT_DESCRIPTOR_ARRAY:
6117                         return "layout(set = 0, binding = " + de::toString(numUsedBindings) + formatQualifier + ") uniform highp " + storageType + " u_texelBuffer[2];\n";
6118
6119                 default:
6120                         DE_FATAL("Impossible");
6121                         return "";
6122         }
6123 }
6124
6125 std::string TexelBufferDescriptorCase::genResourceAccessSource (vk::VkShaderStageFlagBits stage) const
6126 {
6127         DE_UNREF(stage);
6128
6129         const char* const       accessPostfixA  = (m_shaderInterface == SHADER_INPUT_SINGLE_DESCRIPTOR)                                         ? ("")
6130                                                                                 : (m_shaderInterface == SHADER_INPUT_MULTIPLE_CONTIGUOUS_DESCRIPTORS)           ? ("A")
6131                                                                                 : (m_shaderInterface == SHADER_INPUT_DESCRIPTOR_ARRAY)                                          ? ("[0]")
6132                                                                                 : (DE_NULL);
6133         const char* const       accessPostfixB  = (m_shaderInterface == SHADER_INPUT_SINGLE_DESCRIPTOR)                                         ? ("")
6134                                                                                 : (m_shaderInterface == SHADER_INPUT_MULTIPLE_CONTIGUOUS_DESCRIPTORS)           ? ("B")
6135                                                                                 : (m_shaderInterface == SHADER_INPUT_DESCRIPTOR_ARRAY)                                          ? ("[1]")
6136                                                                                 : (DE_NULL);
6137         const char* const       fetchFunc               = (isUniformDescriptorType(m_descriptorType)) ? ("texelFetch") : ("imageLoad");
6138         std::ostringstream      buf;
6139
6140         buf << "        if (quadrant_id == 0)\n"
6141                 << "            result_color = " << fetchFunc << "(u_texelBuffer" << accessPostfixA << ", " << TexelBufferInstanceBuffers::getFetchPos(0) << ");\n"
6142                 << "    else if (quadrant_id == 1)\n"
6143                 << "            result_color = " << fetchFunc << "(u_texelBuffer" << accessPostfixB << ", " << TexelBufferInstanceBuffers::getFetchPos(1) << ");\n"
6144                 << "    else if (quadrant_id == 2)\n"
6145                 << "            result_color = " << fetchFunc << "(u_texelBuffer" << accessPostfixA << ", " << TexelBufferInstanceBuffers::getFetchPos(2) << ");\n"
6146                 << "    else\n"
6147                 << "            result_color = " << fetchFunc << "(u_texelBuffer" << accessPostfixB << ", " << TexelBufferInstanceBuffers::getFetchPos(3) << ");\n";
6148
6149         return buf.str();
6150 }
6151
6152 std::string TexelBufferDescriptorCase::genNoAccessSource (void) const
6153 {
6154         return "        if (quadrant_id == 1 || quadrant_id == 2)\n"
6155                         "               result_color = vec4(0.0, 1.0, 0.0, 1.0);\n"
6156                         "       else\n"
6157                         "               result_color = vec4(1.0, 1.0, 0.0, 1.0);\n";
6158 }
6159
6160 vkt::TestInstance* TexelBufferDescriptorCase::createInstance (vkt::Context& context) const
6161 {
6162         verifyDriverSupport(context.getDeviceFeatures(), m_descriptorType, m_activeStages);
6163
6164         if (m_exitingStages == vk::VK_SHADER_STAGE_COMPUTE_BIT)
6165         {
6166                 DE_ASSERT(m_isPrimaryCmdBuf); // secondaries are only valid within renderpass
6167                 return new TexelBufferComputeInstance(context, m_descriptorType, m_shaderInterface, m_nonzeroViewOffset);
6168         }
6169         else
6170                 return new TexelBufferRenderInstance(context, m_isPrimaryCmdBuf, m_descriptorType, m_activeStages, m_shaderInterface, m_nonzeroViewOffset);
6171 }
6172
6173 void createShaderAccessImageTests (tcu::TestCaseGroup*          group,
6174                                                                    bool                                         isPrimaryCmdBuf,
6175                                                                    vk::VkDescriptorType         descriptorType,
6176                                                                    vk::VkShaderStageFlags       exitingStages,
6177                                                                    vk::VkShaderStageFlags       activeStages,
6178                                                                    ShaderInputInterface         dimension,
6179                                                                    deUint32                                     resourceFlags)
6180 {
6181         static const struct
6182         {
6183                 vk::VkImageViewType     viewType;
6184                 const char*                     name;
6185                 const char*                     description;
6186                 deUint32                        flags;
6187         } s_imageTypes[] =
6188         {
6189                 { vk::VK_IMAGE_VIEW_TYPE_1D,                    "1d",                                           "1D image view",                                                                0u                                                                              },
6190                 { vk::VK_IMAGE_VIEW_TYPE_1D,                    "1d_base_mip",                          "1D image subview with base mip level",                 ImageDescriptorCase::FLAG_BASE_MIP              },
6191                 { vk::VK_IMAGE_VIEW_TYPE_1D,                    "1d_base_slice",                        "1D image subview with base array slice",               ImageDescriptorCase::FLAG_BASE_SLICE    },
6192
6193                 { vk::VK_IMAGE_VIEW_TYPE_1D_ARRAY,              "1d_array",                                     "1D array image view",                                                  0u                                                                              },
6194                 { vk::VK_IMAGE_VIEW_TYPE_1D_ARRAY,              "1d_array_base_mip",            "1D array image subview with base mip level",   ImageDescriptorCase::FLAG_BASE_MIP              },
6195                 { vk::VK_IMAGE_VIEW_TYPE_1D_ARRAY,              "1d_array_base_slice",          "1D array image subview with base array slice", ImageDescriptorCase::FLAG_BASE_SLICE    },
6196
6197                 { vk::VK_IMAGE_VIEW_TYPE_2D,                    "2d",                                           "2D image view",                                                                0u                                                                              },
6198                 { vk::VK_IMAGE_VIEW_TYPE_2D,                    "2d_base_mip",                          "2D image subview with base mip level",                 ImageDescriptorCase::FLAG_BASE_MIP              },
6199                 { vk::VK_IMAGE_VIEW_TYPE_2D,                    "2d_base_slice",                        "2D image subview with base array slice",               ImageDescriptorCase::FLAG_BASE_SLICE    },
6200
6201                 { vk::VK_IMAGE_VIEW_TYPE_2D_ARRAY,              "2d_array",                                     "2D array image view",                                                  0u                                                                              },
6202                 { vk::VK_IMAGE_VIEW_TYPE_2D_ARRAY,              "2d_array_base_mip",            "2D array image subview with base mip level",   ImageDescriptorCase::FLAG_BASE_MIP              },
6203                 { vk::VK_IMAGE_VIEW_TYPE_2D_ARRAY,              "2d_array_base_slice",          "2D array image subview with base array slice", ImageDescriptorCase::FLAG_BASE_SLICE    },
6204
6205                 { vk::VK_IMAGE_VIEW_TYPE_3D,                    "3d",                                           "3D image view",                                                                0u                                                                              },
6206                 { vk::VK_IMAGE_VIEW_TYPE_3D,                    "3d_base_mip",                          "3D image subview with base mip level",                 ImageDescriptorCase::FLAG_BASE_MIP              },
6207                 // no 3d array textures
6208
6209                 { vk::VK_IMAGE_VIEW_TYPE_CUBE,                  "cube",                                         "Cube image view",                                                              0u                                                                              },
6210                 { vk::VK_IMAGE_VIEW_TYPE_CUBE,                  "cube_base_mip",                        "Cube image subview with base mip level",               ImageDescriptorCase::FLAG_BASE_MIP              },
6211                 { vk::VK_IMAGE_VIEW_TYPE_CUBE,                  "cube_base_slice",                      "Cube image subview with base array slice",             ImageDescriptorCase::FLAG_BASE_SLICE    },
6212
6213                 { vk::VK_IMAGE_VIEW_TYPE_CUBE_ARRAY,    "cube_array",                           "Cube image view",                                                              0u                                                                              },
6214                 { vk::VK_IMAGE_VIEW_TYPE_CUBE_ARRAY,    "cube_array_base_mip",          "Cube image subview with base mip level",               ImageDescriptorCase::FLAG_BASE_MIP              },
6215                 { vk::VK_IMAGE_VIEW_TYPE_CUBE_ARRAY,    "cube_array_base_slice",        "Cube image subview with base array slice",             ImageDescriptorCase::FLAG_BASE_SLICE    },
6216         };
6217
6218         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_imageTypes); ++ndx)
6219         {
6220                 // never overlap
6221                 DE_ASSERT((s_imageTypes[ndx].flags & resourceFlags) == 0u);
6222
6223                 // SHADER_INPUT_MULTIPLE_DISCONTIGUOUS_DESCRIPTORS only supported in VK_DESCRIPTOR_TYPE_SAMPLER on graphics shaders for now
6224                 if (dimension == SHADER_INPUT_MULTIPLE_DISCONTIGUOUS_DESCRIPTORS &&
6225                         (descriptorType != vk::VK_DESCRIPTOR_TYPE_SAMPLER || activeStages == vk::VK_SHADER_STAGE_COMPUTE_BIT))
6226                         continue;
6227
6228                 group->addChild(new ImageDescriptorCase(group->getTestContext(),
6229                                                                                                 s_imageTypes[ndx].name,
6230                                                                                                 s_imageTypes[ndx].description,
6231                                                                                                 isPrimaryCmdBuf,
6232                                                                                                 descriptorType,
6233                                                                                                 exitingStages,
6234                                                                                                 activeStages,
6235                                                                                                 dimension,
6236                                                                                                 s_imageTypes[ndx].viewType,
6237                                                                                                 s_imageTypes[ndx].flags | resourceFlags));
6238         }
6239 }
6240
6241 void createShaderAccessTexelBufferTests (tcu::TestCaseGroup*    group,
6242                                                                                  bool                                   isPrimaryCmdBuf,
6243                                                                                  vk::VkDescriptorType   descriptorType,
6244                                                                                  vk::VkShaderStageFlags exitingStages,
6245                                                                                  vk::VkShaderStageFlags activeStages,
6246                                                                                  ShaderInputInterface   dimension,
6247                                                                                  deUint32                               resourceFlags)
6248 {
6249         DE_ASSERT(resourceFlags == 0);
6250         DE_UNREF(resourceFlags);
6251
6252         static const struct
6253         {
6254                 const char*     name;
6255                 const char*     description;
6256                 deUint32        flags;
6257         } s_texelBufferTypes[] =
6258         {
6259                 { "offset_zero",                "View offset is zero",          0u                                                                                      },
6260                 { "offset_nonzero",             "View offset is non-zero",      TexelBufferDescriptorCase::FLAG_VIEW_OFFSET     },
6261         };
6262
6263         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_texelBufferTypes); ++ndx)
6264         {
6265                 if (dimension == SHADER_INPUT_MULTIPLE_DISCONTIGUOUS_DESCRIPTORS)
6266                         continue;
6267
6268                 group->addChild(new TexelBufferDescriptorCase(group->getTestContext(),
6269                                                                                                           s_texelBufferTypes[ndx].name,
6270                                                                                                           s_texelBufferTypes[ndx].description,
6271                                                                                                           isPrimaryCmdBuf,
6272                                                                                                           descriptorType,
6273                                                                                                           exitingStages,
6274                                                                                                           activeStages,
6275                                                                                                           dimension,
6276                                                                                                           s_texelBufferTypes[ndx].flags));
6277         }
6278 }
6279
6280 void createShaderAccessBufferTests (tcu::TestCaseGroup*         group,
6281                                                                         bool                                    isPrimaryCmdBuf,
6282                                                                         vk::VkDescriptorType    descriptorType,
6283                                                                         vk::VkShaderStageFlags  exitingStages,
6284                                                                         vk::VkShaderStageFlags  activeStages,
6285                                                                         ShaderInputInterface    dimension,
6286                                                                         deUint32                                resourceFlags)
6287 {
6288         DE_ASSERT(resourceFlags == 0u);
6289         DE_UNREF(resourceFlags);
6290
6291         static const struct
6292         {
6293                 const char*     name;
6294                 const char*     description;
6295                 bool            isForDynamicCases;
6296                 deUint32        flags;
6297         } s_bufferTypes[] =
6298         {
6299                 { "offset_view_zero",                                           "View offset is zero",                                                                  false,  0u                                                                                                                                                                                      },
6300                 { "offset_view_nonzero",                                        "View offset is non-zero",                                                              false,  BufferDescriptorCase::FLAG_VIEW_OFFSET                                                                                                          },
6301
6302                 { "offset_view_zero_dynamic_zero",                      "View offset is zero, dynamic offset is zero",                  true,   BufferDescriptorCase::FLAG_DYNAMIC_OFFSET_ZERO                                                                                          },
6303                 { "offset_view_zero_dynamic_nonzero",           "View offset is zero, dynamic offset is non-zero",              true,   BufferDescriptorCase::FLAG_DYNAMIC_OFFSET_NONZERO                                                                                       },
6304                 { "offset_view_nonzero_dynamic_zero",           "View offset is non-zero, dynamic offset is zero",              true,   BufferDescriptorCase::FLAG_VIEW_OFFSET | BufferDescriptorCase::FLAG_DYNAMIC_OFFSET_ZERO         },
6305                 { "offset_view_nonzero_dynamic_nonzero",        "View offset is non-zero, dynamic offset is non-zero",  true,   BufferDescriptorCase::FLAG_VIEW_OFFSET | BufferDescriptorCase::FLAG_DYNAMIC_OFFSET_NONZERO      },
6306         };
6307
6308         const bool isDynamicCase = isDynamicDescriptorType(descriptorType);
6309
6310         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_bufferTypes); ++ndx)
6311         {
6312                 if (dimension == SHADER_INPUT_MULTIPLE_DISCONTIGUOUS_DESCRIPTORS)
6313                         continue;
6314
6315                 if (isDynamicCase == s_bufferTypes[ndx].isForDynamicCases)
6316                         group->addChild(new BufferDescriptorCase(group->getTestContext(),
6317                                                                                                          s_bufferTypes[ndx].name,
6318                                                                                                          s_bufferTypes[ndx].description,
6319                                                                                                          isPrimaryCmdBuf,
6320                                                                                                          descriptorType,
6321                                                                                                          exitingStages,
6322                                                                                                          activeStages,
6323                                                                                                          dimension,
6324                                                                                                          s_bufferTypes[ndx].flags));
6325         }
6326 }
6327
6328 } // anonymous
6329
6330 tcu::TestCaseGroup* createShaderAccessTests (tcu::TestContext& testCtx)
6331 {
6332         static const struct
6333         {
6334                 const bool      isPrimary;
6335                 const char*     name;
6336                 const char*     description;
6337         } s_bindTypes[] =
6338         {
6339                 { true,         "primary_cmd_buf",      "Bind in primary command buffer"        },
6340                 { false,        "secondary_cmd_buf",    "Bind in secondary command buffer"      },
6341         };
6342         static const struct
6343         {
6344                 const vk::VkDescriptorType      descriptorType;
6345                 const char*                                     name;
6346                 const char*                                     description;
6347                 deUint32                                        flags;
6348         } s_descriptorTypes[] =
6349         {
6350                 { vk::VK_DESCRIPTOR_TYPE_SAMPLER,                                       "sampler_mutable",                                      "VK_DESCRIPTOR_TYPE_SAMPLER with mutable sampler",                                      0u                                                              },
6351                 { vk::VK_DESCRIPTOR_TYPE_SAMPLER,                                       "sampler_immutable",                            "VK_DESCRIPTOR_TYPE_SAMPLER with immutable sampler",                            RESOURCE_FLAG_IMMUTABLE_SAMPLER },
6352                 { vk::VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,        "combined_image_sampler_mutable",       "VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER with mutable sampler",       0u                                                              },
6353                 { vk::VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,        "combined_image_sampler_immutable",     "VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER with immutable sampler",     RESOURCE_FLAG_IMMUTABLE_SAMPLER },
6354                 // \note No way to access SAMPLED_IMAGE without a sampler
6355                 //{ vk::VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,                               "sampled_image",                                        "VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE",                                                                     0u                                                              },
6356                 { vk::VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,                         "storage_image",                                        "VK_DESCRIPTOR_TYPE_STORAGE_IMAGE",                                                                     0u                                                              },
6357                 { vk::VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER,          "uniform_texel_buffer",                         "VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER",                                                      0u                                                              },
6358                 { vk::VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER,          "storage_texel_buffer",                         "VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER",                                                      0u                                                              },
6359                 { vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,                        "uniform_buffer",                                       "VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER",                                                            0u                                                              },
6360                 { vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,                        "storage_buffer",                                       "VK_DESCRIPTOR_TYPE_STORAGE_BUFFER",                                                            0u                                                              },
6361                 { vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,        "uniform_buffer_dynamic",                       "VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC",                                            0u                                                              },
6362                 { vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC,        "storage_buffer_dynamic",                       "VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC",                                            0u                                                              },
6363         };
6364         static const struct
6365         {
6366                 const char*                             name;
6367                 const char*                             description;
6368                 vk::VkShaderStageFlags  existingStages;                         //!< stages that exists
6369                 vk::VkShaderStageFlags  activeStages;                           //!< stages that access resource
6370                 bool                                    supportsSecondaryCmdBufs;
6371         } s_shaderStages[] =
6372         {
6373                 {
6374                         "no_access",
6375                         "No accessing stages",
6376                         vk::VK_SHADER_STAGE_VERTEX_BIT | vk::VK_SHADER_STAGE_FRAGMENT_BIT,
6377                         0u,
6378                         true,
6379                 },
6380                 {
6381                         "vertex",
6382                         "Vertex stage",
6383                         vk::VK_SHADER_STAGE_VERTEX_BIT | vk::VK_SHADER_STAGE_FRAGMENT_BIT,
6384                         vk::VK_SHADER_STAGE_VERTEX_BIT,
6385                         true,
6386                 },
6387                 {
6388                         "tess_ctrl",
6389                         "Tessellation control stage",
6390                         vk::VK_SHADER_STAGE_VERTEX_BIT | vk::VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT | vk::VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT | vk::VK_SHADER_STAGE_FRAGMENT_BIT,
6391                         vk::VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT,
6392                         true,
6393                 },
6394                 {
6395                         "tess_eval",
6396                         "Tessellation evaluation stage",
6397                         vk::VK_SHADER_STAGE_VERTEX_BIT | vk::VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT | vk::VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT | vk::VK_SHADER_STAGE_FRAGMENT_BIT,
6398                         vk::VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT,
6399                         true,
6400                 },
6401                 {
6402                         "geometry",
6403                         "Geometry stage",
6404                         vk::VK_SHADER_STAGE_VERTEX_BIT | vk::VK_SHADER_STAGE_GEOMETRY_BIT | vk::VK_SHADER_STAGE_FRAGMENT_BIT,
6405                         vk::VK_SHADER_STAGE_GEOMETRY_BIT,
6406                         true,
6407                 },
6408                 {
6409                         "fragment",
6410                         "Fragment stage",
6411                         vk::VK_SHADER_STAGE_VERTEX_BIT | vk::VK_SHADER_STAGE_FRAGMENT_BIT,
6412                         vk::VK_SHADER_STAGE_FRAGMENT_BIT,
6413                         true,
6414                 },
6415                 {
6416                         "compute",
6417                         "Compute stage",
6418                         vk::VK_SHADER_STAGE_COMPUTE_BIT,
6419                         vk::VK_SHADER_STAGE_COMPUTE_BIT,
6420                         false,
6421                 },
6422                 {
6423                         "vertex_fragment",
6424                         "Vertex and fragment stages",
6425                         vk::VK_SHADER_STAGE_VERTEX_BIT | vk::VK_SHADER_STAGE_FRAGMENT_BIT,
6426                         vk::VK_SHADER_STAGE_VERTEX_BIT | vk::VK_SHADER_STAGE_FRAGMENT_BIT,
6427                         true,
6428                 },
6429         };
6430         static const struct
6431         {
6432                 ShaderInputInterface    dimension;
6433                 const char*                             name;
6434                 const char*                             description;
6435         } s_variableDimensions[] =
6436         {
6437                 { SHADER_INPUT_SINGLE_DESCRIPTOR,                                       "single_descriptor",                                    "Single descriptor"             },
6438                 { SHADER_INPUT_MULTIPLE_CONTIGUOUS_DESCRIPTORS,         "multiple_contiguous_descriptors",              "Multiple descriptors"  },
6439                 { SHADER_INPUT_MULTIPLE_DISCONTIGUOUS_DESCRIPTORS,      "multiple_discontiguous_descriptors",   "Multiple descriptors"  },
6440                 { SHADER_INPUT_DESCRIPTOR_ARRAY,                                        "descriptor_array",                                             "Descriptor array"              },
6441         };
6442
6443         de::MovePtr<tcu::TestCaseGroup> group(new tcu::TestCaseGroup(testCtx, "shader_access", "Access resource via descriptor in a single descriptor set"));
6444
6445         // .primary_cmd_buf...
6446         for (int bindTypeNdx = 0; bindTypeNdx < DE_LENGTH_OF_ARRAY(s_bindTypes); ++bindTypeNdx)
6447         {
6448                 de::MovePtr<tcu::TestCaseGroup> bindGroup(new tcu::TestCaseGroup(testCtx, s_bindTypes[bindTypeNdx].name, s_bindTypes[bindTypeNdx].description));
6449
6450                 // .sampler, .combined_image_sampler, other resource types ...
6451                 for (int descriptorNdx = 0; descriptorNdx < DE_LENGTH_OF_ARRAY(s_descriptorTypes); ++descriptorNdx)
6452                 {
6453                         de::MovePtr<tcu::TestCaseGroup> typeGroup(new tcu::TestCaseGroup(testCtx, s_descriptorTypes[descriptorNdx].name, s_descriptorTypes[descriptorNdx].description));
6454
6455                         for (int stageNdx = 0; stageNdx < DE_LENGTH_OF_ARRAY(s_shaderStages); ++stageNdx)
6456                         {
6457                                 if (s_bindTypes[bindTypeNdx].isPrimary || s_shaderStages[stageNdx].supportsSecondaryCmdBufs)
6458                                 {
6459                                         de::MovePtr<tcu::TestCaseGroup> stageGroup(new tcu::TestCaseGroup(testCtx, s_shaderStages[stageNdx].name, s_shaderStages[stageNdx].description));
6460
6461                                         for (int dimensionNdx = 0; dimensionNdx < DE_LENGTH_OF_ARRAY(s_variableDimensions); ++dimensionNdx)
6462                                         {
6463                                                 de::MovePtr<tcu::TestCaseGroup> dimensionGroup(new tcu::TestCaseGroup(testCtx, s_variableDimensions[dimensionNdx].name, s_variableDimensions[dimensionNdx].description));
6464                                                 void                                                    (*createTestsFunc)(tcu::TestCaseGroup*          group,
6465                                                                                                                                                    bool                                         isPrimaryCmdBuf,
6466                                                                                                                                                    vk::VkDescriptorType         descriptorType,
6467                                                                                                                                                    vk::VkShaderStageFlags       existingStages,
6468                                                                                                                                                    vk::VkShaderStageFlags       activeStages,
6469                                                                                                                                                    ShaderInputInterface         dimension,
6470                                                                                                                                                    deUint32                                     resourceFlags);
6471
6472                                                 switch (s_descriptorTypes[descriptorNdx].descriptorType)
6473                                                 {
6474                                                         case vk::VK_DESCRIPTOR_TYPE_SAMPLER:
6475                                                         case vk::VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
6476                                                         case vk::VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
6477                                                                 createTestsFunc = createShaderAccessImageTests;
6478                                                                 break;
6479
6480                                                         case vk::VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
6481                                                         case vk::VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
6482                                                                 createTestsFunc = createShaderAccessTexelBufferTests;
6483                                                                 break;
6484
6485                                                         case vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
6486                                                         case vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
6487                                                         case vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
6488                                                         case vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
6489                                                                 createTestsFunc = createShaderAccessBufferTests;
6490                                                                 break;
6491
6492                                                         default:
6493                                                                 createTestsFunc = DE_NULL;
6494                                                                 DE_FATAL("Impossible");
6495                                                 }
6496
6497                                                 if (createTestsFunc)
6498                                                 {
6499                                                         createTestsFunc(dimensionGroup.get(),
6500                                                                                         s_bindTypes[bindTypeNdx].isPrimary,
6501                                                                                         s_descriptorTypes[descriptorNdx].descriptorType,
6502                                                                                         s_shaderStages[stageNdx].existingStages,
6503                                                                                         s_shaderStages[stageNdx].activeStages,
6504                                                                                         s_variableDimensions[dimensionNdx].dimension,
6505                                                                                         s_descriptorTypes[descriptorNdx].flags);
6506                                                 }
6507                                                 else
6508                                                         DE_FATAL("Impossible");
6509
6510                                                 stageGroup->addChild(dimensionGroup.release());
6511                                         }
6512
6513                                         typeGroup->addChild(stageGroup.release());
6514                                 }
6515                         }
6516
6517                         bindGroup->addChild(typeGroup.release());
6518                 }
6519
6520                 group->addChild(bindGroup.release());
6521         }
6522
6523         return group.release();
6524 }
6525
6526 } // BindingModel
6527 } // vkt