blob: 0c3db961ba25052b0325a9f2cfb1c7018428232f [file] [log] [blame]
/*------------------------------------------------------------------------
* 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