Safe Haskell	None
Language	Haskell2010

Graphics.Vulkan.Core10.Pass

Synopsis

Documentation

newtype VkAttachmentLoadOp Source #

VkAttachmentLoadOp - Specify how contents of an attachment are treated at the beginning of a subpass

Description

VkFramebufferCreateFlags is a bitmask type for setting a mask, but is currently reserved for future use.

Description

VkRenderPassCreateFlags is a bitmask type for setting a mask, but is currently reserved for future use.

Description

VK_ACCESS_INDIRECT_COMMAND_READ_BIT specifies read access to an indirect command structure read as part of an indirect drawing or dispatch command.

VK_ACCESS_INDEX_READ_BIT specifies read access to an index buffer as part of an indexed drawing command, bound by vkCmdBindIndexBuffer.
VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT specifies read access to a vertex buffer as part of a drawing command, bound by vkCmdBindVertexBuffers.
VK_ACCESS_UNIFORM_READ_BIT specifies read access to a uniform buffer.
VK_ACCESS_INPUT_ATTACHMENT_READ_BIT specifies read access to an input attachment within a render pass during fragment shading.
VK_ACCESS_SHADER_READ_BIT specifies read access to a storage buffer, uniform texel buffer, storage texel buffer, sampled image, or storage image.
VK_ACCESS_SHADER_WRITE_BIT specifies write access to a storage buffer, storage texel buffer, or storage image.
VK_ACCESS_COLOR_ATTACHMENT_READ_BIT specifies read access to a color attachment, such as via blending, logic operations, or via certain subpass load operations. It does not include advanced blend operations.
VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT is similar to VK_ACCESS_COLOR_ATTACHMENT_READ_BIT, but also includes advanced blend operations.
VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT specifies write access to a color or resolve attachment during a render pass or via certain subpass load and store operations.
VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT specifies read access to a depth/stencil attachment, via depth or stencil operations or via certain subpass load operations.
VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT specifies write access to a depth/stencil attachment, via depth or stencil operations or via certain subpass load and store operations.
VK_ACCESS_TRANSFER_READ_BIT specifies read access to an image or buffer in a copy operation.
VK_ACCESS_TRANSFER_WRITE_BIT specifies write access to an image or buffer in a clear or copy operation.
VK_ACCESS_HOST_READ_BIT specifies read access by a host operation. Accesses of this type are not performed through a resource, but directly on memory.
VK_ACCESS_HOST_WRITE_BIT specifies write access by a host operation. Accesses of this type are not performed through a resource, but directly on memory.
VK_ACCESS_MEMORY_READ_BIT specifies read access via non-specific entities. These entities include the Vulkan device and host, but may also include entities external to the Vulkan device or otherwise not part of the core Vulkan pipeline. When included in a destination access mask, makes all available writes visible to all future read accesses on entities known to the Vulkan device.
VK_ACCESS_MEMORY_WRITE_BIT specifies write access via non-specific entities. These entities include the Vulkan device and host, but may also include entities external to the Vulkan device or otherwise not part of the core Vulkan pipeline. When included in a source access mask, all writes that are performed by entities known to the Vulkan device are made available. When included in a destination access mask, makes all available writes visible to all future write accesses on entities known to the Vulkan device.
VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX specifies reads from VkBuffer inputs to vkCmdProcessCommandsNVX.
VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX specifies writes to the target command buffer in vkCmdProcessCommandsNVX.

Certain access types are only performed by a subset of pipeline stages. Any synchronization command that takes both stage masks and access masks uses both to define the access scopes - only the specified access types performed by the specified stages are included in the access scope. An application must not specify an access flag in a synchronization command if it does not include a pipeline stage in the corresponding stage mask that is able to perform accesses of that type. The following table lists, for each access flag, which pipeline stages can perform that type of access.

+-----------------------------------+-----------------------------------+
| Access flag                       | Supported pipeline stages         |
+===================================+===================================+
| @VK_ACCESS_INDIRECT_COMMAND_READ_ | @VK_PIPELINE_STAGE_DRAW_INDIRECT_ |
| BIT@                              | BIT@                              |
+-----------------------------------+-----------------------------------+
| @VK_ACCESS_INDEX_READ_BIT@        | @VK_PIPELINE_STAGE_VERTEX_INPUT_B |
|                                   | IT@                               |
+-----------------------------------+-----------------------------------+
| @VK_ACCESS_VERTEX_ATTRIBUTE_READ_ | @VK_PIPELINE_STAGE_VERTEX_INPUT_B |
| BIT@                              | IT@                               |
+-----------------------------------+-----------------------------------+
| @VK_ACCESS_UNIFORM_READ_BIT@      | @VK_PIPELINE_STAGE_VERTEX_SHADER_ |
|                                   | BIT@,                             |
|                                   | @VK_PIPELINE_STAGE_TESSELLATION_C |
|                                   | ONTROL_SHADER_BIT@,               |
|                                   | @VK_PIPELINE_STAGE_TESSELLATION_E |
|                                   | VALUATION_SHADER_BIT@,            |
|                                   | @VK_PIPELINE_STAGE_GEOMETRY_SHADE |
|                                   | R_BIT@,                           |
|                                   | @VK_PIPELINE_STAGE_FRAGMENT_SHADE |
|                                   | R_BIT@,                           |
|                                   | or                                |
|                                   | @VK_PIPELINE_STAGE_COMPUTE_SHADER |
|                                   | _BIT@                             |
+-----------------------------------+-----------------------------------+
| @VK_ACCESS_INPUT_ATTACHMENT_READ_ | @VK_PIPELINE_STAGE_FRAGMENT_SHADE |
| BIT@                              | R_BIT@                            |
+-----------------------------------+-----------------------------------+
| @VK_ACCESS_SHADER_READ_BIT@       | @VK_PIPELINE_STAGE_VERTEX_SHADER_ |
|                                   | BIT@,                             |
|                                   | @VK_PIPELINE_STAGE_TESSELLATION_C |
|                                   | ONTROL_SHADER_BIT@,               |
|                                   | @VK_PIPELINE_STAGE_TESSELLATION_E |
|                                   | VALUATION_SHADER_BIT@,            |
|                                   | @VK_PIPELINE_STAGE_GEOMETRY_SHADE |
|                                   | R_BIT@,                           |
|                                   | @VK_PIPELINE_STAGE_FRAGMENT_SHADE |
|                                   | R_BIT@,                           |
|                                   | or                                |
|                                   | @VK_PIPELINE_STAGE_COMPUTE_SHADER |
|                                   | _BIT@                             |
+-----------------------------------+-----------------------------------+
| @VK_ACCESS_SHADER_WRITE_BIT@      | @VK_PIPELINE_STAGE_VERTEX_SHADER_ |
|                                   | BIT@,                             |
|                                   | @VK_PIPELINE_STAGE_TESSELLATION_C |
|                                   | ONTROL_SHADER_BIT@,               |
|                                   | @VK_PIPELINE_STAGE_TESSELLATION_E |
|                                   | VALUATION_SHADER_BIT@,            |
|                                   | @VK_PIPELINE_STAGE_GEOMETRY_SHADE |
|                                   | R_BIT@,                           |
|                                   | @VK_PIPELINE_STAGE_FRAGMENT_SHADE |
|                                   | R_BIT@,                           |
|                                   | or                                |
|                                   | @VK_PIPELINE_STAGE_COMPUTE_SHADER |
|                                   | _BIT@                             |
+-----------------------------------+-----------------------------------+
| @VK_ACCESS_COLOR_ATTACHMENT_READ_ | @VK_PIPELINE_STAGE_COLOR_ATTACHME |
| BIT@                              | NT_OUTPUT_BIT@                    |
+-----------------------------------+-----------------------------------+
| @VK_ACCESS_COLOR_ATTACHMENT_READ_ | @VK_PIPELINE_STAGE_COLOR_ATTACHME |
| NONCOHERENT_BIT_EXT@              | NT_OUTPUT_BIT@                    |
+-----------------------------------+-----------------------------------+
| @VK_ACCESS_COLOR_ATTACHMENT_WRITE | @VK_PIPELINE_STAGE_COLOR_ATTACHME |
| _BIT@                             | NT_OUTPUT_BIT@                    |
+-----------------------------------+-----------------------------------+
| @VK_ACCESS_DEPTH_STENCIL_ATTACHME | @VK_PIPELINE_STAGE_EARLY_FRAGMENT |
| NT_READ_BIT@                      | _TESTS_BIT@,                      |
|                                   | or                                |
|                                   | @VK_PIPELINE_STAGE_LATE_FRAGMENT_ |
|                                   | TESTS_BIT@                        |
+-----------------------------------+-----------------------------------+
| @VK_ACCESS_DEPTH_STENCIL_ATTACHME | @VK_PIPELINE_STAGE_EARLY_FRAGMENT |
| NT_WRITE_BIT@                     | _TESTS_BIT@,                      |
|                                   | or                                |
|                                   | @VK_PIPELINE_STAGE_LATE_FRAGMENT_ |
|                                   | TESTS_BIT@                        |
+-----------------------------------+-----------------------------------+
| @VK_ACCESS_TRANSFER_READ_BIT@     | @VK_PIPELINE_STAGE_TRANSFER_BIT@  |
+-----------------------------------+-----------------------------------+
| @VK_ACCESS_TRANSFER_WRITE_BIT@    | @VK_PIPELINE_STAGE_TRANSFER_BIT@  |
+-----------------------------------+-----------------------------------+
| @VK_ACCESS_HOST_READ_BIT@         | @VK_PIPELINE_STAGE_HOST_BIT@      |
+-----------------------------------+-----------------------------------+
| @VK_ACCESS_HOST_WRITE_BIT@        | @VK_PIPELINE_STAGE_HOST_BIT@      |
+-----------------------------------+-----------------------------------+
| @VK_ACCESS_MEMORY_READ_BIT@       | N\/A                              |
+-----------------------------------+-----------------------------------+
| @VK_ACCESS_MEMORY_WRITE_BIT@      | N\/A                              |
+-----------------------------------+-----------------------------------+
| @VK_ACCESS_COMMAND_PROCESS_READ_B | @VK_PIPELINE_STAGE_COMMAND_PROCES |
| IT_NVX@                           | S_BIT_NVX@                        |
+-----------------------------------+-----------------------------------+
| @VK_ACCESS_COMMAND_PROCESS_WRITE_ | @VK_PIPELINE_STAGE_COMMAND_PROCES |
| BIT_NVX@                          | S_BIT_NVX@                        |
+-----------------------------------+-----------------------------------+

