external/vulkancts/modules/vulkan/geometry/vktGeometryTestsUtil.cpp

   1 /*------------------------------------------------------------------------
   2  * Vulkan Conformance Tests
   3  * ------------------------
   4  *
   5  * Copyright (c) 2014 The Android Open Source Project
   6  * Copyright (c) 2016 The Khronos Group Inc.
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *      http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  *//*!
  21  * \file
  22  * \brief Geometry Utilities
  23  *//*--------------------------------------------------------------------*/
  24
  25 #include "vktGeometryTestsUtil.hpp"
  26 #include "vkTypeUtil.hpp"
  27 #include "vkDefs.hpp"
  28 #include "tcuImageCompare.hpp"
  29
  30 #include "tcuImageIO.hpp"
  31
  32 #include "deMath.h"
  33
  34 using namespace vk;
  35
  36 namespace vkt
  37 {
  38 namespace geometry
  39 {
  40
  41 GraphicsPipelineBuilder& GraphicsPipelineBuilder::setShader (const DeviceInterface&                     vk,
  42                                                                                                                          const VkDevice                                 device,
  43                                                                                                                          const VkShaderStageFlagBits    stage,
  44                                                                                                                          const ProgramBinary&                   binary,
  45                                                                                                                          const VkSpecializationInfo*    specInfo)
  46 {
  47         VkShaderModule module;
  48         switch (stage)
  49         {
  50                 case (VK_SHADER_STAGE_VERTEX_BIT):
  51                         DE_ASSERT(m_vertexShaderModule.get() == DE_NULL);
  52                         m_vertexShaderModule = createShaderModule(vk, device, binary, (VkShaderModuleCreateFlags)0);
  53                         module = *m_vertexShaderModule;
  54                         break;
  55
  56                 case (VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT):
  57                         DE_ASSERT(m_tessControlShaderModule.get() == DE_NULL);
  58                         m_tessControlShaderModule = createShaderModule(vk, device, binary, (VkShaderModuleCreateFlags)0);
  59                         module = *m_tessControlShaderModule;
  60                         break;
  61
  62                 case (VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT):
  63                         DE_ASSERT(m_tessEvaluationShaderModule.get() == DE_NULL);
  64                         m_tessEvaluationShaderModule = createShaderModule(vk, device, binary, (VkShaderModuleCreateFlags)0);
  65                         module = *m_tessEvaluationShaderModule;
  66                         break;
  67
  68                 case (VK_SHADER_STAGE_GEOMETRY_BIT):
  69                         DE_ASSERT(m_geometryShaderModule.get() == DE_NULL);
  70                         m_geometryShaderModule = createShaderModule(vk, device, binary, (VkShaderModuleCreateFlags)0);
  71                         module = *m_geometryShaderModule;
  72                         break;
  73
  74                 case (VK_SHADER_STAGE_FRAGMENT_BIT):
  75                         DE_ASSERT(m_fragmentShaderModule.get() == DE_NULL);
  76                         m_fragmentShaderModule = createShaderModule(vk, device, binary, (VkShaderModuleCreateFlags)0);
  77                         module = *m_fragmentShaderModule;
  78                         break;
  79
  80                 default:
  81                         DE_FATAL("Invalid shader stage");
  82                         return *this;
  83         }
  84
  85         const VkPipelineShaderStageCreateInfo pipelineShaderStageInfo =
  86         {
  87                 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,    // VkStructureType                                              sType;
  88                 DE_NULL,                                                                                                // const void*                                                  pNext;
  89                 (VkPipelineShaderStageCreateFlags)0,                                    // VkPipelineShaderStageCreateFlags             flags;
  90                 stage,                                                                                                  // VkShaderStageFlagBits                                stage;
  91                 module,                                                                                                 // VkShaderModule                                               module;
  92                 "main",                                                                                                 // const char*                                                  pName;
  93                 specInfo,                                                                                               // const VkSpecializationInfo*                  pSpecializationInfo;
  94         };
  95
  96         m_shaderStageFlags |= stage;
  97         m_shaderStages.push_back(pipelineShaderStageInfo);
  98
  99         return *this;
 100 }
 101
 102 GraphicsPipelineBuilder& GraphicsPipelineBuilder::setVertexInputSingleAttribute (const VkFormat vertexFormat, const deUint32 stride)
 103 {
 104         const VkVertexInputBindingDescription bindingDesc =
 105         {
 106                 0u,                                                                     // uint32_t                             binding;
 107                 stride,                                                         // uint32_t                             stride;
 108                 VK_VERTEX_INPUT_RATE_VERTEX,            // VkVertexInputRate    inputRate;
 109         };
 110         const VkVertexInputAttributeDescription attributeDesc =
 111         {
 112                 0u,                                                                     // uint32_t                     location;
 113                 0u,                                                                     // uint32_t                     binding;
 114                 vertexFormat,                                           // VkFormat                     format;
 115                 0u,                                                                     // uint32_t                     offset;
 116         };
 117
 118         m_vertexInputBindings.clear();
 119         m_vertexInputBindings.push_back(bindingDesc);
 120
 121         m_vertexInputAttributes.clear();
 122         m_vertexInputAttributes.push_back(attributeDesc);
 123
 124         return *this;
 125 }
 126
 127 template<typename T>
 128 inline const T* dataPointer (const std::vector<T>& vec)
 129 {
 130         return (vec.size() != 0 ? &vec[0] : DE_NULL);
 131 }
 132
 133 Move<VkPipeline> GraphicsPipelineBuilder::build (const DeviceInterface& vk,
 134                                                                                                  const VkDevice                 device,
 135                                                                                                  const VkPipelineLayout pipelineLayout,
 136                                                                                                  const VkRenderPass             renderPass)
 137 {
 138         const VkPipelineVertexInputStateCreateInfo vertexInputStateInfo =
 139         {
 140                 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,              // VkStructureType                             sType;
 141                 DE_NULL,                                                                                                                // const void*                                 pNext;
 142                 (VkPipelineVertexInputStateCreateFlags)0,                                               // VkPipelineVertexInputStateCreateFlags       flags;
 143                 static_cast<deUint32>(m_vertexInputBindings.size()),                    // uint32_t                                    vertexBindingDescriptionCount;
 144                 dataPointer(m_vertexInputBindings),                                                             // const VkVertexInputBindingDescription*      pVertexBindingDescriptions;
 145                 static_cast<deUint32>(m_vertexInputAttributes.size()),                  // uint32_t                                    vertexAttributeDescriptionCount;
 146                 dataPointer(m_vertexInputAttributes),                                                   // const VkVertexInputAttributeDescription*    pVertexAttributeDescriptions;
 147         };
 148
 149         const VkPrimitiveTopology topology = (m_shaderStageFlags & VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) ? VK_PRIMITIVE_TOPOLOGY_PATCH_LIST
 150                                                                                                                                                                                                                  : m_primitiveTopology;
 151
 152         VkBool32        primitiveRestartEnable = VK_TRUE;
 153         switch(m_primitiveTopology)
 154         {
 155                 case VK_PRIMITIVE_TOPOLOGY_POINT_LIST:
 156                 case VK_PRIMITIVE_TOPOLOGY_LINE_LIST:
 157                 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST:
 158                 case VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY:
 159                 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY:
 160                 case VK_PRIMITIVE_TOPOLOGY_PATCH_LIST:
 161                         primitiveRestartEnable = VK_FALSE;
 162                         break;
 163                 default:
 164                         break;
 165         };
 166
 167         const VkPipelineInputAssemblyStateCreateInfo pipelineInputAssemblyStateInfo =
 168         {
 169                 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,    // VkStructureType                             sType;
 170                 DE_NULL,                                                                                                                // const void*                                 pNext;
 171                 (VkPipelineInputAssemblyStateCreateFlags)0,                                             // VkPipelineInputAssemblyStateCreateFlags     flags;
 172                 topology,                                                                                                               // VkPrimitiveTopology                         topology;
 173                 primitiveRestartEnable,                                                                                 // VkBool32                                    primitiveRestartEnable;
 174         };
 175
 176         const VkPipelineTessellationStateCreateInfo pipelineTessellationStateInfo =
 177         {
 178                 VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO,              // VkStructureType                             sType;
 179                 DE_NULL,                                                                                                                // const void*                                 pNext;
 180                 (VkPipelineTessellationStateCreateFlags)0,                                              // VkPipelineTessellationStateCreateFlags      flags;
 181                 m_patchControlPoints,                                                                                   // uint32_t                                    patchControlPoints;
 182         };
 183
 184         const VkViewport viewport = makeViewport(
 185                 0.0f, 0.0f,
 186                 static_cast<float>(m_renderSize.x()), static_cast<float>(m_renderSize.y()),
 187                 0.0f, 1.0f);
 188
 189         const VkRect2D scissor = {
 190                 makeOffset2D(0, 0),
 191                 makeExtent2D(m_renderSize.x(), m_renderSize.y()),
 192         };
 193
 194         const VkPipelineViewportStateCreateInfo pipelineViewportStateInfo =
 195         {
 196                 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,  // VkStructureType                             sType;
 197                 DE_NULL,                                                                                                // const void*                                 pNext;
 198                 (VkPipelineViewportStateCreateFlags)0,                                  // VkPipelineViewportStateCreateFlags          flags;
 199                 1u,                                                                                                             // uint32_t                                    viewportCount;
 200                 &viewport,                                                                                              // const VkViewport*                           pViewports;
 201                 1u,                                                                                                             // uint32_t                                    scissorCount;
 202                 &scissor,                                                                                               // const VkRect2D*                             pScissors;
 203         };
 204
 205         const bool isRasterizationDisabled = ((m_shaderStageFlags & VK_SHADER_STAGE_FRAGMENT_BIT) == 0);
 206         const VkPipelineRasterizationStateCreateInfo pipelineRasterizationStateInfo =
 207         {
 208                 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,             // VkStructureType                          sType;
 209                 DE_NULL,                                                                                                                // const void*                              pNext;
 210                 (VkPipelineRasterizationStateCreateFlags)0,                                             // VkPipelineRasterizationStateCreateFlags  flags;
 211                 VK_FALSE,                                                                                                               // VkBool32                                 depthClampEnable;
 212                 isRasterizationDisabled,                                                                                // VkBool32                                 rasterizerDiscardEnable;
 213                 VK_POLYGON_MODE_FILL,                                                                                   // VkPolygonMode                                                        polygonMode;
 214                 m_cullModeFlags,                                                                                                // VkCullModeFlags                                                      cullMode;
 215                 m_frontFace,                                                                                                    // VkFrontFace                                                          frontFace;
 216                 VK_FALSE,                                                                                                               // VkBool32                                                                     depthBiasEnable;
 217                 0.0f,                                                                                                                   // float                                                                        depthBiasConstantFactor;
 218                 0.0f,                                                                                                                   // float                                                                        depthBiasClamp;
 219                 0.0f,                                                                                                                   // float                                                                        depthBiasSlopeFactor;
 220                 1.0f,                                                                                                                   // float                                                                        lineWidth;
 221         };
 222
 223         const VkPipelineMultisampleStateCreateInfo pipelineMultisampleStateInfo =
 224         {
 225                 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,       // VkStructureType                                                      sType;
 226                 DE_NULL,                                                                                                        // const void*                                                          pNext;
 227                 (VkPipelineMultisampleStateCreateFlags)0,                                       // VkPipelineMultisampleStateCreateFlags        flags;
 228                 VK_SAMPLE_COUNT_1_BIT,                                                                          // VkSampleCountFlagBits                                        rasterizationSamples;
 229                 VK_FALSE,                                                                                                       // VkBool32                                                                     sampleShadingEnable;
 230                 0.0f,                                                                                                           // float                                                                        minSampleShading;
 231                 DE_NULL,                                                                                                        // const VkSampleMask*                                          pSampleMask;
 232                 VK_FALSE,                                                                                                       // VkBool32                                                                     alphaToCoverageEnable;
 233                 VK_FALSE                                                                                                        // VkBool32                                                                     alphaToOneEnable;
 234         };
 235
 236         const VkStencilOpState stencilOpState = makeStencilOpState(
 237                 VK_STENCIL_OP_KEEP,             // stencil fail
 238                 VK_STENCIL_OP_KEEP,             // depth & stencil pass
 239                 VK_STENCIL_OP_KEEP,             // depth only fail
 240                 VK_COMPARE_OP_NEVER,    // compare op
 241                 0u,                                             // compare mask
 242                 0u,                                             // write mask
 243                 0u);                                    // reference
 244
 245         const VkPipelineDepthStencilStateCreateInfo pipelineDepthStencilStateInfo =
 246         {
 247                 VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,     // VkStructureType                                                      sType;
 248                 DE_NULL,                                                                                                        // const void*                                                          pNext;
 249                 (VkPipelineDepthStencilStateCreateFlags)0,                                      // VkPipelineDepthStencilStateCreateFlags       flags;
 250                 VK_FALSE,                                                                                                       // VkBool32                                                                     depthTestEnable;
 251                 VK_FALSE,                                                                                                       // VkBool32                                                                     depthWriteEnable;
 252                 VK_COMPARE_OP_LESS,                                                                                     // VkCompareOp                                                          depthCompareOp;
 253                 VK_FALSE,                                                                                                       // VkBool32                                                                     depthBoundsTestEnable;
 254                 VK_FALSE,                                                                                                       // VkBool32                                                                     stencilTestEnable;
 255                 stencilOpState,                                                                                         // VkStencilOpState                                                     front;
 256                 stencilOpState,                                                                                         // VkStencilOpState                                                     back;
 257                 0.0f,                                                                                                           // float                                                                        minDepthBounds;
 258                 1.0f,                                                                                                           // float                                                                        maxDepthBounds;
 259         };
 260
 261         const VkColorComponentFlags colorComponentsAll = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
 262         const VkPipelineColorBlendAttachmentState pipelineColorBlendAttachmentState =
 263         {
 264                 m_blendEnable,                                          // VkBool32                                     blendEnable;
 265                 VK_BLEND_FACTOR_SRC_ALPHA,                      // VkBlendFactor                        srcColorBlendFactor;
 266                 VK_BLEND_FACTOR_ONE,                            // VkBlendFactor                        dstColorBlendFactor;
 267                 VK_BLEND_OP_ADD,                                        // VkBlendOp                            colorBlendOp;
 268                 VK_BLEND_FACTOR_SRC_ALPHA,                      // VkBlendFactor                        srcAlphaBlendFactor;
 269                 VK_BLEND_FACTOR_ONE,                            // VkBlendFactor                        dstAlphaBlendFactor;
 270                 VK_BLEND_OP_ADD,                                        // VkBlendOp                            alphaBlendOp;
 271                 colorComponentsAll,                                     // VkColorComponentFlags        colorWriteMask;
 272         };
 273
 274         const VkPipelineColorBlendStateCreateInfo pipelineColorBlendStateInfo =
 275         {
 276                 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,       // VkStructureType                                                              sType;
 277                 DE_NULL,                                                                                                        // const void*                                                                  pNext;
 278                 (VkPipelineColorBlendStateCreateFlags)0,                                        // VkPipelineColorBlendStateCreateFlags                 flags;
 279                 VK_FALSE,                                                                                                       // VkBool32                                                                             logicOpEnable;
 280                 VK_LOGIC_OP_COPY,                                                                                       // VkLogicOp                                                                    logicOp;
 281                 1u,                                                                                                                     // deUint32                                                                             attachmentCount;
 282                 &pipelineColorBlendAttachmentState,                                                     // const VkPipelineColorBlendAttachmentState*   pAttachments;
 283                 { 0.0f, 0.0f, 0.0f, 0.0f },                                                                     // float                                                                                blendConstants[4];
 284         };
 285
 286         const VkGraphicsPipelineCreateInfo graphicsPipelineInfo =
 287         {
 288                 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,                                                // VkStructureType                                                                      sType;
 289                 DE_NULL,                                                                                                                                // const void*                                                                          pNext;
 290                 (VkPipelineCreateFlags)0,                                                                                               // VkPipelineCreateFlags                                                        flags;
 291                 static_cast<deUint32>(m_shaderStages.size()),                                                   // deUint32                                                                                     stageCount;
 292                 &m_shaderStages[0],                                                                                                             // const VkPipelineShaderStageCreateInfo*                       pStages;
 293                 &vertexInputStateInfo,                                                                                                  // const VkPipelineVertexInputStateCreateInfo*          pVertexInputState;
 294                 &pipelineInputAssemblyStateInfo,                                                                                // const VkPipelineInputAssemblyStateCreateInfo*        pInputAssemblyState;
 295                 (m_shaderStageFlags & VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT ? &pipelineTessellationStateInfo : DE_NULL), // const VkPipelineTessellationStateCreateInfo*             pTessellationState;
 296                 (isRasterizationDisabled ? DE_NULL : &pipelineViewportStateInfo),               // const VkPipelineViewportStateCreateInfo*                     pViewportState;
 297                 &pipelineRasterizationStateInfo,                                                                                // const VkPipelineRasterizationStateCreateInfo*        pRasterizationState;
 298                 (isRasterizationDisabled ? DE_NULL : &pipelineMultisampleStateInfo),    // const VkPipelineMultisampleStateCreateInfo*          pMultisampleState;
 299                 (isRasterizationDisabled ? DE_NULL : &pipelineDepthStencilStateInfo),   // const VkPipelineDepthStencilStateCreateInfo*         pDepthStencilState;
 300                 (isRasterizationDisabled ? DE_NULL : &pipelineColorBlendStateInfo),             // const VkPipelineColorBlendStateCreateInfo*           pColorBlendState;
 301                 DE_NULL,                                                                                                                                // const VkPipelineDynamicStateCreateInfo*                      pDynamicState;
 302                 pipelineLayout,                                                                                                                 // VkPipelineLayout                                                                     layout;
 303                 renderPass,                                                                                                                             // VkRenderPass                                                                         renderPass;
 304                 0u,                                                                                                                                             // deUint32                                                                                     subpass;
 305                 DE_NULL,                                                                                                                                // VkPipeline                                                                           basePipelineHandle;
 306                 0,                                                                                                                                              // deInt32                                                                                      basePipelineIndex;
 307         };
 308
 309         return createGraphicsPipeline(vk, device, DE_NULL, &graphicsPipelineInfo);
 310 }
 311
 312 std::string inputTypeToGLString (const VkPrimitiveTopology& inputType)
 313 {
 314         switch (inputType)
 315         {
 316                 case VK_PRIMITIVE_TOPOLOGY_POINT_LIST:
 317                         return "points";
 318                 case VK_PRIMITIVE_TOPOLOGY_LINE_LIST:
 319                 case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP:
 320                         return "lines";
 321                 case VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY:
 322                 case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY:
 323                         return "lines_adjacency";
 324                 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST:
 325                 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP:
 326                 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN:
 327                         return "triangles";
 328                 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY:
 329                 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY:
 330                         return "triangles_adjacency";
 331                 default:
 332                         DE_ASSERT(DE_FALSE);
 333                         return "error";
 334         }
 335 }
 336
 337 std::string outputTypeToGLString (const VkPrimitiveTopology& outputType)
 338 {
 339         switch (outputType)
 340         {
 341                 case VK_PRIMITIVE_TOPOLOGY_POINT_LIST:
 342                         return "points";
 343                 case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP:
 344                 case VK_PRIMITIVE_TOPOLOGY_LINE_LIST:
 345                                 return "line_strip";
 346                 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP:
 347                 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST:
 348                         return "triangle_strip";
 349                 default:
 350                         DE_ASSERT(DE_FALSE);
 351                         return "error";
 352         }
 353 }
 354
 355 size_t calcOutputVertices (const VkPrimitiveTopology&  inputType)
 356 {
 357         switch (inputType)
 358         {
 359                 case VK_PRIMITIVE_TOPOLOGY_POINT_LIST:
 360                         return 1 * 3;
 361                 case VK_PRIMITIVE_TOPOLOGY_LINE_LIST:
 362                 case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP:
 363                         return 2 * 3;
 364                 case VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY:
 365                 case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY:
 366                         return 4 * 3;
 367                 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST:
 368                 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP:
 369                 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN:
 370                         return 3 * 3;
 371                 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY:
 372                 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY:
 373                         return 6 * 3;
 374                 default:
 375                         DE_ASSERT(DE_FALSE);
 376                         return 0;
 377         }
 378 }
 379
 380 VkBufferCreateInfo makeBufferCreateInfo (const VkDeviceSize                     bufferSize,
 381                                                                                  const VkBufferUsageFlags       usage)
 382 {
 383         const VkBufferCreateInfo bufferCreateInfo =
 384         {
 385                 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,   // VkStructureType              sType;
 386                 DE_NULL,                                                                // const void*                  pNext;
 387                 (VkBufferCreateFlags)0,                                 // VkBufferCreateFlags  flags;
 388                 bufferSize,                                                             // VkDeviceSize                 size;
 389                 usage,                                                                  // VkBufferUsageFlags   usage;
 390                 VK_SHARING_MODE_EXCLUSIVE,                              // VkSharingMode                sharingMode;
 391                 0u,                                                                             // deUint32                             queueFamilyIndexCount;
 392                 DE_NULL,                                                                // const deUint32*              pQueueFamilyIndices;
 393         };
 394         return bufferCreateInfo;
 395 }
 396
 397 VkImageCreateInfo makeImageCreateInfo (const tcu::IVec2& size, const VkFormat format, const VkImageUsageFlags usage, const deUint32 numArrayLayers)
 398 {
 399         const VkImageCreateInfo imageInfo =
 400         {
 401                 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,            // VkStructureType          sType;
 402                 DE_NULL,                                                                        // const void*              pNext;
 403                 (VkImageCreateFlags)0,                                          // VkImageCreateFlags       flags;
 404                 VK_IMAGE_TYPE_2D,                                                       // VkImageType              imageType;
 405                 format,                                                                         // VkFormat                 format;
 406                 makeExtent3D(size.x(), size.y(), 1),            // VkExtent3D               extent;
 407                 1u,                                                                                     // uint32_t                 mipLevels;
 408                 numArrayLayers,                                                         // uint32_t                 arrayLayers;
 409                 VK_SAMPLE_COUNT_1_BIT,                                          // VkSampleCountFlagBits    samples;
 410                 VK_IMAGE_TILING_OPTIMAL,                                        // VkImageTiling            tiling;
 411                 usage,                                                                          // VkImageUsageFlags        usage;
 412                 VK_SHARING_MODE_EXCLUSIVE,                                      // VkSharingMode            sharingMode;
 413                 0u,                                                                                     // uint32_t                 queueFamilyIndexCount;
 414                 DE_NULL,                                                                        // const uint32_t*          pQueueFamilyIndices;
 415                 VK_IMAGE_LAYOUT_UNDEFINED,                                      // VkImageLayout            initialLayout;
 416         };
 417         return imageInfo;
 418 }
 419
 420 Move<VkDescriptorSet> makeDescriptorSet (const DeviceInterface&                 vk,
 421                                                                                  const VkDevice                                 device,
 422                                                                                  const VkDescriptorPool                 descriptorPool,
 423                                                                                  const VkDescriptorSetLayout    setLayout)
 424 {
 425         const VkDescriptorSetAllocateInfo info =
 426         {
 427                 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,         // VkStructureType                              sType;
 428                 DE_NULL,                                                                                        // const void*                                  pNext;
 429                 descriptorPool,                                                                         // VkDescriptorPool                             descriptorPool;
 430                 1u,                                                                                                     // deUint32                                             descriptorSetCount;
 431                 &setLayout,                                                                                     // const VkDescriptorSetLayout* pSetLayouts;
 432         };
 433         return allocateDescriptorSet(vk, device, &info);
 434 }
 435
 436 Move<VkRenderPass> makeRenderPass (const DeviceInterface& vk, const VkDevice device, const VkFormat colorFormat)
 437 {
 438         const VkAttachmentDescription colorAttachmentDescription =
 439         {
 440                 (VkAttachmentDescriptionFlags)0,                                // VkAttachmentDescriptionFlags         flags;
 441                 colorFormat,                                                                    // VkFormat                                                     format;
 442                 VK_SAMPLE_COUNT_1_BIT,                                                  // VkSampleCountFlagBits                        samples;
 443                 VK_ATTACHMENT_LOAD_OP_CLEAR,                                    // VkAttachmentLoadOp                           loadOp;
 444                 VK_ATTACHMENT_STORE_OP_STORE,                                   // VkAttachmentStoreOp                          storeOp;
 445                 VK_ATTACHMENT_LOAD_OP_DONT_CARE,                                // VkAttachmentLoadOp                           stencilLoadOp;
 446                 VK_ATTACHMENT_STORE_OP_DONT_CARE,                               // VkAttachmentStoreOp                          stencilStoreOp;
 447                 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,               // VkImageLayout                                        initialLayout;
 448                 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL                // VkImageLayout                                        finalLayout;
 449         };
 450
 451         const VkAttachmentReference colorAttachmentReference =
 452         {
 453                 0u,                                                                                             // deUint32                     attachment;
 454                 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL                // VkImageLayout        layout;
 455         };
 456
 457         const VkAttachmentReference depthAttachmentReference =
 458         {
 459                 VK_ATTACHMENT_UNUSED,                                                   // deUint32                     attachment;
 460                 VK_IMAGE_LAYOUT_UNDEFINED                                               // VkImageLayout        layout;
 461         };
 462
 463         const VkSubpassDescription subpassDescription =
 464         {
 465                 (VkSubpassDescriptionFlags)0,                                   // VkSubpassDescriptionFlags            flags;
 466                 VK_PIPELINE_BIND_POINT_GRAPHICS,                                // VkPipelineBindPoint                          pipelineBindPoint;
 467                 0u,                                                                                             // deUint32                                                     inputAttachmentCount;
 468                 DE_NULL,                                                                                // const VkAttachmentReference*         pInputAttachments;
 469                 1u,                                                                                             // deUint32                                                     colorAttachmentCount;
 470                 &colorAttachmentReference,                                              // const VkAttachmentReference*         pColorAttachments;
 471                 DE_NULL,                                                                                // const VkAttachmentReference*         pResolveAttachments;
 472                 &depthAttachmentReference,                                              // const VkAttachmentReference*         pDepthStencilAttachment;
 473                 0u,                                                                                             // deUint32                                                     preserveAttachmentCount;
 474                 DE_NULL                                                                                 // const deUint32*                                      pPreserveAttachments;
 475         };
 476
 477         const VkRenderPassCreateInfo renderPassInfo =
 478         {
 479                 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,              // VkStructureType                                      sType;
 480                 DE_NULL,                                                                                // const void*                                          pNext;
 481                 (VkRenderPassCreateFlags)0,                                             // VkRenderPassCreateFlags                      flags;
 482                 1u,                                                                                             // deUint32                                                     attachmentCount;
 483                 &colorAttachmentDescription,                                    // const VkAttachmentDescription*       pAttachments;
 484                 1u,                                                                                             // deUint32                                                     subpassCount;
 485                 &subpassDescription,                                                    // const VkSubpassDescription*          pSubpasses;
 486                 0u,                                                                                             // deUint32                                                     dependencyCount;
 487                 DE_NULL                                                                                 // const VkSubpassDependency*           pDependencies;
 488         };
 489
 490         return createRenderPass(vk, device, &renderPassInfo);
 491 }
 492
 493 Move<VkImageView> makeImageView (const DeviceInterface&                 vk,
 494                                                                  const VkDevice                                 vkDevice,
 495                                                                  const VkImage                                  image,
 496                                                                  const VkImageViewType                  viewType,
 497                                                                  const VkFormat                                 format,
 498                                                                  const VkImageSubresourceRange  subresourceRange)
 499 {
 500         const VkImageViewCreateInfo imageViewParams =
 501         {
 502                 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,       // VkStructureType                      sType;
 503                 DE_NULL,                                                                        // const void*                          pNext;
 504                 (VkImageViewCreateFlags)0,                                      // VkImageViewCreateFlags       flags;
 505                 image,                                                                          // VkImage                                      image;
 506                 viewType,                                                                       // VkImageViewType                      viewType;
 507                 format,                                                                         // VkFormat                                     format;
 508                 makeComponentMappingRGBA(),                                     // VkComponentMapping           components;
 509                 subresourceRange,                                                       // VkImageSubresourceRange      subresourceRange;
 510         };
 511         return createImageView(vk, vkDevice, &imageViewParams);
 512 }
 513
 514 VkBufferImageCopy makeBufferImageCopy (const VkExtent3D                                 extent,
 515                                                                            const VkImageSubresourceLayers       subresourceLayers)
 516 {
 517         const VkBufferImageCopy copyParams =
 518         {
 519                 0ull,                                                                           //      VkDeviceSize                            bufferOffset;
 520                 0u,                                                                                     //      deUint32                                        bufferRowLength;
 521                 0u,                                                                                     //      deUint32                                        bufferImageHeight;
 522                 subresourceLayers,                                                      //      VkImageSubresourceLayers        imageSubresource;
 523                 makeOffset3D(0, 0, 0),                                          //      VkOffset3D                                      imageOffset;
 524                 extent,                                                                         //      VkExtent3D                                      imageExtent;
 525         };
 526         return copyParams;
 527 }
 528
 529 Move<VkPipelineLayout> makePipelineLayout (const DeviceInterface&               vk,
 530                                                                                    const VkDevice                               device,
 531                                                                                    const VkDescriptorSetLayout  descriptorSetLayout)
 532 {
 533         const VkPipelineLayoutCreateInfo info =
 534         {
 535                 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,                                                  // VkStructureType                              sType;
 536                 DE_NULL,                                                                                                                                // const void*                                  pNext;
 537                 (VkPipelineLayoutCreateFlags)0,                                                                                 // VkPipelineLayoutCreateFlags  flags;
 538                 (descriptorSetLayout != DE_NULL ? 1u : 0u),                                                             // deUint32                                             setLayoutCount;
 539                 (descriptorSetLayout != DE_NULL ? &descriptorSetLayout : DE_NULL),              // const VkDescriptorSetLayout* pSetLayouts;
 540                 0u,                                                                                                                                             // deUint32                                             pushConstantRangeCount;
 541                 DE_NULL,                                                                                                                                // const VkPushConstantRange*   pPushConstantRanges;
 542         };
 543         return createPipelineLayout(vk, device, &info);
 544 }
 545
 546 Move<VkFramebuffer> makeFramebuffer (const DeviceInterface&     vk,
 547                                                                          const VkDevice                 device,
 548                                                                          const VkRenderPass             renderPass,
 549                                                                          const VkImageView              colorAttachment,
 550                                                                          const deUint32                 width,
 551                                                                          const deUint32                 height,
 552                                                                          const deUint32                 layers)
 553 {
 554         const VkFramebufferCreateInfo framebufferInfo = {
 555                 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,              // VkStructureType                             sType;
 556                 DE_NULL,                                                                                // const void*                                 pNext;
 557                 (VkFramebufferCreateFlags)0,                                    // VkFramebufferCreateFlags                    flags;
 558                 renderPass,                                                                             // VkRenderPass                                renderPass;
 559                 1u,                                                                                             // uint32_t                                    attachmentCount;
 560                 &colorAttachment,                                                               // const VkImageView*                          pAttachments;
 561                 width,                                                                                  // uint32_t                                    width;
 562                 height,                                                                                 // uint32_t                                    height;
 563                 layers,                                                                                 // uint32_t                                    layers;
 564         };
 565
 566         return createFramebuffer(vk, device, &framebufferInfo);
 567 }
 568
 569 VkImageMemoryBarrier makeImageMemoryBarrier     (const VkAccessFlags                    srcAccessMask,
 570                                                                                          const VkAccessFlags                    dstAccessMask,
 571                                                                                          const VkImageLayout                    oldLayout,
 572                                                                                          const VkImageLayout                    newLayout,
 573                                                                                          const VkImage                                  image,
 574                                                                                          const VkImageSubresourceRange  subresourceRange)
 575 {
 576         const VkImageMemoryBarrier barrier =
 577         {
 578                 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,                 // VkStructureType                      sType;
 579                 DE_NULL,                                                                                // const void*                          pNext;
 580                 srcAccessMask,                                                                  // VkAccessFlags                        outputMask;
 581                 dstAccessMask,                                                                  // VkAccessFlags                        inputMask;
 582                 oldLayout,                                                                              // VkImageLayout                        oldLayout;
 583                 newLayout,                                                                              // VkImageLayout                        newLayout;
 584                 VK_QUEUE_FAMILY_IGNORED,                                                // deUint32                                     srcQueueFamilyIndex;
 585                 VK_QUEUE_FAMILY_IGNORED,                                                // deUint32                                     destQueueFamilyIndex;
 586                 image,                                                                                  // VkImage                                      image;
 587                 subresourceRange,                                                               // VkImageSubresourceRange      subresourceRange;
 588         };
 589         return barrier;
 590 }
 591
 592 VkBufferMemoryBarrier makeBufferMemoryBarrier (const VkAccessFlags      srcAccessMask,
 593                                                                                            const VkAccessFlags  dstAccessMask,
 594                                                                                            const VkBuffer               buffer,
 595                                                                                            const VkDeviceSize   offset,
 596                                                                                            const VkDeviceSize   bufferSizeBytes)
 597 {
 598         const VkBufferMemoryBarrier barrier =
 599         {
 600                 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,        // VkStructureType      sType;
 601                 DE_NULL,                                                                        // const void*          pNext;
 602                 srcAccessMask,                                                          // VkAccessFlags        srcAccessMask;
 603                 dstAccessMask,                                                          // VkAccessFlags        dstAccessMask;
 604                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                     srcQueueFamilyIndex;
 605                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                     destQueueFamilyIndex;
 606                 buffer,                                                                         // VkBuffer                     buffer;
 607                 offset,                                                                         // VkDeviceSize         offset;
 608                 bufferSizeBytes,                                                        // VkDeviceSize         size;
 609         };
 610         return barrier;
 611 }
 612
 613 void beginRenderPass (const DeviceInterface&    vk,
 614                                           const VkCommandBuffer         commandBuffer,
 615                                           const VkRenderPass            renderPass,
 616                                           const VkFramebuffer           framebuffer,
 617                                           const VkRect2D&                       renderArea,
 618                                           const tcu::Vec4&                      clearColor)
 619 {
 620         const VkClearValue clearValue = makeClearValueColor(clearColor);
 621
 622         const VkRenderPassBeginInfo renderPassBeginInfo = {
 623                 VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,               // VkStructureType         sType;
 624                 DE_NULL,                                                                                // const void*             pNext;
 625                 renderPass,                                                                             // VkRenderPass            renderPass;
 626                 framebuffer,                                                                    // VkFramebuffer           framebuffer;
 627                 renderArea,                                                                             // VkRect2D                renderArea;
 628                 1u,                                                                                             // uint32_t                clearValueCount;
 629                 &clearValue,                                                                    // const VkClearValue*     pClearValues;
 630         };
 631
 632         vk.cmdBeginRenderPass(commandBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
 633 }
 634
 635 void endRenderPass (const DeviceInterface&      vk,
 636                                         const VkCommandBuffer   commandBuffer)
 637 {
 638         vk.cmdEndRenderPass(commandBuffer);
 639 }
 640
 641 void beginCommandBuffer (const DeviceInterface& vk, const VkCommandBuffer commandBuffer)
 642 {
 643         const VkCommandBufferBeginInfo info =
 644         {
 645                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,    // VkStructureType                          sType;
 646                 DE_NULL,                                                                                // const void*                              pNext;
 647                 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,    // VkCommandBufferUsageFlags                flags;
 648                 DE_NULL,                                                                                // const VkCommandBufferInheritanceInfo*    pInheritanceInfo;
 649         };
 650         VK_CHECK(vk.beginCommandBuffer(commandBuffer, &info));
 651 }
 652
 653 void endCommandBuffer (const DeviceInterface& vk, const VkCommandBuffer commandBuffer)
 654 {
 655         VK_CHECK(vk.endCommandBuffer(commandBuffer));
 656 }
 657
 658 void submitCommandsAndWait (const DeviceInterface&      vk,
 659                                                         const VkDevice                  device,
 660                                                         const VkQueue                   queue,
 661                                                         const VkCommandBuffer   commandBuffer)
 662 {
 663         const Unique<VkFence> fence(createFence(vk, device));
 664
 665         const VkSubmitInfo submitInfo =
 666         {
 667                 VK_STRUCTURE_TYPE_SUBMIT_INFO,          // VkStructureType                sType;
 668                 DE_NULL,                                                        // const void*                    pNext;
 669                 0u,                                                                     // uint32_t                       waitSemaphoreCount;
 670                 DE_NULL,                                                        // const VkSemaphore*             pWaitSemaphores;
 671                 DE_NULL,                                                        // const VkPipelineStageFlags*    pWaitDstStageMask;
 672                 1u,                                                                     // uint32_t                       commandBufferCount;
 673                 &commandBuffer,                                         // const VkCommandBuffer*         pCommandBuffers;
 674                 0u,                                                                     // uint32_t                       signalSemaphoreCount;
 675                 DE_NULL,                                                        // const VkSemaphore*             pSignalSemaphores;
 676         };
 677         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
 678         VK_CHECK(vk.waitForFences(device, 1u, &fence.get(), DE_TRUE, ~0ull));
 679 }
 680
 681 bool compareWithFileImage (Context& context, const tcu::ConstPixelBufferAccess& resultImage, std::string testName)
 682 {
 683         tcu::TextureLevel referenceImage;
 684         std::string fileName="vulkan/data/geometry/"+testName+".png";
 685         tcu::ImageIO::loadPNG(referenceImage, context.getTestContext().getArchive(), fileName.c_str());
 686
 687         if (tcu::fuzzyCompare(context.getTestContext().getLog(), "ImageComparison", "Image Comparison",
 688                                                                 referenceImage.getAccess(), resultImage, 0.001f, tcu::COMPARE_LOG_RESULT))
 689                 return tcu::intThresholdPositionDeviationCompare(context.getTestContext().getLog(), "ImageComparison", "Image Comparison",
 690                                                                                                                 referenceImage.getAccess(), resultImage, tcu::UVec4(1u, 1u, 1u, 1u), tcu::IVec3(2,2,2), false, tcu::COMPARE_LOG_RESULT);
 691         else
 692                 return false;
 693 }
 694
 695 de::MovePtr<Allocation> bindImage (const DeviceInterface& vk, const VkDevice device, Allocator& allocator, const VkImage image, const MemoryRequirement requirement)
 696 {
 697         de::MovePtr<Allocation> alloc = allocator.allocate(getImageMemoryRequirements(vk, device, image), requirement);
 698         VK_CHECK(vk.bindImageMemory(device, image, alloc->getMemory(), alloc->getOffset()));
 699         return alloc;
 700 }
 701
 702 de::MovePtr<Allocation> bindBuffer (const DeviceInterface& vk, const VkDevice device, Allocator& allocator, const VkBuffer buffer, const MemoryRequirement requirement)
 703 {
 704         de::MovePtr<Allocation> alloc(allocator.allocate(getBufferMemoryRequirements(vk, device, buffer), requirement));
 705         VK_CHECK(vk.bindBufferMemory(device, buffer, alloc->getMemory(), alloc->getOffset()));
 706         return alloc;
 707 }
 708
 709 void zeroBuffer (const DeviceInterface& vk, const VkDevice device, const Allocation& alloc, const VkDeviceSize size)
 710 {
 711         deMemset(alloc.getHostPtr(), 0, static_cast<std::size_t>(size));
 712         flushMappedMemoryRange(vk, device, alloc.getMemory(), alloc.getOffset(), size);
 713 }
 714
 715 VkBool32 checkPointSize (const InstanceInterface& vki, const VkPhysicalDevice physDevice)
 716 {
 717         const VkPhysicalDeviceFeatures  features        = getPhysicalDeviceFeatures  (vki, physDevice);
 718         return features.shaderTessellationAndGeometryPointSize;
 719 }
 720
 721 void checkGeometryShaderSupport (const InstanceInterface& vki, const VkPhysicalDevice physDevice, const int numGeometryShaderInvocations)
 722 {
 723         const VkPhysicalDeviceFeatures  features        = getPhysicalDeviceFeatures  (vki, physDevice);
 724         const VkPhysicalDeviceLimits    limits          = getPhysicalDeviceProperties(vki, physDevice).limits;
 725
 726         if (!features.geometryShader)
 727                 TCU_THROW(NotSupportedError, "Missing feature: geometryShader");
 728
 729         if (numGeometryShaderInvocations != 0 && limits.maxGeometryShaderInvocations < static_cast<deUint32>(numGeometryShaderInvocations))
 730                 TCU_THROW(NotSupportedError, ("Unsupported limit: maxGeometryShaderInvocations < " + de::toString(numGeometryShaderInvocations)).c_str());
 731 }
 732
 733 } //geometry
 734 } //vkt