## 8. Render Pass

A render pass represents a collection of attachments, subpasses, and dependencies between the subpasses, and describes how the attachments are used over the course of the subpasses. The use of a render pass in a command buffer is a render pass instance.

Render passes are represented by VkRenderPass handles:

// Provided by VK_VERSION_1_0
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass)

An attachment description describes the properties of an attachment including its format, sample count, and how its contents are treated at the beginning and end of each render pass instance.

A subpass represents a phase of rendering that reads and writes a subset of the attachments in a render pass. Rendering commands are recorded into a particular subpass of a render pass instance.

A subpass description describes the subset of attachments that is involved in the execution of a subpass. Each subpass can read from some attachments as input attachments, write to some as color attachments or depth/stencil attachments, and perform multisample resolve operations to resolve attachments. A subpass description can also include a set of preserve attachments, which are attachments that are not read or written by the subpass but whose contents must be preserved throughout the subpass.

A subpass uses an attachment if the attachment is a color, depth/stencil, resolve, depth/stencil resolve, or input attachment for that subpass (as determined by the pColorAttachments, pDepthStencilAttachment, pResolveAttachments, VkSubpassDescriptionDepthStencilResolve::pDepthStencilResolveAttachment, and pInputAttachments members of VkSubpassDescription, respectively). A subpass does not use an attachment if that attachment is preserved by the subpass. The first use of an attachment is in the lowest numbered subpass that uses that attachment. Similarly, the last use of an attachment is in the highest numbered subpass that uses that attachment.

The subpasses in a render pass all render to the same dimensions, and fragments for pixel (x,y,layer) in one subpass can only read attachment contents written by previous subpasses at that same (x,y,layer) location.

 Note By describing a complete set of subpasses in advance, render passes provide the implementation an opportunity to optimize the storage and transfer of attachment data between subpasses. In practice, this means that subpasses with a simple framebuffer-space dependency may be merged into a single tiled rendering pass, keeping the attachment data on-chip for the duration of a render pass instance. However, it is also quite common for a render pass to only contain a single subpass.

Subpass dependencies describe execution and memory dependencies between subpasses.

A subpass dependency chain is a sequence of subpass dependencies in a render pass, where the source subpass of each subpass dependency (after the first) equals the destination subpass of the previous dependency.

Execution of subpasses may overlap or execute out of order with regards to other subpasses, unless otherwise enforced by an execution dependency. Each subpass only respects submission order for commands recorded in the same subpass, and the vkCmdBeginRenderPass and vkCmdEndRenderPass commands that delimit the render pass - commands within other subpasses are not included. This affects most other implicit ordering guarantees.

A render pass describes the structure of subpasses and attachments independent of any specific image views for the attachments. The specific image views that will be used for the attachments, and their dimensions, are specified in VkFramebuffer objects. Framebuffers are created with respect to a specific render pass that the framebuffer is compatible with (see Render Pass Compatibility). Collectively, a render pass and a framebuffer define the complete render target state for one or more subpasses as well as the algorithmic dependencies between the subpasses.

The various pipeline stages of the drawing commands for a given subpass may execute concurrently and/or out of order, both within and across drawing commands, whilst still respecting pipeline order. However for a given (x,y,layer,sample) sample location, certain per-sample operations are performed in rasterization order.

### 8.1. Render Pass Creation

To create a render pass, call:

// Provided by VK_VERSION_1_0
VkResult vkCreateRenderPass(
VkDevice                                    device,
const VkRenderPassCreateInfo*               pCreateInfo,
const VkAllocationCallbacks*                pAllocator,
VkRenderPass*                               pRenderPass);
• device is the logical device that creates the render pass.

• pCreateInfo is a pointer to a VkRenderPassCreateInfo structure describing the parameters of the render pass.

• pAllocator controls host memory allocation as described in the Memory Allocation chapter.

• pRenderPass is a pointer to a VkRenderPass handle in which the resulting render pass object is returned.

Valid Usage (Implicit)
• VUID-vkCreateRenderPass-device-parameter
device must be a valid VkDevice handle

• VUID-vkCreateRenderPass-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkRenderPassCreateInfo structure

• VUID-vkCreateRenderPass-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure

• VUID-vkCreateRenderPass-pRenderPass-parameter
pRenderPass must be a valid pointer to a VkRenderPass handle

Return Codes
Success
• VK_SUCCESS

Failure
• VK_ERROR_OUT_OF_HOST_MEMORY

• VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkRenderPassCreateInfo structure is defined as:

// Provided by VK_VERSION_1_0
typedef struct VkRenderPassCreateInfo {
VkStructureType                   sType;
const void*                       pNext;
VkRenderPassCreateFlags           flags;
uint32_t                          attachmentCount;
const VkAttachmentDescription*    pAttachments;
uint32_t                          subpassCount;
const VkSubpassDescription*       pSubpasses;
uint32_t                          dependencyCount;
const VkSubpassDependency*        pDependencies;
} VkRenderPassCreateInfo;
• sType is the type of this structure.

• pNext is NULL or a pointer to a structure extending this structure.

• flags is reserved for future use.

• attachmentCount is the number of attachments used by this render pass.

• pAttachments is a pointer to an array of attachmentCount VkAttachmentDescription structures describing the attachments used by the render pass.

• subpassCount is the number of subpasses to create.

• pSubpasses is a pointer to an array of subpassCount VkSubpassDescription structures describing each subpass.

• dependencyCount is the number of memory dependencies between pairs of subpasses.

• pDependencies is a pointer to an array of dependencyCount VkSubpassDependency structures describing dependencies between pairs of subpasses.

 Note Care should be taken to avoid a data race here; if any subpasses access attachments with overlapping memory locations, and one of those accesses is a write, a subpass dependency needs to be included between them.
Valid Usage
• VUID-VkRenderPassCreateInfo-attachment-00834
If the attachment member of any element of pInputAttachments, pColorAttachments, pResolveAttachments or pDepthStencilAttachment, or any element of pPreserveAttachments in any element of pSubpasses is not VK_ATTACHMENT_UNUSED, it must be less than attachmentCount

• VUID-VkRenderPassCreateInfo-pAttachments-00836
For any member of pAttachments with a loadOp equal to VK_ATTACHMENT_LOAD_OP_CLEAR, the first use of that attachment must not specify a layout equal to VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL

• VUID-VkRenderPassCreateInfo-pAttachments-02511
For any member of pAttachments with a stencilLoadOp equal to VK_ATTACHMENT_LOAD_OP_CLEAR, the first use of that attachment must not specify a layout equal to VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL

• VUID-VkRenderPassCreateInfo-pAttachments-01566
For any member of pAttachments with a loadOp equal to VK_ATTACHMENT_LOAD_OP_CLEAR, the first use of that attachment must not specify a layout equal to VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL

• VUID-VkRenderPassCreateInfo-pAttachments-01567
For any member of pAttachments with a stencilLoadOp equal to VK_ATTACHMENT_LOAD_OP_CLEAR, the first use of that attachment must not specify a layout equal to VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL

• VUID-VkRenderPassCreateInfo-pNext-01926
If the pNext chain includes a VkRenderPassInputAttachmentAspectCreateInfo structure, the subpass member of each element of its pAspectReferences member must be less than subpassCount

• VUID-VkRenderPassCreateInfo-pNext-01927
If the pNext chain includes a VkRenderPassInputAttachmentAspectCreateInfo structure, the inputAttachmentIndex member of each element of its pAspectReferences member must be less than the value of inputAttachmentCount in the member of pSubpasses identified by its subpass member

• VUID-VkRenderPassCreateInfo-pNext-01963
If the pNext chain includes a VkRenderPassInputAttachmentAspectCreateInfo structure, for any element of the pInputAttachments member of any element of pSubpasses where the attachment member is not VK_ATTACHMENT_UNUSED, the aspectMask member of the corresponding element of VkRenderPassInputAttachmentAspectCreateInfo::pAspectReferences must only include aspects that are present in images of the format specified by the element of pAttachments at attachment

• VUID-VkRenderPassCreateInfo-pNext-01928
If the pNext chain includes a VkRenderPassMultiviewCreateInfo structure, and its subpassCount member is not zero, that member must be equal to the value of subpassCount

• VUID-VkRenderPassCreateInfo-pNext-01929
If the pNext chain includes a VkRenderPassMultiviewCreateInfo structure, if its dependencyCount member is not zero, it must be equal to dependencyCount

• VUID-VkRenderPassCreateInfo-pNext-01930
If the pNext chain includes a VkRenderPassMultiviewCreateInfo structure, for each non-zero element of pViewOffsets, the srcSubpass and dstSubpass members of pDependencies at the same index must not be equal

• VUID-VkRenderPassCreateInfo-pNext-02512
If the pNext chain includes a VkRenderPassMultiviewCreateInfo structure, for any element of pDependencies with a dependencyFlags member that does not include VK_DEPENDENCY_VIEW_LOCAL_BIT, the corresponding element of the pViewOffsets member of that VkRenderPassMultiviewCreateInfo instance must be 0

• VUID-VkRenderPassCreateInfo-pNext-02513
If the pNext chain includes a VkRenderPassMultiviewCreateInfo structure, elements of its pViewMasks member must either all be 0, or all not be 0

• VUID-VkRenderPassCreateInfo-pNext-02514
If the pNext chain includes a VkRenderPassMultiviewCreateInfo structure, and each element of its pViewMasks member is 0, the dependencyFlags member of each element of pDependencies must not include VK_DEPENDENCY_VIEW_LOCAL_BIT

• VUID-VkRenderPassCreateInfo-pNext-02515
If the pNext chain includes a VkRenderPassMultiviewCreateInfo structure, and each element of its pViewMasks member is 0, correlatedViewMaskCount must be 0

• VUID-VkRenderPassCreateInfo-pDependencies-00837
For any element of pDependencies, if the srcSubpass is not VK_SUBPASS_EXTERNAL, all stage flags included in the srcStageMask member of that dependency must be a pipeline stage supported by the pipeline identified by the pipelineBindPoint member of the source subpass

• VUID-VkRenderPassCreateInfo-pDependencies-00838
For any element of pDependencies, if the dstSubpass is not VK_SUBPASS_EXTERNAL, all stage flags included in the dstStageMask member of that dependency must be a pipeline stage supported by the pipeline identified by the pipelineBindPoint member of the destination subpass

• VUID-VkRenderPassCreateInfo-srcSubpass-02517
The srcSubpass member of each element of pDependencies must be less than subpassCount

• VUID-VkRenderPassCreateInfo-dstSubpass-02518
The dstSubpass member of each element of pDependencies must be less than subpassCount

Valid Usage (Implicit)
• VUID-VkRenderPassCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO

• VUID-VkRenderPassCreateInfo-pNext-pNext
Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkRenderPassInputAttachmentAspectCreateInfo or VkRenderPassMultiviewCreateInfo

• VUID-VkRenderPassCreateInfo-sType-unique
The sType value of each struct in the pNext chain must be unique

flags must be 0

• VUID-VkRenderPassCreateInfo-pAttachments-parameter
If attachmentCount is not 0, pAttachments must be a valid pointer to an array of attachmentCount valid VkAttachmentDescription structures

• VUID-VkRenderPassCreateInfo-pSubpasses-parameter
pSubpasses must be a valid pointer to an array of subpassCount valid VkSubpassDescription structures

• VUID-VkRenderPassCreateInfo-pDependencies-parameter
If dependencyCount is not 0, pDependencies must be a valid pointer to an array of dependencyCount valid VkSubpassDependency structures

• VUID-VkRenderPassCreateInfo-subpassCount-arraylength
subpassCount must be greater than 0

// Provided by VK_VERSION_1_0
typedef VkFlags VkRenderPassCreateFlags;

VkRenderPassCreateFlags is a bitmask type for setting a mask of zero or more VkRenderPassCreateFlagBits.

If the VkRenderPassCreateInfo::pNext chain includes a VkRenderPassMultiviewCreateInfo structure, then that structure includes an array of view masks, view offsets, and correlation masks for the render pass.

The VkRenderPassMultiviewCreateInfo structure is defined as:

// Provided by VK_VERSION_1_1
typedef struct VkRenderPassMultiviewCreateInfo {
VkStructureType    sType;
const void*        pNext;
uint32_t           subpassCount;
uint32_t           dependencyCount;
const int32_t*     pViewOffsets;
} VkRenderPassMultiviewCreateInfo;
• sType is the type of this structure.

• pNext is NULL or a pointer to a structure extending this structure.

• subpassCount is zero or the number of subpasses in the render pass.

• pViewMasks is a pointer to an array of subpassCount view masks, where each mask is a bitfield of view indices describing which views rendering is broadcast to in each subpass, when multiview is enabled. If subpassCount is zero, each view mask is treated as zero.

• dependencyCount is zero or the number of dependencies in the render pass.

• pViewOffsets is a pointer to an array of dependencyCount view offsets, one for each dependency. If dependencyCount is zero, each dependency’s view offset is treated as zero. Each view offset controls which views in the source subpass the views in the destination subpass depend on.

• correlationMaskCount is zero or the number of correlation masks.

• pCorrelationMasks is a pointer to an array of correlationMaskCount view masks indicating sets of views that may be more efficient to render concurrently.

When a subpass uses a non-zero view mask, multiview functionality is considered to be enabled. Multiview is all-or-nothing for a render pass - that is, either all subpasses must have a non-zero view mask (though some subpasses may have only one view) or all must be zero. Multiview causes all drawing and clear commands in the subpass to behave as if they were broadcast to each view, where a view is represented by one layer of the framebuffer attachments. All draws and clears are broadcast to each view index whose bit is set in the view mask. The view index is provided in the ViewIndex shader input variable, and color, depth/stencil, and input attachments all read/write the layer of the framebuffer corresponding to the view index.

If the view mask is zero for all subpasses, multiview is considered to be disabled and all drawing commands execute normally, without this additional broadcasting.

Some implementations may not support multiview in conjunction with geometry shaders or tessellation shaders.

When multiview is enabled, the VK_DEPENDENCY_VIEW_LOCAL_BIT bit in a dependency can be used to express a view-local dependency, meaning that each view in the destination subpass depends on a single view in the source subpass. Unlike pipeline barriers, a subpass dependency can potentially have a different view mask in the source subpass and the destination subpass. If the dependency is view-local, then each view (dstView) in the destination subpass depends on the view dstView + pViewOffsets[dependency] in the source subpass. If there is not such a view in the source subpass, then this dependency does not affect that view in the destination subpass. If the dependency is not view-local, then all views in the destination subpass depend on all views in the source subpass, and the view offset is ignored. A non-zero view offset is not allowed in a self-dependency.

The elements of pCorrelationMasks are a set of masks of views indicating that views in the same mask may exhibit spatial coherency between the views, making it more efficient to render them concurrently. Correlation masks must not have a functional effect on the results of the multiview rendering.

When multiview is enabled, at the beginning of each subpass all non-render pass state is undefined. In particular, each time vkCmdBeginRenderPass or vkCmdNextSubpass is called the graphics pipeline must be bound, any relevant descriptor sets or vertex/index buffers must be bound, and any relevant dynamic state or push constants must be set before they are used.

Valid Usage
Each view index must not be set in more than one element of pCorrelationMasks

Valid Usage (Implicit)
• VUID-VkRenderPassMultiviewCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO

If subpassCount is not 0, pViewMasks must be a valid pointer to an array of subpassCount uint32_t values

• VUID-VkRenderPassMultiviewCreateInfo-pViewOffsets-parameter
If dependencyCount is not 0, pViewOffsets must be a valid pointer to an array of dependencyCount int32_t values

If correlationMaskCount is not 0, pCorrelationMasks must be a valid pointer to an array of correlationMaskCount uint32_t values

The VkAttachmentDescription structure is defined as:

// Provided by VK_VERSION_1_0
typedef struct VkAttachmentDescription {
VkAttachmentDescriptionFlags    flags;
VkFormat                        format;
VkSampleCountFlagBits           samples;
VkAttachmentStoreOp             storeOp;
VkAttachmentStoreOp             stencilStoreOp;
VkImageLayout                   initialLayout;
VkImageLayout                   finalLayout;
} VkAttachmentDescription;
• flags is a bitmask of VkAttachmentDescriptionFlagBits specifying additional properties of the attachment.

• format is a VkFormat value specifying the format of the image view that will be used for the attachment.

• samples is the number of samples of the image as defined in VkSampleCountFlagBits.

• loadOp is a VkAttachmentLoadOp value specifying how the contents of color and depth components of the attachment are treated at the beginning of the subpass where it is first used.

• storeOp is a VkAttachmentStoreOp value specifying how the contents of color and depth components of the attachment are treated at the end of the subpass where it is last used.

• stencilLoadOp is a VkAttachmentLoadOp value specifying how the contents of stencil components of the attachment are treated at the beginning of the subpass where it is first used.

• stencilStoreOp is a VkAttachmentStoreOp value specifying how the contents of stencil components of the attachment are treated at the end of the last subpass where it is used.

• initialLayout is the layout the attachment image subresource will be in when a render pass instance begins.

• finalLayout is the layout the attachment image subresource will be transitioned to when a render pass instance ends.

If the attachment uses a color format, then loadOp and storeOp are used, and stencilLoadOp and stencilStoreOp are ignored. If the format has depth and/or stencil components, loadOp and storeOp apply only to the depth data, while stencilLoadOp and stencilStoreOp define how the stencil data is handled. loadOp and stencilLoadOp define the load operations that execute as part of the first subpass that uses the attachment. storeOp and stencilStoreOp define the store operations that execute as part of the last subpass that uses the attachment.

