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