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

   1 /*-------------------------------------------------------------------------
   2  * Vulkan Conformance Tests
   3  * ------------------------
   4  *
   5  * Copyright (c) 2015 Google Inc.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief Simple Smoke Tests
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "vktApiTests.hpp"
  25
  26 #include "vktTestCaseUtil.hpp"
  27
  28 #include "vkDefs.hpp"
  29 #include "vkPlatform.hpp"
  30 #include "vkStrUtil.hpp"
  31 #include "vkRef.hpp"
  32 #include "vkRefUtil.hpp"
  33 #include "vkQueryUtil.hpp"
  34 #include "vkMemUtil.hpp"
  35 #include "vkDeviceUtil.hpp"
  36 #include "vkPrograms.hpp"
  37 #include "vkTypeUtil.hpp"
  38 #include "vkImageUtil.hpp"
  39
  40 #include "tcuTestLog.hpp"
  41 #include "tcuFormatUtil.hpp"
  42 #include "tcuTextureUtil.hpp"
  43 #include "tcuImageCompare.hpp"
  44
  45 #include "rrRenderer.hpp"
  46
  47 #include "deUniquePtr.hpp"
  48
  49 namespace vkt
  50 {
  51 namespace api
  52 {
  53
  54 namespace
  55 {
  56
  57 using namespace vk;
  58 using std::vector;
  59 using tcu::TestLog;
  60 using de::UniquePtr;
  61
  62 tcu::TestStatus createSamplerTest (Context& context)
  63 {
  64         const VkDevice                  vkDevice        = context.getDevice();
  65         const DeviceInterface&  vk                      = context.getDeviceInterface();
  66
  67         {
  68                 const struct VkSamplerCreateInfo                samplerInfo     =
  69                 {
  70                         VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,          // sType
  71                         DE_NULL,                                                                        // pNext
  72                         0u,                                                                                     // flags
  73                         VK_FILTER_NEAREST,                                                      // magFilter
  74                         VK_FILTER_NEAREST,                                                      // minFilter
  75                         VK_SAMPLER_MIPMAP_MODE_NEAREST,                         // mipmapMode
  76                         VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,          // addressModeU
  77                         VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,          // addressModeV
  78                         VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,          // addressModeW
  79                         0.0f,                                                                           // mipLodBias
  80                         VK_FALSE,                                                                       // anisotropyEnable
  81                         1.0f,                                                                           // maxAnisotropy
  82                         DE_FALSE,                                                                       // compareEnable
  83                         VK_COMPARE_OP_ALWAYS,                                           // compareOp
  84                         0.0f,                                                                           // minLod
  85                         0.0f,                                                                           // maxLod
  86                         VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,        // borderColor
  87                         VK_FALSE,                                                                       // unnormalizedCoords
  88                 };
  89
  90                 Move<VkSampler>                 tmpSampler      = createSampler(vk, vkDevice, &samplerInfo);
  91                 Move<VkSampler>                 tmp2Sampler;
  92
  93                 tmp2Sampler = tmpSampler;
  94
  95                 const Unique<VkSampler> sampler         (tmp2Sampler);
  96         }
  97
  98         return tcu::TestStatus::pass("Creating sampler succeeded");
  99 }
 100
 101 void createShaderProgs (SourceCollections& dst)
 102 {
 103         dst.glslSources.add("test") << glu::VertexSource(
 104                 "#version 310 es\n"
 105                 "in highp vec4 a_position;\n"
 106                 "void main (void) { gl_Position = a_position; }\n");
 107 }
 108
 109 tcu::TestStatus createShaderModuleTest (Context& context)
 110 {
 111         const VkDevice                                  vkDevice        = context.getDevice();
 112         const DeviceInterface&                  vk                      = context.getDeviceInterface();
 113         const Unique<VkShaderModule>    shader          (createShaderModule(vk, vkDevice, context.getBinaryCollection().get("test"), 0));
 114
 115         return tcu::TestStatus::pass("Creating shader module succeeded");
 116 }
 117
 118 void createTriangleAsmProgs (SourceCollections& dst)
 119 {
 120         dst.spirvAsmSources.add("vert") <<
 121                 "                OpCapability Shader\n"
 122                 "%1 =    OpExtInstImport \"GLSL.std.450\"\n"
 123                 "                OpMemoryModel Logical GLSL450\n"
 124                 "                OpEntryPoint Vertex %4 \"main\" %10 %12 %16 %17\n"
 125                 "                OpSource ESSL 300\n"
 126                 "                OpName %4 \"main\"\n"
 127                 "                OpName %10 \"gl_Position\"\n"
 128                 "                OpName %12 \"a_position\"\n"
 129                 "                OpName %16 \"gl_VertexIndex\"\n"
 130                 "                OpName %17 \"gl_InstanceIndex\"\n"
 131                 "                OpDecorate %10 BuiltIn Position\n"
 132                 "                OpDecorate %12 Location 0\n"
 133                 "                OpDecorate %16 BuiltIn VertexIndex\n"
 134                 "                OpDecorate %17 BuiltIn InstanceIndex\n"
 135                 "%2 =    OpTypeVoid\n"
 136                 "%3 =    OpTypeFunction %2\n"
 137                 "%7 =    OpTypeFloat 32\n"
 138                 "%8 =    OpTypeVector %7 4\n"
 139                 "%9 =    OpTypePointer Output %8\n"
 140                 "%10 =   OpVariable %9 Output\n"
 141                 "%11 =   OpTypePointer Input %8\n"
 142                 "%12 =   OpVariable %11 Input\n"
 143                 "%14 =   OpTypeInt 32 1\n"
 144                 "%15 =   OpTypePointer Input %14\n"
 145                 "%16 =   OpVariable %15 Input\n"
 146                 "%17 =   OpVariable %15 Input\n"
 147                 "%4 =    OpFunction %2 None %3\n"
 148                 "%5 =    OpLabel\n"
 149                 "%13 =   OpLoad %8 %12\n"
 150                 "                OpStore %10 %13\n"
 151                 "                OpBranch %6\n"
 152                 "%6 =    OpLabel\n"
 153                 "                OpReturn\n"
 154                 "                OpFunctionEnd\n";
 155         dst.spirvAsmSources.add("frag") <<
 156                 "               OpCapability Shader\n"
 157                 "%1 =   OpExtInstImport \"GLSL.std.450\"\n"
 158                 "               OpMemoryModel Logical GLSL450\n"
 159                 "               OpEntryPoint Fragment %4 \"main\" %10\n"
 160                 "               OpExecutionMode %4 OriginLowerLeft\n"
 161                 "               OpSource ESSL 300\n"
 162                 "               OpName %4 \"main\"\n"
 163                 "               OpName %10 \"o_color\"\n"
 164                 "               OpDecorate %10 RelaxedPrecision\n"
 165                 "               OpDecorate %10 Location 0\n"
 166                 "%2 =   OpTypeVoid\n"
 167                 "%3 =   OpTypeFunction %2\n"
 168                 "%7 =   OpTypeFloat 32\n"
 169                 "%8 =   OpTypeVector %7 4\n"
 170                 "%9 =   OpTypePointer Output %8\n"
 171                 "%10 =  OpVariable %9 Output\n"
 172                 "%11 =  OpConstant %7 1065353216\n"
 173                 "%12 =  OpConstant %7 0\n"
 174                 "%13 =  OpConstantComposite %8 %11 %12 %11 %11\n"
 175                 "%4 =   OpFunction %2 None %3\n"
 176                 "%5 =   OpLabel\n"
 177                 "               OpStore %10 %13\n"
 178                 "               OpBranch %6\n"
 179                 "%6 =   OpLabel\n"
 180                 "               OpReturn\n"
 181                 "               OpFunctionEnd\n";
 182 }
 183
 184 void createTriangleProgs (SourceCollections& dst)
 185 {
 186         dst.glslSources.add("vert") << glu::VertexSource(
 187                 "#version 310 es\n"
 188                 "layout(location = 0) in highp vec4 a_position;\n"
 189                 "void main (void) { gl_Position = a_position; }\n");
 190         dst.glslSources.add("frag") << glu::FragmentSource(
 191                 "#version 310 es\n"
 192                 "layout(location = 0) out lowp vec4 o_color;\n"
 193                 "void main (void) { o_color = vec4(1.0, 0.0, 1.0, 1.0); }\n");
 194 }
 195
 196 class RefVertexShader : public rr::VertexShader
 197 {
 198 public:
 199         RefVertexShader (void)
 200                 : rr::VertexShader(1, 0)
 201         {
 202                 m_inputs[0].type = rr::GENERICVECTYPE_FLOAT;
 203         }
 204
 205         void shadeVertices (const rr::VertexAttrib* inputs, rr::VertexPacket* const* packets, const int numPackets) const
 206         {
 207                 for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
 208                 {
 209                         packets[packetNdx]->position = rr::readVertexAttribFloat(inputs[0],
 210                                                                                                                                          packets[packetNdx]->instanceNdx,
 211                                                                                                                                          packets[packetNdx]->vertexNdx);
 212                 }
 213         }
 214 };
 215
 216 class RefFragmentShader : public rr::FragmentShader
 217 {
 218 public:
 219         RefFragmentShader (void)
 220                 : rr::FragmentShader(0, 1)
 221         {
 222                 m_outputs[0].type = rr::GENERICVECTYPE_FLOAT;
 223         }
 224
 225         void shadeFragments (rr::FragmentPacket*, const int numPackets, const rr::FragmentShadingContext& context) const
 226         {
 227                 for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
 228                 {
 229                         for (int fragNdx = 0; fragNdx < rr::NUM_FRAGMENTS_PER_PACKET; ++fragNdx)
 230                         {
 231                                 rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, tcu::Vec4(1.0f, 0.0f, 1.0f, 1.0f));
 232                         }
 233                 }
 234         }
 235 };
 236
 237 void renderReferenceTriangle (const tcu::PixelBufferAccess& dst, const tcu::Vec4 (&vertices)[3])
 238 {
 239         const RefVertexShader                                   vertShader;
 240         const RefFragmentShader                                 fragShader;
 241         const rr::Program                                               program                 (&vertShader, &fragShader);
 242         const rr::MultisamplePixelBufferAccess  colorBuffer             = rr::MultisamplePixelBufferAccess::fromSinglesampleAccess(dst);
 243         const rr::RenderTarget                                  renderTarget    (colorBuffer);
 244         const rr::RenderState                                   renderState             ((rr::ViewportState(colorBuffer)));
 245         const rr::Renderer                                              renderer;
 246         const rr::VertexAttrib                                  vertexAttribs[] =
 247         {
 248                 rr::VertexAttrib(rr::VERTEXATTRIBTYPE_FLOAT, 4, sizeof(tcu::Vec4), 0, vertices[0].getPtr())
 249         };
 250
 251         renderer.draw(rr::DrawCommand(renderState,
 252                                                                   renderTarget,
 253                                                                   program,
 254                                                                   DE_LENGTH_OF_ARRAY(vertexAttribs),
 255                                                                   &vertexAttribs[0],
 256                                                                   rr::PrimitiveList(rr::PRIMITIVETYPE_TRIANGLES, DE_LENGTH_OF_ARRAY(vertices), 0)));
 257 }
 258
 259 tcu::TestStatus renderTriangleTest (Context& context)
 260 {
 261         const VkDevice                                                  vkDevice                                = context.getDevice();
 262         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
 263         const VkQueue                                                   queue                                   = context.getUniversalQueue();
 264         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
 265         SimpleAllocator                                                 memAlloc                                (vk, vkDevice, getPhysicalDeviceMemoryProperties(context.getInstanceInterface(), context.getPhysicalDevice()));
 266         const tcu::IVec2                                                renderSize                              (256, 256);
 267         const VkFormat                                                  colorFormat                             = VK_FORMAT_R8G8B8A8_UNORM;
 268         const tcu::Vec4                                                 clearColor                              (0.125f, 0.25f, 0.75f, 1.0f);
 269
 270         const tcu::Vec4                                                 vertices[]                              =
 271         {
 272                 tcu::Vec4(-0.5f, -0.5f, 0.0f, 1.0f),
 273                 tcu::Vec4(+0.5f, -0.5f, 0.0f, 1.0f),
 274                 tcu::Vec4( 0.0f, +0.5f, 0.0f, 1.0f)
 275         };
 276
 277         const VkBufferCreateInfo                                vertexBufferParams              =
 278         {
 279                 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,   // sType
 280                 DE_NULL,                                                                // pNext
 281                 0u,                                                                             // flags
 282                 (VkDeviceSize)sizeof(vertices),                 // size
 283                 VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,              // usage
 284                 VK_SHARING_MODE_EXCLUSIVE,                              // sharingMode
 285                 1u,                                                                             // queueFamilyIndexCount
 286                 &queueFamilyIndex,                                              // pQueueFamilyIndices
 287         };
 288         const Unique<VkBuffer>                                  vertexBuffer                    (createBuffer(vk, vkDevice, &vertexBufferParams));
 289         const UniquePtr<Allocation>                             vertexBufferMemory              (memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *vertexBuffer), MemoryRequirement::HostVisible));
 290
 291         VK_CHECK(vk.bindBufferMemory(vkDevice, *vertexBuffer, vertexBufferMemory->getMemory(), vertexBufferMemory->getOffset()));
 292
 293         const VkDeviceSize                                              imageSizeBytes                  = (VkDeviceSize)(sizeof(deUint32)*renderSize.x()*renderSize.y());
 294         const VkBufferCreateInfo                                readImageBufferParams   =
 295         {
 296                 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,           // sType
 297                 DE_NULL,                                                                        // pNext
 298                 (VkBufferCreateFlags)0u,                                        // flags
 299                 imageSizeBytes,                                                         // size
 300                 VK_BUFFER_USAGE_TRANSFER_DST_BIT,                       // usage
 301                 VK_SHARING_MODE_EXCLUSIVE,                                      // sharingMode
 302                 1u,                                                                                     // queueFamilyIndexCount
 303                 &queueFamilyIndex,                                                      // pQueueFamilyIndices
 304         };
 305         const Unique<VkBuffer>                                  readImageBuffer                 (createBuffer(vk, vkDevice, &readImageBufferParams));
 306         const UniquePtr<Allocation>                             readImageBufferMemory   (memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *readImageBuffer), MemoryRequirement::HostVisible));
 307
 308         VK_CHECK(vk.bindBufferMemory(vkDevice, *readImageBuffer, readImageBufferMemory->getMemory(), readImageBufferMemory->getOffset()));
 309
 310         const VkImageCreateInfo                                 imageParams                             =
 311         {
 312                 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,                                                                    // sType
 313                 DE_NULL,                                                                                                                                // pNext
 314                 0u,                                                                                                                                             // flags
 315                 VK_IMAGE_TYPE_2D,                                                                                                               // imageType
 316                 VK_FORMAT_R8G8B8A8_UNORM,                                                                                               // format
 317                 { (deUint32)renderSize.x(), (deUint32)renderSize.y(), 1 },                              // extent
 318                 1u,                                                                                                                                             // mipLevels
 319                 1u,                                                                                                                                             // arraySize
 320                 VK_SAMPLE_COUNT_1_BIT,                                                                                                  // samples
 321                 VK_IMAGE_TILING_OPTIMAL,                                                                                                // tiling
 322                 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT|VK_IMAGE_USAGE_TRANSFER_SRC_BIT,    // usage
 323                 VK_SHARING_MODE_EXCLUSIVE,                                                                                              // sharingMode
 324                 1u,                                                                                                                                             // queueFamilyIndexCount
 325                 &queueFamilyIndex,                                                                                                              // pQueueFamilyIndices
 326                 VK_IMAGE_LAYOUT_UNDEFINED,                                                                                              // initialLayout
 327         };
 328
 329         const Unique<VkImage>                                   image                                   (createImage(vk, vkDevice, &imageParams));
 330         const UniquePtr<Allocation>                             imageMemory                             (memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *image), MemoryRequirement::Any));
 331
 332         VK_CHECK(vk.bindImageMemory(vkDevice, *image, imageMemory->getMemory(), imageMemory->getOffset()));
 333
 334         const VkAttachmentDescription                   colorAttDesc                    =
 335         {
 336                 0u,                                                                                             // flags
 337                 VK_FORMAT_R8G8B8A8_UNORM,                                               // format
 338                 VK_SAMPLE_COUNT_1_BIT,                                                  // samples
 339                 VK_ATTACHMENT_LOAD_OP_CLEAR,                                    // loadOp
 340                 VK_ATTACHMENT_STORE_OP_STORE,                                   // storeOp
 341                 VK_ATTACHMENT_LOAD_OP_DONT_CARE,                                // stencilLoadOp
 342                 VK_ATTACHMENT_STORE_OP_DONT_CARE,                               // stencilStoreOp
 343                 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,               // initialLayout
 344                 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,               // finalLayout
 345         };
 346         const VkAttachmentReference                             colorAttRef                             =
 347         {
 348                 0u,                                                                                             // attachment
 349                 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,               // layout
 350         };
 351         const VkSubpassDescription                              subpassDesc                             =
 352         {
 353                 (VkSubpassDescriptionFlags)0u,                                  // flags
 354                 VK_PIPELINE_BIND_POINT_GRAPHICS,                                // pipelineBindPoint
 355                 0u,                                                                                             // inputAttachmentCount
 356                 DE_NULL,                                                                                // pInputAttachments
 357                 1u,                                                                                             // colorAttachmentCount
 358                 &colorAttRef,                                                                   // pColorAttachments
 359                 DE_NULL,                                                                                // pResolveAttachments
 360                 DE_NULL,                                                                                // depthStencilAttachment
 361                 0u,                                                                                             // preserveAttachmentCount
 362                 DE_NULL,                                                                                // pPreserveAttachments
 363         };
 364         const VkRenderPassCreateInfo                    renderPassParams                =
 365         {
 366                 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,              // sType
 367                 DE_NULL,                                                                                // pNext
 368                 0u,                                                                                             // flags
 369                 1u,                                                                                             // attachmentCount
 370                 &colorAttDesc,                                                                  // pAttachments
 371                 1u,                                                                                             // subpassCount
 372                 &subpassDesc,                                                                   // pSubpasses
 373                 0u,                                                                                             // dependencyCount
 374                 DE_NULL,                                                                                // pDependencies
 375         };
 376         const Unique<VkRenderPass>                              renderPass                              (createRenderPass(vk, vkDevice, &renderPassParams));
 377
 378         const VkImageViewCreateInfo                             colorAttViewParams              =
 379         {
 380                 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,               // sType
 381                 DE_NULL,                                                                                // pNext
 382                 0u,                                                                                             // flags
 383                 *image,                                                                                 // image
 384                 VK_IMAGE_VIEW_TYPE_2D,                                                  // viewType
 385                 VK_FORMAT_R8G8B8A8_UNORM,                                               // format
 386                 {
 387                         VK_COMPONENT_SWIZZLE_R,
 388                         VK_COMPONENT_SWIZZLE_G,
 389                         VK_COMPONENT_SWIZZLE_B,
 390                         VK_COMPONENT_SWIZZLE_A
 391                 },                                                                                              // components
 392                 {
 393                         VK_IMAGE_ASPECT_COLOR_BIT,                                              // aspectMask
 394                         0u,                                                                                             // baseMipLevel
 395                         1u,                                                                                             // levelCount
 396                         0u,                                                                                             // baseArrayLayer
 397                         1u,                                                                                             // layerCount
 398                 },                                                                                              // subresourceRange
 399         };
 400         const Unique<VkImageView>                               colorAttView                    (createImageView(vk, vkDevice, &colorAttViewParams));
 401
 402         // Pipeline layout
 403         const VkPipelineLayoutCreateInfo                pipelineLayoutParams    =
 404         {
 405                 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,                  // sType
 406                 DE_NULL,                                                                                                // pNext
 407                 (vk::VkPipelineLayoutCreateFlags)0,
 408                 0u,                                                                                                             // setLayoutCount
 409                 DE_NULL,                                                                                                // pSetLayouts
 410                 0u,                                                                                                             // pushConstantRangeCount
 411                 DE_NULL,                                                                                                // pPushConstantRanges
 412         };
 413         const Unique<VkPipelineLayout>                  pipelineLayout                  (createPipelineLayout(vk, vkDevice, &pipelineLayoutParams));
 414
 415         // Shaders
 416         const Unique<VkShaderModule>                    vertShaderModule                (createShaderModule(vk, vkDevice, context.getBinaryCollection().get("vert"), 0));
 417         const Unique<VkShaderModule>                    fragShaderModule                (createShaderModule(vk, vkDevice, context.getBinaryCollection().get("frag"), 0));
 418
 419         // Pipeline
 420         const VkSpecializationInfo                              emptyShaderSpecParams   =
 421         {
 422                 0u,                                                                                                             // mapEntryCount
 423                 DE_NULL,                                                                                                // pMap
 424                 0,                                                                                                              // dataSize
 425                 DE_NULL,                                                                                                // pData
 426         };
 427         const VkPipelineShaderStageCreateInfo   shaderStageParams[]     =
 428         {
 429                 {
 430                         VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,    // sType
 431                         DE_NULL,                                                                                                // pNext
 432                         0u,                                                                                                             // flags
 433                         VK_SHADER_STAGE_VERTEX_BIT,                                                             // stage
 434                         *vertShaderModule,                                                                              // module
 435                         "main",                                                                                                 // pName
 436                         &emptyShaderSpecParams,                                                                 // pSpecializationInfo
 437                 },
 438                 {
 439                         VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,    // sType
 440                         DE_NULL,                                                                                                // pNext
 441                         0u,                                                                                                             // flags
 442                         VK_SHADER_STAGE_FRAGMENT_BIT,                                                   // stage
 443                         *fragShaderModule,                                                                              // module
 444                         "main",                                                                                                 // pName
 445                         &emptyShaderSpecParams,                                                                 // pSpecializationInfo
 446                 }
 447         };
 448         const VkPipelineDepthStencilStateCreateInfo     depthStencilParams              =
 449         {
 450                 VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,     // sType
 451                 DE_NULL,                                                                                                        // pNext
 452                 0u,                                                                                                                     // flags
 453                 DE_FALSE,                                                                                                       // depthTestEnable
 454                 DE_FALSE,                                                                                                       // depthWriteEnable
 455                 VK_COMPARE_OP_ALWAYS,                                                                           // depthCompareOp
 456                 DE_FALSE,                                                                                                       // depthBoundsTestEnable
 457                 DE_FALSE,                                                                                                       // stencilTestEnable
 458                 {
 459                         VK_STENCIL_OP_KEEP,                                                                                     // failOp
 460                         VK_STENCIL_OP_KEEP,                                                                                     // passOp
 461                         VK_STENCIL_OP_KEEP,                                                                                     // depthFailOp
 462                         VK_COMPARE_OP_ALWAYS,                                                                           // compareOp
 463                         0u,                                                                                                                     // compareMask
 464                         0u,                                                                                                                     // writeMask
 465                         0u,                                                                                                                     // reference
 466                 },                                                                                                                      // front
 467                 {
 468                         VK_STENCIL_OP_KEEP,                                                                                     // failOp
 469                         VK_STENCIL_OP_KEEP,                                                                                     // passOp
 470                         VK_STENCIL_OP_KEEP,                                                                                     // depthFailOp
 471                         VK_COMPARE_OP_ALWAYS,                                                                           // compareOp
 472                         0u,                                                                                                                     // compareMask
 473                         0u,                                                                                                                     // writeMask
 474                         0u,                                                                                                                     // reference
 475                 },                                                                                                                      // back;
 476                 -1.0f,                                                                                                          //      float                           minDepthBounds;
 477                 +1.0f,                                                                                                          //      float                           maxDepthBounds;
 478         };
 479         const VkViewport                                                viewport0                               =
 480         {
 481                 0.0f,                                                                                                           // x
 482                 0.0f,                                                                                                           // y
 483                 (float)renderSize.x(),                                                                          // width
 484                 (float)renderSize.y(),                                                                          // height
 485                 0.0f,                                                                                                           // minDepth
 486                 1.0f,                                                                                                           // maxDepth
 487         };
 488         const VkRect2D                                                  scissor0                                =
 489         {
 490                 {
 491                         0u,                                                                                                                     // x
 492                         0u,                                                                                                                     // y
 493                 },                                                                                                                      // offset
 494                 {
 495                         (deUint32)renderSize.x(),                                                                       // width
 496                         (deUint32)renderSize.y(),                                                                       // height
 497                 },                                                                                                                      // extent;
 498         };
 499         const VkPipelineViewportStateCreateInfo         viewportParams                  =
 500         {
 501                 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,          // sType
 502                 DE_NULL,                                                                                                        // pNext
 503                 0u,                                                                                                                     // flags
 504                 1u,                                                                                                                     // viewportCount
 505                 &viewport0,                                                                                                     // pViewports
 506                 1u,                                                                                                                     // scissorCount
 507                 &scissor0                                                                                                       // pScissors
 508         };
 509         const VkSampleMask                                                      sampleMask                              = ~0u;
 510         const VkPipelineMultisampleStateCreateInfo      multisampleParams               =
 511         {
 512                 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,       // sType
 513                 DE_NULL,                                                                                                        // pNext
 514                 0u,                                                                                                                     // flags
 515                 VK_SAMPLE_COUNT_1_BIT,                                                                          // rasterizationSamples
 516                 VK_FALSE,                                                                                                       // sampleShadingEnable
 517                 0.0f,                                                                                                           // minSampleShading
 518                 &sampleMask,                                                                                            // sampleMask
 519                 VK_FALSE,                                                                                                       // alphaToCoverageEnable
 520                 VK_FALSE,                                                                                                       // alphaToOneEnable
 521         };
 522         const VkPipelineRasterizationStateCreateInfo    rasterParams            =
 523         {
 524                 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,     // sType
 525                 DE_NULL,                                                                                                        // pNext
 526                 0u,                                                                                                                     // flags
 527                 VK_TRUE,                                                                                                        // depthClampEnable
 528                 VK_FALSE,                                                                                                       // rasterizerDiscardEnable
 529                 VK_POLYGON_MODE_FILL,                                                                           // polygonMode
 530                 VK_CULL_MODE_NONE,                                                                                      // cullMode
 531                 VK_FRONT_FACE_COUNTER_CLOCKWISE,                                                        // frontFace
 532                 VK_FALSE,                                                                                                       // depthBiasEnable
 533                 0.0f,                                                                                                           // depthBiasConstantFactor
 534                 0.0f,                                                                                                           // depthBiasClamp
 535                 0.0f,                                                                                                           // depthBiasSlopeFactor
 536                 1.0f,                                                                                                           // lineWidth
 537         };
 538         const VkPipelineInputAssemblyStateCreateInfo    inputAssemblyParams     =
 539         {
 540                 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,    // sType
 541                 DE_NULL,                                                                                                                // pNext
 542                 0u,                                                                                                                             // flags
 543                 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,                                                    // topology
 544                 DE_FALSE,                                                                                                               // primitiveRestartEnable
 545         };
 546         const VkVertexInputBindingDescription           vertexBinding0                  =
 547         {
 548                 0u,                                                                                                             // binding
 549                 (deUint32)sizeof(tcu::Vec4),                                                    // stride
 550                 VK_VERTEX_INPUT_RATE_VERTEX,                                                    // inputRate
 551         };
 552         const VkVertexInputAttributeDescription         vertexAttrib0                   =
 553         {
 554                 0u,                                                                                                             // location
 555                 0u,                                                                                                             // binding
 556                 VK_FORMAT_R32G32B32A32_SFLOAT,                                                  // format
 557                 0u,                                                                                                             // offset
 558         };
 559         const VkPipelineVertexInputStateCreateInfo      vertexInputStateParams  =
 560         {
 561                 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,      // sType
 562                 DE_NULL,                                                                                                        // pNext
 563                 0u,                                                                                                                     // flags
 564                 1u,                                                                                                                     // vertexBindingDescriptionCount
 565                 &vertexBinding0,                                                                                        // pVertexBindingDescriptions
 566                 1u,                                                                                                                     // vertexAttributeDescriptionCount
 567                 &vertexAttrib0,                                                                                         // pVertexAttributeDescriptions
 568         };
 569         const VkPipelineColorBlendAttachmentState       attBlendParams                  =
 570         {
 571                 VK_FALSE,                                                                                                       // blendEnable
 572                 VK_BLEND_FACTOR_ONE,                                                                            // srcColorBlendFactor
 573                 VK_BLEND_FACTOR_ZERO,                                                                           // dstColorBlendFactor
 574                 VK_BLEND_OP_ADD,                                                                                        // colorBlendOp
 575                 VK_BLEND_FACTOR_ONE,                                                                            // srcAlphaBlendFactor
 576                 VK_BLEND_FACTOR_ZERO,                                                                           // dstAlphaBlendFactor
 577                 VK_BLEND_OP_ADD,                                                                                        // alphaBlendOp
 578                 (VK_COLOR_COMPONENT_R_BIT|
 579                  VK_COLOR_COMPONENT_G_BIT|
 580                  VK_COLOR_COMPONENT_B_BIT|
 581                  VK_COLOR_COMPONENT_A_BIT),                                                                     // colorWriteMask
 582         };
 583         const VkPipelineColorBlendStateCreateInfo       blendParams                             =
 584         {
 585                 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,       // sType
 586                 DE_NULL,                                                                                                        // pNext
 587                 0u,                                                                                                                     // flags
 588                 DE_FALSE,                                                                                                       // logicOpEnable
 589                 VK_LOGIC_OP_COPY,                                                                                       // logicOp
 590                 1u,                                                                                                                     // attachmentCount
 591                 &attBlendParams,                                                                                        // pAttachments
 592                 { 0.0f, 0.0f, 0.0f, 0.0f },                                                                     // blendConstants[4]
 593         };
 594         const VkGraphicsPipelineCreateInfo              pipelineParams                  =
 595         {
 596                 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,                // sType
 597                 DE_NULL,                                                                                                // pNext
 598                 0u,                                                                                                             // flags
 599                 (deUint32)DE_LENGTH_OF_ARRAY(shaderStageParams),                // stageCount
 600                 shaderStageParams,                                                                              // pStages
 601                 &vertexInputStateParams,                                                                // pVertexInputState
 602                 &inputAssemblyParams,                                                                   // pInputAssemblyState
 603                 DE_NULL,                                                                                                // pTessellationState
 604                 &viewportParams,                                                                                // pViewportState
 605                 &rasterParams,                                                                                  // pRasterizationState
 606                 &multisampleParams,                                                                             // pMultisampleState
 607                 &depthStencilParams,                                                                    // pDepthStencilState
 608                 &blendParams,                                                                                   // pColorBlendState
 609                 (const VkPipelineDynamicStateCreateInfo*)DE_NULL,               // pDynamicState
 610                 *pipelineLayout,                                                                                // layout
 611                 *renderPass,                                                                                    // renderPass
 612                 0u,                                                                                                             // subpass
 613                 DE_NULL,                                                                                                // basePipelineHandle
 614                 0u,                                                                                                             // basePipelineIndex
 615         };
 616
 617         const Unique<VkPipeline>                                pipeline                                (createGraphicsPipeline(vk, vkDevice, DE_NULL, &pipelineParams));
 618
 619         // Framebuffer
 620         const VkFramebufferCreateInfo                   framebufferParams               =
 621         {
 622                 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,                              // sType
 623                 DE_NULL,                                                                                                // pNext
 624                 0u,                                                                                                             // flags
 625                 *renderPass,                                                                                    // renderPass
 626                 1u,                                                                                                             // attachmentCount
 627                 &*colorAttView,                                                                                 // pAttachments
 628                 (deUint32)renderSize.x(),                                                               // width
 629                 (deUint32)renderSize.y(),                                                               // height
 630                 1u,                                                                                                             // layers
 631         };
 632         const Unique<VkFramebuffer>                             framebuffer                             (createFramebuffer(vk, vkDevice, &framebufferParams));
 633
 634         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
 635         {
 636                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     // sType
 637                 DE_NULL,                                                                                                        // pNext
 638                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        // flags
 639                 queueFamilyIndex,                                                                                       // queueFamilyIndex
 640         };
 641         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
 642
 643         // Command buffer
 644         const VkCommandBufferAllocateInfo               cmdBufParams                    =
 645         {
 646                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                 // sType
 647                 DE_NULL,                                                                                                // pNext
 648                 *cmdPool,                                                                                               // pool
 649                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                // level
 650                 1u,                                                                                                             // bufferCount
 651         };
 652         const Unique<VkCommandBuffer>                   cmdBuf                                  (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
 653
 654         const VkCommandBufferBeginInfo                  cmdBufBeginParams               =
 655         {
 656                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                    // sType
 657                 DE_NULL,                                                                                                // pNext
 658                 0u,                                                                                                             // flags
 659                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
 660         };
 661
 662         // Record commands
 663         VK_CHECK(vk.beginCommandBuffer(*cmdBuf, &cmdBufBeginParams));
 664
 665         {
 666                 const VkMemoryBarrier           vertFlushBarrier        =
 667                 {
 668                         VK_STRUCTURE_TYPE_MEMORY_BARRIER,                       // sType
 669                         DE_NULL,                                                                        // pNext
 670                         VK_ACCESS_HOST_WRITE_BIT,                                       // srcAccessMask
 671                         VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT,            // dstAccessMask
 672                 };
 673                 const VkImageMemoryBarrier      colorAttBarrier         =
 674                 {
 675                         VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,         // sType
 676                         DE_NULL,                                                                        // pNext
 677                         0u,                                                                                     // srcAccessMask
 678                         (VK_ACCESS_COLOR_ATTACHMENT_READ_BIT|
 679                          VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT),         // dstAccessMask
 680                         VK_IMAGE_LAYOUT_UNDEFINED,                                      // oldLayout
 681                         VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,       // newLayout
 682                         queueFamilyIndex,                                                       // srcQueueFamilyIndex
 683                         queueFamilyIndex,                                                       // dstQueueFamilyIndex
 684                         *image,                                                                         // image
 685                         {
 686                                 VK_IMAGE_ASPECT_COLOR_BIT,                                      // aspectMask
 687                                 0u,                                                                                     // baseMipLevel
 688                                 1u,                                                                                     // levelCount
 689                                 0u,                                                                                     // baseArrayLayer
 690                                 1u,                                                                                     // layerCount
 691                         }                                                                                       // subresourceRange
 692                 };
 693                 vk.cmdPipelineBarrier(*cmdBuf, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, (VkDependencyFlags)0, 1, &vertFlushBarrier, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &colorAttBarrier);
 694         }
 695
 696         {
 697                 const VkClearValue                      clearValue              = makeClearValueColorF32(clearColor[0],
 698                                                                                                                                                          clearColor[1],
 699                                                                                                                                                          clearColor[2],
 700                                                                                                                                                          clearColor[3]);
 701                 const VkRenderPassBeginInfo     passBeginParams =
 702                 {
 703                         VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,                       // sType
 704                         DE_NULL,                                                                                        // pNext
 705                         *renderPass,                                                                            // renderPass
 706                         *framebuffer,                                                                           // framebuffer
 707                         {
 708                                 { 0, 0 },
 709                                 { (deUint32)renderSize.x(), (deUint32)renderSize.y() }
 710                         },                                                                                                      // renderArea
 711                         1u,                                                                                                     // clearValueCount
 712                         &clearValue,                                                                            // pClearValues
 713                 };
 714                 vk.cmdBeginRenderPass(*cmdBuf, &passBeginParams, VK_SUBPASS_CONTENTS_INLINE);
 715         }
 716
 717         vk.cmdBindPipeline(*cmdBuf, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
 718         {
 719                 const VkDeviceSize bindingOffset = 0;
 720                 vk.cmdBindVertexBuffers(*cmdBuf, 0u, 1u, &vertexBuffer.get(), &bindingOffset);
 721         }
 722         vk.cmdDraw(*cmdBuf, 3u, 1u, 0u, 0u);
 723         vk.cmdEndRenderPass(*cmdBuf);
 724
 725         {
 726                 const VkImageMemoryBarrier      renderFinishBarrier     =
 727                 {
 728                         VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,         // sType
 729                         DE_NULL,                                                                        // pNext
 730                         VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,           // outputMask
 731                         VK_ACCESS_TRANSFER_READ_BIT,                            // inputMask
 732                         VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,       // oldLayout
 733                         VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,           // newLayout
 734                         queueFamilyIndex,                                                       // srcQueueFamilyIndex
 735                         queueFamilyIndex,                                                       // dstQueueFamilyIndex
 736                         *image,                                                                         // image
 737                         {
 738                                 VK_IMAGE_ASPECT_COLOR_BIT,                                      // aspectMask
 739                                 0u,                                                                                     // baseMipLevel
 740                                 1u,                                                                                     // mipLevels
 741                                 0u,                                                                                     // baseArraySlice
 742                                 1u,                                                                                     // arraySize
 743                         }                                                                                       // subresourceRange
 744                 };
 745                 vk.cmdPipelineBarrier(*cmdBuf, VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &renderFinishBarrier);
 746         }
 747
 748         {
 749                 const VkBufferImageCopy copyParams      =
 750                 {
 751                         (VkDeviceSize)0u,                                               // bufferOffset
 752                         (deUint32)renderSize.x(),                               // bufferRowLength
 753                         (deUint32)renderSize.y(),                               // bufferImageHeight
 754                         {
 755                                 VK_IMAGE_ASPECT_COLOR_BIT,                              // aspectMask
 756                                 0u,                                                                             // mipLevel
 757                                 0u,                                                                             // baseArrayLayer
 758                                 1u,                                                                             // layerCount
 759                         },                                                                              // imageSubresource
 760                         { 0u, 0u, 0u },                                                 // imageOffset
 761                         {
 762                                 (deUint32)renderSize.x(),
 763                                 (deUint32)renderSize.y(),
 764                                 1u
 765                         }                                                                               // imageExtent
 766                 };
 767                 vk.cmdCopyImageToBuffer(*cmdBuf, *image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *readImageBuffer, 1u, &copyParams);
 768         }
 769
 770         {
 771                 const VkBufferMemoryBarrier     copyFinishBarrier       =
 772                 {
 773                         VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,        // sType
 774                         DE_NULL,                                                                        // pNext
 775                         VK_ACCESS_TRANSFER_WRITE_BIT,                           // srcAccessMask
 776                         VK_ACCESS_HOST_READ_BIT,                                        // dstAccessMask
 777                         queueFamilyIndex,                                                       // srcQueueFamilyIndex
 778                         queueFamilyIndex,                                                       // dstQueueFamilyIndex
 779                         *readImageBuffer,                                                       // buffer
 780                         0u,                                                                                     // offset
 781                         imageSizeBytes                                                          // size
 782                 };
 783                 vk.cmdPipelineBarrier(*cmdBuf, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &copyFinishBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
 784         }
 785
 786         VK_CHECK(vk.endCommandBuffer(*cmdBuf));
 787
 788         // Upload vertex data
 789         {
 790                 const VkMappedMemoryRange       range                   =
 791                 {
 792                         VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,  // sType
 793                         DE_NULL,                                                                // pNext
 794                         vertexBufferMemory->getMemory(),                // memory
 795                         0,                                                                              // offset
 796                         (VkDeviceSize)sizeof(vertices),                 // size
 797                 };
 798                 void*                                           vertexBufPtr    = vertexBufferMemory->getHostPtr();
 799
 800                 deMemcpy(vertexBufPtr, &vertices[0], sizeof(vertices));
 801                 VK_CHECK(vk.flushMappedMemoryRanges(vkDevice, 1u, &range));
 802         }
 803
 804         // Submit & wait for completion
 805         {
 806                 const VkFenceCreateInfo fenceParams     =
 807                 {
 808                         VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,    // sType
 809                         DE_NULL,                                                                // pNext
 810                         0u,                                                                             // flags
 811                 };
 812                 const VkSubmitInfo              submitInfo      =
 813                 {
 814                         VK_STRUCTURE_TYPE_SUBMIT_INFO,                  // sType
 815                         DE_NULL,                                                                // pNext
 816                         0u,                                                                             // waitSemaphoreCount
 817                         DE_NULL,                                                                // pWaitSemaphores
 818                         (const VkPipelineStageFlags*)DE_NULL,
 819                         1u,                                                                             // commandBufferCount
 820                         &cmdBuf.get(),                                                  // pCommandBuffers
 821                         0u,                                                                             // signalSemaphoreCount
 822                         DE_NULL,                                                                // pSignalSemaphores
 823                 };
 824                 const Unique<VkFence>   fence           (createFence(vk, vkDevice, &fenceParams));
 825
 826                 VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
 827                 VK_CHECK(vk.waitForFences(vkDevice, 1u, &fence.get(), DE_TRUE, ~0ull));
 828         }
 829
 830         // Read results, render reference, compare
 831         {
 832                 const tcu::TextureFormat                        tcuFormat               = vk::mapVkFormat(colorFormat);
 833                 const VkMappedMemoryRange                       range                   =
 834                 {
 835                         VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,  // sType
 836                         DE_NULL,                                                                // pNext
 837                         readImageBufferMemory->getMemory(),             // memory
 838                         0,                                                                              // offset
 839                         imageSizeBytes,                                                 // size
 840                 };
 841                 const tcu::ConstPixelBufferAccess       resultAccess    (tcuFormat, renderSize.x(), renderSize.y(), 1, readImageBufferMemory->getHostPtr());
 842
 843                 VK_CHECK(vk.invalidateMappedMemoryRanges(vkDevice, 1u, &range));
 844
 845                 {
 846                         tcu::TextureLevel       refImage                (tcuFormat, renderSize.x(), renderSize.y());
 847                         const tcu::UVec4        threshold               (0u);
 848                         const tcu::IVec3        posDeviation    (1,1,0);
 849
 850                         tcu::clear(refImage.getAccess(), clearColor);
 851                         renderReferenceTriangle(refImage.getAccess(), vertices);
 852
 853                         if (tcu::intThresholdPositionDeviationCompare(context.getTestContext().getLog(),
 854                                                                                                                   "ComparisonResult",
 855                                                                                                                   "Image comparison result",
 856                                                                                                                   refImage.getAccess(),
 857                                                                                                                   resultAccess,
 858                                                                                                                   threshold,
 859                                                                                                                   posDeviation,
 860                                                                                                                   false,
 861                                                                                                                   tcu::COMPARE_LOG_RESULT))
 862                                 return tcu::TestStatus::pass("Rendering succeeded");
 863                         else
 864                                 return tcu::TestStatus::fail("Image comparison failed");
 865                 }
 866         }
 867
 868         return tcu::TestStatus::pass("Rendering succeeded");
 869 }
 870
 871 tcu::TestStatus renderTriangleUnusedResolveAttachmentTest (Context& context)
 872 {
 873         const VkDevice                                                  vkDevice                                = context.getDevice();
 874         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
 875         const VkQueue                                                   queue                                   = context.getUniversalQueue();
 876         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
 877         SimpleAllocator                                                 memAlloc                                (vk, vkDevice, getPhysicalDeviceMemoryProperties(context.getInstanceInterface(), context.getPhysicalDevice()));
 878         const tcu::IVec2                                                renderSize                              (256, 256);
 879         const VkFormat                                                  colorFormat                             = VK_FORMAT_R8G8B8A8_UNORM;
 880         const tcu::Vec4                                                 clearColor                              (0.125f, 0.25f, 0.75f, 1.0f);
 881
 882         const tcu::Vec4                                                 vertices[]                              =
 883         {
 884                 tcu::Vec4(-0.5f, -0.5f, 0.0f, 1.0f),
 885                 tcu::Vec4(+0.5f, -0.5f, 0.0f, 1.0f),
 886                 tcu::Vec4( 0.0f, +0.5f, 0.0f, 1.0f)
 887         };
 888
 889         const VkBufferCreateInfo                                vertexBufferParams              =
 890         {
 891                 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,   // sType
 892                 DE_NULL,                                                                // pNext
 893                 0u,                                                                             // flags
 894                 (VkDeviceSize)sizeof(vertices),                 // size
 895                 VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,              // usage
 896                 VK_SHARING_MODE_EXCLUSIVE,                              // sharingMode
 897                 1u,                                                                             // queueFamilyIndexCount
 898                 &queueFamilyIndex,                                              // pQueueFamilyIndices
 899         };
 900         const Unique<VkBuffer>                                  vertexBuffer                    (createBuffer(vk, vkDevice, &vertexBufferParams));
 901         const UniquePtr<Allocation>                             vertexBufferMemory              (memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *vertexBuffer), MemoryRequirement::HostVisible));
 902
 903         VK_CHECK(vk.bindBufferMemory(vkDevice, *vertexBuffer, vertexBufferMemory->getMemory(), vertexBufferMemory->getOffset()));
 904
 905         const VkDeviceSize                                              imageSizeBytes                  = (VkDeviceSize)(sizeof(deUint32)*renderSize.x()*renderSize.y());
 906         const VkBufferCreateInfo                                readImageBufferParams   =
 907         {
 908                 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,           // sType
 909                 DE_NULL,                                                                        // pNext
 910                 (VkBufferCreateFlags)0u,                                        // flags
 911                 imageSizeBytes,                                                         // size
 912                 VK_BUFFER_USAGE_TRANSFER_DST_BIT,                       // usage
 913                 VK_SHARING_MODE_EXCLUSIVE,                                      // sharingMode
 914                 1u,                                                                                     // queueFamilyIndexCount
 915                 &queueFamilyIndex,                                                      // pQueueFamilyIndices
 916         };
 917         const Unique<VkBuffer>                                  readImageBuffer                 (createBuffer(vk, vkDevice, &readImageBufferParams));
 918         const UniquePtr<Allocation>                             readImageBufferMemory   (memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *readImageBuffer), MemoryRequirement::HostVisible));
 919
 920         VK_CHECK(vk.bindBufferMemory(vkDevice, *readImageBuffer, readImageBufferMemory->getMemory(), readImageBufferMemory->getOffset()));
 921
 922         const VkImageCreateInfo                                 imageParams                             =
 923         {
 924                 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,                                                                    // sType
 925                 DE_NULL,                                                                                                                                // pNext
 926                 0u,                                                                                                                                             // flags
 927                 VK_IMAGE_TYPE_2D,                                                                                                               // imageType
 928                 VK_FORMAT_R8G8B8A8_UNORM,                                                                                               // format
 929                 { (deUint32)renderSize.x(), (deUint32)renderSize.y(), 1 },                              // extent
 930                 1u,                                                                                                                                             // mipLevels
 931                 1u,                                                                                                                                             // arraySize
 932                 VK_SAMPLE_COUNT_1_BIT,                                                                                                  // samples
 933                 VK_IMAGE_TILING_OPTIMAL,                                                                                                // tiling
 934                 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT|VK_IMAGE_USAGE_TRANSFER_SRC_BIT,    // usage
 935                 VK_SHARING_MODE_EXCLUSIVE,                                                                                              // sharingMode
 936                 1u,                                                                                                                                             // queueFamilyIndexCount
 937                 &queueFamilyIndex,                                                                                                              // pQueueFamilyIndices
 938                 VK_IMAGE_LAYOUT_UNDEFINED,                                                                                              // initialLayout
 939         };
 940
 941         const Unique<VkImage>                                   image                                   (createImage(vk, vkDevice, &imageParams));
 942         const UniquePtr<Allocation>                             imageMemory                             (memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *image), MemoryRequirement::Any));
 943
 944         VK_CHECK(vk.bindImageMemory(vkDevice, *image, imageMemory->getMemory(), imageMemory->getOffset()));
 945
 946         const VkAttachmentDescription                   colorAttDesc                    =
 947         {
 948                 0u,                                                                                             // flags
 949                 VK_FORMAT_R8G8B8A8_UNORM,                                               // format
 950                 VK_SAMPLE_COUNT_1_BIT,                                                  // samples
 951                 VK_ATTACHMENT_LOAD_OP_CLEAR,                                    // loadOp
 952                 VK_ATTACHMENT_STORE_OP_STORE,                                   // storeOp
 953                 VK_ATTACHMENT_LOAD_OP_DONT_CARE,                                // stencilLoadOp
 954                 VK_ATTACHMENT_STORE_OP_DONT_CARE,                               // stencilStoreOp
 955                 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,               // initialLayout
 956                 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,               // finalLayout
 957         };
 958         const VkAttachmentReference                             colorAttRef                             =
 959         {
 960                 0u,                                                                                             // attachment
 961                 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,               // layout
 962         };
 963         const VkAttachmentReference                             resolveAttRef                   =
 964         {
 965                 VK_ATTACHMENT_UNUSED,
 966                 VK_IMAGE_LAYOUT_GENERAL
 967         };
 968         const VkSubpassDescription                              subpassDesc                             =
 969         {
 970                 (VkSubpassDescriptionFlags)0u,                                  // flags
 971                 VK_PIPELINE_BIND_POINT_GRAPHICS,                                // pipelineBindPoint
 972                 0u,                                                                                             // inputAttachmentCount
 973                 DE_NULL,                                                                                // pInputAttachments
 974                 1u,                                                                                             // colorAttachmentCount
 975                 &colorAttRef,                                                                   // pColorAttachments
 976                 &resolveAttRef,                                                                 // pResolveAttachments
 977                 DE_NULL,                                                                                // depthStencilAttachment
 978                 0u,                                                                                             // preserveAttachmentCount
 979                 DE_NULL,                                                                                // pPreserveAttachments
 980         };
 981         const VkRenderPassCreateInfo                    renderPassParams                =
 982         {
 983                 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,              // sType
 984                 DE_NULL,                                                                                // pNext
 985                 0u,                                                                                             // flags
 986                 1u,                                                                                             // attachmentCount
 987                 &colorAttDesc,                                                                  // pAttachments
 988                 1u,                                                                                             // subpassCount
 989                 &subpassDesc,                                                                   // pSubpasses
 990                 0u,                                                                                             // dependencyCount
 991                 DE_NULL,                                                                                // pDependencies
 992         };
 993         const Unique<VkRenderPass>                              renderPass                              (createRenderPass(vk, vkDevice, &renderPassParams));
 994
 995         const VkImageViewCreateInfo                             colorAttViewParams              =
 996         {
 997                 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,               // sType
 998                 DE_NULL,                                                                                // pNext
 999                 0u,                                                                                             // flags
1000                 *image,                                                                                 // image
1001                 VK_IMAGE_VIEW_TYPE_2D,                                                  // viewType
1002                 VK_FORMAT_R8G8B8A8_UNORM,                                               // format
1003                 {
1004                         VK_COMPONENT_SWIZZLE_R,
1005                         VK_COMPONENT_SWIZZLE_G,
1006                         VK_COMPONENT_SWIZZLE_B,
1007                         VK_COMPONENT_SWIZZLE_A
1008                 },                                                                                              // components
1009                 {
1010                         VK_IMAGE_ASPECT_COLOR_BIT,                                              // aspectMask
1011                         0u,                                                                                             // baseMipLevel
1012                         1u,                                                                                             // levelCount
1013                         0u,                                                                                             // baseArrayLayer
1014                         1u,                                                                                             // layerCount
1015                 },                                                                                              // subresourceRange
1016         };
1017         const Unique<VkImageView>                               colorAttView                    (createImageView(vk, vkDevice, &colorAttViewParams));
1018
1019         // Pipeline layout
1020         const VkPipelineLayoutCreateInfo                pipelineLayoutParams    =
1021         {
1022                 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,                  // sType
1023                 DE_NULL,                                                                                                // pNext
1024                 (vk::VkPipelineLayoutCreateFlags)0,
1025                 0u,                                                                                                             // setLayoutCount
1026                 DE_NULL,                                                                                                // pSetLayouts
1027                 0u,                                                                                                             // pushConstantRangeCount
1028                 DE_NULL,                                                                                                // pPushConstantRanges
1029         };
1030         const Unique<VkPipelineLayout>                  pipelineLayout                  (createPipelineLayout(vk, vkDevice, &pipelineLayoutParams));
1031
1032         // Shaders
1033         const Unique<VkShaderModule>                    vertShaderModule                (createShaderModule(vk, vkDevice, context.getBinaryCollection().get("vert"), 0));
1034         const Unique<VkShaderModule>                    fragShaderModule                (createShaderModule(vk, vkDevice, context.getBinaryCollection().get("frag"), 0));
1035
1036         // Pipeline
1037         const VkSpecializationInfo                              emptyShaderSpecParams   =
1038         {
1039                 0u,                                                                                                             // mapEntryCount
1040                 DE_NULL,                                                                                                // pMap
1041                 0,                                                                                                              // dataSize
1042                 DE_NULL,                                                                                                // pData
1043         };
1044         const VkPipelineShaderStageCreateInfo   shaderStageParams[]     =
1045         {
1046                 {
1047                         VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,    // sType
1048                         DE_NULL,                                                                                                // pNext
1049                         0u,                                                                                                             // flags
1050                         VK_SHADER_STAGE_VERTEX_BIT,                                                             // stage
1051                         *vertShaderModule,                                                                              // module
1052                         "main",                                                                                                 // pName
1053                         &emptyShaderSpecParams,                                                                 // pSpecializationInfo
1054                 },
1055                 {
1056                         VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,    // sType
1057                         DE_NULL,                                                                                                // pNext
1058                         0u,                                                                                                             // flags
1059                         VK_SHADER_STAGE_FRAGMENT_BIT,                                                   // stage
1060                         *fragShaderModule,                                                                              // module
1061                         "main",                                                                                                 // pName
1062                         &emptyShaderSpecParams,                                                                 // pSpecializationInfo
1063                 }
1064         };
1065         const VkPipelineDepthStencilStateCreateInfo     depthStencilParams              =
1066         {
1067                 VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,     // sType
1068                 DE_NULL,                                                                                                        // pNext
1069                 0u,                                                                                                                     // flags
1070                 DE_FALSE,                                                                                                       // depthTestEnable
1071                 DE_FALSE,                                                                                                       // depthWriteEnable
1072                 VK_COMPARE_OP_ALWAYS,                                                                           // depthCompareOp
1073                 DE_FALSE,                                                                                                       // depthBoundsTestEnable
1074                 DE_FALSE,                                                                                                       // stencilTestEnable
1075                 {
1076                         VK_STENCIL_OP_KEEP,                                                                                     // failOp
1077                         VK_STENCIL_OP_KEEP,                                                                                     // passOp
1078                         VK_STENCIL_OP_KEEP,                                                                                     // depthFailOp
1079                         VK_COMPARE_OP_ALWAYS,                                                                           // compareOp
1080                         0u,                                                                                                                     // compareMask
1081                         0u,                                                                                                                     // writeMask
1082                         0u,                                                                                                                     // reference
1083                 },                                                                                                                      // front
1084                 {
1085                         VK_STENCIL_OP_KEEP,                                                                                     // failOp
1086                         VK_STENCIL_OP_KEEP,                                                                                     // passOp
1087                         VK_STENCIL_OP_KEEP,                                                                                     // depthFailOp
1088                         VK_COMPARE_OP_ALWAYS,                                                                           // compareOp
1089                         0u,                                                                                                                     // compareMask
1090                         0u,                                                                                                                     // writeMask
1091                         0u,                                                                                                                     // reference
1092                 },                                                                                                                      // back;
1093                 -1.0f,                                                                                                          //      float                           minDepthBounds;
1094                 +1.0f,                                                                                                          //      float                           maxDepthBounds;
1095         };
1096         const VkViewport                                                viewport0                               =
1097         {
1098                 0.0f,                                                                                                           // x
1099                 0.0f,                                                                                                           // y
1100                 (float)renderSize.x(),                                                                          // width
1101                 (float)renderSize.y(),                                                                          // height
1102                 0.0f,                                                                                                           // minDepth
1103                 1.0f,                                                                                                           // maxDepth
1104         };
1105         const VkRect2D                                                  scissor0                                =
1106         {
1107                 {
1108                         0u,                                                                                                                     // x
1109                         0u,                                                                                                                     // y
1110                 },                                                                                                                      // offset
1111                 {
1112                         (deUint32)renderSize.x(),                                                                       // width
1113                         (deUint32)renderSize.y(),                                                                       // height
1114                 },                                                                                                                      // extent;
1115         };
1116         const VkPipelineViewportStateCreateInfo         viewportParams                  =
1117         {
1118                 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,          // sType
1119                 DE_NULL,                                                                                                        // pNext
1120                 0u,                                                                                                                     // flags
1121                 1u,                                                                                                                     // viewportCount
1122                 &viewport0,                                                                                                     // pViewports
1123                 1u,                                                                                                                     // scissorCount
1124                 &scissor0                                                                                                       // pScissors
1125         };
1126         const VkSampleMask                                                      sampleMask                              = ~0u;
1127         const VkPipelineMultisampleStateCreateInfo      multisampleParams               =
1128         {
1129                 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,       // sType
1130                 DE_NULL,                                                                                                        // pNext
1131                 0u,                                                                                                                     // flags
1132                 VK_SAMPLE_COUNT_1_BIT,                                                                          // rasterizationSamples
1133                 VK_FALSE,                                                                                                       // sampleShadingEnable
1134                 0.0f,                                                                                                           // minSampleShading
1135                 &sampleMask,                                                                                            // sampleMask
1136                 VK_FALSE,                                                                                                       // alphaToCoverageEnable
1137                 VK_FALSE,                                                                                                       // alphaToOneEnable
1138         };
1139         const VkPipelineRasterizationStateCreateInfo    rasterParams            =
1140         {
1141                 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,     // sType
1142                 DE_NULL,                                                                                                        // pNext
1143                 0u,                                                                                                                     // flags
1144                 VK_TRUE,                                                                                                        // depthClampEnable
1145                 VK_FALSE,                                                                                                       // rasterizerDiscardEnable
1146                 VK_POLYGON_MODE_FILL,                                                                           // polygonMode
1147                 VK_CULL_MODE_NONE,                                                                                      // cullMode
1148                 VK_FRONT_FACE_COUNTER_CLOCKWISE,                                                        // frontFace
1149                 VK_FALSE,                                                                                                       // depthBiasEnable
1150                 0.0f,                                                                                                           // depthBiasConstantFactor
1151                 0.0f,                                                                                                           // depthBiasClamp
1152                 0.0f,                                                                                                           // depthBiasSlopeFactor
1153                 1.0f,                                                                                                           // lineWidth
1154         };
1155         const VkPipelineInputAssemblyStateCreateInfo    inputAssemblyParams     =
1156         {
1157                 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,    // sType
1158                 DE_NULL,                                                                                                                // pNext
1159                 0u,                                                                                                                             // flags
1160                 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,                                                    // topology
1161                 DE_FALSE,                                                                                                               // primitiveRestartEnable
1162         };
1163         const VkVertexInputBindingDescription           vertexBinding0                  =
1164         {
1165                 0u,                                                                                                             // binding
1166                 (deUint32)sizeof(tcu::Vec4),                                                    // stride
1167                 VK_VERTEX_INPUT_RATE_VERTEX,                                                    // inputRate
1168         };
1169         const VkVertexInputAttributeDescription         vertexAttrib0                   =
1170         {
1171                 0u,                                                                                                             // location
1172                 0u,                                                                                                             // binding
1173                 VK_FORMAT_R32G32B32A32_SFLOAT,                                                  // format
1174                 0u,                                                                                                             // offset
1175         };
1176         const VkPipelineVertexInputStateCreateInfo      vertexInputStateParams  =
1177         {
1178                 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,      // sType
1179                 DE_NULL,                                                                                                        // pNext
1180                 0u,                                                                                                                     // flags
1181                 1u,                                                                                                                     // vertexBindingDescriptionCount
1182                 &vertexBinding0,                                                                                        // pVertexBindingDescriptions
1183                 1u,                                                                                                                     // vertexAttributeDescriptionCount
1184                 &vertexAttrib0,                                                                                         // pVertexAttributeDescriptions
1185         };
1186         const VkPipelineColorBlendAttachmentState       attBlendParams                  =
1187         {
1188                 VK_FALSE,                                                                                                       // blendEnable
1189                 VK_BLEND_FACTOR_ONE,                                                                            // srcColorBlendFactor
1190                 VK_BLEND_FACTOR_ZERO,                                                                           // dstColorBlendFactor
1191                 VK_BLEND_OP_ADD,                                                                                        // colorBlendOp
1192                 VK_BLEND_FACTOR_ONE,                                                                            // srcAlphaBlendFactor
1193                 VK_BLEND_FACTOR_ZERO,                                                                           // dstAlphaBlendFactor
1194                 VK_BLEND_OP_ADD,                                                                                        // alphaBlendOp
1195                 (VK_COLOR_COMPONENT_R_BIT|
1196                  VK_COLOR_COMPONENT_G_BIT|
1197                  VK_COLOR_COMPONENT_B_BIT|
1198                  VK_COLOR_COMPONENT_A_BIT),                                                                     // colorWriteMask
1199         };
1200         const VkPipelineColorBlendStateCreateInfo       blendParams                             =
1201         {
1202                 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,       // sType
1203                 DE_NULL,                                                                                                        // pNext
1204                 0u,                                                                                                                     // flags
1205                 DE_FALSE,                                                                                                       // logicOpEnable
1206                 VK_LOGIC_OP_COPY,                                                                                       // logicOp
1207                 1u,                                                                                                                     // attachmentCount
1208                 &attBlendParams,                                                                                        // pAttachments
1209                 { 0.0f, 0.0f, 0.0f, 0.0f },                                                                     // blendConstants[4]
1210         };
1211         const VkGraphicsPipelineCreateInfo              pipelineParams                  =
1212         {
1213                 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,                // sType
1214                 DE_NULL,                                                                                                // pNext
1215                 0u,                                                                                                             // flags
1216                 (deUint32)DE_LENGTH_OF_ARRAY(shaderStageParams),                // stageCount
1217                 shaderStageParams,                                                                              // pStages
1218                 &vertexInputStateParams,                                                                // pVertexInputState
1219                 &inputAssemblyParams,                                                                   // pInputAssemblyState
1220                 DE_NULL,                                                                                                // pTessellationState
1221                 &viewportParams,                                                                                // pViewportState
1222                 &rasterParams,                                                                                  // pRasterizationState
1223                 &multisampleParams,                                                                             // pMultisampleState
1224                 &depthStencilParams,                                                                    // pDepthStencilState
1225                 &blendParams,                                                                                   // pColorBlendState
1226                 (const VkPipelineDynamicStateCreateInfo*)DE_NULL,               // pDynamicState
1227                 *pipelineLayout,                                                                                // layout
1228                 *renderPass,                                                                                    // renderPass
1229                 0u,                                                                                                             // subpass
1230                 DE_NULL,                                                                                                // basePipelineHandle
1231                 0u,                                                                                                             // basePipelineIndex
1232         };
1233
1234         const Unique<VkPipeline>                                pipeline                                (createGraphicsPipeline(vk, vkDevice, DE_NULL, &pipelineParams));
1235
1236         // Framebuffer
1237         const VkFramebufferCreateInfo                   framebufferParams               =
1238         {
1239                 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,                              // sType
1240                 DE_NULL,                                                                                                // pNext
1241                 0u,                                                                                                             // flags
1242                 *renderPass,                                                                                    // renderPass
1243                 1u,                                                                                                             // attachmentCount
1244                 &*colorAttView,                                                                                 // pAttachments
1245                 (deUint32)renderSize.x(),                                                               // width
1246                 (deUint32)renderSize.y(),                                                               // height
1247                 1u,                                                                                                             // layers
1248         };
1249         const Unique<VkFramebuffer>                             framebuffer                             (createFramebuffer(vk, vkDevice, &framebufferParams));
1250
1251         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
1252         {
1253                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     // sType
1254                 DE_NULL,                                                                                                        // pNext
1255                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        // flags
1256                 queueFamilyIndex,                                                                                       // queueFamilyIndex
1257         };
1258         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
1259
1260         // Command buffer
1261         const VkCommandBufferAllocateInfo               cmdBufParams                    =
1262         {
1263                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                 // sType
1264                 DE_NULL,                                                                                                // pNext
1265                 *cmdPool,                                                                                               // pool
1266                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                // level
1267                 1u,                                                                                                             // bufferCount
1268         };
1269         const Unique<VkCommandBuffer>                   cmdBuf                                  (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
1270
1271         const VkCommandBufferBeginInfo                  cmdBufBeginParams               =
1272         {
1273                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                    // sType
1274                 DE_NULL,                                                                                                // pNext
1275                 0u,                                                                                                             // flags
1276                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
1277         };
1278
1279         // Record commands
1280         VK_CHECK(vk.beginCommandBuffer(*cmdBuf, &cmdBufBeginParams));
1281
1282         {
1283                 const VkMemoryBarrier           vertFlushBarrier        =
1284                 {
1285                         VK_STRUCTURE_TYPE_MEMORY_BARRIER,                       // sType
1286                         DE_NULL,                                                                        // pNext
1287                         VK_ACCESS_HOST_WRITE_BIT,                                       // srcAccessMask
1288                         VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT,            // dstAccessMask
1289                 };
1290                 const VkImageMemoryBarrier      colorAttBarrier         =
1291                 {
1292                         VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,         // sType
1293                         DE_NULL,                                                                        // pNext
1294                         0u,                                                                                     // srcAccessMask
1295                         (VK_ACCESS_COLOR_ATTACHMENT_READ_BIT|
1296                          VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT),         // dstAccessMask
1297                         VK_IMAGE_LAYOUT_UNDEFINED,                                      // oldLayout
1298                         VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,       // newLayout
1299                         queueFamilyIndex,                                                       // srcQueueFamilyIndex
1300                         queueFamilyIndex,                                                       // dstQueueFamilyIndex
1301                         *image,                                                                         // image
1302                         {
1303                                 VK_IMAGE_ASPECT_COLOR_BIT,                                      // aspectMask
1304                                 0u,                                                                                     // baseMipLevel
1305                                 1u,                                                                                     // levelCount
1306                                 0u,                                                                                     // baseArrayLayer
1307                                 1u,                                                                                     // layerCount
1308                         }                                                                                       // subresourceRange
1309                 };
1310                 vk.cmdPipelineBarrier(*cmdBuf, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, (VkDependencyFlags)0, 1, &vertFlushBarrier, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &colorAttBarrier);
1311         }
1312
1313         {
1314                 const VkClearValue                      clearValue              = makeClearValueColorF32(clearColor[0],
1315                                                                                                                                                          clearColor[1],
1316                                                                                                                                                          clearColor[2],
1317                                                                                                                                                          clearColor[3]);
1318                 const VkRenderPassBeginInfo     passBeginParams =
1319                 {
1320                         VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,                       // sType
1321                         DE_NULL,                                                                                        // pNext
1322                         *renderPass,                                                                            // renderPass
1323                         *framebuffer,                                                                           // framebuffer
1324                         {
1325                                 { 0, 0 },
1326                                 { (deUint32)renderSize.x(), (deUint32)renderSize.y() }
1327                         },                                                                                                      // renderArea
1328                         1u,                                                                                                     // clearValueCount
1329                         &clearValue,                                                                            // pClearValues
1330                 };
1331                 vk.cmdBeginRenderPass(*cmdBuf, &passBeginParams, VK_SUBPASS_CONTENTS_INLINE);
1332         }
1333
1334         vk.cmdBindPipeline(*cmdBuf, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
1335         {
1336                 const VkDeviceSize bindingOffset = 0;
1337                 vk.cmdBindVertexBuffers(*cmdBuf, 0u, 1u, &vertexBuffer.get(), &bindingOffset);
1338         }
1339         vk.cmdDraw(*cmdBuf, 3u, 1u, 0u, 0u);
1340         vk.cmdEndRenderPass(*cmdBuf);
1341
1342         {
1343                 const VkImageMemoryBarrier      renderFinishBarrier     =
1344                 {
1345                         VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,         // sType
1346                         DE_NULL,                                                                        // pNext
1347                         VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,           // outputMask
1348                         VK_ACCESS_TRANSFER_READ_BIT,                            // inputMask
1349                         VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,       // oldLayout
1350                         VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,           // newLayout
1351                         queueFamilyIndex,                                                       // srcQueueFamilyIndex
1352                         queueFamilyIndex,                                                       // dstQueueFamilyIndex
1353                         *image,                                                                         // image
1354                         {
1355                                 VK_IMAGE_ASPECT_COLOR_BIT,                                      // aspectMask
1356                                 0u,                                                                                     // baseMipLevel
1357                                 1u,                                                                                     // mipLevels
1358                                 0u,                                                                                     // baseArraySlice
1359                                 1u,                                                                                     // arraySize
1360                         }                                                                                       // subresourceRange
1361                 };
1362                 vk.cmdPipelineBarrier(*cmdBuf, VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &renderFinishBarrier);
1363         }
1364
1365         {
1366                 const VkBufferImageCopy copyParams      =
1367                 {
1368                         (VkDeviceSize)0u,                                               // bufferOffset
1369                         (deUint32)renderSize.x(),                               // bufferRowLength
1370                         (deUint32)renderSize.y(),                               // bufferImageHeight
1371                         {
1372                                 VK_IMAGE_ASPECT_COLOR_BIT,                              // aspectMask
1373                                 0u,                                                                             // mipLevel
1374                                 0u,                                                                             // baseArrayLayer
1375                                 1u,                                                                             // layerCount
1376                         },                                                                              // imageSubresource
1377                         { 0u, 0u, 0u },                                                 // imageOffset
1378                         {
1379                                 (deUint32)renderSize.x(),
1380                                 (deUint32)renderSize.y(),
1381                                 1u
1382                         }                                                                               // imageExtent
1383                 };
1384                 vk.cmdCopyImageToBuffer(*cmdBuf, *image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *readImageBuffer, 1u, &copyParams);
1385         }
1386
1387         {
1388                 const VkBufferMemoryBarrier     copyFinishBarrier       =
1389                 {
1390                         VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,        // sType
1391                         DE_NULL,                                                                        // pNext
1392                         VK_ACCESS_TRANSFER_WRITE_BIT,                           // srcAccessMask
1393                         VK_ACCESS_HOST_READ_BIT,                                        // dstAccessMask
1394                         queueFamilyIndex,                                                       // srcQueueFamilyIndex
1395                         queueFamilyIndex,                                                       // dstQueueFamilyIndex
1396                         *readImageBuffer,                                                       // buffer
1397                         0u,                                                                                     // offset
1398                         imageSizeBytes                                                          // size
1399                 };
1400                 vk.cmdPipelineBarrier(*cmdBuf, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &copyFinishBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
1401         }
1402
1403         VK_CHECK(vk.endCommandBuffer(*cmdBuf));
1404
1405         // Upload vertex data
1406         {
1407                 const VkMappedMemoryRange       range                   =
1408                 {
1409                         VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,  // sType
1410                         DE_NULL,                                                                // pNext
1411                         vertexBufferMemory->getMemory(),                // memory
1412                         0,                                                                              // offset
1413                         (VkDeviceSize)sizeof(vertices),                 // size
1414                 };
1415                 void*                                           vertexBufPtr    = vertexBufferMemory->getHostPtr();
1416
1417                 deMemcpy(vertexBufPtr, &vertices[0], sizeof(vertices));
1418                 VK_CHECK(vk.flushMappedMemoryRanges(vkDevice, 1u, &range));
1419         }
1420
1421         // Submit & wait for completion
1422         {
1423                 const VkFenceCreateInfo fenceParams     =
1424                 {
1425                         VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,    // sType
1426                         DE_NULL,                                                                // pNext
1427                         0u,                                                                             // flags
1428                 };
1429                 const VkSubmitInfo              submitInfo      =
1430                 {
1431                         VK_STRUCTURE_TYPE_SUBMIT_INFO,                  // sType
1432                         DE_NULL,                                                                // pNext
1433                         0u,                                                                             // waitSemaphoreCount
1434                         DE_NULL,                                                                // pWaitSemaphores
1435                         (const VkPipelineStageFlags*)DE_NULL,
1436                         1u,                                                                             // commandBufferCount
1437                         &cmdBuf.get(),                                                  // pCommandBuffers
1438                         0u,                                                                             // signalSemaphoreCount
1439                         DE_NULL,                                                                // pSignalSemaphores
1440                 };
1441                 const Unique<VkFence>   fence           (createFence(vk, vkDevice, &fenceParams));
1442
1443                 VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
1444                 VK_CHECK(vk.waitForFences(vkDevice, 1u, &fence.get(), DE_TRUE, ~0ull));
1445         }
1446
1447         // Read results, render reference, compare
1448         {
1449                 const tcu::TextureFormat                        tcuFormat               = vk::mapVkFormat(colorFormat);
1450                 const VkMappedMemoryRange                       range                   =
1451                 {
1452                         VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,  // sType
1453                         DE_NULL,                                                                // pNext
1454                         readImageBufferMemory->getMemory(),             // memory
1455                         0,                                                                              // offset
1456                         imageSizeBytes,                                                 // size
1457                 };
1458                 const tcu::ConstPixelBufferAccess       resultAccess    (tcuFormat, renderSize.x(), renderSize.y(), 1, readImageBufferMemory->getHostPtr());
1459
1460                 VK_CHECK(vk.invalidateMappedMemoryRanges(vkDevice, 1u, &range));
1461
1462                 {
1463                         tcu::TextureLevel       refImage                (tcuFormat, renderSize.x(), renderSize.y());
1464                         const tcu::UVec4        threshold               (0u);
1465                         const tcu::IVec3        posDeviation    (1,1,0);
1466
1467                         tcu::clear(refImage.getAccess(), clearColor);
1468                         renderReferenceTriangle(refImage.getAccess(), vertices);
1469
1470                         if (tcu::intThresholdPositionDeviationCompare(context.getTestContext().getLog(),
1471                                                                                                                   "ComparisonResult",
1472                                                                                                                   "Image comparison result",
1473                                                                                                                   refImage.getAccess(),
1474                                                                                                                   resultAccess,
1475                                                                                                                   threshold,
1476                                                                                                                   posDeviation,
1477                                                                                                                   false,
1478                                                                                                                   tcu::COMPARE_LOG_RESULT))
1479                                 return tcu::TestStatus::pass("Rendering succeeded");
1480                         else
1481                                 return tcu::TestStatus::fail("Image comparison failed");
1482                 }
1483         }
1484
1485         return tcu::TestStatus::pass("Rendering succeeded");
1486 }
1487
1488 } // anonymous
1489
1490 tcu::TestCaseGroup* createSmokeTests (tcu::TestContext& testCtx)
1491 {
1492         de::MovePtr<tcu::TestCaseGroup> smokeTests      (new tcu::TestCaseGroup(testCtx, "smoke", "Smoke Tests"));
1493
1494         addFunctionCase                         (smokeTests.get(), "create_sampler",                    "",     createSamplerTest);
1495         addFunctionCaseWithPrograms     (smokeTests.get(), "create_shader",                             "", createShaderProgs,          createShaderModuleTest);
1496         addFunctionCaseWithPrograms     (smokeTests.get(), "triangle",                                  "", createTriangleProgs,        renderTriangleTest);
1497         addFunctionCaseWithPrograms     (smokeTests.get(), "asm_triangle",                              "", createTriangleAsmProgs,     renderTriangleTest);
1498         addFunctionCaseWithPrograms     (smokeTests.get(), "unused_resolve_attachment", "", createTriangleProgs,        renderTriangleUnusedResolveAttachmentTest);
1499
1500         return smokeTests.release();
1501 }
1502
1503 } // api
1504 } // vkt