external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateBaseClass.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 State Tests - Base Class
  23  *//*--------------------------------------------------------------------*/
  24
  25 #include "vktDynamicStateBaseClass.hpp"
  26
  27 #include "vkPrograms.hpp"
  28
  29 namespace vkt
  30 {
  31 namespace DynamicState
  32 {
  33
  34 DynamicStateBaseClass::DynamicStateBaseClass (Context& context, const char* vertexShaderName, const char* fragmentShaderName)
  35         : TestInstance                          (context)
  36         , m_colorAttachmentFormat   (vk::VK_FORMAT_R8G8B8A8_UNORM)
  37         , m_topology                            (vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP)
  38         , m_vk                                          (context.getDeviceInterface())
  39         , m_vertexShaderName            (vertexShaderName)
  40         , m_fragmentShaderName          (fragmentShaderName)
  41 {
  42 }
  43
  44 void DynamicStateBaseClass::initialize (void)
  45 {
  46         const vk::VkDevice device               = m_context.getDevice();
  47         const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
  48
  49         const PipelineLayoutCreateInfo pipelineLayoutCreateInfo;
  50         m_pipelineLayout = vk::createPipelineLayout(m_vk, device, &pipelineLayoutCreateInfo);
  51
  52         const vk::VkExtent3D targetImageExtent = { WIDTH, HEIGHT, 1 };
  53         const ImageCreateInfo targetImageCreateInfo(vk::VK_IMAGE_TYPE_2D, m_colorAttachmentFormat, targetImageExtent, 1, 1, vk::VK_SAMPLE_COUNT_1_BIT,
  54                                                                                                 vk::VK_IMAGE_TILING_OPTIMAL, vk::VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | vk::VK_IMAGE_USAGE_TRANSFER_SRC_BIT | vk::VK_IMAGE_USAGE_TRANSFER_DST_BIT);
  55
  56         m_colorTargetImage = Image::createAndAlloc(m_vk, device, targetImageCreateInfo, m_context.getDefaultAllocator());
  57
  58         const ImageViewCreateInfo colorTargetViewInfo(m_colorTargetImage->object(), vk::VK_IMAGE_VIEW_TYPE_2D, m_colorAttachmentFormat);
  59         m_colorTargetView = vk::createImageView(m_vk, device, &colorTargetViewInfo);
  60
  61         RenderPassCreateInfo renderPassCreateInfo;
  62         renderPassCreateInfo.addAttachment(AttachmentDescription(m_colorAttachmentFormat,
  63                                                                                                                          vk::VK_SAMPLE_COUNT_1_BIT,
  64                                                                                                                          vk::VK_ATTACHMENT_LOAD_OP_LOAD,
  65                                                                                                                          vk::VK_ATTACHMENT_STORE_OP_STORE,
  66                                                                                                                          vk::VK_ATTACHMENT_LOAD_OP_DONT_CARE,
  67                                                                                                                          vk::VK_ATTACHMENT_STORE_OP_STORE,
  68                                                                                                                          vk::VK_IMAGE_LAYOUT_GENERAL,
  69                                                                                                                          vk::VK_IMAGE_LAYOUT_GENERAL));
  70
  71         const vk::VkAttachmentReference colorAttachmentReference =
  72         {
  73                 0,
  74                 vk::VK_IMAGE_LAYOUT_GENERAL
  75         };
  76
  77         renderPassCreateInfo.addSubpass(SubpassDescription(
  78                 vk::VK_PIPELINE_BIND_POINT_GRAPHICS,
  79                 0,
  80                 0,
  81                 DE_NULL,
  82                 1,
  83                 &colorAttachmentReference,
  84                 DE_NULL,
  85                 AttachmentReference(),
  86                 0,
  87                 DE_NULL
  88                 )
  89                 );
  90
  91         m_renderPass = vk::createRenderPass(m_vk, device, &renderPassCreateInfo);
  92
  93         std::vector<vk::VkImageView> colorAttachments(1);
  94         colorAttachments[0] = *m_colorTargetView;
  95
  96         const FramebufferCreateInfo framebufferCreateInfo(*m_renderPass, colorAttachments, WIDTH, HEIGHT, 1);
  97
  98         m_framebuffer = vk::createFramebuffer(m_vk, device, &framebufferCreateInfo);
  99
 100         const vk::VkVertexInputBindingDescription vertexInputBindingDescription =
 101         {
 102                 0,
 103                 (deUint32)sizeof(tcu::Vec4) * 2,
 104                 vk::VK_VERTEX_INPUT_RATE_VERTEX,
 105         };
 106
 107         const vk::VkVertexInputAttributeDescription vertexInputAttributeDescriptions[2] =
 108         {
 109                 {
 110                         0u,
 111                         0u,
 112                         vk::VK_FORMAT_R32G32B32A32_SFLOAT,
 113                         0u
 114                 },
 115                 {
 116                         1u,
 117                         0u,
 118                         vk::VK_FORMAT_R32G32B32A32_SFLOAT,
 119                         (deUint32)(sizeof(float)* 4),
 120                 }
 121         };
 122
 123         m_vertexInputState = PipelineCreateInfo::VertexInputState(
 124                 1,
 125                 &vertexInputBindingDescription,
 126                 2,
 127                 vertexInputAttributeDescriptions);
 128
 129         const vk::VkDeviceSize dataSize = m_data.size() * sizeof(PositionColorVertex);
 130         m_vertexBuffer = Buffer::createAndAlloc(m_vk, device, BufferCreateInfo(dataSize, vk::VK_BUFFER_USAGE_VERTEX_BUFFER_BIT),
 131                                                                                         m_context.getDefaultAllocator(), vk::MemoryRequirement::HostVisible);
 132
 133         deUint8* ptr = reinterpret_cast<unsigned char *>(m_vertexBuffer->getBoundMemory().getHostPtr());
 134         deMemcpy(ptr, &m_data[0], (size_t)dataSize);
 135
 136         vk::flushMappedMemoryRange(m_vk, device,
 137                 m_vertexBuffer->getBoundMemory().getMemory(),
 138                 m_vertexBuffer->getBoundMemory().getOffset(),
 139                 dataSize);
 140
 141         const CmdPoolCreateInfo cmdPoolCreateInfo(queueFamilyIndex);
 142         m_cmdPool = vk::createCommandPool(m_vk, device, &cmdPoolCreateInfo);
 143
 144         const vk::VkCommandBufferAllocateInfo cmdBufferAllocateInfo =
 145         {
 146                 vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,     // VkStructureType                      sType;
 147                 DE_NULL,                                                                                        // const void*                          pNext;
 148                 *m_cmdPool,                                                                                     // VkCommandPool                        commandPool;
 149                 vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY,                            // VkCommandBufferLevel         level;
 150                 1u,                                                                                                     // deUint32                                     bufferCount;
 151         };
 152         m_cmdBuffer = vk::allocateCommandBuffer(m_vk, device, &cmdBufferAllocateInfo);
 153
 154         initPipeline(device);
 155 }
 156
 157 void DynamicStateBaseClass::initPipeline (const vk::VkDevice device)
 158 {
 159         const vk::Unique<vk::VkShaderModule> vs(createShaderModule(m_vk, device, m_context.getBinaryCollection().get(m_vertexShaderName), 0));
 160         const vk::Unique<vk::VkShaderModule> fs(createShaderModule(m_vk, device, m_context.getBinaryCollection().get(m_fragmentShaderName), 0));
 161
 162         const PipelineCreateInfo::ColorBlendState::Attachment vkCbAttachmentState;
 163
 164         PipelineCreateInfo pipelineCreateInfo(*m_pipelineLayout, *m_renderPass, 0, 0);
 165         pipelineCreateInfo.addShader(PipelineCreateInfo::PipelineShaderStage(*vs, "main", vk::VK_SHADER_STAGE_VERTEX_BIT));
 166         pipelineCreateInfo.addShader(PipelineCreateInfo::PipelineShaderStage(*fs, "main", vk::VK_SHADER_STAGE_FRAGMENT_BIT));
 167         pipelineCreateInfo.addState(PipelineCreateInfo::VertexInputState(m_vertexInputState));
 168         pipelineCreateInfo.addState(PipelineCreateInfo::InputAssemblerState(m_topology));
 169         pipelineCreateInfo.addState(PipelineCreateInfo::ColorBlendState(1, &vkCbAttachmentState));
 170         pipelineCreateInfo.addState(PipelineCreateInfo::ViewportState(1));
 171         pipelineCreateInfo.addState(PipelineCreateInfo::DepthStencilState());
 172         pipelineCreateInfo.addState(PipelineCreateInfo::RasterizerState());
 173         pipelineCreateInfo.addState(PipelineCreateInfo::MultiSampleState());
 174         pipelineCreateInfo.addState(PipelineCreateInfo::DynamicState());
 175
 176         m_pipeline = vk::createGraphicsPipeline(m_vk, device, DE_NULL, &pipelineCreateInfo);
 177 }
 178
 179 tcu::TestStatus DynamicStateBaseClass::iterate (void)
 180 {
 181         DE_ASSERT(false);
 182         return tcu::TestStatus::fail("Implement iterate() method!");
 183 }
 184
 185 void DynamicStateBaseClass::beginRenderPass (void)
 186 {
 187         const vk::VkClearColorValue clearColor = { { 0.0f, 0.0f, 0.0f, 1.0f } };
 188         beginRenderPassWithClearColor(clearColor);
 189 }
 190
 191 void DynamicStateBaseClass::beginRenderPassWithClearColor (const vk::VkClearColorValue& clearColor)
 192 {
 193         const CmdBufferBeginInfo beginInfo;
 194         m_vk.beginCommandBuffer(*m_cmdBuffer, &beginInfo);
 195
 196         initialTransitionColor2DImage(m_vk, *m_cmdBuffer, m_colorTargetImage->object(), vk::VK_IMAGE_LAYOUT_GENERAL);
 197
 198         const ImageSubresourceRange subresourceRange(vk::VK_IMAGE_ASPECT_COLOR_BIT);
 199         m_vk.cmdClearColorImage(*m_cmdBuffer, m_colorTargetImage->object(),
 200                 vk::VK_IMAGE_LAYOUT_GENERAL, &clearColor, 1, &subresourceRange);
 201
 202         const vk::VkMemoryBarrier memBarrier =
 203         {
 204                 vk::VK_STRUCTURE_TYPE_MEMORY_BARRIER,
 205                 DE_NULL,
 206                 vk::VK_ACCESS_TRANSFER_WRITE_BIT,
 207                 vk::VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | vk::VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT
 208         };
 209
 210         m_vk.cmdPipelineBarrier(*m_cmdBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT,
 211                 vk::VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
 212                 0, 1, &memBarrier, 0, DE_NULL, 0, DE_NULL);
 213
 214         const vk::VkRect2D renderArea = { { 0, 0 }, { WIDTH, HEIGHT } };
 215         const RenderPassBeginInfo renderPassBegin(*m_renderPass, *m_framebuffer, renderArea);
 216
 217         m_vk.cmdBeginRenderPass(*m_cmdBuffer, &renderPassBegin, vk::VK_SUBPASS_CONTENTS_INLINE);
 218 }
 219
 220 void DynamicStateBaseClass::setDynamicViewportState (const deUint32 width, const deUint32 height)
 221 {
 222         vk::VkViewport viewport;
 223         viewport.x = 0;
 224         viewport.y = 0;
 225         viewport.width = static_cast<float>(width);
 226         viewport.height = static_cast<float>(height);
 227         viewport.minDepth = 0.0f;
 228         viewport.maxDepth = 1.0f;
 229
 230         m_vk.cmdSetViewport(*m_cmdBuffer, 0, 1, &viewport);
 231
 232         vk::VkRect2D scissor;
 233         scissor.offset.x = 0;
 234         scissor.offset.y = 0;
 235         scissor.extent.width = width;
 236         scissor.extent.height = height;
 237         m_vk.cmdSetScissor(*m_cmdBuffer, 0, 1, &scissor);
 238 }
 239
 240 void DynamicStateBaseClass::setDynamicViewportState (deUint32 viewportCount, const vk::VkViewport* pViewports, const vk::VkRect2D* pScissors)
 241 {
 242         m_vk.cmdSetViewport(*m_cmdBuffer, 0, viewportCount, pViewports);
 243         m_vk.cmdSetScissor(*m_cmdBuffer, 0, viewportCount, pScissors);
 244 }
 245
 246 void DynamicStateBaseClass::setDynamicRasterizationState (const float lineWidth,
 247                                                                                                                  const float depthBiasConstantFactor,
 248                                                                                                                  const float depthBiasClamp,
 249                                                                                                                  const float depthBiasSlopeFactor)
 250 {
 251         m_vk.cmdSetLineWidth(*m_cmdBuffer, lineWidth);
 252         m_vk.cmdSetDepthBias(*m_cmdBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
 253 }
 254
 255 void DynamicStateBaseClass::setDynamicBlendState (const float const1, const float const2, const float const3, const float const4)
 256 {
 257         float blendConstantsants[4] = { const1, const2, const3, const4 };
 258         m_vk.cmdSetBlendConstants(*m_cmdBuffer, blendConstantsants);
 259 }
 260
 261 void DynamicStateBaseClass::setDynamicDepthStencilState (const float    minDepthBounds,
 262                                                                                                                  const float    maxDepthBounds,
 263                                                                                                                  const deUint32 stencilFrontCompareMask,
 264                                                                                                                  const deUint32 stencilFrontWriteMask,
 265                                                                                                                  const deUint32 stencilFrontReference,
 266                                                                                                                  const deUint32 stencilBackCompareMask,
 267                                                                                                                  const deUint32 stencilBackWriteMask,
 268                                                                                                                  const deUint32 stencilBackReference)
 269 {
 270         m_vk.cmdSetDepthBounds(*m_cmdBuffer, minDepthBounds, maxDepthBounds);
 271         m_vk.cmdSetStencilCompareMask(*m_cmdBuffer, vk::VK_STENCIL_FACE_FRONT_BIT, stencilFrontCompareMask);
 272         m_vk.cmdSetStencilWriteMask(*m_cmdBuffer, vk::VK_STENCIL_FACE_FRONT_BIT, stencilFrontWriteMask);
 273         m_vk.cmdSetStencilReference(*m_cmdBuffer, vk::VK_STENCIL_FACE_FRONT_BIT, stencilFrontReference);
 274         m_vk.cmdSetStencilCompareMask(*m_cmdBuffer, vk::VK_STENCIL_FACE_BACK_BIT, stencilBackCompareMask);
 275         m_vk.cmdSetStencilWriteMask(*m_cmdBuffer, vk::VK_STENCIL_FACE_BACK_BIT, stencilBackWriteMask);
 276         m_vk.cmdSetStencilReference(*m_cmdBuffer, vk::VK_STENCIL_FACE_BACK_BIT, stencilBackReference);
 277 }
 278
 279 } // DynamicState
 280 } // vkt