external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateRSTests.cpp

   1 /*------------------------------------------------------------------------
   2  * Vulkan Conformance Tests
   3  * ------------------------
   4  *
   5  * Copyright (c) 2015 The Khronos Group Inc.
   6  * Copyright (c) 2015 Intel Corporation
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a
   9  * copy of this software and/or associated documentation files (the
  10  * "Materials"), to deal in the Materials without restriction, including
  11  * without limitation the rights to use, copy, modify, merge, publish,
  12  * distribute, sublicense, and/or sell copies of the Materials, and to
  13  * permit persons to whom the Materials are furnished to do so, subject to
  14  * the following conditions:
  15  *
  16  * The above copyright notice(s) and this permission notice shall be included
  17  * in all copies or substantial portions of the Materials.
  18  *
  19  * The Materials are Confidential Information as defined by the
  20  * Khronos Membership Agreement until designated non-confidential by Khronos,
  21  * at which point this condition clause shall be removed.
  22  *
  23  * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  26  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
  27  * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  28  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  29  * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
  30  *
  31  *//*!
  32  * \file
  33  * \brief Dynamic Raster State Tests
  34  *//*--------------------------------------------------------------------*/
  35
  36 #include "vktDynamicStateRSTests.hpp"
  37
  38 #include "vktDynamicStateBaseClass.hpp"
  39 #include "vktDynamicStateTestCaseUtil.hpp"
  40
  41 #include "vkImageUtil.hpp"
  42
  43 #include "tcuTextureUtil.hpp"
  44 #include "tcuImageCompare.hpp"
  45 #include "tcuRGBA.hpp"
  46
  47 #include "deMath.h"
  48
  49 namespace vkt
  50 {
  51 namespace DynamicState
  52 {
  53 namespace
  54 {
  55
  56 class DepthBiasBaseCase : public TestInstance
  57 {
  58 public:
  59         DepthBiasBaseCase (Context& context, const char* vertexShaderName, const char* fragmentShaderName)
  60                 : TestInstance                                          (context)
  61                 , m_colorAttachmentFormat                       (vk::VK_FORMAT_R8G8B8A8_UNORM)
  62                 , m_topology                                            (vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP)
  63                 , m_vk                                                          (context.getDeviceInterface())
  64                 , m_vertexShaderName                            (vertexShaderName)
  65                 , m_fragmentShaderName                          (fragmentShaderName)
  66         {
  67         }
  68
  69 protected:
  70
  71         enum
  72         {
  73                 WIDTH   = 128,
  74                 HEIGHT  = 128
  75         };
  76
  77         vk::VkFormat                                                                    m_colorAttachmentFormat;
  78         vk::VkFormat                                                                    m_depthStencilAttachmentFormat;
  79
  80         vk::VkPrimitiveTopology                                                 m_topology;
  81
  82         const vk::DeviceInterface&                                              m_vk;
  83
  84         vk::Move<vk::VkPipeline>                                                m_pipeline;
  85         vk::Move<vk::VkPipelineLayout>                                  m_pipelineLayout;
  86
  87         de::SharedPtr<Image>                                                    m_colorTargetImage;
  88         vk::Move<vk::VkImageView>                                               m_colorTargetView;
  89
  90         de::SharedPtr<Image>                                                    m_depthStencilImage;
  91         vk::Move<vk::VkImageView>                                               m_attachmentView;
  92
  93         PipelineCreateInfo::VertexInputState                    m_vertexInputState;
  94         de::SharedPtr<Buffer>                                                   m_vertexBuffer;
  95
  96         vk::Move<vk::VkCommandPool>                                             m_cmdPool;
  97         vk::Move<vk::VkCommandBuffer>                                   m_cmdBuffer;
  98
  99         vk::Move<vk::VkFramebuffer>                                             m_framebuffer;
 100         vk::Move<vk::VkRenderPass>                                              m_renderPass;
 101
 102         std::string                                                                             m_vertexShaderName;
 103         std::string                                                                             m_fragmentShaderName;
 104
 105         std::vector<PositionColorVertex>                                m_data;
 106
 107         PipelineCreateInfo::DepthStencilState                   m_depthStencilState;
 108
 109         void initialize (void)
 110         {
 111                 const vk::VkDevice device       = m_context.getDevice();
 112
 113                 vk::VkFormatProperties formatProperties;
 114                 // check for VK_FORMAT_D24_UNORM_S8_UINT support
 115                 m_context.getInstanceInterface().getPhysicalDeviceFormatProperties(m_context.getPhysicalDevice(), vk::VK_FORMAT_D24_UNORM_S8_UINT, &formatProperties);
 116                 if (formatProperties.optimalTilingFeatures & vk::VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)
 117                 {
 118                         m_depthStencilAttachmentFormat = vk::VK_FORMAT_D24_UNORM_S8_UINT;
 119                 }
 120                 else
 121                 {
 122                         // check for VK_FORMAT_D32_SFLOAT_S8_UINT support
 123                         m_context.getInstanceInterface().getPhysicalDeviceFormatProperties(m_context.getPhysicalDevice(), vk::VK_FORMAT_D32_SFLOAT_S8_UINT, &formatProperties);
 124                         if (formatProperties.optimalTilingFeatures & vk::VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)
 125                         {
 126                                 m_depthStencilAttachmentFormat = vk::VK_FORMAT_D32_SFLOAT_S8_UINT;
 127                         }
 128                         else
 129                                 throw tcu::NotSupportedError("No valid depth stencil attachment available");
 130                 }
 131
 132                 const PipelineLayoutCreateInfo pipelineLayoutCreateInfo;
 133                 m_pipelineLayout                        = vk::createPipelineLayout(m_vk, device, &pipelineLayoutCreateInfo);
 134
 135                 const vk::Unique<vk::VkShaderModule> vs(createShaderModule(m_vk, device, m_context.getBinaryCollection().get(m_vertexShaderName), 0));
 136                 const vk::Unique<vk::VkShaderModule> fs(createShaderModule(m_vk, device, m_context.getBinaryCollection().get(m_fragmentShaderName), 0));
 137
 138                 const vk::VkExtent3D imageExtent = { WIDTH, HEIGHT, 1 };
 139                 ImageCreateInfo targetImageCreateInfo(vk::VK_IMAGE_TYPE_2D, m_colorAttachmentFormat, imageExtent, 1, 1, vk::VK_SAMPLE_COUNT_1_BIT, vk::VK_IMAGE_TILING_OPTIMAL,
 140                                                                                           vk::VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | vk::VK_IMAGE_USAGE_TRANSFER_SRC_BIT);
 141
 142                 m_colorTargetImage = Image::createAndAlloc(m_vk, device, targetImageCreateInfo, m_context.getDefaultAllocator());
 143
 144                 const ImageCreateInfo depthStencilImageCreateInfo(vk::VK_IMAGE_TYPE_2D, m_depthStencilAttachmentFormat, imageExtent,
 145                                                                                                                   1, 1, vk::VK_SAMPLE_COUNT_1_BIT, vk::VK_IMAGE_TILING_OPTIMAL,
 146                                                                                                                   vk::VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT);
 147
 148                 m_depthStencilImage = Image::createAndAlloc(m_vk, device, depthStencilImageCreateInfo, m_context.getDefaultAllocator());
 149
 150                 const ImageViewCreateInfo colorTargetViewInfo(m_colorTargetImage->object(), vk::VK_IMAGE_VIEW_TYPE_2D, m_colorAttachmentFormat);
 151                 m_colorTargetView = vk::createImageView(m_vk, device, &colorTargetViewInfo);
 152
 153                 const ImageViewCreateInfo attachmentViewInfo(m_depthStencilImage->object(), vk::VK_IMAGE_VIEW_TYPE_2D, m_depthStencilAttachmentFormat);
 154                 m_attachmentView = vk::createImageView(m_vk, device, &attachmentViewInfo);
 155
 156                 RenderPassCreateInfo renderPassCreateInfo;
 157                 renderPassCreateInfo.addAttachment(AttachmentDescription(m_colorAttachmentFormat,
 158                                                                                                                                  vk::VK_SAMPLE_COUNT_1_BIT,
 159                                                                                                                                  vk::VK_ATTACHMENT_LOAD_OP_LOAD,
 160                                                                                                                                  vk::VK_ATTACHMENT_STORE_OP_STORE,
 161                                                                                                                                  vk::VK_ATTACHMENT_LOAD_OP_DONT_CARE,
 162                                                                                                                                  vk::VK_ATTACHMENT_STORE_OP_STORE,
 163                                                                                                                                  vk::VK_IMAGE_LAYOUT_GENERAL,
 164                                                                                                                                  vk::VK_IMAGE_LAYOUT_GENERAL));
 165
 166                 renderPassCreateInfo.addAttachment(AttachmentDescription(m_depthStencilAttachmentFormat,
 167                                                                                                                                  vk::VK_SAMPLE_COUNT_1_BIT,
 168                                                                                                                                  vk::VK_ATTACHMENT_LOAD_OP_LOAD,
 169                                                                                                                                  vk::VK_ATTACHMENT_STORE_OP_STORE,
 170                                                                                                                                  vk::VK_ATTACHMENT_LOAD_OP_DONT_CARE,
 171                                                                                                                                  vk::VK_ATTACHMENT_STORE_OP_STORE,
 172                                                                                                                                  vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
 173                                                                                                                                  vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL));
 174
 175                 const vk::VkAttachmentReference colorAttachmentReference =
 176                 {
 177                         0,
 178                         vk::VK_IMAGE_LAYOUT_GENERAL
 179                 };
 180
 181                 const vk::VkAttachmentReference depthAttachmentReference =
 182                 {
 183                         1,
 184                         vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL
 185                 };
 186
 187                 renderPassCreateInfo.addSubpass(SubpassDescription(vk::VK_PIPELINE_BIND_POINT_GRAPHICS,
 188                                                                                                                    0,
 189                                                                                                                    0,
 190                                                                                                                    DE_NULL,
 191                                                                                                                    1,
 192                                                                                                                    &colorAttachmentReference,
 193                                                                                                                    DE_NULL,
 194                                                                                                                    depthAttachmentReference,
 195                                                                                                                    0,
 196                                                                                                                    DE_NULL));
 197
 198                 m_renderPass = vk::createRenderPass(m_vk, device, &renderPassCreateInfo);
 199
 200                 const vk::VkVertexInputBindingDescription vertexInputBindingDescription =
 201                 {
 202                         0,
 203                         (deUint32)sizeof(tcu::Vec4) * 2,
 204                         vk::VK_VERTEX_INPUT_RATE_VERTEX,
 205                 };
 206
 207                 const vk::VkVertexInputAttributeDescription vertexInputAttributeDescriptions[2] =
 208                 {
 209                         {
 210                                 0u,
 211                                 0u,
 212                                 vk::VK_FORMAT_R32G32B32A32_SFLOAT,
 213                                 0u
 214                         },
 215                         {
 216                                 1u,
 217                                 0u,
 218                                 vk::VK_FORMAT_R32G32B32A32_SFLOAT,
 219                                 (deUint32)(sizeof(float)* 4),
 220                         }
 221                 };
 222
 223                 m_vertexInputState = PipelineCreateInfo::VertexInputState(1,
 224                                                                                                                                   &vertexInputBindingDescription,
 225                                                                                                                                   2,
 226                                                                                                                                   vertexInputAttributeDescriptions);
 227
 228                 const PipelineCreateInfo::ColorBlendState::Attachment vkCbAttachmentState;
 229
 230                 PipelineCreateInfo pipelineCreateInfo(*m_pipelineLayout, *m_renderPass, 0, 0);
 231                 pipelineCreateInfo.addShader(PipelineCreateInfo::PipelineShaderStage(*vs, "main", vk::VK_SHADER_STAGE_VERTEX_BIT));
 232                 pipelineCreateInfo.addShader(PipelineCreateInfo::PipelineShaderStage(*fs, "main", vk::VK_SHADER_STAGE_FRAGMENT_BIT));
 233                 pipelineCreateInfo.addState(PipelineCreateInfo::VertexInputState(m_vertexInputState));
 234                 pipelineCreateInfo.addState(PipelineCreateInfo::InputAssemblerState(m_topology));
 235                 pipelineCreateInfo.addState(PipelineCreateInfo::ColorBlendState(1, &vkCbAttachmentState));
 236                 pipelineCreateInfo.addState(PipelineCreateInfo::ViewportState(1));
 237                 pipelineCreateInfo.addState(m_depthStencilState);
 238                 pipelineCreateInfo.addState(PipelineCreateInfo::RasterizerState());
 239                 pipelineCreateInfo.addState(PipelineCreateInfo::MultiSampleState());
 240                 pipelineCreateInfo.addState(PipelineCreateInfo::DynamicState());
 241
 242                 m_pipeline = vk::createGraphicsPipeline(m_vk, device, DE_NULL, &pipelineCreateInfo);
 243
 244                 std::vector<vk::VkImageView> attachments(2);
 245                 attachments[0] = *m_colorTargetView;
 246                 attachments[1] = *m_attachmentView;
 247
 248                 const FramebufferCreateInfo framebufferCreateInfo(*m_renderPass, attachments, WIDTH, HEIGHT, 1);
 249
 250                 m_framebuffer = vk::createFramebuffer(m_vk, device, &framebufferCreateInfo);
 251
 252                 const vk::VkDeviceSize dataSize = m_data.size() * sizeof(PositionColorVertex);
 253                 m_vertexBuffer = Buffer::createAndAlloc(m_vk, device, BufferCreateInfo(dataSize,
 254                         vk::VK_BUFFER_USAGE_VERTEX_BUFFER_BIT),
 255                         m_context.getDefaultAllocator(), vk::MemoryRequirement::HostVisible);
 256
 257                 deUint8* ptr = reinterpret_cast<unsigned char *>(m_vertexBuffer->getBoundMemory().getHostPtr());
 258                 deMemcpy(ptr, &m_data[0], static_cast<size_t>(dataSize));
 259
 260                 vk::flushMappedMemoryRange(m_vk, device,
 261                                                                    m_vertexBuffer->getBoundMemory().getMemory(),
 262                                                                    m_vertexBuffer->getBoundMemory().getOffset(),
 263                                                                    sizeof(dataSize));
 264
 265                 const CmdPoolCreateInfo cmdPoolCreateInfo(m_context.getUniversalQueueFamilyIndex());
 266                 m_cmdPool = vk::createCommandPool(m_vk, device, &cmdPoolCreateInfo);
 267
 268                 const vk::VkCommandBufferAllocateInfo cmdBufferAllocateInfo =
 269                 {
 270                         vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,     // VkStructureType                      sType;
 271                         DE_NULL,                                                                                        // const void*                          pNext;
 272                         *m_cmdPool,                                                                                     // VkCommandPool                        commandPool;
 273                         vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY,                            // VkCommandBufferLevel         level;
 274                         1u,                                                                                                     // deUint32                                     bufferCount;
 275                 };
 276                 m_cmdBuffer = vk::allocateCommandBuffer(m_vk, device, &cmdBufferAllocateInfo);
 277         }
 278
 279         virtual tcu::TestStatus iterate (void)
 280         {
 281                 DE_ASSERT(false);
 282                 return tcu::TestStatus::fail("Should reimplement iterate() method");
 283         }
 284
 285         void beginRenderPass (void)
 286         {
 287                 const vk::VkClearColorValue clearColor = { { 0.0f, 0.0f, 0.0f, 1.0f } };
 288                 beginRenderPassWithClearColor(clearColor);
 289         }
 290
 291         void beginRenderPassWithClearColor (const vk::VkClearColorValue &clearColor)
 292         {
 293                 const CmdBufferBeginInfo beginInfo;
 294                 m_vk.beginCommandBuffer(*m_cmdBuffer, &beginInfo);
 295
 296                 initialTransitionColor2DImage(m_vk, *m_cmdBuffer, m_colorTargetImage->object(), vk::VK_IMAGE_LAYOUT_GENERAL);
 297                 initialTransitionDepthStencil2DImage(m_vk, *m_cmdBuffer, m_depthStencilImage->object(), vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
 298
 299                 const ImageSubresourceRange subresourceRangeImage(vk::VK_IMAGE_ASPECT_COLOR_BIT);
 300                 m_vk.cmdClearColorImage(*m_cmdBuffer, m_colorTargetImage->object(),
 301                                                                 vk::VK_IMAGE_LAYOUT_GENERAL, &clearColor, 1, &subresourceRangeImage);
 302
 303                 const vk::VkClearDepthStencilValue depthStencilClearValue = { 0.0f, 0 };
 304
 305                 const ImageSubresourceRange subresourceRangeDepthStencil[2] = { vk::VK_IMAGE_ASPECT_DEPTH_BIT, vk::VK_IMAGE_ASPECT_STENCIL_BIT };
 306                 m_vk.cmdClearDepthStencilImage(*m_cmdBuffer, m_depthStencilImage->object(),
 307                                                                            vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &depthStencilClearValue, 2, subresourceRangeDepthStencil);
 308
 309                 const vk::VkRect2D renderArea = { { 0, 0 }, { WIDTH, HEIGHT } };
 310                 const RenderPassBeginInfo renderPassBegin(*m_renderPass, *m_framebuffer, renderArea);
 311
 312                 m_vk.cmdBeginRenderPass(*m_cmdBuffer, &renderPassBegin, vk::VK_SUBPASS_CONTENTS_INLINE);
 313         }
 314
 315         void setDynamicViewportState (const deUint32 width, const deUint32 height)
 316         {
 317                 vk::VkViewport viewport;
 318                 viewport.x = 0;
 319                 viewport.y = 0;
 320                 viewport.width = static_cast<float>(width);
 321                 viewport.height = static_cast<float>(height);
 322                 viewport.minDepth = 0.0f;
 323                 viewport.maxDepth = 1.0f;
 324
 325                 m_vk.cmdSetViewport(*m_cmdBuffer, 0, 1, &viewport);
 326
 327                 vk::VkRect2D scissor;
 328                 scissor.offset.x = 0;
 329                 scissor.offset.y = 0;
 330                 scissor.extent.width = width;
 331                 scissor.extent.height = height;
 332                 m_vk.cmdSetScissor(*m_cmdBuffer, 0, 1, &scissor);
 333         }
 334
 335         void setDynamicViewportState (const deUint32 viewportCount, const vk::VkViewport* pViewports, const vk::VkRect2D* pScissors)
 336         {
 337                 m_vk.cmdSetViewport(*m_cmdBuffer, 0, viewportCount, pViewports);
 338                 m_vk.cmdSetScissor(*m_cmdBuffer, 0, viewportCount, pScissors);
 339         }
 340
 341         void setDynamicRasterizationState (const float lineWidth = 1.0f,
 342                 const float depthBiasConstantFactor = 0.0f,
 343                 const float depthBiasClamp = 0.0f,
 344                 const float depthBiasSlopeFactor = 0.0f)
 345         {
 346                 m_vk.cmdSetLineWidth(*m_cmdBuffer, lineWidth);
 347                 m_vk.cmdSetDepthBias(*m_cmdBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
 348         }
 349
 350         void setDynamicBlendState (const float const1 = 0.0f, const float const2 = 0.0f,
 351                 const float const3 = 0.0f, const float const4 = 0.0f)
 352         {
 353                 float blendConstantsants[4] = { const1, const2, const3, const4 };
 354                 m_vk.cmdSetBlendConstants(*m_cmdBuffer, blendConstantsants);
 355         }
 356
 357         void setDynamicDepthStencilState (const float minDepthBounds = -1.0f, const float maxDepthBounds = 1.0f,
 358                 const deUint32 stencilFrontCompareMask = 0xffffffffu, const deUint32 stencilFrontWriteMask = 0xffffffffu,
 359                 const deUint32 stencilFrontReference = 0, const deUint32 stencilBackCompareMask = 0xffffffffu,
 360                 const deUint32 stencilBackWriteMask = 0xffffffffu, const deUint32 stencilBackReference = 0)
 361         {
 362                 m_vk.cmdSetDepthBounds(*m_cmdBuffer, minDepthBounds, maxDepthBounds);
 363                 m_vk.cmdSetStencilCompareMask(*m_cmdBuffer, vk::VK_STENCIL_FACE_FRONT_BIT, stencilFrontCompareMask);
 364                 m_vk.cmdSetStencilWriteMask(*m_cmdBuffer, vk::VK_STENCIL_FACE_FRONT_BIT, stencilFrontWriteMask);
 365                 m_vk.cmdSetStencilReference(*m_cmdBuffer, vk::VK_STENCIL_FACE_FRONT_BIT, stencilFrontReference);
 366                 m_vk.cmdSetStencilCompareMask(*m_cmdBuffer, vk::VK_STENCIL_FACE_BACK_BIT, stencilBackCompareMask);
 367                 m_vk.cmdSetStencilWriteMask(*m_cmdBuffer, vk::VK_STENCIL_FACE_BACK_BIT, stencilBackWriteMask);
 368                 m_vk.cmdSetStencilReference(*m_cmdBuffer, vk::VK_STENCIL_FACE_BACK_BIT, stencilBackReference);
 369         }
 370 };
 371
 372 class DepthBiasParamTestInstance : public DepthBiasBaseCase
 373 {
 374 public:
 375         DepthBiasParamTestInstance (Context& context, ShaderMap shaders)
 376                 : DepthBiasBaseCase (context, shaders[glu::SHADERTYPE_VERTEX], shaders[glu::SHADERTYPE_FRAGMENT])
 377         {
 378                 m_data.push_back(PositionColorVertex(tcu::Vec4(-1.0f, 1.0f, 0.5f, 1.0f), tcu::RGBA::blue().toVec()));
 379                 m_data.push_back(PositionColorVertex(tcu::Vec4(1.0f, 1.0f, 0.5f, 1.0f), tcu::RGBA::blue().toVec()));
 380                 m_data.push_back(PositionColorVertex(tcu::Vec4(-1.0f, -1.0f, 0.5f, 1.0f), tcu::RGBA::blue().toVec()));
 381                 m_data.push_back(PositionColorVertex(tcu::Vec4(1.0f, -1.0f, 0.5f, 1.0f), tcu::RGBA::blue().toVec()));
 382
 383                 m_data.push_back(PositionColorVertex(tcu::Vec4(-0.5f, 0.5f, 1.0f, 1.0f), tcu::RGBA::green().toVec()));
 384                 m_data.push_back(PositionColorVertex(tcu::Vec4(0.5f, 0.5f, 1.0f, 1.0f), tcu::RGBA::green().toVec()));
 385                 m_data.push_back(PositionColorVertex(tcu::Vec4(-0.5f, -0.5f, 1.0f, 1.0f), tcu::RGBA::green().toVec()));
 386                 m_data.push_back(PositionColorVertex(tcu::Vec4(0.5f, -0.5f, 1.0f, 1.0f), tcu::RGBA::green().toVec()));
 387
 388                 m_data.push_back(PositionColorVertex(tcu::Vec4(-1.0f, 1.0f, 0.5f, 1.0f), tcu::RGBA::red().toVec()));
 389                 m_data.push_back(PositionColorVertex(tcu::Vec4(1.0f, 1.0f, 0.5f, 1.0f), tcu::RGBA::red().toVec()));
 390                 m_data.push_back(PositionColorVertex(tcu::Vec4(-1.0f, -1.0f, 0.5f, 1.0f), tcu::RGBA::red().toVec()));
 391                 m_data.push_back(PositionColorVertex(tcu::Vec4(1.0f, -1.0f, 0.5f, 1.0f), tcu::RGBA::red().toVec()));
 392
 393                 // enable depth test
 394                 m_depthStencilState = PipelineCreateInfo::DepthStencilState(
 395                         vk::VK_TRUE, vk::VK_TRUE, vk::VK_COMPARE_OP_GREATER_OR_EQUAL);
 396
 397                 DepthBiasBaseCase::initialize();
 398         }
 399
 400         virtual tcu::TestStatus iterate (void)
 401         {
 402                 tcu::TestLog &log               = m_context.getTestContext().getLog();
 403                 const vk::VkQueue queue = m_context.getUniversalQueue();
 404
 405                 beginRenderPass();
 406
 407                 // set states here
 408                 setDynamicViewportState(WIDTH, HEIGHT);
 409                 setDynamicBlendState();
 410                 setDynamicDepthStencilState();
 411
 412                 m_vk.cmdBindPipeline(*m_cmdBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipeline);
 413
 414                 const vk::VkDeviceSize vertexBufferOffset       = 0;
 415                 const vk::VkBuffer vertexBuffer                         = m_vertexBuffer->object();
 416                 m_vk.cmdBindVertexBuffers(*m_cmdBuffer, 0, 1, &vertexBuffer, &vertexBufferOffset);
 417
 418                 setDynamicRasterizationState(1.0f, 0.0f);
 419                 m_vk.cmdDraw(*m_cmdBuffer, 4, 1, 0, 0);
 420                 m_vk.cmdDraw(*m_cmdBuffer, 4, 1, 4, 0);
 421
 422                 setDynamicRasterizationState(1.0f, -1.0f);
 423                 m_vk.cmdDraw(*m_cmdBuffer, 4, 1, 8, 0);
 424
 425                 m_vk.cmdEndRenderPass(*m_cmdBuffer);
 426                 m_vk.endCommandBuffer(*m_cmdBuffer);
 427
 428                 vk::VkSubmitInfo submitInfo =
 429                 {
 430                         vk::VK_STRUCTURE_TYPE_SUBMIT_INFO,      // VkStructureType                      sType;
 431                         DE_NULL,                                                        // const void*                          pNext;
 432                         0,                                                                      // deUint32                                     waitSemaphoreCount;
 433                         DE_NULL,                                                        // const VkSemaphore*           pWaitSemaphores;
 434                         (const vk::VkPipelineStageFlags*)DE_NULL,
 435                         1,                                                                      // deUint32                                     commandBufferCount;
 436                         &m_cmdBuffer.get(),                                     // const VkCommandBuffer*       pCommandBuffers;
 437                         0,                                                                      // deUint32                                     signalSemaphoreCount;
 438                         DE_NULL                                                         // const VkSemaphore*           pSignalSemaphores;
 439                 };
 440                 m_vk.queueSubmit(queue, 1, &submitInfo, DE_NULL);
 441
 442                 // validation
 443                 {
 444                         VK_CHECK(m_vk.queueWaitIdle(queue));
 445
 446                         tcu::Texture2D referenceFrame(vk::mapVkFormat(m_colorAttachmentFormat), (int)(0.5 + WIDTH), (int)(0.5 + HEIGHT));
 447                         referenceFrame.allocLevel(0);
 448
 449                         const deInt32 frameWidth = referenceFrame.getWidth();
 450                         const deInt32 frameHeight = referenceFrame.getHeight();
 451
 452                         tcu::clear(referenceFrame.getLevel(0), tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f));
 453
 454                         for (int y = 0; y < frameHeight; y++)
 455                         {
 456                                 const float yCoord = (float)(y / (0.5*frameHeight)) - 1.0f;
 457
 458                                 for (int x = 0; x < frameWidth; x++)
 459                                 {
 460                                         const float xCoord = (float)(x / (0.5*frameWidth)) - 1.0f;
 461
 462                                         if (xCoord >= -0.5f && xCoord <= 0.5f && yCoord >= -0.5f && yCoord <= 0.5f)
 463                                                 referenceFrame.getLevel(0).setPixel(tcu::Vec4(0.0f, 1.0f, 0.0f, 1.0f), x, y);
 464                                         else
 465                                                 referenceFrame.getLevel(0).setPixel(tcu::Vec4(0.0f, 0.0f, 1.0f, 1.0f), x, y);
 466                                 }
 467                         }
 468
 469                         const vk::VkOffset3D zeroOffset = { 0, 0, 0 };
 470                         const tcu::ConstPixelBufferAccess renderedFrame = m_colorTargetImage->readSurface(queue, m_context.getDefaultAllocator(),
 471                                 vk::VK_IMAGE_LAYOUT_GENERAL, zeroOffset, WIDTH, HEIGHT, vk::VK_IMAGE_ASPECT_COLOR_BIT);
 472
 473                         if (!tcu::fuzzyCompare(log, "Result", "Image comparison result",
 474                                 referenceFrame.getLevel(0), renderedFrame, 0.05f,
 475                                 tcu::COMPARE_LOG_RESULT))
 476                         {
 477                                 return tcu::TestStatus(QP_TEST_RESULT_FAIL, "Image verification failed");
 478                         }
 479
 480                         return tcu::TestStatus(QP_TEST_RESULT_PASS, "Image verification passed");
 481                 }
 482         }
 483 };
 484
 485 class DepthBiasClampParamTestInstance : public DepthBiasBaseCase
 486 {
 487 public:
 488         DepthBiasClampParamTestInstance (Context& context, ShaderMap shaders)
 489                 : DepthBiasBaseCase (context, shaders[glu::SHADERTYPE_VERTEX], shaders[glu::SHADERTYPE_FRAGMENT])
 490         {
 491                 m_data.push_back(PositionColorVertex(tcu::Vec4(-1.0f, 1.0f, 0.0f, 1.0f), tcu::RGBA::blue().toVec()));
 492                 m_data.push_back(PositionColorVertex(tcu::Vec4(1.0f, 1.0f, 0.0f, 1.0f), tcu::RGBA::blue().toVec()));
 493                 m_data.push_back(PositionColorVertex(tcu::Vec4(-1.0f, -1.0f, 0.0f, 1.0f), tcu::RGBA::blue().toVec()));
 494                 m_data.push_back(PositionColorVertex(tcu::Vec4(1.0f, -1.0f, 0.0f, 1.0f), tcu::RGBA::blue().toVec()));
 495
 496                 m_data.push_back(PositionColorVertex(tcu::Vec4(-0.5f, 0.5f, 0.01f, 1.0f), tcu::RGBA::green().toVec()));
 497                 m_data.push_back(PositionColorVertex(tcu::Vec4(0.5f, 0.5f, 0.01f, 1.0f), tcu::RGBA::green().toVec()));
 498                 m_data.push_back(PositionColorVertex(tcu::Vec4(-0.5f, -0.5f, 0.01f, 1.0f), tcu::RGBA::green().toVec()));
 499                 m_data.push_back(PositionColorVertex(tcu::Vec4(0.5f, -0.5f, 0.01f, 1.0f), tcu::RGBA::green().toVec()));
 500
 501                 // enable depth test
 502                 m_depthStencilState = PipelineCreateInfo::DepthStencilState(vk::VK_TRUE, vk::VK_TRUE, vk::VK_COMPARE_OP_GREATER_OR_EQUAL);
 503
 504                 DepthBiasBaseCase::initialize();
 505         }
 506
 507         virtual tcu::TestStatus iterate (void)
 508         {
 509                 tcu::TestLog &log = m_context.getTestContext().getLog();
 510                 const vk::VkQueue queue = m_context.getUniversalQueue();
 511
 512                 beginRenderPass();
 513
 514                 // set states here
 515                 setDynamicViewportState(WIDTH, HEIGHT);
 516                 setDynamicBlendState();
 517                 setDynamicDepthStencilState();
 518
 519                 m_vk.cmdBindPipeline(*m_cmdBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipeline);
 520
 521                 const vk::VkDeviceSize vertexBufferOffset = 0;
 522                 const vk::VkBuffer vertexBuffer = m_vertexBuffer->object();
 523                 m_vk.cmdBindVertexBuffers(*m_cmdBuffer, 0, 1, &vertexBuffer, &vertexBufferOffset);
 524
 525                 setDynamicRasterizationState(1.0f, 1000.0f, 0.005f);
 526                 m_vk.cmdDraw(*m_cmdBuffer, 4, 1, 0, 0);
 527
 528                 setDynamicRasterizationState(1.0f, 0.0f);
 529                 m_vk.cmdDraw(*m_cmdBuffer, 4, 1, 4, 0);
 530
 531                 m_vk.cmdEndRenderPass(*m_cmdBuffer);
 532                 m_vk.endCommandBuffer(*m_cmdBuffer);
 533
 534                 vk::VkSubmitInfo submitInfo =
 535                 {
 536                         vk::VK_STRUCTURE_TYPE_SUBMIT_INFO,      // VkStructureType                      sType;
 537                         DE_NULL,                                                        // const void*                          pNext;
 538                         0,                                                                      // deUint32                                     waitSemaphoreCount;
 539                         DE_NULL,                                                        // const VkSemaphore*           pWaitSemaphores;
 540                         (const vk::VkPipelineStageFlags*)DE_NULL,
 541                         1,                                                                      // deUint32                                     commandBufferCount;
 542                         &m_cmdBuffer.get(),                                     // const VkCommandBuffer*       pCommandBuffers;
 543                         0,                                                                      // deUint32                                     signalSemaphoreCount;
 544                         DE_NULL                                                         // const VkSemaphore*           pSignalSemaphores;
 545                 };
 546                 m_vk.queueSubmit(queue, 1, &submitInfo, DE_NULL);
 547
 548                 // validation
 549                 {
 550                         VK_CHECK(m_vk.queueWaitIdle(queue));
 551
 552                         tcu::Texture2D referenceFrame(vk::mapVkFormat(m_colorAttachmentFormat), (int)(0.5 + WIDTH), (int)(0.5 + HEIGHT));
 553                         referenceFrame.allocLevel(0);
 554
 555                         const deInt32 frameWidth        = referenceFrame.getWidth();
 556                         const deInt32 frameHeight       = referenceFrame.getHeight();
 557
 558                         tcu::clear(referenceFrame.getLevel(0), tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f));
 559
 560                         for (int y = 0; y < frameHeight; y++)
 561                         {
 562                                 float yCoord = (float)(y / (0.5*frameHeight)) - 1.0f;
 563
 564                                 for (int x = 0; x < frameWidth; x++)
 565                                 {
 566                                         float xCoord = (float)(x / (0.5*frameWidth)) - 1.0f;
 567
 568                                         if (xCoord >= -0.5f && xCoord <= 0.5f && yCoord >= -0.5f && yCoord <= 0.5f)
 569                                                 referenceFrame.getLevel(0).setPixel(tcu::Vec4(0.0f, 1.0f, 0.0f, 1.0f), x, y);
 570                                         else
 571                                                 referenceFrame.getLevel(0).setPixel(tcu::Vec4(0.0f, 0.0f, 1.0f, 1.0f), x, y);
 572                                 }
 573                         }
 574
 575                         const vk::VkOffset3D zeroOffset                                 = { 0, 0, 0 };
 576                         const tcu::ConstPixelBufferAccess renderedFrame = m_colorTargetImage->readSurface(queue, m_context.getDefaultAllocator(),
 577                                 vk::VK_IMAGE_LAYOUT_GENERAL, zeroOffset, WIDTH, HEIGHT, vk::VK_IMAGE_ASPECT_COLOR_BIT);
 578
 579                         if (!tcu::fuzzyCompare(log, "Result", "Image comparison result",
 580                                 referenceFrame.getLevel(0), renderedFrame, 0.05f,
 581                                 tcu::COMPARE_LOG_RESULT))
 582                         {
 583                                 return tcu::TestStatus(QP_TEST_RESULT_FAIL, "Image verification failed");
 584                         }
 585
 586                         return tcu::TestStatus(QP_TEST_RESULT_PASS, "Image verification passed");
 587                 }
 588         }
 589 };
 590
 591 class LineWidthParamTestInstance : public DynamicStateBaseClass
 592 {
 593 public:
 594         LineWidthParamTestInstance (Context& context, ShaderMap shaders)
 595                 : DynamicStateBaseClass (context, shaders[glu::SHADERTYPE_VERTEX], shaders[glu::SHADERTYPE_FRAGMENT])
 596         {
 597                 // Check if line width test is supported
 598                 {
 599                         const vk::VkPhysicalDeviceFeatures& deviceFeatures = m_context.getDeviceFeatures();
 600
 601                         if (!deviceFeatures.wideLines)
 602                                 throw tcu::NotSupportedError("Line width test is unsupported");
 603                 }
 604
 605                 m_topology = vk::VK_PRIMITIVE_TOPOLOGY_LINE_LIST;
 606
 607                 m_data.push_back(PositionColorVertex(tcu::Vec4(-1.0f, 0.0f, 0.0f, 1.0f), tcu::RGBA::green().toVec()));
 608                 m_data.push_back(PositionColorVertex(tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f), tcu::RGBA::green().toVec()));
 609
 610                 DynamicStateBaseClass::initialize();
 611         }
 612
 613         virtual tcu::TestStatus iterate (void)
 614         {
 615                 tcu::TestLog &log               = m_context.getTestContext().getLog();
 616                 const vk::VkQueue queue = m_context.getUniversalQueue();
 617
 618                 beginRenderPass();
 619
 620                 // set states here
 621                 vk::VkPhysicalDeviceProperties deviceProperties;
 622                 m_context.getInstanceInterface().getPhysicalDeviceProperties(m_context.getPhysicalDevice(), &deviceProperties);
 623
 624                 setDynamicViewportState(WIDTH, HEIGHT);
 625                 setDynamicBlendState();
 626                 setDynamicDepthStencilState();
 627                 setDynamicRasterizationState(deFloatFloor(deviceProperties.limits.lineWidthRange[1]));
 628
 629                 m_vk.cmdBindPipeline(*m_cmdBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipeline);
 630
 631                 const vk::VkDeviceSize vertexBufferOffset       = 0;
 632                 const vk::VkBuffer vertexBuffer                         = m_vertexBuffer->object();
 633                 m_vk.cmdBindVertexBuffers(*m_cmdBuffer, 0, 1, &vertexBuffer, &vertexBufferOffset);
 634
 635                 m_vk.cmdDraw(*m_cmdBuffer, static_cast<deUint32>(m_data.size()), 1, 0, 0);
 636
 637                 m_vk.cmdEndRenderPass(*m_cmdBuffer);
 638                 m_vk.endCommandBuffer(*m_cmdBuffer);
 639
 640                 vk::VkSubmitInfo submitInfo =
 641                 {
 642                         vk::VK_STRUCTURE_TYPE_SUBMIT_INFO,      // VkStructureType                      sType;
 643                         DE_NULL,                                                        // const void*                          pNext;
 644                         0,                                                                      // deUint32                                     waitSemaphoreCount;
 645                         DE_NULL,                                                        // const VkSemaphore*           pWaitSemaphores;
 646                         (const vk::VkPipelineStageFlags*)DE_NULL,
 647                         1,                                                                      // deUint32                                     commandBufferCount;
 648                         &m_cmdBuffer.get(),                                     // const VkCommandBuffer*       pCommandBuffers;
 649                         0,                                                                      // deUint32                                     signalSemaphoreCount;
 650                         DE_NULL                                                         // const VkSemaphore*           pSignalSemaphores;
 651                 };
 652                 m_vk.queueSubmit(queue, 1, &submitInfo, DE_NULL);
 653
 654                 // validation
 655                 {
 656                         VK_CHECK(m_vk.queueWaitIdle(queue));
 657
 658                         tcu::Texture2D referenceFrame(vk::mapVkFormat(m_colorAttachmentFormat), (int)(0.5 + WIDTH), (int)(0.5 + HEIGHT));
 659                         referenceFrame.allocLevel(0);
 660
 661                         const deInt32 frameWidth = referenceFrame.getWidth();
 662                         const deInt32 frameHeight = referenceFrame.getHeight();
 663
 664                         tcu::clear(referenceFrame.getLevel(0), tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f));
 665
 666                         for (int y = 0; y < frameHeight; y++)
 667                         {
 668                                 float yCoord = (float)(y / (0.5*frameHeight)) - 1.0f;
 669
 670                                 for (int x = 0; x < frameWidth; x++)
 671                                 {
 672                                         float xCoord = (float)(x / (0.5*frameWidth)) - 1.0f;
 673                                         float lineHalfWidth = (float)(deFloor(deviceProperties.limits.lineWidthRange[1]) / frameHeight);
 674
 675                                         if (xCoord >= -1.0f && xCoord <= 1.0f && yCoord >= -lineHalfWidth && yCoord <= lineHalfWidth)
 676                                                 referenceFrame.getLevel(0).setPixel(tcu::Vec4(0.0f, 1.0f, 0.0f, 1.0f), x, y);
 677                                 }
 678                         }
 679
 680                         const vk::VkOffset3D zeroOffset = { 0, 0, 0 };
 681                         const tcu::ConstPixelBufferAccess renderedFrame = m_colorTargetImage->readSurface(queue, m_context.getDefaultAllocator(),
 682                                                                                                                                                                                           vk::VK_IMAGE_LAYOUT_GENERAL, zeroOffset, WIDTH, HEIGHT,
 683                                                                                                                                                                                           vk::VK_IMAGE_ASPECT_COLOR_BIT);
 684
 685                         if (!tcu::fuzzyCompare(log, "Result", "Image comparison result",
 686                                 referenceFrame.getLevel(0), renderedFrame, 0.05f,
 687                                 tcu::COMPARE_LOG_RESULT))
 688                         {
 689                                 return tcu::TestStatus(QP_TEST_RESULT_FAIL, "Image verification failed");
 690                         }
 691
 692                         return tcu::TestStatus(QP_TEST_RESULT_PASS, "Image verification passed");
 693                 }
 694         }
 695 };
 696
 697 } //anonymous
 698
 699 DynamicStateRSTests::DynamicStateRSTests (tcu::TestContext& testCtx)
 700         : TestCaseGroup (testCtx, "rs_state", "Tests for rasterizer state")
 701 {
 702         /* Left blank on purpose */
 703 }
 704
 705 DynamicStateRSTests::~DynamicStateRSTests ()
 706 {
 707 }
 708
 709 void DynamicStateRSTests::init (void)
 710 {
 711         ShaderMap shaderPaths;
 712         shaderPaths[glu::SHADERTYPE_VERTEX]             = "vulkan/dynamic_state/VertexFetch.vert";
 713         shaderPaths[glu::SHADERTYPE_FRAGMENT]   = "vulkan/dynamic_state/VertexFetch.frag";
 714
 715         addChild(new InstanceFactory<DepthBiasParamTestInstance>(m_testCtx, "depth_bias", "Test depth bias functionality", shaderPaths));
 716         addChild(new InstanceFactory<DepthBiasClampParamTestInstance>(m_testCtx, "depth_bias_clamp", "Test depth bias clamp functionality", shaderPaths));
 717         addChild(new InstanceFactory<LineWidthParamTestInstance>(m_testCtx, "line_width", "Draw a line with width set to max defined by physical device", shaderPaths));
 718 }
 719
 720 } // DynamicState
 721 } // vkt