The load operation for each sample in an attachment happens-before any recorded command which accesses the sample in the first subpass where the attachment is used. Load operations for attachments with a depth/stencil format execute in the VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT pipeline stage. Load operations for attachments with a color format execute in the VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT pipeline stage.

The store operation for each sample in an attachment happens-after any recorded command which accesses the sample in the last subpass where the attachment is used. Store operations for attachments with a depth/stencil format execute in the VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT pipeline stage. Store operations for attachments with a color format execute in the VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT pipeline stage.

If an attachment is not used by any subpass, then loadOp, storeOp, stencilStoreOp, and stencilLoadOp are ignored, and the attachment’s memory contents will not be modified by execution of a render pass instance.

The load and store operations apply on the first and last use of each view in the render pass, respectively. If a view index of an attachment is not included in the view mask in any subpass that uses it, then the load and store operations are ignored, and the attachment’s memory contents will not be modified by execution of a render pass instance.

During a render pass instance, input/color attachments with color formats that have a component size of 8, 16, or 32 bits must be represented in the attachment’s format throughout the instance. Attachments with other floating- or fixed-point color formats, or with depth components may be represented in a format with a precision higher than the attachment format, but must be represented with the same range. When such a component is loaded via the loadOp, it will be converted into an implementation-dependent format used by the render pass. Such components must be converted from the render pass format, to the format of the attachment, before they are resolved or stored at the end of a render pass instance via storeOp. Conversions occur as described in Numeric Representation and Computation and Fixed-Point Data Conversions.

If flags includes VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT, then the attachment is treated as if it shares physical memory with another attachment in the same render pass. This information limits the ability of the implementation to reorder certain operations (like layout transitions and the loadOp) such that it is not improperly reordered against other uses of the same physical memory via a different attachment. This is described in more detail below.

If a render pass uses multiple attachments that alias the same device memory, those attachments must each include the VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT bit in their attachment description flags. Attachments aliasing the same memory occurs in multiple ways:

• Multiple attachments being assigned the same image view as part of framebuffer creation.

• Attachments using distinct image views that correspond to the same image subresource of an image.

• Attachments using views of distinct image subresources which are bound to overlapping memory ranges.

 Note Render passes must include subpass dependencies (either directly or via a subpass dependency chain) between any two subpasses that operate on the same attachment or aliasing attachments and those subpass dependencies must include execution and memory dependencies separating uses of the aliases, if at least one of those subpasses writes to one of the aliases. These dependencies must not include the VK_DEPENDENCY_BY_REGION_BIT if the aliases are views of distinct image subresources which overlap in memory.

Multiple attachments that alias the same memory must not be used in a single subpass. A given attachment index must not be used multiple times in a single subpass, with one exception: two subpass attachments can use the same attachment index if at least one use is as an input attachment and neither use is as a resolve or preserve attachment. In other words, the same view can be used simultaneously as an input and color or depth/stencil attachment, but must not be used as multiple color or depth/stencil attachments nor as resolve or preserve attachments. The precise set of valid scenarios is described in more detail below.

If a set of attachments alias each other, then all except the first to be used in the render pass must use an initialLayout of VK_IMAGE_LAYOUT_UNDEFINED, since the earlier uses of the other aliases make their contents undefined. Once an alias has been used and a different alias has been used after it, the first alias must not be used in any later subpasses. However, an application can assign the same image view to multiple aliasing attachment indices, which allows that image view to be used multiple times even if other aliases are used in between.

 Note Once an attachment needs the VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT bit, there should be no additional cost of introducing additional aliases, and using these additional aliases may allow more efficient clearing of the attachments on multiple uses via VK_ATTACHMENT_LOAD_OP_CLEAR.
Valid Usage
• VUID-VkAttachmentDescription-finalLayout-00843
finalLayout must not be VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED

• VUID-VkAttachmentDescription-format-03280
If format is a color format, initialLayout must not be VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL

• VUID-VkAttachmentDescription-format-03281
If format is a depth/stencil format, initialLayout must not be VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL

• VUID-VkAttachmentDescription-format-03282
If format is a color format, finalLayout must not be VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL

• VUID-VkAttachmentDescription-format-03283
If format is a depth/stencil format, finalLayout must not be VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL

• VUID-VkAttachmentDescription-separateDepthStencilLayouts-03284
If the separateDepthStencilLayouts feature is not enabled, initialLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL

• VUID-VkAttachmentDescription-separateDepthStencilLayouts-03285
If the separateDepthStencilLayouts feature is not enabled, finalLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL

• VUID-VkAttachmentDescription-format-03286
If format is a color format, initialLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL

• VUID-VkAttachmentDescription-format-03287
If format is a color format, finalLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL

• VUID-VkAttachmentDescription-format-03288
If format is a depth/stencil format which includes both depth and stencil aspects, initialLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL

• VUID-VkAttachmentDescription-format-03289
If format is a depth/stencil format which includes both depth and stencil aspects, finalLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL

• VUID-VkAttachmentDescription-format-03290
If format is a depth/stencil format which includes only the depth aspect, initialLayout must not be VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL

• VUID-VkAttachmentDescription-format-03291
If format is a depth/stencil format which includes only the depth aspect, finalLayout must not be VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL

• VUID-VkAttachmentDescription-format-03292
If format is a depth/stencil format which includes only the stencil aspect, initialLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL

• VUID-VkAttachmentDescription-format-03293
If format is a depth/stencil format which includes only the stencil aspect, finalLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL

Valid Usage (Implicit)
• VUID-VkAttachmentDescription-flags-parameter
flags must be a valid combination of VkAttachmentDescriptionFlagBits values

• VUID-VkAttachmentDescription-format-parameter
format must be a valid VkFormat value

• VUID-VkAttachmentDescription-samples-parameter
samples must be a valid VkSampleCountFlagBits value

loadOp must be a valid VkAttachmentLoadOp value

• VUID-VkAttachmentDescription-storeOp-parameter
storeOp must be a valid VkAttachmentStoreOp value

stencilLoadOp must be a valid VkAttachmentLoadOp value

• VUID-VkAttachmentDescription-stencilStoreOp-parameter
stencilStoreOp must be a valid VkAttachmentStoreOp value

• VUID-VkAttachmentDescription-initialLayout-parameter
initialLayout must be a valid VkImageLayout value

• VUID-VkAttachmentDescription-finalLayout-parameter
finalLayout must be a valid VkImageLayout value

Bits which can be set in VkAttachmentDescription::flags describing additional properties of the attachment are:

// Provided by VK_VERSION_1_0
typedef enum VkAttachmentDescriptionFlagBits {
VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001,
} VkAttachmentDescriptionFlagBits;
• VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT specifies that the attachment aliases the same device memory as other attachments.

// Provided by VK_VERSION_1_0
typedef VkFlags VkAttachmentDescriptionFlags;

VkAttachmentDescriptionFlags is a bitmask type for setting a mask of zero or more VkAttachmentDescriptionFlagBits.

Possible values of VkAttachmentDescription::loadOp and stencilLoadOp, specifying how the contents of the attachment are treated, are:

// Provided by VK_VERSION_1_0
} VkAttachmentLoadOp;
• VK_ATTACHMENT_LOAD_OP_LOAD specifies that the previous contents of the image within the render area will be preserved. For attachments with a depth/stencil format, this uses the access type VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT. For attachments with a color format, this uses the access type VK_ACCESS_COLOR_ATTACHMENT_READ_BIT.

• VK_ATTACHMENT_LOAD_OP_CLEAR specifies that the contents within the render area will be cleared to a uniform value, which is specified when a render pass instance is begun. For attachments with a depth/stencil format, this uses the access type VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT. For attachments with a color format, this uses the access type VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT.

• VK_ATTACHMENT_LOAD_OP_DONT_CARE specifies that the previous contents within the area need not be preserved; the contents of the attachment will be undefined inside the render area. For attachments with a depth/stencil format, this uses the access type VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT. For attachments with a color format, this uses the access type VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT.

Possible values of VkAttachmentDescription::storeOp and stencilStoreOp, specifying how the contents of the attachment are treated, are:

// Provided by VK_VERSION_1_0
typedef enum VkAttachmentStoreOp {
VK_ATTACHMENT_STORE_OP_STORE = 0,
VK_ATTACHMENT_STORE_OP_DONT_CARE = 1,
} VkAttachmentStoreOp;
• VK_ATTACHMENT_STORE_OP_STORE specifies the contents generated during the render pass and within the render area are written to memory. For attachments with a depth/stencil format, this uses the access type VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT. For attachments with a color format, this uses the access type VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT.

• VK_ATTACHMENT_STORE_OP_DONT_CARE specifies the contents within the render area are not needed after rendering, and may be discarded; the contents of the attachment will be undefined inside the render area. For attachments with a depth/stencil format, this uses the access type VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT. For attachments with a color format, this uses the access type VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT.

 Note VK_ATTACHMENT_STORE_OP_DONT_CARE can cause contents generated during previous render passes to be discarded before reaching memory, even if no write to the attachment occurs during the current render pass.

To specify which aspects of an input attachment can be read, add a VkRenderPassInputAttachmentAspectCreateInfo structure to the pNext chain of the VkRenderPassCreateInfo structure:

The VkRenderPassInputAttachmentAspectCreateInfo structure is defined as:

// Provided by VK_VERSION_1_1
typedef struct VkRenderPassInputAttachmentAspectCreateInfo {
VkStructureType                            sType;
const void*                                pNext;
uint32_t                                   aspectReferenceCount;
const VkInputAttachmentAspectReference*    pAspectReferences;
} VkRenderPassInputAttachmentAspectCreateInfo;
• sType is the type of this structure.

• pNext is NULL or a pointer to a structure extending this structure.

• aspectReferenceCount is the number of elements in the pAspectReferences array.

• pAspectReferences is a pointer to an array of aspectReferenceCount VkInputAttachmentAspectReference structures containing a mask describing which aspect(s) can be accessed for a given input attachment within a given subpass.

An application can access any aspect of an input attachment that does not have a specified aspect mask in the pAspectReferences array. Otherwise, an application must not access aspect(s) of an input attachment other than those in its specified aspect mask.

Valid Usage (Implicit)
• VUID-VkRenderPassInputAttachmentAspectCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO

• VUID-VkRenderPassInputAttachmentAspectCreateInfo-pAspectReferences-parameter
pAspectReferences must be a valid pointer to an array of aspectReferenceCount valid VkInputAttachmentAspectReference structures

• VUID-VkRenderPassInputAttachmentAspectCreateInfo-aspectReferenceCount-arraylength
aspectReferenceCount must be greater than 0

The VkInputAttachmentAspectReference structure specifies an aspect mask for a specific input attachment of a specific subpass in the render pass.

subpass and inputAttachmentIndex index into the render pass as:

pCreateInfo->pSubpasses[subpass].pInputAttachments[inputAttachmentIndex]

// Provided by VK_VERSION_1_1
typedef struct VkInputAttachmentAspectReference {
uint32_t              subpass;
uint32_t              inputAttachmentIndex;
} VkInputAttachmentAspectReference;
• subpass is an index into the pSubpasses array of the parent VkRenderPassCreateInfo structure.

• inputAttachmentIndex is an index into the pInputAttachments of the specified subpass.

• aspectMask is a mask of which aspect(s) can be accessed within the specified subpass.

Valid Usage
aspectMask must not include VK_IMAGE_ASPECT_METADATA_BIT

Valid Usage (Implicit)
aspectMask must be a valid combination of VkImageAspectFlagBits values

aspectMask must not be 0

The VkSubpassDescription structure is defined as:

// Provided by VK_VERSION_1_0
typedef struct VkSubpassDescription {
VkSubpassDescriptionFlags       flags;
VkPipelineBindPoint             pipelineBindPoint;
uint32_t                        inputAttachmentCount;
const VkAttachmentReference*    pInputAttachments;
uint32_t                        colorAttachmentCount;
const VkAttachmentReference*    pColorAttachments;
const VkAttachmentReference*    pResolveAttachments;
const VkAttachmentReference*    pDepthStencilAttachment;
uint32_t                        preserveAttachmentCount;
const uint32_t*                 pPreserveAttachments;
} VkSubpassDescription;
• flags is a bitmask of VkSubpassDescriptionFlagBits specifying usage of the subpass.

• pipelineBindPoint is a VkPipelineBindPoint value specifying the pipeline type supported for this subpass.

• inputAttachmentCount is the number of input attachments.

• pInputAttachments is a pointer to an array of VkAttachmentReference structures defining the input attachments for this subpass and their layouts.

• colorAttachmentCount is the number of color attachments.

• pColorAttachments is a pointer to an array of VkAttachmentReference structures defining the color attachments for this subpass and their layouts.

• pResolveAttachments is an optional array of colorAttachmentCount VkAttachmentReference structures defining the resolve attachments for this subpass and their layouts.

• pDepthStencilAttachment is a pointer to a VkAttachmentReference structure specifying the depth/stencil attachment for this subpass and its layout.

• preserveAttachmentCount is the number of preserved attachments.

• pPreserveAttachments is a pointer to an array of preserveAttachmentCount render pass attachment indices identifying attachments that are not used by this subpass, but whose contents must be preserved throughout the subpass.

Each element of the pInputAttachments array corresponds to an input attachment index in a fragment shader, i.e. if a shader declares an image variable decorated with a InputAttachmentIndex value of X, then it uses the attachment provided in pInputAttachments[X]. Input attachments must also be bound to the pipeline in a descriptor set. If the attachment member of any element of pInputAttachments is VK_ATTACHMENT_UNUSED, the application must not read from the corresponding input attachment index. Fragment shaders can use subpass input variables to access the contents of an input attachment at the fragment’s (x, y, layer) framebuffer coordinates.

Each element of the pColorAttachments array corresponds to an output location in the shader, i.e. if the shader declares an output variable decorated with a Location value of X, then it uses the attachment provided in pColorAttachments[X]. If the attachment member of any element of pColorAttachments is VK_ATTACHMENT_UNUSED, then writes to the corresponding location by a fragment are discarded.

If pResolveAttachments is not NULL, each of its elements corresponds to a color attachment (the element in pColorAttachments at the same index), and a multisample resolve operation is defined for each attachment. At the end of each subpass, multisample resolve operations read the subpass’s color attachments, and resolve the samples for each pixel within the render area to the same pixel location in the corresponding resolve attachments, unless the resolve attachment index is VK_ATTACHMENT_UNUSED.

Similarly, if VkSubpassDescriptionDepthStencilResolve::pDepthStencilResolveAttachment is not NULL and does not have the value VK_ATTACHMENT_UNUSED, it corresponds to the depth/stencil attachment in pDepthStencilAttachment, and multisample resolve operations for depth and stencil are defined by VkSubpassDescriptionDepthStencilResolve::depthResolveMode and VkSubpassDescriptionDepthStencilResolve::stencilResolveMode, respectively. At the end of each subpass, multisample resolve operations read the subpass’s depth/stencil attachment, and resolve the samples for each pixel to the same pixel location in the corresponding resolve attachment. If VkSubpassDescriptionDepthStencilResolve::depthResolveMode is VK_RESOLVE_MODE_NONE, then the depth component of the resolve attachment is not written to and its contents are preserved. Similarly, if VkSubpassDescriptionDepthStencilResolve::stencilResolveMode is VK_RESOLVE_MODE_NONE, then the stencil component of the resolve attachment is not written to and its contents are preserved. VkSubpassDescriptionDepthStencilResolve::depthResolveMode is ignored if the VkFormat of the pDepthStencilResolveAttachment does not have a depth component. Similarly, VkSubpassDescriptionDepthStencilResolve::stencilResolveMode is ignored if the VkFormat of the pDepthStencilResolveAttachment does not have a stencil component.

If pDepthStencilAttachment is NULL, or if its attachment index is VK_ATTACHMENT_UNUSED, it indicates that no depth/stencil attachment will be used in the subpass.

The contents of an attachment within the render area become undefined at the start of a subpass S if all of the following conditions are true:

• The attachment is used as a color, depth/stencil, or resolve attachment in any subpass in the render pass.

• There is a subpass S1 that uses or preserves the attachment, and a subpass dependency from S1 to S.

• The attachment is not used or preserved in subpass S.

Once the contents of an attachment become undefined in subpass S, they remain undefined for subpasses in subpass dependency chains starting with subpass S until they are written again. However, they remain valid for subpasses in other subpass dependency chains starting with subpass S1 if those subpasses use or preserve the attachment.

Valid Usage
• VUID-VkSubpassDescription-pipelineBindPoint-00844
pipelineBindPoint must be VK_PIPELINE_BIND_POINT_GRAPHICS

• VUID-VkSubpassDescription-colorAttachmentCount-00845
colorAttachmentCount must be less than or equal to VkPhysicalDeviceLimits::maxColorAttachments

If the first use of an attachment in this render pass is as an input attachment, and the attachment is not also used as a color or depth/stencil attachment in the same subpass, then loadOp must not be VK_ATTACHMENT_LOAD_OP_CLEAR

• VUID-VkSubpassDescription-pResolveAttachments-00847
If pResolveAttachments is not NULL, for each resolve attachment that is not VK_ATTACHMENT_UNUSED, the corresponding color attachment must not be VK_ATTACHMENT_UNUSED

