blob: b5caef8add8817a386a7a356f38a94099ffff8ac [file] [log] [blame]
#ifndef _VKTRENDERPASSTESTSUTIL_HPP
#define _VKTRENDERPASSTESTSUTIL_HPP
/*------------------------------------------------------------------------
* 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 "tcuDefs.hpp"
#include "vkRef.hpp"
#include "vkDefs.hpp"
#include "vkMemUtil.hpp"
#include "vkTypeUtil.hpp"
#include <vector>
namespace vkt
{
namespace renderpass
{
using namespace vk;
enum RenderingType
{
RENDERING_TYPE_RENDERPASS_LEGACY = 0,
RENDERING_TYPE_RENDERPASS2,
RENDERING_TYPE_DYNAMIC_RENDERING
};
enum SynchronizationType
{
SYNCHRONIZATION_TYPE_LEGACY = 0,
SYNCHRONIZATION_TYPE_SYNCHRONIZATION2,
};
class AttachmentDescription1 : public vk::VkAttachmentDescription
{
public:
AttachmentDescription1 (const void* pNext,
VkAttachmentDescriptionFlags flags,
VkFormat format,
VkSampleCountFlagBits samples,
VkAttachmentLoadOp loadOp,
VkAttachmentStoreOp storeOp,
VkAttachmentLoadOp stencilLoadOp,
VkAttachmentStoreOp stencilStoreOp,
VkImageLayout initialLayout,
VkImageLayout finalLayout);
};
class AttachmentDescription2 : public vk::VkAttachmentDescription2
{
public:
AttachmentDescription2 (const void* pNext,
VkAttachmentDescriptionFlags flags,
VkFormat format,
VkSampleCountFlagBits samples,
VkAttachmentLoadOp loadOp,
VkAttachmentStoreOp storeOp,
VkAttachmentLoadOp stencilLoadOp,
VkAttachmentStoreOp stencilStoreOp,
VkImageLayout initialLayout,
VkImageLayout finalLayout);
};
class AttachmentReference1 : public vk::VkAttachmentReference
{
public:
AttachmentReference1 (const void* pNext,
deUint32 attachment,
VkImageLayout layout,
VkImageAspectFlags aspectMask);
};
class AttachmentReference2 : public vk::VkAttachmentReference2
{
public:
AttachmentReference2 (const void* pNext,
deUint32 attachment,
VkImageLayout layout,
VkImageAspectFlags aspectMask);
};
class SubpassDescription1 : public vk::VkSubpassDescription
{
public:
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);
};
class SubpassDescription2 : public vk::VkSubpassDescription2
{
public:
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);
};
class SubpassDependency1 : public vk::VkSubpassDependency
{
public:
SubpassDependency1 (const void* pNext,
deUint32 srcSubpass,
deUint32 dstSubpass,
VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
VkAccessFlags srcAccessMask,
VkAccessFlags dstAccessMask,
VkDependencyFlags dependencyFlags,
deInt32 viewOffset);
};
class SubpassDependency2 : public vk::VkSubpassDependency2
{
public:
SubpassDependency2 (const void* pNext,
deUint32 srcSubpass,
deUint32 dstSubpass,
VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
VkAccessFlags srcAccessMask,
VkAccessFlags dstAccessMask,
VkDependencyFlags dependencyFlags,
deInt32 viewOffset);
};
class RenderPassCreateInfo1 : public VkRenderPassCreateInfo
{
public:
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);
Move<VkRenderPass> createRenderPass (const DeviceInterface& vk,
VkDevice device) const;
};
class RenderPassCreateInfo2 : public VkRenderPassCreateInfo2
{
public:
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);
Move<VkRenderPass> createRenderPass (const DeviceInterface& vk,
VkDevice device) const;
};
class SubpassBeginInfo1
{
public:
SubpassBeginInfo1 (const void* pNext,
VkSubpassContents contents);
VkSubpassContents contents;
};
class SubpassBeginInfo2 : public VkSubpassBeginInfo
{
public:
SubpassBeginInfo2 (const void* pNext,
VkSubpassContents contents);
};
class SubpassEndInfo1
{
public:
SubpassEndInfo1 (const void* pNext);
};
class SubpassEndInfo2 : public VkSubpassEndInfo
{
public:
SubpassEndInfo2 (const void* pNext);
};
class RenderpassSubpass1
{
public:
typedef SubpassBeginInfo1 SubpassBeginInfo;
typedef SubpassEndInfo1 SubpassEndInfo;
static void cmdBeginRenderPass (const DeviceInterface& vk,
VkCommandBuffer cmdBuffer,
const VkRenderPassBeginInfo* pRenderPassBegin,
const SubpassBeginInfo* pSubpassBeginInfo);
static void cmdNextSubpass (const DeviceInterface& vk,
VkCommandBuffer cmdBuffer,
const SubpassBeginInfo* pSubpassBeginInfo,
const SubpassEndInfo* pSubpassEndInfo);
static void cmdEndRenderPass (const DeviceInterface& vk,
VkCommandBuffer cmdBuffer,
const SubpassEndInfo* pSubpassEndInfo);
};
class RenderpassSubpass2
{
public:
typedef SubpassBeginInfo2 SubpassBeginInfo;
typedef SubpassEndInfo2 SubpassEndInfo;
static void cmdBeginRenderPass (const DeviceInterface& vk,
VkCommandBuffer cmdBuffer,
const VkRenderPassBeginInfo* pRenderPassBegin,
const SubpassBeginInfo* pSubpassBeginInfo);
static void cmdNextSubpass (const DeviceInterface& vk,
VkCommandBuffer cmdBuffer,
const SubpassBeginInfo* pSubpassBeginInfo,
const SubpassEndInfo* pSubpassEndInfo);
static void cmdEndRenderPass (const DeviceInterface& vk,
VkCommandBuffer cmdBuffer,
const SubpassEndInfo* pSubpassEndInfo);
};
// For internal to RP/RP2 conversions
class AttachmentReference
{
public:
AttachmentReference (deUint32 attachment,
VkImageLayout layout,
VkImageAspectFlags aspectMask = static_cast<VkImageAspectFlags>(0u));
deUint32 getAttachment (void) const;
VkImageLayout getImageLayout (void) const;
VkImageAspectFlags getAspectMask (void) const;
void setImageLayout (VkImageLayout layout);
private:
deUint32 m_attachment;
VkImageLayout m_layout;
VkImageAspectFlags m_aspectMask;
};
class Subpass
{
public:
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 = false);
VkPipelineBindPoint getPipelineBindPoint (void) const;
VkSubpassDescriptionFlags getFlags (void) const;
const std::vector<AttachmentReference>& getInputAttachments (void) const;
const std::vector<AttachmentReference>& getColorAttachments (void) const;
const std::vector<AttachmentReference>& getResolveAttachments (void) const;
const AttachmentReference& getDepthStencilAttachment (void) const;
const std::vector<deUint32>& getPreserveAttachments (void) const;
bool getOmitBlendState (void) const;
private:
VkPipelineBindPoint m_pipelineBindPoint;
VkSubpassDescriptionFlags m_flags;
std::vector<AttachmentReference> m_inputAttachments;
std::vector<AttachmentReference> m_colorAttachments;
std::vector<AttachmentReference> m_resolveAttachments;
AttachmentReference m_depthStencilAttachment;
std::vector<deUint32> m_preserveAttachments;
bool m_omitBlendState;
};
class SubpassDependency
{
public:
SubpassDependency (deUint32 srcPass,
deUint32 dstPass,
VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
VkAccessFlags srcAccessMask,
VkAccessFlags dstAccessMask,
VkDependencyFlags flags);
deUint32 getSrcPass (void) const;
deUint32 getDstPass (void) const;
VkPipelineStageFlags getSrcStageMask (void) const;
VkPipelineStageFlags getDstStageMask (void) const;
VkAccessFlags getSrcAccessMask (void) const;
VkAccessFlags getDstAccessMask (void) const;
VkDependencyFlags getFlags (void) const;
private:
deUint32 m_srcPass;
deUint32 m_dstPass;
VkPipelineStageFlags m_srcStageMask;
VkPipelineStageFlags m_dstStageMask;
VkAccessFlags m_srcAccessMask;
VkAccessFlags m_dstAccessMask;
VkDependencyFlags m_flags;
};
class Attachment
{
public:
Attachment (VkFormat format,
VkSampleCountFlagBits samples,
VkAttachmentLoadOp loadOp,
VkAttachmentStoreOp storeOp,
VkAttachmentLoadOp stencilLoadOp,
VkAttachmentStoreOp stencilStoreOp,
VkImageLayout initialLayout,
VkImageLayout finalLayout);
VkFormat getFormat (void) const;
VkSampleCountFlagBits getSamples (void) const;
VkAttachmentLoadOp getLoadOp (void) const;
VkAttachmentStoreOp getStoreOp (void) const;
VkAttachmentLoadOp getStencilLoadOp (void) const;
VkAttachmentStoreOp getStencilStoreOp (void) const;
VkImageLayout getInitialLayout (void) const;
VkImageLayout getFinalLayout (void) const;
private:
VkFormat m_format;
VkSampleCountFlagBits m_samples;
VkAttachmentLoadOp m_loadOp;
VkAttachmentStoreOp m_storeOp;
VkAttachmentLoadOp m_stencilLoadOp;
VkAttachmentStoreOp m_stencilStoreOp;
VkImageLayout m_initialLayout;
VkImageLayout m_finalLayout;
};
class RenderPass
{
public:
RenderPass (const std::vector<Attachment>& attachments,
const std::vector<Subpass>& subpasses,
const std::vector<SubpassDependency>& dependencies,
const std::vector<VkInputAttachmentAspectReference> inputAspects = std::vector<VkInputAttachmentAspectReference>());
const std::vector<Attachment>& getAttachments (void) const;
const std::vector<Subpass>& getSubpasses (void) const;
const std::vector<SubpassDependency>& getDependencies (void) const;
const std::vector<VkInputAttachmentAspectReference>& getInputAspects (void) const;
private:
std::vector<Attachment> m_attachments;
std::vector<Subpass> m_subpasses;
std::vector<SubpassDependency> m_dependencies;
std::vector<VkInputAttachmentAspectReference> m_inputAspects;
};
Move<VkRenderPass> createRenderPass (const DeviceInterface& vk,
VkDevice device,
const RenderPass& renderPassInfo,
RenderingType renderingType,
SynchronizationType synchronizationType = SYNCHRONIZATION_TYPE_LEGACY);
} // renderpass
} // vkt
#endif // _VKTRENDERPASSTESTSUTIL_HPP