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