• VUID-VkSubpassDescription-pResolveAttachments-00848
If pResolveAttachments is not NULL, for each resolve attachment that is not VK_ATTACHMENT_UNUSED, the corresponding color attachment must not have a sample count of VK_SAMPLE_COUNT_1_BIT

• VUID-VkSubpassDescription-pResolveAttachments-00849
If pResolveAttachments is not NULL, each resolve attachment that is not VK_ATTACHMENT_UNUSED must have a sample count of VK_SAMPLE_COUNT_1_BIT

• VUID-VkSubpassDescription-pResolveAttachments-00850
If pResolveAttachments is not NULL, each resolve attachment that is not VK_ATTACHMENT_UNUSED must have the same VkFormat as its corresponding color attachment

• VUID-VkSubpassDescription-pColorAttachments-01417
All attachments in pColorAttachments that are not VK_ATTACHMENT_UNUSED must have the same sample count

• VUID-VkSubpassDescription-pInputAttachments-02647
All attachments in pInputAttachments that are not VK_ATTACHMENT_UNUSED must have image formats whose potential format features contain at least VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT or VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT

• VUID-VkSubpassDescription-pColorAttachments-02648
All attachments in pColorAttachments that are not VK_ATTACHMENT_UNUSED must have image formats whose potential format features contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT

• VUID-VkSubpassDescription-pResolveAttachments-02649
All attachments in pResolveAttachments that are not VK_ATTACHMENT_UNUSED must have image formats whose potential format features contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT

• VUID-VkSubpassDescription-pDepthStencilAttachment-02650
If pDepthStencilAttachment is not NULL and the attachment is not VK_ATTACHMENT_UNUSED then it must have an image format whose potential format features contain VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT

• VUID-VkSubpassDescription-pDepthStencilAttachment-01418
If neither the [VK_AMD_mixed_attachment_samples] nor the [VK_NV_framebuffer_mixed_samples] extensions are enabled, and if pDepthStencilAttachment is not VK_ATTACHMENT_UNUSED and any attachments in pColorAttachments are not VK_ATTACHMENT_UNUSED, they must have the same sample count

• VUID-VkSubpassDescription-attachment-00853
The attachment member of each element of pPreserveAttachments must not be VK_ATTACHMENT_UNUSED

• VUID-VkSubpassDescription-pPreserveAttachments-00854
Each element of pPreserveAttachments must not also be an element of any other member of the subpass description

• VUID-VkSubpassDescription-layout-02519
If any attachment is used by more than one VkAttachmentReference member, then each use must use the same layout

• VUID-VkSubpassDescription-None-04437
Each attachment must follow the image layout requirements specified for its attachment type

• VUID-VkSubpassDescription-pDepthStencilAttachment-04438
pDepthStencilAttachment and pColorAttachments must not contain references to the same attachment

Valid Usage (Implicit)
flags must be 0

• VUID-VkSubpassDescription-pipelineBindPoint-parameter
pipelineBindPoint must be a valid VkPipelineBindPoint value

• VUID-VkSubpassDescription-pInputAttachments-parameter
If inputAttachmentCount is not 0, pInputAttachments must be a valid pointer to an array of inputAttachmentCount valid VkAttachmentReference structures

• VUID-VkSubpassDescription-pColorAttachments-parameter
If colorAttachmentCount is not 0, pColorAttachments must be a valid pointer to an array of colorAttachmentCount valid VkAttachmentReference structures

• VUID-VkSubpassDescription-pResolveAttachments-parameter
If colorAttachmentCount is not 0, and pResolveAttachments is not NULL, pResolveAttachments must be a valid pointer to an array of colorAttachmentCount valid VkAttachmentReference structures

• VUID-VkSubpassDescription-pDepthStencilAttachment-parameter
If pDepthStencilAttachment is not NULL, pDepthStencilAttachment must be a valid pointer to a valid VkAttachmentReference structure

• VUID-VkSubpassDescription-pPreserveAttachments-parameter
If preserveAttachmentCount is not 0, pPreserveAttachments must be a valid pointer to an array of preserveAttachmentCount uint32_t values

Bits which can be set in VkSubpassDescription::flags, specifying usage of the subpass, are:

// Provided by VK_VERSION_1_0
typedef enum VkSubpassDescriptionFlagBits {
} VkSubpassDescriptionFlagBits;
 Note All bits for this type are defined by extensions, and none of those extensions are enabled in this build of the specification.
// Provided by VK_VERSION_1_0
typedef VkFlags VkSubpassDescriptionFlags;

VkSubpassDescriptionFlags is a bitmask type for setting a mask of zero or more VkSubpassDescriptionFlagBits.

The VkAttachmentReference structure is defined as:

// Provided by VK_VERSION_1_0
typedef struct VkAttachmentReference {
uint32_t         attachment;
VkImageLayout    layout;
} VkAttachmentReference;
• attachment is either an integer value identifying an attachment at the corresponding index in VkRenderPassCreateInfo::pAttachments, or VK_ATTACHMENT_UNUSED to signify that this attachment is not used.

• layout is a VkImageLayout value specifying the layout the attachment uses during the subpass.

Valid Usage
• VUID-VkAttachmentReference-layout-00857
If attachment is not VK_ATTACHMENT_UNUSED, layout must not be VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_PREINITIALIZED, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL

Valid Usage (Implicit)
• VUID-VkAttachmentReference-layout-parameter
layout must be a valid VkImageLayout value

The VkSubpassDependency structure is defined as:

// Provided by VK_VERSION_1_0
typedef struct VkSubpassDependency {
uint32_t                srcSubpass;
uint32_t                dstSubpass;
VkDependencyFlags       dependencyFlags;
} VkSubpassDependency;

If srcSubpass is equal to dstSubpass then the VkSubpassDependency describes a subpass self-dependency, and only constrains the pipeline barriers allowed within a subpass instance. Otherwise, when a render pass instance which includes a subpass dependency is submitted to a queue, it defines a memory dependency between the subpasses identified by srcSubpass and dstSubpass.

If srcSubpass is equal to VK_SUBPASS_EXTERNAL, the first synchronization scope includes commands that occur earlier in submission order than the vkCmdBeginRenderPass used to begin the render pass instance. Otherwise, the first set of commands includes all commands submitted as part of the subpass instance identified by srcSubpass and any load, store or multisample resolve operations on attachments used in srcSubpass. In either case, the first synchronization scope is limited to operations on the pipeline stages determined by the source stage mask specified by srcStageMask.

If dstSubpass is equal to VK_SUBPASS_EXTERNAL, the second synchronization scope includes commands that occur later in submission order than the vkCmdEndRenderPass used to end the render pass instance. Otherwise, the second set of commands includes all commands submitted as part of the subpass instance identified by dstSubpass and any load, store or multisample resolve operations on attachments used in dstSubpass. In either case, the second synchronization scope is limited to operations on the pipeline stages determined by the destination stage mask specified by dstStageMask.

The first access scope is limited to access in the pipeline stages determined by the source stage mask specified by srcStageMask. It is also limited to access types in the source access mask specified by srcAccessMask.

The second access scope is limited to access in the pipeline stages determined by the destination stage mask specified by dstStageMask. It is also limited to access types in the destination access mask specified by dstAccessMask.

The availability and visibility operations defined by a subpass dependency affect the execution of image layout transitions within the render pass.

 Note For non-attachment resources, the memory dependency expressed by subpass dependency is nearly identical to that of a VkMemoryBarrier (with matching srcAccessMask and dstAccessMask parameters) submitted as a part of a vkCmdPipelineBarrier (with matching srcStageMask and dstStageMask parameters). The only difference being that its scopes are limited to the identified subpasses rather than potentially affecting everything before and after. For attachments however, subpass dependencies work more like a VkImageMemoryBarrier defined similarly to the VkMemoryBarrier above, the queue family indices set to VK_QUEUE_FAMILY_IGNORED, and layouts as follows: The equivalent to oldLayout is the attachment’s layout according to the subpass description for srcSubpass. The equivalent to newLayout is the attachment’s layout according to the subpass description for dstSubpass.
Valid Usage
If the geometry shaders feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT

If the geometry shaders feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT

If the tessellation shaders feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT

If the tessellation shaders feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT

• VUID-VkSubpassDependency-srcSubpass-00864
srcSubpass must be less than or equal to dstSubpass, unless one of them is VK_SUBPASS_EXTERNAL, to avoid cyclic dependencies and ensure a valid execution order

• VUID-VkSubpassDependency-srcSubpass-00865
srcSubpass and dstSubpass must not both be equal to VK_SUBPASS_EXTERNAL

• VUID-VkSubpassDependency-srcSubpass-00867
If srcSubpass is equal to dstSubpass and not all of the stages in srcStageMask and dstStageMask are framebuffer-space stages, the logically latest pipeline stage in srcStageMask must be logically earlier than or equal to the logically earliest pipeline stage in dstStageMask

Any access flag included in srcAccessMask must be supported by one of the pipeline stages in srcStageMask, as specified in the table of supported access types

Any access flag included in dstAccessMask must be supported by one of the pipeline stages in dstStageMask, as specified in the table of supported access types

• VUID-VkSubpassDependency-srcSubpass-02243
If srcSubpass equals dstSubpass, and srcStageMask and dstStageMask both include a framebuffer-space stage, then dependencyFlags must include VK_DEPENDENCY_BY_REGION_BIT

• VUID-VkSubpassDependency-dependencyFlags-02520
If dependencyFlags includes VK_DEPENDENCY_VIEW_LOCAL_BIT, srcSubpass must not be equal to VK_SUBPASS_EXTERNAL

• VUID-VkSubpassDependency-dependencyFlags-02521
If dependencyFlags includes VK_DEPENDENCY_VIEW_LOCAL_BIT, dstSubpass must not be equal to VK_SUBPASS_EXTERNAL

• VUID-VkSubpassDependency-srcSubpass-00872
If srcSubpass equals dstSubpass and that subpass has more than one bit set in the view mask, then dependencyFlags must include VK_DEPENDENCY_VIEW_LOCAL_BIT

Valid Usage (Implicit)
srcStageMask must be a valid combination of VkPipelineStageFlagBits values

dstStageMask must be a valid combination of VkPipelineStageFlagBits values

srcAccessMask must be a valid combination of VkAccessFlagBits values

dstAccessMask must be a valid combination of VkAccessFlagBits values

• VUID-VkSubpassDependency-dependencyFlags-parameter
dependencyFlags must be a valid combination of VkDependencyFlagBits values

When multiview is enabled, the execution of the multiple views of one subpass may not occur simultaneously or even back-to-back, and rather may be interleaved with the execution of other subpasses. The load and store operations apply to attachments on a per-view basis. For example, an attachment using VK_ATTACHMENT_LOAD_OP_CLEAR will have each view cleared on first use, but the first use of one view may be temporally distant from the first use of another view.

 Note A good mental model for multiview is to think of a multiview subpass as if it were a collection of individual (per-view) subpasses that are logically grouped together and described as a single multiview subpass in the API. Similarly, a multiview attachment can be thought of like several individual attachments that happen to be layers in a single image. A view-local dependency between two multiview subpasses acts like a set of one-to-one dependencies between corresponding pairs of per-view subpasses. A view-global dependency between two multiview subpasses acts like a set of N × M dependencies between all pairs of per-view subpasses in the source and destination. Thus, it is a more compact representation which also makes clear the commonality and reuse that is present between views in a subpass. This interpretation motivates the answers to questions like “when does the load op apply” - it is on the first use of each view of an attachment, as if each view were a separate attachment.

If there is no subpass dependency from VK_SUBPASS_EXTERNAL to the first subpass that uses an attachment, then an implicit subpass dependency exists from VK_SUBPASS_EXTERNAL to the first subpass it is used in. The implicit subpass dependency only exists if there exists an automatic layout transition away from initialLayout. The subpass dependency operates as if defined with the following parameters:

VkSubpassDependency implicitDependency = {
.srcSubpass = VK_SUBPASS_EXTERNAL;
.dstSubpass = firstSubpass; // First subpass attachment is used in
VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
.dependencyFlags = 0;
};

Similarly, if there is no subpass dependency from the last subpass that uses an attachment to VK_SUBPASS_EXTERNAL, then an implicit subpass dependency exists from the last subpass it is used in to VK_SUBPASS_EXTERNAL. The implicit subpass dependency only exists if there exists an automatic layout transition into finalLayout. The subpass dependency operates as if defined with the following parameters:

VkSubpassDependency implicitDependency = {
.srcSubpass = lastSubpass; // Last subpass attachment is used in
.dstSubpass = VK_SUBPASS_EXTERNAL;
VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
.dependencyFlags = 0;
};

As subpasses may overlap or execute out of order with regards to other subpasses unless a subpass dependency chain describes otherwise, the layout transitions required between subpasses cannot be known to an application. Instead, an application provides the layout that each attachment must be in at the start and end of a render pass, and the layout it must be in during each subpass it is used in. The implementation then must execute layout transitions between subpasses in order to guarantee that the images are in the layouts required by each subpass, and in the final layout at the end of the render pass.

Automatic layout transitions apply to the entire image subresource attached to the framebuffer. If the attachment view is a 2D or 2D array view of a 3D image, even if the attachment view only refers to a subset of the slices of the selected mip level of the 3D image, automatic layout transitions apply to the entire subresource referenced which is the entire mip level in this case.

Automatic layout transitions away from the layout used in a subpass happen-after the availability operations for all dependencies with that subpass as the srcSubpass.

Automatic layout transitions into the layout used in a subpass happen-before the visibility operations for all dependencies with that subpass as the dstSubpass.

Automatic layout transitions away from initialLayout happens-after the availability operations for all dependencies with a srcSubpass equal to VK_SUBPASS_EXTERNAL, where dstSubpass uses the attachment that will be transitioned. For attachments created with VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT, automatic layout transitions away from initialLayout happen-after the availability operations for all dependencies with a srcSubpass equal to VK_SUBPASS_EXTERNAL, where dstSubpass uses any aliased attachment.

Automatic layout transitions into finalLayout happens-before the visibility operations for all dependencies with a dstSubpass equal to VK_SUBPASS_EXTERNAL, where srcSubpass uses the attachment that will be transitioned. For attachments created with VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT, automatic layout transitions into finalLayout happen-before the visibility operations for all dependencies with a dstSubpass equal to VK_SUBPASS_EXTERNAL, where srcSubpass uses any aliased attachment.

If two subpasses use the same attachment, and both subpasses use the attachment in a read-only layout, no subpass dependency needs to be specified between those subpasses. If an implementation treats those layouts separately, it must insert an implicit subpass dependency between those subpasses to separate the uses in each layout. The subpass dependency operates as if defined with the following parameters:

// Used for input attachments

// Used for depth/stencil attachments
VkPipelineStageFlags depthStencilAttachmentStages = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;

VkSubpassDependency implicitDependency = {
.srcSubpass = firstSubpass;
.dstSubpass = secondSubpass;
.dependencyFlags = 0;
};

If a subpass uses the same attachment as both an input attachment and either a color attachment or a depth/stencil attachment, writes via the color or depth/stencil attachment are not automatically made visible to reads via the input attachment, causing a feedback loop, except in any of the following conditions:

• If the color components or depth/stencil components read by the input attachment are mutually exclusive with the components written by the color or depth/stencil attachments, then there is no feedback loop. This requires the graphics pipelines used by the subpass to disable writes to color components that are read as inputs via the colorWriteMask, and to disable writes to depth/stencil components that are read as inputs via depthWriteEnable or stencilTestEnable.

• If the attachment is used as an input attachment and depth/stencil attachment only, and the depth/stencil attachment is not written to.

Rendering within a subpass that contains a feedback loop creates a data race, except in the following cases:

• If a memory dependency is inserted between when the attachment is written and when it is subsequently read by later fragments. Pipeline barriers expressing a subpass self-dependency are the only way to achieve this, and one must be inserted every time a fragment will read values at a particular sample (x, y, layer, sample) coordinate, if those values have been written since the most recent pipeline barrier; or the since start of the subpass if there have been no pipeline barriers since the start of the subpass.

Attachments have requirements for a valid image layout depending on the usage

• An attachment used as an input attachment must be in the VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, or VK_IMAGE_LAYOUT_GENERAL layout.

• An attachment used only as a color attachment must be in the VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL layout.

• An attachment used as both an input attachment and a color attachment must be in the VK_IMAGE_LAYOUT_GENERAL layout.

• An attachment used only as a depth/stencil attachment must be in the VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, or VK_IMAGE_LAYOUT_GENERAL layout.

• An attachment used as an input attachment and depth/stencil attachment must be in the VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, or VK_IMAGE_LAYOUT_GENERAL layout.

An attachment must not be used as both a depth/stencil attachment and a color attachment.

A more extensible version of render pass creation is also defined below.

To create a render pass, call:

// Provided by VK_VERSION_1_2
VkResult vkCreateRenderPass2(
VkDevice                                    device,
const VkRenderPassCreateInfo2*              pCreateInfo,
const VkAllocationCallbacks*                pAllocator,
VkRenderPass*                               pRenderPass);
• device is the logical device that creates the render pass.

• pCreateInfo is a pointer to a VkRenderPassCreateInfo2 structure describing the parameters of the render pass.

• pAllocator controls host memory allocation as described in the Memory Allocation chapter.

