external/vulkancts/modules/vulkan/fragment_ops/vktFragmentOperationsScissorTests.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 tests
  23  *//*--------------------------------------------------------------------*/
  24
  25 #include "vktFragmentOperationsScissorTests.hpp"
  26 #include "vktFragmentOperationsScissorMultiViewportTests.hpp"
  27 #include "vktTestCaseUtil.hpp"
  28 #include "vktTestGroupUtil.hpp"
  29 #include "vktFragmentOperationsMakeUtil.hpp"
  30
  31 #include "vkDefs.hpp"
  32 #include "vkRefUtil.hpp"
  33 #include "vkTypeUtil.hpp"
  34 #include "vkMemUtil.hpp"
  35 #include "vkPrograms.hpp"
  36 #include "vkImageUtil.hpp"
  37
  38 #include "tcuTestLog.hpp"
  39 #include "tcuVector.hpp"
  40 #include "tcuImageCompare.hpp"
  41
  42 #include "deUniquePtr.hpp"
  43 #include "deRandom.hpp"
  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 //! What primitives will be drawn by the test case.
  61 enum TestPrimitive
  62 {
  63         TEST_PRIMITIVE_POINTS,                  //!< Many points.
  64         TEST_PRIMITIVE_LINES,                   //!< Many short lines.
  65         TEST_PRIMITIVE_TRIANGLES,               //!< Many small triangles.
  66         TEST_PRIMITIVE_BIG_LINE,                //!< One line crossing the whole render area.
  67         TEST_PRIMITIVE_BIG_TRIANGLE,    //!< One triangle covering the whole render area.
  68 };
  69
  70 struct VertexData
  71 {
  72         Vec4    position;
  73         Vec4    color;
  74 };
  75
  76 //! Parameters used by the test case.
  77 struct CaseDef
  78 {
  79         Vec4                    renderArea;             //!< (ox, oy, w, h), where origin (0,0) is the top-left corner of the viewport. Width and height are in range [0, 1].
  80         Vec4                    scissorArea;    //!< scissored area (ox, oy, w, h)
  81         TestPrimitive   primitive;
  82 };
  83
  84 template<typename T>
  85 inline VkDeviceSize sizeInBytes(const std::vector<T>& vec)
  86 {
  87         return vec.size() * sizeof(vec[0]);
  88 }
  89
  90 VkImageCreateInfo makeImageCreateInfo (const VkFormat format, const IVec2& size, VkImageUsageFlags usage)
  91 {
  92         const VkImageCreateInfo imageParams =
  93         {
  94                 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,                    // VkStructureType                      sType;
  95                 DE_NULL,                                                                                // const void*                          pNext;
  96                 (VkImageCreateFlags)0,                                                  // VkImageCreateFlags           flags;
  97                 VK_IMAGE_TYPE_2D,                                                               // VkImageType                          imageType;
  98                 format,                                                                                 // VkFormat                                     format;
  99                 makeExtent3D(size.x(), size.y(), 1),                    // VkExtent3D                           extent;
 100                 1u,                                                                                             // deUint32                                     mipLevels;
 101                 1u,                                                                                             // deUint32                                     arrayLayers;
 102                 VK_SAMPLE_COUNT_1_BIT,                                                  // VkSampleCountFlagBits        samples;
 103                 VK_IMAGE_TILING_OPTIMAL,                                                // VkImageTiling                        tiling;
 104                 usage,                                                                                  // VkImageUsageFlags            usage;
 105                 VK_SHARING_MODE_EXCLUSIVE,                                              // VkSharingMode                        sharingMode;
 106                 0u,                                                                                             // deUint32                                     queueFamilyIndexCount;
 107                 DE_NULL,                                                                                // const deUint32*                      pQueueFamilyIndices;
 108                 VK_IMAGE_LAYOUT_UNDEFINED,                                              // VkImageLayout                        initialLayout;
 109         };
 110         return imageParams;
 111 }
 112
 113 //! A single-attachment, single-subpass render pass.
 114 Move<VkRenderPass> makeRenderPass (const DeviceInterface&       vk,
 115                                                                    const VkDevice                       device,
 116                                                                    const VkFormat                       colorFormat)
 117 {
 118         const VkAttachmentDescription colorAttachmentDescription =
 119         {
 120                 (VkAttachmentDescriptionFlags)0,                                        // VkAttachmentDescriptionFlags         flags;
 121                 colorFormat,                                                                            // VkFormat                                                     format;
 122                 VK_SAMPLE_COUNT_1_BIT,                                                          // VkSampleCountFlagBits                        samples;
 123                 VK_ATTACHMENT_LOAD_OP_CLEAR,                                            // VkAttachmentLoadOp                           loadOp;
 124                 VK_ATTACHMENT_STORE_OP_STORE,                                           // VkAttachmentStoreOp                          storeOp;
 125                 VK_ATTACHMENT_LOAD_OP_DONT_CARE,                                        // VkAttachmentLoadOp                           stencilLoadOp;
 126                 VK_ATTACHMENT_STORE_OP_DONT_CARE,                                       // VkAttachmentStoreOp                          stencilStoreOp;
 127                 VK_IMAGE_LAYOUT_UNDEFINED,                                                      // VkImageLayout                                        initialLayout;
 128                 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,                       // VkImageLayout                                        finalLayout;
 129         };
 130
 131         const VkAttachmentReference colorAttachmentRef =
 132         {
 133                 0u,                                                                                                     // deUint32                     attachment;
 134                 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL                        // VkImageLayout        layout;
 135         };
 136
 137         const VkSubpassDescription subpassDescription =
 138         {
 139                 (VkSubpassDescriptionFlags)0,                                           // VkSubpassDescriptionFlags            flags;
 140                 VK_PIPELINE_BIND_POINT_GRAPHICS,                                        // VkPipelineBindPoint                          pipelineBindPoint;
 141                 0u,                                                                                                     // deUint32                                                     inputAttachmentCount;
 142                 DE_NULL,                                                                                        // const VkAttachmentReference*         pInputAttachments;
 143                 1u,                                                                                                     // deUint32                                                     colorAttachmentCount;
 144                 &colorAttachmentRef,                                                            // const VkAttachmentReference*         pColorAttachments;
 145                 DE_NULL,                                                                                        // const VkAttachmentReference*         pResolveAttachments;
 146                 DE_NULL,                                                                                        // const VkAttachmentReference*         pDepthStencilAttachment;
 147                 0u,                                                                                                     // deUint32                                                     preserveAttachmentCount;
 148                 DE_NULL                                                                                         // const deUint32*                                      pPreserveAttachments;
 149         };
 150
 151         const VkRenderPassCreateInfo renderPassInfo =
 152         {
 153                 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,                      // VkStructureType                                      sType;
 154                 DE_NULL,                                                                                        // const void*                                          pNext;
 155                 (VkRenderPassCreateFlags)0,                                                     // VkRenderPassCreateFlags                      flags;
 156                 1u,                                                                                                     // deUint32                                                     attachmentCount;
 157                 &colorAttachmentDescription,                                            // const VkAttachmentDescription*       pAttachments;
 158                 1u,                                                                                                     // deUint32                                                     subpassCount;
 159                 &subpassDescription,                                                            // const VkSubpassDescription*          pSubpasses;
 160                 0u,                                                                                                     // deUint32                                                     dependencyCount;
 161                 DE_NULL                                                                                         // const VkSubpassDependency*           pDependencies;
 162         };
 163
 164         return createRenderPass(vk, device, &renderPassInfo);
 165 }
 166
 167 Move<VkPipeline> makeGraphicsPipeline (const DeviceInterface&           vk,
 168                                                                            const VkDevice                               device,
 169                                                                            const VkPipelineLayout               pipelineLayout,
 170                                                                            const VkRenderPass                   renderPass,
 171                                                                            const VkShaderModule                 vertexModule,
 172                                                                            const VkShaderModule                 fragmentModule,
 173                                                                            const IVec2                                  renderSize,
 174                                                                            const IVec4                                  scissorArea,    //!< (ox, oy, w, h)
 175                                                                            const VkPrimitiveTopology    topology)
 176 {
 177         const VkVertexInputBindingDescription vertexInputBindingDescription =
 178         {
 179                 0u,                                                             // uint32_t                             binding;
 180                 sizeof(VertexData),                             // uint32_t                             stride;
 181                 VK_VERTEX_INPUT_RATE_VERTEX,    // VkVertexInputRate    inputRate;
 182         };
 183
 184         const VkVertexInputAttributeDescription vertexInputAttributeDescriptions[] =
 185         {
 186                 {
 187                         0u,                                                                     // uint32_t                     location;
 188                         0u,                                                                     // uint32_t                     binding;
 189                         VK_FORMAT_R32G32B32A32_SFLOAT,          // VkFormat                     format;
 190                         0u,                                                                     // uint32_t                     offset;
 191                 },
 192                 {
 193                         1u,                                                                     // uint32_t                     location;
 194                         0u,                                                                     // uint32_t                     binding;
 195                         VK_FORMAT_R32G32B32A32_SFLOAT,          // VkFormat                     format;
 196                         sizeof(Vec4),                                           // uint32_t                     offset;
 197                 },
 198         };
 199
 200         const VkPipelineVertexInputStateCreateInfo vertexInputStateInfo =
 201         {
 202                 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,              // VkStructureType                             sType;
 203                 DE_NULL,                                                                                                                // const void*                                 pNext;
 204                 (VkPipelineVertexInputStateCreateFlags)0,                                               // VkPipelineVertexInputStateCreateFlags       flags;
 205                 1u,                                                                                                                             // uint32_t                                    vertexBindingDescriptionCount;
 206                 &vertexInputBindingDescription,                                                                 // const VkVertexInputBindingDescription*      pVertexBindingDescriptions;
 207                 DE_LENGTH_OF_ARRAY(vertexInputAttributeDescriptions),                   // uint32_t                                    vertexAttributeDescriptionCount;
 208                 vertexInputAttributeDescriptions,                                                               // const VkVertexInputAttributeDescription*    pVertexAttributeDescriptions;
 209         };
 210
 211         const VkPipelineInputAssemblyStateCreateInfo pipelineInputAssemblyStateInfo =
 212         {
 213                 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,    // VkStructureType                             sType;
 214                 DE_NULL,                                                                                                                // const void*                                 pNext;
 215                 (VkPipelineInputAssemblyStateCreateFlags)0,                                             // VkPipelineInputAssemblyStateCreateFlags     flags;
 216                 topology,                                                                                                               // VkPrimitiveTopology                         topology;
 217                 VK_FALSE,                                                                                                               // VkBool32                                    primitiveRestartEnable;
 218         };
 219
 220         const VkViewport viewport = makeViewport(
 221                 0.0f, 0.0f,
 222                 static_cast<float>(renderSize.x()), static_cast<float>(renderSize.y()),
 223                 0.0f, 1.0f);
 224
 225         const VkRect2D scissor = {
 226                 makeOffset2D(scissorArea.x(), scissorArea.y()),
 227                 makeExtent2D(static_cast<deUint32>(scissorArea.z()), static_cast<deUint32>(scissorArea.w())),
 228         };
 229
 230         const VkPipelineViewportStateCreateInfo pipelineViewportStateInfo =
 231         {
 232                 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,                  // VkStructureType                             sType;
 233                 DE_NULL,                                                                                                                // const void*                                 pNext;
 234                 (VkPipelineViewportStateCreateFlags)0,                                                  // VkPipelineViewportStateCreateFlags          flags;
 235                 1u,                                                                                                                             // uint32_t                                    viewportCount;
 236                 &viewport,                                                                                                              // const VkViewport*                           pViewports;
 237                 1u,                                                                                                                             // uint32_t                                    scissorCount;
 238                 &scissor,                                                                                                               // const VkRect2D*                             pScissors;
 239         };
 240
 241         const VkPipelineRasterizationStateCreateInfo pipelineRasterizationStateInfo =
 242         {
 243                 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,             // VkStructureType                          sType;
 244                 DE_NULL,                                                                                                                // const void*                              pNext;
 245                 (VkPipelineRasterizationStateCreateFlags)0,                                             // VkPipelineRasterizationStateCreateFlags  flags;
 246                 VK_FALSE,                                                                                                               // VkBool32                                 depthClampEnable;
 247                 VK_FALSE,                                                                                                               // VkBool32                                 rasterizerDiscardEnable;
 248                 VK_POLYGON_MODE_FILL,                                                                                   // VkPolygonMode                                                        polygonMode;
 249                 VK_CULL_MODE_NONE,                                                                                              // VkCullModeFlags                                                      cullMode;
 250                 VK_FRONT_FACE_COUNTER_CLOCKWISE,                                                                // VkFrontFace                                                          frontFace;
 251                 VK_FALSE,                                                                                                               // VkBool32                                                                     depthBiasEnable;
 252                 0.0f,                                                                                                                   // float                                                                        depthBiasConstantFactor;
 253                 0.0f,                                                                                                                   // float                                                                        depthBiasClamp;
 254                 0.0f,                                                                                                                   // float                                                                        depthBiasSlopeFactor;
 255                 1.0f,                                                                                                                   // float                                                                        lineWidth;
 256         };
 257
 258         const VkPipelineMultisampleStateCreateInfo pipelineMultisampleStateInfo =
 259         {
 260                 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,               // VkStructureType                                                      sType;
 261                 DE_NULL,                                                                                                                // const void*                                                          pNext;
 262                 (VkPipelineMultisampleStateCreateFlags)0,                                               // VkPipelineMultisampleStateCreateFlags        flags;
 263                 VK_SAMPLE_COUNT_1_BIT,                                                                                  // VkSampleCountFlagBits                                        rasterizationSamples;
 264                 VK_FALSE,                                                                                                               // VkBool32                                                                     sampleShadingEnable;
 265                 0.0f,                                                                                                                   // float                                                                        minSampleShading;
 266                 DE_NULL,                                                                                                                // const VkSampleMask*                                          pSampleMask;
 267                 VK_FALSE,                                                                                                               // VkBool32                                                                     alphaToCoverageEnable;
 268                 VK_FALSE                                                                                                                // VkBool32                                                                     alphaToOneEnable;
 269         };
 270
 271         const VkStencilOpState stencilOpState = makeStencilOpState(
 272                 VK_STENCIL_OP_KEEP,                             // stencil fail
 273                 VK_STENCIL_OP_KEEP,                             // depth & stencil pass
 274                 VK_STENCIL_OP_KEEP,                             // depth only fail
 275                 VK_COMPARE_OP_ALWAYS,                   // compare op
 276                 0u,                                                             // compare mask
 277                 0u,                                                             // write mask
 278                 0u);                                                    // reference
 279
 280         VkPipelineDepthStencilStateCreateInfo pipelineDepthStencilStateInfo =
 281         {
 282                 VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,             // VkStructureType                                                      sType;
 283                 DE_NULL,                                                                                                                // const void*                                                          pNext;
 284                 (VkPipelineDepthStencilStateCreateFlags)0,                                              // VkPipelineDepthStencilStateCreateFlags       flags;
 285                 VK_FALSE,                                                                                                               // VkBool32                                                                     depthTestEnable;
 286                 VK_FALSE,                                                                                                               // VkBool32                                                                     depthWriteEnable;
 287                 VK_COMPARE_OP_LESS,                                                                                             // VkCompareOp                                                          depthCompareOp;
 288                 VK_FALSE,                                                                                                               // VkBool32                                                                     depthBoundsTestEnable;
 289                 VK_FALSE,                                                                                                               // VkBool32                                                                     stencilTestEnable;
 290                 stencilOpState,                                                                                                 // VkStencilOpState                                                     front;
 291                 stencilOpState,                                                                                                 // VkStencilOpState                                                     back;
 292                 0.0f,                                                                                                                   // float                                                                        minDepthBounds;
 293                 1.0f,                                                                                                                   // float                                                                        maxDepthBounds;
 294         };
 295
 296         const VkColorComponentFlags                                     colorComponentsAll                                      = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
 297         const VkPipelineColorBlendAttachmentState       pipelineColorBlendAttachmentState       =
 298         {
 299                 VK_FALSE,                                               // VkBool32                                     blendEnable;
 300                 VK_BLEND_FACTOR_ONE,                    // VkBlendFactor                        srcColorBlendFactor;
 301                 VK_BLEND_FACTOR_ZERO,                   // VkBlendFactor                        dstColorBlendFactor;
 302                 VK_BLEND_OP_ADD,                                // VkBlendOp                            colorBlendOp;
 303                 VK_BLEND_FACTOR_ONE,                    // VkBlendFactor                        srcAlphaBlendFactor;
 304                 VK_BLEND_FACTOR_ZERO,                   // VkBlendFactor                        dstAlphaBlendFactor;
 305                 VK_BLEND_OP_ADD,                                // VkBlendOp                            alphaBlendOp;
 306                 colorComponentsAll,                             // VkColorComponentFlags        colorWriteMask;
 307         };
 308
 309         const VkPipelineColorBlendStateCreateInfo pipelineColorBlendStateInfo =
 310         {
 311                 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,               // VkStructureType                                                              sType;
 312                 DE_NULL,                                                                                                                // const void*                                                                  pNext;
 313                 (VkPipelineColorBlendStateCreateFlags)0,                                                // VkPipelineColorBlendStateCreateFlags                 flags;
 314                 VK_FALSE,                                                                                                               // VkBool32                                                                             logicOpEnable;
 315                 VK_LOGIC_OP_COPY,                                                                                               // VkLogicOp                                                                    logicOp;
 316                 1u,                                                                                                                             // deUint32                                                                             attachmentCount;
 317                 &pipelineColorBlendAttachmentState,                                                             // const VkPipelineColorBlendAttachmentState*   pAttachments;
 318                 { 0.0f, 0.0f, 0.0f, 0.0f },                                                                             // float                                                                                blendConstants[4];
 319         };
 320
 321         const VkPipelineShaderStageCreateInfo pShaderStages[] =
 322         {
 323                 {
 324                         VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,            // VkStructureType                                              sType;
 325                         DE_NULL,                                                                                                        // const void*                                                  pNext;
 326                         (VkPipelineShaderStageCreateFlags)0,                                            // VkPipelineShaderStageCreateFlags             flags;
 327                         VK_SHADER_STAGE_VERTEX_BIT,                                                                     // VkShaderStageFlagBits                                stage;
 328                         vertexModule,                                                                                           // VkShaderModule                                               module;
 329                         "main",                                                                                                         // const char*                                                  pName;
 330                         DE_NULL,                                                                                                        // const VkSpecializationInfo*                  pSpecializationInfo;
 331                 },
 332                 {
 333                         VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,            // VkStructureType                                              sType;
 334                         DE_NULL,                                                                                                        // const void*                                                  pNext;
 335                         (VkPipelineShaderStageCreateFlags)0,                                            // VkPipelineShaderStageCreateFlags             flags;
 336                         VK_SHADER_STAGE_FRAGMENT_BIT,                                                           // VkShaderStageFlagBits                                stage;
 337                         fragmentModule,                                                                                         // VkShaderModule                                               module;
 338                         "main",                                                                                                         // const char*                                                  pName;
 339                         DE_NULL,                                                                                                        // const VkSpecializationInfo*                  pSpecializationInfo;
 340                 }
 341         };
 342
 343         const VkGraphicsPipelineCreateInfo graphicsPipelineInfo =
 344         {
 345                 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,        // VkStructureType                                                                      sType;
 346                 DE_NULL,                                                                                        // const void*                                                                          pNext;
 347                 (VkPipelineCreateFlags)0,                                                       // VkPipelineCreateFlags                                                        flags;
 348                 DE_LENGTH_OF_ARRAY(pShaderStages),                                      // deUint32                                                                                     stageCount;
 349                 pShaderStages,                                                                          // const VkPipelineShaderStageCreateInfo*                       pStages;
 350                 &vertexInputStateInfo,                                                          // const VkPipelineVertexInputStateCreateInfo*          pVertexInputState;
 351                 &pipelineInputAssemblyStateInfo,                                        // const VkPipelineInputAssemblyStateCreateInfo*        pInputAssemblyState;
 352                 DE_NULL,                                                                                        // const VkPipelineTessellationStateCreateInfo*         pTessellationState;
 353                 &pipelineViewportStateInfo,                                                     // const VkPipelineViewportStateCreateInfo*                     pViewportState;
 354                 &pipelineRasterizationStateInfo,                                        // const VkPipelineRasterizationStateCreateInfo*        pRasterizationState;
 355                 &pipelineMultisampleStateInfo,                                          // const VkPipelineMultisampleStateCreateInfo*          pMultisampleState;
 356                 &pipelineDepthStencilStateInfo,                                         // const VkPipelineDepthStencilStateCreateInfo*         pDepthStencilState;
 357                 &pipelineColorBlendStateInfo,                                           // const VkPipelineColorBlendStateCreateInfo*           pColorBlendState;
 358                 DE_NULL,                                                                                        // const VkPipelineDynamicStateCreateInfo*                      pDynamicState;
 359                 pipelineLayout,                                                                         // VkPipelineLayout                                                                     layout;
 360                 renderPass,                                                                                     // VkRenderPass                                                                         renderPass;
 361                 0u,                                                                                                     // deUint32                                                                                     subpass;
 362                 DE_NULL,                                                                                        // VkPipeline                                                                           basePipelineHandle;
 363                 0,                                                                                                      // deInt32                                                                                      basePipelineIndex;
 364         };
 365
 366         return createGraphicsPipeline(vk, device, DE_NULL, &graphicsPipelineInfo);
 367 }
 368
 369 inline VertexData makeVertex (const float x, const float y, const Vec4& color)
 370 {
 371         const VertexData data = { Vec4(x, y, 0.0f, 1.0f), color };
 372         return data;
 373 }
 374
 375 std::vector<VertexData> genVertices (const TestPrimitive primitive, const Vec4& renderArea, const Vec4& primitiveColor)
 376 {
 377         std::vector<VertexData> vertices;
 378         de::Random                              rng                     (1234);
 379
 380         const float     x0              = 2.0f * renderArea.x() - 1.0f;
 381         const float y0          = 2.0f * renderArea.y() - 1.0f;
 382         const float     rx              = 2.0f * renderArea.z();
 383         const float     ry              = 2.0f * renderArea.w();
 384         const float     size    = 0.2f;
 385
 386         switch (primitive)
 387         {
 388                 case TEST_PRIMITIVE_POINTS:
 389                         for (int i = 0; i < 50; ++i)
 390                         {
 391                                 const float x = x0 + rng.getFloat(0.0f, rx);
 392                                 const float y = y0 + rng.getFloat(0.0f, ry);
 393                                 vertices.push_back(makeVertex(x, y, primitiveColor));
 394                         }
 395                         break;
 396
 397                 case TEST_PRIMITIVE_LINES:
 398                         for (int i = 0; i < 30; ++i)
 399                         {
 400                                 const float x = x0 + rng.getFloat(0.0f, rx - size);
 401                                 const float y = y0 + rng.getFloat(0.0f, ry - size);
 402                                 vertices.push_back(makeVertex(x,        y,        primitiveColor));
 403                                 vertices.push_back(makeVertex(x + size, y + size, primitiveColor));
 404                         }
 405                         break;
 406
 407                 case TEST_PRIMITIVE_TRIANGLES:
 408                         for (int i = 0; i < 20; ++i)
 409                         {
 410                                 const float x = x0 + rng.getFloat(0.0f, rx - size);
 411                                 const float y = y0 + rng.getFloat(0.0f, ry - size);
 412                                 vertices.push_back(makeVertex(x,             y,        primitiveColor));
 413                                 vertices.push_back(makeVertex(x + size/2.0f, y + size, primitiveColor));
 414                                 vertices.push_back(makeVertex(x + size,      y,        primitiveColor));
 415                         }
 416                         break;
 417
 418                 case TEST_PRIMITIVE_BIG_LINE:
 419                         vertices.push_back(makeVertex(x0,      y0,      primitiveColor));
 420                         vertices.push_back(makeVertex(x0 + rx, y0 + ry, primitiveColor));
 421                         break;
 422
 423                 case TEST_PRIMITIVE_BIG_TRIANGLE:
 424                         vertices.push_back(makeVertex(x0,           y0,      primitiveColor));
 425                         vertices.push_back(makeVertex(x0 + rx/2.0f, y0 + ry, primitiveColor));
 426                         vertices.push_back(makeVertex(x0 + rx,      y0,      primitiveColor));
 427                         break;
 428         }
 429
 430         return vertices;
 431 }
 432
 433 VkPrimitiveTopology     getTopology (const TestPrimitive primitive)
 434 {
 435         switch (primitive)
 436         {
 437                 case TEST_PRIMITIVE_POINTS:                     return VK_PRIMITIVE_TOPOLOGY_POINT_LIST;
 438
 439                 case TEST_PRIMITIVE_LINES:
 440                 case TEST_PRIMITIVE_BIG_LINE:           return VK_PRIMITIVE_TOPOLOGY_LINE_LIST;
 441
 442                 case TEST_PRIMITIVE_TRIANGLES:
 443                 case TEST_PRIMITIVE_BIG_TRIANGLE:       return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
 444
 445                 default:
 446                         DE_ASSERT(0);
 447                         return VK_PRIMITIVE_TOPOLOGY_LAST;
 448         }
 449 }
 450
 451 void zeroBuffer (const DeviceInterface& vk, const VkDevice device, const Allocation& alloc, const VkDeviceSize size)
 452 {
 453         deMemset(alloc.getHostPtr(), 0, static_cast<std::size_t>(size));
 454         flushMappedMemoryRange(vk, device, alloc.getMemory(), alloc.getOffset(), size);
 455 }
 456
 457 //! Transform from normalized coords to framebuffer space.
 458 inline IVec4 getAreaRect (const Vec4& area, const int width, const int height)
 459 {
 460         return IVec4(static_cast<deInt32>(static_cast<float>(width)  * area.x()),
 461                                  static_cast<deInt32>(static_cast<float>(height) * area.y()),
 462                                  static_cast<deInt32>(static_cast<float>(width)  * area.z()),
 463                                  static_cast<deInt32>(static_cast<float>(height) * area.w()));
 464 }
 465
 466 void applyScissor (tcu::PixelBufferAccess imageAccess, const Vec4& floatScissorArea, const Vec4& clearColor)
 467 {
 468         const IVec4     scissorRect     (getAreaRect(floatScissorArea, imageAccess.getWidth(), imageAccess.getHeight()));
 469         const int       sx0                     = scissorRect.x();
 470         const int       sx1                     = scissorRect.x() + scissorRect.z();
 471         const int       sy0                     = scissorRect.y();
 472         const int       sy1                     = scissorRect.y() + scissorRect.w();
 473
 474         for (int y = 0; y < imageAccess.getHeight(); ++y)
 475         for (int x = 0; x < imageAccess.getWidth(); ++x)
 476         {
 477                 // Fragments outside fail the scissor test.
 478                 if (x < sx0 || x >= sx1 || y < sy0 || y >= sy1)
 479                         imageAccess.setPixel(clearColor, x, y);
 480         }
 481 }
 482
 483 void initPrograms (SourceCollections& programCollection, const CaseDef caseDef)
 484 {
 485         DE_UNREF(caseDef);
 486
 487         // Vertex shader
 488         {
 489                 const bool usePointSize = (caseDef.primitive == TEST_PRIMITIVE_POINTS);
 490
 491                 std::ostringstream src;
 492                 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n"
 493                         << "\n"
 494                         << "layout(location = 0) in  vec4 in_position;\n"
 495                         << "layout(location = 1) in  vec4 in_color;\n"
 496                         << "layout(location = 0) out vec4 o_color;\n"
 497                         << "\n"
 498                         << "out gl_PerVertex {\n"
 499                         << "    vec4  gl_Position;\n"
 500                         << (usePointSize ? "    float gl_PointSize;\n" : "")
 501                         << "};\n"
 502                         << "\n"
 503                         << "void main(void)\n"
 504                         << "{\n"
 505                         << "    gl_Position  = in_position;\n"
 506                         << (usePointSize ? "    gl_PointSize = 1.0;\n" : "")
 507                         << "    o_color      = in_color;\n"
 508                         << "}\n";
 509
 510                 programCollection.glslSources.add("vert") << glu::VertexSource(src.str());
 511         }
 512
 513         // Fragment shader
 514         {
 515                 std::ostringstream src;
 516                 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n"
 517                         << "\n"
 518                         << "layout(location = 0) in  vec4 in_color;\n"
 519                         << "layout(location = 0) out vec4 o_color;\n"
 520                         << "\n"
 521                         << "void main(void)\n"
 522                         << "{\n"
 523                         << "    o_color = in_color;\n"
 524                         << "}\n";
 525
 526                 programCollection.glslSources.add("frag") << glu::FragmentSource(src.str());
 527         }
 528 }
 529
 530 class ScissorRenderer
 531 {
 532 public:
 533         ScissorRenderer (Context& context, const CaseDef caseDef, const IVec2& renderSize, const VkFormat colorFormat, const Vec4& primitiveColor, const Vec4& clearColor)
 534                 : m_renderSize                          (renderSize)
 535                 , m_colorFormat                         (colorFormat)
 536                 , m_colorSubresourceRange       (makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u))
 537                 , m_primitiveColor                      (primitiveColor)
 538                 , m_clearColor                          (clearColor)
 539                 , m_vertices                            (genVertices(caseDef.primitive, caseDef.renderArea, m_primitiveColor))
 540                 , m_vertexBufferSize            (sizeInBytes(m_vertices))
 541                 , m_topology                            (getTopology(caseDef.primitive))
 542         {
 543                 const DeviceInterface&          vk                                      = context.getDeviceInterface();
 544                 const VkDevice                          device                          = context.getDevice();
 545                 const deUint32                          queueFamilyIndex        = context.getUniversalQueueFamilyIndex();
 546                 Allocator&                                      allocator                       = context.getDefaultAllocator();
 547
 548                 m_colorImage                    = makeImage(vk, device, makeImageCreateInfo(m_colorFormat, m_renderSize, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT));
 549                 m_colorImageAlloc               = bindImage(vk, device, allocator, *m_colorImage, MemoryRequirement::Any);
 550                 m_colorAttachment               = makeImageView(vk, device, *m_colorImage, VK_IMAGE_VIEW_TYPE_2D, m_colorFormat, m_colorSubresourceRange);
 551
 552                 m_vertexBuffer                  = makeBuffer(vk, device, makeBufferCreateInfo(m_vertexBufferSize, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT));
 553                 m_vertexBufferAlloc             = bindBuffer(vk, device, allocator, *m_vertexBuffer, MemoryRequirement::HostVisible);
 554
 555                 {
 556                         deMemcpy(m_vertexBufferAlloc->getHostPtr(), &m_vertices[0], static_cast<std::size_t>(m_vertexBufferSize));
 557                         flushMappedMemoryRange(vk, device, m_vertexBufferAlloc->getMemory(), m_vertexBufferAlloc->getOffset(), m_vertexBufferSize);
 558                 }
 559
 560                 m_vertexModule                          = createShaderModule    (vk, device, context.getBinaryCollection().get("vert"), 0u);
 561                 m_fragmentModule                        = createShaderModule    (vk, device, context.getBinaryCollection().get("frag"), 0u);
 562                 m_renderPass                            = makeRenderPass                (vk, device, m_colorFormat);
 563                 m_framebuffer                           = makeFramebuffer               (vk, device, *m_renderPass, 1u, &m_colorAttachment.get(),
 564                                                                                                                          static_cast<deUint32>(m_renderSize.x()),  static_cast<deUint32>(m_renderSize.y()));
 565                 m_pipelineLayout                        = makePipelineLayout    (vk, device);
 566                 m_cmdPool                                       = createCommandPool             (vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueFamilyIndex);
 567                 m_cmdBuffer                                     = allocateCommandBuffer (vk, device, *m_cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
 568
 569         }
 570
 571         void draw (Context& context, const Vec4& scissorAreaFloat, const VkBuffer colorBuffer) const
 572         {
 573                 const DeviceInterface&          vk                      = context.getDeviceInterface();
 574                 const VkDevice                          device          = context.getDevice();
 575                 const VkQueue                           queue           = context.getUniversalQueue();
 576
 577                 // New pipeline, because we're modifying scissor (we don't use dynamic state).
 578                 const Unique<VkPipeline>        pipeline        (makeGraphicsPipeline(vk, device, *m_pipelineLayout, *m_renderPass, *m_vertexModule, *m_fragmentModule,
 579                                                                                                  m_renderSize, getAreaRect(scissorAreaFloat, m_renderSize.x(), m_renderSize.y()), m_topology));
 580
 581                 beginCommandBuffer(vk, *m_cmdBuffer);
 582
 583                 const VkClearValue                      clearValue      = makeClearValueColor(m_clearColor);
 584                 const VkRect2D                          renderArea      =
 585                 {
 586                         makeOffset2D(0, 0),
 587                         makeExtent2D(m_renderSize.x(), m_renderSize.y()),
 588                 };
 589                 const VkRenderPassBeginInfo renderPassBeginInfo =
 590                 {
 591                         VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,               // VkStructureType         sType;
 592                         DE_NULL,                                                                                // const void*             pNext;
 593                         *m_renderPass,                                                                  // VkRenderPass            renderPass;
 594                         *m_framebuffer,                                                                 // VkFramebuffer           framebuffer;
 595                         renderArea,                                                                             // VkRect2D                renderArea;
 596                         1u,                                                                                             // uint32_t                clearValueCount;
 597                         &clearValue,                                                                    // const VkClearValue*     pClearValues;
 598                 };
 599                 vk.cmdBeginRenderPass(*m_cmdBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
 600
 601                 vk.cmdBindPipeline(*m_cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
 602                 {
 603                         const VkDeviceSize vertexBufferOffset = 0ull;
 604                         vk.cmdBindVertexBuffers(*m_cmdBuffer, 0u, 1u, &m_vertexBuffer.get(), &vertexBufferOffset);
 605                 }
 606
 607                 vk.cmdDraw(*m_cmdBuffer, static_cast<deUint32>(m_vertices.size()), 1u, 0u, 0u);
 608                 vk.cmdEndRenderPass(*m_cmdBuffer);
 609
 610                 // Prepare color image for copy
 611                 {
 612                         const VkImageMemoryBarrier barriers[] =
 613                         {
 614                                 {
 615                                         VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,                                         // VkStructureType                      sType;
 616                                         DE_NULL,                                                                                                        // const void*                          pNext;
 617                                         VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,                                           // VkAccessFlags                        outputMask;
 618                                         VK_ACCESS_TRANSFER_READ_BIT,                                                            // VkAccessFlags                        inputMask;
 619                                         VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,                                       // VkImageLayout                        oldLayout;
 620                                         VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,                                           // VkImageLayout                        newLayout;
 621                                         VK_QUEUE_FAMILY_IGNORED,                                                                        // deUint32                                     srcQueueFamilyIndex;
 622                                         VK_QUEUE_FAMILY_IGNORED,                                                                        // deUint32                                     destQueueFamilyIndex;
 623                                         *m_colorImage,                                                                                          // VkImage                                      image;
 624                                         m_colorSubresourceRange,                                                                        // VkImageSubresourceRange      subresourceRange;
 625                                 },
 626                         };
 627
 628                         vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u,
 629                                 0u, DE_NULL, 0u, DE_NULL, DE_LENGTH_OF_ARRAY(barriers), barriers);
 630                 }
 631                 // Color image -> host buffer
 632                 {
 633                         const VkBufferImageCopy region =
 634                         {
 635                                 0ull,                                                                                                                                           // VkDeviceSize                bufferOffset;
 636                                 0u,                                                                                                                                                     // uint32_t                    bufferRowLength;
 637                                 0u,                                                                                                                                                     // uint32_t                    bufferImageHeight;
 638                                 makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, 1u),                      // VkImageSubresourceLayers    imageSubresource;
 639                                 makeOffset3D(0, 0, 0),                                                                                                          // VkOffset3D                  imageOffset;
 640                                 makeExtent3D(m_renderSize.x(), m_renderSize.y(), 1u),                                           // VkExtent3D                  imageExtent;
 641                         };
 642
 643                         vk.cmdCopyImageToBuffer(*m_cmdBuffer, *m_colorImage, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, colorBuffer, 1u, &region);
 644                 }
 645                 // Buffer write barrier
 646                 {
 647                         const VkBufferMemoryBarrier barriers[] =
 648                         {
 649                                 {
 650                                         VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,                // VkStructureType    sType;
 651                                         DE_NULL,                                                                                // const void*        pNext;
 652                                         VK_ACCESS_TRANSFER_WRITE_BIT,                                   // VkAccessFlags      srcAccessMask;
 653                                         VK_ACCESS_HOST_READ_BIT,                                                // VkAccessFlags      dstAccessMask;
 654                                         VK_QUEUE_FAMILY_IGNORED,                                                // uint32_t           srcQueueFamilyIndex;
 655                                         VK_QUEUE_FAMILY_IGNORED,                                                // uint32_t           dstQueueFamilyIndex;
 656                                         colorBuffer,                                                                    // VkBuffer           buffer;
 657                                         0ull,                                                                                   // VkDeviceSize       offset;
 658                                         VK_WHOLE_SIZE,                                                                  // VkDeviceSize       size;
 659                                 },
 660                         };
 661
 662                         vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0u,
 663                                 0u, DE_NULL, DE_LENGTH_OF_ARRAY(barriers), barriers, DE_NULL, 0u);
 664                 }
 665
 666                 VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
 667                 submitCommandsAndWait(vk, device, queue, *m_cmdBuffer);
 668         }
 669
 670 private:
 671         const IVec2                                             m_renderSize;
 672         const VkFormat                                  m_colorFormat;
 673         const VkImageSubresourceRange   m_colorSubresourceRange;
 674         const Vec4                                              m_primitiveColor;
 675         const Vec4                                              m_clearColor;
 676         const std::vector<VertexData>   m_vertices;
 677         const VkDeviceSize                              m_vertexBufferSize;
 678         const VkPrimitiveTopology               m_topology;
 679
 680         Move<VkImage>                                   m_colorImage;
 681         MovePtr<Allocation>                             m_colorImageAlloc;
 682         Move<VkImageView>                               m_colorAttachment;
 683         Move<VkBuffer>                                  m_vertexBuffer;
 684         MovePtr<Allocation>                             m_vertexBufferAlloc;
 685         Move<VkShaderModule>                    m_vertexModule;
 686         Move<VkShaderModule>                    m_fragmentModule;
 687         Move<VkRenderPass>                              m_renderPass;
 688         Move<VkFramebuffer>                             m_framebuffer;
 689         Move<VkPipelineLayout>                  m_pipelineLayout;
 690         Move<VkCommandPool>                             m_cmdPool;
 691         Move<VkCommandBuffer>                   m_cmdBuffer;
 692
 693         // "deleted"
 694                                                 ScissorRenderer (const ScissorRenderer&);
 695         ScissorRenderer&        operator=               (const ScissorRenderer&);
 696 };
 697
 698 tcu::TestStatus test (Context& context, const CaseDef caseDef)
 699 {
 700         const DeviceInterface&                  vk                                                      = context.getDeviceInterface();
 701         const VkDevice                                  device                                          = context.getDevice();
 702         Allocator&                                              allocator                                       = context.getDefaultAllocator();
 703
 704         const IVec2                                             renderSize                                      (128, 128);
 705         const VkFormat                                  colorFormat                                     = VK_FORMAT_R8G8B8A8_UNORM;
 706         const Vec4                                              scissorFullArea                         (0.0f, 0.0f, 1.0f, 1.0f);
 707         const Vec4                                              primitiveColor                          (1.0f, 1.0f, 1.0f, 1.0f);
 708         const Vec4                                              clearColor                                      (0.5f, 0.5f, 1.0f, 1.0f);
 709
 710         const VkDeviceSize                              colorBufferSize                         = renderSize.x() * renderSize.y() * tcu::getPixelSize(mapVkFormat(colorFormat));
 711         const Unique<VkBuffer>                  colorBufferFull                         (makeBuffer(vk, device, makeBufferCreateInfo(colorBufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT)));
 712         const UniquePtr<Allocation>             colorBufferFullAlloc            (bindBuffer(vk, device, allocator, *colorBufferFull, MemoryRequirement::HostVisible));
 713
 714         const Unique<VkBuffer>                  colorBufferScissored            (makeBuffer(vk, device, makeBufferCreateInfo(colorBufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT)));
 715         const UniquePtr<Allocation>             colorBufferScissoredAlloc       (bindBuffer(vk, device, allocator, *colorBufferScissored, MemoryRequirement::HostVisible));
 716
 717         zeroBuffer(vk, device, *colorBufferFullAlloc, colorBufferSize);
 718         zeroBuffer(vk, device, *colorBufferScissoredAlloc, colorBufferSize);
 719
 720         // Draw
 721         {
 722                 const ScissorRenderer renderer (context, caseDef, renderSize, colorFormat, primitiveColor, clearColor);
 723
 724                 renderer.draw(context, scissorFullArea, *colorBufferFull);
 725                 renderer.draw(context, caseDef.scissorArea, *colorBufferScissored);
 726         }
 727
 728         // Log image
 729         {
 730                 invalidateMappedMemoryRange(vk, device, colorBufferFullAlloc->getMemory(), 0ull, colorBufferSize);
 731                 invalidateMappedMemoryRange(vk, device, colorBufferScissoredAlloc->getMemory(), 0ull, colorBufferSize);
 732
 733                 const tcu::ConstPixelBufferAccess       resultImage             (mapVkFormat(colorFormat), renderSize.x(), renderSize.y(), 1u, colorBufferScissoredAlloc->getHostPtr());
 734                 tcu::PixelBufferAccess                          referenceImage  (mapVkFormat(colorFormat), renderSize.x(), renderSize.y(), 1u, colorBufferFullAlloc->getHostPtr());
 735
 736                 // Apply scissor to the full image, so we can compare it with the result image.
 737                 applyScissor (referenceImage, caseDef.scissorArea, clearColor);
 738
 739                 // Images should now match.
 740                 if (!tcu::floatThresholdCompare(context.getTestContext().getLog(), "color", "Image compare", referenceImage, resultImage, Vec4(0.02f), tcu::COMPARE_LOG_RESULT))
 741                         return tcu::TestStatus::fail("Rendered image is not correct");
 742         }
 743
 744         return tcu::TestStatus::pass("OK");
 745 }
 746
 747 //! \note The ES 2.0 scissoring tests included color/depth/stencil clear cases, but these operations are not affected by scissor test in Vulkan.
 748 //!       Scissor is part of the pipeline state and pipeline only affects the drawing commands.
 749 void createTestsInGroup (tcu::TestCaseGroup* scissorGroup)
 750 {
 751         tcu::TestContext& testCtx = scissorGroup->getTestContext();
 752
 753         struct TestSpec
 754         {
 755                 const char*             name;
 756                 const char*             description;
 757                 CaseDef                 caseDef;
 758         };
 759
 760         const Vec4      areaFull                        (0.0f, 0.0f, 1.0f, 1.0f);
 761         const Vec4      areaCropped                     (0.2f, 0.2f, 0.6f, 0.6f);
 762         const Vec4      areaCroppedMore         (0.4f, 0.4f, 0.2f, 0.2f);
 763         const Vec4      areaLeftHalf            (0.0f, 0.0f, 0.5f, 1.0f);
 764         const Vec4      areaRightHalf           (0.5f, 0.0f, 0.5f, 1.0f);
 765
 766         // Points
 767         {
 768                 MovePtr<tcu::TestCaseGroup> primitiveGroup (new tcu::TestCaseGroup(testCtx, "points", ""));
 769
 770                 const TestSpec  cases[] =
 771                 {
 772                         { "inside",                             "Points fully inside the scissor area",         { areaFull,             areaFull,               TEST_PRIMITIVE_POINTS } },
 773                         { "partially_inside",   "Points partially inside the scissor area",     { areaFull,             areaCropped,    TEST_PRIMITIVE_POINTS } },
 774                         { "outside",                    "Points fully outside the scissor area",        { areaLeftHalf, areaRightHalf,  TEST_PRIMITIVE_POINTS } },
 775                 };
 776
 777                 for (int i = 0; i < DE_LENGTH_OF_ARRAY(cases); ++i)
 778                         addFunctionCaseWithPrograms(primitiveGroup.get(), cases[i].name, cases[i].description, initPrograms, test, cases[i].caseDef);
 779
 780                 scissorGroup->addChild(primitiveGroup.release());
 781         }
 782
 783         // Lines
 784         {
 785                 MovePtr<tcu::TestCaseGroup> primitiveGroup (new tcu::TestCaseGroup(testCtx, "lines", ""));
 786
 787                 const TestSpec  cases[] =
 788                 {
 789                         { "inside",                             "Lines fully inside the scissor area",          { areaFull,             areaFull,                       TEST_PRIMITIVE_LINES    } },
 790                         { "partially_inside",   "Lines partially inside the scissor area",      { areaFull,             areaCropped,            TEST_PRIMITIVE_LINES    } },
 791                         { "outside",                    "Lines fully outside the scissor area",         { areaLeftHalf, areaRightHalf,          TEST_PRIMITIVE_LINES    } },
 792                         { "crossing",                   "A line crossing the scissor area",                     { areaFull,             areaCroppedMore,        TEST_PRIMITIVE_BIG_LINE } },
 793                 };
 794
 795                 for (int i = 0; i < DE_LENGTH_OF_ARRAY(cases); ++i)
 796                         addFunctionCaseWithPrograms(primitiveGroup.get(), cases[i].name, cases[i].description, initPrograms, test, cases[i].caseDef);
 797
 798                 scissorGroup->addChild(primitiveGroup.release());
 799         }
 800
 801         // Triangles
 802         {
 803                 MovePtr<tcu::TestCaseGroup> primitiveGroup (new tcu::TestCaseGroup(testCtx, "triangles", ""));
 804
 805                 const TestSpec  cases[] =
 806                 {
 807                         { "inside",                             "Triangles fully inside the scissor area",              { areaFull,             areaFull,                       TEST_PRIMITIVE_TRIANGLES        } },
 808                         { "partially_inside",   "Triangles partially inside the scissor area",  { areaFull,             areaCropped,            TEST_PRIMITIVE_TRIANGLES        } },
 809                         { "outside",                    "Triangles fully outside the scissor area",             { areaLeftHalf, areaRightHalf,          TEST_PRIMITIVE_TRIANGLES        } },
 810                         { "crossing",                   "A triangle crossing the scissor area",                 { areaFull,             areaCroppedMore,        TEST_PRIMITIVE_BIG_TRIANGLE     } },
 811                 };
 812
 813                 for (int i = 0; i < DE_LENGTH_OF_ARRAY(cases); ++i)
 814                         addFunctionCaseWithPrograms(primitiveGroup.get(), cases[i].name, cases[i].description, initPrograms, test, cases[i].caseDef);
 815
 816                 scissorGroup->addChild(primitiveGroup.release());
 817         }
 818
 819         // Mulit-viewport scissor
 820         {
 821                 scissorGroup->addChild(createScissorMultiViewportTests(testCtx));
 822         }
 823 }
 824
 825 } // anonymous
 826
 827 tcu::TestCaseGroup* createScissorTests (tcu::TestContext& testCtx)
 828 {
 829         return createTestGroup(testCtx, "scissor", "Scissor tests", createTestsInGroup);
 830 }
 831
 832 } // FragmentOperations
 833 } // vkt