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