• pRenderPass is a pointer to a VkRenderPass handle in which the resulting render pass object is returned.

This command is functionally identical to vkCreateRenderPass, but includes extensible sub-structures that include sType and pNext parameters, allowing them to be more easily extended.

Valid Usage (Implicit)
• VUID-vkCreateRenderPass2-device-parameter
device must be a valid VkDevice handle

• VUID-vkCreateRenderPass2-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkRenderPassCreateInfo2 structure

• VUID-vkCreateRenderPass2-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure

• VUID-vkCreateRenderPass2-pRenderPass-parameter
pRenderPass must be a valid pointer to a VkRenderPass handle

Return Codes
Success
• VK_SUCCESS

Failure
• VK_ERROR_OUT_OF_HOST_MEMORY

• VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkRenderPassCreateInfo2 structure is defined as:

// Provided by VK_VERSION_1_2
typedef struct VkRenderPassCreateInfo2 {
VkStructureType                    sType;
const void*                        pNext;
VkRenderPassCreateFlags            flags;
uint32_t                           attachmentCount;
const VkAttachmentDescription2*    pAttachments;
uint32_t                           subpassCount;
const VkSubpassDescription2*       pSubpasses;
uint32_t                           dependencyCount;
const VkSubpassDependency2*        pDependencies;
} VkRenderPassCreateInfo2;
• sType is the type of this structure.

• pNext is NULL or a pointer to a structure extending this structure.

• flags is reserved for future use.

• attachmentCount is the number of attachments used by this render pass.

• pAttachments is a pointer to an array of attachmentCount VkAttachmentDescription2 structures describing the attachments used by the render pass.

• subpassCount is the number of subpasses to create.

• pSubpasses is a pointer to an array of subpassCount VkSubpassDescription2 structures describing each subpass.

• dependencyCount is the number of dependencies between pairs of subpasses.

• pDependencies is a pointer to an array of dependencyCount VkSubpassDependency2 structures describing dependencies between pairs of subpasses.

• correlatedViewMaskCount is the number of correlation masks.

• pCorrelatedViewMasks is a pointer to an array of view masks indicating sets of views that may be more efficient to render concurrently.

Parameters defined by this structure with the same name as those in VkRenderPassCreateInfo have the identical effect to those parameters; the child structures are variants of those used in VkRenderPassCreateInfo which add sType and pNext parameters, allowing them to be extended.

If the VkSubpassDescription2::viewMask member of any element of pSubpasses is not zero, multiview functionality is considered to be enabled for this render pass.

correlatedViewMaskCount and pCorrelatedViewMasks have the same effect as VkRenderPassMultiviewCreateInfo::correlationMaskCount and VkRenderPassMultiviewCreateInfo::pCorrelationMasks, respectively.

Valid Usage
• VUID-VkRenderPassCreateInfo2-None-03049
If any two subpasses operate on attachments with overlapping ranges of the same VkDeviceMemory object, and at least one subpass writes to that area of VkDeviceMemory, a subpass dependency must be included (either directly or via some intermediate subpasses) between them

• VUID-VkRenderPassCreateInfo2-attachment-03050
If the attachment member of any element of pInputAttachments, pColorAttachments, pResolveAttachments or pDepthStencilAttachment, or the attachment indexed by any element of pPreserveAttachments in any given element of pSubpasses is bound to a range of a VkDeviceMemory object that overlaps with any other attachment in any subpass (including the same subpass), the VkAttachmentDescription2 structures describing them must include VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT in flags

• VUID-VkRenderPassCreateInfo2-attachment-03051
If the attachment member of any element of pInputAttachments, pColorAttachments, pResolveAttachments or pDepthStencilAttachment, or any element of pPreserveAttachments in any given element of pSubpasses is not VK_ATTACHMENT_UNUSED, it must be less than attachmentCount

• VUID-VkRenderPassCreateInfo2-pAttachments-02522
For any member of pAttachments with a loadOp equal to VK_ATTACHMENT_LOAD_OP_CLEAR, the first use of that attachment must not specify a layout equal to VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL

• VUID-VkRenderPassCreateInfo2-pAttachments-02523
For any member of pAttachments with a stencilLoadOp equal to VK_ATTACHMENT_LOAD_OP_CLEAR, the first use of that attachment must not specify a layout equal to VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL

• VUID-VkRenderPassCreateInfo2-pDependencies-03054
For any element of pDependencies, if the srcSubpass is not VK_SUBPASS_EXTERNAL, all stage flags included in the srcStageMask member of that dependency must be a pipeline stage supported by the pipeline identified by the pipelineBindPoint member of the source subpass

• VUID-VkRenderPassCreateInfo2-pDependencies-03055
For any element of pDependencies, if the dstSubpass is not VK_SUBPASS_EXTERNAL, all stage flags included in the dstStageMask member of that dependency must be a pipeline stage supported by the pipeline identified by the pipelineBindPoint member of the destination subpass

The set of bits included in any element of pCorrelatedViewMasks must not overlap with the set of bits included in any other element of pCorrelatedViewMasks

If the VkSubpassDescription2::viewMask member of all elements of pSubpasses is 0, correlatedViewMaskCount must be 0

The VkSubpassDescription2::viewMask member of all elements of pSubpasses must either all be 0, or all not be 0

If the VkSubpassDescription2::viewMask member of all elements of pSubpasses is 0, the dependencyFlags member of any element of pDependencies must not include VK_DEPENDENCY_VIEW_LOCAL_BIT

• VUID-VkRenderPassCreateInfo2-pDependencies-03060
For any element of pDependencies where its srcSubpass member equals its dstSubpass member, if the viewMask member of the corresponding element of pSubpasses includes more than one bit, its dependencyFlags member must include VK_DEPENDENCY_VIEW_LOCAL_BIT

• VUID-VkRenderPassCreateInfo2-attachment-02525
If the attachment member of any element of the pInputAttachments member of any element of pSubpasses is not VK_ATTACHMENT_UNUSED, the aspectMask member of that element of pInputAttachments must only include aspects that are present in images of the format specified by the element of pAttachments specified by attachment

• VUID-VkRenderPassCreateInfo2-srcSubpass-02526
The srcSubpass member of each element of pDependencies must be less than subpassCount

• VUID-VkRenderPassCreateInfo2-dstSubpass-02527
The dstSubpass member of each element of pDependencies must be less than subpassCount

Valid Usage (Implicit)
• VUID-VkRenderPassCreateInfo2-sType-sType
sType must be VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2

• VUID-VkRenderPassCreateInfo2-pNext-pNext
pNext must be NULL

flags must be 0

• VUID-VkRenderPassCreateInfo2-pAttachments-parameter
If attachmentCount is not 0, pAttachments must be a valid pointer to an array of attachmentCount valid VkAttachmentDescription2 structures

• VUID-VkRenderPassCreateInfo2-pSubpasses-parameter
pSubpasses must be a valid pointer to an array of subpassCount valid VkSubpassDescription2 structures

• VUID-VkRenderPassCreateInfo2-pDependencies-parameter
If dependencyCount is not 0, pDependencies must be a valid pointer to an array of dependencyCount valid VkSubpassDependency2 structures

If correlatedViewMaskCount is not 0, pCorrelatedViewMasks must be a valid pointer to an array of correlatedViewMaskCount uint32_t values

• VUID-VkRenderPassCreateInfo2-subpassCount-arraylength
subpassCount must be greater than 0

The VkAttachmentDescription2 structure is defined as:

// Provided by VK_VERSION_1_2
typedef struct VkAttachmentDescription2 {
VkStructureType                 sType;
const void*                     pNext;
VkAttachmentDescriptionFlags    flags;
VkFormat                        format;
VkSampleCountFlagBits           samples;
VkAttachmentStoreOp             storeOp;
VkAttachmentStoreOp             stencilStoreOp;
VkImageLayout                   initialLayout;
VkImageLayout                   finalLayout;
} VkAttachmentDescription2;
• sType is the type of this structure.

• pNext is NULL or a pointer to a structure extending this structure.

• flags is a bitmask of VkAttachmentDescriptionFlagBits specifying additional properties of the attachment.

• format is a VkFormat value specifying the format of the image that will be used for the attachment.

• samples is the number of samples of the image as defined in VkSampleCountFlagBits.

• loadOp is a VkAttachmentLoadOp value specifying how the contents of color and depth components of the attachment are treated at the beginning of the subpass where it is first used.

• storeOp is a VkAttachmentStoreOp value specifying how the contents of color and depth components of the attachment are treated at the end of the subpass where it is last used.

• stencilLoadOp is a VkAttachmentLoadOp value specifying how the contents of stencil components of the attachment are treated at the beginning of the subpass where it is first used.

• stencilStoreOp is a VkAttachmentStoreOp value specifying how the contents of stencil components of the attachment are treated at the end of the last subpass where it is used.

• initialLayout is the layout the attachment image subresource will be in when a render pass instance begins.

• finalLayout is the layout the attachment image subresource will be transitioned to when a render pass instance ends.

Parameters defined by this structure with the same name as those in VkAttachmentDescription have the identical effect to those parameters.

If the separateDepthStencilLayouts feature is enabled, and format is a depth/stencil format, initialLayout and finalLayout can be set to a layout that only specifies the layout of the depth aspect.

If the pNext chain includes a VkAttachmentDescriptionStencilLayout structure, then the stencilInitialLayout and stencilFinalLayout members specify the initial and final layouts of the stencil aspect of a depth/stencil format, and initialLayout and finalLayout only apply to the depth aspect. For depth-only formats, the VkAttachmentDescriptionStencilLayout structure is ignored. For stencil-only formats, the initial and final layouts of the stencil aspect are taken from the VkAttachmentDescriptionStencilLayout structure if present, or initialLayout and finalLayout if not present.

If format is a depth/stencil format, and either initialLayout or finalLayout does not specify a layout for the stencil aspect, then the application must specify the initial and final layouts of the stencil aspect by including a VkAttachmentDescriptionStencilLayout structure in the pNext chain.

Valid Usage
• VUID-VkAttachmentDescription2-finalLayout-03061
finalLayout must not be VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED

• VUID-VkAttachmentDescription2-format-03294
If format is a color format, initialLayout must not be VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL

• VUID-VkAttachmentDescription2-format-03295
If format is a depth/stencil format, initialLayout must not be VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL

• VUID-VkAttachmentDescription2-format-03296
If format is a color format, finalLayout must not be VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL

• VUID-VkAttachmentDescription2-format-03297
If format is a depth/stencil format, finalLayout must not be VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL

• VUID-VkAttachmentDescription2-separateDepthStencilLayouts-03298
If the separateDepthStencilLayouts feature is not enabled, initialLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL

• VUID-VkAttachmentDescription2-separateDepthStencilLayouts-03299
If the separateDepthStencilLayouts feature is not enabled, finalLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL

• VUID-VkAttachmentDescription2-format-03300
If format is a color format, initialLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL

• VUID-VkAttachmentDescription2-format-03301
If format is a color format, finalLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL

• VUID-VkAttachmentDescription2-format-03302
If format is a depth/stencil format which includes both depth and stencil aspects, and initialLayout is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, the pNext chain must include a VkAttachmentDescriptionStencilLayout structure

• VUID-VkAttachmentDescription2-format-03303
If format is a depth/stencil format which includes both depth and stencil aspects, and finalLayout is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, the pNext chain must include a VkAttachmentDescriptionStencilLayout structure

• VUID-VkAttachmentDescription2-format-03304
If format is a depth/stencil format which includes only the depth aspect, initialLayout must not be VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL

• VUID-VkAttachmentDescription2-format-03305
If format is a depth/stencil format which includes only the depth aspect, finalLayout must not be VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL

• VUID-VkAttachmentDescription2-format-03306
If format is a depth/stencil format which includes only the stencil aspect, initialLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL

• VUID-VkAttachmentDescription2-format-03307
If format is a depth/stencil format which includes only the stencil aspect, finalLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL

Valid Usage (Implicit)
• VUID-VkAttachmentDescription2-sType-sType
sType must be VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2

• VUID-VkAttachmentDescription2-pNext-pNext
pNext must be NULL or a pointer to a valid instance of VkAttachmentDescriptionStencilLayout

• VUID-VkAttachmentDescription2-sType-unique
The sType value of each struct in the pNext chain must be unique

• VUID-VkAttachmentDescription2-flags-parameter
flags must be a valid combination of VkAttachmentDescriptionFlagBits values

• VUID-VkAttachmentDescription2-format-parameter
format must be a valid VkFormat value

• VUID-VkAttachmentDescription2-samples-parameter
samples must be a valid VkSampleCountFlagBits value

loadOp must be a valid VkAttachmentLoadOp value

• VUID-VkAttachmentDescription2-storeOp-parameter
storeOp must be a valid VkAttachmentStoreOp value

stencilLoadOp must be a valid VkAttachmentLoadOp value

• VUID-VkAttachmentDescription2-stencilStoreOp-parameter
stencilStoreOp must be a valid VkAttachmentStoreOp value

• VUID-VkAttachmentDescription2-initialLayout-parameter
initialLayout must be a valid VkImageLayout value

• VUID-VkAttachmentDescription2-finalLayout-parameter
finalLayout must be a valid VkImageLayout value

The VkAttachmentDescriptionStencilLayout structure is defined as:

// Provided by VK_VERSION_1_2
typedef struct VkAttachmentDescriptionStencilLayout {
VkStructureType    sType;
void*              pNext;
VkImageLayout      stencilInitialLayout;
VkImageLayout      stencilFinalLayout;
} VkAttachmentDescriptionStencilLayout;
• sType is the type of this structure.

• pNext is NULL or a pointer to a structure extending this structure.

• stencilInitialLayout is the layout the stencil aspect of the attachment image subresource will be in when a render pass instance begins.

• stencilFinalLayout is the layout the stencil aspect of the attachment image subresource will be transitioned to when a render pass instance ends.

Valid Usage
• VUID-VkAttachmentDescriptionStencilLayout-stencilInitialLayout-03308
stencilInitialLayout must not be VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL

• VUID-VkAttachmentDescriptionStencilLayout-stencilFinalLayout-03309
stencilFinalLayout must not be VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL

• VUID-VkAttachmentDescriptionStencilLayout-stencilFinalLayout-03310
stencilFinalLayout must not be VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED

Valid Usage (Implicit)
• VUID-VkAttachmentDescriptionStencilLayout-sType-sType
sType must be VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT

• VUID-VkAttachmentDescriptionStencilLayout-stencilInitialLayout-parameter
stencilInitialLayout must be a valid VkImageLayout value

• VUID-VkAttachmentDescriptionStencilLayout-stencilFinalLayout-parameter
stencilFinalLayout must be a valid VkImageLayout value

The VkSubpassDescription2 structure is defined as:

// Provided by VK_VERSION_1_2
typedef struct VkSubpassDescription2 {
VkStructureType                  sType;
const void*                      pNext;
VkSubpassDescriptionFlags        flags;
VkPipelineBindPoint              pipelineBindPoint;
uint32_t                         inputAttachmentCount;
const VkAttachmentReference2*    pInputAttachments;
uint32_t                         colorAttachmentCount;
const VkAttachmentReference2*    pColorAttachments;
const VkAttachmentReference2*    pResolveAttachments;
const VkAttachmentReference2*    pDepthStencilAttachment;
uint32_t                         preserveAttachmentCount;
const uint32_t*                  pPreserveAttachments;
} VkSubpassDescription2;
• sType is the type of this structure.

• pNext is NULL or a pointer to a structure extending this structure.

• flags is a bitmask of VkSubpassDescriptionFlagBits specifying usage of the subpass.

• pipelineBindPoint is a VkPipelineBindPoint value specifying the pipeline type supported for this subpass.

• viewMask is a bitfield of view indices describing which views rendering is broadcast to in this subpass, when multiview is enabled.

• inputAttachmentCount is the number of input attachments.

• pInputAttachments is a pointer to an array of VkAttachmentReference2 structures defining the input attachments for this subpass and their layouts.

• colorAttachmentCount is the number of color attachments.

• pColorAttachments is a pointer to an array of VkAttachmentReference2 structures defining the color attachments for this subpass and their layouts.

• pResolveAttachments is an optional array of colorAttachmentCount VkAttachmentReference2 structures defining the resolve attachments for this subpass and their layouts.

• pDepthStencilAttachment is a pointer to a VkAttachmentReference2 structure specifying the depth/stencil attachment for this subpass and its layout.

• preserveAttachmentCount is the number of preserved attachments.

• pPreserveAttachments is a pointer to an array of preserveAttachmentCount render pass attachment indices identifying attachments that are not used by this subpass, but whose contents must be preserved throughout the subpass.

Parameters defined by this structure with the same name as those in VkSubpassDescription have the identical effect to those parameters.

viewMask has the same effect for the described subpass as VkRenderPassMultiviewCreateInfo::pViewMasks has on each corresponding subpass.

Valid Usage
• VUID-VkSubpassDescription2-pipelineBindPoint-03062
pipelineBindPoint must be VK_PIPELINE_BIND_POINT_GRAPHICS

• VUID-VkSubpassDescription2-colorAttachmentCount-03063
colorAttachmentCount must be less than or equal to VkPhysicalDeviceLimits::maxColorAttachments

If the first use of an attachment in this render pass is as an input attachment, and the attachment is not also used as a color or depth/stencil attachment in the same subpass, then loadOp must not be VK_ATTACHMENT_LOAD_OP_CLEAR