Supported access types

If a memory object does not have the VK_MEMORY_PROPERTY_HOST_COHERENT_BIT property, then vkFlushMappedMemoryRanges must be called in order to guarantee that writes to the memory object from the host are made visible to the VK_ACCESS_HOST_WRITE_BIT access type, where it can be further made available to the device by synchronization commands. Similarly, vkInvalidateMappedMemoryRanges must be called to guarantee that writes which are visible to the VK_ACCESS_HOST_READ_BIT access type are made visible to host operations.

If the memory object does have the VK_MEMORY_PROPERTY_HOST_COHERENT_BIT property flag, writes to the memory object from the host are automatically made visible to the VK_ACCESS_HOST_WRITE_BIT access type. Similarly, writes made visible to the VK_ACCESS_HOST_READ_BIT access type are automatically made visible to the host.

Note

The vkQueueSubmit command automatically guarantees that host writes flushed to VK_ACCESS_HOST_WRITE_BIT are made available if they were flushed before the command executed, so in most cases an explicit memory barrier is not needed for this case. In the few circumstances where a submit does not occur between the host write and the device read access, writes can be made available by using an explicit memory barrier.

Description

Parameters

device is the logical device that creates the framebuffer.

pCreateInfo points to a VkFramebufferCreateInfo structure which describes additional information about framebuffer creation.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.
pFramebuffer points to a VkFramebuffer handle in which the resulting framebuffer object is returned.

Description

Valid Usage (Implicit)

device must be a valid VkDevice handle

pCreateInfo must be a valid pointer to a valid VkFramebufferCreateInfo structure
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
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
```

Parameters

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.

Description

Valid Usage

All submitted commands that refer to framebuffer must have completed execution

If VkAllocationCallbacks were provided when framebuffer was created, a compatible set of callbacks must be provided here
If no VkAllocationCallbacks were provided when framebuffer was created, pAllocator must be NULL

Valid Usage (Implicit)

device must be a valid VkDevice handle

If framebuffer is not VK_NULL_HANDLE, framebuffer must be a valid VkFramebuffer handle
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
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

Parameters

device is the logical device that creates the render pass.

pCreateInfo is a pointer to an instance of the VkRenderPassCreateInfo structure that describes the parameters of the render pass.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.
pRenderPass points to a VkRenderPass handle in which the resulting render pass object is returned.

Description

Valid Usage (Implicit)

device must be a valid VkDevice handle

pCreateInfo must be a valid pointer to a valid VkRenderPassCreateInfo structure
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
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
```

Parameters

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.

Description

Valid Usage

All submitted commands that refer to renderPass must have completed execution

If VkAllocationCallbacks were provided when renderPass was created, a compatible set of callbacks must be provided here
If no VkAllocationCallbacks were provided when renderPass was created, pAllocator must be NULL

Valid Usage (Implicit)

device must be a valid VkDevice handle

If renderPass is not VK_NULL_HANDLE, renderPass must be a valid VkRenderPass handle
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
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

Parameters

device is the logical device that owns the render pass.

renderPass is a handle to a render pass.
pGranularity points to a VkExtent2D structure in which the granularity is returned.

Description

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)

device must be a valid VkDevice handle

renderPass must be a valid VkRenderPass handle
pGranularity must be a valid pointer to a VkExtent2D structure
renderPass must have been created, allocated, or retrieved from device

Description

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.

Valid Usage

finalLayout must not be VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED

Valid Usage (Implicit)

flags must be a valid combination of VkAttachmentDescriptionFlagBits values

format must be a valid VkFormat value
samples must be a valid VkSampleCountFlagBits value
loadOp must be a valid VkAttachmentLoadOp value
storeOp must be a valid VkAttachmentStoreOp value
stencilLoadOp must be a valid VkAttachmentLoadOp value
stencilStoreOp must be a valid VkAttachmentStoreOp value
initialLayout must be a valid VkImageLayout value
finalLayout must be a valid VkImageLayout value

Description

Valid Usage

layout must not be VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED

Valid Usage (Implicit)

layout must be a valid VkImageLayout value

Description

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

pipelineBindPoint must be VK_PIPELINE_BIND_POINT_GRAPHICS

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
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
If pResolveAttachments is not NULL, the sample count of each element of pColorAttachments must be anything other than VK_SAMPLE_COUNT_1_BIT
Each element of pResolveAttachments must have a sample count of VK_SAMPLE_COUNT_1_BIT
Each element of pResolveAttachments must have the same VkFormat as its corresponding color attachment
All attachments in pColorAttachments that are not VK_ATTACHMENT_UNUSED must have the same sample count
All attachments in pColorAttachments that are not VK_ATTACHMENT_UNUSED must have a sample count that is smaller than or equal to the sample count of pDepthStencilAttachment if it is not VK_ATTACHMENT_UNUSED
If any input attachments are VK_ATTACHMENT_UNUSED, then any pipelines bound during the subpass must not access those input attachments from the fragment shader
The attachment member of each element of pPreserveAttachments must not be VK_ATTACHMENT_UNUSED
Each element of pPreserveAttachments must not also be an element of any other member of the subpass description
If any attachment is used as both an input attachment and a color or depth/stencil attachment, then each use must use the same layout
If flags includes VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX, it must also include VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX.

Valid Usage (Implicit)

flags must be a valid combination of VkSubpassDescriptionFlagBits values

