external/vulkancts/modules/vulkan/fragment_ops/vktFragmentOperationsScissorMultiViewportTests.cpp

   1 /*------------------------------------------------------------------------
   2  * Vulkan Conformance Tests
   3  * ------------------------
   4  *
   5  * Copyright (c) 2016 The Khronos Group Inc.
   6  * Copyright (c) 2014 The Android Open Source Project
   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 Scissor multi viewport tests
  23  *//*--------------------------------------------------------------------*/
  24
  25 #include "vktFragmentOperationsScissorMultiViewportTests.hpp"
  26 #include "vktTestCaseUtil.hpp"
  27 #include "vktFragmentOperationsMakeUtil.hpp"
  28
  29 #include "vkDefs.hpp"
  30 #include "vkRefUtil.hpp"
  31 #include "vkTypeUtil.hpp"
  32 #include "vkMemUtil.hpp"
  33 #include "vkPrograms.hpp"
  34 #include "vkImageUtil.hpp"
  35 #include "vkQueryUtil.hpp"
  36
  37 #include "tcuTestLog.hpp"
  38 #include "tcuVector.hpp"
  39 #include "tcuImageCompare.hpp"
  40 #include "tcuTextureUtil.hpp"
  41
  42 #include "deUniquePtr.hpp"
  43 #include "deMath.h"
  44
  45 namespace vkt
  46 {
  47 namespace FragmentOperations
  48 {
  49 using namespace vk;
  50 using de::UniquePtr;
  51 using de::MovePtr;
  52 using tcu::Vec4;
  53 using tcu::Vec2;
  54 using tcu::IVec2;
  55 using tcu::IVec4;
  56
  57 namespace
  58 {
  59
  60 enum Constants
  61 {
  62         MIN_MAX_VIEWPORTS = 16,         //!< Minimum number of viewports for an implementation supporting multiViewport.
  63 };
  64
  65 template<typename T>
  66 inline VkDeviceSize sizeInBytes(const std::vector<T>& vec)
  67 {
  68         return vec.size() * sizeof(vec[0]);
  69 }
  70
  71 VkImageCreateInfo makeImageCreateInfo (const VkFormat format, const IVec2& size, VkImageUsageFlags usage)
  72 {
  73         const VkImageCreateInfo imageParams =
  74         {
  75                 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,                    // VkStructureType                      sType;
  76                 DE_NULL,                                                                                // const void*                          pNext;
  77                 (VkImageCreateFlags)0,                                                  // VkImageCreateFlags           flags;
  78                 VK_IMAGE_TYPE_2D,                                                               // VkImageType                          imageType;
  79                 format,                                                                                 // VkFormat                                     format;
  80                 makeExtent3D(size.x(), size.y(), 1),                    // VkExtent3D                           extent;
  81                 1u,                                                                                             // deUint32                                     mipLevels;
  82                 1u,                                                                                             // deUint32                                     arrayLayers;
  83                 VK_SAMPLE_COUNT_1_BIT,                                                  // VkSampleCountFlagBits        samples;
  84                 VK_IMAGE_TILING_OPTIMAL,                                                // VkImageTiling                        tiling;
  85                 usage,                                                                                  // VkImageUsageFlags            usage;
  86                 VK_SHARING_MODE_EXCLUSIVE,                                              // VkSharingMode                        sharingMode;
  87                 0u,                                                                                             // deUint32                                     queueFamilyIndexCount;
  88                 DE_NULL,                                                                                // const deUint32*                      pQueueFamilyIndices;
  89                 VK_IMAGE_LAYOUT_UNDEFINED,                                              // VkImageLayout                        initialLayout;
  90         };
  91         return imageParams;
  92 }
  93
  94 //! A single-attachment, single-subpass render pass.
  95 Move<VkRenderPass> makeRenderPass (const DeviceInterface&       vk,
  96                                                                    const VkDevice                       device,
  97                                                                    const VkFormat                       colorFormat)
  98 {
  99         const VkAttachmentDescription colorAttachmentDescription =
 100         {
 101                 (VkAttachmentDescriptionFlags)0,                                        // VkAttachmentDescriptionFlags         flags;
 102                 colorFormat,                                                                            // VkFormat                                                     format;
 103                 VK_SAMPLE_COUNT_1_BIT,                                                          // VkSampleCountFlagBits                        samples;
 104                 VK_ATTACHMENT_LOAD_OP_CLEAR,                                            // VkAttachmentLoadOp                           loadOp;
 105                 VK_ATTACHMENT_STORE_OP_STORE,                                           // VkAttachmentStoreOp                          storeOp;
 106                 VK_ATTACHMENT_LOAD_OP_DONT_CARE,                                        // VkAttachmentLoadOp                           stencilLoadOp;
 107                 VK_ATTACHMENT_STORE_OP_DONT_CARE,                                       // VkAttachmentStoreOp                          stencilStoreOp;
 108                 VK_IMAGE_LAYOUT_UNDEFINED,                                                      // VkImageLayout                                        initialLayout;
 109                 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,                       // VkImageLayout                                        finalLayout;
 110         };
 111
 112         const VkAttachmentReference colorAttachmentRef =
 113         {
 114                 0u,                                                                                                     // deUint32                     attachment;
 115                 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL                        // VkImageLayout        layout;
 116         };
 117
 118         const VkSubpassDescription subpassDescription =
 119         {
 120                 (VkSubpassDescriptionFlags)0,                                           // VkSubpassDescriptionFlags            flags;
 121                 VK_PIPELINE_BIND_POINT_GRAPHICS,                                        // VkPipelineBindPoint                          pipelineBindPoint;
 122                 0u,                                                                                                     // deUint32                                                     inputAttachmentCount;
 123                 DE_NULL,                                                                                        // const VkAttachmentReference*         pInputAttachments;
 124                 1u,                                                                                                     // deUint32                                                     colorAttachmentCount;
 125                 &colorAttachmentRef,                                                            // const VkAttachmentReference*         pColorAttachments;
 126                 DE_NULL,                                                                                        // const VkAttachmentReference*         pResolveAttachments;
 127                 DE_NULL,                                                                                        // const VkAttachmentReference*         pDepthStencilAttachment;
 128                 0u,                                                                                                     // deUint32                                                     preserveAttachmentCount;
 129                 DE_NULL                                                                                         // const deUint32*                                      pPreserveAttachments;
 130         };
 131
 132         const VkRenderPassCreateInfo renderPassInfo =
 133         {
 134                 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,                      // VkStructureType                                      sType;
 135                 DE_NULL,                                                                                        // const void*                                          pNext;
 136                 (VkRenderPassCreateFlags)0,                                                     // VkRenderPassCreateFlags                      flags;
 137                 1u,                                                                                                     // deUint32                                                     attachmentCount;
 138                 &colorAttachmentDescription,                                            // const VkAttachmentDescription*       pAttachments;
 139                 1u,                                                                                                     // deUint32                                                     subpassCount;
 140                 &subpassDescription,                                                            // const VkSubpassDescription*          pSubpasses;
 141                 0u,                                                                                                     // deUint32                                                     dependencyCount;
 142                 DE_NULL                                                                                         // const VkSubpassDependency*           pDependencies;
 143         };
 144
 145         return createRenderPass(vk, device, &renderPassInfo);
 146 }
 147
 148 Move<VkPipeline> makeGraphicsPipeline (const DeviceInterface&           vk,
 149                                                                            const VkDevice                               device,
 150                                                                            const VkPipelineLayout               pipelineLayout,
 151                                                                            const VkRenderPass                   renderPass,
 152                                                                            const VkShaderModule                 vertexModule,
 153                                                                            const VkShaderModule                 geometryModule,
 154                                                                            const VkShaderModule                 fragmentModule,
 155                                                                            const IVec2                                  renderSize,
 156                                                                            const int                                    numViewports,
 157                                                                            const std::vector<IVec4>             scissors)
 158 {
 159         const VkVertexInputBindingDescription vertexInputBindingDescription =
 160         {
 161                 0u,                                                             // uint32_t                             binding;
 162                 sizeof(Vec4),                                   // uint32_t                             stride;
 163                 VK_VERTEX_INPUT_RATE_VERTEX,    // VkVertexInputRate    inputRate;
 164         };
 165
 166         const VkVertexInputAttributeDescription vertexInputAttributeDescriptions[] =
 167         {
 168                 {
 169                         0u,                                                                     // uint32_t                     location;
 170                         0u,                                                                     // uint32_t                     binding;
 171                         VK_FORMAT_R32G32B32A32_SFLOAT,          // VkFormat                     format;
 172                         0u,                                                                     // uint32_t                     offset;
 173                 },
 174         };
 175
 176         const VkPipelineVertexInputStateCreateInfo vertexInputStateInfo =
 177         {
 178                 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,              // VkStructureType                             sType;
 179                 DE_NULL,                                                                                                                // const void*                                 pNext;
 180                 (VkPipelineVertexInputStateCreateFlags)0,                                               // VkPipelineVertexInputStateCreateFlags       flags;
 181                 1u,                                                                                                                             // uint32_t                                    vertexBindingDescriptionCount;
 182                 &vertexInputBindingDescription,                                                                 // const VkVertexInputBindingDescription*      pVertexBindingDescriptions;
 183                 DE_LENGTH_OF_ARRAY(vertexInputAttributeDescriptions),                   // uint32_t                                    vertexAttributeDescriptionCount;
 184                 vertexInputAttributeDescriptions,                                                               // const VkVertexInputAttributeDescription*    pVertexAttributeDescriptions;
 185         };
 186
 187         const VkPipelineInputAssemblyStateCreateInfo pipelineInputAssemblyStateInfo =
 188         {
 189                 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,    // VkStructureType                             sType;
 190                 DE_NULL,                                                                                                                // const void*                                 pNext;
 191                 (VkPipelineInputAssemblyStateCreateFlags)0,                                             // VkPipelineInputAssemblyStateCreateFlags     flags;
 192                 VK_PRIMITIVE_TOPOLOGY_POINT_LIST,                                                               // VkPrimitiveTopology                         topology;
 193                 VK_FALSE,                                                                                                               // VkBool32                                    primitiveRestartEnable;
 194         };
 195
 196         const VkViewport defaultViewport = makeViewport(
 197                 0.0f, 0.0f,
 198                 static_cast<float>(renderSize.x()), static_cast<float>(renderSize.y()),
 199                 0.0f, 1.0f);
 200         const std::vector<VkViewport> viewports(numViewports, defaultViewport);
 201
 202         DE_ASSERT(numViewports == static_cast<int>(scissors.size()));
 203
 204         std::vector<VkRect2D> rectScissors;
 205         rectScissors.reserve(numViewports);
 206
 207         for (std::vector<IVec4>::const_iterator it = scissors.begin(); it != scissors.end(); ++it)
 208         {
 209                 const VkRect2D rect =
 210                 {
 211                         makeOffset2D(it->x(), it->y()),
 212                         makeExtent2D(static_cast<deUint32>(it->z()), static_cast<deUint32>(it->w())),
 213                 };
 214                 rectScissors.push_back(rect);
 215         }
 216
 217         const VkPipelineViewportStateCreateInfo pipelineViewportStateInfo =
 218         {
 219                 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,                  // VkStructureType                             sType;
 220                 DE_NULL,                                                                                                                // const void*                                 pNext;
 221                 (VkPipelineViewportStateCreateFlags)0,                                                  // VkPipelineViewportStateCreateFlags          flags;
 222                 static_cast<deUint32>(numViewports),                                                    // uint32_t                                    viewportCount;
 223                 &viewports[0],                                                                                                  // const VkViewport*                           pViewports;
 224                 static_cast<deUint32>(numViewports),                                                    // uint32_t                                    scissorCount;
 225                 &rectScissors[0],                                                                                               // const VkRect2D*                             pScissors;
 226         };
 227
 228         const VkPipelineRasterizationStateCreateInfo pipelineRasterizationStateInfo =
 229         {
 230                 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,             // VkStructureType                          sType;
 231                 DE_NULL,                                                                                                                // const void*                              pNext;
 232                 (VkPipelineRasterizationStateCreateFlags)0,                                             // VkPipelineRasterizationStateCreateFlags  flags;
 233                 VK_FALSE,                                                                                                               // VkBool32                                 depthClampEnable;
 234                 VK_FALSE,                                                                                                               // VkBool32                                 rasterizerDiscardEnable;
 235                 VK_POLYGON_MODE_FILL,                                                                                   // VkPolygonMode                                                        polygonMode;
 236                 VK_CULL_MODE_NONE,                                                                                              // VkCullModeFlags                                                      cullMode;
 237                 VK_FRONT_FACE_COUNTER_CLOCKWISE,                                                                // VkFrontFace                                                          frontFace;
 238                 VK_FALSE,                                                                                                               // VkBool32                                                                     depthBiasEnable;
 239                 0.0f,                                                                                                                   // float                                                                        depthBiasConstantFactor;
 240                 0.0f,                                                                                                                   // float                                                                        depthBiasClamp;
 241                 0.0f,                                                                                                                   // float                                                                        depthBiasSlopeFactor;
 242                 1.0f,                                                                                                                   // float                                                                        lineWidth;
 243         };
 244
 245         const VkPipelineMultisampleStateCreateInfo pipelineMultisampleStateInfo =
 246         {
 247                 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,               // VkStructureType                                                      sType;
 248                 DE_NULL,                                                                                                                // const void*                                                          pNext;
 249                 (VkPipelineMultisampleStateCreateFlags)0,                                               // VkPipelineMultisampleStateCreateFlags        flags;
 250                 VK_SAMPLE_COUNT_1_BIT,                                                                                  // VkSampleCountFlagBits                                        rasterizationSamples;
 251                 VK_FALSE,                                                                                                               // VkBool32                                                                     sampleShadingEnable;
 252                 0.0f,                                                                                                                   // float                                                                        minSampleShading;
 253                 DE_NULL,                                                                                                                // const VkSampleMask*                                          pSampleMask;
 254                 VK_FALSE,                                                                                                               // VkBool32                                                                     alphaToCoverageEnable;
 255                 VK_FALSE                                                                                                                // VkBool32                                                                     alphaToOneEnable;
 256         };
 257
 258         const VkStencilOpState stencilOpState = makeStencilOpState(
 259                 VK_STENCIL_OP_KEEP,                             // stencil fail
 260                 VK_STENCIL_OP_KEEP,                             // depth & stencil pass
 261                 VK_STENCIL_OP_KEEP,                             // depth only fail
 262                 VK_COMPARE_OP_ALWAYS,                   // compare op
 263                 0u,                                                             // compare mask
 264                 0u,                                                             // write mask
 265                 0u);                                                    // reference
 266
 267         VkPipelineDepthStencilStateCreateInfo pipelineDepthStencilStateInfo =
 268         {
 269                 VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,             // VkStructureType                                                      sType;
 270                 DE_NULL,                                                                                                                // const void*                                                          pNext;
 271                 (VkPipelineDepthStencilStateCreateFlags)0,                                              // VkPipelineDepthStencilStateCreateFlags       flags;
 272                 VK_FALSE,                                                                                                               // VkBool32                                                                     depthTestEnable;
 273                 VK_FALSE,                                                                                                               // VkBool32                                                                     depthWriteEnable;
 274                 VK_COMPARE_OP_LESS,                                                                                             // VkCompareOp                                                          depthCompareOp;
 275                 VK_FALSE,                                                                                                               // VkBool32                                                                     depthBoundsTestEnable;
 276                 VK_FALSE,                                                                                                               // VkBool32                                                                     stencilTestEnable;
 277                 stencilOpState,                                                                                                 // VkStencilOpState                                                     front;
 278                 stencilOpState,                                                                                                 // VkStencilOpState                                                     back;
 279                 0.0f,                                                                                                                   // float                                                                        minDepthBounds;
 280                 1.0f,                                                                                                                   // float                                                                        maxDepthBounds;
 281         };
 282
 283         const VkColorComponentFlags                                     colorComponentsAll                                      = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
 284         const VkPipelineColorBlendAttachmentState       pipelineColorBlendAttachmentState       =
 285         {
 286                 VK_FALSE,                                               // VkBool32                                     blendEnable;
 287                 VK_BLEND_FACTOR_ONE,                    // VkBlendFactor                        srcColorBlendFactor;
 288                 VK_BLEND_FACTOR_ZERO,                   // VkBlendFactor                        dstColorBlendFactor;
 289                 VK_BLEND_OP_ADD,                                // VkBlendOp                            colorBlendOp;
 290                 VK_BLEND_FACTOR_ONE,                    // VkBlendFactor                        srcAlphaBlendFactor;
 291                 VK_BLEND_FACTOR_ZERO,                   // VkBlendFactor                        dstAlphaBlendFactor;
 292                 VK_BLEND_OP_ADD,                                // VkBlendOp                            alphaBlendOp;
 293                 colorComponentsAll,                             // VkColorComponentFlags        colorWriteMask;
 294         };
 295
 296         const VkPipelineColorBlendStateCreateInfo pipelineColorBlendStateInfo =
 297         {
 298                 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,               // VkStructureType                                                              sType;
 299                 DE_NULL,                                                                                                                // const void*                                                                  pNext;
 300                 (VkPipelineColorBlendStateCreateFlags)0,                                                // VkPipelineColorBlendStateCreateFlags                 flags;
 301                 VK_FALSE,                                                                                                               // VkBool32                                                                             logicOpEnable;
 302                 VK_LOGIC_OP_COPY,                                                                                               // VkLogicOp                                                                    logicOp;
 303                 1u,                                                                                                                             // deUint32                                                                             attachmentCount;
 304                 &pipelineColorBlendAttachmentState,                                                             // const VkPipelineColorBlendAttachmentState*   pAttachments;
 305                 { 0.0f, 0.0f, 0.0f, 0.0f },                                                                             // float                                                                                blendConstants[4];
 306         };
 307
 308         const VkPipelineShaderStageCreateInfo pShaderStages[] =
 309         {
 310                 {
 311                         VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,            // VkStructureType                                              sType;
 312                         DE_NULL,                                                                                                        // const void*                                                  pNext;
 313                         (VkPipelineShaderStageCreateFlags)0,                                            // VkPipelineShaderStageCreateFlags             flags;
 314                         VK_SHADER_STAGE_VERTEX_BIT,                                                                     // VkShaderStageFlagBits                                stage;
 315                         vertexModule,                                                                                           // VkShaderModule                                               module;
 316                         "main",                                                                                                         // const char*                                                  pName;
 317                         DE_NULL,                                                                                                        // const VkSpecializationInfo*                  pSpecializationInfo;
 318                 },
 319                 {
 320                         VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,            // VkStructureType                                              sType;
 321                         DE_NULL,                                                                                                        // const void*                                                  pNext;
 322                         (VkPipelineShaderStageCreateFlags)0,                                            // VkPipelineShaderStageCreateFlags             flags;
 323                         VK_SHADER_STAGE_GEOMETRY_BIT,                                                           // VkShaderStageFlagBits                                stage;
 324                         geometryModule,                                                                                         // VkShaderModule                                               module;
 325                         "main",                                                                                                         // const char*                                                  pName;
 326                         DE_NULL,                                                                                                        // const VkSpecializationInfo*                  pSpecializationInfo;
 327                 },
 328                 {
 329                         VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,            // VkStructureType                                              sType;
 330                         DE_NULL,                                                                                                        // const void*                                                  pNext;
 331                         (VkPipelineShaderStageCreateFlags)0,                                            // VkPipelineShaderStageCreateFlags             flags;
 332                         VK_SHADER_STAGE_FRAGMENT_BIT,                                                           // VkShaderStageFlagBits                                stage;
 333                         fragmentModule,                                                                                         // VkShaderModule                                               module;
 334                         "main",                                                                                                         // const char*                                                  pName;
 335                         DE_NULL,                                                                                                        // const VkSpecializationInfo*                  pSpecializationInfo;
 336                 },
 337         };
 338
 339         const VkGraphicsPipelineCreateInfo graphicsPipelineInfo =
 340         {
 341                 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,        // VkStructureType                                                                      sType;
 342                 DE_NULL,                                                                                        // const void*                                                                          pNext;
 343                 (VkPipelineCreateFlags)0,                                                       // VkPipelineCreateFlags                                                        flags;
 344                 DE_LENGTH_OF_ARRAY(pShaderStages),                                      // deUint32                                                                                     stageCount;
 345                 pShaderStages,                                                                          // const VkPipelineShaderStageCreateInfo*                       pStages;
 346                 &vertexInputStateInfo,                                                          // const VkPipelineVertexInputStateCreateInfo*          pVertexInputState;
 347                 &pipelineInputAssemblyStateInfo,                                        // const VkPipelineInputAssemblyStateCreateInfo*        pInputAssemblyState;
 348                 DE_NULL,                                                                                        // const VkPipelineTessellationStateCreateInfo*         pTessellationState;
 349                 &pipelineViewportStateInfo,                                                     // const VkPipelineViewportStateCreateInfo*                     pViewportState;
 350                 &pipelineRasterizationStateInfo,                                        // const VkPipelineRasterizationStateCreateInfo*        pRasterizationState;
 351                 &pipelineMultisampleStateInfo,                                          // const VkPipelineMultisampleStateCreateInfo*          pMultisampleState;
 352                 &pipelineDepthStencilStateInfo,                                         // const VkPipelineDepthStencilStateCreateInfo*         pDepthStencilState;
 353                 &pipelineColorBlendStateInfo,                                           // const VkPipelineColorBlendStateCreateInfo*           pColorBlendState;
 354                 DE_NULL,                                                                                        // const VkPipelineDynamicStateCreateInfo*                      pDynamicState;
 355                 pipelineLayout,                                                                         // VkPipelineLayout                                                                     layout;
 356                 renderPass,                                                                                     // VkRenderPass                                                                         renderPass;
 357                 0u,                                                                                                     // deUint32                                                                                     subpass;
 358                 DE_NULL,                                                                                        // VkPipeline                                                                           basePipelineHandle;
 359                 0,                                                                                                      // deInt32                                                                                      basePipelineIndex;
 360         };
 361
 362         return createGraphicsPipeline(vk, device, DE_NULL, &graphicsPipelineInfo);
 363 }
 364
 365 void zeroBuffer (const DeviceInterface& vk, const VkDevice device, const Allocation& alloc, const VkDeviceSize size)
 366 {
 367         deMemset(alloc.getHostPtr(), 0, static_cast<std::size_t>(size));
 368         flushMappedMemoryRange(vk, device, alloc.getMemory(), alloc.getOffset(), size);
 369 }
 370
 371 void requireFeatureMultiViewport (const InstanceInterface& vki, const VkPhysicalDevice physDevice)
 372 {
 373         const VkPhysicalDeviceFeatures  features        = getPhysicalDeviceFeatures(vki, physDevice);
 374         const VkPhysicalDeviceLimits    limits          = getPhysicalDeviceProperties(vki, physDevice).limits;
 375
 376         if (!features.geometryShader)
 377                 TCU_THROW(NotSupportedError, "Required feature is not supported: geometryShader");
 378
 379         if (!features.multiViewport)
 380                 TCU_THROW(NotSupportedError, "Required feature is not supported: multiViewport");
 381
 382         if (limits.maxViewports < MIN_MAX_VIEWPORTS)
 383                 TCU_THROW(NotSupportedError, "Implementation doesn't support minimum required number of viewports");
 384 }
 385
 386 std::vector<IVec4> generateScissors (const int numScissors, const IVec2& renderSize)
 387 {
 388         // Scissor rects will be arranged in a grid-like fashion.
 389
 390         const int numCols               = deCeilFloatToInt32(deFloatSqrt(static_cast<float>(numScissors)));
 391         const int numRows               = deCeilFloatToInt32(static_cast<float>(numScissors) / static_cast<float>(numCols));
 392         const int rectWidth             = renderSize.x() / numCols;
 393         const int rectHeight    = renderSize.y() / numRows;
 394
 395         std::vector<IVec4> scissors;
 396         scissors.reserve(numScissors);
 397
 398         int x = 0;
 399         int y = 0;
 400
 401         for (int scissorNdx = 0; scissorNdx < numScissors; ++scissorNdx)
 402         {
 403                 const bool nextRow = (scissorNdx != 0) && (scissorNdx % numCols == 0);
 404                 if (nextRow)
 405                 {
 406                         x  = 0;
 407                         y += rectHeight;
 408                 }
 409
 410                 scissors.push_back(IVec4(x, y, rectWidth, rectHeight));
 411
 412                 x += rectWidth;
 413         }
 414
 415         return scissors;
 416 }
 417
 418 std::vector<Vec4> generateColors (const int numColors)
 419 {
 420         const Vec4 colors[] =
 421         {
 422                 Vec4(0.18f, 0.42f, 0.17f, 1.0f),
 423                 Vec4(0.29f, 0.62f, 0.28f, 1.0f),
 424                 Vec4(0.59f, 0.84f, 0.44f, 1.0f),
 425                 Vec4(0.96f, 0.95f, 0.72f, 1.0f),
 426                 Vec4(0.94f, 0.55f, 0.39f, 1.0f),
 427                 Vec4(0.82f, 0.19f, 0.12f, 1.0f),
 428                 Vec4(0.46f, 0.15f, 0.26f, 1.0f),
 429                 Vec4(0.24f, 0.14f, 0.24f, 1.0f),
 430                 Vec4(0.49f, 0.31f, 0.26f, 1.0f),
 431                 Vec4(0.78f, 0.52f, 0.33f, 1.0f),
 432                 Vec4(0.94f, 0.82f, 0.31f, 1.0f),
 433                 Vec4(0.98f, 0.65f, 0.30f, 1.0f),
 434                 Vec4(0.22f, 0.65f, 0.53f, 1.0f),
 435                 Vec4(0.67f, 0.81f, 0.91f, 1.0f),
 436                 Vec4(0.43f, 0.44f, 0.75f, 1.0f),
 437                 Vec4(0.26f, 0.24f, 0.48f, 1.0f),
 438         };
 439
 440         DE_ASSERT(numColors <= DE_LENGTH_OF_ARRAY(colors));
 441
 442         return std::vector<Vec4>(colors, colors + numColors);
 443 }
 444
 445 //! Renders a colorful grid of rectangles.
 446 tcu::TextureLevel generateReferenceImage (const tcu::TextureFormat      format,
 447                                                                                   const IVec2&                          renderSize,
 448                                                                                   const Vec4&                           clearColor,
 449                                                                                   const std::vector<IVec4>&     scissors,
 450                                                                                   const std::vector<Vec4>&      scissorColors)
 451 {
 452         DE_ASSERT(scissors.size() == scissorColors.size());
 453
 454         tcu::TextureLevel image(format, renderSize.x(), renderSize.y());
 455         tcu::clear(image.getAccess(), clearColor);
 456
 457         for (std::size_t i = 0; i < scissors.size(); ++i)
 458         {
 459                 tcu::clear(
 460                         tcu::getSubregion(image.getAccess(), scissors[i].x(), scissors[i].y(), scissors[i].z(), scissors[i].w()),
 461                         scissorColors[i]);
 462         }
 463
 464         return image;
 465 }
 466
 467 void initPrograms (SourceCollections& programCollection, const int numViewports)
 468 {
 469         DE_UNREF(numViewports);
 470
 471         // Vertex shader
 472         {
 473                 std::ostringstream src;
 474                 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n"
 475                         << "\n"
 476                         << "layout(location = 0) in  vec4 in_color;\n"
 477                         << "layout(location = 0) out vec4 out_color;\n"
 478                         << "\n"
 479                         << "void main(void)\n"
 480                         << "{\n"
 481                         << "    out_color = in_color;\n"
 482                         << "}\n";
 483
 484                 programCollection.glslSources.add("vert") << glu::VertexSource(src.str());
 485         }
 486
 487         // Geometry shader
 488         {
 489                 // Each input point generates a fullscreen quad.
 490
 491                 std::ostringstream src;
 492                 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n"
 493                         << "\n"
 494                         << "layout(points) in;\n"
 495                         << "layout(triangle_strip, max_vertices=4) out;\n"
 496                         << "\n"
 497                         << "out gl_PerVertex {\n"
 498                         << "    vec4 gl_Position;\n"
 499                         << "};\n"
 500                         << "\n"
 501                         << "layout(location = 0) in  vec4 in_color[];\n"
 502                         << "layout(location = 0) out vec4 out_color;\n"
 503                         << "\n"
 504                         << "void main(void)\n"
 505                         << "{\n"
 506                         << "    gl_ViewportIndex = gl_PrimitiveIDIn;\n"
 507                         << "    gl_Position      = vec4(-1.0, -1.0, 0.0, 1.0);\n"
 508                         << "    out_color        = in_color[0];\n"
 509                         << "    EmitVertex();"
 510                         << "\n"
 511                         << "    gl_ViewportIndex = gl_PrimitiveIDIn;\n"
 512                         << "    gl_Position      = vec4(-1.0, 1.0, 0.0, 1.0);\n"
 513                         << "    out_color        = in_color[0];\n"
 514                         << "    EmitVertex();"
 515                         << "\n"
 516                         << "    gl_ViewportIndex = gl_PrimitiveIDIn;\n"
 517                         << "    gl_Position      = vec4(1.0, -1.0, 0.0, 1.0);\n"
 518                         << "    out_color        = in_color[0];\n"
 519                         << "    EmitVertex();"
 520                         << "\n"
 521                         << "    gl_ViewportIndex = gl_PrimitiveIDIn;\n"
 522                         << "    gl_Position      = vec4(1.0, 1.0, 0.0, 1.0);\n"
 523                         << "    out_color        = in_color[0];\n"
 524                         << "    EmitVertex();"
 525                         << "}\n";
 526
 527                 programCollection.glslSources.add("geom") << glu::GeometrySource(src.str());
 528         }
 529
 530         // Fragment shader
 531         {
 532                 std::ostringstream src;
 533                 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n"
 534                         << "\n"
 535                         << "layout(location = 0) in  vec4 in_color;\n"
 536                         << "layout(location = 0) out vec4 out_color;\n"
 537                         << "\n"
 538                         << "void main(void)\n"
 539                         << "{\n"
 540                         << "    out_color = in_color;\n"
 541                         << "}\n";
 542
 543                 programCollection.glslSources.add("frag") << glu::FragmentSource(src.str());
 544         }
 545 }
 546
 547 class ScissorRenderer
 548 {
 549 public:
 550         ScissorRenderer (Context&                                       context,
 551                                          const IVec2&                           renderSize,
 552                                          const int                                      numViewports,
 553                                          const std::vector<IVec4>&      scissors,
 554                                          const VkFormat                         colorFormat,
 555                                          const Vec4&                            clearColor,
 556                                          const std::vector<Vec4>&       vertices)
 557                 : m_renderSize                          (renderSize)
 558                 , m_colorFormat                         (colorFormat)
 559                 , m_colorSubresourceRange       (makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u))
 560                 , m_clearColor                          (clearColor)
 561                 , m_numViewports                        (numViewports)
 562                 , m_vertexBufferSize            (sizeInBytes(vertices))
 563         {
 564                 const DeviceInterface&          vk                                      = context.getDeviceInterface();
 565                 const VkDevice                          device                          = context.getDevice();
 566                 const deUint32                          queueFamilyIndex        = context.getUniversalQueueFamilyIndex();
 567                 Allocator&                                      allocator                       = context.getDefaultAllocator();
 568
 569                 m_colorImage            = makeImage                             (vk, device, makeImageCreateInfo(m_colorFormat, m_renderSize, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT));
 570                 m_colorImageAlloc       = bindImage                             (vk, device, allocator, *m_colorImage, MemoryRequirement::Any);
 571                 m_colorAttachment       = makeImageView                 (vk, device, *m_colorImage, VK_IMAGE_VIEW_TYPE_2D, m_colorFormat, m_colorSubresourceRange);
 572
 573                 m_vertexBuffer          = makeBuffer                    (vk, device, makeBufferCreateInfo(m_vertexBufferSize, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT));
 574                 m_vertexBufferAlloc     = bindBuffer                    (vk, device, allocator, *m_vertexBuffer, MemoryRequirement::HostVisible);
 575
 576                 {
 577                         deMemcpy(m_vertexBufferAlloc->getHostPtr(), &vertices[0], static_cast<std::size_t>(m_vertexBufferSize));
 578                         flushMappedMemoryRange(vk, device, m_vertexBufferAlloc->getMemory(), m_vertexBufferAlloc->getOffset(), m_vertexBufferSize);
 579                 }
 580
 581                 m_vertexModule          = createShaderModule    (vk, device, context.getBinaryCollection().get("vert"), 0u);
 582                 m_geometryModule        = createShaderModule    (vk, device, context.getBinaryCollection().get("geom"), 0u);
 583                 m_fragmentModule        = createShaderModule    (vk, device, context.getBinaryCollection().get("frag"), 0u);
 584                 m_renderPass            = makeRenderPass                (vk, device, m_colorFormat);
 585                 m_framebuffer           = makeFramebuffer               (vk, device, *m_renderPass, 1u, &m_colorAttachment.get(),
 586                                                                                                          static_cast<deUint32>(m_renderSize.x()),  static_cast<deUint32>(m_renderSize.y()));
 587                 m_pipelineLayout        = makePipelineLayout    (vk, device);
 588                 m_pipeline                      = makeGraphicsPipeline  (vk, device, *m_pipelineLayout, *m_renderPass, *m_vertexModule, *m_geometryModule, *m_fragmentModule,
 589                                                                                                          m_renderSize, m_numViewports, scissors);
 590                 m_cmdPool                       = createCommandPool             (vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueFamilyIndex);
 591                 m_cmdBuffer                     = allocateCommandBuffer (vk, device, *m_cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
 592         }
 593
 594         void draw (Context& context, const VkBuffer colorBuffer) const
 595         {
 596                 const DeviceInterface&          vk                      = context.getDeviceInterface();
 597                 const VkDevice                          device          = context.getDevice();
 598                 const VkQueue                           queue           = context.getUniversalQueue();
 599
 600                 beginCommandBuffer(vk, *m_cmdBuffer);
 601
 602                 const VkClearValue                      clearValue      = makeClearValueColor(m_clearColor);
 603                 const VkRect2D                          renderArea      =
 604                 {
 605                         makeOffset2D(0, 0),
 606                         makeExtent2D(m_renderSize.x(), m_renderSize.y()),
 607                 };
 608                 const VkRenderPassBeginInfo renderPassBeginInfo =
 609                 {
 610                         VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,               // VkStructureType         sType;
 611                         DE_NULL,                                                                                // const void*             pNext;
 612                         *m_renderPass,                                                                  // VkRenderPass            renderPass;
 613                         *m_framebuffer,                                                                 // VkFramebuffer           framebuffer;
 614                         renderArea,                                                                             // VkRect2D                renderArea;
 615                         1u,                                                                                             // uint32_t                clearValueCount;
 616                         &clearValue,                                                                    // const VkClearValue*     pClearValues;
 617                 };
 618                 vk.cmdBeginRenderPass(*m_cmdBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
 619
 620                 vk.cmdBindPipeline(*m_cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipeline);
 621                 {
 622                         const VkDeviceSize vertexBufferOffset = 0ull;
 623                         vk.cmdBindVertexBuffers(*m_cmdBuffer, 0u, 1u, &m_vertexBuffer.get(), &vertexBufferOffset);
 624                 }
 625                 vk.cmdDraw(*m_cmdBuffer, static_cast<deUint32>(m_numViewports), 1u, 0u, 0u);    // one vertex per viewport
 626                 vk.cmdEndRenderPass(*m_cmdBuffer);
 627
 628                 // Prepare color image for copy
 629                 {
 630                         const VkImageMemoryBarrier barriers[] =
 631                         {
 632                                 {
 633                                         VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,                                         // VkStructureType                      sType;
 634                                         DE_NULL,                                                                                                        // const void*                          pNext;
 635                                         VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,                                           // VkAccessFlags                        outputMask;
 636                                         VK_ACCESS_TRANSFER_READ_BIT,                                                            // VkAccessFlags                        inputMask;
 637                                         VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,                                       // VkImageLayout                        oldLayout;
 638                                         VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,                                           // VkImageLayout                        newLayout;
 639                                         VK_QUEUE_FAMILY_IGNORED,                                                                        // deUint32                                     srcQueueFamilyIndex;
 640                                         VK_QUEUE_FAMILY_IGNORED,                                                                        // deUint32                                     destQueueFamilyIndex;
 641                                         *m_colorImage,                                                                                          // VkImage                                      image;
 642                                         m_colorSubresourceRange,                                                                        // VkImageSubresourceRange      subresourceRange;
 643                                 },
 644                         };
 645
 646                         vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u,
 647                                 0u, DE_NULL, 0u, DE_NULL, DE_LENGTH_OF_ARRAY(barriers), barriers);
 648                 }
 649                 // Color image -> host buffer
 650                 {
 651                         const VkBufferImageCopy region =
 652                         {
 653                                 0ull,                                                                                                                                           // VkDeviceSize                bufferOffset;
 654                                 0u,                                                                                                                                                     // uint32_t                    bufferRowLength;
 655                                 0u,                                                                                                                                                     // uint32_t                    bufferImageHeight;
 656                                 makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, 1u),                      // VkImageSubresourceLayers    imageSubresource;
 657                                 makeOffset3D(0, 0, 0),                                                                                                          // VkOffset3D                  imageOffset;
 658                                 makeExtent3D(m_renderSize.x(), m_renderSize.y(), 1u),                                           // VkExtent3D                  imageExtent;
 659                         };
 660
 661                         vk.cmdCopyImageToBuffer(*m_cmdBuffer, *m_colorImage, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, colorBuffer, 1u, &region);
 662                 }
 663                 // Buffer write barrier
 664                 {
 665                         const VkBufferMemoryBarrier barriers[] =
 666                         {
 667                                 {
 668                                         VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,                // VkStructureType    sType;
 669                                         DE_NULL,                                                                                // const void*        pNext;
 670                                         VK_ACCESS_TRANSFER_WRITE_BIT,                                   // VkAccessFlags      srcAccessMask;
 671                                         VK_ACCESS_HOST_READ_BIT,                                                // VkAccessFlags      dstAccessMask;
 672                                         VK_QUEUE_FAMILY_IGNORED,                                                // uint32_t           srcQueueFamilyIndex;
 673                                         VK_QUEUE_FAMILY_IGNORED,                                                // uint32_t           dstQueueFamilyIndex;
 674                                         colorBuffer,                                                                    // VkBuffer           buffer;
 675                                         0ull,                                                                                   // VkDeviceSize       offset;
 676                                         VK_WHOLE_SIZE,                                                                  // VkDeviceSize       size;
 677                                 },
 678                         };
 679
 680                         vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0u,
 681                                 0u, DE_NULL, DE_LENGTH_OF_ARRAY(barriers), barriers, DE_NULL, 0u);
 682                 }
 683
 684                 VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
 685                 submitCommandsAndWait(vk, device, queue, *m_cmdBuffer);
 686         }
 687
 688 private:
 689         const IVec2                                             m_renderSize;
 690         const VkFormat                                  m_colorFormat;
 691         const VkImageSubresourceRange   m_colorSubresourceRange;
 692         const Vec4                                              m_clearColor;
 693         const int                                               m_numViewports;
 694         const VkDeviceSize                              m_vertexBufferSize;
 695
 696         Move<VkImage>                                   m_colorImage;
 697         MovePtr<Allocation>                             m_colorImageAlloc;
 698         Move<VkImageView>                               m_colorAttachment;
 699         Move<VkBuffer>                                  m_vertexBuffer;
 700         MovePtr<Allocation>                             m_vertexBufferAlloc;
 701         Move<VkShaderModule>                    m_vertexModule;
 702         Move<VkShaderModule>                    m_geometryModule;
 703         Move<VkShaderModule>                    m_fragmentModule;
 704         Move<VkRenderPass>                              m_renderPass;
 705         Move<VkFramebuffer>                             m_framebuffer;
 706         Move<VkPipelineLayout>                  m_pipelineLayout;
 707         Move<VkPipeline>                                m_pipeline;
 708         Move<VkCommandPool>                             m_cmdPool;
 709         Move<VkCommandBuffer>                   m_cmdBuffer;
 710
 711         // "deleted"
 712                                                 ScissorRenderer (const ScissorRenderer&);
 713         ScissorRenderer&        operator=               (const ScissorRenderer&);
 714 };
 715
 716 tcu::TestStatus test (Context& context, const int numViewports)
 717 {
 718         requireFeatureMultiViewport(context.getInstanceInterface(), context.getPhysicalDevice());
 719
 720         const DeviceInterface&                  vk                                      = context.getDeviceInterface();
 721         const VkDevice                                  device                          = context.getDevice();
 722         Allocator&                                              allocator                       = context.getDefaultAllocator();
 723
 724         const IVec2                                             renderSize                      (128, 128);
 725         const VkFormat                                  colorFormat                     = VK_FORMAT_R8G8B8A8_UNORM;
 726         const Vec4                                              clearColor                      (0.5f, 0.5f, 0.5f, 1.0f);
 727         const std::vector<Vec4>                 vertexColors            = generateColors(numViewports);
 728         const std::vector<IVec4>                scissors                        = generateScissors(numViewports, renderSize);
 729
 730         const VkDeviceSize                              colorBufferSize         = renderSize.x() * renderSize.y() * tcu::getPixelSize(mapVkFormat(colorFormat));
 731         const Unique<VkBuffer>                  colorBuffer                     (makeBuffer(vk, device, makeBufferCreateInfo(colorBufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT)));
 732         const UniquePtr<Allocation>             colorBufferAlloc        (bindBuffer(vk, device, allocator, *colorBuffer, MemoryRequirement::HostVisible));
 733
 734         zeroBuffer(vk, device, *colorBufferAlloc, colorBufferSize);
 735
 736         {
 737                 context.getTestContext().getLog()
 738                         << tcu::TestLog::Message << "Rendering a colorful grid of " << numViewports << " rectangle(s)." << tcu::TestLog::EndMessage
 739                         << tcu::TestLog::Message << "Not covered area will be filled with a gray color." << tcu::TestLog::EndMessage;
 740         }
 741
 742         // Draw
 743         {
 744                 const ScissorRenderer renderer (context, renderSize, numViewports, scissors, colorFormat, clearColor, vertexColors);
 745                 renderer.draw(context, *colorBuffer);
 746         }
 747
 748         // Log image
 749         {
 750                 invalidateMappedMemoryRange(vk, device, colorBufferAlloc->getMemory(), 0ull, colorBufferSize);
 751
 752                 const tcu::ConstPixelBufferAccess       resultImage             (mapVkFormat(colorFormat), renderSize.x(), renderSize.y(), 1u, colorBufferAlloc->getHostPtr());
 753                 const tcu::TextureLevel                         referenceImage  = generateReferenceImage(mapVkFormat(colorFormat), renderSize, clearColor, scissors, vertexColors);
 754
 755                 // Images should now match.
 756                 if (!tcu::floatThresholdCompare(context.getTestContext().getLog(), "color", "Image compare", referenceImage.getAccess(), resultImage, Vec4(0.02f), tcu::COMPARE_LOG_RESULT))
 757                         return tcu::TestStatus::fail("Rendered image is not correct");
 758         }
 759
 760         return tcu::TestStatus::pass("OK");
 761 }
 762
 763 } // anonymous
 764
 765 tcu::TestCaseGroup* createScissorMultiViewportTests     (tcu::TestContext& testCtx)
 766 {
 767         MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, "multi_viewport", ""));
 768
 769         for (int numViewports = 1; numViewports <= MIN_MAX_VIEWPORTS; ++numViewports)
 770                 addFunctionCaseWithPrograms(group.get(), "scissor_" + de::toString(numViewports), "", initPrograms, test, numViewports);
 771
 772         return group.release();
 773 }
 774
 775 } // FragmentOperations
 776 } // vkt