• VUID-VkSubpassDescription2-pResolveAttachments-03065
If pResolveAttachments is not NULL, for each resolve attachment that does not have the value VK_ATTACHMENT_UNUSED, the corresponding color attachment must not have the value VK_ATTACHMENT_UNUSED

• VUID-VkSubpassDescription2-pResolveAttachments-03066
If pResolveAttachments is not NULL, for each resolve attachment that is not VK_ATTACHMENT_UNUSED, the corresponding color attachment must not have a sample count of VK_SAMPLE_COUNT_1_BIT

• VUID-VkSubpassDescription2-pResolveAttachments-03067
If pResolveAttachments is not NULL, each resolve attachment that is not VK_ATTACHMENT_UNUSED must have a sample count of VK_SAMPLE_COUNT_1_BIT

• VUID-VkSubpassDescription2-pResolveAttachments-03068
Any given element of pResolveAttachments must have the same VkFormat as its corresponding color attachment

• VUID-VkSubpassDescription2-pColorAttachments-03069
All attachments in pColorAttachments that are not VK_ATTACHMENT_UNUSED must have the same sample count

• VUID-VkSubpassDescription2-pInputAttachments-02897
All attachments in pInputAttachments that are not VK_ATTACHMENT_UNUSED must have image formats whose potential format features contain at least VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT or VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT

• VUID-VkSubpassDescription2-pColorAttachments-02898
All attachments in pColorAttachments that are not VK_ATTACHMENT_UNUSED must have image formats whose potential format features contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT

• VUID-VkSubpassDescription2-pResolveAttachments-02899
All attachments in pResolveAttachments that are not VK_ATTACHMENT_UNUSED must have image formats whose potential format features contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT

• VUID-VkSubpassDescription2-pDepthStencilAttachment-02900
If pDepthStencilAttachment is not NULL and the attachment is not VK_ATTACHMENT_UNUSED then it must have an image format whose potential format features contain VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT

• VUID-VkSubpassDescription2-pDepthStencilAttachment-03071
If neither the [VK_AMD_mixed_attachment_samples] nor the [VK_NV_framebuffer_mixed_samples] extensions are enabled, and if pDepthStencilAttachment is not VK_ATTACHMENT_UNUSED and any attachments in pColorAttachments are not VK_ATTACHMENT_UNUSED, they must have the same sample count

• VUID-VkSubpassDescription2-attachment-03073
The attachment member of any element of pPreserveAttachments must not be VK_ATTACHMENT_UNUSED

• VUID-VkSubpassDescription2-pPreserveAttachments-03074
Any given element of pPreserveAttachments must not also be an element of any other member of the subpass description

• VUID-VkSubpassDescription2-layout-02528
If any attachment is used by more than one VkAttachmentReference member, then each use must use the same layout

• VUID-VkSubpassDescription2-None-04439
Attachments must follow the image layout requirements based on the type of attachment it is being used as

• VUID-VkSubpassDescription2-attachment-02799
If the attachment member of any element of pInputAttachments is not VK_ATTACHMENT_UNUSED, then the aspectMask member must be a valid combination of VkImageAspectFlagBits

• VUID-VkSubpassDescription2-attachment-02800
If the attachment member of any element of pInputAttachments is not VK_ATTACHMENT_UNUSED, then the aspectMask member must not be 0

• VUID-VkSubpassDescription2-attachment-02801
If the attachment member of any element of pInputAttachments is not VK_ATTACHMENT_UNUSED, then the aspectMask member must not include VK_IMAGE_ASPECT_METADATA_BIT

• VUID-VkSubpassDescription2-pDepthStencilAttachment-04440
An attachment must not be used in both pDepthStencilAttachment and pColorAttachments

Valid Usage (Implicit)
• VUID-VkSubpassDescription2-sType-sType
sType must be VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2

• VUID-VkSubpassDescription2-pNext-pNext
pNext must be NULL or a pointer to a valid instance of VkSubpassDescriptionDepthStencilResolve

• VUID-VkSubpassDescription2-sType-unique
The sType value of each struct in the pNext chain must be unique

flags must be 0

• VUID-VkSubpassDescription2-pipelineBindPoint-parameter
pipelineBindPoint must be a valid VkPipelineBindPoint value

• VUID-VkSubpassDescription2-pInputAttachments-parameter
If inputAttachmentCount is not 0, pInputAttachments must be a valid pointer to an array of inputAttachmentCount valid VkAttachmentReference2 structures

• VUID-VkSubpassDescription2-pColorAttachments-parameter
If colorAttachmentCount is not 0, pColorAttachments must be a valid pointer to an array of colorAttachmentCount valid VkAttachmentReference2 structures

• VUID-VkSubpassDescription2-pResolveAttachments-parameter
If colorAttachmentCount is not 0, and pResolveAttachments is not NULL, pResolveAttachments must be a valid pointer to an array of colorAttachmentCount valid VkAttachmentReference2 structures

• VUID-VkSubpassDescription2-pDepthStencilAttachment-parameter
If pDepthStencilAttachment is not NULL, pDepthStencilAttachment must be a valid pointer to a valid VkAttachmentReference2 structure

• VUID-VkSubpassDescription2-pPreserveAttachments-parameter
If preserveAttachmentCount is not 0, pPreserveAttachments must be a valid pointer to an array of preserveAttachmentCount uint32_t values

If the pNext list of VkSubpassDescription2 includes a VkSubpassDescriptionDepthStencilResolve structure, then that structure describes multisample resolve operations for the depth/stencil attachment in a subpass.

The VkSubpassDescriptionDepthStencilResolve structure is defined as:

// Provided by VK_VERSION_1_2
typedef struct VkSubpassDescriptionDepthStencilResolve {
VkStructureType                  sType;
const void*                      pNext;
VkResolveModeFlagBits            depthResolveMode;
VkResolveModeFlagBits            stencilResolveMode;
const VkAttachmentReference2*    pDepthStencilResolveAttachment;
} VkSubpassDescriptionDepthStencilResolve;
• sType is the type of this structure.

• pNext is NULL or a pointer to a structure extending this structure.

• depthResolveMode is a bitmask of VkResolveModeFlagBits describing the depth resolve mode.

• stencilResolveMode is a bitmask of VkResolveModeFlagBits describing the stencil resolve mode.

• pDepthStencilResolveAttachment is an optional VkAttachmentReference structure defining the depth/stencil resolve attachment for this subpass and its layout.

Valid Usage
• VUID-VkSubpassDescriptionDepthStencilResolve-pDepthStencilResolveAttachment-03177
If pDepthStencilResolveAttachment is not NULL and does not have the value VK_ATTACHMENT_UNUSED, pDepthStencilAttachment must not have the value VK_ATTACHMENT_UNUSED

• VUID-VkSubpassDescriptionDepthStencilResolve-pDepthStencilResolveAttachment-03178
If pDepthStencilResolveAttachment is not NULL and does not have the value VK_ATTACHMENT_UNUSED, depthResolveMode and stencilResolveMode must not both be VK_RESOLVE_MODE_NONE

• VUID-VkSubpassDescriptionDepthStencilResolve-pDepthStencilResolveAttachment-03179
If pDepthStencilResolveAttachment is not NULL and does not have the value VK_ATTACHMENT_UNUSED, pDepthStencilAttachment must not have a sample count of VK_SAMPLE_COUNT_1_BIT

• VUID-VkSubpassDescriptionDepthStencilResolve-pDepthStencilResolveAttachment-03180
If pDepthStencilResolveAttachment is not NULL and does not have the value VK_ATTACHMENT_UNUSED, pDepthStencilResolveAttachment must have a sample count of VK_SAMPLE_COUNT_1_BIT

• VUID-VkSubpassDescriptionDepthStencilResolve-pDepthStencilResolveAttachment-02651
If pDepthStencilResolveAttachment is not NULL and does not have the value VK_ATTACHMENT_UNUSED then it must have a format whose features contain VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT

• VUID-VkSubpassDescriptionDepthStencilResolve-pDepthStencilResolveAttachment-03181
If the VkFormat of pDepthStencilResolveAttachment has a depth component, then the VkFormat of pDepthStencilAttachment must have a depth component with the same number of bits and numerical type

• VUID-VkSubpassDescriptionDepthStencilResolve-pDepthStencilResolveAttachment-03182
If the VkFormat of pDepthStencilResolveAttachment has a stencil component, then the VkFormat of pDepthStencilAttachment must have a stencil component with the same number of bits and numerical type

• VUID-VkSubpassDescriptionDepthStencilResolve-depthResolveMode-03183
The value of depthResolveMode must be one of the bits set in VkPhysicalDeviceDepthStencilResolveProperties::supportedDepthResolveModes or VK_RESOLVE_MODE_NONE

• VUID-VkSubpassDescriptionDepthStencilResolve-stencilResolveMode-03184
The value of stencilResolveMode must be one of the bits set in VkPhysicalDeviceDepthStencilResolveProperties::supportedStencilResolveModes or VK_RESOLVE_MODE_NONE

• VUID-VkSubpassDescriptionDepthStencilResolve-pDepthStencilResolveAttachment-03185
If the VkFormat of pDepthStencilResolveAttachment has both depth and stencil components, VkPhysicalDeviceDepthStencilResolveProperties::independentResolve is VK_FALSE, and VkPhysicalDeviceDepthStencilResolveProperties::independentResolveNone is VK_FALSE, then the values of depthResolveMode and stencilResolveMode must be identical

• VUID-VkSubpassDescriptionDepthStencilResolve-pDepthStencilResolveAttachment-03186
If the VkFormat of pDepthStencilResolveAttachment has both depth and stencil components, VkPhysicalDeviceDepthStencilResolveProperties::independentResolve is VK_FALSE and VkPhysicalDeviceDepthStencilResolveProperties::independentResolveNone is VK_TRUE, then the values of depthResolveMode and stencilResolveMode must be identical or one of them must be VK_RESOLVE_MODE_NONE

• VUID-VkSubpassDescriptionDepthStencilResolve-pDepthStencilResolveAttachment-04588
If the VkFormat of pDepthStencilResolveAttachment has a depth component, depthResolveMode must be a valid VkResolveModeFlagBits value

• VUID-VkSubpassDescriptionDepthStencilResolve-pDepthStencilResolveAttachment-04589
If the VkFormat of pDepthStencilResolveAttachment has a stencil component, stencilResolveMode must be a valid VkResolveModeFlagBits value

Valid Usage (Implicit)
• VUID-VkSubpassDescriptionDepthStencilResolve-sType-sType
sType must be VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE

• VUID-VkSubpassDescriptionDepthStencilResolve-pDepthStencilResolveAttachment-parameter
If pDepthStencilResolveAttachment is not NULL, pDepthStencilResolveAttachment must be a valid pointer to a valid VkAttachmentReference2 structure

Possible values of VkSubpassDescriptionDepthStencilResolve::depthResolveMode and stencilResolveMode, specifying the depth and stencil resolve modes, are:

// Provided by VK_VERSION_1_2
typedef enum VkResolveModeFlagBits {
VK_RESOLVE_MODE_NONE = 0,
VK_RESOLVE_MODE_SAMPLE_ZERO_BIT = 0x00000001,
VK_RESOLVE_MODE_AVERAGE_BIT = 0x00000002,
VK_RESOLVE_MODE_MIN_BIT = 0x00000004,
VK_RESOLVE_MODE_MAX_BIT = 0x00000008,
} VkResolveModeFlagBits;
• VK_RESOLVE_MODE_NONE indicates that no resolve operation is done.

• VK_RESOLVE_MODE_SAMPLE_ZERO_BIT indicates that result of the resolve operation is equal to the value of sample 0.

• VK_RESOLVE_MODE_AVERAGE_BIT indicates that result of the resolve operation is the average of the sample values.

• VK_RESOLVE_MODE_MIN_BIT indicates that result of the resolve operation is the minimum of the sample values.

• VK_RESOLVE_MODE_MAX_BIT indicates that result of the resolve operation is the maximum of the sample values.

// Provided by VK_VERSION_1_2
typedef VkFlags VkResolveModeFlags;

VkResolveModeFlags is a bitmask type for setting a mask of zero or more VkResolveModeFlagBits.

The VkAttachmentReference2 structure is defined as:

// Provided by VK_VERSION_1_2
typedef struct VkAttachmentReference2 {
VkStructureType       sType;
const void*           pNext;
uint32_t              attachment;
VkImageLayout         layout;
} VkAttachmentReference2;
• sType is the type of this structure.

• pNext is NULL or a pointer to a structure extending this structure.

• attachment is either an integer value identifying an attachment at the corresponding index in VkRenderPassCreateInfo::pAttachments, or VK_ATTACHMENT_UNUSED to signify that this attachment is not used.

• layout is a VkImageLayout value specifying the layout the attachment uses during the subpass.

• aspectMask is a mask of which aspect(s) can be accessed within the specified subpass as an input attachment.

Parameters defined by this structure with the same name as those in VkAttachmentReference have the identical effect to those parameters.

aspectMask is ignored when this structure is used to describe anything other than an input attachment reference.

If the separateDepthStencilLayouts feature is enabled, and attachment has a depth/stencil format, layout can be set to a layout that only specifies the layout of the depth aspect.

If layout only specifies the layout of the depth aspect of the attachment, the layout of the stencil aspect is specified by the stencilLayout member of a VkAttachmentReferenceStencilLayout structure included in the pNext chain. Otherwise, layout describes the layout for all relevant image aspects.

Valid Usage
• VUID-VkAttachmentReference2-layout-03077
If attachment is not VK_ATTACHMENT_UNUSED, layout must not be VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_PREINITIALIZED, or VK_IMAGE_LAYOUT_PRESENT_SRC_KHR

• VUID-VkAttachmentReference2-separateDepthStencilLayouts-03313
If the separateDepthStencilLayouts feature is not enabled, and attachment is not VK_ATTACHMENT_UNUSED, layout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL,

• VUID-VkAttachmentReference2-attachment-04754
If attachment is not VK_ATTACHMENT_UNUSED, and the format of the referenced attachment is a color format, layout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL

• VUID-VkAttachmentReference2-attachment-04755
If attachment is not VK_ATTACHMENT_UNUSED, and the format of the referenced attachment is a depth/stencil format which includes both depth and stencil aspects, and layout is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, the pNext chain must include a VkAttachmentReferenceStencilLayout structure

• VUID-VkAttachmentReference2-attachment-04756
If attachment is not VK_ATTACHMENT_UNUSED, and the format of the referenced attachment is a depth/stencil format which includes only the depth aspect, layout must not be VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL

• VUID-VkAttachmentReference2-attachment-04757
If attachment is not VK_ATTACHMENT_UNUSED, and the format of the referenced attachment is a depth/stencil format which includes only the stencil aspect, layout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL

Valid Usage (Implicit)
• VUID-VkAttachmentReference2-sType-sType
sType must be VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2

• VUID-VkAttachmentReference2-pNext-pNext
pNext must be NULL or a pointer to a valid instance of VkAttachmentReferenceStencilLayout

• VUID-VkAttachmentReference2-sType-unique
The sType value of each struct in the pNext chain must be unique

• VUID-VkAttachmentReference2-layout-parameter
layout must be a valid VkImageLayout value

The VkAttachmentReferenceStencilLayout structure is defined as:

// Provided by VK_VERSION_1_2
typedef struct VkAttachmentReferenceStencilLayout {
VkStructureType    sType;
void*              pNext;
VkImageLayout      stencilLayout;
} VkAttachmentReferenceStencilLayout;
• sType is the type of this structure.

• pNext is NULL or a pointer to a structure extending this structure.

• stencilLayout is a VkImageLayout value specifying the layout the stencil aspect of the attachment uses during the subpass.

Valid Usage
• VUID-VkAttachmentReferenceStencilLayout-stencilLayout-03318
stencilLayout must not be VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_PREINITIALIZED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_PRESENT_SRC_KHR

Valid Usage (Implicit)
• VUID-VkAttachmentReferenceStencilLayout-sType-sType
sType must be VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT

• VUID-VkAttachmentReferenceStencilLayout-stencilLayout-parameter
stencilLayout must be a valid VkImageLayout value

The VkSubpassDependency2 structure is defined as:

// Provided by VK_VERSION_1_2
typedef struct VkSubpassDependency2 {
VkStructureType         sType;
const void*             pNext;
uint32_t                srcSubpass;
uint32_t                dstSubpass;
VkDependencyFlags       dependencyFlags;
int32_t                 viewOffset;
} VkSubpassDependency2;
• sType is the type of this structure.

• pNext is NULL or a pointer to a structure extending this structure.

• srcSubpass is the subpass index of the first subpass in the dependency, or VK_SUBPASS_EXTERNAL.

• dstSubpass is the subpass index of the second subpass in the dependency, or VK_SUBPASS_EXTERNAL.

• srcStageMask is a bitmask of VkPipelineStageFlagBits specifying the source stage mask.

• dstStageMask is a bitmask of VkPipelineStageFlagBits specifying the destination stage mask

• srcAccessMask is a bitmask of VkAccessFlagBits specifying a source access mask.

• dstAccessMask is a bitmask of VkAccessFlagBits specifying a destination access mask.

• dependencyFlags is a bitmask of VkDependencyFlagBits.

• viewOffset controls which views in the source subpass the views in the destination subpass depend on.

