| /*------------------------------------------------------------------------ |
| * Vulkan Conformance Tests |
| * ------------------------ |
| * |
| * Copyright (c) 2018 The Khronos Group Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| *//*! |
| * \file |
| * \brief RenderPass test utils |
| *//*--------------------------------------------------------------------*/ |
| |
| #include "vktRenderPassTestsUtil.hpp" |
| #include "tcuTestCase.hpp" |
| #include "vkMemUtil.hpp" |
| #include "vkRefUtil.hpp" |
| |
| #include <vector> |
| |
| using namespace vk; |
| |
| namespace vkt |
| { |
| namespace renderpass |
| { |
| |
| AttachmentDescription1::AttachmentDescription1 (const void* pNext_, |
| VkAttachmentDescriptionFlags flags_, |
| VkFormat format_, |
| VkSampleCountFlagBits samples_, |
| VkAttachmentLoadOp loadOp_, |
| VkAttachmentStoreOp storeOp_, |
| VkAttachmentLoadOp stencilLoadOp_, |
| VkAttachmentStoreOp stencilStoreOp_, |
| VkImageLayout initialLayout_, |
| VkImageLayout finalLayout_) |
| { |
| DE_ASSERT(pNext_ == DE_NULL); |
| |
| // No sType field in this struct |
| DE_UNREF(pNext_); |
| flags = flags_; |
| format = format_; |
| samples = samples_; |
| loadOp = loadOp_; |
| storeOp = storeOp_; |
| stencilLoadOp = stencilLoadOp_; |
| stencilStoreOp = stencilStoreOp_; |
| initialLayout = initialLayout_; |
| finalLayout = finalLayout_; |
| } |
| |
| AttachmentDescription2::AttachmentDescription2 (const void* pNext_, |
| VkAttachmentDescriptionFlags flags_, |
| VkFormat format_, |
| VkSampleCountFlagBits samples_, |
| VkAttachmentLoadOp loadOp_, |
| VkAttachmentStoreOp storeOp_, |
| VkAttachmentLoadOp stencilLoadOp_, |
| VkAttachmentStoreOp stencilStoreOp_, |
| VkImageLayout initialLayout_, |
| VkImageLayout finalLayout_) |
| { |
| sType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2; |
| pNext = pNext_; |
| flags = flags_; |
| format = format_; |
| samples = samples_; |
| loadOp = loadOp_; |
| storeOp = storeOp_; |
| stencilLoadOp = stencilLoadOp_; |
| stencilStoreOp = stencilStoreOp_; |
| initialLayout = initialLayout_; |
| finalLayout = finalLayout_; |
| } |
| |
| AttachmentReference1::AttachmentReference1 (const void* pNext_, |
| deUint32 attachment_, |
| VkImageLayout layout_, |
| VkImageAspectFlags aspectMask_) |
| { |
| DE_ASSERT(pNext_ == DE_NULL); |
| |
| // No sType field in this struct |
| DE_UNREF (pNext_); |
| attachment = attachment_; |
| layout = layout_; |
| DE_UNREF (aspectMask_); |
| } |
| |
| AttachmentReference2::AttachmentReference2 (const void* pNext_, |
| deUint32 attachment_, |
| VkImageLayout layout_, |
| VkImageAspectFlags aspectMask_) |
| { |
| sType = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2; |
| pNext = pNext_; |
| attachment = attachment_; |
| layout = layout_; |
| aspectMask = aspectMask_; |
| } |
| |
| SubpassDescription1::SubpassDescription1 (const void* pNext_, |
| VkSubpassDescriptionFlags flags_, |
| VkPipelineBindPoint pipelineBindPoint_, |
| deUint32 viewMask_, |
| deUint32 inputAttachmentCount_, |
| const VkAttachmentReference* pInputAttachments_, |
| deUint32 colorAttachmentCount_, |
| const VkAttachmentReference* pColorAttachments_, |
| const VkAttachmentReference* pResolveAttachments_, |
| const VkAttachmentReference* pDepthStencilAttachment_, |
| deUint32 preserveAttachmentCount_, |
| const deUint32* pPreserveAttachments_) |
| { |
| DE_ASSERT(pNext_ == DE_NULL); |
| DE_ASSERT(viewMask_ == 0); |
| |
| // No sType field in this struct |
| DE_UNREF (pNext_); |
| flags = flags_; |
| pipelineBindPoint = pipelineBindPoint_; |
| DE_UNREF (viewMask_); |
| inputAttachmentCount = inputAttachmentCount_; |
| pInputAttachments = pInputAttachments_; |
| colorAttachmentCount = colorAttachmentCount_; |
| pColorAttachments = pColorAttachments_; |
| pResolveAttachments = pResolveAttachments_; |
| pDepthStencilAttachment = pDepthStencilAttachment_; |
| preserveAttachmentCount = preserveAttachmentCount_; |
| pPreserveAttachments = pPreserveAttachments_; |
| } |
| |
| SubpassDescription2::SubpassDescription2 (const void* pNext_, |
| VkSubpassDescriptionFlags flags_, |
| VkPipelineBindPoint pipelineBindPoint_, |
| deUint32 viewMask_, |
| deUint32 inputAttachmentCount_, |
| const VkAttachmentReference2* pInputAttachments_, |
| deUint32 colorAttachmentCount_, |
| const VkAttachmentReference2* pColorAttachments_, |
| const VkAttachmentReference2* pResolveAttachments_, |
| const VkAttachmentReference2* pDepthStencilAttachment_, |
| deUint32 preserveAttachmentCount_, |
| const deUint32* pPreserveAttachments_) |
| { |
| sType = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2; |
| pNext = pNext_; |
| flags = flags_; |
| pipelineBindPoint = pipelineBindPoint_; |
| viewMask = viewMask_; |
| inputAttachmentCount = inputAttachmentCount_; |
| pInputAttachments = pInputAttachments_; |
| colorAttachmentCount = colorAttachmentCount_; |
| pColorAttachments = pColorAttachments_; |
| pResolveAttachments = pResolveAttachments_; |
| pDepthStencilAttachment = pDepthStencilAttachment_; |
| preserveAttachmentCount = preserveAttachmentCount_; |
| pPreserveAttachments = pPreserveAttachments_; |
| } |
| |
| SubpassDependency1::SubpassDependency1 (const void* pNext_, |
| deUint32 srcSubpass_, |
| deUint32 dstSubpass_, |
| VkPipelineStageFlags srcStageMask_, |
| VkPipelineStageFlags dstStageMask_, |
| VkAccessFlags srcAccessMask_, |
| VkAccessFlags dstAccessMask_, |
| VkDependencyFlags dependencyFlags_, |
| deInt32 viewOffset_) |
| { |
| DE_ASSERT(pNext_ == DE_NULL); |
| DE_ASSERT(viewOffset_ == 0); |
| |
| // No sType field in this struct |
| DE_UNREF (pNext_); |
| srcSubpass = srcSubpass_; |
| dstSubpass = dstSubpass_; |
| srcStageMask = srcStageMask_; |
| dstStageMask = dstStageMask_; |
| srcAccessMask = srcAccessMask_; |
| dstAccessMask = dstAccessMask_; |
| dependencyFlags = dependencyFlags_; |
| DE_UNREF (viewOffset_); |
| } |
| |
| SubpassDependency2::SubpassDependency2 (const void* pNext_, |
| deUint32 srcSubpass_, |
| deUint32 dstSubpass_, |
| VkPipelineStageFlags srcStageMask_, |
| VkPipelineStageFlags dstStageMask_, |
| VkAccessFlags srcAccessMask_, |
| VkAccessFlags dstAccessMask_, |
| VkDependencyFlags dependencyFlags_, |
| deInt32 viewOffset_) |
| { |
| sType = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2; |
| pNext = pNext_; |
| srcSubpass = srcSubpass_; |
| dstSubpass = dstSubpass_; |
| srcStageMask = srcStageMask_; |
| dstStageMask = dstStageMask_; |
| srcAccessMask = srcAccessMask_; |
| dstAccessMask = dstAccessMask_; |
| dependencyFlags = dependencyFlags_; |
| viewOffset = viewOffset_; |
| } |
| |
| RenderPassCreateInfo1::RenderPassCreateInfo1 (const void* pNext_, |
| VkRenderPassCreateFlags flags_, |
| deUint32 attachmentCount_, |
| const VkAttachmentDescription* pAttachments_, |
| deUint32 subpassCount_, |
| const VkSubpassDescription* pSubpasses_, |
| deUint32 dependencyCount_, |
| const VkSubpassDependency* pDependencies_, |
| deUint32 correlatedViewMaskCount_, |
| const deUint32* pCorrelatedViewMasks_) |
| { |
| DE_ASSERT(correlatedViewMaskCount_ == 0); |
| DE_ASSERT(pCorrelatedViewMasks_ == DE_NULL); |
| |
| sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO; |
| pNext = pNext_; |
| flags = flags_; |
| attachmentCount = attachmentCount_; |
| pAttachments = pAttachments_; |
| subpassCount = subpassCount_; |
| pSubpasses = pSubpasses_; |
| dependencyCount = dependencyCount_; |
| pDependencies = pDependencies_; |
| DE_UNREF (correlatedViewMaskCount_); |
| DE_UNREF (pCorrelatedViewMasks_); |
| } |
| |
| Move<VkRenderPass> RenderPassCreateInfo1::createRenderPass (const DeviceInterface& vk, VkDevice device) const |
| { |
| return vk::createRenderPass(vk, device, this); |
| } |
| |
| RenderPassCreateInfo2::RenderPassCreateInfo2 (const void* pNext_, |
| VkRenderPassCreateFlags flags_, |
| deUint32 attachmentCount_, |
| const VkAttachmentDescription2* pAttachments_, |
| deUint32 subpassCount_, |
| const VkSubpassDescription2* pSubpasses_, |
| deUint32 dependencyCount_, |
| const VkSubpassDependency2* pDependencies_, |
| deUint32 correlatedViewMaskCount_, |
| const deUint32* pCorrelatedViewMasks_) |
| { |
| sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2; |
| pNext = pNext_; |
| flags = flags_; |
| attachmentCount = attachmentCount_; |
| pAttachments = pAttachments_; |
| subpassCount = subpassCount_; |
| pSubpasses = pSubpasses_; |
| dependencyCount = dependencyCount_; |
| pDependencies = pDependencies_; |
| correlatedViewMaskCount = correlatedViewMaskCount_; |
| pCorrelatedViewMasks = pCorrelatedViewMasks_; |
| } |
| |
| Move<VkRenderPass> RenderPassCreateInfo2::createRenderPass (const DeviceInterface& vk, VkDevice device) const |
| { |
| return vk::createRenderPass2(vk, device, this); |
| } |
| |
| SubpassBeginInfo1::SubpassBeginInfo1 (const void* pNext_, |
| VkSubpassContents contents_) |
| : contents (contents_) |
| { |
| DE_ASSERT(pNext_ == DE_NULL); |
| |
| DE_UNREF(pNext_); |
| } |
| |
| SubpassBeginInfo2::SubpassBeginInfo2 (const void* pNext_, |
| VkSubpassContents contents_) |
| { |
| sType = VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO; |
| pNext = pNext_; |
| contents = contents_; |
| } |
| |
| SubpassEndInfo1::SubpassEndInfo1 (const void* pNext_) |
| { |
| DE_ASSERT(pNext_ == DE_NULL); |
| |
| DE_UNREF(pNext_); |
| } |
| |
| SubpassEndInfo2::SubpassEndInfo2 (const void* pNext_) |
| { |
| sType = VK_STRUCTURE_TYPE_SUBPASS_END_INFO; |
| pNext = pNext_; |
| } |
| |
| void RenderpassSubpass1::cmdBeginRenderPass (const DeviceInterface& vk, |
| VkCommandBuffer cmdBuffer, |
| const VkRenderPassBeginInfo* pRenderPassBegin, |
| const SubpassBeginInfo* pSubpassBeginInfo) |
| { |
| DE_ASSERT(pSubpassBeginInfo != DE_NULL); |
| |
| vk.cmdBeginRenderPass(cmdBuffer, pRenderPassBegin, pSubpassBeginInfo->contents); |
| } |
| |
| void RenderpassSubpass1::cmdNextSubpass (const DeviceInterface& vk, |
| VkCommandBuffer cmdBuffer, |
| const SubpassBeginInfo* pSubpassBeginInfo, |
| const SubpassEndInfo* pSubpassEndInfo) |
| { |
| DE_UNREF(pSubpassEndInfo); |
| DE_ASSERT(pSubpassBeginInfo != DE_NULL); |
| |
| vk.cmdNextSubpass(cmdBuffer, pSubpassBeginInfo->contents); |
| } |
| |
| void RenderpassSubpass1::cmdEndRenderPass (const DeviceInterface& vk, |
| VkCommandBuffer cmdBuffer, |
| const SubpassEndInfo* pSubpassEndInfo) |
| { |
| DE_UNREF(pSubpassEndInfo); |
| |
| vk.cmdEndRenderPass(cmdBuffer); |
| } |
| |
| void RenderpassSubpass2::cmdBeginRenderPass (const DeviceInterface& vk, |
| VkCommandBuffer cmdBuffer, |
| const VkRenderPassBeginInfo* pRenderPassBegin, |
| const SubpassBeginInfo* pSubpassBeginInfo) |
| { |
| vk.cmdBeginRenderPass2(cmdBuffer, pRenderPassBegin, pSubpassBeginInfo); |
| } |
| |
| void RenderpassSubpass2::cmdNextSubpass (const DeviceInterface& vk, |
| VkCommandBuffer cmdBuffer, |
| const SubpassBeginInfo* pSubpassBeginInfo, |
| const SubpassEndInfo* pSubpassEndInfo) |
| { |
| DE_ASSERT(pSubpassBeginInfo != DE_NULL); |
| DE_ASSERT(pSubpassEndInfo != DE_NULL); |
| |
| vk.cmdNextSubpass2(cmdBuffer, pSubpassBeginInfo, pSubpassEndInfo); |
| } |
| |
| void RenderpassSubpass2::cmdEndRenderPass (const DeviceInterface& vk, |
| VkCommandBuffer cmdBuffer, |
| const SubpassEndInfo* pSubpassEndInfo) |
| { |
| DE_ASSERT(pSubpassEndInfo != DE_NULL); |
| |
| vk.cmdEndRenderPass2(cmdBuffer, pSubpassEndInfo); |
| } |
| |
| // For internal to RP/RP2 conversions |
| |
| AttachmentReference::AttachmentReference (deUint32 attachment, |
| VkImageLayout layout, |
| VkImageAspectFlags aspectMask) |
| |
| :m_attachment (attachment) |
| ,m_layout (layout) |
| ,m_aspectMask (aspectMask) |
| { |
| } |
| |
| deUint32 AttachmentReference::getAttachment (void) const |
| { |
| return m_attachment; |
| } |
| |
| VkImageLayout AttachmentReference::getImageLayout (void) const |
| { |
| return m_layout; |
| } |
| |
| VkImageAspectFlags AttachmentReference::getAspectMask (void) const |
| { |
| return m_aspectMask; |
| } |
| |
| void AttachmentReference::setImageLayout (VkImageLayout layout) |
| { |
| m_layout = layout; |
| } |
| |
| Subpass::Subpass (VkPipelineBindPoint pipelineBindPoint, |
| VkSubpassDescriptionFlags flags, |
| const std::vector<AttachmentReference>& inputAttachments, |
| const std::vector<AttachmentReference>& colorAttachments, |
| const std::vector<AttachmentReference>& resolveAttachments, |
| AttachmentReference depthStencilAttachment, |
| const std::vector<deUint32>& preserveAttachments, |
| bool omitBlendState) |
| |
| :m_pipelineBindPoint (pipelineBindPoint) |
| ,m_flags (flags) |
| ,m_inputAttachments (inputAttachments) |
| ,m_colorAttachments (colorAttachments) |
| ,m_resolveAttachments (resolveAttachments) |
| ,m_depthStencilAttachment (depthStencilAttachment) |
| ,m_preserveAttachments (preserveAttachments) |
| ,m_omitBlendState (omitBlendState) |
| { |
| } |
| |
| VkPipelineBindPoint Subpass::getPipelineBindPoint (void) const |
| { |
| return m_pipelineBindPoint; |
| } |
| |
| VkSubpassDescriptionFlags Subpass::getFlags (void) const |
| { |
| return m_flags; |
| } |
| |
| const std::vector<AttachmentReference>& Subpass::getInputAttachments (void) const |
| { |
| return m_inputAttachments; |
| } |
| |
| const std::vector<AttachmentReference>& Subpass::getColorAttachments (void) const |
| { |
| return m_colorAttachments; |
| } |
| |
| const std::vector<AttachmentReference>& Subpass::getResolveAttachments (void) const |
| { |
| return m_resolveAttachments; |
| } |
| |
| const AttachmentReference& Subpass::getDepthStencilAttachment (void) const |
| { |
| return m_depthStencilAttachment; |
| } |
| |
| const std::vector<deUint32>& Subpass::getPreserveAttachments (void) const |
| { |
| return m_preserveAttachments; |
| } |
| |
| bool Subpass::getOmitBlendState (void) const |
| { |
| return m_omitBlendState; |
| } |
| |
| SubpassDependency::SubpassDependency (deUint32 srcPass, |
| deUint32 dstPass, |
| |
| VkPipelineStageFlags srcStageMask, |
| VkPipelineStageFlags dstStageMask, |
| |
| VkAccessFlags srcAccessMask, |
| VkAccessFlags dstAccessMask, |
| |
| VkDependencyFlags flags) |
| |
| : m_srcPass (srcPass) |
| , m_dstPass (dstPass) |
| |
| , m_srcStageMask (srcStageMask) |
| , m_dstStageMask (dstStageMask) |
| |
| , m_srcAccessMask (srcAccessMask) |
| , m_dstAccessMask (dstAccessMask) |
| , m_flags (flags) |
| { |
| } |
| |
| deUint32 SubpassDependency::getSrcPass (void) const |
| { |
| return m_srcPass; |
| } |
| |
| deUint32 SubpassDependency::getDstPass (void) const |
| { |
| return m_dstPass; |
| } |
| |
| VkPipelineStageFlags SubpassDependency::getSrcStageMask (void) const |
| { |
| return m_srcStageMask; |
| } |
| |
| VkPipelineStageFlags SubpassDependency::getDstStageMask (void) const |
| { |
| return m_dstStageMask; |
| } |
| |
| VkAccessFlags SubpassDependency::getSrcAccessMask (void) const |
| { |
| return m_srcAccessMask; |
| } |
| |
| VkAccessFlags SubpassDependency::getDstAccessMask (void) const |
| { |
| return m_dstAccessMask; |
| } |
| |
| VkDependencyFlags SubpassDependency::getFlags (void) const |
| { |
| return m_flags; |
| } |
| |
| Attachment::Attachment (VkFormat format, |
| VkSampleCountFlagBits samples, |
| |
| VkAttachmentLoadOp loadOp, |
| VkAttachmentStoreOp storeOp, |
| |
| VkAttachmentLoadOp stencilLoadOp, |
| VkAttachmentStoreOp stencilStoreOp, |
| |
| VkImageLayout initialLayout, |
| VkImageLayout finalLayout) |
| |
| : m_format (format) |
| , m_samples (samples) |
| , m_loadOp (loadOp) |
| , m_storeOp (storeOp) |
| , m_stencilLoadOp (stencilLoadOp) |
| , m_stencilStoreOp (stencilStoreOp) |
| , m_initialLayout (initialLayout) |
| , m_finalLayout (finalLayout) |
| { |
| } |
| |
| VkFormat Attachment::getFormat (void) const |
| { |
| return m_format; |
| } |
| |
| VkSampleCountFlagBits Attachment::getSamples (void) const |
| { |
| return m_samples; |
| } |
| |
| VkAttachmentLoadOp Attachment::getLoadOp (void) const |
| { |
| return m_loadOp; |
| } |
| |
| VkAttachmentStoreOp Attachment::getStoreOp (void) const |
| { |
| return m_storeOp; |
| } |
| |
| VkAttachmentLoadOp Attachment::getStencilLoadOp (void) const |
| { |
| return m_stencilLoadOp; |
| } |
| |
| VkAttachmentStoreOp Attachment::getStencilStoreOp (void) const |
| { |
| return m_stencilStoreOp; |
| } |
| |
| VkImageLayout Attachment::getInitialLayout (void) const |
| { |
| return m_initialLayout; |
| } |
| |
| VkImageLayout Attachment::getFinalLayout (void) const |
| { |
| return m_finalLayout; |
| } |
| |
| RenderPass::RenderPass (const std::vector<Attachment>& attachments, |
| const std::vector<Subpass>& subpasses, |
| const std::vector<SubpassDependency>& dependencies, |
| const std::vector<VkInputAttachmentAspectReference> inputAspects) |
| |
| : m_attachments (attachments) |
| , m_subpasses (subpasses) |
| , m_dependencies (dependencies) |
| , m_inputAspects (inputAspects) |
| { |
| } |
| |
| const std::vector<Attachment>& RenderPass::getAttachments (void) const |
| { |
| return m_attachments; |
| } |
| |
| const std::vector<Subpass>& RenderPass::getSubpasses (void) const |
| { |
| return m_subpasses; |
| } |
| |
| const std::vector<SubpassDependency>& RenderPass::getDependencies (void) const |
| { |
| return m_dependencies; |
| } |
| |
| const std::vector<VkInputAttachmentAspectReference>& RenderPass::getInputAspects (void) const |
| { |
| return m_inputAspects; |
| } |
| |
| template <typename AttachmentDesc> |
| AttachmentDesc createAttachmentDescription (const Attachment& attachment) |
| { |
| const AttachmentDesc attachmentDescription // VkAttachmentDescription || VkAttachmentDescription2 |
| ( |
| // || VkStructureType sType; |
| DE_NULL, // || const void* pNext; |
| 0u, // VkAttachmentDescriptionFlags flags; || VkAttachmentDescriptionFlags flags; |
| attachment.getFormat(), // VkFormat format; || VkFormat format; |
| attachment.getSamples(), // VkSampleCountFlagBits samples; || VkSampleCountFlagBits samples; |
| attachment.getLoadOp(), // VkAttachmentLoadOp loadOp; || VkAttachmentLoadOp loadOp; |
| attachment.getStoreOp(), // VkAttachmentStoreOp storeOp; || VkAttachmentStoreOp storeOp; |
| attachment.getStencilLoadOp(), // VkAttachmentLoadOp stencilLoadOp; || VkAttachmentLoadOp stencilLoadOp; |
| attachment.getStencilStoreOp(), // VkAttachmentStoreOp stencilStoreOp; || VkAttachmentStoreOp stencilStoreOp; |
| attachment.getInitialLayout(), // VkImageLayout initialLayout; || VkImageLayout initialLayout; |
| attachment.getFinalLayout() // VkImageLayout finalLayout; || VkImageLayout finalLayout; |
| ); |
| |
| return attachmentDescription; |
| } |
| |
| template <typename AttachmentRef> |
| AttachmentRef createAttachmentReference (const AttachmentReference& referenceInfo) |
| { |
| const AttachmentRef reference // VkAttachmentReference || VkAttachmentReference2 |
| ( |
| // || VkStructureType sType; |
| DE_NULL, // || const void* pNext; |
| referenceInfo.getAttachment(), // deUint32 attachment; || deUint32 attachment; |
| referenceInfo.getImageLayout(), // VkImageLayout layout; || VkImageLayout layout; |
| referenceInfo.getAspectMask() // || VkImageAspectFlags aspectMask; |
| ); |
| |
| return reference; |
| } |
| |
| template <typename SubpassDesc, typename AttachmentRef> |
| SubpassDesc createSubpassDescription (const Subpass& subpass, |
| std::vector<AttachmentRef>* attachmentReferenceLists, |
| std::vector<deUint32>* preserveAttachmentReferences) |
| { |
| std::vector<AttachmentRef>& inputAttachmentReferences = attachmentReferenceLists[0]; |
| std::vector<AttachmentRef>& colorAttachmentReferences = attachmentReferenceLists[1]; |
| std::vector<AttachmentRef>& resolveAttachmentReferences = attachmentReferenceLists[2]; |
| std::vector<AttachmentRef>& depthStencilAttachmentReferences = attachmentReferenceLists[3]; |
| |
| for (size_t attachmentNdx = 0; attachmentNdx < subpass.getColorAttachments().size(); attachmentNdx++) |
| colorAttachmentReferences.push_back(createAttachmentReference<AttachmentRef>(subpass.getColorAttachments()[attachmentNdx])); |
| |
| for (size_t attachmentNdx = 0; attachmentNdx < subpass.getInputAttachments().size(); attachmentNdx++) |
| inputAttachmentReferences.push_back(createAttachmentReference<AttachmentRef>(subpass.getInputAttachments()[attachmentNdx])); |
| |
| for (size_t attachmentNdx = 0; attachmentNdx < subpass.getResolveAttachments().size(); attachmentNdx++) |
| resolveAttachmentReferences.push_back(createAttachmentReference<AttachmentRef>(subpass.getResolveAttachments()[attachmentNdx])); |
| |
| depthStencilAttachmentReferences.push_back(createAttachmentReference<AttachmentRef>(subpass.getDepthStencilAttachment())); |
| |
| for (size_t attachmentNdx = 0; attachmentNdx < subpass.getPreserveAttachments().size(); attachmentNdx++) |
| preserveAttachmentReferences->push_back(subpass.getPreserveAttachments()[attachmentNdx]); |
| |
| DE_ASSERT(resolveAttachmentReferences.empty() || colorAttachmentReferences.size() == resolveAttachmentReferences.size()); |
| |
| { |
| const SubpassDesc subpassDescription // VkSubpassDescription || VkSubpassDescription2 |
| ( |
| // || VkStructureType sType; |
| DE_NULL, // || const void* pNext; |
| subpass.getFlags(), // VkSubpassDescriptionFlags flags; || VkSubpassDescriptionFlags flags; |
| subpass.getPipelineBindPoint(), // VkPipelineBindPoint pipelineBindPoint; || VkPipelineBindPoint pipelineBindPoint; |
| 0u, // || deUint32 viewMask; |
| (deUint32)inputAttachmentReferences.size(), // deUint32 inputAttachmentCount; || deUint32 inputAttachmentCount; |
| inputAttachmentReferences.empty() ? DE_NULL : &inputAttachmentReferences[0], // const VkAttachmentReference* pInputAttachments; || const VkAttachmentReference2* pInputAttachments; |
| (deUint32)colorAttachmentReferences.size(), // deUint32 colorAttachmentCount; || deUint32 colorAttachmentCount; |
| colorAttachmentReferences.empty() ? DE_NULL : &colorAttachmentReferences[0], // const VkAttachmentReference* pColorAttachments; || const VkAttachmentReference2* pColorAttachments; |
| resolveAttachmentReferences.empty() ? DE_NULL : &resolveAttachmentReferences[0], // const VkAttachmentReference* pResolveAttachments; || const VkAttachmentReference2* pResolveAttachments; |
| &depthStencilAttachmentReferences[0], // const VkAttachmentReference* pDepthStencilAttachment; || const VkAttachmentReference2* pDepthStencilAttachment; |
| (deUint32)preserveAttachmentReferences->size(), // deUint32 preserveAttachmentCount; || deUint32 preserveAttachmentCount; |
| preserveAttachmentReferences->empty() ? DE_NULL : &(*preserveAttachmentReferences)[0] // const deUint32* pPreserveAttachments; || const deUint32* pPreserveAttachments; |
| ); |
| |
| return subpassDescription; |
| } |
| } |
| |
| VkMemoryBarrier2KHR createMemoryBarrierFromSubpassDependency(const SubpassDependency& dependencyInfo) |
| { |
| return |
| { |
| VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR, // VkStructureType sType |
| DE_NULL, // const void* pNext |
| static_cast<VkPipelineStageFlags2KHR> (dependencyInfo.getSrcStageMask()), // VkPipelineStageFlags2KHR srcStageMask |
| static_cast<VkAccessFlags2KHR> (dependencyInfo.getSrcAccessMask()), // VkAccessFlags2KHR srcAccessMask |
| static_cast<VkPipelineStageFlags2KHR> (dependencyInfo.getDstStageMask()), // VkPipelineStageFlags2KHR dstStageMask |
| static_cast<VkAccessFlags2KHR> (dependencyInfo.getDstAccessMask()) // VkAccessFlags2KHR dstAccessMask |
| }; |
| } |
| |
| template <typename SubpassDep> |
| SubpassDep createSubpassDependency (const SubpassDependency& dependencyInfo, VkMemoryBarrier2KHR* memoryBarrierPtr = DE_NULL) |
| { |
| VkPipelineStageFlags srcStageMask = dependencyInfo.getSrcStageMask(); |
| VkPipelineStageFlags dstStageMask = dependencyInfo.getDstStageMask(); |
| VkAccessFlags srcAccessMask = dependencyInfo.getSrcAccessMask(); |
| VkAccessFlags dstAccessMask = dependencyInfo.getDstAccessMask(); |
| |
| // If an instance of VkMemoryBarrier2KHR is included in the pNext chain, srcStageMask, |
| // dstStageMask, srcAccessMask and dstAccessMask parameters are ignored. The synchronization |
| // and access scopes instead are defined by the parameters of VkMemoryBarrier2KHR. |
| if (memoryBarrierPtr) |
| { |
| srcStageMask = 0; |
| dstStageMask = 0; |
| srcAccessMask = 0; |
| dstAccessMask = 0; |
| } |
| |
| return // VkSubpassDependency || VkSubpassDependency2 |
| { |
| memoryBarrierPtr, // || const void* pNext |
| dependencyInfo.getSrcPass(), // deUint32 srcSubpass || deUint32 srcSubpass |
| dependencyInfo.getDstPass(), // deUint32 dstSubpass || deUint32 dstSubpass |
| srcStageMask, // VkPipelineStageFlags srcStageMask || VkPipelineStageFlags srcStageMask |
| dstStageMask, // VkPipelineStageFlags dstStageMask || VkPipelineStageFlags dstStageMask |
| srcAccessMask, // VkAccessFlags srcAccessMask || VkAccessFlags srcAccessMask |
| dstAccessMask, // VkAccessFlags dstAccessMask || VkAccessFlags dstAccessMask |
| dependencyInfo.getFlags(), // VkDependencyFlags dependencyFlags || VkDependencyFlags dependencyFlags |
| 0u // deInt32 viewOffset || deInt32 viewOffset |
| }; |
| } |
| |
| de::MovePtr<VkRenderPassInputAttachmentAspectCreateInfo> createRenderPassInputAttachmentAspectCreateInfo (const RenderPass& renderPassInfo) |
| { |
| de::MovePtr<VkRenderPassInputAttachmentAspectCreateInfo> result (DE_NULL); |
| |
| if (!renderPassInfo.getInputAspects().empty()) |
| { |
| const VkRenderPassInputAttachmentAspectCreateInfo inputAspectCreateInfo = |
| { |
| VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO, |
| DE_NULL, |
| |
| (deUint32)renderPassInfo.getInputAspects().size(), |
| renderPassInfo.getInputAspects().data(), |
| }; |
| |
| result = de::MovePtr<VkRenderPassInputAttachmentAspectCreateInfo>(new VkRenderPassInputAttachmentAspectCreateInfo(inputAspectCreateInfo)); |
| } |
| |
| return result; |
| } |
| |
| template<typename AttachmentDesc, typename AttachmentRef, typename SubpassDesc, typename SubpassDep, typename RenderPassCreateInfo> |
| Move<VkRenderPass> createRenderPass (const DeviceInterface& vk, |
| VkDevice device, |
| const RenderPass& renderPassInfo, |
| SynchronizationType synchronizationType) |
| { |
| const size_t perSubpassAttachmentReferenceLists = 4; |
| std::vector<AttachmentDesc> attachments; |
| std::vector<SubpassDesc> subpasses; |
| std::vector<SubpassDep> dependencies; |
| std::vector<VkMemoryBarrier2KHR> memoryBarriers; |
| std::vector<std::vector<AttachmentRef> > attachmentReferenceLists(renderPassInfo.getSubpasses().size() * perSubpassAttachmentReferenceLists); |
| std::vector<std::vector<deUint32> > preserveAttachments(renderPassInfo.getSubpasses().size()); |
| de::MovePtr<VkRenderPassInputAttachmentAspectCreateInfo> inputAspectCreateInfo(createRenderPassInputAttachmentAspectCreateInfo(renderPassInfo)); |
| |
| for (size_t attachmentNdx = 0; attachmentNdx < renderPassInfo.getAttachments().size(); attachmentNdx++) |
| attachments.push_back(createAttachmentDescription<AttachmentDesc>(renderPassInfo.getAttachments()[attachmentNdx])); |
| |
| for (size_t subpassNdx = 0; subpassNdx < renderPassInfo.getSubpasses().size(); subpassNdx++) |
| subpasses.push_back(createSubpassDescription<SubpassDesc>(renderPassInfo.getSubpasses()[subpassNdx], &(attachmentReferenceLists[subpassNdx * perSubpassAttachmentReferenceLists]), &preserveAttachments[subpassNdx])); |
| |
| if (synchronizationType == SYNCHRONIZATION_TYPE_SYNCHRONIZATION2) |
| { |
| // reserve space to avoid reallocation in vector that will invalidate pointers |
| memoryBarriers.reserve(renderPassInfo.getDependencies().size()); |
| for (const auto& dependency : renderPassInfo.getDependencies()) |
| { |
| memoryBarriers.push_back(createMemoryBarrierFromSubpassDependency(dependency)); |
| dependencies.push_back(createSubpassDependency<SubpassDep>(dependency, &memoryBarriers.back())); |
| } |
| } |
| else |
| { |
| for (const auto& dependency : renderPassInfo.getDependencies()) |
| dependencies.push_back(createSubpassDependency<SubpassDep>(dependency)); |
| } |
| |
| const RenderPassCreateInfo renderPassCreator // VkRenderPassCreateInfo || VkRenderPassCreateInfo2 |
| ( |
| // VkStructureType sType; || VkStructureType sType; |
| inputAspectCreateInfo.get(), // const void* pNext; || const void* pNext; |
| (VkRenderPassCreateFlags)0u, // VkRenderPassCreateFlags flags; || VkRenderPassCreateFlags flags; |
| (deUint32)attachments.size(), // deUint32 attachmentCount; || deUint32 attachmentCount; |
| (attachments.empty() ? DE_NULL : &attachments[0]), // const VkAttachmentDescription* pAttachments; || const VkAttachmentDescription2* pAttachments; |
| (deUint32)subpasses.size(), // deUint32 subpassCount; || deUint32 subpassCount; |
| (subpasses.empty() ? DE_NULL : &subpasses[0]), // const VkSubpassDescription* pSubpasses; || const VkSubpassDescription2* pSubpasses; |
| (deUint32)dependencies.size(), // deUint32 dependencyCount; || deUint32 dependencyCount; |
| (dependencies.empty() ? DE_NULL : &dependencies[0]), // const VkSubpassDependency* pDependencies; || const VkSubpassDependency2* pDependencies; |
| 0u, // || deUint32 correlatedViewMaskCount; |
| DE_NULL // || const deUint32* pCorrelatedViewMasks; |
| ); |
| |
| return renderPassCreator.createRenderPass(vk, device); |
| } |
| |
| Move<VkRenderPass> createRenderPass (const DeviceInterface& vk, |
| VkDevice device, |
| const RenderPass& renderPassInfo, |
| RenderingType renderingType, |
| SynchronizationType synchronizationType) |
| { |
| switch (renderingType) |
| { |
| case RENDERING_TYPE_RENDERPASS_LEGACY: |
| return createRenderPass<AttachmentDescription1, |
| AttachmentReference1, |
| SubpassDescription1, |
| SubpassDependency1, |
| RenderPassCreateInfo1>(vk, device, renderPassInfo, SYNCHRONIZATION_TYPE_LEGACY); |
| case RENDERING_TYPE_RENDERPASS2: |
| return createRenderPass<AttachmentDescription2, |
| AttachmentReference2, |
| SubpassDescription2, |
| SubpassDependency2, |
| RenderPassCreateInfo2>(vk, device, renderPassInfo, synchronizationType); |
| default: |
| TCU_THROW(InternalError, "Impossible"); |
| } |
| } |
| |
| } // renderpass |
| |
| } // vkt |
