409 lines
14 KiB
C
409 lines
14 KiB
C
/*
|
|
* Copyright © 2021 Intel Corporation
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
* to deal in the Software without restriction, including without limitation
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice (including the next
|
|
* paragraph) shall be included in all copies or substantial portions of the
|
|
* Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
* IN THE SOFTWARE.
|
|
*/
|
|
#ifndef VK_RENDER_PASS_H
|
|
#define VK_RENDER_PASS_H
|
|
|
|
#include "vk_object.h"
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/**
|
|
* Pseudo-extension struct that may be chained into VkRenderingInfo,
|
|
* VkCommandBufferInheritanceRenderingInfo, or VkPipelineRenderingCreateInfo
|
|
* to provide self-dependency information.
|
|
*/
|
|
typedef struct VkRenderingSelfDependencyInfoMESA {
|
|
VkStructureType sType;
|
|
#define VK_STRUCTURE_TYPE_RENDERING_SELF_DEPENDENCY_INFO_MESA (VkStructureType)1000044900
|
|
const void* pNext;
|
|
|
|
/** Bitset of which color attachments have self-dependencies */
|
|
uint32_t colorSelfDependencies;
|
|
|
|
/** True if there is a depth self-dependency */
|
|
VkBool32 depthSelfDependency;
|
|
|
|
/** True if there is a stencil self-dependency */
|
|
VkBool32 stencilSelfDependency;
|
|
} VkRenderingSelfDependencyInfoMESA;
|
|
|
|
/**
|
|
* Pseudo-extension struct that may be chained into VkRenderingAttachmentInfo
|
|
* to indicate an initial layout for the attachment. This is only allowed if
|
|
* all of the following conditions are met:
|
|
*
|
|
* 1. VkRenderingAttachmentInfo::loadOp == LOAD_OP_CLEAR
|
|
*
|
|
* 2. VkRenderingInfo::renderArea is tne entire image view LOD
|
|
*
|
|
* 3. For 3D image attachments, VkRenderingInfo::viewMask == 0 AND
|
|
* VkRenderingInfo::layerCount references the entire bound image view
|
|
* OR VkRenderingInfo::viewMask is dense (no holes) and references the
|
|
* entire bound image view. (2D and 2D array images have no such
|
|
* requirement.)
|
|
*
|
|
* If this struct is included in the pNext chain of a
|
|
* VkRenderingAttachmentInfo, the driver is responsible for transitioning the
|
|
* bound region of the image from
|
|
* VkRenderingAttachmentInitialLayoutInfoMESA::initialLayout to
|
|
* VkRenderingAttachmentInfo::imageLayout prior to rendering.
|
|
*/
|
|
typedef struct VkRenderingAttachmentInitialLayoutInfoMESA {
|
|
VkStructureType sType;
|
|
#define VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INITIAL_LAYOUT_INFO_MESA (VkStructureType)1000044901
|
|
const void* pNext;
|
|
|
|
/** Initial layout of the attachment */
|
|
VkImageLayout initialLayout;
|
|
} VkRenderingAttachmentInitialLayoutInfoMESA;
|
|
|
|
#define VK_IMAGE_LAYOUT_SUBPASS_SELF_DEPENDENCY_MESA (VkImageLayout)1000044902
|
|
|
|
struct vk_subpass_attachment {
|
|
/** VkAttachmentReference2::attachment */
|
|
uint32_t attachment;
|
|
|
|
/** Aspects referenced by this attachment
|
|
*
|
|
* For an input attachment, this is VkAttachmentReference2::aspectMask.
|
|
* For all others, it's equal to the vk_render_pass_attachment::aspects.
|
|
*/
|
|
VkImageAspectFlags aspects;
|
|
|
|
/** Usage for this attachment
|
|
*
|
|
* This is a single VK_IMAGE_USAGE_* describing the usage of this subpass
|
|
* attachment. Resolve attachments are VK_IMAGE_USAGE_TRANSFER_DST_BIT.
|
|
*/
|
|
VkImageUsageFlagBits usage;
|
|
|
|
/** VkAttachmentReference2::layout */
|
|
VkImageLayout layout;
|
|
|
|
/** VkAttachmentReferenceStencilLayout::stencilLayout
|
|
*
|
|
* If VK_KHR_separate_depth_stencil_layouts is not used, this will be
|
|
* layout if the attachment contains stencil and VK_IMAGE_LAYOUT_UNDEFINED
|
|
* otherwise.
|
|
*/
|
|
VkImageLayout stencil_layout;
|
|
|
|
/** A per-view mask for if this is the last use of this attachment
|
|
*
|
|
* If the same render pass attachment is used multiple ways within a
|
|
* subpass, corresponding last_subpass bits will be set in all of them.
|
|
* For the non-multiview case, only the first bit is used.
|
|
*/
|
|
uint32_t last_subpass;
|
|
|
|
/** Resolve attachment, if any */
|
|
struct vk_subpass_attachment *resolve;
|
|
};
|
|
|
|
struct vk_subpass {
|
|
/** Count of all attachments referenced by this subpass */
|
|
uint32_t attachment_count;
|
|
|
|
/** Array of all attachments referenced by this subpass */
|
|
struct vk_subpass_attachment *attachments;
|
|
|
|
/** VkSubpassDescription2::inputAttachmentCount */
|
|
uint32_t input_count;
|
|
|
|
/** VkSubpassDescription2::pInputAttachments */
|
|
struct vk_subpass_attachment *input_attachments;
|
|
|
|
/** VkSubpassDescription2::colorAttachmentCount */
|
|
uint32_t color_count;
|
|
|
|
/** VkSubpassDescription2::pColorAttachments */
|
|
struct vk_subpass_attachment *color_attachments;
|
|
|
|
/** VkSubpassDescription2::colorAttachmentCount or zero */
|
|
uint32_t color_resolve_count;
|
|
|
|
/** VkSubpassDescription2::pResolveAttachments */
|
|
struct vk_subpass_attachment *color_resolve_attachments;
|
|
|
|
/** VkSubpassDescription2::pDepthStencilAttachment */
|
|
struct vk_subpass_attachment *depth_stencil_attachment;
|
|
|
|
/** VkSubpassDescriptionDepthStencilResolve::pDepthStencilResolveAttachment */
|
|
struct vk_subpass_attachment *depth_stencil_resolve_attachment;
|
|
|
|
/** VkFragmentShadingRateAttachmentInfoKHR::pFragmentShadingRateAttachment */
|
|
struct vk_subpass_attachment *fragment_shading_rate_attachment;
|
|
|
|
/** VkSubpassDescription2::viewMask or 1 for non-multiview
|
|
*
|
|
* For all view masks in the vk_render_pass data structure, we use a mask
|
|
* of 1 for non-multiview instead of a mask of 0. To determine if the
|
|
* render pass is multiview or not, see vk_render_pass::is_multiview.
|
|
*/
|
|
uint32_t view_mask;
|
|
|
|
/** VkSubpassDescriptionDepthStencilResolve::depthResolveMode */
|
|
VkResolveModeFlagBits depth_resolve_mode;
|
|
|
|
/** VkSubpassDescriptionDepthStencilResolve::stencilResolveMode */
|
|
VkResolveModeFlagBits stencil_resolve_mode;
|
|
|
|
/** VkFragmentShadingRateAttachmentInfoKHR::shadingRateAttachmentTexelSize */
|
|
VkExtent2D fragment_shading_rate_attachment_texel_size;
|
|
|
|
/** VkRenderingSelfDependencyInfoMESA for this subpass
|
|
*
|
|
* This is in the pNext chain of pipeline_info and inheritance_info.
|
|
*/
|
|
VkRenderingSelfDependencyInfoMESA self_dep_info;
|
|
|
|
/** VkAttachmentSampleCountInfoAMD for this subpass
|
|
*
|
|
* This is in the pNext chain of pipeline_info and inheritance_info.
|
|
*/
|
|
VkAttachmentSampleCountInfoAMD sample_count_info_amd;
|
|
|
|
/** VkPipelineRenderingCreateInfo for this subpass
|
|
*
|
|
* Returned by vk_get_pipeline_rendering_create_info() if
|
|
* VkGraphicsPipelineCreateInfo::renderPass != VK_NULL_HANDLE.
|
|
*/
|
|
VkPipelineRenderingCreateInfo pipeline_info;
|
|
|
|
/** VkCommandBufferInheritanceRenderingInfo for this subpass
|
|
*
|
|
* Returned by vk_get_command_buffer_inheritance_rendering_info() if
|
|
* VkCommandBufferInheritanceInfo::renderPass != VK_NULL_HANDLE.
|
|
*/
|
|
VkCommandBufferInheritanceRenderingInfo inheritance_info;
|
|
|
|
/** VkMultisampledRenderToSingleSampledInfoEXT for this subpass */
|
|
VkMultisampledRenderToSingleSampledInfoEXT mrtss;
|
|
};
|
|
|
|
struct vk_render_pass_attachment {
|
|
/** VkAttachmentDescription2::format */
|
|
VkFormat format;
|
|
|
|
/** Aspects contained in format */
|
|
VkImageAspectFlags aspects;
|
|
|
|
/** VkAttachmentDescription2::samples */
|
|
uint32_t samples;
|
|
|
|
/** Views in which this attachment is used, 0 for unused
|
|
*
|
|
* For non-multiview, this will be 1 if the attachment is used.
|
|
*/
|
|
uint32_t view_mask;
|
|
|
|
/** VkAttachmentDescription2::loadOp */
|
|
VkAttachmentLoadOp load_op;
|
|
|
|
/** VkAttachmentDescription2::storeOp */
|
|
VkAttachmentStoreOp store_op;
|
|
|
|
/** VkAttachmentDescription2::stencilLoadOp */
|
|
VkAttachmentLoadOp stencil_load_op;
|
|
|
|
/** VkAttachmentDescription2::stencilStoreOp */
|
|
VkAttachmentStoreOp stencil_store_op;
|
|
|
|
/** VkAttachmentDescription2::initialLayout */
|
|
VkImageLayout initial_layout;
|
|
|
|
/** VkAttachmentDescription2::finalLayout */
|
|
VkImageLayout final_layout;
|
|
|
|
/** VkAttachmentDescriptionStencilLayout::stencilInitialLayout
|
|
*
|
|
* If VK_KHR_separate_depth_stencil_layouts is not used, this will be
|
|
* initial_layout if format contains stencil and VK_IMAGE_LAYOUT_UNDEFINED
|
|
* otherwise.
|
|
*/
|
|
VkImageLayout initial_stencil_layout;
|
|
|
|
/** VkAttachmentDescriptionStencilLayout::stencilFinalLayout
|
|
*
|
|
* If VK_KHR_separate_depth_stencil_layouts is not used, this will be
|
|
* final_layout if format contains stencil and VK_IMAGE_LAYOUT_UNDEFINED
|
|
* otherwise.
|
|
*/
|
|
VkImageLayout final_stencil_layout;
|
|
};
|
|
|
|
struct vk_subpass_dependency {
|
|
/** VkSubpassDependency2::dependencyFlags */
|
|
VkDependencyFlags flags;
|
|
|
|
/** VkSubpassDependency2::srcSubpass */
|
|
uint32_t src_subpass;
|
|
|
|
/** VkSubpassDependency2::dstSubpass */
|
|
uint32_t dst_subpass;
|
|
|
|
/** VkSubpassDependency2::srcStageMask */
|
|
VkPipelineStageFlags2 src_stage_mask;
|
|
|
|
/** VkSubpassDependency2::dstStageMask */
|
|
VkPipelineStageFlags2 dst_stage_mask;
|
|
|
|
/** VkSubpassDependency2::srcAccessMask */
|
|
VkAccessFlags2 src_access_mask;
|
|
|
|
/** VkSubpassDependency2::dstAccessMask */
|
|
VkAccessFlags2 dst_access_mask;
|
|
|
|
/** VkSubpassDependency2::viewOffset */
|
|
int32_t view_offset;
|
|
};
|
|
|
|
struct vk_render_pass {
|
|
struct vk_object_base base;
|
|
|
|
/** True if this render pass uses multiview
|
|
*
|
|
* This is true if all subpasses have viewMask != 0.
|
|
*/
|
|
bool is_multiview;
|
|
|
|
/** Views used by this render pass or 1 for non-multiview */
|
|
uint32_t view_mask;
|
|
|
|
/** VkRenderPassCreateInfo2::attachmentCount */
|
|
uint32_t attachment_count;
|
|
|
|
/** VkRenderPassCreateInfo2::pAttachments */
|
|
struct vk_render_pass_attachment *attachments;
|
|
|
|
/** VkRenderPassCreateInfo2::subpassCount */
|
|
uint32_t subpass_count;
|
|
|
|
/** VkRenderPassCreateInfo2::subpasses */
|
|
struct vk_subpass *subpasses;
|
|
|
|
/** VkRenderPassCreateInfo2::dependencyCount */
|
|
uint32_t dependency_count;
|
|
|
|
/** VkRenderPassCreateInfo2::pDependencies */
|
|
struct vk_subpass_dependency *dependencies;
|
|
};
|
|
|
|
VK_DEFINE_NONDISP_HANDLE_CASTS(vk_render_pass, base, VkRenderPass,
|
|
VK_OBJECT_TYPE_RENDER_PASS);
|
|
|
|
/** Returns the VkPipelineRenderingCreateInfo for a graphics pipeline
|
|
*
|
|
* For render-pass-free drivers, this can be used in the implementation of
|
|
* vkCreateGraphicsPipelines to get the VkPipelineRenderingCreateInfo. If
|
|
* VkGraphicsPipelineCreateInfo::renderPass is not VK_NULL_HANDLE, it will
|
|
* return a representation of the specified subpass as a
|
|
* VkPipelineRenderingCreateInfo. If VkGraphicsPipelineCreateInfo::renderPass
|
|
* is VK_NULL_HANDLE and there is a VkPipelineRenderingCreateInfo in the pNext
|
|
* chain of VkGraphicsPipelineCreateInfo, it will return that.
|
|
*
|
|
* @param[in] info One of the pCreateInfos from vkCreateGraphicsPipelines
|
|
*/
|
|
const VkPipelineRenderingCreateInfo *
|
|
vk_get_pipeline_rendering_create_info(const VkGraphicsPipelineCreateInfo *info);
|
|
|
|
/** Returns the VkAttachmentSampleCountInfoAMD for a graphics pipeline
|
|
*
|
|
* For render-pass-free drivers, this can be used in the implementaiton of
|
|
* vkCreateGraphicsPipelines to get the VkAttachmentSampleCountInfoAMD. If
|
|
* VkGraphicsPipelineCreateInfo::renderPass is not VK_NULL_HANDLE, it will
|
|
* return the sample counts from the specified subpass as a
|
|
* VkAttachmentSampleCountInfoAMD. If VkGraphicsPipelineCreateInfo::renderPass
|
|
* is VK_NULL_HANDLE and there is a VkAttachmentSampleCountInfoAMD in the pNext
|
|
* chain of VkGraphicsPipelineCreateInfo, it will return that.
|
|
*
|
|
* @param[in] info One of the pCreateInfos from vkCreateGraphicsPipelines
|
|
*/
|
|
const VkAttachmentSampleCountInfoAMD *
|
|
vk_get_pipeline_sample_count_info_amd(const VkGraphicsPipelineCreateInfo *info);
|
|
|
|
/**
|
|
* Returns the VkCommandBufferInheritanceRenderingInfo for secondary command
|
|
* buffer execution
|
|
*
|
|
* For render-pass-free drivers, this can be used in the implementation of
|
|
* vkCmdExecuteCommands to get the VkCommandBufferInheritanceRenderingInfo.
|
|
* If VkCommandBufferInheritanceInfo::renderPass is not VK_NULL_HANDLE, it
|
|
* will return a representation of the specified subpass as a
|
|
* VkCommandBufferInheritanceRenderingInfo. If
|
|
* VkCommandBufferInheritanceInfo::renderPass is not VK_NULL_HANDLE and there
|
|
* is a VkCommandBufferInheritanceRenderingInfo in the pNext chain of
|
|
* VkCommandBufferBeginInfo, it will return that.
|
|
*
|
|
* @param[in] level The nesting level of this command buffer
|
|
* @param[in] pBeginInfo The pBeginInfo from vkBeginCommandBuffer
|
|
*/
|
|
const VkCommandBufferInheritanceRenderingInfo *
|
|
vk_get_command_buffer_inheritance_rendering_info(
|
|
VkCommandBufferLevel level,
|
|
const VkCommandBufferBeginInfo *pBeginInfo);
|
|
|
|
struct vk_gcbiarr_data {
|
|
VkRenderingInfo rendering;
|
|
VkRenderingFragmentShadingRateAttachmentInfoKHR fsr_att;
|
|
VkRenderingAttachmentInfo attachments[];
|
|
};
|
|
|
|
#define VK_GCBIARR_DATA_SIZE(max_color_rts) (\
|
|
sizeof(struct vk_gcbiarr_data) + \
|
|
sizeof(VkRenderingAttachmentInfo) * ((max_color_rts) + 2) \
|
|
)
|
|
|
|
/**
|
|
* Constructs a VkRenderingInfo for the inheritance rendering info
|
|
*
|
|
* For render-pass-free drivers, this can be used in the implementaiton of
|
|
* vkCmdExecuteCommands to get a VkRenderingInfo representing the subpass and
|
|
* framebuffer provided via the inheritance info for a command buffer created
|
|
* with VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT. The mental model
|
|
* here is that VkExecuteCommands() implicitly suspends the render pass and
|
|
* VkBeginCommandBuffer() resumes it. If a VkRenderingInfo cannot be
|
|
* constructed due to a missing framebuffer or similar, NULL will be
|
|
* returned.
|
|
*
|
|
* @param[in] level The nesting level of this command buffer
|
|
* @param[in] pBeginInfo The pBeginInfo from vkBeginCommandBuffer
|
|
* @param[out] stack_data An opaque blob of data which will be overwritten by
|
|
* this function, passed in from the caller to avoid
|
|
* heap allocations. It must be at least
|
|
* VK_GCBIARR_DATA_SIZE(max_color_rts) bytes.
|
|
*/
|
|
const VkRenderingInfo *
|
|
vk_get_command_buffer_inheritance_as_rendering_resume(
|
|
VkCommandBufferLevel level,
|
|
const VkCommandBufferBeginInfo *pBeginInfo,
|
|
void *stack_data);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif /* VK_RENDER_PASS_H */
|