Parameters defined by this structure with the same name as those in VkSubpassDependency have the identical effect to those parameters.

viewOffset has the same effect for the described subpass dependency as VkRenderPassMultiviewCreateInfo::pViewOffsets has on each corresponding subpass dependency.

Valid Usage
If the geometry shaders feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT

If the geometry shaders feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT

If the tessellation shaders feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT

If the tessellation shaders feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT

• VUID-VkSubpassDependency2-srcSubpass-03084
srcSubpass must be less than or equal to dstSubpass, unless one of them is VK_SUBPASS_EXTERNAL, to avoid cyclic dependencies and ensure a valid execution order

• VUID-VkSubpassDependency2-srcSubpass-03085
srcSubpass and dstSubpass must not both be equal to VK_SUBPASS_EXTERNAL

• VUID-VkSubpassDependency2-srcSubpass-03087
If srcSubpass is equal to dstSubpass and not all of the stages in srcStageMask and dstStageMask are framebuffer-space stages, the logically latest pipeline stage in srcStageMask must be logically earlier than or equal to the logically earliest pipeline stage in dstStageMask

Any access flag included in srcAccessMask must be supported by one of the pipeline stages in srcStageMask, as specified in the table of supported access types

Any access flag included in dstAccessMask must be supported by one of the pipeline stages in dstStageMask, as specified in the table of supported access types

• VUID-VkSubpassDependency2-dependencyFlags-03090
If dependencyFlags includes VK_DEPENDENCY_VIEW_LOCAL_BIT, srcSubpass must not be equal to VK_SUBPASS_EXTERNAL

• VUID-VkSubpassDependency2-dependencyFlags-03091
If dependencyFlags includes VK_DEPENDENCY_VIEW_LOCAL_BIT, dstSubpass must not be equal to VK_SUBPASS_EXTERNAL

• VUID-VkSubpassDependency2-srcSubpass-02245
If srcSubpass equals dstSubpass, and srcStageMask and dstStageMask both include a framebuffer-space stage, then dependencyFlags must include VK_DEPENDENCY_BY_REGION_BIT

• VUID-VkSubpassDependency2-viewOffset-02530
If viewOffset is not equal to 0, srcSubpass must not be equal to dstSubpass

• VUID-VkSubpassDependency2-dependencyFlags-03092
If dependencyFlags does not include VK_DEPENDENCY_VIEW_LOCAL_BIT, viewOffset must be 0

Valid Usage (Implicit)
• VUID-VkSubpassDependency2-sType-sType
sType must be VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2

• VUID-VkSubpassDependency2-pNext-pNext
pNext must be NULL

srcStageMask must be a valid combination of VkPipelineStageFlagBits values

dstStageMask must be a valid combination of VkPipelineStageFlagBits values

srcAccessMask must be a valid combination of VkAccessFlagBits values

dstAccessMask must be a valid combination of VkAccessFlagBits values

• VUID-VkSubpassDependency2-dependencyFlags-parameter
dependencyFlags must be a valid combination of VkDependencyFlagBits values

To destroy a render pass, call:

// Provided by VK_VERSION_1_0
void vkDestroyRenderPass(
VkDevice                                    device,
VkRenderPass                                renderPass,
const VkAllocationCallbacks*                pAllocator);
• device is the logical device that destroys the render pass.

• renderPass is the handle of the render pass to destroy.

• pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Valid Usage
• VUID-vkDestroyRenderPass-renderPass-00873
All submitted commands that refer to renderPass must have completed execution

• VUID-vkDestroyRenderPass-renderPass-00874
If VkAllocationCallbacks were provided when renderPass was created, a compatible set of callbacks must be provided here

• VUID-vkDestroyRenderPass-renderPass-00875
If no VkAllocationCallbacks were provided when renderPass was created, pAllocator must be NULL

Valid Usage (Implicit)
• VUID-vkDestroyRenderPass-device-parameter
device must be a valid VkDevice handle

• VUID-vkDestroyRenderPass-renderPass-parameter
If renderPass is not VK_NULL_HANDLE, renderPass must be a valid VkRenderPass handle

• VUID-vkDestroyRenderPass-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure

• VUID-vkDestroyRenderPass-renderPass-parent
If renderPass is a valid handle, it must have been created, allocated, or retrieved from device

Host Synchronization
• Host access to renderPass must be externally synchronized

### 8.2. Render Pass Compatibility

Framebuffers and graphics pipelines are created based on a specific render pass object. They must only be used with that render pass object, or one compatible with it.

Two attachment references are compatible if they have matching format and sample count, or are both VK_ATTACHMENT_UNUSED or the pointer that would contain the reference is NULL.

Two arrays of attachment references are compatible if all corresponding pairs of attachments are compatible. If the arrays are of different lengths, attachment references not present in the smaller array are treated as VK_ATTACHMENT_UNUSED.

Two render passes are compatible if their corresponding color, input, resolve, and depth/stencil attachment references are compatible and if they are otherwise identical except for:

• Initial and final image layout in attachment descriptions

• Load and store operations in attachment descriptions

• Image layout in attachment references

As an additional special case, if two render passes have a single subpass, the resolve attachment reference compatibility requirements are ignored.

A framebuffer is compatible with a render pass if it was created using the same render pass or a compatible render pass.

### 8.3. Framebuffers

Render passes operate in conjunction with framebuffers. Framebuffers represent a collection of specific memory attachments that a render pass instance uses.

Framebuffers are represented by VkFramebuffer handles:

// Provided by VK_VERSION_1_0
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer)

To create a framebuffer, call:

// Provided by VK_VERSION_1_0
VkResult vkCreateFramebuffer(
VkDevice                                    device,
const VkFramebufferCreateInfo*              pCreateInfo,
const VkAllocationCallbacks*                pAllocator,
VkFramebuffer*                              pFramebuffer);
• device is the logical device that creates the framebuffer.

• pCreateInfo is a pointer to a VkFramebufferCreateInfo structure describing additional information about framebuffer creation.

• pAllocator controls host memory allocation as described in the Memory Allocation chapter.

• pFramebuffer is a pointer to a VkFramebuffer handle in which the resulting framebuffer object is returned.

Valid Usage
• VUID-vkCreateFramebuffer-pCreateInfo-02777
If pCreateInfo->flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, and attachmentCount is not 0, each element of pCreateInfo->pAttachments must have been created on device

Valid Usage (Implicit)
• VUID-vkCreateFramebuffer-device-parameter
device must be a valid VkDevice handle

• VUID-vkCreateFramebuffer-pCreateInfo-parameter
pCreateInfo must be a valid pointer to a valid VkFramebufferCreateInfo structure

• VUID-vkCreateFramebuffer-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure

• VUID-vkCreateFramebuffer-pFramebuffer-parameter
pFramebuffer must be a valid pointer to a VkFramebuffer handle

Return Codes
Success
• VK_SUCCESS

Failure
• VK_ERROR_OUT_OF_HOST_MEMORY

• VK_ERROR_OUT_OF_DEVICE_MEMORY

The VkFramebufferCreateInfo structure is defined as:

// Provided by VK_VERSION_1_0
typedef struct VkFramebufferCreateInfo {
VkStructureType             sType;
const void*                 pNext;
VkFramebufferCreateFlags    flags;
VkRenderPass                renderPass;
uint32_t                    attachmentCount;
const VkImageView*          pAttachments;
uint32_t                    width;
uint32_t                    height;
uint32_t                    layers;
} VkFramebufferCreateInfo;
• sType is the type of this structure.

• pNext is NULL or a pointer to a structure extending this structure.

• flags is a bitmask of VkFramebufferCreateFlagBits

• renderPass is a render pass defining what render passes the framebuffer will be compatible with. See Render Pass Compatibility for details.

• attachmentCount is the number of attachments.

• pAttachments is a pointer to an array of VkImageView handles, each of which will be used as the corresponding attachment in a render pass instance. If flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, this parameter is ignored.

• width, height and layers define the dimensions of the framebuffer. If the render pass uses multiview, then layers must be one and each attachment requires a number of layers that is greater than the maximum bit index set in the view mask in the subpasses in which it is used.

Other than the exceptions listed below, applications must ensure that all accesses to memory that backs image subresources used as attachments in a given renderpass instance either happen-before the load operations for those attachments, or happen-after the store operations for those attachments.

The exceptions to the general rule are:

• For depth/stencil attachments, an aspect can be used separately as attachment and non-attachment if both accesses are read-only.

• For depth/stencil attachments, each aspect can be used separately as attachments and non-attachments as long as the non-attachment accesses are also via an image subresource in either the VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL layout or the VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL layout, and the attachment resource uses whichever of those two layouts the image accesses do not.

Use of non-attachment aspects in these cases is only well defined if the attachment is used in the subpass where the non-attachment access is being made, or the layout of the image subresource is constant throughout the entire render pass instance, including the initialLayout and finalLayout.

 Note These restrictions mean that the render pass has full knowledge of all uses of all of the attachments, so that the implementation is able to make correct decisions about when and how to perform layout transitions, when to overlap execution of subpasses, etc.

It is legal for a subpass to use no color or depth/stencil attachments, either because it has no attachment references or because all of them are VK_ATTACHMENT_UNUSED. This kind of subpass can use shader side effects such as image stores and atomics to produce an output. In this case, the subpass continues to use the width, height, and layers of the framebuffer to define the dimensions of the rendering area, and the rasterizationSamples from each pipeline’s VkPipelineMultisampleStateCreateInfo to define the number of samples used in rasterization; however, if VkPhysicalDeviceFeatures::variableMultisampleRate is VK_FALSE, then all pipelines to be bound with the subpass must have the same value for VkPipelineMultisampleStateCreateInfo::rasterizationSamples.

Valid Usage
• VUID-VkFramebufferCreateInfo-attachmentCount-00876
attachmentCount must be equal to the attachment count specified in renderPass

• VUID-VkFramebufferCreateInfo-flags-02778
If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, and attachmentCount is not 0, pAttachments must be a valid pointer to an array of attachmentCount valid VkImageView handles

• VUID-VkFramebufferCreateInfo-pAttachments-00877
If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments that is used as a color attachment or resolve attachment by renderPass must have been created with a usage value including VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT

• VUID-VkFramebufferCreateInfo-pAttachments-02633
If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments that is used as a depth/stencil attachment by renderPass must have been created with a usage value including VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT

• VUID-VkFramebufferCreateInfo-pAttachments-02634
If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments that is used as a depth/stencil resolve attachment by renderPass must have been created with a usage value including VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT

• VUID-VkFramebufferCreateInfo-pAttachments-00879
If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments that is used as an input attachment by renderPass must have been created with a usage value including VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT

• VUID-VkFramebufferCreateInfo-pAttachments-00880
If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments must have been created with a VkFormat value that matches the VkFormat specified by the corresponding VkAttachmentDescription in renderPass

• VUID-VkFramebufferCreateInfo-pAttachments-00881
If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments must have been created with a samples value that matches the samples value specified by the corresponding VkAttachmentDescription in renderPass

• VUID-VkFramebufferCreateInfo-flags-04533
If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments that is used as an input, color, resolve, or depth/stencil attachment by renderPass must have been created with a VkImageCreateInfo::width greater than or equal to width

• VUID-VkFramebufferCreateInfo-flags-04534
If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments that is used as an input, color, resolve, or depth/stencil attachment by renderPass must have been created with a VkImageCreateInfo::height greater than or equal to height

• VUID-VkFramebufferCreateInfo-flags-04535
If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments that is used as an input, color, resolve, or depth/stencil attachment by renderPass must have been created with a VkImageViewCreateInfo::subresourceRange.layerCount greater than or equal to layers

• VUID-VkFramebufferCreateInfo-renderPass-04536
If renderPass was specified with non-zero view masks, each element of pAttachments that is used as an input, color, resolve, or depth/stencil attachment by renderPass must have a layerCount greater than the index of the most significant bit set in any of those view masks

• VUID-VkFramebufferCreateInfo-pAttachments-00883
If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments must only specify a single mip level

• VUID-VkFramebufferCreateInfo-pAttachments-00884
If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments must have been created with the identity swizzle

• VUID-VkFramebufferCreateInfo-width-00885
width must be greater than 0

• VUID-VkFramebufferCreateInfo-width-00886
width must be less than or equal to VkPhysicalDeviceLimits::maxFramebufferWidth

• VUID-VkFramebufferCreateInfo-height-00887
height must be greater than 0

• VUID-VkFramebufferCreateInfo-height-00888
height must be less than or equal to VkPhysicalDeviceLimits::maxFramebufferHeight

• VUID-VkFramebufferCreateInfo-layers-00889
layers must be greater than 0

• VUID-VkFramebufferCreateInfo-layers-00890
layers must be less than or equal to VkPhysicalDeviceLimits::maxFramebufferLayers

• VUID-VkFramebufferCreateInfo-renderPass-02531
If renderPass was specified with non-zero view masks, layers must be 1

• VUID-VkFramebufferCreateInfo-pAttachments-00891
If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments that is a 2D or 2D array image view taken from a 3D image must not be a depth/stencil format

• VUID-VkFramebufferCreateInfo-flags-03189
If the imageless framebuffer feature is not enabled, flags must not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT

• VUID-VkFramebufferCreateInfo-flags-03190
If flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the pNext chain must include an instance of VkFramebufferAttachmentsCreateInfo

• VUID-VkFramebufferCreateInfo-flags-03191
If flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the attachmentImageInfoCount member of an instance of VkFramebufferAttachmentsCreateInfo in the pNext chain must be equal to either zero or attachmentCount

• VUID-VkFramebufferCreateInfo-flags-04541
If flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the width member of any element of the pAttachmentImageInfos member of an instance of VkFramebufferAttachmentsCreateInfo in the pNext chain that is used as an input, color, resolve or depth/stencil attachment in pRenderPass must be greater than or equal to width

• VUID-VkFramebufferCreateInfo-flags-04542
If flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the height member of any element of the pAttachmentImageInfos member of an instance of VkFramebufferAttachmentsCreateInfo in the pNext chain that is used as an input, color, resolve or depth/stencil attachment in pRenderPass must be greater than or equal to height

• VUID-VkFramebufferCreateInfo-renderPass-03198
If multiview is enabled for renderPass, and flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the layerCount member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure included in the pNext chain used as an input, color, resolve, or depth/stencil attachment in pRenderPass must be greater than the maximum bit index set in the view mask in the subpasses in which it is used in renderPass

• VUID-VkFramebufferCreateInfo-renderPass-04546
If multiview is not enabled for renderPass, and flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the layerCount member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure included in the pNext chain used as an input, color, resolve, or depth/stencil attachment in pRenderPass must be greater than or equal to layers

• VUID-VkFramebufferCreateInfo-flags-04547
If flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the layerCount member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure included in the pNext chain used as an input, color, resolve, or depth/stencil attachment in pRenderPass must be greater than or equal to layers

• VUID-VkFramebufferCreateInfo-flags-03201
If flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the usage member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure included in the pNext chain that refers to an attachment used as a color attachment or resolve attachment by renderPass must include VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT

• VUID-VkFramebufferCreateInfo-flags-03202
If flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the usage member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure included in the pNext chain that refers to an attachment used as a depth/stencil attachment by renderPass must include VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT

• VUID-VkFramebufferCreateInfo-flags-03204
If flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the usage member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure included in the pNext chain that refers to an attachment used as an input attachment by renderPass must include VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT

• VUID-VkFramebufferCreateInfo-flags-03205
If flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, at least one element of the pViewFormats member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure included in the pNext chain must be equal to the corresponding value of VkAttachmentDescription::format used to create renderPass

• VUID-VkFramebufferCreateInfo-flags-04113
If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments must have been created with VkImageViewCreateInfo::viewType not equal to VK_IMAGE_VIEW_TYPE_3D

Valid Usage (Implicit)
• VUID-VkFramebufferCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO

• VUID-VkFramebufferCreateInfo-pNext-pNext
pNext must be NULL or a pointer to a valid instance of VkFramebufferAttachmentsCreateInfo

• VUID-VkFramebufferCreateInfo-sType-unique
The sType value of each struct in the pNext chain must be unique

• VUID-VkFramebufferCreateInfo-flags-parameter
flags must be a valid combination of VkFramebufferCreateFlagBits values

• VUID-VkFramebufferCreateInfo-renderPass-parameter
renderPass must be a valid VkRenderPass handle

• VUID-VkFramebufferCreateInfo-commonparent
Both of renderPass, and the elements of pAttachments that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice

The VkFramebufferAttachmentsCreateInfo structure is defined as:

// Provided by VK_VERSION_1_2
typedef struct VkFramebufferAttachmentsCreateInfo {
VkStructureType                            sType;
const void*                                pNext;
uint32_t                                   attachmentImageInfoCount;
const VkFramebufferAttachmentImageInfo*    pAttachmentImageInfos;
} VkFramebufferAttachmentsCreateInfo;
• sType is the type of this structure.

• pNext is NULL or a pointer to a structure extending this structure.

• attachmentImageInfoCount is the number of attachments being described.

• pAttachmentImageInfos is a pointer to an array of VkFramebufferAttachmentImageInfo instances, each of which describes a number of parameters of the corresponding attachment in a render pass instance.

Valid Usage (Implicit)
• VUID-VkFramebufferAttachmentsCreateInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO

• VUID-VkFramebufferAttachmentsCreateInfo-pAttachmentImageInfos-parameter
If attachmentImageInfoCount is not 0, pAttachmentImageInfos must be a valid pointer to an array of attachmentImageInfoCount valid VkFramebufferAttachmentImageInfo structures

The VkFramebufferAttachmentImageInfo structure is defined as:

// Provided by VK_VERSION_1_2
typedef struct VkFramebufferAttachmentImageInfo {
VkStructureType       sType;
const void*           pNext;
VkImageCreateFlags    flags;
VkImageUsageFlags     usage;
uint32_t              width;
uint32_t              height;
uint32_t              layerCount;
uint32_t              viewFormatCount;
const VkFormat*       pViewFormats;
} VkFramebufferAttachmentImageInfo;
• sType is the type of this structure.

• pNext is NULL or a pointer to a structure extending this structure.

• flags is a bitmask of VkImageCreateFlagBits, matching the value of VkImageCreateInfo::flags used to create an image that will be used with this framebuffer.

• usage is a bitmask of VkImageUsageFlagBits, matching the value of VkImageCreateInfo::usage used to create an image used with this framebuffer.

• width is the width of the image view used for rendering.

• height is the height of the image view used for rendering.

• viewFormatCount is the number of entries in the pViewFormats array, matching the value of VkImageFormatListCreateInfo::viewFormatCount used to create an image used with this framebuffer.

• pViewFormats is an array which lists of all formats which can be used when creating views of the image, matching the value of VkImageFormatListCreateInfo::pViewFormats used to create an image used with this framebuffer.

Images that can be used with the framebuffer when beginning a render pass, as specified by VkRenderPassAttachmentBeginInfo, must be created with parameters that are identical to those specified here.

Valid Usage (Implicit)
• VUID-VkFramebufferAttachmentImageInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO

• VUID-VkFramebufferAttachmentImageInfo-pNext-pNext
pNext must be NULL

• VUID-VkFramebufferAttachmentImageInfo-flags-parameter
flags must be a valid combination of VkImageCreateFlagBits values

• VUID-VkFramebufferAttachmentImageInfo-usage-parameter
usage must be a valid combination of VkImageUsageFlagBits values

usage must not be 0

• VUID-VkFramebufferAttachmentImageInfo-pViewFormats-parameter
If viewFormatCount is not 0, pViewFormats must be a valid pointer to an array of viewFormatCount valid VkFormat values

Bits which can be set in VkFramebufferCreateInfo::flags to specify options for framebuffers are:

// Provided by VK_VERSION_1_0
typedef enum VkFramebufferCreateFlagBits {
// Provided by VK_VERSION_1_2
VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT = 0x00000001,
} VkFramebufferCreateFlagBits;
• VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT specifies that image views are not specified, and only attachment compatibility information will be provided via a VkFramebufferAttachmentImageInfo structure.

// Provided by VK_VERSION_1_0
typedef VkFlags VkFramebufferCreateFlags;

VkFramebufferCreateFlags is a bitmask type for setting a mask of zero or more VkFramebufferCreateFlagBits.

To destroy a framebuffer, call:

// Provided by VK_VERSION_1_0
void vkDestroyFramebuffer(
VkDevice                                    device,
VkFramebuffer                               framebuffer,
const VkAllocationCallbacks*                pAllocator);
• device is the logical device that destroys the framebuffer.

• framebuffer is the handle of the framebuffer to destroy.

• pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Valid Usage
• VUID-vkDestroyFramebuffer-framebuffer-00892
All submitted commands that refer to framebuffer must have completed execution

• VUID-vkDestroyFramebuffer-framebuffer-00893
If VkAllocationCallbacks were provided when framebuffer was created, a compatible set of callbacks must be provided here

• VUID-vkDestroyFramebuffer-framebuffer-00894
If no VkAllocationCallbacks were provided when framebuffer was created, pAllocator must be NULL

Valid Usage (Implicit)
• VUID-vkDestroyFramebuffer-device-parameter
device must be a valid VkDevice handle

• VUID-vkDestroyFramebuffer-framebuffer-parameter
If framebuffer is not VK_NULL_HANDLE, framebuffer must be a valid VkFramebuffer handle

• VUID-vkDestroyFramebuffer-pAllocator-parameter
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure

• VUID-vkDestroyFramebuffer-framebuffer-parent
If framebuffer is a valid handle, it must have been created, allocated, or retrieved from device

Host Synchronization
• Host access to framebuffer must be externally synchronized

### 8.4. Render Pass Commands

An application records the commands for a render pass instance one subpass at a time, by beginning a render pass instance, iterating over the subpasses to record commands for that subpass, and then ending the render pass instance.

To begin a render pass instance, call:

// Provided by VK_VERSION_1_0
void vkCmdBeginRenderPass(
VkCommandBuffer                             commandBuffer,
const VkRenderPassBeginInfo*                pRenderPassBegin,
VkSubpassContents                           contents);
• commandBuffer is the command buffer in which to record the command.

• pRenderPassBegin is a pointer to a VkRenderPassBeginInfo structure specifying the render pass to begin an instance of, and the framebuffer the instance uses.

• contents is a VkSubpassContents value specifying how the commands in the first subpass will be provided.

After beginning a render pass instance, the command buffer is ready to record the commands for the first subpass of that render pass.

Valid Usage
• VUID-vkCmdBeginRenderPass-initialLayout-00895
If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT

• VUID-vkCmdBeginRenderPass-initialLayout-01758
If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT

• VUID-vkCmdBeginRenderPass-initialLayout-02842
If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT

• VUID-vkCmdBeginRenderPass-stencilInitialLayout-02843
If any of the stencilInitialLayout or stencilFinalLayout member of the VkAttachmentDescriptionStencilLayout structures or the stencilLayout member of the VkAttachmentReferenceStencilLayout structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT

• VUID-vkCmdBeginRenderPass-initialLayout-00897
If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_SAMPLED_BIT or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT

• VUID-vkCmdBeginRenderPass-initialLayout-00898
If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_TRANSFER_SRC_BIT

• VUID-vkCmdBeginRenderPass-initialLayout-00899
If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_TRANSFER_DST_BIT

• VUID-vkCmdBeginRenderPass-initialLayout-00900
If any of the initialLayout members of the VkAttachmentDescription structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is not VK_IMAGE_LAYOUT_UNDEFINED, then each such initialLayout must be equal to the current layout of the corresponding attachment image subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin

The srcStageMask and dstStageMask members of any element of the pDependencies member of VkRenderPassCreateInfo used to create renderPass must be supported by the capabilities of the queue family identified by the queueFamilyIndex member of the VkCommandPoolCreateInfo used to create the command pool which commandBuffer was allocated from

• VUID-vkCmdBeginRenderPass-framebuffer-02532
For any attachment in framebuffer that is used by renderPass and is bound to memory locations that are also bound to another attachment used by renderPass, and if at least one of those uses causes either attachment to be written to, both attachments must have had the VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT set

Valid Usage (Implicit)
• VUID-vkCmdBeginRenderPass-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle

• VUID-vkCmdBeginRenderPass-pRenderPassBegin-parameter
pRenderPassBegin must be a valid pointer to a valid VkRenderPassBeginInfo structure

• VUID-vkCmdBeginRenderPass-contents-parameter
contents must be a valid VkSubpassContents value

• VUID-vkCmdBeginRenderPass-commandBuffer-recording
commandBuffer must be in the recording state

• VUID-vkCmdBeginRenderPass-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations

• VUID-vkCmdBeginRenderPass-renderpass
This command must only be called outside of a render pass instance

• VUID-vkCmdBeginRenderPass-bufferlevel
commandBuffer must be a primary VkCommandBuffer

Host Synchronization
• Host access to commandBuffer must be externally synchronized

• Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties
Command Buffer Levels Render Pass Scope Supported Queue Types Pipeline Type

Primary

Outside

Graphics

Graphics

Alternatively to begin a render pass, call:

// Provided by VK_VERSION_1_2
void vkCmdBeginRenderPass2(
VkCommandBuffer                             commandBuffer,
const VkRenderPassBeginInfo*                pRenderPassBegin,
const VkSubpassBeginInfo*                   pSubpassBeginInfo);
• commandBuffer is the command buffer in which to record the command.

• pRenderPassBegin is a pointer to a VkRenderPassBeginInfo structure specifying the render pass to begin an instance of, and the framebuffer the instance uses.

• pSubpassBeginInfo is a pointer to a VkSubpassBeginInfo structure containing information about the subpass which is about to begin rendering.

After beginning a render pass instance, the command buffer is ready to record the commands for the first subpass of that render pass.

Valid Usage
• VUID-vkCmdBeginRenderPass2-framebuffer-02779
Both the framebuffer and renderPass members of pRenderPassBegin must have been created on the same VkDevice that commandBuffer was allocated on

• VUID-vkCmdBeginRenderPass2-initialLayout-03094
If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT

• VUID-vkCmdBeginRenderPass2-initialLayout-03096
If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT

• VUID-vkCmdBeginRenderPass2-initialLayout-02844
If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT

• VUID-vkCmdBeginRenderPass2-stencilInitialLayout-02845
If any of the stencilInitialLayout or stencilFinalLayout member of the VkAttachmentDescriptionStencilLayout structures or the stencilLayout member of the VkAttachmentReferenceStencilLayout structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT

• VUID-vkCmdBeginRenderPass2-initialLayout-03097
If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_SAMPLED_BIT or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT

• VUID-vkCmdBeginRenderPass2-initialLayout-03098
If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_TRANSFER_SRC_BIT

• VUID-vkCmdBeginRenderPass2-initialLayout-03099
If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_TRANSFER_DST_BIT

• VUID-vkCmdBeginRenderPass2-initialLayout-03100
If any of the initialLayout members of the VkAttachmentDescription structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is not VK_IMAGE_LAYOUT_UNDEFINED, then each such initialLayout must be equal to the current layout of the corresponding attachment image subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin

The srcStageMask and dstStageMask members of any element of the pDependencies member of VkRenderPassCreateInfo used to create renderPass must be supported by the capabilities of the queue family identified by the queueFamilyIndex member of the VkCommandPoolCreateInfo used to create the command pool which commandBuffer was allocated from

• VUID-vkCmdBeginRenderPass2-framebuffer-02533
For any attachment in framebuffer that is used by renderPass and is bound to memory locations that are also bound to another attachment used by renderPass, and if at least one of those uses causes either attachment to be written to, both attachments must have had the VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT set

Valid Usage (Implicit)
• VUID-vkCmdBeginRenderPass2-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle

• VUID-vkCmdBeginRenderPass2-pRenderPassBegin-parameter
pRenderPassBegin must be a valid pointer to a valid VkRenderPassBeginInfo structure

• VUID-vkCmdBeginRenderPass2-pSubpassBeginInfo-parameter
pSubpassBeginInfo must be a valid pointer to a valid VkSubpassBeginInfo structure

• VUID-vkCmdBeginRenderPass2-commandBuffer-recording
commandBuffer must be in the recording state

• VUID-vkCmdBeginRenderPass2-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations

• VUID-vkCmdBeginRenderPass2-renderpass
This command must only be called outside of a render pass instance

• VUID-vkCmdBeginRenderPass2-bufferlevel
commandBuffer must be a primary VkCommandBuffer

Host Synchronization
• Host access to commandBuffer must be externally synchronized

• Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties
Command Buffer Levels Render Pass Scope Supported Queue Types Pipeline Type

Primary

Outside

Graphics

Graphics

The VkRenderPassBeginInfo structure is defined as:

// Provided by VK_VERSION_1_0
typedef struct VkRenderPassBeginInfo {
VkStructureType        sType;
const void*            pNext;
VkRenderPass           renderPass;
VkFramebuffer          framebuffer;
VkRect2D               renderArea;
uint32_t               clearValueCount;
const VkClearValue*    pClearValues;
} VkRenderPassBeginInfo;
• sType is the type of this structure.

• pNext is NULL or a pointer to a structure extending this structure.

• renderPass is the render pass to begin an instance of.

• framebuffer is the framebuffer containing the attachments that are used with the render pass.

• renderArea is the render area that is affected by the render pass instance, and is described in more detail below.

• clearValueCount is the number of elements in pClearValues.

• pClearValues is a pointer to an array of clearValueCount VkClearValue structures that contains clear values for each attachment, if the attachment uses a loadOp value of VK_ATTACHMENT_LOAD_OP_CLEAR or if the attachment has a depth/stencil format and uses a stencilLoadOp value of VK_ATTACHMENT_LOAD_OP_CLEAR. The array is indexed by attachment number. Only elements corresponding to cleared attachments are used. Other elements of pClearValues are ignored.

renderArea is the render area that is affected by the render pass instance. The effects of attachment load, store and multisample resolve operations are restricted to the pixels whose x and y coordinates fall within the render area on all attachments. The render area extends to all layers of framebuffer. The application must ensure (using scissor if necessary) that all rendering is contained within the render area. The render area must be contained within the framebuffer dimensions.

When multiview is enabled, the resolve operation at the end of a subpass applies to all views in the view mask.

 Note There may be a performance cost for using a render area smaller than the framebuffer, unless it matches the render area granularity for the render pass.
Valid Usage
• VUID-VkRenderPassBeginInfo-clearValueCount-00902
clearValueCount must be greater than the largest attachment index in renderPass that specifies a loadOp (or stencilLoadOp, if the attachment has a depth/stencil format) of VK_ATTACHMENT_LOAD_OP_CLEAR

• VUID-VkRenderPassBeginInfo-renderPass-00904
renderPass must be compatible with the renderPass member of the VkFramebufferCreateInfo structure specified when creating framebuffer

• VUID-VkRenderPassBeginInfo-pNext-02850
If the pNext chain does not contain VkDeviceGroupRenderPassBeginInfo or its deviceRenderAreaCount member is equal to 0, renderArea.offset.x must be greater than or equal to 0

• VUID-VkRenderPassBeginInfo-pNext-02851
If the pNext chain does not contain VkDeviceGroupRenderPassBeginInfo or its deviceRenderAreaCount member is equal to 0, renderArea.offset.y must be greater than or equal to 0

• VUID-VkRenderPassBeginInfo-pNext-02852
If the pNext chain does not contain VkDeviceGroupRenderPassBeginInfo or its deviceRenderAreaCount member is equal to 0, renderArea.offset.x + renderArea.offset.width must be less than or equal to VkFramebufferCreateInfo::width the framebuffer was created with

• VUID-VkRenderPassBeginInfo-pNext-02853
If the pNext chain does not contain VkDeviceGroupRenderPassBeginInfo or its deviceRenderAreaCount member is equal to 0, renderArea.offset.y + renderArea.offset.height must be less than or equal to VkFramebufferCreateInfo::height the framebuffer was created with

• VUID-VkRenderPassBeginInfo-pNext-02854
If the pNext chain contains VkDeviceGroupRenderPassBeginInfo, the offset.x member of each element of pDeviceRenderAreas must be greater than or equal to 0

• VUID-VkRenderPassBeginInfo-pNext-02855
If the pNext chain contains VkDeviceGroupRenderPassBeginInfo, the offset.y member of each element of pDeviceRenderAreas must be greater than or equal to 0

• VUID-VkRenderPassBeginInfo-pNext-02856
If the pNext chain contains VkDeviceGroupRenderPassBeginInfo, offset.x + offset.width of each element of pDeviceRenderAreas must be less than or equal to VkFramebufferCreateInfo::width the framebuffer was created with

• VUID-VkRenderPassBeginInfo-pNext-02857
If the pNext chain contains VkDeviceGroupRenderPassBeginInfo, offset.y + offset.height of each element of pDeviceRenderAreas must be less than or equal to VkFramebufferCreateInfo::height the framebuffer was created with

• VUID-VkRenderPassBeginInfo-framebuffer-03207
If framebuffer was created with a VkFramebufferCreateInfo::flags value that did not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, and the pNext chain includes a VkRenderPassAttachmentBeginInfo structure, its attachmentCount must be zero

• VUID-VkRenderPassBeginInfo-framebuffer-03208
If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the attachmentCount of a VkRenderPassAttachmentBeginInfo structure included in the pNext chain must be equal to the value of VkFramebufferAttachmentsCreateInfo::attachmentImageInfoCount used to create framebuffer

• VUID-VkRenderPassBeginInfo-framebuffer-02780
If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of the pAttachments member of a VkRenderPassAttachmentBeginInfo structure included in the pNext chain must have been created on the same VkDevice as framebuffer and renderPass

• VUID-VkRenderPassBeginInfo-framebuffer-03209
If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of the pAttachments member of a VkRenderPassAttachmentBeginInfo structure included in the pNext chain must be a VkImageView of an image created with a value of VkImageCreateInfo::flags equal to the flags member of the corresponding element of VkFramebufferAttachmentsCreateInfo::pAttachmentImageInfos used to create framebuffer

• VUID-VkRenderPassBeginInfo-framebuffer-04627
If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of the pAttachments member of a VkRenderPassAttachmentBeginInfo structure included in the pNext chain must be a VkImageView with an inherited usage equal to the usage member of the corresponding element of VkFramebufferAttachmentsCreateInfo::pAttachmentImageInfos used to create framebuffer