pipelineBindPoint must be a valid VkPipelineBindPoint value
If inputAttachmentCount is not 0, pInputAttachments must be a valid pointer to an array of inputAttachmentCount valid VkAttachmentReference structures
If colorAttachmentCount is not 0, pColorAttachments must be a valid pointer to an array of colorAttachmentCount valid VkAttachmentReference structures
If colorAttachmentCount is not 0, and pResolveAttachments is not NULL, pResolveAttachments must be a valid pointer to an array of colorAttachmentCount valid VkAttachmentReference structures
If pDepthStencilAttachment is not NULL, pDepthStencilAttachment must be a valid pointer to a valid VkAttachmentReference structure
If preserveAttachmentCount is not 0, pPreserveAttachments must be a valid pointer to an array of preserveAttachmentCount uint32_t values

Description

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/dstAccessMask parameters) submitted as a part of a vkCmdPipelineBarrier (with matching srcStageMask/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 an 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 srcSubpass is not VK_SUBPASS_EXTERNAL, srcStageMask must not include VK_PIPELINE_STAGE_HOST_BIT

If dstSubpass is not VK_SUBPASS_EXTERNAL, dstStageMask must not include VK_PIPELINE_STAGE_HOST_BIT
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
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
srcSubpass and dstSubpass must not both be equal to VK_SUBPASS_EXTERNAL
If srcSubpass is equal to dstSubpass, srcStageMask and dstStageMask must only contain one of VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT, VK_PIPELINE_STAGE_VERTEX_INPUT_BIT, VK_PIPELINE_STAGE_VERTEX_SHADER_BIT, VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT, VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT, VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT, VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, or VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT
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.
If dependencyFlags includes VK_DEPENDENCY_VIEW_LOCAL_BIT, then both srcSubpass and dstSubpass must not equal VK_SUBPASS_EXTERNAL
If dependencyFlags includes VK_DEPENDENCY_VIEW_LOCAL_BIT, then the render pass must have multiview enabled
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

srcStageMask must not be 0
dstStageMask must be a valid combination of VkPipelineStageFlagBits values
dstStageMask must not be 0
srcAccessMask must be a valid combination of VkAccessFlagBits values
dstAccessMask must be a valid combination of VkAccessFlagBits values
dependencyFlags must be a valid combination of VkDependencyFlagBits values

Description

Valid Usage

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

If the attachment member of any element of pInputAttachments, pColorAttachments, pResolveAttachments or pDepthStencilAttachment, or the attachment indexed by any element of pPreserveAttachments in any 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 VkAttachmentDescription structures describing them must include VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT in flags
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
The value of each element of the pPreserveAttachments member in each element of pSubpasses must not be VK_ATTACHMENT_UNUSED
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.
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.
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.
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.
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 source subpass.

Valid Usage (Implicit)

sType must be VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO

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
Each sType member in the pNext chain must be unique
flags must be 0
If attachmentCount is not 0, pAttachments must be a valid pointer to an array of attachmentCount valid VkAttachmentDescription structures
pSubpasses must be a valid pointer to an array of subpassCount valid VkSubpassDescription structures
If dependencyCount is not 0, pDependencies must be a valid pointer to an array of dependencyCount valid VkSubpassDependency structures
subpassCount must be greater than 0

Description

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.

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 this case 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, and rather 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 a given zero-attachment subpass must have the same value for VkPipelineMultisampleStateCreateInfo::rasterizationSamples.

Valid Usage

attachmentCount must be equal to the attachment count specified in renderPass

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
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
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
Each element of pAttachments must have been created with an VkFormat value that matches the VkFormat specified by the corresponding VkAttachmentDescription in renderPass
Each element of pAttachments must have been created with a samples value that matches the samples value specified by the corresponding VkAttachmentDescription in renderPass
Each element of pAttachments must have dimensions at least as large as the corresponding framebuffer dimension
Each element of pAttachments must only specify a single mip level
Each element of pAttachments must have been created with the identity swizzle
width must be greater than 0.
width must be less than or equal to VkPhysicalDeviceLimits::maxFramebufferWidth
height must be greater than 0.
height must be less than or equal to VkPhysicalDeviceLimits::maxFramebufferHeight
layers must be greater than 0.
layers must be less than or equal to VkPhysicalDeviceLimits::maxFramebufferLayers
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

Valid Usage (Implicit)

sType must be VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO

pNext must be NULL
flags must be 0
renderPass must be a valid VkRenderPass handle
If attachmentCount is not 0, pAttachments must be a valid pointer to an array of attachmentCount valid VkImageView handles
Both of renderPass, and the elements of pAttachments that are valid handles must have been created, allocated, or retrieved from the same VkDevice

Description

VkAccessFlags is a bitmask type for setting a mask of zero or more VkAccessFlagBits.

Description

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

Description

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

Description

VkDependencyFlags is a bitmask type for setting a mask of zero or more VkDependencyFlagBits.

Eq VkAttachmentLoadOp Source #
Methods (==) :: VkAttachmentLoadOp -> VkAttachmentLoadOp -> Bool # (/=) :: VkAttachmentLoadOp -> VkAttachmentLoadOp -> Bool #
Ord VkAttachmentLoadOp Source #
Methods compare :: VkAttachmentLoadOp -> VkAttachmentLoadOp -> Ordering # (<) :: VkAttachmentLoadOp -> VkAttachmentLoadOp -> Bool # (<=) :: VkAttachmentLoadOp -> VkAttachmentLoadOp -> Bool # (>) :: VkAttachmentLoadOp -> VkAttachmentLoadOp -> Bool # (>=) :: VkAttachmentLoadOp -> VkAttachmentLoadOp -> Bool # max :: VkAttachmentLoadOp -> VkAttachmentLoadOp -> VkAttachmentLoadOp # min :: VkAttachmentLoadOp -> VkAttachmentLoadOp -> VkAttachmentLoadOp #
Read VkAttachmentLoadOp Source #
Methods readsPrec :: Int -> ReadS VkAttachmentLoadOp # readList :: ReadS [VkAttachmentLoadOp] # readPrec :: ReadPrec VkAttachmentLoadOp # readListPrec :: ReadPrec [VkAttachmentLoadOp] #
Show VkAttachmentLoadOp Source #
Methods showsPrec :: Int -> VkAttachmentLoadOp -> ShowS # show :: VkAttachmentLoadOp -> String # showList :: [VkAttachmentLoadOp] -> ShowS #
Storable VkAttachmentLoadOp Source #
Methods sizeOf :: VkAttachmentLoadOp -> Int # alignment :: VkAttachmentLoadOp -> Int # peekElemOff :: Ptr VkAttachmentLoadOp -> Int -> IO VkAttachmentLoadOp # pokeElemOff :: Ptr VkAttachmentLoadOp -> Int -> VkAttachmentLoadOp -> IO () # peekByteOff :: Ptr b -> Int -> IO VkAttachmentLoadOp # pokeByteOff :: Ptr b -> Int -> VkAttachmentLoadOp -> IO () # peek :: Ptr VkAttachmentLoadOp -> IO VkAttachmentLoadOp # poke :: Ptr VkAttachmentLoadOp -> VkAttachmentLoadOp -> IO () #

Eq VkAttachmentStoreOp Source #
Methods (==) :: VkAttachmentStoreOp -> VkAttachmentStoreOp -> Bool # (/=) :: VkAttachmentStoreOp -> VkAttachmentStoreOp -> Bool #
Ord VkAttachmentStoreOp Source #
Methods compare :: VkAttachmentStoreOp -> VkAttachmentStoreOp -> Ordering # (<) :: VkAttachmentStoreOp -> VkAttachmentStoreOp -> Bool # (<=) :: VkAttachmentStoreOp -> VkAttachmentStoreOp -> Bool # (>) :: VkAttachmentStoreOp -> VkAttachmentStoreOp -> Bool # (>=) :: VkAttachmentStoreOp -> VkAttachmentStoreOp -> Bool # max :: VkAttachmentStoreOp -> VkAttachmentStoreOp -> VkAttachmentStoreOp # min :: VkAttachmentStoreOp -> VkAttachmentStoreOp -> VkAttachmentStoreOp #
Read VkAttachmentStoreOp Source #
Methods readsPrec :: Int -> ReadS VkAttachmentStoreOp # readList :: ReadS [VkAttachmentStoreOp] # readPrec :: ReadPrec VkAttachmentStoreOp # readListPrec :: ReadPrec [VkAttachmentStoreOp] #
Show VkAttachmentStoreOp Source #
Methods showsPrec :: Int -> VkAttachmentStoreOp -> ShowS # show :: VkAttachmentStoreOp -> String # showList :: [VkAttachmentStoreOp] -> ShowS #
Storable VkAttachmentStoreOp Source #
Methods sizeOf :: VkAttachmentStoreOp -> Int # alignment :: VkAttachmentStoreOp -> Int # peekElemOff :: Ptr VkAttachmentStoreOp -> Int -> IO VkAttachmentStoreOp # pokeElemOff :: Ptr VkAttachmentStoreOp -> Int -> VkAttachmentStoreOp -> IO () # peekByteOff :: Ptr b -> Int -> IO VkAttachmentStoreOp # pokeByteOff :: Ptr b -> Int -> VkAttachmentStoreOp -> IO () # peek :: Ptr VkAttachmentStoreOp -> IO VkAttachmentStoreOp # poke :: Ptr VkAttachmentStoreOp -> VkAttachmentStoreOp -> IO () #

Eq VkPipelineBindPoint Source #
Methods (==) :: VkPipelineBindPoint -> VkPipelineBindPoint -> Bool # (/=) :: VkPipelineBindPoint -> VkPipelineBindPoint -> Bool #
Ord VkPipelineBindPoint Source #
Methods compare :: VkPipelineBindPoint -> VkPipelineBindPoint -> Ordering # (<) :: VkPipelineBindPoint -> VkPipelineBindPoint -> Bool # (<=) :: VkPipelineBindPoint -> VkPipelineBindPoint -> Bool # (>) :: VkPipelineBindPoint -> VkPipelineBindPoint -> Bool # (>=) :: VkPipelineBindPoint -> VkPipelineBindPoint -> Bool # max :: VkPipelineBindPoint -> VkPipelineBindPoint -> VkPipelineBindPoint # min :: VkPipelineBindPoint -> VkPipelineBindPoint -> VkPipelineBindPoint #
Read VkPipelineBindPoint Source #
Methods readsPrec :: Int -> ReadS VkPipelineBindPoint # readList :: ReadS [VkPipelineBindPoint] # readPrec :: ReadPrec VkPipelineBindPoint # readListPrec :: ReadPrec [VkPipelineBindPoint] #
Show VkPipelineBindPoint Source #
Methods showsPrec :: Int -> VkPipelineBindPoint -> ShowS # show :: VkPipelineBindPoint -> String # showList :: [VkPipelineBindPoint] -> ShowS #
Storable VkPipelineBindPoint Source #
Methods sizeOf :: VkPipelineBindPoint -> Int # alignment :: VkPipelineBindPoint -> Int # peekElemOff :: Ptr VkPipelineBindPoint -> Int -> IO VkPipelineBindPoint # pokeElemOff :: Ptr VkPipelineBindPoint -> Int -> VkPipelineBindPoint -> IO () # peekByteOff :: Ptr b -> Int -> IO VkPipelineBindPoint # pokeByteOff :: Ptr b -> Int -> VkPipelineBindPoint -> IO () # peek :: Ptr VkPipelineBindPoint -> IO VkPipelineBindPoint # poke :: Ptr VkPipelineBindPoint -> VkPipelineBindPoint -> IO () #

Eq VkFramebufferCreateFlags Source #
Methods (==) :: VkFramebufferCreateFlags -> VkFramebufferCreateFlags -> Bool # (/=) :: VkFramebufferCreateFlags -> VkFramebufferCreateFlags -> Bool #
Ord VkFramebufferCreateFlags Source #
Methods compare :: VkFramebufferCreateFlags -> VkFramebufferCreateFlags -> Ordering # (<) :: VkFramebufferCreateFlags -> VkFramebufferCreateFlags -> Bool # (<=) :: VkFramebufferCreateFlags -> VkFramebufferCreateFlags -> Bool # (>) :: VkFramebufferCreateFlags -> VkFramebufferCreateFlags -> Bool # (>=) :: VkFramebufferCreateFlags -> VkFramebufferCreateFlags -> Bool # max :: VkFramebufferCreateFlags -> VkFramebufferCreateFlags -> VkFramebufferCreateFlags # min :: VkFramebufferCreateFlags -> VkFramebufferCreateFlags -> VkFramebufferCreateFlags #
Read VkFramebufferCreateFlags Source #
Methods readsPrec :: Int -> ReadS VkFramebufferCreateFlags # readList :: ReadS [VkFramebufferCreateFlags] # readPrec :: ReadPrec VkFramebufferCreateFlags # readListPrec :: ReadPrec [VkFramebufferCreateFlags] #
Show VkFramebufferCreateFlags Source #
Methods showsPrec :: Int -> VkFramebufferCreateFlags -> ShowS # show :: VkFramebufferCreateFlags -> String # showList :: [VkFramebufferCreateFlags] -> ShowS #
Storable VkFramebufferCreateFlags Source #
Methods sizeOf :: VkFramebufferCreateFlags -> Int # alignment :: VkFramebufferCreateFlags -> Int # peekElemOff :: Ptr VkFramebufferCreateFlags -> Int -> IO VkFramebufferCreateFlags # pokeElemOff :: Ptr VkFramebufferCreateFlags -> Int -> VkFramebufferCreateFlags -> IO () # peekByteOff :: Ptr b -> Int -> IO VkFramebufferCreateFlags # pokeByteOff :: Ptr b -> Int -> VkFramebufferCreateFlags -> IO () # peek :: Ptr VkFramebufferCreateFlags -> IO VkFramebufferCreateFlags # poke :: Ptr VkFramebufferCreateFlags -> VkFramebufferCreateFlags -> IO () #
Bits VkFramebufferCreateFlags Source #
Methods (.&.) :: VkFramebufferCreateFlags -> VkFramebufferCreateFlags -> VkFramebufferCreateFlags # (.\|.) :: VkFramebufferCreateFlags -> VkFramebufferCreateFlags -> VkFramebufferCreateFlags # xor :: VkFramebufferCreateFlags -> VkFramebufferCreateFlags -> VkFramebufferCreateFlags # complement :: VkFramebufferCreateFlags -> VkFramebufferCreateFlags # shift :: VkFramebufferCreateFlags -> Int -> VkFramebufferCreateFlags # rotate :: VkFramebufferCreateFlags -> Int -> VkFramebufferCreateFlags # zeroBits :: VkFramebufferCreateFlags # bit :: Int -> VkFramebufferCreateFlags # setBit :: VkFramebufferCreateFlags -> Int -> VkFramebufferCreateFlags # clearBit :: VkFramebufferCreateFlags -> Int -> VkFramebufferCreateFlags # complementBit :: VkFramebufferCreateFlags -> Int -> VkFramebufferCreateFlags # testBit :: VkFramebufferCreateFlags -> Int -> Bool # bitSizeMaybe :: VkFramebufferCreateFlags -> Maybe Int # bitSize :: VkFramebufferCreateFlags -> Int # isSigned :: VkFramebufferCreateFlags -> Bool # shiftL :: VkFramebufferCreateFlags -> Int -> VkFramebufferCreateFlags # unsafeShiftL :: VkFramebufferCreateFlags -> Int -> VkFramebufferCreateFlags # shiftR :: VkFramebufferCreateFlags -> Int -> VkFramebufferCreateFlags # unsafeShiftR :: VkFramebufferCreateFlags -> Int -> VkFramebufferCreateFlags # rotateL :: VkFramebufferCreateFlags -> Int -> VkFramebufferCreateFlags # rotateR :: VkFramebufferCreateFlags -> Int -> VkFramebufferCreateFlags # popCount :: VkFramebufferCreateFlags -> Int #
FiniteBits VkFramebufferCreateFlags Source #
Methods finiteBitSize :: VkFramebufferCreateFlags -> Int # countLeadingZeros :: VkFramebufferCreateFlags -> Int # countTrailingZeros :: VkFramebufferCreateFlags -> Int #

Eq VkRenderPassCreateFlags Source #
Methods (==) :: VkRenderPassCreateFlags -> VkRenderPassCreateFlags -> Bool # (/=) :: VkRenderPassCreateFlags -> VkRenderPassCreateFlags -> Bool #
Ord VkRenderPassCreateFlags Source #
Methods compare :: VkRenderPassCreateFlags -> VkRenderPassCreateFlags -> Ordering # (<) :: VkRenderPassCreateFlags -> VkRenderPassCreateFlags -> Bool # (<=) :: VkRenderPassCreateFlags -> VkRenderPassCreateFlags -> Bool # (>) :: VkRenderPassCreateFlags -> VkRenderPassCreateFlags -> Bool # (>=) :: VkRenderPassCreateFlags -> VkRenderPassCreateFlags -> Bool # max :: VkRenderPassCreateFlags -> VkRenderPassCreateFlags -> VkRenderPassCreateFlags # min :: VkRenderPassCreateFlags -> VkRenderPassCreateFlags -> VkRenderPassCreateFlags #
Read VkRenderPassCreateFlags Source #
Methods readsPrec :: Int -> ReadS VkRenderPassCreateFlags # readList :: ReadS [VkRenderPassCreateFlags] # readPrec :: ReadPrec VkRenderPassCreateFlags # readListPrec :: ReadPrec [VkRenderPassCreateFlags] #
Show VkRenderPassCreateFlags Source #
Methods showsPrec :: Int -> VkRenderPassCreateFlags -> ShowS # show :: VkRenderPassCreateFlags -> String # showList :: [VkRenderPassCreateFlags] -> ShowS #
Storable VkRenderPassCreateFlags Source #
Methods sizeOf :: VkRenderPassCreateFlags -> Int # alignment :: VkRenderPassCreateFlags -> Int # peekElemOff :: Ptr VkRenderPassCreateFlags -> Int -> IO VkRenderPassCreateFlags # pokeElemOff :: Ptr VkRenderPassCreateFlags -> Int -> VkRenderPassCreateFlags -> IO () # peekByteOff :: Ptr b -> Int -> IO VkRenderPassCreateFlags # pokeByteOff :: Ptr b -> Int -> VkRenderPassCreateFlags -> IO () # peek :: Ptr VkRenderPassCreateFlags -> IO VkRenderPassCreateFlags # poke :: Ptr VkRenderPassCreateFlags -> VkRenderPassCreateFlags -> IO () #
Bits VkRenderPassCreateFlags Source #
Methods (.&.) :: VkRenderPassCreateFlags -> VkRenderPassCreateFlags -> VkRenderPassCreateFlags # (.\|.) :: VkRenderPassCreateFlags -> VkRenderPassCreateFlags -> VkRenderPassCreateFlags # xor :: VkRenderPassCreateFlags -> VkRenderPassCreateFlags -> VkRenderPassCreateFlags # complement :: VkRenderPassCreateFlags -> VkRenderPassCreateFlags # shift :: VkRenderPassCreateFlags -> Int -> VkRenderPassCreateFlags # rotate :: VkRenderPassCreateFlags -> Int -> VkRenderPassCreateFlags # zeroBits :: VkRenderPassCreateFlags # bit :: Int -> VkRenderPassCreateFlags # setBit :: VkRenderPassCreateFlags -> Int -> VkRenderPassCreateFlags # clearBit :: VkRenderPassCreateFlags -> Int -> VkRenderPassCreateFlags # complementBit :: VkRenderPassCreateFlags -> Int -> VkRenderPassCreateFlags # testBit :: VkRenderPassCreateFlags -> Int -> Bool # bitSizeMaybe :: VkRenderPassCreateFlags -> Maybe Int # bitSize :: VkRenderPassCreateFlags -> Int # isSigned :: VkRenderPassCreateFlags -> Bool # shiftL :: VkRenderPassCreateFlags -> Int -> VkRenderPassCreateFlags # unsafeShiftL :: VkRenderPassCreateFlags -> Int -> VkRenderPassCreateFlags # shiftR :: VkRenderPassCreateFlags -> Int -> VkRenderPassCreateFlags # unsafeShiftR :: VkRenderPassCreateFlags -> Int -> VkRenderPassCreateFlags # rotateL :: VkRenderPassCreateFlags -> Int -> VkRenderPassCreateFlags # rotateR :: VkRenderPassCreateFlags -> Int -> VkRenderPassCreateFlags # popCount :: VkRenderPassCreateFlags -> Int #
FiniteBits VkRenderPassCreateFlags Source #
Methods finiteBitSize :: VkRenderPassCreateFlags -> Int # countLeadingZeros :: VkRenderPassCreateFlags -> Int # countTrailingZeros :: VkRenderPassCreateFlags -> Int #

Eq VkAccessFlagBits Source #
Methods (==) :: VkAccessFlagBits -> VkAccessFlagBits -> Bool # (/=) :: VkAccessFlagBits -> VkAccessFlagBits -> Bool #
Ord VkAccessFlagBits Source #
Methods compare :: VkAccessFlagBits -> VkAccessFlagBits -> Ordering # (<) :: VkAccessFlagBits -> VkAccessFlagBits -> Bool # (<=) :: VkAccessFlagBits -> VkAccessFlagBits -> Bool # (>) :: VkAccessFlagBits -> VkAccessFlagBits -> Bool # (>=) :: VkAccessFlagBits -> VkAccessFlagBits -> Bool # max :: VkAccessFlagBits -> VkAccessFlagBits -> VkAccessFlagBits # min :: VkAccessFlagBits -> VkAccessFlagBits -> VkAccessFlagBits #
Read VkAccessFlagBits Source #
Methods readsPrec :: Int -> ReadS VkAccessFlagBits # readList :: ReadS [VkAccessFlagBits] # readPrec :: ReadPrec VkAccessFlagBits # readListPrec :: ReadPrec [VkAccessFlagBits] #
Show VkAccessFlagBits Source #
Methods showsPrec :: Int -> VkAccessFlagBits -> ShowS # show :: VkAccessFlagBits -> String # showList :: [VkAccessFlagBits] -> ShowS #
Storable VkAccessFlagBits Source #
Methods sizeOf :: VkAccessFlagBits -> Int # alignment :: VkAccessFlagBits -> Int # peekElemOff :: Ptr VkAccessFlagBits -> Int -> IO VkAccessFlagBits # pokeElemOff :: Ptr VkAccessFlagBits -> Int -> VkAccessFlagBits -> IO () # peekByteOff :: Ptr b -> Int -> IO VkAccessFlagBits # pokeByteOff :: Ptr b -> Int -> VkAccessFlagBits -> IO () # peek :: Ptr VkAccessFlagBits -> IO VkAccessFlagBits # poke :: Ptr VkAccessFlagBits -> VkAccessFlagBits -> IO () #
Bits VkAccessFlagBits Source #
Methods (.&.) :: VkAccessFlagBits -> VkAccessFlagBits -> VkAccessFlagBits # (.\|.) :: VkAccessFlagBits -> VkAccessFlagBits -> VkAccessFlagBits # xor :: VkAccessFlagBits -> VkAccessFlagBits -> VkAccessFlagBits # complement :: VkAccessFlagBits -> VkAccessFlagBits # shift :: VkAccessFlagBits -> Int -> VkAccessFlagBits # rotate :: VkAccessFlagBits -> Int -> VkAccessFlagBits # zeroBits :: VkAccessFlagBits # bit :: Int -> VkAccessFlagBits # setBit :: VkAccessFlagBits -> Int -> VkAccessFlagBits # clearBit :: VkAccessFlagBits -> Int -> VkAccessFlagBits # complementBit :: VkAccessFlagBits -> Int -> VkAccessFlagBits # testBit :: VkAccessFlagBits -> Int -> Bool # bitSizeMaybe :: VkAccessFlagBits -> Maybe Int # bitSize :: VkAccessFlagBits -> Int # isSigned :: VkAccessFlagBits -> Bool # shiftL :: VkAccessFlagBits -> Int -> VkAccessFlagBits # unsafeShiftL :: VkAccessFlagBits -> Int -> VkAccessFlagBits # shiftR :: VkAccessFlagBits -> Int -> VkAccessFlagBits # unsafeShiftR :: VkAccessFlagBits -> Int -> VkAccessFlagBits # rotateL :: VkAccessFlagBits -> Int -> VkAccessFlagBits # rotateR :: VkAccessFlagBits -> Int -> VkAccessFlagBits # popCount :: VkAccessFlagBits -> Int #
FiniteBits VkAccessFlagBits Source #
Methods finiteBitSize :: VkAccessFlagBits -> Int # countLeadingZeros :: VkAccessFlagBits -> Int # countTrailingZeros :: VkAccessFlagBits -> Int #

Eq VkSubpassDescriptionFlagBits Source #
Methods (==) :: VkSubpassDescriptionFlagBits -> VkSubpassDescriptionFlagBits -> Bool # (/=) :: VkSubpassDescriptionFlagBits -> VkSubpassDescriptionFlagBits -> Bool #
Ord VkSubpassDescriptionFlagBits Source #
Methods compare :: VkSubpassDescriptionFlagBits -> VkSubpassDescriptionFlagBits -> Ordering # (<) :: VkSubpassDescriptionFlagBits -> VkSubpassDescriptionFlagBits -> Bool # (<=) :: VkSubpassDescriptionFlagBits -> VkSubpassDescriptionFlagBits -> Bool # (>) :: VkSubpassDescriptionFlagBits -> VkSubpassDescriptionFlagBits -> Bool # (>=) :: VkSubpassDescriptionFlagBits -> VkSubpassDescriptionFlagBits -> Bool # max :: VkSubpassDescriptionFlagBits -> VkSubpassDescriptionFlagBits -> VkSubpassDescriptionFlagBits # min :: VkSubpassDescriptionFlagBits -> VkSubpassDescriptionFlagBits -> VkSubpassDescriptionFlagBits #
Read VkSubpassDescriptionFlagBits Source #
Methods readsPrec :: Int -> ReadS VkSubpassDescriptionFlagBits # readList :: ReadS [VkSubpassDescriptionFlagBits] # readPrec :: ReadPrec VkSubpassDescriptionFlagBits # readListPrec :: ReadPrec [VkSubpassDescriptionFlagBits] #
Show VkSubpassDescriptionFlagBits Source #
Methods showsPrec :: Int -> VkSubpassDescriptionFlagBits -> ShowS # show :: VkSubpassDescriptionFlagBits -> String # showList :: [VkSubpassDescriptionFlagBits] -> ShowS #
Storable VkSubpassDescriptionFlagBits Source #
Methods sizeOf :: VkSubpassDescriptionFlagBits -> Int # alignment :: VkSubpassDescriptionFlagBits -> Int # peekElemOff :: Ptr VkSubpassDescriptionFlagBits -> Int -> IO VkSubpassDescriptionFlagBits # pokeElemOff :: Ptr VkSubpassDescriptionFlagBits -> Int -> VkSubpassDescriptionFlagBits -> IO () # peekByteOff :: Ptr b -> Int -> IO VkSubpassDescriptionFlagBits # pokeByteOff :: Ptr b -> Int -> VkSubpassDescriptionFlagBits -> IO () # peek :: Ptr VkSubpassDescriptionFlagBits -> IO VkSubpassDescriptionFlagBits # poke :: Ptr VkSubpassDescriptionFlagBits -> VkSubpassDescriptionFlagBits -> IO () #
Bits VkSubpassDescriptionFlagBits Source #
Methods (.&.) :: VkSubpassDescriptionFlagBits -> VkSubpassDescriptionFlagBits -> VkSubpassDescriptionFlagBits # (.\|.) :: VkSubpassDescriptionFlagBits -> VkSubpassDescriptionFlagBits -> VkSubpassDescriptionFlagBits # xor :: VkSubpassDescriptionFlagBits -> VkSubpassDescriptionFlagBits -> VkSubpassDescriptionFlagBits # complement :: VkSubpassDescriptionFlagBits -> VkSubpassDescriptionFlagBits # shift :: VkSubpassDescriptionFlagBits -> Int -> VkSubpassDescriptionFlagBits # rotate :: VkSubpassDescriptionFlagBits -> Int -> VkSubpassDescriptionFlagBits # zeroBits :: VkSubpassDescriptionFlagBits # bit :: Int -> VkSubpassDescriptionFlagBits # setBit :: VkSubpassDescriptionFlagBits -> Int -> VkSubpassDescriptionFlagBits # clearBit :: VkSubpassDescriptionFlagBits -> Int -> VkSubpassDescriptionFlagBits # complementBit :: VkSubpassDescriptionFlagBits -> Int -> VkSubpassDescriptionFlagBits # testBit :: VkSubpassDescriptionFlagBits -> Int -> Bool # bitSizeMaybe :: VkSubpassDescriptionFlagBits -> Maybe Int # bitSize :: VkSubpassDescriptionFlagBits -> Int # isSigned :: VkSubpassDescriptionFlagBits -> Bool # shiftL :: VkSubpassDescriptionFlagBits -> Int -> VkSubpassDescriptionFlagBits # unsafeShiftL :: VkSubpassDescriptionFlagBits -> Int -> VkSubpassDescriptionFlagBits # shiftR :: VkSubpassDescriptionFlagBits -> Int -> VkSubpassDescriptionFlagBits # unsafeShiftR :: VkSubpassDescriptionFlagBits -> Int -> VkSubpassDescriptionFlagBits # rotateL :: VkSubpassDescriptionFlagBits -> Int -> VkSubpassDescriptionFlagBits # rotateR :: VkSubpassDescriptionFlagBits -> Int -> VkSubpassDescriptionFlagBits # popCount :: VkSubpassDescriptionFlagBits -> Int #
FiniteBits VkSubpassDescriptionFlagBits Source #
Methods finiteBitSize :: VkSubpassDescriptionFlagBits -> Int # countLeadingZeros :: VkSubpassDescriptionFlagBits -> Int # countTrailingZeros :: VkSubpassDescriptionFlagBits -> Int #

Eq VkAttachmentDescriptionFlagBits Source #
Methods (==) :: VkAttachmentDescriptionFlagBits -> VkAttachmentDescriptionFlagBits -> Bool # (/=) :: VkAttachmentDescriptionFlagBits -> VkAttachmentDescriptionFlagBits -> Bool #
Ord VkAttachmentDescriptionFlagBits Source #
Methods compare :: VkAttachmentDescriptionFlagBits -> VkAttachmentDescriptionFlagBits -> Ordering # (<) :: VkAttachmentDescriptionFlagBits -> VkAttachmentDescriptionFlagBits -> Bool # (<=) :: VkAttachmentDescriptionFlagBits -> VkAttachmentDescriptionFlagBits -> Bool # (>) :: VkAttachmentDescriptionFlagBits -> VkAttachmentDescriptionFlagBits -> Bool # (>=) :: VkAttachmentDescriptionFlagBits -> VkAttachmentDescriptionFlagBits -> Bool # max :: VkAttachmentDescriptionFlagBits -> VkAttachmentDescriptionFlagBits -> VkAttachmentDescriptionFlagBits # min :: VkAttachmentDescriptionFlagBits -> VkAttachmentDescriptionFlagBits -> VkAttachmentDescriptionFlagBits #
Read VkAttachmentDescriptionFlagBits Source #
Methods readsPrec :: Int -> ReadS VkAttachmentDescriptionFlagBits # readList :: ReadS [VkAttachmentDescriptionFlagBits] # readPrec :: ReadPrec VkAttachmentDescriptionFlagBits # readListPrec :: ReadPrec [VkAttachmentDescriptionFlagBits] #
Show VkAttachmentDescriptionFlagBits Source #
Methods showsPrec :: Int -> VkAttachmentDescriptionFlagBits -> ShowS # show :: VkAttachmentDescriptionFlagBits -> String # showList :: [VkAttachmentDescriptionFlagBits] -> ShowS #
Storable VkAttachmentDescriptionFlagBits Source #
Methods sizeOf :: VkAttachmentDescriptionFlagBits -> Int # alignment :: VkAttachmentDescriptionFlagBits -> Int # peekElemOff :: Ptr VkAttachmentDescriptionFlagBits -> Int -> IO VkAttachmentDescriptionFlagBits # pokeElemOff :: Ptr VkAttachmentDescriptionFlagBits -> Int -> VkAttachmentDescriptionFlagBits -> IO () # peekByteOff :: Ptr b -> Int -> IO VkAttachmentDescriptionFlagBits # pokeByteOff :: Ptr b -> Int -> VkAttachmentDescriptionFlagBits -> IO () # peek :: Ptr VkAttachmentDescriptionFlagBits -> IO VkAttachmentDescriptionFlagBits # poke :: Ptr VkAttachmentDescriptionFlagBits -> VkAttachmentDescriptionFlagBits -> IO () #
Bits VkAttachmentDescriptionFlagBits Source #
Methods (.&.) :: VkAttachmentDescriptionFlagBits -> VkAttachmentDescriptionFlagBits -> VkAttachmentDescriptionFlagBits # (.\|.) :: VkAttachmentDescriptionFlagBits -> VkAttachmentDescriptionFlagBits -> VkAttachmentDescriptionFlagBits # xor :: VkAttachmentDescriptionFlagBits -> VkAttachmentDescriptionFlagBits -> VkAttachmentDescriptionFlagBits # complement :: VkAttachmentDescriptionFlagBits -> VkAttachmentDescriptionFlagBits # shift :: VkAttachmentDescriptionFlagBits -> Int -> VkAttachmentDescriptionFlagBits # rotate :: VkAttachmentDescriptionFlagBits -> Int -> VkAttachmentDescriptionFlagBits # zeroBits :: VkAttachmentDescriptionFlagBits # bit :: Int -> VkAttachmentDescriptionFlagBits # setBit :: VkAttachmentDescriptionFlagBits -> Int -> VkAttachmentDescriptionFlagBits # clearBit :: VkAttachmentDescriptionFlagBits -> Int -> VkAttachmentDescriptionFlagBits # complementBit :: VkAttachmentDescriptionFlagBits -> Int -> VkAttachmentDescriptionFlagBits # testBit :: VkAttachmentDescriptionFlagBits -> Int -> Bool # bitSizeMaybe :: VkAttachmentDescriptionFlagBits -> Maybe Int # bitSize :: VkAttachmentDescriptionFlagBits -> Int # isSigned :: VkAttachmentDescriptionFlagBits -> Bool # shiftL :: VkAttachmentDescriptionFlagBits -> Int -> VkAttachmentDescriptionFlagBits # unsafeShiftL :: VkAttachmentDescriptionFlagBits -> Int -> VkAttachmentDescriptionFlagBits # shiftR :: VkAttachmentDescriptionFlagBits -> Int -> VkAttachmentDescriptionFlagBits # unsafeShiftR :: VkAttachmentDescriptionFlagBits -> Int -> VkAttachmentDescriptionFlagBits # rotateL :: VkAttachmentDescriptionFlagBits -> Int -> VkAttachmentDescriptionFlagBits # rotateR :: VkAttachmentDescriptionFlagBits -> Int -> VkAttachmentDescriptionFlagBits # popCount :: VkAttachmentDescriptionFlagBits -> Int #
FiniteBits VkAttachmentDescriptionFlagBits Source #
Methods finiteBitSize :: VkAttachmentDescriptionFlagBits -> Int # countLeadingZeros :: VkAttachmentDescriptionFlagBits -> Int # countTrailingZeros :: VkAttachmentDescriptionFlagBits -> Int #

Eq VkDependencyFlagBits Source #
Methods (==) :: VkDependencyFlagBits -> VkDependencyFlagBits -> Bool # (/=) :: VkDependencyFlagBits -> VkDependencyFlagBits -> Bool #
Ord VkDependencyFlagBits Source #
Methods compare :: VkDependencyFlagBits -> VkDependencyFlagBits -> Ordering # (<) :: VkDependencyFlagBits -> VkDependencyFlagBits -> Bool # (<=) :: VkDependencyFlagBits -> VkDependencyFlagBits -> Bool # (>) :: VkDependencyFlagBits -> VkDependencyFlagBits -> Bool # (>=) :: VkDependencyFlagBits -> VkDependencyFlagBits -> Bool # max :: VkDependencyFlagBits -> VkDependencyFlagBits -> VkDependencyFlagBits # min :: VkDependencyFlagBits -> VkDependencyFlagBits -> VkDependencyFlagBits #
Read VkDependencyFlagBits Source #
Methods readsPrec :: Int -> ReadS VkDependencyFlagBits # readList :: ReadS [VkDependencyFlagBits] # readPrec :: ReadPrec VkDependencyFlagBits # readListPrec :: ReadPrec [VkDependencyFlagBits] #
Show VkDependencyFlagBits Source #
Methods showsPrec :: Int -> VkDependencyFlagBits -> ShowS # show :: VkDependencyFlagBits -> String # showList :: [VkDependencyFlagBits] -> ShowS #
Storable VkDependencyFlagBits Source #
Methods sizeOf :: VkDependencyFlagBits -> Int # alignment :: VkDependencyFlagBits -> Int # peekElemOff :: Ptr VkDependencyFlagBits -> Int -> IO VkDependencyFlagBits # pokeElemOff :: Ptr VkDependencyFlagBits -> Int -> VkDependencyFlagBits -> IO () # peekByteOff :: Ptr b -> Int -> IO VkDependencyFlagBits # pokeByteOff :: Ptr b -> Int -> VkDependencyFlagBits -> IO () # peek :: Ptr VkDependencyFlagBits -> IO VkDependencyFlagBits # poke :: Ptr VkDependencyFlagBits -> VkDependencyFlagBits -> IO () #
Bits VkDependencyFlagBits Source #
Methods (.&.) :: VkDependencyFlagBits -> VkDependencyFlagBits -> VkDependencyFlagBits # (.\|.) :: VkDependencyFlagBits -> VkDependencyFlagBits -> VkDependencyFlagBits # xor :: VkDependencyFlagBits -> VkDependencyFlagBits -> VkDependencyFlagBits # complement :: VkDependencyFlagBits -> VkDependencyFlagBits # shift :: VkDependencyFlagBits -> Int -> VkDependencyFlagBits # rotate :: VkDependencyFlagBits -> Int -> VkDependencyFlagBits # zeroBits :: VkDependencyFlagBits # bit :: Int -> VkDependencyFlagBits # setBit :: VkDependencyFlagBits -> Int -> VkDependencyFlagBits # clearBit :: VkDependencyFlagBits -> Int -> VkDependencyFlagBits # complementBit :: VkDependencyFlagBits -> Int -> VkDependencyFlagBits # testBit :: VkDependencyFlagBits -> Int -> Bool # bitSizeMaybe :: VkDependencyFlagBits -> Maybe Int # bitSize :: VkDependencyFlagBits -> Int # isSigned :: VkDependencyFlagBits -> Bool # shiftL :: VkDependencyFlagBits -> Int -> VkDependencyFlagBits # unsafeShiftL :: VkDependencyFlagBits -> Int -> VkDependencyFlagBits # shiftR :: VkDependencyFlagBits -> Int -> VkDependencyFlagBits # unsafeShiftR :: VkDependencyFlagBits -> Int -> VkDependencyFlagBits # rotateL :: VkDependencyFlagBits -> Int -> VkDependencyFlagBits # rotateR :: VkDependencyFlagBits -> Int -> VkDependencyFlagBits # popCount :: VkDependencyFlagBits -> Int #
FiniteBits VkDependencyFlagBits Source #
Methods finiteBitSize :: VkDependencyFlagBits -> Int # countLeadingZeros :: VkDependencyFlagBits -> Int # countTrailingZeros :: VkDependencyFlagBits -> Int #

Eq VkAttachmentDescription Source #
Methods (==) :: VkAttachmentDescription -> VkAttachmentDescription -> Bool # (/=) :: VkAttachmentDescription -> VkAttachmentDescription -> Bool #
Show VkAttachmentDescription Source #
Methods showsPrec :: Int -> VkAttachmentDescription -> ShowS # show :: VkAttachmentDescription -> String # showList :: [VkAttachmentDescription] -> ShowS #
Storable VkAttachmentDescription Source #
Methods sizeOf :: VkAttachmentDescription -> Int # alignment :: VkAttachmentDescription -> Int # peekElemOff :: Ptr VkAttachmentDescription -> Int -> IO VkAttachmentDescription # pokeElemOff :: Ptr VkAttachmentDescription -> Int -> VkAttachmentDescription -> IO () # peekByteOff :: Ptr b -> Int -> IO VkAttachmentDescription # pokeByteOff :: Ptr b -> Int -> VkAttachmentDescription -> IO () # peek :: Ptr VkAttachmentDescription -> IO VkAttachmentDescription # poke :: Ptr VkAttachmentDescription -> VkAttachmentDescription -> IO () #

Eq VkAttachmentReference Source #
Methods (==) :: VkAttachmentReference -> VkAttachmentReference -> Bool # (/=) :: VkAttachmentReference -> VkAttachmentReference -> Bool #
Show VkAttachmentReference Source #
Methods showsPrec :: Int -> VkAttachmentReference -> ShowS # show :: VkAttachmentReference -> String # showList :: [VkAttachmentReference] -> ShowS #
Storable VkAttachmentReference Source #
Methods sizeOf :: VkAttachmentReference -> Int # alignment :: VkAttachmentReference -> Int # peekElemOff :: Ptr VkAttachmentReference -> Int -> IO VkAttachmentReference # pokeElemOff :: Ptr VkAttachmentReference -> Int -> VkAttachmentReference -> IO () # peekByteOff :: Ptr b -> Int -> IO VkAttachmentReference # pokeByteOff :: Ptr b -> Int -> VkAttachmentReference -> IO () # peek :: Ptr VkAttachmentReference -> IO VkAttachmentReference # poke :: Ptr VkAttachmentReference -> VkAttachmentReference -> IO () #

Eq VkSubpassDescription Source #
Methods (==) :: VkSubpassDescription -> VkSubpassDescription -> Bool # (/=) :: VkSubpassDescription -> VkSubpassDescription -> Bool #
Show VkSubpassDescription Source #
Methods showsPrec :: Int -> VkSubpassDescription -> ShowS # show :: VkSubpassDescription -> String # showList :: [VkSubpassDescription] -> ShowS #
Storable VkSubpassDescription Source #
Methods sizeOf :: VkSubpassDescription -> Int # alignment :: VkSubpassDescription -> Int # peekElemOff :: Ptr VkSubpassDescription -> Int -> IO VkSubpassDescription # pokeElemOff :: Ptr VkSubpassDescription -> Int -> VkSubpassDescription -> IO () # peekByteOff :: Ptr b -> Int -> IO VkSubpassDescription # pokeByteOff :: Ptr b -> Int -> VkSubpassDescription -> IO () # peek :: Ptr VkSubpassDescription -> IO VkSubpassDescription # poke :: Ptr VkSubpassDescription -> VkSubpassDescription -> IO () #

Eq VkSubpassDependency Source #
Methods (==) :: VkSubpassDependency -> VkSubpassDependency -> Bool # (/=) :: VkSubpassDependency -> VkSubpassDependency -> Bool #
Show VkSubpassDependency Source #
Methods showsPrec :: Int -> VkSubpassDependency -> ShowS # show :: VkSubpassDependency -> String # showList :: [VkSubpassDependency] -> ShowS #
Storable VkSubpassDependency Source #
Methods sizeOf :: VkSubpassDependency -> Int # alignment :: VkSubpassDependency -> Int # peekElemOff :: Ptr VkSubpassDependency -> Int -> IO VkSubpassDependency # pokeElemOff :: Ptr VkSubpassDependency -> Int -> VkSubpassDependency -> IO () # peekByteOff :: Ptr b -> Int -> IO VkSubpassDependency # pokeByteOff :: Ptr b -> Int -> VkSubpassDependency -> IO () # peek :: Ptr VkSubpassDependency -> IO VkSubpassDependency # poke :: Ptr VkSubpassDependency -> VkSubpassDependency -> IO () #

Eq VkRenderPassCreateInfo Source #
Methods (==) :: VkRenderPassCreateInfo -> VkRenderPassCreateInfo -> Bool # (/=) :: VkRenderPassCreateInfo -> VkRenderPassCreateInfo -> Bool #
Show VkRenderPassCreateInfo Source #
Methods showsPrec :: Int -> VkRenderPassCreateInfo -> ShowS # show :: VkRenderPassCreateInfo -> String # showList :: [VkRenderPassCreateInfo] -> ShowS #
Storable VkRenderPassCreateInfo Source #
Methods sizeOf :: VkRenderPassCreateInfo -> Int # alignment :: VkRenderPassCreateInfo -> Int # peekElemOff :: Ptr VkRenderPassCreateInfo -> Int -> IO VkRenderPassCreateInfo # pokeElemOff :: Ptr VkRenderPassCreateInfo -> Int -> VkRenderPassCreateInfo -> IO () # peekByteOff :: Ptr b -> Int -> IO VkRenderPassCreateInfo # pokeByteOff :: Ptr b -> Int -> VkRenderPassCreateInfo -> IO () # peek :: Ptr VkRenderPassCreateInfo -> IO VkRenderPassCreateInfo # poke :: Ptr VkRenderPassCreateInfo -> VkRenderPassCreateInfo -> IO () #

Eq VkFramebufferCreateInfo Source #
Methods (==) :: VkFramebufferCreateInfo -> VkFramebufferCreateInfo -> Bool # (/=) :: VkFramebufferCreateInfo -> VkFramebufferCreateInfo -> Bool #
Show VkFramebufferCreateInfo Source #
Methods showsPrec :: Int -> VkFramebufferCreateInfo -> ShowS # show :: VkFramebufferCreateInfo -> String # showList :: [VkFramebufferCreateInfo] -> ShowS #
Storable VkFramebufferCreateInfo Source #
Methods sizeOf :: VkFramebufferCreateInfo -> Int # alignment :: VkFramebufferCreateInfo -> Int # peekElemOff :: Ptr VkFramebufferCreateInfo -> Int -> IO VkFramebufferCreateInfo # pokeElemOff :: Ptr VkFramebufferCreateInfo -> Int -> VkFramebufferCreateInfo -> IO () # peekByteOff :: Ptr b -> Int -> IO VkFramebufferCreateInfo # pokeByteOff :: Ptr b -> Int -> VkFramebufferCreateInfo -> IO () # peek :: Ptr VkFramebufferCreateInfo -> IO VkFramebufferCreateInfo # poke :: Ptr VkFramebufferCreateInfo -> VkFramebufferCreateInfo -> IO () #

Documentation

See Also

See Also

See Also

Description

See Also

Description

See Also

Description

See Also

See Also

See Also

See Also

Description

See Also

Parameters

Description

Valid Usage (Implicit)

Return Codes

See Also

Parameters

Description

Valid Usage

Valid Usage (Implicit)

Host Synchronization

See Also

Parameters

Description

Valid Usage (Implicit)

Return Codes

See Also

Parameters

Description

Valid Usage

Valid Usage (Implicit)

Host Synchronization

See Also

Parameters

Description

Valid Usage (Implicit)

See Also

Description

Valid Usage

Valid Usage (Implicit)

See Also

Description

Valid Usage

Valid Usage (Implicit)

See Also

Description

Valid Usage

Valid Usage (Implicit)

See Also

Description

Valid Usage

Valid Usage (Implicit)

See Also

Description

Valid Usage

Valid Usage (Implicit)

See Also

Description

Valid Usage

Valid Usage (Implicit)

See Also

Description

See Also

Description

See Also

Description

See Also

Description

See Also