external/vulkancts/modules/vulkan/api/vktApiSmokeTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * Vulkan Conformance Tests
   3  * ------------------------
   4  *
   5  * Copyright (c) 2015 Google Inc.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and/or associated documentation files (the
   9  * "Materials"), to deal in the Materials without restriction, including
  10  * without limitation the rights to use, copy, modify, merge, publish,
  11  * distribute, sublicense, and/or sell copies of the Materials, and to
  12  * permit persons to whom the Materials are furnished to do so, subject to
  13  * the following conditions:
  14  *
  15  * The above copyright notice(s) and this permission notice shall be
  16  * included in all copies or substantial portions of the Materials.
  17  *
  18  * The Materials are Confidential Information as defined by the
  19  * Khronos Membership Agreement until designated non-confidential by
  20  * Khronos, at which point this condition clause shall be removed.
  21  *
  22  * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  23  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  24  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  25  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
  26  * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  27  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  28  * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
  29  *
  30  *//*!
  31  * \file
  32  * \brief Simple Smoke Tests
  33  *//*--------------------------------------------------------------------*/
  34
  35 #include "vktApiTests.hpp"
  36
  37 #include "vktTestCaseUtil.hpp"
  38
  39 #include "vkDefs.hpp"
  40 #include "vkPlatform.hpp"
  41 #include "vkStrUtil.hpp"
  42 #include "vkRef.hpp"
  43 #include "vkRefUtil.hpp"
  44 #include "vkQueryUtil.hpp"
  45 #include "vkMemUtil.hpp"
  46 #include "vkDeviceUtil.hpp"
  47 #include "vkPrograms.hpp"
  48 #include "vkTypeUtil.hpp"
  49
  50 #include "tcuTestLog.hpp"
  51 #include "tcuFormatUtil.hpp"
  52
  53 #include "deUniquePtr.hpp"
  54
  55 namespace vkt
  56 {
  57 namespace api
  58 {
  59
  60 namespace
  61 {
  62
  63 using namespace vk;
  64 using std::vector;
  65 using tcu::TestLog;
  66 using de::UniquePtr;
  67
  68 tcu::TestStatus createSamplerTest (Context& context)
  69 {
  70         const VkDevice                  vkDevice        = context.getDevice();
  71         const DeviceInterface&  vk                      = context.getDeviceInterface();
  72
  73         {
  74                 const struct VkSamplerCreateInfo                samplerInfo     =
  75                 {
  76                         VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,          //      VkStructureType         sType;
  77                         DE_NULL,                                                                        //      const void*                     pNext;
  78                         VK_TEX_FILTER_NEAREST,                                          //      VkTexFilter                     magFilter;
  79                         VK_TEX_FILTER_NEAREST,                                          //      VkTexFilter                     minFilter;
  80                         VK_TEX_MIPMAP_MODE_BASE,                                        //      VkTexMipmapMode         mipMode;
  81                         VK_TEX_ADDRESS_MODE_CLAMP,                                      //      VkTexAddressMode        addressU;
  82                         VK_TEX_ADDRESS_MODE_CLAMP,                                      //      VkTexAddressMode        addressV;
  83                         VK_TEX_ADDRESS_MODE_CLAMP,                                      //      VkTexAddressMode        addressW;
  84                         0.0f,                                                                           //      float                           mipLodBias;
  85                         0.0f,                                                                           //      float                           maxAnisotropy;
  86                         DE_FALSE,                                                                       //      VkBool32                        compareEnable;
  87                         VK_COMPARE_OP_ALWAYS,                                           //      VkCompareOp                     compareOp;
  88                         0.0f,                                                                           //      float                           minLod;
  89                         0.0f,                                                                           //      float                           maxLod;
  90                         VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,        //      VkBorderColor           borderColor;
  91                         VK_FALSE,                                                                       //      VKBool32                        unnormalizedCoords;
  92                 };
  93
  94                 Move<VkSampler>                 tmpSampler      = createSampler(vk, vkDevice, &samplerInfo);
  95                 Move<VkSampler>                 tmp2Sampler;
  96
  97                 tmp2Sampler = tmpSampler;
  98
  99                 const Unique<VkSampler> sampler         (tmp2Sampler);
 100         }
 101
 102         return tcu::TestStatus::pass("Creating sampler succeeded");
 103 }
 104
 105 void createShaderProgs (SourceCollections& dst)
 106 {
 107         dst.glslSources.add("test") << glu::VertexSource(
 108                 "#version 300 es\n"
 109                 "in highp vec4 a_position;\n"
 110                 "void main (void) { gl_Position = a_position; }\n");
 111 }
 112
 113 tcu::TestStatus createShaderModuleTest (Context& context)
 114 {
 115         const VkDevice                                  vkDevice        = context.getDevice();
 116         const DeviceInterface&                  vk                      = context.getDeviceInterface();
 117         const Unique<VkShaderModule>    shader          (createShaderModule(vk, vkDevice, context.getBinaryCollection().get("test"), 0));
 118
 119         return tcu::TestStatus::pass("Creating shader module succeeded");
 120 }
 121
 122 void createTriangleAsmProgs (SourceCollections& dst)
 123 {
 124         dst.spirvAsmSources.add("vert") <<
 125                 "                OpSource ESSL 300\n"
 126                 "                OpCapability Shader\n"
 127                 "%1 =    OpExtInstImport \"GLSL.std.450\"\n"
 128                 "                OpMemoryModel Logical GLSL450\n"
 129                 "                OpEntryPoint Vertex %4 \"main\" %10 %12 %16 %17\n"
 130                 "                OpName %4 \"main\"\n"
 131                 "                OpName %10 \"gl_Position\"\n"
 132                 "                OpName %12 \"a_position\"\n"
 133                 "                OpName %16 \"gl_VertexID\"\n"
 134                 "                OpName %17 \"gl_InstanceID\"\n"
 135                 "                OpDecorate %10 BuiltIn Position\n"
 136                 "                OpDecorate %12 Location 0\n"
 137                 "                OpDecorate %16 BuiltIn VertexId\n"
 138                 "                OpDecorate %17 BuiltIn InstanceId\n"
 139                 "%2 =    OpTypeVoid\n"
 140                 "%3 =    OpTypeFunction %2\n"
 141                 "%7 =    OpTypeFloat 32\n"
 142                 "%8 =    OpTypeVector %7 4\n"
 143                 "%9 =    OpTypePointer Output %8\n"
 144                 "%10 =   OpVariable %9 Output\n"
 145                 "%11 =   OpTypePointer Input %8\n"
 146                 "%12 =   OpVariable %11 Input\n"
 147                 "%14 =   OpTypeInt 32 1\n"
 148                 "%15 =   OpTypePointer Input %14\n"
 149                 "%16 =   OpVariable %15 Input\n"
 150                 "%17 =   OpVariable %15 Input\n"
 151                 "%4 =    OpFunction %2 None %3\n"
 152                 "%5 =    OpLabel\n"
 153                 "%13 =   OpLoad %8 %12\n"
 154                 "                OpStore %10 %13\n"
 155                 "                OpBranch %6\n"
 156                 "%6 =    OpLabel\n"
 157                 "                OpReturn\n"
 158                 "                OpFunctionEnd\n";
 159         dst.spirvAsmSources.add("frag") <<
 160                 "               OpSource ESSL 300\n"
 161                 "               OpCapability Shader\n"
 162                 "%1 =   OpExtInstImport \"GLSL.std.450\"\n"
 163                 "               OpMemoryModel Logical GLSL450\n"
 164                 "               OpEntryPoint Fragment %4 \"main\" %10\n"
 165                 "               OpExecutionMode %4 OriginLowerLeft\n"
 166                 "               OpName %4 \"main\"\n"
 167                 "               OpName %10 \"o_color\"\n"
 168                 "               OpDecorate %10 RelaxedPrecision\n"
 169                 "               OpDecorate %10 Location 0\n"
 170                 "%2 =   OpTypeVoid\n"
 171                 "%3 =   OpTypeFunction %2\n"
 172                 "%7 =   OpTypeFloat 32\n"
 173                 "%8 =   OpTypeVector %7 4\n"
 174                 "%9 =   OpTypePointer Output %8\n"
 175                 "%10 =  OpVariable %9 Output\n"
 176                 "%11 =  OpConstant %7 1065353216\n"
 177                 "%12 =  OpConstant %7 0\n"
 178                 "%13 =  OpConstantComposite %8 %11 %12 %11 %11\n"
 179                 "%4 =   OpFunction %2 None %3\n"
 180                 "%5 =   OpLabel\n"
 181                 "               OpStore %10 %13\n"
 182                 "               OpBranch %6\n"
 183                 "%6 =   OpLabel\n"
 184                 "               OpReturn\n"
 185                 "               OpFunctionEnd\n";
 186 }
 187
 188 void createTriangleProgs (SourceCollections& dst)
 189 {
 190         dst.glslSources.add("vert") << glu::VertexSource(
 191                 "#version 300 es\n"
 192                 "layout(location = 0) in highp vec4 a_position;\n"
 193                 "void main (void) { gl_Position = a_position; }\n");
 194         dst.glslSources.add("frag") << glu::FragmentSource(
 195                 "#version 300 es\n"
 196                 "layout(location = 0) out lowp vec4 o_color;\n"
 197                 "void main (void) { o_color = vec4(1.0, 0.0, 1.0, 1.0); }\n");
 198 }
 199
 200 tcu::TestStatus renderTriangleTest (Context& context)
 201 {
 202         const VkDevice                                                  vkDevice                                = context.getDevice();
 203         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
 204         const VkQueue                                                   queue                                   = context.getUniversalQueue();
 205         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
 206         SimpleAllocator                                                 memAlloc                                (vk, vkDevice, getPhysicalDeviceMemoryProperties(context.getInstanceInterface(), context.getPhysicalDevice()));
 207         const tcu::IVec2                                                renderSize                              (256, 256);
 208
 209         const tcu::Vec4                                                 vertices[]                              =
 210         {
 211                 tcu::Vec4(-0.5f, -0.5f, 0.0f, 1.0f),
 212                 tcu::Vec4(+0.5f, -0.5f, 0.0f, 1.0f),
 213                 tcu::Vec4( 0.0f, +0.5f, 0.0f, 1.0f)
 214         };
 215
 216         const VkBufferCreateInfo                                vertexBufferParams              =
 217         {
 218                 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,   //      VkStructureType         sType;
 219                 DE_NULL,                                                                //      const void*                     pNext;
 220                 (VkDeviceSize)sizeof(vertices),                 //      VkDeviceSize            size;
 221                 VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,              //      VkBufferUsageFlags      usage;
 222                 0u,                                                                             //      VkBufferCreateFlags     flags;
 223                 VK_SHARING_MODE_EXCLUSIVE,                              //      VkSharingMode           sharingMode;
 224                 1u,                                                                             //      deUint32                        queueFamilyCount;
 225                 &queueFamilyIndex,                                              //      const deUint32*         pQueueFamilyIndices;
 226         };
 227         const Unique<VkBuffer>                                  vertexBuffer                    (createBuffer(vk, vkDevice, &vertexBufferParams));
 228         const UniquePtr<Allocation>                             vertexBufferMemory              (memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *vertexBuffer), MemoryRequirement::HostVisible));
 229
 230         VK_CHECK(vk.bindBufferMemory(vkDevice, *vertexBuffer, vertexBufferMemory->getMemory(), vertexBufferMemory->getOffset()));
 231
 232         const VkDeviceSize                                              imageSizeBytes                  = (VkDeviceSize)(sizeof(deUint32)*renderSize.x()*renderSize.y());
 233         const VkBufferCreateInfo                                readImageBufferParams   =
 234         {
 235                 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,           //      VkStructureType         sType;
 236                 DE_NULL,                                                                        //      const void*                     pNext;
 237                 imageSizeBytes,                                                         //      VkDeviceSize            size;
 238                 VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT,       //      VkBufferUsageFlags      usage;
 239                 0u,                                                                                     //      VkBufferCreateFlags     flags;
 240                 VK_SHARING_MODE_EXCLUSIVE,                                      //      VkSharingMode           sharingMode;
 241                 1u,                                                                                     //      deUint32                        queueFamilyCount;
 242                 &queueFamilyIndex,                                                      //      const deUint32*         pQueueFamilyIndices;
 243         };
 244         const Unique<VkBuffer>                                  readImageBuffer                 (createBuffer(vk, vkDevice, &readImageBufferParams));
 245         const UniquePtr<Allocation>                             readImageBufferMemory   (memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *readImageBuffer), MemoryRequirement::HostVisible));
 246
 247         VK_CHECK(vk.bindBufferMemory(vkDevice, *readImageBuffer, readImageBufferMemory->getMemory(), readImageBufferMemory->getOffset()));
 248
 249         const VkImageCreateInfo                                 imageParams                             =
 250         {
 251                 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,                                                                    //      VkStructureType         sType;
 252                 DE_NULL,                                                                                                                                //      const void*                     pNext;
 253                 VK_IMAGE_TYPE_2D,                                                                                                               //      VkImageType                     imageType;
 254                 VK_FORMAT_R8G8B8A8_UNORM,                                                                                               //      VkFormat                        format;
 255                 { renderSize.x(), renderSize.y(), 1 },                                                                  //      VkExtent3D                      extent;
 256                 1u,                                                                                                                                             //      deUint32                        mipLevels;
 257                 1u,                                                                                                                                             //      deUint32                        arraySize;
 258                 1u,                                                                                                                                             //      deUint32                        samples;
 259                 VK_IMAGE_TILING_OPTIMAL,                                                                                                //      VkImageTiling           tiling;
 260                 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT|VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT, //      VkImageUsageFlags       usage;
 261                 0u,                                                                                                                                             //      VkImageCreateFlags      flags;
 262                 VK_SHARING_MODE_EXCLUSIVE,                                                                                              //      VkSharingMode           sharingMode;
 263                 1u,                                                                                                                                             //      deUint32                        queueFamilyCount;
 264                 &queueFamilyIndex,                                                                                                              //      const deUint32*         pQueueFamilyIndices;
 265                 VK_IMAGE_LAYOUT_UNDEFINED,                                                                                              //      VkImageLayout           initialLayout;
 266         };
 267
 268         const Unique<VkImage>                                   image                                   (createImage(vk, vkDevice, &imageParams));
 269         const UniquePtr<Allocation>                             imageMemory                             (memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *image), MemoryRequirement::Any));
 270
 271         VK_CHECK(vk.bindImageMemory(vkDevice, *image, imageMemory->getMemory(), imageMemory->getOffset()));
 272
 273         const VkAttachmentDescription                   colorAttDesc                    =
 274         {
 275                 VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION,               //      VkStructureType                                 sType;
 276                 DE_NULL,                                                                                //      const void*                                             pNext;
 277                 VK_FORMAT_R8G8B8A8_UNORM,                                               //      VkFormat                                                format;
 278                 1u,                                                                                             //      deUint32                                                samples;
 279                 VK_ATTACHMENT_LOAD_OP_CLEAR,                                    //      VkAttachmentLoadOp                              loadOp;
 280                 VK_ATTACHMENT_STORE_OP_STORE,                                   //      VkAttachmentStoreOp                             storeOp;
 281                 VK_ATTACHMENT_LOAD_OP_DONT_CARE,                                //      VkAttachmentLoadOp                              stencilLoadOp;
 282                 VK_ATTACHMENT_STORE_OP_DONT_CARE,                               //      VkAttachmentStoreOp                             stencilStoreOp;
 283                 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,               //      VkImageLayout                                   initialLayout;
 284                 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,               //      VkImageLayout                                   finalLayout;
 285                 0u,                                                                                             //      VkAttachmentDescriptionFlags    flags;
 286         };
 287         const VkAttachmentReference                             colorAttRef                             =
 288         {
 289                 0u,                                                                                             //      deUint32                attachment;
 290                 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,               //      VkImageLayout   layout;
 291         };
 292         const VkSubpassDescription                              subpassDesc                             =
 293         {
 294                 VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION,                  //      VkStructureType                                 sType;
 295                 DE_NULL,                                                                                //      const void*                                             pNext;
 296                 VK_PIPELINE_BIND_POINT_GRAPHICS,                                //      VkPipelineBindPoint                             pipelineBindPoint;
 297                 0u,                                                                                             //      VkSubpassDescriptionFlags               flags;
 298                 0u,                                                                                             //      deUint32                                                inputCount;
 299                 DE_NULL,                                                                                //      const VkAttachmentReference*    pInputAttachments;
 300                 1u,                                                                                             //      deUint32                                                colorCount;
 301                 &colorAttRef,                                                                   //      const VkAttachmentReference*    pColorAttachments;
 302                 DE_NULL,                                                                                //      const VkAttachmentReference*    pResolveAttachments;
 303                 { VK_NO_ATTACHMENT, VK_IMAGE_LAYOUT_GENERAL },  //      VkAttachmentReference                   depthStencilAttachment;
 304                 0u,                                                                                             //      deUint32                                                preserveCount;
 305                 DE_NULL,                                                                                //      const VkAttachmentReference*    pPreserveAttachments;
 306
 307         };
 308         const VkRenderPassCreateInfo                    renderPassParams                =
 309         {
 310                 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,              //      VkStructureType                                 sType;
 311                 DE_NULL,                                                                                //      const void*                                             pNext;
 312                 1u,                                                                                             //      deUint32                                                attachmentCount;
 313                 &colorAttDesc,                                                                  //      const VkAttachmentDescription*  pAttachments;
 314                 1u,                                                                                             //      deUint32                                                subpassCount;
 315                 &subpassDesc,                                                                   //      const VkSubpassDescription*             pSubpasses;
 316                 0u,                                                                                             //      deUint32                                                dependencyCount;
 317                 DE_NULL,                                                                                //      const VkSubpassDependency*              pDependencies;
 318         };
 319         const Unique<VkRenderPass>                              renderPass                              (createRenderPass(vk, vkDevice, &renderPassParams));
 320
 321         const VkImageViewCreateInfo                             colorAttViewParams              =
 322         {
 323                 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,               //      VkStructureType                         sType;
 324                 DE_NULL,                                                                                //      const void*                                     pNext;
 325                 *image,                                                                                 //      VkImage                                         image;
 326                 VK_IMAGE_VIEW_TYPE_2D,                                                  //      VkImageViewType                         viewType;
 327                 VK_FORMAT_R8G8B8A8_UNORM,                                               //      VkFormat                                        format;
 328                 {
 329                         VK_CHANNEL_SWIZZLE_R,
 330                         VK_CHANNEL_SWIZZLE_G,
 331                         VK_CHANNEL_SWIZZLE_B,
 332                         VK_CHANNEL_SWIZZLE_A
 333                 },                                                                                              //      VkChannelMapping                        channels;
 334                 {
 335                         VK_IMAGE_ASPECT_COLOR_BIT,                                              //      VkImageAspectFlags      aspectMask;
 336                         0u,                                                                                             //      deUint32                        baseMipLevel;
 337                         1u,                                                                                             //      deUint32                        mipLevels;
 338                         0u,                                                                                             //      deUint32                        baseArrayLayer;
 339                         1u,                                                                                             //      deUint32                        arraySize;
 340                 },                                                                                              //      VkImageSubresourceRange         subresourceRange;
 341                 0u,                                                                                             //      VkImageViewCreateFlags          flags;
 342         };
 343         const Unique<VkImageView>                               colorAttView                    (createImageView(vk, vkDevice, &colorAttViewParams));
 344
 345         const Unique<VkShaderModule>                    vertShaderModule                (createShaderModule(vk, vkDevice, context.getBinaryCollection().get("vert"), 0));
 346         const VkShaderCreateInfo                                vertShaderParams                =
 347         {
 348                 VK_STRUCTURE_TYPE_SHADER_CREATE_INFO,                   //      VkStructureType         sType;
 349                 DE_NULL,                                                                                //      const void*                     pNext;
 350                 *vertShaderModule,                                                              //      VkShaderModule          module;
 351                 "main",                                                                                 //      const char*                     pName;
 352                 0u,                                                                                             //      VkShaderCreateFlags     flags;
 353                 VK_SHADER_STAGE_VERTEX,                                                 //      VkShaderStage           stage;
 354         };
 355         const Unique<VkShader>                                  vertShader                              (createShader(vk, vkDevice, &vertShaderParams));
 356         const Unique<VkShaderModule>                    fragShaderModule                (createShaderModule(vk, vkDevice, context.getBinaryCollection().get("frag"), 0));
 357         const VkShaderCreateInfo                                fragShaderParams                =
 358         {
 359                 VK_STRUCTURE_TYPE_SHADER_CREATE_INFO,                   //      VkStructureType         sType;
 360                 DE_NULL,                                                                                //      const void*                     pNext;
 361                 *fragShaderModule,                                                              //      VkShaderModule          module;
 362                 "main",                                                                                 //      const char*                     pName;
 363                 0u,                                                                                             //      VkShaderCreateFlags     flags;
 364                 VK_SHADER_STAGE_FRAGMENT,                                               //      VkShaderStage           stage;
 365         };
 366         const Unique<VkShader>                                  fragShader                              (createShader(vk, vkDevice, &fragShaderParams));
 367
 368         // Pipeline layout
 369         const VkPipelineLayoutCreateInfo                pipelineLayoutParams    =
 370         {
 371                 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,                  //      VkStructureType                                 sType;
 372                 DE_NULL,                                                                                                //      const void*                                             pNext;
 373                 0u,                                                                                                             //      deUint32                                                descriptorSetCount;
 374                 DE_NULL,                                                                                                //      const VkDescriptorSetLayout*    pSetLayouts;
 375                 0u,                                                                                                             //      deUint32                                                pushConstantRangeCount;
 376                 DE_NULL,                                                                                                //      const VkPushConstantRange*              pPushConstantRanges;
 377         };
 378         const Unique<VkPipelineLayout>                  pipelineLayout                  (createPipelineLayout(vk, vkDevice, &pipelineLayoutParams));
 379
 380         // Pipeline
 381         const VkSpecializationInfo                              emptyShaderSpecParams   =
 382         {
 383                 0u,                                                                                                             //      deUint32                                                mapEntryCount;
 384                 DE_NULL,                                                                                                //      const VkSpecializationMapEntry* pMap;
 385                 0,                                                                                                              //      const deUintptr                                 dataSize;
 386                 DE_NULL,                                                                                                //      const void*                                             pData;
 387         };
 388         const VkPipelineShaderStageCreateInfo   shaderStageParams[]     =
 389         {
 390                 {
 391                         VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,    //      VkStructureType                         sType;
 392                         DE_NULL,                                                                                                //      const void*                                     pNext;
 393                         VK_SHADER_STAGE_VERTEX,                                                                 //      VkShaderStage                           stage;
 394                         *vertShader,                                                                                    //      VkShader                                        shader;
 395                         &emptyShaderSpecParams,                                                                 //      const VkSpecializationInfo*     pSpecializationInfo;
 396                 },
 397                 {
 398                         VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,    //      VkStructureType                         sType;
 399                         DE_NULL,                                                                                                //      const void*                                     pNext;
 400                         VK_SHADER_STAGE_FRAGMENT,                                                               //      VkShaderStage                           stage;
 401                         *fragShader,                                                                                    //      VkShader                                        shader;
 402                         &emptyShaderSpecParams,                                                                 //      const VkSpecializationInfo*     pSpecializationInfo;
 403                 }
 404         };
 405         const VkPipelineDepthStencilStateCreateInfo     depthStencilParams              =
 406         {
 407                 VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,     //      VkStructureType         sType;
 408                 DE_NULL,                                                                                                        //      const void*                     pNext;
 409                 DE_FALSE,                                                                                                       //      deUint32                        depthTestEnable;
 410                 DE_FALSE,                                                                                                       //      deUint32                        depthWriteEnable;
 411                 VK_COMPARE_OP_ALWAYS,                                                                           //      VkCompareOp                     depthCompareOp;
 412                 DE_FALSE,                                                                                                       //      deUint32                        depthBoundsTestEnable;
 413                 DE_FALSE,                                                                                                       //      deUint32                        stencilTestEnable;
 414                 {
 415                         VK_STENCIL_OP_KEEP,                                                                                     //      VkStencilOp     stencilFailOp;
 416                         VK_STENCIL_OP_KEEP,                                                                                     //      VkStencilOp     stencilPassOp;
 417                         VK_STENCIL_OP_KEEP,                                                                                     //      VkStencilOp     stencilDepthFailOp;
 418                         VK_COMPARE_OP_ALWAYS,                                                                           //      VkCompareOp     stencilCompareOp;
 419                         0u,                                                                                                                     //      deUint32        stencilCompareMask;
 420                         0u,                                                                                                                     //      deUint32        stencilWriteMask;
 421                         0u,                                                                                                                     //      deUint32        stencilReference;
 422                 },                                                                                                                      //      VkStencilOpState        front;
 423                 {
 424                         VK_STENCIL_OP_KEEP,                                                                                     //      VkStencilOp     stencilFailOp;
 425                         VK_STENCIL_OP_KEEP,                                                                                     //      VkStencilOp     stencilPassOp;
 426                         VK_STENCIL_OP_KEEP,                                                                                     //      VkStencilOp     stencilDepthFailOp;
 427                         VK_COMPARE_OP_ALWAYS,                                                                           //      VkCompareOp     stencilCompareOp;
 428                         0u,                                                                                                                     //      deUint32        stencilCompareMask;
 429                         0u,                                                                                                                     //      deUint32        stencilWriteMask;
 430                         0u,                                                                                                                     //      deUint32        stencilReference;
 431                 },                                                                                                                      //      VkStencilOpState        back;
 432                 -1.0f,                                                                                                          //      float                           minDepthBounds;
 433                 +1.0f,                                                                                                          //      float                           maxDepthBounds;
 434         };
 435         const VkViewport                                                viewport0                               =
 436         {
 437                 0.0f,                                                                                                           //      float   originX;
 438                 0.0f,                                                                                                           //      float   originY;
 439                 (float)renderSize.x(),                                                                          //      float   width;
 440                 (float)renderSize.y(),                                                                          //      float   height;
 441                 0.0f,                                                                                                           //      float   minDepth;
 442                 1.0f,                                                                                                           //      float   maxDepth;
 443         };
 444         const VkRect2D                                                  scissor0                                =
 445         {
 446                 {
 447                         0u,                                                                                                                     //      deInt32 x;
 448                         0u,                                                                                                                     //      deInt32 y;
 449                 },                                                                                                                      //      VkOffset2D      offset;
 450                 {
 451                         renderSize.x(),                                                                                         //      deInt32 width;
 452                         renderSize.y(),                                                                                         //      deInt32 height;
 453                 },                                                                                                                      //      VkExtent2D      extent;
 454         };
 455         const VkPipelineViewportStateCreateInfo         viewportParams                  =
 456         {
 457                 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,          //      VkStructureType         sType;
 458                 DE_NULL,                                                                                                        //      const void*                     pNext;
 459                 1u,                                                                                                                     //      deUint32                        viewportCount;
 460                 &viewport0,
 461                 1u,
 462                 &scissor0
 463         };
 464         const VkSampleMask                                                      sampleMask                              = ~0u;
 465         const VkPipelineMultisampleStateCreateInfo      multisampleParams               =
 466         {
 467                 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,       //      VkStructureType sType;
 468                 DE_NULL,                                                                                                        //      const void*             pNext;
 469                 1u,                                                                                                                     //      deUint32                rasterSamples;
 470                 DE_FALSE,                                                                                                       //      deUint32                sampleShadingEnable;
 471                 0.0f,                                                                                                           //      float                   minSampleShading;
 472                 &sampleMask,                                                                                            //      VkSampleMask    sampleMask;
 473         };
 474         const VkPipelineRasterStateCreateInfo           rasterParams                    =
 475         {
 476                 VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO,    //      VkStructureType sType;
 477                 DE_NULL,                                                                                                //      const void*             pNext;
 478                 DE_TRUE,                                                                                                //      deUint32                depthClipEnable;
 479                 DE_FALSE,                                                                                               //      deUint32                rasterizerDiscardEnable;
 480                 VK_FILL_MODE_SOLID,                                                                             //      VkFillMode              fillMode;
 481                 VK_CULL_MODE_NONE,                                                                              //      VkCullMode              cullMode;
 482                 VK_FRONT_FACE_CCW,                                                                              //      VkFrontFace             frontFace;
 483                 VK_FALSE,                                                                                               //      VkBool32                depthBiasEnable;
 484                 0.0f,                                                                                                   //      float                   depthBias;
 485                 0.0f,                                                                                                   //      float                   depthBiasClamp;
 486                 0.0f,                                                                                                   //      float                   slopeScaledDepthBias;
 487                 1.0f,                                                                                                   //      float                   lineWidth;
 488         };
 489         const VkPipelineInputAssemblyStateCreateInfo    inputAssemblyParams     =
 490         {
 491                 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,    //      VkStructureType         sType;
 492                 DE_NULL,                                                                                                                //      const void*                     pNext;
 493                 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,                                                    //      VkPrimitiveTopology     topology;
 494                 DE_FALSE,                                                                                                               //      deUint32                        primitiveRestartEnable;
 495         };
 496         const VkVertexInputBindingDescription           vertexBinding0                  =
 497         {
 498                 0u,                                                                                                             //      deUint32                                binding;
 499                 (deUint32)sizeof(tcu::Vec4),                                                    //      deUint32                                strideInBytes;
 500                 VK_VERTEX_INPUT_STEP_RATE_VERTEX,                                               //      VkVertexInputStepRate   stepRate;
 501         };
 502         const VkVertexInputAttributeDescription         vertexAttrib0                   =
 503         {
 504                 0u,                                                                                                             //      deUint32        location;
 505                 0u,                                                                                                             //      deUint32        binding;
 506                 VK_FORMAT_R32G32B32A32_SFLOAT,                                                  //      VkFormat        format;
 507                 0u,                                                                                                             //      deUint32        offsetInBytes;
 508         };
 509         const VkPipelineVertexInputStateCreateInfo      vertexInputStateParams  =
 510         {
 511                 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,      //      VkStructureType                                                         sType;
 512                 DE_NULL,                                                                                                        //      const void*                                                                     pNext;
 513                 1u,                                                                                                                     //      deUint32                                                                        bindingCount;
 514                 &vertexBinding0,                                                                                        //      const VkVertexInputBindingDescription*          pVertexBindingDescriptions;
 515                 1u,                                                                                                                     //      deUint32                                                                        attributeCount;
 516                 &vertexAttrib0,                                                                                         //      const VkVertexInputAttributeDescription*        pVertexAttributeDescriptions;
 517         };
 518         const VkPipelineColorBlendAttachmentState       attBlendParams                  =
 519         {
 520                 DE_FALSE,                                                                                                                               //      deUint32                blendEnable;
 521                 VK_BLEND_ONE,                                                                                                                   //      VkBlend                 srcBlendColor;
 522                 VK_BLEND_ZERO,                                                                                                                  //      VkBlend                 destBlendColor;
 523                 VK_BLEND_OP_ADD,                                                                                                                //      VkBlendOp               blendOpColor;
 524                 VK_BLEND_ONE,                                                                                                                   //      VkBlend                 srcBlendAlpha;
 525                 VK_BLEND_ZERO,                                                                                                                  //      VkBlend                 destBlendAlpha;
 526                 VK_BLEND_OP_ADD,                                                                                                                //      VkBlendOp               blendOpAlpha;
 527                 VK_CHANNEL_R_BIT|VK_CHANNEL_G_BIT|VK_CHANNEL_B_BIT|VK_CHANNEL_A_BIT,    //      VkChannelFlags  channelWriteMask;
 528         };
 529         const VkPipelineColorBlendStateCreateInfo       blendParams                             =
 530         {
 531                 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,       //      VkStructureType                                                         sType;
 532                 DE_NULL,                                                                                                        //      const void*                                                                     pNext;
 533                 DE_FALSE,                                                                                                       //      VkBool32                                                                        alphaToCoverageEnable;
 534                 DE_FALSE,                                                                                                       //      VkBool32                                                                        alphaToOneEnable;
 535                 DE_FALSE,                                                                                                       //      VkBool32                                                                        logicOpEnable;
 536                 VK_LOGIC_OP_COPY,                                                                                       //      VkLogicOp                                                                       logicOp;
 537                 1u,                                                                                                                     //      deUint32                                                                        attachmentCount;
 538                 &attBlendParams,                                                                                        //      const VkPipelineColorBlendAttachmentState*      pAttachments;
 539                 { 0.0f, 0.0f, 0.0f, 0.0f },                                                                     //      float                                                                           blendConst[4];
 540         };
 541         const VkPipelineDynamicStateCreateInfo  dynamicStateInfo                =
 542         {
 543                 VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO,   //      VkStructureType                 sType;
 544                 DE_NULL,                                                                                                //      const void*                             pNext;
 545                 0u,                                                                                                             //      deUint32                                dynamicStateCount;
 546                 DE_NULL                                                                                                 //      const VkDynamicState*   pDynamicStates;
 547         };
 548         const VkGraphicsPipelineCreateInfo              pipelineParams                  =
 549         {
 550                 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,                //      VkStructureType                                                                 sType;
 551                 DE_NULL,                                                                                                //      const void*                                                                             pNext;
 552                 (deUint32)DE_LENGTH_OF_ARRAY(shaderStageParams),                //      deUint32                                                                                stageCount;
 553                 shaderStageParams,                                                                              //      const VkPipelineShaderStageCreateInfo*                  pStages;
 554                 &vertexInputStateParams,                                                                //      const VkPipelineVertexInputStateCreateInfo*             pVertexInputState;
 555                 &inputAssemblyParams,                                                                   //      const VkPipelineInputAssemblyStateCreateInfo*   pInputAssemblyState;
 556                 DE_NULL,                                                                                                //      const VkPipelineTessellationStateCreateInfo*    pTessellationState;
 557                 &viewportParams,                                                                                //      const VkPipelineViewportStateCreateInfo*                pViewportState;
 558                 &rasterParams,                                                                                  //      const VkPipelineRasterStateCreateInfo*                  pRasterState;
 559                 &multisampleParams,                                                                             //      const VkPipelineMultisampleStateCreateInfo*             pMultisampleState;
 560                 &depthStencilParams,                                                                    //      const VkPipelineDepthStencilStateCreateInfo*    pDepthStencilState;
 561                 &blendParams,                                                                                   //      const VkPipelineColorBlendStateCreateInfo*              pColorBlendState;
 562                 &dynamicStateInfo,                                                                              //      const VkPipelineDynamicStateCreateInfo*                 pDynamicState;
 563                 0u,                                                                                                             //      VkPipelineCreateFlags                                                   flags;
 564                 *pipelineLayout,                                                                                //      VkPipelineLayout                                                                layout;
 565                 *renderPass,                                                                                    //      VkRenderPass                                                                    renderPass;
 566                 0u,                                                                                                             //      deUint32                                                                                subpass;
 567                 DE_NULL,                                                                                                //      VkPipeline                                                                              basePipelineHandle;
 568                 0u,                                                                                                             //      deInt32                                                                                 basePipelineIndex;
 569         };
 570
 571         const Unique<VkPipeline>                                pipeline                                (createGraphicsPipeline(vk, vkDevice, DE_NULL, &pipelineParams));
 572
 573         // Framebuffer
 574         const VkFramebufferCreateInfo                   framebufferParams               =
 575         {
 576                 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,                              //      VkStructureType         sType;
 577                 DE_NULL,                                                                                                //      const void*                     pNext;
 578                 *renderPass,                                                                                    //      VkRenderPass            renderPass;
 579                 1u,                                                                                                             //      deUint32                        attachmentCount;
 580                 &*colorAttView,                                                                                 //      const VkImageView*      pAttachments;
 581                 (deUint32)renderSize.x(),                                                               //      deUint32                        width;
 582                 (deUint32)renderSize.y(),                                                               //      deUint32                        height;
 583                 1u,                                                                                                             //      deUint32                        layers;
 584         };
 585         const Unique<VkFramebuffer>                             framebuffer                             (createFramebuffer(vk, vkDevice, &framebufferParams));
 586
 587         const VkCmdPoolCreateInfo                               cmdPoolParams                   =
 588         {
 589                 VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO,                                         //      VkStructureType                 sType;
 590                 DE_NULL,                                                                                                        //      const void*                             pNext;
 591                 queueFamilyIndex,                                                                                       //      deUint32                                queueFamilyIndex;
 592                 VK_CMD_POOL_CREATE_RESET_COMMAND_BUFFER_BIT                                     //      VkCmdPoolCreateFlags    flags;
 593         };
 594         const Unique<VkCmdPool>                                 cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
 595
 596         // Command buffer
 597         const VkCmdBufferCreateInfo                             cmdBufParams                    =
 598         {
 599                 VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO,                               //      VkStructureType                 sType;
 600                 DE_NULL,                                                                                                //      const void*                             pNext;
 601                 *cmdPool,                                                                                               //      VkCmdPool                               pool;
 602                 VK_CMD_BUFFER_LEVEL_PRIMARY,                                                    //      VkCmdBufferLevel                level;
 603                 0u,                                                                                                             //      VkCmdBufferCreateFlags  flags;
 604         };
 605         const Unique<VkCmdBuffer>                               cmdBuf                                  (createCommandBuffer(vk, vkDevice, &cmdBufParams));
 606
 607         const VkCmdBufferBeginInfo                              cmdBufBeginParams               =
 608         {
 609                 VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO,                                //      VkStructureType                         sType;
 610                 DE_NULL,                                                                                                //      const void*                                     pNext;
 611                 0u,                                                                                                             //      VkCmdBufferOptimizeFlags        flags;
 612                 DE_NULL,                                                                                                //      VkRenderPass                            renderPass;
 613                 0u,                                                                                                             //      deUint32                                        subpass;
 614                 DE_NULL,                                                                                                //      VkFramebuffer                           framebuffer;
 615         };
 616
 617         // Record commands
 618         VK_CHECK(vk.beginCommandBuffer(*cmdBuf, &cmdBufBeginParams));
 619
 620         {
 621                 const VkMemoryBarrier           vertFlushBarrier        =
 622                 {
 623                         VK_STRUCTURE_TYPE_MEMORY_BARRIER,                       //      VkStructureType         sType;
 624                         DE_NULL,                                                                        //      const void*                     pNext;
 625                         VK_MEMORY_OUTPUT_HOST_WRITE_BIT,                        //      VkMemoryOutputFlags     outputMask;
 626                         VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT,     //      VkMemoryInputFlags      inputMask;
 627                 };
 628                 const VkImageMemoryBarrier      colorAttBarrier         =
 629                 {
 630                         VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,         //      VkStructureType                 sType;
 631                         DE_NULL,                                                                        //      const void*                             pNext;
 632                         0u,                                                                                     //      VkMemoryOutputFlags             outputMask;
 633                         VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT,           //      VkMemoryInputFlags              inputMask;
 634                         VK_IMAGE_LAYOUT_UNDEFINED,                                      //      VkImageLayout                   oldLayout;
 635                         VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,       //      VkImageLayout                   newLayout;
 636                         queueFamilyIndex,                                                       //      deUint32                                srcQueueFamilyIndex;
 637                         queueFamilyIndex,                                                       //      deUint32                                destQueueFamilyIndex;
 638                         *image,                                                                         //      VkImage                                 image;
 639                         {
 640                                 VK_IMAGE_ASPECT_COLOR_BIT,                                      //      VkImageAspect   aspect;
 641                                 0u,                                                                                     //      deUint32                baseMipLevel;
 642                                 1u,                                                                                     //      deUint32                mipLevels;
 643                                 0u,                                                                                     //      deUint32                baseArraySlice;
 644                                 1u,                                                                                     //      deUint32                arraySize;
 645                         }                                                                                       //      VkImageSubresourceRange subresourceRange;
 646                 };
 647                 const void*                             barriers[]                              = { &vertFlushBarrier, &colorAttBarrier };
 648                 vk.cmdPipelineBarrier(*cmdBuf, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_ALL_GPU_COMMANDS, DE_FALSE, (deUint32)DE_LENGTH_OF_ARRAY(barriers), barriers);
 649         }
 650
 651         {
 652                 const VkClearValue                      clearValue              = makeClearValueColorF32(0.125f, 0.25f, 0.75f, 1.0f);
 653                 const VkRenderPassBeginInfo     passBeginParams =
 654                 {
 655                         VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,                       //      VkStructureType         sType;
 656                         DE_NULL,                                                                                        //      const void*                     pNext;
 657                         *renderPass,                                                                            //      VkRenderPass            renderPass;
 658                         *framebuffer,                                                                           //      VkFramebuffer           framebuffer;
 659                         { { 0, 0 }, { renderSize.x(), renderSize.y() } },       //      VkRect2D                        renderArea;
 660                         1u,                                                                                                     //      deUint32                        clearValueCount;
 661                         &clearValue,                                                                            //      const VkClearValue*     pClearValues;
 662                 };
 663                 vk.cmdBeginRenderPass(*cmdBuf, &passBeginParams, VK_RENDER_PASS_CONTENTS_INLINE);
 664         }
 665
 666         vk.cmdBindPipeline(*cmdBuf, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
 667         {
 668                 const VkDeviceSize bindingOffset = 0;
 669                 vk.cmdBindVertexBuffers(*cmdBuf, 0u, 1u, &vertexBuffer.get(), &bindingOffset);
 670         }
 671         vk.cmdDraw(*cmdBuf, 3u, 1u, 0u, 0u);
 672         vk.cmdEndRenderPass(*cmdBuf);
 673
 674         {
 675                 const VkImageMemoryBarrier      renderFinishBarrier     =
 676                 {
 677                         VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,         //      VkStructureType                 sType;
 678                         DE_NULL,                                                                        //      const void*                             pNext;
 679                         VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT,          //      VkMemoryOutputFlags             outputMask;
 680                         VK_MEMORY_INPUT_TRANSFER_BIT,                           //      VkMemoryInputFlags              inputMask;
 681                         VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,       //      VkImageLayout                   oldLayout;
 682                         VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL,        //      VkImageLayout                   newLayout;
 683                         queueFamilyIndex,                                                       //      deUint32                                srcQueueFamilyIndex;
 684                         queueFamilyIndex,                                                       //      deUint32                                destQueueFamilyIndex;
 685                         *image,                                                                         //      VkImage                                 image;
 686                         {
 687                                 VK_IMAGE_ASPECT_COLOR_BIT,                                      //      VkImageAspectFlags      aspectMask;
 688                                 0u,                                                                                     //      deUint32                        baseMipLevel;
 689                                 1u,                                                                                     //      deUint32                        mipLevels;
 690                                 0u,                                                                                     //      deUint32                        baseArraySlice;
 691                                 1u,                                                                                     //      deUint32                        arraySize;
 692                         }                                                                                       //      VkImageSubresourceRange subresourceRange;
 693                 };
 694                 const void*                             barriers[]                              = { &renderFinishBarrier };
 695                 vk.cmdPipelineBarrier(*cmdBuf, VK_PIPELINE_STAGE_ALL_GRAPHICS, VK_PIPELINE_STAGE_TRANSFER_BIT, DE_FALSE, (deUint32)DE_LENGTH_OF_ARRAY(barriers), barriers);
 696         }
 697
 698         {
 699                 const VkBufferImageCopy copyParams      =
 700                 {
 701                         (VkDeviceSize)0u,                                               //      VkDeviceSize                    bufferOffset;
 702                         (deUint32)renderSize.x(),                               //      deUint32                                bufferRowLength;
 703                         (deUint32)renderSize.y(),                               //      deUint32                                bufferImageHeight;
 704                         {
 705                                 VK_IMAGE_ASPECT_COLOR,                                  //      VkImageAspect           aspect;
 706                                 0u,                                                                             //      deUint32                        mipLevel;
 707                                 0u,                                                                             //      deUint32                        arrayLayer;
 708                                 1u,                                                                             //      deUint32                        arraySize;
 709                         },                                                                              //      VkImageSubresourceCopy  imageSubresource;
 710                         { 0u, 0u, 0u },                                                 //      VkOffset3D                              imageOffset;
 711                         { renderSize.x(), renderSize.y(), 1u }  //      VkExtent3D                              imageExtent;
 712                 };
 713                 vk.cmdCopyImageToBuffer(*cmdBuf, *image, VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL, *readImageBuffer, 1u, &copyParams);
 714         }
 715
 716         {
 717                 const VkBufferMemoryBarrier     copyFinishBarrier       =
 718                 {
 719                         VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,        //      VkStructureType         sType;
 720                         DE_NULL,                                                                        //      const void*                     pNext;
 721                         VK_MEMORY_OUTPUT_TRANSFER_BIT,                          //      VkMemoryOutputFlags     outputMask;
 722                         VK_MEMORY_INPUT_HOST_READ_BIT,                          //      VkMemoryInputFlags      inputMask;
 723                         queueFamilyIndex,                                                       //      deUint32                        srcQueueFamilyIndex;
 724                         queueFamilyIndex,                                                       //      deUint32                        destQueueFamilyIndex;
 725                         *readImageBuffer,                                                       //      VkBuffer                        buffer;
 726                         0u,                                                                                     //      VkDeviceSize            offset;
 727                         imageSizeBytes                                                          //      VkDeviceSize            size;
 728                 };
 729                 const void*                             barriers[]                              = { &copyFinishBarrier };
 730                 vk.cmdPipelineBarrier(*cmdBuf, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, DE_FALSE, (deUint32)DE_LENGTH_OF_ARRAY(barriers), barriers);
 731         }
 732
 733         VK_CHECK(vk.endCommandBuffer(*cmdBuf));
 734
 735         // Upload vertex data
 736         {
 737                 const VkMappedMemoryRange       range                   =
 738                 {
 739                         VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,  //      VkStructureType sType;
 740                         DE_NULL,                                                                //      const void*             pNext;
 741                         vertexBufferMemory->getMemory(),                //      VkDeviceMemory  mem;
 742                         0,                                                                              //      VkDeviceSize    offset;
 743                         (VkDeviceSize)sizeof(vertices),                 //      VkDeviceSize    size;
 744                 };
 745                 void*                                           vertexBufPtr    = vertexBufferMemory->getHostPtr();
 746
 747                 deMemcpy(vertexBufPtr, &vertices[0], sizeof(vertices));
 748                 VK_CHECK(vk.flushMappedMemoryRanges(vkDevice, 1u, &range));
 749         }
 750
 751         // Submit & wait for completion
 752         {
 753                 const VkFenceCreateInfo fenceParams     =
 754                 {
 755                         VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,    //      VkStructureType         sType;
 756                         DE_NULL,                                                                //      const void*                     pNext;
 757                         0u,                                                                             //      VkFenceCreateFlags      flags;
 758                 };
 759                 const Unique<VkFence>   fence           (createFence(vk, vkDevice, &fenceParams));
 760
 761                 VK_CHECK(vk.queueSubmit(queue, 1u, &cmdBuf.get(), *fence));
 762                 VK_CHECK(vk.waitForFences(vkDevice, 1u, &fence.get(), DE_TRUE, ~0ull));
 763         }
 764
 765         // Log image
 766         {
 767                 const VkMappedMemoryRange       range           =
 768                 {
 769                         VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,  //      VkStructureType sType;
 770                         DE_NULL,                                                                //      const void*             pNext;
 771                         readImageBufferMemory->getMemory(),             //      VkDeviceMemory  mem;
 772                         0,                                                                              //      VkDeviceSize    offset;
 773                         imageSizeBytes,                                                 //      VkDeviceSize    size;
 774                 };
 775                 void*                                           imagePtr        = readImageBufferMemory->getHostPtr();
 776
 777                 VK_CHECK(vk.invalidateMappedMemoryRanges(vkDevice, 1u, &range));
 778                 context.getTestContext().getLog() << TestLog::Image("Result", "Result", tcu::ConstPixelBufferAccess(tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8), renderSize.x(), renderSize.y(), 1, imagePtr));
 779         }
 780
 781         return tcu::TestStatus::pass("Rendering succeeded");
 782 }
 783
 784 } // anonymous
 785
 786 tcu::TestCaseGroup* createSmokeTests (tcu::TestContext& testCtx)
 787 {
 788         de::MovePtr<tcu::TestCaseGroup> smokeTests      (new tcu::TestCaseGroup(testCtx, "smoke", "Smoke Tests"));
 789
 790         addFunctionCase                         (smokeTests.get(), "create_sampler",    "",     createSamplerTest);
 791         addFunctionCaseWithPrograms     (smokeTests.get(), "create_shader",             "", createShaderProgs,          createShaderModuleTest);
 792         addFunctionCaseWithPrograms     (smokeTests.get(), "triangle",                  "", createTriangleProgs,        renderTriangleTest);
 793         addFunctionCaseWithPrograms     (smokeTests.get(), "asm_triangle",              "", createTriangleAsmProgs,     renderTriangleTest);
 794
 795         return smokeTests.release();
 796 }
 797
 798 } // api
 799 } // vkt