• VUID-VkRenderPassBeginInfo-framebuffer-03211
If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of the pAttachments member of a VkRenderPassAttachmentBeginInfo structure included in the pNext chain must be a VkImageView with a width equal to the width member of the corresponding element of VkFramebufferAttachmentsCreateInfo::pAttachmentImageInfos used to create framebuffer

• VUID-VkRenderPassBeginInfo-framebuffer-03212
If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of the pAttachments member of a VkRenderPassAttachmentBeginInfo structure included in the pNext chain must be a VkImageView with a height equal to the height member of the corresponding element of VkFramebufferAttachmentsCreateInfo::pAttachmentImageInfos used to create framebuffer

• VUID-VkRenderPassBeginInfo-framebuffer-03213
If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of the pAttachments member of a VkRenderPassAttachmentBeginInfo structure included in the pNext chain must be a VkImageView of an image created with a value of VkImageViewCreateInfo::subresourceRange.layerCount equal to the layerCount member of the corresponding element of VkFramebufferAttachmentsCreateInfo::pAttachmentImageInfos used to create framebuffer

• VUID-VkRenderPassBeginInfo-framebuffer-03214
If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of the pAttachments member of a VkRenderPassAttachmentBeginInfo structure included in the pNext chain must be a VkImageView of an image created with a value of VkImageFormatListCreateInfo::viewFormatCount equal to the viewFormatCount member of the corresponding element of VkFramebufferAttachmentsCreateInfo::pAttachmentImageInfos used to create framebuffer

• VUID-VkRenderPassBeginInfo-framebuffer-03215
If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of the pAttachments member of a VkRenderPassAttachmentBeginInfo structure included in the pNext chain must be a VkImageView of an image created with a set of elements in VkImageFormatListCreateInfo::pViewFormats equal to the set of elements in the pViewFormats member of the corresponding element of VkFramebufferAttachmentsCreateInfo::pAttachmentImageInfos used to create framebuffer

• VUID-VkRenderPassBeginInfo-framebuffer-03216
If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of the pAttachments member of a VkRenderPassAttachmentBeginInfo structure included in the pNext chain must be a VkImageView of an image created with a value of VkImageViewCreateInfo::format equal to the corresponding value of VkAttachmentDescription::format in renderPass

• VUID-VkRenderPassBeginInfo-framebuffer-03217
If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of the pAttachments member of a VkRenderPassAttachmentBeginInfo structure included in the pNext chain must be a VkImageView of an image created with a value of VkImageCreateInfo::samples equal to the corresponding value of VkAttachmentDescription::samples in renderPass

Valid Usage (Implicit)
• VUID-VkRenderPassBeginInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO

• VUID-VkRenderPassBeginInfo-pNext-pNext
Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDeviceGroupRenderPassBeginInfo or VkRenderPassAttachmentBeginInfo

• VUID-VkRenderPassBeginInfo-sType-unique
The sType value of each struct in the pNext chain must be unique

• VUID-VkRenderPassBeginInfo-renderPass-parameter
renderPass must be a valid VkRenderPass handle

• VUID-VkRenderPassBeginInfo-framebuffer-parameter
framebuffer must be a valid VkFramebuffer handle

• VUID-VkRenderPassBeginInfo-commonparent
Both of framebuffer, and renderPass must have been created, allocated, or retrieved from the same VkDevice

The VkSubpassBeginInfo structure is defined as:

// Provided by VK_VERSION_1_2
typedef struct VkSubpassBeginInfo {
VkStructureType      sType;
const void*          pNext;
VkSubpassContents    contents;
} VkSubpassBeginInfo;
• sType is the type of this structure.

• pNext is NULL or a pointer to a structure extending this structure.

• contents is a VkSubpassContents value specifying how the commands in the next subpass will be provided.

Valid Usage (Implicit)
• VUID-VkSubpassBeginInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO

• VUID-VkSubpassBeginInfo-pNext-pNext
pNext must be NULL

• VUID-VkSubpassBeginInfo-contents-parameter
contents must be a valid VkSubpassContents value

Possible values of vkCmdBeginRenderPass::contents, specifying how the commands in the first subpass will be provided, are:

// Provided by VK_VERSION_1_0
typedef enum VkSubpassContents {
VK_SUBPASS_CONTENTS_INLINE = 0,
VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1,
} VkSubpassContents;
• VK_SUBPASS_CONTENTS_INLINE specifies that the contents of the subpass will be recorded inline in the primary command buffer, and secondary command buffers must not be executed within the subpass.

• VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS specifies that the contents are recorded in secondary command buffers that will be called from the primary command buffer, and vkCmdExecuteCommands is the only valid command on the command buffer until vkCmdNextSubpass or vkCmdEndRenderPass.

If the pNext chain of VkRenderPassBeginInfo includes a VkDeviceGroupRenderPassBeginInfo structure, then that structure includes a device mask and set of render areas for the render pass instance.

The VkDeviceGroupRenderPassBeginInfo structure is defined as:

// Provided by VK_VERSION_1_1
typedef struct VkDeviceGroupRenderPassBeginInfo {
VkStructureType    sType;
const void*        pNext;
uint32_t           deviceRenderAreaCount;
const VkRect2D*    pDeviceRenderAreas;
} VkDeviceGroupRenderPassBeginInfo;
• sType is the type of this structure.

• pNext is NULL or a pointer to a structure extending this structure.

• deviceMask is the device mask for the render pass instance.

• deviceRenderAreaCount is the number of elements in the pDeviceRenderAreas array.

• pDeviceRenderAreas is a pointer to an array of VkRect2D structures defining the render area for each physical device.

The deviceMask serves several purposes. It is an upper bound on the set of physical devices that can be used during the render pass instance, and the initial device mask when the render pass instance begins. In addition, commands transitioning to the next subpass in the render pass instance and commands ending the render pass instance, and, accordingly render pass attachment load, store, and resolve operations and subpass dependencies corresponding to the render pass instance, are executed on the physical devices included in the device mask provided here.

If deviceRenderAreaCount is not zero, then the elements of pDeviceRenderAreas override the value of VkRenderPassBeginInfo::renderArea, and provide a render area specific to each physical device. These render areas serve the same purpose as VkRenderPassBeginInfo::renderArea, including controlling the region of attachments that are cleared by VK_ATTACHMENT_LOAD_OP_CLEAR and that are resolved into resolve attachments.

If this structure is not present, the render pass instance’s device mask is the value of VkDeviceGroupCommandBufferBeginInfo::deviceMask. If this structure is not present or if deviceRenderAreaCount is zero, VkRenderPassBeginInfo::renderArea is used for all physical devices.

Valid Usage
deviceMask must be a valid device mask value

deviceMask must not be zero

deviceMask must be a subset of the command buffer’s initial device mask

• VUID-VkDeviceGroupRenderPassBeginInfo-deviceRenderAreaCount-00908
deviceRenderAreaCount must either be zero or equal to the number of physical devices in the logical device

Valid Usage (Implicit)
• VUID-VkDeviceGroupRenderPassBeginInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO

• VUID-VkDeviceGroupRenderPassBeginInfo-pDeviceRenderAreas-parameter
If deviceRenderAreaCount is not 0, pDeviceRenderAreas must be a valid pointer to an array of deviceRenderAreaCount VkRect2D structures

The VkRenderPassAttachmentBeginInfo structure is defined as:

// Provided by VK_VERSION_1_2
typedef struct VkRenderPassAttachmentBeginInfo {
VkStructureType       sType;
const void*           pNext;
uint32_t              attachmentCount;
const VkImageView*    pAttachments;
} VkRenderPassAttachmentBeginInfo;
• sType is the type of this structure.

• pNext is NULL or a pointer to a structure extending this structure.

• attachmentCount is the number of attachments.

• pAttachments is a pointer to an array of VkImageView handles, each of which will be used as the corresponding attachment in the render pass instance.

Valid Usage
• VUID-VkRenderPassAttachmentBeginInfo-pAttachments-03218
Each element of pAttachments must only specify a single mip level

• VUID-VkRenderPassAttachmentBeginInfo-pAttachments-03219
Each element of pAttachments must have been created with the identity swizzle

• VUID-VkRenderPassAttachmentBeginInfo-pAttachments-04114
Each element of pAttachments must have been created with VkImageViewCreateInfo::viewType not equal to VK_IMAGE_VIEW_TYPE_3D

Valid Usage (Implicit)
• VUID-VkRenderPassAttachmentBeginInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO

• VUID-VkRenderPassAttachmentBeginInfo-pAttachments-parameter
If attachmentCount is not 0, pAttachments must be a valid pointer to an array of attachmentCount valid VkImageView handles

To query the render area granularity, call:

// Provided by VK_VERSION_1_0
void vkGetRenderAreaGranularity(
VkDevice                                    device,
VkRenderPass                                renderPass,
VkExtent2D*                                 pGranularity);
• device is the logical device that owns the render pass.

• renderPass is a handle to a render pass.

• pGranularity is a pointer to a VkExtent2D structure in which the granularity is returned.

The conditions leading to an optimal renderArea are:

• the offset.x member in renderArea is a multiple of the width member of the returned VkExtent2D (the horizontal granularity).

• the offset.y member in renderArea is a multiple of the height of the returned VkExtent2D (the vertical granularity).

• either the offset.width member in renderArea is a multiple of the horizontal granularity or offset.x+offset.width is equal to the width of the framebuffer in the VkRenderPassBeginInfo.

• either the offset.height member in renderArea is a multiple of the vertical granularity or offset.y+offset.height is equal to the height of the framebuffer in the VkRenderPassBeginInfo.

Subpass dependencies are not affected by the render area, and apply to the entire image subresources attached to the framebuffer as specified in the description of automatic layout transitions. Similarly, pipeline barriers are valid even if their effect extends outside the render area.

Valid Usage (Implicit)
• VUID-vkGetRenderAreaGranularity-device-parameter
device must be a valid VkDevice handle

• VUID-vkGetRenderAreaGranularity-renderPass-parameter
renderPass must be a valid VkRenderPass handle

• VUID-vkGetRenderAreaGranularity-pGranularity-parameter
pGranularity must be a valid pointer to a VkExtent2D structure

• VUID-vkGetRenderAreaGranularity-renderPass-parent
renderPass must have been created, allocated, or retrieved from device

To transition to the next subpass in the render pass instance after recording the commands for a subpass, call:

// Provided by VK_VERSION_1_0
void vkCmdNextSubpass(
VkCommandBuffer                             commandBuffer,
VkSubpassContents                           contents);
• commandBuffer is the command buffer in which to record the command.

• contents specifies how the commands in the next subpass will be provided, in the same fashion as the corresponding parameter of vkCmdBeginRenderPass.

The subpass index for a render pass begins at zero when vkCmdBeginRenderPass is recorded, and increments each time vkCmdNextSubpass is recorded.

Moving to the next subpass automatically performs any multisample resolve operations in the subpass being ended. End-of-subpass multisample resolves are treated as color attachment writes for the purposes of synchronization. This applies to resolve operations for both color and depth/stencil attachments. That is, they are considered to execute in the VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT pipeline stage and their writes are synchronized with VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT. Synchronization between rendering within a subpass and any resolve operations at the end of the subpass occurs automatically, without need for explicit dependencies or pipeline barriers. However, if the resolve attachment is also used in a different subpass, an explicit dependency is needed.

After transitioning to the next subpass, the application can record the commands for that subpass.

Valid Usage
• VUID-vkCmdNextSubpass-None-00909
The current subpass index must be less than the number of subpasses in the render pass minus one

Valid Usage (Implicit)
• VUID-vkCmdNextSubpass-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle

• VUID-vkCmdNextSubpass-contents-parameter
contents must be a valid VkSubpassContents value

• VUID-vkCmdNextSubpass-commandBuffer-recording
commandBuffer must be in the recording state

• VUID-vkCmdNextSubpass-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations

• VUID-vkCmdNextSubpass-renderpass
This command must only be called inside of a render pass instance

• VUID-vkCmdNextSubpass-bufferlevel
commandBuffer must be a primary VkCommandBuffer

Host Synchronization
• Host access to commandBuffer must be externally synchronized

• Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties
Command Buffer Levels Render Pass Scope Supported Queue Types Pipeline Type

Primary

Inside

Graphics

Graphics

To transition to the next subpass in the render pass instance after recording the commands for a subpass, call:

// Provided by VK_VERSION_1_2
void vkCmdNextSubpass2(
VkCommandBuffer                             commandBuffer,
const VkSubpassBeginInfo*                   pSubpassBeginInfo,
const VkSubpassEndInfo*                     pSubpassEndInfo);
• commandBuffer is the command buffer in which to record the command.

• pSubpassBeginInfo is a pointer to a VkSubpassBeginInfo structure containing information about the subpass which is about to begin rendering.

• pSubpassEndInfo is a pointer to a VkSubpassEndInfo structure containing information about how the previous subpass will be ended.

vkCmdNextSubpass2 is semantically identical to vkCmdNextSubpass, except that it is extensible, and that contents is provided as part of an extensible structure instead of as a flat parameter.

Valid Usage
• VUID-vkCmdNextSubpass2-None-03102
The current subpass index must be less than the number of subpasses in the render pass minus one

Valid Usage (Implicit)
• VUID-vkCmdNextSubpass2-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle

• VUID-vkCmdNextSubpass2-pSubpassBeginInfo-parameter
pSubpassBeginInfo must be a valid pointer to a valid VkSubpassBeginInfo structure

• VUID-vkCmdNextSubpass2-pSubpassEndInfo-parameter
pSubpassEndInfo must be a valid pointer to a valid VkSubpassEndInfo structure

• VUID-vkCmdNextSubpass2-commandBuffer-recording
commandBuffer must be in the recording state

• VUID-vkCmdNextSubpass2-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations

• VUID-vkCmdNextSubpass2-renderpass
This command must only be called inside of a render pass instance

• VUID-vkCmdNextSubpass2-bufferlevel
commandBuffer must be a primary VkCommandBuffer

Host Synchronization
• Host access to commandBuffer must be externally synchronized

• Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties
Command Buffer Levels Render Pass Scope Supported Queue Types Pipeline Type

Primary

Inside

Graphics

Graphics

To record a command to end a render pass instance after recording the commands for the last subpass, call:

// Provided by VK_VERSION_1_0
void vkCmdEndRenderPass(
VkCommandBuffer                             commandBuffer);
• commandBuffer is the command buffer in which to end the current render pass instance.

Ending a render pass instance performs any multisample resolve operations on the final subpass.

Valid Usage
• VUID-vkCmdEndRenderPass-None-00910
The current subpass index must be equal to the number of subpasses in the render pass minus one

Valid Usage (Implicit)
• VUID-vkCmdEndRenderPass-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle

• VUID-vkCmdEndRenderPass-commandBuffer-recording
commandBuffer must be in the recording state

• VUID-vkCmdEndRenderPass-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations

• VUID-vkCmdEndRenderPass-renderpass
This command must only be called inside of a render pass instance

• VUID-vkCmdEndRenderPass-bufferlevel
commandBuffer must be a primary VkCommandBuffer

Host Synchronization
• Host access to commandBuffer must be externally synchronized

• Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties
Command Buffer Levels Render Pass Scope Supported Queue Types Pipeline Type

Primary

Inside

Graphics

Graphics

To record a command to end a render pass instance after recording the commands for the last subpass, call:

// Provided by VK_VERSION_1_2
void vkCmdEndRenderPass2(
VkCommandBuffer                             commandBuffer,
const VkSubpassEndInfo*                     pSubpassEndInfo);
• commandBuffer is the command buffer in which to end the current render pass instance.

• pSubpassEndInfo is a pointer to a VkSubpassEndInfo structure containing information about how the previous subpass will be ended.

vkCmdEndRenderPass2 is semantically identical to vkCmdEndRenderPass, except that it is extensible.

Valid Usage
• VUID-vkCmdEndRenderPass2-None-03103
The current subpass index must be equal to the number of subpasses in the render pass minus one

Valid Usage (Implicit)
• VUID-vkCmdEndRenderPass2-commandBuffer-parameter
commandBuffer must be a valid VkCommandBuffer handle

• VUID-vkCmdEndRenderPass2-pSubpassEndInfo-parameter
pSubpassEndInfo must be a valid pointer to a valid VkSubpassEndInfo structure

• VUID-vkCmdEndRenderPass2-commandBuffer-recording
commandBuffer must be in the recording state

• VUID-vkCmdEndRenderPass2-commandBuffer-cmdpool
The VkCommandPool that commandBuffer was allocated from must support graphics operations

• VUID-vkCmdEndRenderPass2-renderpass
This command must only be called inside of a render pass instance

• VUID-vkCmdEndRenderPass2-bufferlevel
commandBuffer must be a primary VkCommandBuffer

Host Synchronization
• Host access to commandBuffer must be externally synchronized

• Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties
Command Buffer Levels Render Pass Scope Supported Queue Types Pipeline Type

Primary

Inside

Graphics

Graphics

The VkSubpassEndInfo structure is defined as:

// Provided by VK_VERSION_1_2
typedef struct VkSubpassEndInfo {
VkStructureType    sType;
const void*        pNext;
} VkSubpassEndInfo;
• sType is the type of this structure.

• pNext is NULL or a pointer to a structure extending this structure.

Valid Usage (Implicit)
• VUID-VkSubpassEndInfo-sType-sType
sType must be VK_STRUCTURE_TYPE_SUBPASS_END_INFO

• VUID-VkSubpassEndInfo-pNext-pNext
pNext must be NULL