Credit to devdocs.io

vulkan

vulkan

Vulkan API Reference

Vulkan Commands

vkAllocateCommandBuffers(3)

Name

vkAllocateCommandBuffers - Allocate command buffers from an existing command pool

C Specification

To allocate command buffers, call:

VkResult vkAllocateCommandBuffers(
    VkDevice                                    device,
    const VkCommandBufferAllocateInfo*          pAllocateInfo,
    VkCommandBuffer*                            pCommandBuffers);

Parameters

  • device is the logical device that owns the command pool.
  • pAllocateInfo is a pointer to an instance of the VkCommandBufferAllocateInfo structure describing parameters of the allocation.
  • pCommandBuffers is a pointer to an array of VkCommandBuffer handles in which the resulting command buffer objects are returned. The array must be at least the length specified by the commandBufferCount member of pAllocateInfo. Each allocated command buffer begins in the initial state.

Description

When command buffers are first allocated, they are in the initial state.

Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • pAllocateInfo must be a pointer to a valid VkCommandBufferAllocateInfo structure
  • pCommandBuffers must be a pointer to an array of pAllocateInfo::commandBufferCount VkCommandBuffer handles
Host Synchronization
  • Host access to pAllocateInfo::commandPool must be externally synchronized
Return Codes
Success
  • VK_SUCCESS
Failure
  • VK_ERROR_OUT_OF_HOST_MEMORY
  • VK_ERROR_OUT_OF_DEVICE_MEMORY

See Also

VkCommandBuffer, VkCommandBufferAllocateInfo, VkDevice

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkAllocateCommandBuffers

vkAllocateDescriptorSets(3)

Name

vkAllocateDescriptorSets - Allocate one or more descriptor sets

C Specification

To allocate descriptor sets from a descriptor pool, call:

VkResult vkAllocateDescriptorSets(
    VkDevice                                    device,
    const VkDescriptorSetAllocateInfo*          pAllocateInfo,
    VkDescriptorSet*                            pDescriptorSets);

Parameters

  • device is the logical device that owns the descriptor pool.
  • pAllocateInfo is a pointer to an instance of the VkDescriptorSetAllocateInfo structure describing parameters of the allocation.
  • pDescriptorSets is a pointer to an array of VkDescriptorSet handles in which the resulting descriptor set objects are returned. The array must be at least the length specified by the descriptorSetCount member of pAllocateInfo.

Description

The allocated descriptor sets are returned in pDescriptorSets.

When a descriptor set is allocated, the initial state is largely uninitialized and all descriptors are undefined. However, the descriptor set can be bound in a command buffer without causing errors or exceptions. All entries that are statically used by a pipeline in a drawing or dispatching command must have been populated before the descriptor set is bound for use by that command. Entries that are not statically used by a pipeline can have uninitialized descriptors or descriptors of resources that have been destroyed, and executing a draw or dispatch with such a descriptor set bound does not cause undefined behavior. This means applications need not populate unused entries with dummy descriptors.

If an allocation fails due to fragmentation, an indeterminate error is returned with an unspecified error code. Any returned error other than VK_ERROR_FRAGMENTED_POOL does not imply its usual meaning: applications should assume that the allocation failed due to fragmentation, and create a new descriptor pool.

Note

Applications should check for a negative return value when allocating new descriptor sets, assume that any error effectively means VK_ERROR_FRAGMENTED_POOL, and try to create a new descriptor pool. If VK_ERROR_FRAGMENTED_POOL is the actual return value, it adds certainty to that decision.

The reason for this is that VK_ERROR_FRAGMENTED_POOL was only added in a later revision of the 1.0 specification, and so drivers may return other errors if they were written against earlier revisions. To ensure full compatibility with earlier patch revisions, these other errors are allowed.

Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • pAllocateInfo must be a pointer to a valid VkDescriptorSetAllocateInfo structure
  • pDescriptorSets must be a pointer to an array of pAllocateInfo::descriptorSetCount VkDescriptorSet handles
Host Synchronization
  • Host access to pAllocateInfo::descriptorPool must be externally synchronized
Return Codes
Success
  • VK_SUCCESS
Failure
  • VK_ERROR_OUT_OF_HOST_MEMORY
  • VK_ERROR_OUT_OF_DEVICE_MEMORY
  • VK_ERROR_FRAGMENTED_POOL

See Also

VkDescriptorSet, VkDescriptorSetAllocateInfo, VkDevice

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkAllocateDescriptorSets

vkAllocateMemory(3)

Name

vkAllocateMemory - Allocate GPU memory

C Specification

To allocate memory objects, call:

VkResult vkAllocateMemory(
    VkDevice                                    device,
    const VkMemoryAllocateInfo*                 pAllocateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkDeviceMemory*                             pMemory);

Parameters

  • device is the logical device that owns the memory.
  • pAllocateInfo is a pointer to an instance of the VkMemoryAllocateInfo structure describing parameters of the allocation. A successful returned allocation must use the requested parameters — no substitution is permitted by the implementation.
  • pAllocator controls host memory allocation as described in the Memory Allocation chapter.
  • pMemory is a pointer to a VkDeviceMemory handle in which information about the allocated memory is returned.

Description

Allocations returned by vkAllocateMemory are guaranteed to meet any alignment requirement by the implementation. For example, if an implementation requires 128 byte alignment for images and 64 byte alignment for buffers, the device memory returned through this mechanism would be 128-byte aligned. This ensures that applications can correctly suballocate objects of different types (with potentially different alignment requirements) in the same memory object.

When memory is allocated, its contents are undefined.

There is an implementation-dependent maximum number of memory allocations which can be simultaneously created on a device. This is specified by the maxMemoryAllocationCount member of the VkPhysicalDeviceLimits structure. If maxMemoryAllocationCount is exceeded, vkAllocateMemory will return VK_ERROR_TOO_MANY_OBJECTS.

Note

Some platforms may have a limit on the maximum size of a single allocation. For example, certain systems may fail to create allocations with a size greater than or equal to 4GB. Such a limit is implementation-dependent, and if such a failure occurs then the error VK_ERROR_OUT_OF_DEVICE_MEMORY should be returned.

Valid Usage
  • The number of currently valid memory objects, allocated from device, must be less than VkPhysicalDeviceLimits::maxMemoryAllocationCount
Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • pAllocateInfo must be a pointer to a valid VkMemoryAllocateInfo structure
  • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
  • pMemory must be a pointer to a VkDeviceMemory handle
Return Codes
Success
  • VK_SUCCESS
Failure
  • VK_ERROR_OUT_OF_HOST_MEMORY
  • VK_ERROR_OUT_OF_DEVICE_MEMORY
  • VK_ERROR_TOO_MANY_OBJECTS

See Also

VkAllocationCallbacks, VkDevice, VkDeviceMemory, VkMemoryAllocateInfo

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkAllocateMemory

vkBeginCommandBuffer(3)

Name

vkBeginCommandBuffer - Start recording a command buffer

C Specification

To begin recording a command buffer, call:

VkResult vkBeginCommandBuffer(
    VkCommandBuffer                             commandBuffer,
    const VkCommandBufferBeginInfo*             pBeginInfo);

Parameters

  • commandBuffer is the handle of the command buffer which is to be put in the recording state.
  • pBeginInfo is an instance of the VkCommandBufferBeginInfo structure, which defines additional information about how the command buffer begins recording.

Description

Valid Usage
  • commandBuffer must not be in the recording or pending state.
  • If commandBuffer was allocated from a VkCommandPool which did not have the VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT flag set, commandBuffer must be in the initial state.
  • If commandBuffer is a secondary command buffer, the pInheritanceInfo member of pBeginInfo must be a valid VkCommandBufferInheritanceInfo structure
  • If commandBuffer is a secondary command buffer and either the occlusionQueryEnable member of the pInheritanceInfo member of pBeginInfo is VK_FALSE, or the precise occlusion queries feature is not enabled, the queryFlags member of the pInheritanceInfo member pBeginInfo must not contain VK_QUERY_CONTROL_PRECISE_BIT
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
  • pBeginInfo must be a pointer to a valid VkCommandBufferBeginInfo structure
Host Synchronization
  • Host access to commandBuffer must be externally synchronized
  • Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized
Return Codes
Success
  • VK_SUCCESS
Failure
  • VK_ERROR_OUT_OF_HOST_MEMORY
  • VK_ERROR_OUT_OF_DEVICE_MEMORY

See Also

VkCommandBuffer, VkCommandBufferBeginInfo

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkBeginCommandBuffer

vkBindBufferMemory(3)

Name

vkBindBufferMemory - Bind device memory to a buffer object

C Specification

To attach memory to a buffer object, call:

VkResult vkBindBufferMemory(
    VkDevice                                    device,
    VkBuffer                                    buffer,
    VkDeviceMemory                              memory,
    VkDeviceSize                                memoryOffset);

Parameters

  • device is the logical device that owns the buffer and memory.
  • buffer is the buffer to be attached to memory.
  • memory is a VkDeviceMemory object describing the device memory to attach.
  • memoryOffset is the start offset of the region of memory which is to be bound to the buffer. The number of bytes returned in the VkMemoryRequirements::size member in memory, starting from memoryOffset bytes, will be bound to the specified buffer.

Description

Valid Usage
  • buffer must not already be backed by a memory object
  • buffer must not have been created with any sparse memory binding flags
  • memoryOffset must be less than the size of memory
  • If buffer was created with the VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT or VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, memoryOffset must be a multiple of VkPhysicalDeviceLimits::minTexelBufferOffsetAlignment
  • If buffer was created with the VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, memoryOffset must be a multiple of VkPhysicalDeviceLimits::minUniformBufferOffsetAlignment
  • If buffer was created with the VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, memoryOffset must be a multiple of VkPhysicalDeviceLimits::minStorageBufferOffsetAlignment
  • memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer
  • memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer
  • The size member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer must be less than or equal to the size of memory minus memoryOffset
Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • buffer must be a valid VkBuffer handle
  • memory must be a valid VkDeviceMemory handle
  • buffer must have been created, allocated, or retrieved from device
  • memory must have been created, allocated, or retrieved from device
Host Synchronization
  • Host access to buffer must be externally synchronized
Return Codes
Success
  • VK_SUCCESS
Failure
  • VK_ERROR_OUT_OF_HOST_MEMORY
  • VK_ERROR_OUT_OF_DEVICE_MEMORY

See Also

VkBuffer, VkDevice, VkDeviceMemory, VkDeviceSize

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkBindBufferMemory

vkBindImageMemory(3)

Name

vkBindImageMemory - Bind device memory to an image object

C Specification

To attach memory to an image object, call:

VkResult vkBindImageMemory(
    VkDevice                                    device,
    VkImage                                     image,
    VkDeviceMemory                              memory,
    VkDeviceSize                                memoryOffset);

Parameters

  • device is the logical device that owns the image and memory.
  • image is the image.
  • memory is the VkDeviceMemory object describing the device memory to attach.
  • memoryOffset is the start offset of the region of memory which is to be bound to the image. The number of bytes returned in the VkMemoryRequirements::size member in memory, starting from memoryOffset bytes, will be bound to the specified image.

Description

Valid Usage
  • image must not already be backed by a memory object
  • image must not have been created with any sparse memory binding flags
  • memoryOffset must be less than the size of memory
  • memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements with image
  • memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements with image
  • The size member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements with image must be less than or equal to the size of memory minus memoryOffset
Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • image must be a valid VkImage handle
  • memory must be a valid VkDeviceMemory handle
  • image must have been created, allocated, or retrieved from device
  • memory must have been created, allocated, or retrieved from device
Host Synchronization
  • Host access to image must be externally synchronized
Return Codes
Success
  • VK_SUCCESS
Failure
  • VK_ERROR_OUT_OF_HOST_MEMORY
  • VK_ERROR_OUT_OF_DEVICE_MEMORY

See Also

VkDevice, VkDeviceMemory, VkDeviceSize, VkImage

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkBindImageMemory

vkCmdBeginQuery(3)

Name

vkCmdBeginQuery - Begin a query

C Specification

To begin a query, call:

void vkCmdBeginQuery(
    VkCommandBuffer                             commandBuffer,
    VkQueryPool                                 queryPool,
    uint32_t                                    query,
    VkQueryControlFlags                         flags);

Parameters

  • commandBuffer is the command buffer into which this command will be recorded.
  • queryPool is the query pool that will manage the results of the query.
  • query is the query index within the query pool that will contain the results.
  • flags is a bitmask of VkQueryControlFlagBits specifying constraints on the types of queries that can be performed.

Description

If the queryType of the pool is VK_QUERY_TYPE_OCCLUSION and flags contains VK_QUERY_CONTROL_PRECISE_BIT, an implementation must return a result that matches the actual number of samples passed. This is described in more detail in Occlusion Queries.

After beginning a query, that query is considered active within the command buffer it was called in until that same query is ended. Queries active in a primary command buffer when secondary command buffers are executed are considered active for those secondary command buffers.

Valid Usage
  • The query identified by queryPool and query must currently not be active
  • The query identified by queryPool and query must be unavailable
  • If the precise occlusion queries feature is not enabled, or the queryType used to create queryPool was not VK_QUERY_TYPE_OCCLUSION, flags must not contain VK_QUERY_CONTROL_PRECISE_BIT
  • queryPool must have been created with a queryType that differs from that of any other queries that have been made active, and are currently still active within commandBuffer
  • query must be less than the number of queries in queryPool
  • If the queryType used to create queryPool was VK_QUERY_TYPE_OCCLUSION, the VkCommandPool that commandBuffer was allocated from must support graphics operations
  • If the queryType used to create queryPool was VK_QUERY_TYPE_PIPELINE_STATISTICS and any of the pipelineStatistics indicate graphics operations, the VkCommandPool that commandBuffer was allocated from must support graphics operations
  • If the queryType used to create queryPool was VK_QUERY_TYPE_PIPELINE_STATISTICS and any of the pipelineStatistics indicate compute operations, the VkCommandPool that commandBuffer was allocated from must support compute operations
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
  • queryPool must be a valid VkQueryPool handle
  • flags must be a valid combination of VkQueryControlFlagBits values
  • commandBuffer must be in the recording state
  • The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations
  • Both of commandBuffer, and queryPool must have been created, allocated, or retrieved from the same VkDevice
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

See Also

VkCommandBuffer, VkQueryControlFlags, VkQueryPool

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCmdBeginQuery

vkCmdBeginRenderPass(3)

Name

vkCmdBeginRenderPass - Begin a new render pass

C Specification

To begin a render pass instance, call:

void vkCmdBeginRenderPass(
    VkCommandBuffer                             commandBuffer,
    const VkRenderPassBeginInfo*                pRenderPassBegin,
    VkSubpassContents                           contents);

Parameters

  • commandBuffer is the command buffer in which to record the command.
  • pRenderPassBegin is a pointer to a VkRenderPassBeginInfo structure (defined below) which indicates 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.

Description

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
  • 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 subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT set
  • 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_STENCIL_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT set
  • 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 subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with VK_IMAGE_USAGE_SAMPLED_BIT or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT set
  • 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 subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT set
  • 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 subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT set
  • 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.
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
  • pRenderPassBegin must be a pointer to a valid VkRenderPassBeginInfo structure
  • contents must be a valid VkSubpassContents value
  • commandBuffer must be in the recording state
  • The VkCommandPool that commandBuffer was allocated from must support graphics operations
  • This command must only be called outside of a render pass instance
  • 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

See Also

VkCommandBuffer, VkRenderPassBeginInfo, VkSubpassContents

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCmdBeginRenderPass

vkCmdBindDescriptorSets(3)

Name

vkCmdBindDescriptorSets - Binds descriptor sets to a command buffer

C Specification

To bind one or more descriptor sets to a command buffer, call:

void vkCmdBindDescriptorSets(
    VkCommandBuffer                             commandBuffer,
    VkPipelineBindPoint                         pipelineBindPoint,
    VkPipelineLayout                            layout,
    uint32_t                                    firstSet,
    uint32_t                                    descriptorSetCount,
    const VkDescriptorSet*                      pDescriptorSets,
    uint32_t                                    dynamicOffsetCount,
    const uint32_t*                             pDynamicOffsets);

Parameters

  • commandBuffer is the command buffer that the descriptor sets will be bound to.
  • pipelineBindPoint is a VkPipelineBindPoint indicating whether the descriptors will be used by graphics pipelines or compute pipelines. There is a separate set of bind points for each of graphics and compute, so binding one does not disturb the other.
  • layout is a VkPipelineLayout object used to program the bindings.
  • firstSet is the set number of the first descriptor set to be bound.
  • descriptorSetCount is the number of elements in the pDescriptorSets array.
  • pDescriptorSets is an array of handles to VkDescriptorSet objects describing the descriptor sets to write to.
  • dynamicOffsetCount is the number of dynamic offsets in the pDynamicOffsets array.
  • pDynamicOffsets is a pointer to an array of uint32_t values specifying dynamic offsets.

Description

vkCmdBindDescriptorSets causes the sets numbered [firstSet.. firstSet+descriptorSetCount-1] to use the bindings stored in pDescriptorSets[0..descriptorSetCount-1] for subsequent rendering commands (either compute or graphics, according to the pipelineBindPoint). Any bindings that were previously applied via these sets are no longer valid.

Once bound, a descriptor set affects rendering of subsequent graphics or compute commands in the command buffer until a different set is bound to the same set number, or else until the set is disturbed as described in Pipeline Layout Compatibility.

A compatible descriptor set must be bound for all set numbers that any shaders in a pipeline access, at the time that a draw or dispatch command is recorded to execute using that pipeline. However, if none of the shaders in a pipeline statically use any bindings with a particular set number, then no descriptor set need be bound for that set number, even if the pipeline layout includes a non-trivial descriptor set layout for that set number.

If any of the sets being bound include dynamic uniform or storage buffers, then pDynamicOffsets includes one element for each array element in each dynamic descriptor type binding in each set. Values are taken from pDynamicOffsets in an order such that all entries for set N come before set N+1; within a set, entries are ordered by the binding numbers in the descriptor set layouts; and within a binding array, elements are in order. dynamicOffsetCount must equal the total number of dynamic descriptors in the sets being bound.

The effective offset used for dynamic uniform and storage buffer bindings is the sum of the relative offset taken from pDynamicOffsets, and the base address of the buffer plus base offset in the descriptor set. The length of the dynamic uniform and storage buffer bindings is the buffer range as specified in the descriptor set.

Each of the pDescriptorSets must be compatible with the pipeline layout specified by layout. The layout used to program the bindings must also be compatible with the pipeline used in subsequent graphics or compute commands, as defined in the Pipeline Layout Compatibility section.

The descriptor set contents bound by a call to vkCmdBindDescriptorSets may be consumed during host execution of the command, or during shader execution of the resulting draws, or any time in between. Thus, the contents must not be altered (overwritten by an update command, or freed) between when the command is recorded and when the command completes executing on the queue. The contents of pDynamicOffsets are consumed immediately during execution of vkCmdBindDescriptorSets. Once all pending uses have completed, it is legal to update and reuse a descriptor set.

Valid Usage
  • Any given element of pDescriptorSets must have been allocated with a VkDescriptorSetLayout that matches (is the same as, or identically defined as) the VkDescriptorSetLayout at set n in layout, where n is the sum of firstSet and the index into pDescriptorSets
  • dynamicOffsetCount must be equal to the total number of dynamic descriptors in pDescriptorSets
  • The sum of firstSet and descriptorSetCount must be less than or equal to VkPipelineLayoutCreateInfo::setLayoutCount provided when layout was created
  • pipelineBindPoint must be supported by the commandBuffer’s parent VkCommandPool’s queue family
  • Any given element of pDynamicOffsets must satisfy the required alignment for the corresponding descriptor binding’s descriptor type
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
  • pipelineBindPoint must be a valid VkPipelineBindPoint value
  • layout must be a valid VkPipelineLayout handle
  • pDescriptorSets must be a pointer to an array of descriptorSetCount valid VkDescriptorSet handles
  • If dynamicOffsetCount is not 0, pDynamicOffsets must be a pointer to an array of dynamicOffsetCount uint32_t values
  • commandBuffer must be in the recording state
  • The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations
  • descriptorSetCount must be greater than 0
  • Each of commandBuffer, layout, and the elements of pDescriptorSets must have been created, allocated, or retrieved from the same VkDevice
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

See Also

VkCommandBuffer, VkDescriptorSet, VkPipelineBindPoint, VkPipelineLayout

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCmdBindDescriptorSets

vkCmdBindIndexBuffer(3)

Name

vkCmdBindIndexBuffer - Bind an index buffer to a command buffer

C Specification

To bind an index buffer to a command buffer, call:

void vkCmdBindIndexBuffer(
    VkCommandBuffer                             commandBuffer,
    VkBuffer                                    buffer,
    VkDeviceSize                                offset,
    VkIndexType                                 indexType);

Parameters

  • commandBuffer is the command buffer into which the command is recorded.
  • buffer is the buffer being bound.
  • offset is the starting offset in bytes within buffer used in index buffer address calculations.
  • indexType is a VkIndexType value specifying whether indices are treated as 16 bits or 32 bits.

Description

Valid Usage
  • offset must be less than the size of buffer
  • The sum of offset and the address of the range of VkDeviceMemory object that is backing buffer, must be a multiple of the type indicated by indexType
  • buffer must have been created with the VK_BUFFER_USAGE_INDEX_BUFFER_BIT flag
  • If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
  • buffer must be a valid VkBuffer handle
  • indexType must be a valid VkIndexType value
  • commandBuffer must be in the recording state
  • The VkCommandPool that commandBuffer was allocated from must support graphics operations
  • Both of buffer, and commandBuffer must have been created, allocated, or retrieved from the same VkDevice
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

See Also

VkBuffer, VkCommandBuffer, VkDeviceSize, VkIndexType

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCmdBindIndexBuffer

vkCmdBindPipeline(3)

Name

vkCmdBindPipeline - Bind a pipeline object to a command buffer

C Specification

Once a pipeline has been created, it can be bound to the command buffer using the command:

void vkCmdBindPipeline(
    VkCommandBuffer                             commandBuffer,
    VkPipelineBindPoint                         pipelineBindPoint,
    VkPipeline                                  pipeline);

Parameters

  • commandBuffer is the command buffer that the pipeline will be bound to.
  • pipelineBindPoint is a VkPipelineBindPoint value specifying whether to bind to the compute or graphics bind point. Binding one does not disturb the other.
  • pipeline is the pipeline to be bound.

Description

Once bound, a pipeline binding affects subsequent graphics or compute commands in the command buffer until a different pipeline is bound to the bind point. The pipeline bound to VK_PIPELINE_BIND_POINT_COMPUTE controls the behavior of vkCmdDispatch and vkCmdDispatchIndirect. The pipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS controls the behavior of vkCmdDraw, vkCmdDrawIndexed, vkCmdDrawIndirect, and vkCmdDrawIndexedIndirect. No other commands are affected by the pipeline state.

Valid Usage
  • If pipelineBindPoint is VK_PIPELINE_BIND_POINT_COMPUTE, the VkCommandPool that commandBuffer was allocated from must support compute operations
  • If pipelineBindPoint is VK_PIPELINE_BIND_POINT_GRAPHICS, the VkCommandPool that commandBuffer was allocated from must support graphics operations
  • If pipelineBindPoint is VK_PIPELINE_BIND_POINT_COMPUTE, pipeline must be a compute pipeline
  • If pipelineBindPoint is VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline must be a graphics pipeline
  • If the variable multisample rate feature is not supported, pipeline is a graphics pipeline, the current subpass has no attachments, and this is not the first call to this function with a graphics pipeline after transitioning to the current subpass, then the sample count specified by this pipeline must match that set in the previous pipeline
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
  • pipelineBindPoint must be a valid VkPipelineBindPoint value
  • pipeline must be a valid VkPipeline handle
  • commandBuffer must be in the recording state
  • The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations
  • Both of commandBuffer, and pipeline must have been created, allocated, or retrieved from the same VkDevice
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

See Also

VkCommandBuffer, VkPipeline, VkPipelineBindPoint

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCmdBindPipeline

vkCmdBindVertexBuffers(3)

Name

vkCmdBindVertexBuffers - Bind vertex buffers to a command buffer

C Specification

To bind vertex buffers to a command buffer for use in subsequent draw commands, call:

void vkCmdBindVertexBuffers(
    VkCommandBuffer                             commandBuffer,
    uint32_t                                    firstBinding,
    uint32_t                                    bindingCount,
    const VkBuffer*                             pBuffers,
    const VkDeviceSize*                         pOffsets);

Parameters

  • commandBuffer is the command buffer into which the command is recorded.
  • firstBinding is the index of the first vertex input binding whose state is updated by the command.
  • bindingCount is the number of vertex input bindings whose state is updated by the command.
  • pBuffers is a pointer to an array of buffer handles.
  • pOffsets is a pointer to an array of buffer offsets.

Description

The values taken from elements i of pBuffers and pOffsets replace the current state for the vertex input binding firstBinding + i, for i in [0, bindingCount). The vertex input binding is updated to start at the offset indicated by pOffsets[i] from the start of the buffer pBuffers[i]. All vertex input attributes that use each of these bindings will use these updated addresses in their address calculations for subsequent draw commands.

Valid Usage
  • firstBinding must be less than VkPhysicalDeviceLimits::maxVertexInputBindings
  • The sum of firstBinding and bindingCount must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputBindings
  • All elements of pOffsets must be less than the size of the corresponding element in pBuffers
  • All elements of pBuffers must have been created with the VK_BUFFER_USAGE_VERTEX_BUFFER_BIT flag
  • Each element of pBuffers that is non-sparse must be bound completely and contiguously to a single VkDeviceMemory object
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
  • pBuffers must be a pointer to an array of bindingCount valid VkBuffer handles
  • pOffsets must be a pointer to an array of bindingCount VkDeviceSize values
  • commandBuffer must be in the recording state
  • The VkCommandPool that commandBuffer was allocated from must support graphics operations
  • bindingCount must be greater than 0
  • Both of commandBuffer, and the elements of pBuffers must have been created, allocated, or retrieved from the same VkDevice
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

See Also

VkBuffer, VkCommandBuffer, VkDeviceSize

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCmdBindVertexBuffers

vkCmdBlitImage(3)

Name

vkCmdBlitImage - Copy regions of an image, potentially performing format conversion,

C Specification

To copy regions of a source image into a destination image, potentially performing format conversion, arbitrary scaling, and filtering, call:

void vkCmdBlitImage(
    VkCommandBuffer                             commandBuffer,
    VkImage                                     srcImage,
    VkImageLayout                               srcImageLayout,
    VkImage                                     dstImage,
    VkImageLayout                               dstImageLayout,
    uint32_t                                    regionCount,
    const VkImageBlit*                          pRegions,
    VkFilter                                    filter);

Parameters

  • commandBuffer is the command buffer into which the command will be recorded.
  • srcImage is the source image.
  • srcImageLayout is the layout of the source image subresources for the blit.
  • dstImage is the destination image.
  • dstImageLayout is the layout of the destination image subresources for the blit.
  • regionCount is the number of regions to blit.
  • pRegions is a pointer to an array of VkImageBlit structures specifying the regions to blit.
  • filter is a VkFilter specifying the filter to apply if the blits require scaling.

Description

vkCmdBlitImage must not be used for multisampled source or destination images. Use vkCmdResolveImage for this purpose.

As the sizes of the source and destination extents can differ in any dimension, texels in the source extent are scaled and filtered to the destination extent. Scaling occurs via the following operations:

  • For each destination texel, the integer coordinate of that texel is converted to an unnormalized texture coordinate, using the effective inverse of the equations described in unnormalized to integer conversion:

    ubase = i + ½
    vbase = j + ½
    wbase = k + ½
  • These base coordinates are then offset by the first destination offset:

    uoffset = ubase - xdst0
    voffset = vbase - ydst0
    woffset = wbase - zdst0
    aoffset = a - baseArrayCountdst
  • The scale is determined from the source and destination regions, and applied to the offset coordinates:

    scale_u = (xsrc1 - xsrc0) / (xdst1 - xdst0)
    scale_v = (ysrc1 - ysrc0) / (ydst1 - ydst0)
    scale_w = (zsrc1 - zsrc0) / (zdst1 - zdst0)
    uscaled = uoffset * scaleu
    vscaled = voffset * scalev
    wscaled = woffset * scalew
  • Finally the source offset is added to the scaled coordinates, to determine the final unnormalized coordinates used to sample from srcImage:

    u = uscaled + xsrc0
    v = vscaled + ysrc0
    w = wscaled + zsrc0
    q = mipLevel
    a = aoffset + baseArrayCountsrc

These coordinates are used to sample from the source image, as described in Image Operations chapter, with the filter mode equal to that of filter, a mipmap mode of VK_SAMPLER_MIPMAP_MODE_NEAREST and an address mode of VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE. Implementations must clamp at the edge of the source image, and may additionally clamp to the edge of the source region.

Note

Due to allowable rounding errors in the generation of the source texture coordinates, it is not always possible to guarantee exactly which source texels will be sampled for a given blit. As rounding errors are implementation dependent, the exact results of a blitting operation are also implementation dependent.

Blits are done layer by layer starting with the baseArrayLayer member of srcSubresource for the source and dstSubresource for the destination. layerCount layers are blitted to the destination image.

3D textures are blitted slice by slice. Slices in the source region bounded by srcOffsets[0].z and srcOffsets[1].z are copied to slices in the destination region bounded by dstOffsets[0].z and dstOffsets[1].z. For each destination slice, a source z coordinate is linearly interpolated between srcOffsets[0].z and srcOffsets[1].z. If the filter parameter is VK_FILTER_LINEAR then the value sampled from the source image is taken by doing linear filtering using the interpolated z coordinate. If filter parameter is VK_FILTER_NEAREST then value sampled from the source image is taken from the single nearest slice (with undefined rounding mode).

The following filtering and conversion rules apply:

  • Integer formats can only be converted to other integer formats with the same signedness.
  • No format conversion is supported between depth/stencil images. The formats must match.
  • Format conversions on unorm, snorm, unscaled and packed float formats of the copied aspect of the image are performed by first converting the pixels to float values.
  • For sRGB source formats, nonlinear RGB values are converted to linear representation prior to filtering.
  • After filtering, the float values are first clamped and then cast to the destination image format. In case of sRGB destination format, linear RGB values are converted to nonlinear representation before writing the pixel to the image.

Signed and unsigned integers are converted by first clamping to the representable range of the destination format, then casting the value.

Valid Usage
  • The source region specified by a given element of pRegions must be a region that is contained within srcImage
  • The destination region specified by a given element of pRegions must be a region that is contained within dstImage
  • The union of all destination regions, specified by the elements of pRegions, must not overlap in memory with any texel that may be sampled during the blit operation
  • srcImage must use a format that supports VK_FORMAT_FEATURE_BLIT_SRC_BIT, which is indicated by VkFormatProperties::linearTilingFeatures (for linearly tiled images) or VkFormatProperties::optimalTilingFeatures (for optimally tiled images) - as returned by vkGetPhysicalDeviceFormatProperties
  • srcImage must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag
  • If srcImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
  • srcImageLayout must specify the layout of the image subresources of srcImage specified in pRegions at the time this command is executed on a VkDevice
  • srcImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL
  • dstImage must use a format that supports VK_FORMAT_FEATURE_BLIT_DST_BIT, which is indicated by VkFormatProperties::linearTilingFeatures (for linearly tiled images) or VkFormatProperties::optimalTilingFeatures (for optimally tiled images) - as returned by vkGetPhysicalDeviceFormatProperties
  • dstImage must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag
  • If dstImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
  • dstImageLayout must specify the layout of the image subresources of dstImage specified in pRegions at the time this command is executed on a VkDevice
  • dstImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL
  • The sample count of srcImage and dstImage must both be equal to VK_SAMPLE_COUNT_1_BIT
  • If either of srcImage or dstImage was created with a signed integer VkFormat, the other must also have been created with a signed integer VkFormat
  • If either of srcImage or dstImage was created with an unsigned integer VkFormat, the other must also have been created with an unsigned integer VkFormat
  • If either of srcImage or dstImage was created with a depth/stencil format, the other must have exactly the same format
  • If srcImage was created with a depth/stencil format, filter must be VK_FILTER_NEAREST
  • srcImage must have been created with a samples value of VK_SAMPLE_COUNT_1_BIT
  • dstImage must have been created with a samples value of VK_SAMPLE_COUNT_1_BIT
  • If filter is VK_FILTER_LINEAR, srcImage must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
  • srcImage must be a valid VkImage handle
  • srcImageLayout must be a valid VkImageLayout value
  • dstImage must be a valid VkImage handle
  • dstImageLayout must be a valid VkImageLayout value
  • pRegions must be a pointer to an array of regionCount valid VkImageBlit structures
  • filter must be a valid VkFilter value
  • commandBuffer must be in the recording state
  • The VkCommandPool that commandBuffer was allocated from must support graphics operations
  • This command must only be called outside of a render pass instance
  • regionCount must be greater than 0
  • Each of commandBuffer, dstImage, and srcImage must have been created, allocated, or retrieved from the same VkDevice
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
Secondary

Outside

Graphics

Transfer

See Also

VkCommandBuffer, VkFilter, VkImage, VkImageBlit, VkImageLayout

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCmdBlitImage

vkCmdClearAttachments(3)

Name

vkCmdClearAttachments - Clear regions within currently bound framebuffer attachments

C Specification

To clear one or more regions of color and depth/stencil attachments inside a render pass instance, call:

void vkCmdClearAttachments(
    VkCommandBuffer                             commandBuffer,
    uint32_t                                    attachmentCount,
    const VkClearAttachment*                    pAttachments,
    uint32_t                                    rectCount,
    const VkClearRect*                          pRects);

Parameters

  • commandBuffer is the command buffer into which the command will be recorded.
  • attachmentCount is the number of entries in the pAttachments array.
  • pAttachments is a pointer to an array of VkClearAttachment structures defining the attachments to clear and the clear values to use.
  • rectCount is the number of entries in the pRects array.
  • pRects points to an array of VkClearRect structures defining regions within each selected attachment to clear.

Description

vkCmdClearAttachments can clear multiple regions of each attachment used in the current subpass of a render pass instance. This command must be called only inside a render pass instance, and implicitly selects the images to clear based on the current framebuffer attachments and the command parameters.

Valid Usage
  • If the aspectMask member of any given element of pAttachments contains VK_IMAGE_ASPECT_COLOR_BIT, the colorAttachment member of those elements must refer to a valid color attachment in the current subpass
  • The rectangular region specified by a given element of pRects must be contained within the render area of the current render pass instance
  • The layers specified by a given element of pRects must be contained within every attachment that pAttachments refers to
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
  • pAttachments must be a pointer to an array of attachmentCount valid VkClearAttachment structures
  • pRects must be a pointer to an array of rectCount VkClearRect structures
  • commandBuffer must be in the recording state
  • The VkCommandPool that commandBuffer was allocated from must support graphics operations
  • This command must only be called inside of a render pass instance
  • attachmentCount must be greater than 0
  • rectCount must be greater than 0
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
Secondary

Inside

Graphics

Graphics

See Also

VkClearAttachment, VkClearRect, VkCommandBuffer

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCmdClearAttachments

vkCmdClearColorImage(3)

Name

vkCmdClearColorImage - Clear regions of a color image

C Specification

To clear one or more subranges of a color image, call:

void vkCmdClearColorImage(
    VkCommandBuffer                             commandBuffer,
    VkImage                                     image,
    VkImageLayout                               imageLayout,
    const VkClearColorValue*                    pColor,
    uint32_t                                    rangeCount,
    const VkImageSubresourceRange*              pRanges);

Parameters

  • commandBuffer is the command buffer into which the command will be recorded.
  • image is the image to be cleared.
  • imageLayout specifies the current layout of the image subresource ranges to be cleared, and must be VK_IMAGE_LAYOUT_GENERAL or VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL.
  • pColor is a pointer to a VkClearColorValue structure that contains the values the image subresource ranges will be cleared to (see html/vkspec.html#clears-values below).
  • rangeCount is the number of image subresource range structures in pRanges.
  • pRanges points to an array of VkImageSubresourceRange structures that describe a range of mipmap levels, array layers, and aspects to be cleared, as described in Image Views. The aspectMask of all image subresource ranges must only include VK_IMAGE_ASPECT_COLOR_BIT.

Description

Each specified range in pRanges is cleared to the value specified by pColor.

Valid Usage
  • image must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag
  • If image is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
  • imageLayout must specify the layout of the image subresource ranges of image specified in pRanges at the time this command is executed on a VkDevice
  • imageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL
  • The VkImageSubresourceRange::baseMipLevel members of the elements of the pRanges array must each be less than the mipLevels specified in VkImageCreateInfo when image was created
  • If the VkImageSubresourceRange::levelCount member of any element of the pRanges array is not VK_REMAINING_MIP_LEVELS, it must be non-zero and VkImageSubresourceRange::baseMipLevel + VkImageSubresourceRange::levelCount for that element of the pRanges array must be less than or equal to the mipLevels specified in VkImageCreateInfo when image was created
  • The VkImageSubresourceRange::baseArrayLayer members of the elements of the pRanges array must each be less than the arrayLayers specified in VkImageCreateInfo when image was created
  • If the VkImageSubresourceRange::layerCount member of any element of the pRanges array is not VK_REMAINING_ARRAY_LAYERS, it must be non-zero and VkImageSubresourceRange::baseArrayLayer + VkImageSubresourceRange::layerCount for that element of the pRanges array must be less than or equal to the arrayLayers specified in VkImageCreateInfo when image was created
  • image must not have a compressed or depth/stencil format
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
  • image must be a valid VkImage handle
  • imageLayout must be a valid VkImageLayout value
  • pColor must be a pointer to a valid VkClearColorValue union
  • pRanges must be a pointer to an array of rangeCount valid VkImageSubresourceRange structures
  • commandBuffer must be in the recording state
  • The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations
  • This command must only be called outside of a render pass instance
  • rangeCount must be greater than 0
  • Both of commandBuffer, and image must have been created, allocated, or retrieved from the same VkDevice
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
Secondary

Outside

Graphics
compute

Transfer

See Also

VkClearColorValue, VkCommandBuffer, VkImage, VkImageLayout, VkImageSubresourceRange

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCmdClearColorImage

vkCmdClearDepthStencilImage(3)

Name

vkCmdClearDepthStencilImage - Fill regions of a combined depth/stencil image

C Specification

To clear one or more subranges of a depth/stencil image, call:

void vkCmdClearDepthStencilImage(
    VkCommandBuffer                             commandBuffer,
    VkImage                                     image,
    VkImageLayout                               imageLayout,
    const VkClearDepthStencilValue*             pDepthStencil,
    uint32_t                                    rangeCount,
    const VkImageSubresourceRange*              pRanges);

Parameters

  • commandBuffer is the command buffer into which the command will be recorded.
  • image is the image to be cleared.
  • imageLayout specifies the current layout of the image subresource ranges to be cleared, and must be VK_IMAGE_LAYOUT_GENERAL or VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL.
  • pDepthStencil is a pointer to a VkClearDepthStencilValue structure that contains the values the depth and stencil image subresource ranges will be cleared to (see html/vkspec.html#clears-values below).
  • rangeCount is the number of image subresource range structures in pRanges.
  • pRanges points to an array of VkImageSubresourceRange structures that describe a range of mipmap levels, array layers, and aspects to be cleared, as described in Image Views. The aspectMask of each image subresource range in pRanges can include VK_IMAGE_ASPECT_DEPTH_BIT if the image format has a depth component, and VK_IMAGE_ASPECT_STENCIL_BIT if the image format has a stencil component. pDepthStencil is a pointer to a VkClearDepthStencilValue structure that contains the values the image subresource ranges will be cleared to (see html/vkspec.html#clears-values below).

Description

Valid Usage
  • image must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag
  • If image is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
  • imageLayout must specify the layout of the image subresource ranges of image specified in pRanges at the time this command is executed on a VkDevice
  • imageLayout must be either of VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL
  • The VkImageSubresourceRange::baseMipLevel members of the elements of the pRanges array must each be less than the mipLevels specified in VkImageCreateInfo when image was created
  • If the VkImageSubresourceRange::levelCount member of any element of the pRanges array is not VK_REMAINING_MIP_LEVELS, it must be non-zero and VkImageSubresourceRange::baseMipLevel + VkImageSubresourceRange::levelCount for that element of the pRanges array must be less than or equal to the mipLevels specified in VkImageCreateInfo when image was created
  • The VkImageSubresourceRange::baseArrayLayer members of the elements of the pRanges array must each be less than the arrayLayers specified in VkImageCreateInfo when image was created
  • If the VkImageSubresourceRange::layerCount member of any element of the pRanges array is not VK_REMAINING_ARRAY_LAYERS, it must be non-zero and VkImageSubresourceRange::baseArrayLayer + VkImageSubresourceRange::layerCount for that element of the pRanges array must be less than or equal to the arrayLayers specified in VkImageCreateInfo when image was created
  • image must have a depth/stencil format
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
  • image must be a valid VkImage handle
  • imageLayout must be a valid VkImageLayout value
  • pDepthStencil must be a pointer to a valid VkClearDepthStencilValue structure
  • pRanges must be a pointer to an array of rangeCount valid VkImageSubresourceRange structures
  • commandBuffer must be in the recording state
  • The VkCommandPool that commandBuffer was allocated from must support graphics operations
  • This command must only be called outside of a render pass instance
  • rangeCount must be greater than 0
  • Both of commandBuffer, and image must have been created, allocated, or retrieved from the same VkDevice
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
Secondary

Outside

Graphics

Transfer

See Also

VkClearDepthStencilValue, VkCommandBuffer, VkImage, VkImageLayout, VkImageSubresourceRange

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCmdClearDepthStencilImage

vkCmdCopyBuffer(3)

Name

vkCmdCopyBuffer - Copy data between buffer regions

C Specification

To copy data between buffer objects, call:

void vkCmdCopyBuffer(
    VkCommandBuffer                             commandBuffer,
    VkBuffer                                    srcBuffer,
    VkBuffer                                    dstBuffer,
    uint32_t                                    regionCount,
    const VkBufferCopy*                         pRegions);

Parameters

  • commandBuffer is the command buffer into which the command will be recorded.
  • srcBuffer is the source buffer.
  • dstBuffer is the destination buffer.
  • regionCount is the number of regions to copy.
  • pRegions is a pointer to an array of VkBufferCopy structures specifying the regions to copy.

Description

Each region in pRegions is copied from the source buffer to the same region of the destination buffer. srcBuffer and dstBuffer can be the same buffer or alias the same memory, but the result is undefined if the copy regions overlap in memory.

Valid Usage
  • The size member of a given element of pRegions must be greater than 0
  • The srcOffset member of a given element of pRegions must be less than the size of srcBuffer
  • The dstOffset member of a given element of pRegions must be less than the size of dstBuffer
  • The size member of a given element of pRegions must be less than or equal to the size of srcBuffer minus srcOffset
  • The size member of a given element of pRegions must be less than or equal to the size of dstBuffer minus dstOffset
  • The union of the source regions, and the union of the destination regions, specified by the elements of pRegions, must not overlap in memory
  • srcBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_SRC_BIT usage flag
  • If srcBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
  • dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag
  • If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
  • srcBuffer must be a valid VkBuffer handle
  • dstBuffer must be a valid VkBuffer handle
  • pRegions must be a pointer to an array of regionCount VkBufferCopy structures
  • commandBuffer must be in the recording state
  • The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations
  • This command must only be called outside of a render pass instance
  • regionCount must be greater than 0
  • Each of commandBuffer, dstBuffer, and srcBuffer must have been created, allocated, or retrieved from the same VkDevice
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
Secondary

Outside

Transfer
graphics
compute

Transfer

See Also

VkBuffer, VkBufferCopy, VkCommandBuffer

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCmdCopyBuffer

vkCmdCopyBufferToImage(3)

Name

vkCmdCopyBufferToImage - Copy data from a buffer into an image

C Specification

To copy data from a buffer object to an image object, call:

void vkCmdCopyBufferToImage(
    VkCommandBuffer                             commandBuffer,
    VkBuffer                                    srcBuffer,
    VkImage                                     dstImage,
    VkImageLayout                               dstImageLayout,
    uint32_t                                    regionCount,
    const VkBufferImageCopy*                    pRegions);

Parameters

  • commandBuffer is the command buffer into which the command will be recorded.
  • srcBuffer is the source buffer.
  • dstImage is the destination image.
  • dstImageLayout is the layout of the destination image subresources for the copy.
  • regionCount is the number of regions to copy.
  • pRegions is a pointer to an array of VkBufferImageCopy structures specifying the regions to copy.

Description

Each region in pRegions is copied from the specified region of the source buffer to the specified region of the destination image.

Valid Usage
  • The buffer region specified by a given element of pRegions must be a region that is contained within srcBuffer
  • The image region specified by a given element of pRegions must be a region that is contained within dstImage
  • The union of all source regions, and the union of all destination regions, specified by the elements of pRegions, must not overlap in memory
  • srcBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_SRC_BIT usage flag
  • If srcBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
  • dstImage must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag
  • If dstImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
  • dstImage must have a sample count equal to VK_SAMPLE_COUNT_1_BIT
  • dstImageLayout must specify the layout of the image subresources of dstImage specified in pRegions at the time this command is executed on a VkDevice
  • dstImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
  • srcBuffer must be a valid VkBuffer handle
  • dstImage must be a valid VkImage handle
  • dstImageLayout must be a valid VkImageLayout value
  • pRegions must be a pointer to an array of regionCount valid VkBufferImageCopy structures
  • commandBuffer must be in the recording state
  • The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations
  • This command must only be called outside of a render pass instance
  • regionCount must be greater than 0
  • Each of commandBuffer, dstImage, and srcBuffer must have been created, allocated, or retrieved from the same VkDevice
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
Secondary

Outside

Transfer
graphics
compute

Transfer

See Also

VkBuffer, VkBufferImageCopy, VkCommandBuffer, VkImage, VkImageLayout

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCmdCopyBufferToImage

vkCmdCopyImage(3)

Name

vkCmdCopyImage - Copy data between images

C Specification

To copy data between image objects, call:

void vkCmdCopyImage(
    VkCommandBuffer                             commandBuffer,
    VkImage                                     srcImage,
    VkImageLayout                               srcImageLayout,
    VkImage                                     dstImage,
    VkImageLayout                               dstImageLayout,
    uint32_t                                    regionCount,
    const VkImageCopy*                          pRegions);

Parameters

  • commandBuffer is the command buffer into which the command will be recorded.
  • srcImage is the source image.
  • srcImageLayout is the current layout of the source image subresource.
  • dstImage is the destination image.
  • dstImageLayout is the current layout of the destination image subresource.
  • regionCount is the number of regions to copy.
  • pRegions is a pointer to an array of VkImageCopy structures specifying the regions to copy.

Description

Each region in pRegions is copied from the source image to the same region of the destination image. srcImage and dstImage can be the same image or alias the same memory.

The formats of srcImage and dstImage must be compatible. Formats are considered compatible if their element size is the same between both formats. For example, VK_FORMAT_R8G8B8A8_UNORM is compatible with VK_FORMAT_R32_UINT because both texels are 4 bytes in size. Depth/stencil formats must match exactly.

vkCmdCopyImage allows copying between size-compatible compressed and uncompressed internal formats. Formats are size-compatible if the element size of the uncompressed format is equal to the element size (compressed texel block size) of the compressed format. Such a copy does not perform on-the-fly compression or decompression. When copying from an uncompressed format to a compressed format, each texel of uncompressed data of the source image is copied as a raw value to the corresponding compressed texel block of the destination image. When copying from a compressed format to an uncompressed format, each compressed texel block of the source image is copied as a raw value to the corresponding texel of uncompressed data in the destination image. Thus, for example, it is legal to copy between a 128-bit uncompressed format and a compressed format which has a 128-bit sized compressed texel block representing 4×4 texels (using 8 bits per texel), or between a 64-bit uncompressed format and a compressed format which has a 64-bit sized compressed texel block representing 4×4 texels (using 4 bits per texel).

When copying between compressed and uncompressed formats the extent members represent the texel dimensions of the source image and not the destination. When copying from a compressed image to an uncompressed image the image texel dimensions written to the uncompressed image will be source extent divided by the compressed texel block dimensions. When copying from an uncompressed image to a compressed image the image texel dimensions written to the compressed image will be the source extent multiplied by the compressed texel block dimensions. In both cases the number of bytes read and the number of bytes written will be identical.

Copying to or from block-compressed images is typically done in multiples of the compressed texel block size. For this reason the extent must be a multiple of the compressed texel block dimension. There is one exception to this rule which is required to handle compressed images created with dimensions that are not a multiple of the compressed texel block dimensions: if the srcImage is compressed, then:

  • If extent.width is not a multiple of the compressed texel block width, then (extent.width + srcOffset.x) must equal the image subresource width.
  • If extent.height is not a multiple of the compressed texel block height, then (extent.height + srcOffset.y) must equal the image subresource height.
  • If extent.depth is not a multiple of the compressed texel block depth, then (extent.depth + srcOffset.z) must equal the image subresource depth.

Similarly, if the dstImage is compressed, then:

  • If extent.width is not a multiple of the compressed texel block width, then (extent.width + dstOffset.x) must equal the image subresource width.
  • If extent.height is not a multiple of the compressed texel block height, then (extent.height + dstOffset.y) must equal the image subresource height.
  • If extent.depth is not a multiple of the compressed texel block depth, then (extent.depth + dstOffset.z) must equal the image subresource depth.

This allows the last compressed texel block of the image in each non-multiple dimension to be included as a source or destination of the copy.

vkCmdCopyImage can be used to copy image data between multisample images, but both images must have the same number of samples.

Valid Usage
  • The source region specified by a given element of pRegions must be a region that is contained within srcImage
  • The destination region specified by a given element of pRegions must be a region that is contained within dstImage
  • The union of all source regions, and the union of all destination regions, specified by the elements of pRegions, must not overlap in memory
  • srcImage must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag
  • If srcImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
  • srcImageLayout must specify the layout of the image subresources of srcImage specified in pRegions at the time this command is executed on a VkDevice
  • srcImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL
  • dstImage must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag
  • If dstImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
  • dstImageLayout must specify the layout of the image subresources of dstImage specified in pRegions at the time this command is executed on a VkDevice
  • dstImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL
  • The VkFormat of each of srcImage and dstImage must be compatible, as defined below
  • The sample count of srcImage and dstImage must match
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
  • srcImage must be a valid VkImage handle
  • srcImageLayout must be a valid VkImageLayout value
  • dstImage must be a valid VkImage handle
  • dstImageLayout must be a valid VkImageLayout value
  • pRegions must be a pointer to an array of regionCount valid VkImageCopy structures
  • commandBuffer must be in the recording state
  • The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations
  • This command must only be called outside of a render pass instance
  • regionCount must be greater than 0
  • Each of commandBuffer, dstImage, and srcImage must have been created, allocated, or retrieved from the same VkDevice
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
Secondary

Outside

Transfer
graphics
compute

Transfer

See Also

VkCommandBuffer, VkImage, VkImageCopy, VkImageLayout

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCmdCopyImage

vkCmdCopyImageToBuffer(3)

Name

vkCmdCopyImageToBuffer - Copy image data into a buffer

C Specification

To copy data from an image object to a buffer object, call:

void vkCmdCopyImageToBuffer(
    VkCommandBuffer                             commandBuffer,
    VkImage                                     srcImage,
    VkImageLayout                               srcImageLayout,
    VkBuffer                                    dstBuffer,
    uint32_t                                    regionCount,
    const VkBufferImageCopy*                    pRegions);

Parameters

  • commandBuffer is the command buffer into which the command will be recorded.
  • srcImage is the source image.
  • srcImageLayout is the layout of the source image subresources for the copy.
  • dstBuffer is the destination buffer.
  • regionCount is the number of regions to copy.
  • pRegions is a pointer to an array of VkBufferImageCopy structures specifying the regions to copy.

Description

Each region in pRegions is copied from the specified region of the source image to the specified region of the destination buffer.

Valid Usage
  • The image region specified by a given element of pRegions must be a region that is contained within srcImage
  • The buffer region specified by a given element of pRegions must be a region that is contained within dstBuffer
  • The union of all source regions, and the union of all destination regions, specified by the elements of pRegions, must not overlap in memory
  • srcImage must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag
  • If srcImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
  • srcImage must have a sample count equal to VK_SAMPLE_COUNT_1_BIT
  • srcImageLayout must specify the layout of the image subresources of srcImage specified in pRegions at the time this command is executed on a VkDevice
  • srcImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL
  • dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag
  • If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
  • srcImage must be a valid VkImage handle
  • srcImageLayout must be a valid VkImageLayout value
  • dstBuffer must be a valid VkBuffer handle
  • pRegions must be a pointer to an array of regionCount valid VkBufferImageCopy structures
  • commandBuffer must be in the recording state
  • The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations
  • This command must only be called outside of a render pass instance
  • regionCount must be greater than 0
  • Each of commandBuffer, dstBuffer, and srcImage must have been created, allocated, or retrieved from the same VkDevice
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
Secondary

Outside

Transfer
graphics
compute

Transfer

See Also

VkBuffer, VkBufferImageCopy, VkCommandBuffer, VkImage, VkImageLayout

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCmdCopyImageToBuffer

vkCmdCopyQueryPoolResults(3)

Name

vkCmdCopyQueryPoolResults - Copy the results of queries in a query pool to a buffer object

C Specification

To copy query statuses and numerical results directly to buffer memory, call:

void vkCmdCopyQueryPoolResults(
    VkCommandBuffer                             commandBuffer,
    VkQueryPool                                 queryPool,
    uint32_t                                    firstQuery,
    uint32_t                                    queryCount,
    VkBuffer                                    dstBuffer,
    VkDeviceSize                                dstOffset,
    VkDeviceSize                                stride,
    VkQueryResultFlags                          flags);

Parameters

  • commandBuffer is the command buffer into which this command will be recorded.
  • queryPool is the query pool managing the queries containing the desired results.
  • firstQuery is the initial query index.
  • queryCount is the number of queries. firstQuery and queryCount together define a range of queries.
  • dstBuffer is a VkBuffer object that will receive the results of the copy command.
  • dstOffset is an offset into dstBuffer.
  • stride is the stride in bytes between results for individual queries within dstBuffer. The required size of the backing memory for dstBuffer is determined as described above for vkGetQueryPoolResults.
  • flags is a bitmask of VkQueryResultFlagBits specifying how and when results are returned.

Description

vkCmdCopyQueryPoolResults is guaranteed to see the effect of previous uses of vkCmdResetQueryPool in the same queue, without any additional synchronization. Thus, the results will always reflect the most recent use of the query.

flags has the same possible values described above for the flags parameter of vkGetQueryPoolResults, but the different style of execution causes some subtle behavioral differences. Because vkCmdCopyQueryPoolResults executes in order with respect to other query commands, there is less ambiguity about which use of a query is being requested.

If no bits are set in flags, results for all requested queries in the available state are written as 32-bit unsigned integer values, and nothing is written for queries in the unavailable state.

If VK_QUERY_RESULT_64_BIT is set, the results are written as an array of 64-bit unsigned integer values as described for vkGetQueryPoolResults.

If VK_QUERY_RESULT_WAIT_BIT is set, the implementation will wait for each query’s status to be in the available state before retrieving the numerical results for that query. This is guaranteed to reflect the most recent use of the query on the same queue, assuming that the query is not being simultaneously used by other queues. If the query does not become available in a finite amount of time (e.g. due to not issuing a query since the last reset), a VK_ERROR_DEVICE_LOST error may occur.

Similarly, if VK_QUERY_RESULT_WITH_AVAILABILITY_BIT is set and VK_QUERY_RESULT_WAIT_BIT is not set, the availability is guaranteed to reflect the most recent use of the query on the same queue, assuming that the query is not being simultaneously used by other queues. As with vkGetQueryPoolResults, implementations must guarantee that if they return a non-zero availability value, then the numerical results are valid.

If VK_QUERY_RESULT_PARTIAL_BIT is set, VK_QUERY_RESULT_WAIT_BIT is not set, and the query’s status is unavailable, an intermediate result value between zero and the final result value is written for that query.

VK_QUERY_RESULT_PARTIAL_BIT must not be used if the pool’s queryType is VK_QUERY_TYPE_TIMESTAMP.

vkCmdCopyQueryPoolResults is considered to be a transfer operation, and its writes to buffer memory must be synchronized using VK_PIPELINE_STAGE_TRANSFER_BIT and VK_ACCESS_TRANSFER_WRITE_BIT before using the results.

Valid Usage
  • dstOffset must be less than the size of dstBuffer
  • firstQuery must be less than the number of queries in queryPool
  • The sum of firstQuery and queryCount must be less than or equal to the number of queries in queryPool
  • If VK_QUERY_RESULT_64_BIT is not set in flags then dstOffset and stride must be multiples of 4
  • If VK_QUERY_RESULT_64_BIT is set in flags then dstOffset and stride must be multiples of 8
  • dstBuffer must have enough storage, from dstOffset, to contain the result of each query, as described here
  • dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag
  • If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
  • If the queryType used to create queryPool was VK_QUERY_TYPE_TIMESTAMP, flags must not contain VK_QUERY_RESULT_PARTIAL_BIT
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
  • queryPool must be a valid VkQueryPool handle
  • dstBuffer must be a valid VkBuffer handle
  • flags must be a valid combination of VkQueryResultFlagBits values
  • commandBuffer must be in the recording state
  • The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations
  • This command must only be called outside of a render pass instance
  • Each of commandBuffer, dstBuffer, and queryPool must have been created, allocated, or retrieved from the same VkDevice
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
Secondary

Outside

Graphics
compute

Transfer

See Also

VkBuffer, VkCommandBuffer, VkDeviceSize, VkQueryPool, VkQueryResultFlags

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCmdCopyQueryPoolResults

vkCmdDispatch(3)

Name

vkCmdDispatch - Dispatch compute work items

C Specification

To record a dispatch, call:

void vkCmdDispatch(
    VkCommandBuffer                             commandBuffer,
    uint32_t                                    groupCountX,
    uint32_t                                    groupCountY,
    uint32_t                                    groupCountZ);

Parameters

  • commandBuffer is the command buffer into which the command will be recorded.
  • groupCountX is the number of local workgroups to dispatch in the X dimension.
  • groupCountY is the number of local workgroups to dispatch in the Y dimension.
  • groupCountZ is the number of local workgroups to dispatch in the Z dimension.

Description

When the command is executed, a global workgroup consisting of groupCountX × groupCountY × groupCountZ local workgroups is assembled.

Valid Usage
  • groupCountX must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[0]
  • groupCountY must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[1]
  • groupCountZ must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[2]
  • For each set n that is statically used by the VkPipeline currently bound to VK_PIPELINE_BIND_POINT_COMPUTE, a descriptor set must have been bound to n at VK_PIPELINE_BIND_POINT_COMPUTE, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in html/vkspec.html#descriptorsets-compatibility
  • Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the currently bound VkPipeline object, specified via vkCmdBindPipeline
  • A valid compute pipeline must be bound to the current command buffer with VK_PIPELINE_BIND_POINT_COMPUTE
  • For each push constant that is statically used by the VkPipeline currently bound to VK_PIPELINE_BIND_POINT_COMPUTE, a push constant value must have been set for VK_PIPELINE_BIND_POINT_COMPUTE, with a VkPipelineLayout that is compatible for push constants with the one used to create the current VkPipeline, as described in html/vkspec.html#descriptorsets-compatibility
  • If any VkSampler object that is accessed from a shader by the VkPipeline currently bound to VK_PIPELINE_BIND_POINT_COMPUTE uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage
  • If any VkSampler object that is accessed from a shader by the VkPipeline currently bound to VK_PIPELINE_BIND_POINT_COMPUTE uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage
  • If any VkSampler object that is accessed from a shader by the VkPipeline currently bound to VK_PIPELINE_BIND_POINT_COMPUTE uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage
  • If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object currently bound to VK_PIPELINE_BIND_POINT_COMPUTE accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the currently bound descriptor set
  • If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object currently bound to VK_PIPELINE_BIND_POINT_COMPUTE accesses a storage buffer, it must not access values outside of the range of that buffer specified in the currently bound descriptor set
  • Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
  • commandBuffer must be in the recording state
  • The VkCommandPool that commandBuffer was allocated from must support compute operations
  • This command must only be called outside of a render pass instance
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

See Also

VkCommandBuffer

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCmdDispatch

vkCmdDispatchIndirect(3)

Name

vkCmdDispatchIndirect - Dispatch compute work items using indirect parameters

C Specification

To record an indirect command dispatch, call:

void vkCmdDispatchIndirect(
    VkCommandBuffer                             commandBuffer,
    VkBuffer                                    buffer,
    VkDeviceSize                                offset);

Parameters

  • commandBuffer is the command buffer into which the command will be recorded.
  • buffer is the buffer containing dispatch parameters.
  • offset is the byte offset into buffer where parameters begin.

Description

vkCmdDispatchIndirect behaves similarly to vkCmdDispatch except that the parameters are read by the device from a buffer during execution. The parameters of the dispatch are encoded in a VkDispatchIndirectCommand structure taken from buffer starting at offset.

Valid Usage
  • If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
  • For each set n that is statically used by the VkPipeline currently bound to VK_PIPELINE_BIND_POINT_COMPUTE, a descriptor set must have been bound to n at VK_PIPELINE_BIND_POINT_COMPUTE, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in html/vkspec.html#descriptorsets-compatibility
  • Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the currently bound VkPipeline object, specified via vkCmdBindPipeline
  • A valid compute pipeline must be bound to the current command buffer with VK_PIPELINE_BIND_POINT_COMPUTE
  • buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set
  • offset must be a multiple of 4
  • The sum of offset and the size of VkDispatchIndirectCommand must be less than or equal to the size of buffer
  • For each push constant that is statically used by the VkPipeline currently bound to VK_PIPELINE_BIND_POINT_COMPUTE, a push constant value must have been set for VK_PIPELINE_BIND_POINT_COMPUTE, with a VkPipelineLayout that is compatible for push constants with the one used to create the current VkPipeline, as described in html/vkspec.html#descriptorsets-compatibility
  • If any VkSampler object that is accessed from a shader by the VkPipeline currently bound to VK_PIPELINE_BIND_POINT_COMPUTE uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage
  • If any VkSampler object that is accessed from a shader by the VkPipeline currently bound to VK_PIPELINE_BIND_POINT_COMPUTE uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage
  • If any VkSampler object that is accessed from a shader by the VkPipeline currently bound to VK_PIPELINE_BIND_POINT_COMPUTE uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage
  • If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object currently bound to VK_PIPELINE_BIND_POINT_COMPUTE accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the currently bound descriptor set
  • If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object currently bound to VK_PIPELINE_BIND_POINT_COMPUTE accesses a storage buffer, it must not access values outside of the range of that buffer specified in the currently bound descriptor set
  • Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
  • buffer must be a valid VkBuffer handle
  • commandBuffer must be in the recording state
  • The VkCommandPool that commandBuffer was allocated from must support compute operations
  • This command must only be called outside of a render pass instance
  • Both of buffer, and commandBuffer must have been created, allocated, or retrieved from the same VkDevice
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

See Also

VkBuffer, VkCommandBuffer, VkDeviceSize

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCmdDispatchIndirect

vkCmdDraw(3)

Name

vkCmdDraw - Draw primitives

C Specification

To record a non-indexed draw, call:

void vkCmdDraw(
    VkCommandBuffer                             commandBuffer,
    uint32_t                                    vertexCount,
    uint32_t                                    instanceCount,
    uint32_t                                    firstVertex,
    uint32_t                                    firstInstance);

Parameters

  • commandBuffer is the command buffer into which the command is recorded.
  • vertexCount is the number of vertices to draw.
  • instanceCount is the number of instances to draw.
  • firstVertex is the index of the first vertex to draw.
  • firstInstance is the instance ID of the first instance to draw.

Description

When the command is executed, primitives are assembled using the current primitive topology and vertexCount consecutive vertex indices with the first vertexIndex value equal to firstVertex. The primitives are drawn instanceCount times with instanceIndex starting with firstInstance and increasing sequentially for each instance. The assembled primitives execute the currently bound graphics pipeline.

Valid Usage
  • The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline currently bound to VK_PIPELINE_BIND_POINT_GRAPHICS.
  • The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline currently bound to VK_PIPELINE_BIND_POINT_GRAPHICS.
  • For each set n that is statically used by the VkPipeline currently bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a descriptor set must have been bound to n at VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in html/vkspec.html#descriptorsets-compatibility
  • For each push constant that is statically used by the VkPipeline currently bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a push constant value must have been set for VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in html/vkspec.html#descriptorsets-compatibility
  • Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the currently bound VkPipeline object, specified via vkCmdBindPipeline
  • All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must have valid buffers bound
  • For a given vertex buffer binding, any attribute data fetched must be entirely contained within the corresponding vertex buffer binding, as described in html/vkspec.html#fxvertex-input
  • A valid graphics pipeline must be bound to the current command buffer with VK_PIPELINE_BIND_POINT_GRAPHICS
  • If the VkPipeline object currently bound to VK_PIPELINE_BIND_POINT_GRAPHICS requires any dynamic state, that state must have been set on the current command buffer
  • Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set
  • If any VkSampler object that is accessed from a shader by the VkPipeline currently bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage
  • If any VkSampler object that is accessed from a shader by the VkPipeline currently bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage
  • If any VkSampler object that is accessed from a shader by the VkPipeline currently bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage
  • If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object currently bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the currently bound descriptor set
  • If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object currently bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a storage buffer, it must not access values outside of the range of that buffer specified in the currently bound descriptor set
  • Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties
  • Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command.
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
  • commandBuffer must be in the recording state
  • The VkCommandPool that commandBuffer was allocated from must support graphics operations
  • This command must only be called inside of a render pass instance
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
Secondary

Inside

Graphics

Graphics

See Also

VkCommandBuffer

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCmdDraw

vkCmdDrawIndexed(3)

Name

vkCmdDrawIndexed - Issue an indexed draw into a command buffer

C Specification

To record an indexed draw, call:

void vkCmdDrawIndexed(
    VkCommandBuffer                             commandBuffer,
    uint32_t                                    indexCount,
    uint32_t                                    instanceCount,
    uint32_t                                    firstIndex,
    int32_t                                     vertexOffset,
    uint32_t                                    firstInstance);

Parameters

  • commandBuffer is the command buffer into which the command is recorded.
  • indexCount is the number of vertices to draw.
  • instanceCount is the number of instances to draw.
  • firstIndex is the base index within the index buffer.
  • vertexOffset is the value added to the vertex index before indexing into the vertex buffer.
  • firstInstance is the instance ID of the first instance to draw.

Description

When the command is executed, primitives are assembled using the current primitive topology and indexCount vertices whose indices are retrieved from the index buffer. The index buffer is treated as an array of tightly packed unsigned integers of size defined by the vkCmdBindIndexBuffer::indexType parameter with which the buffer was bound.

The first vertex index is at an offset of firstIndex * indexSize + offset within the currently bound index buffer, where offset is the offset specified by vkCmdBindIndexBuffer and indexSize is the byte size of the type specified by indexType. Subsequent index values are retrieved from consecutive locations in the index buffer. Indices are first compared to the primitive restart value, then zero extended to 32 bits (if the indexType is VK_INDEX_TYPE_UINT16) and have vertexOffset added to them, before being supplied as the vertexIndex value.

The primitives are drawn instanceCount times with instanceIndex starting with firstInstance and increasing sequentially for each instance. The assembled primitives execute the currently bound graphics pipeline.

Valid Usage
  • The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline currently bound to VK_PIPELINE_BIND_POINT_GRAPHICS.
  • The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline currently bound to VK_PIPELINE_BIND_POINT_GRAPHICS.
  • For each set n that is statically used by the VkPipeline currently bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a descriptor set must have been bound to n at VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in html/vkspec.html#descriptorsets-compatibility
  • For each push constant that is statically used by the VkPipeline currently bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a push constant value must have been set for VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in html/vkspec.html#descriptorsets-compatibility
  • Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the currently bound VkPipeline object, specified via vkCmdBindPipeline
  • All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must have valid buffers bound
  • For a given vertex buffer binding, any attribute data fetched must be entirely contained within the corresponding vertex buffer binding, as described in html/vkspec.html#fxvertex-input
  • A valid graphics pipeline must be bound to the current command buffer with VK_PIPELINE_BIND_POINT_GRAPHICS
  • If the VkPipeline object currently bound to VK_PIPELINE_BIND_POINT_GRAPHICS requires any dynamic state, that state must have been set on the current command buffer
  • (indexSize * (firstIndex + indexCount) + offset) must be less than or equal to the size of the currently bound index buffer, with indexSize being based on the type specified by indexType, where the index buffer, indexType, and offset are specified via vkCmdBindIndexBuffer
  • Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set
  • If any VkSampler object that is accessed from a shader by the VkPipeline currently bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage
  • If any VkSampler object that is accessed from a shader by the VkPipeline currently bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage
  • If any VkSampler object that is accessed from a shader by the VkPipeline currently bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage
  • If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object currently bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the currently bound descriptor set
  • If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object currently bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a storage buffer, it must not access values outside of the range of that buffer specified in the currently bound descriptor set
  • Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties
  • Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command.
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
  • commandBuffer must be in the recording state
  • The VkCommandPool that commandBuffer was allocated from must support graphics operations
  • This command must only be called inside of a render pass instance
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
Secondary

Inside

Graphics

Graphics

See Also

VkCommandBuffer

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCmdDrawIndexed

vkCmdDrawIndexedIndirect(3)

Name

vkCmdDrawIndexedIndirect - Perform an indexed indirect draw

C Specification

To record an indexed indirect draw, call:

void vkCmdDrawIndexedIndirect(
    VkCommandBuffer                             commandBuffer,
    VkBuffer                                    buffer,
    VkDeviceSize                                offset,
    uint32_t                                    drawCount,
    uint32_t                                    stride);

Parameters

  • commandBuffer is the command buffer into which the command is recorded.
  • buffer is the buffer containing draw parameters.
  • offset is the byte offset into buffer where parameters begin.
  • drawCount is the number of draws to execute, and can be zero.
  • stride is the byte stride between successive sets of draw parameters.

Description

vkCmdDrawIndexedIndirect behaves similarly to vkCmdDrawIndexed except that the parameters are read by the device from a buffer during execution. drawCount draws are executed by the command, with parameters taken from buffer starting at offset and increasing by stride bytes for each successive draw. The parameters of each draw are encoded in an array of VkDrawIndexedIndirectCommand structures. If drawCount is less than or equal to one, stride is ignored.

Valid Usage
  • If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
  • offset must be a multiple of 4
  • If drawCount is greater than 1, stride must be a multiple of 4 and must be greater than or equal to sizeof(VkDrawIndexedIndirectCommand)
  • If the multi-draw indirect feature is not enabled, drawCount must be 0 or 1
  • If the drawIndirectFirstInstance feature is not enabled, all the firstInstance members of the VkDrawIndexedIndirectCommand structures accessed by this command must be 0
  • The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline currently bound to VK_PIPELINE_BIND_POINT_GRAPHICS.
  • The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline currently bound to VK_PIPELINE_BIND_POINT_GRAPHICS.
  • For each set n that is statically used by the VkPipeline currently bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a descriptor set must have been bound to n at VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in html/vkspec.html#descriptorsets-compatibility
  • For each push constant that is statically used by the VkPipeline currently bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a push constant value must have been set for VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in html/vkspec.html#descriptorsets-compatibility
  • Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the currently bound VkPipeline object, specified via vkCmdBindPipeline
  • All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must have valid buffers bound
  • A valid graphics pipeline must be bound to the current command buffer with VK_PIPELINE_BIND_POINT_GRAPHICS
  • If the VkPipeline object currently bound to VK_PIPELINE_BIND_POINT_GRAPHICS requires any dynamic state, that state must have been set on the current command buffer
  • If drawCount is equal to 1, (offset + sizeof(VkDrawIndexedIndirectCommand)) must be less than or equal to the size of buffer
  • If drawCount is greater than 1, (stride × (drawCount - 1) + offset + sizeof(VkDrawIndexedIndirectCommand)) must be less than or equal to the size of buffer
  • drawCount must be less than or equal to VkPhysicalDeviceLimits::maxDrawIndirectCount
  • Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set
  • If any VkSampler object that is accessed from a shader by the VkPipeline currently bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage
  • If any VkSampler object that is accessed from a shader by the VkPipeline currently bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage
  • If any VkSampler object that is accessed from a shader by the VkPipeline currently bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage
  • If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object currently bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the currently bound descriptor set
  • If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object currently bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a storage buffer, it must not access values outside of the range of that buffer specified in the currently bound descriptor set
  • Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties
  • Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command.
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
  • buffer must be a valid VkBuffer handle
  • commandBuffer must be in the recording state
  • The VkCommandPool that commandBuffer was allocated from must support graphics operations
  • This command must only be called inside of a render pass instance
  • Both of buffer, and commandBuffer must have been created, allocated, or retrieved from the same VkDevice
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
Secondary

Inside

Graphics

Graphics

See Also

VkBuffer, VkCommandBuffer, VkDeviceSize

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCmdDrawIndexedIndirect

vkCmdDrawIndirect(3)

Name

vkCmdDrawIndirect - Issue an indirect draw into a command buffer

C Specification

To record a non-indexed indirect draw, call:

void vkCmdDrawIndirect(
    VkCommandBuffer                             commandBuffer,
    VkBuffer                                    buffer,
    VkDeviceSize                                offset,
    uint32_t                                    drawCount,
    uint32_t                                    stride);

Parameters

  • commandBuffer is the command buffer into which the command is recorded.
  • buffer is the buffer containing draw parameters.
  • offset is the byte offset into buffer where parameters begin.
  • drawCount is the number of draws to execute, and can be zero.
  • stride is the byte stride between successive sets of draw parameters.

Description

vkCmdDrawIndirect behaves similarly to vkCmdDraw except that the parameters are read by the device from a buffer during execution. drawCount draws are executed by the command, with parameters taken from buffer starting at offset and increasing by stride bytes for each successive draw. The parameters of each draw are encoded in an array of VkDrawIndirectCommand structures. If drawCount is less than or equal to one, stride is ignored.

Valid Usage
  • If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
  • offset must be a multiple of 4
  • If drawCount is greater than 1, stride must be a multiple of 4 and must be greater than or equal to sizeof(VkDrawIndirectCommand)
  • If the multi-draw indirect feature is not enabled, drawCount must be 0 or 1
  • If the drawIndirectFirstInstance feature is not enabled, all the firstInstance members of the VkDrawIndirectCommand structures accessed by this command must be 0
  • The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline currently bound to VK_PIPELINE_BIND_POINT_GRAPHICS.
  • The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline currently bound to VK_PIPELINE_BIND_POINT_GRAPHICS.
  • For each set n that is statically used by the VkPipeline currently bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a descriptor set must have been bound to n at VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in html/vkspec.html#descriptorsets-compatibility
  • For each push constant that is statically used by the VkPipeline currently bound to VK_PIPELINE_BIND_POINT_GRAPHICS, a push constant value must have been set for VK_PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in html/vkspec.html#descriptorsets-compatibility
  • Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the currently bound VkPipeline object, specified via vkCmdBindPipeline
  • All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must have valid buffers bound
  • A valid graphics pipeline must be bound to the current command buffer with VK_PIPELINE_BIND_POINT_GRAPHICS
  • If the VkPipeline object currently bound to VK_PIPELINE_BIND_POINT_GRAPHICS requires any dynamic state, that state must have been set on the current command buffer
  • If drawCount is equal to 1, (offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer
  • If drawCount is greater than 1, (stride × (drawCount - 1) + offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer
  • drawCount must be less than or equal to VkPhysicalDeviceLimits::maxDrawIndirectCount
  • Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set
  • If any VkSampler object that is accessed from a shader by the VkPipeline currently bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage
  • If any VkSampler object that is accessed from a shader by the VkPipeline currently bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage
  • If any VkSampler object that is accessed from a shader by the VkPipeline currently bound to VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage
  • If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object currently bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the currently bound descriptor set
  • If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object currently bound to VK_PIPELINE_BIND_POINT_GRAPHICS accesses a storage buffer, it must not access values outside of the range of that buffer specified in the currently bound descriptor set
  • Any VkImageView being sampled with VK_FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by vkGetPhysicalDeviceFormatProperties
  • Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command.
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
  • buffer must be a valid VkBuffer handle
  • commandBuffer must be in the recording state
  • The VkCommandPool that commandBuffer was allocated from must support graphics operations
  • This command must only be called inside of a render pass instance
  • Both of buffer, and commandBuffer must have been created, allocated, or retrieved from the same VkDevice
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
Secondary

Inside

Graphics

Graphics

See Also

VkBuffer, VkCommandBuffer, VkDeviceSize

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCmdDrawIndirect

vkCmdEndQuery(3)

Name

vkCmdEndQuery - Ends a query

C Specification

To end a query after the set of desired draw or dispatch commands is executed, call:

void vkCmdEndQuery(
    VkCommandBuffer                             commandBuffer,
    VkQueryPool                                 queryPool,
    uint32_t                                    query);

Parameters

  • commandBuffer is the command buffer into which this command will be recorded.
  • queryPool is the query pool that is managing the results of the query.
  • query is the query index within the query pool where the result is stored.

Description

As queries operate asynchronously, ending a query does not immediately set the query’s status to available. A query is considered finished when the final results of the query are ready to be retrieved by vkGetQueryPoolResults and vkCmdCopyQueryPoolResults, and this is when the query’s status is set to available.

Once a query is ended the query must finish in finite time, unless the state of the query is changed using other commands, e.g. by issuing a reset of the query.

Valid Usage
  • The query identified by queryPool and query must currently be active
  • query must be less than the number of queries in queryPool
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
  • queryPool must be a valid VkQueryPool handle
  • commandBuffer must be in the recording state
  • The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations
  • Both of commandBuffer, and queryPool must have been created, allocated, or retrieved from the same VkDevice
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

See Also

VkCommandBuffer, VkQueryPool

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCmdEndQuery

vkCmdEndRenderPass(3)

Name

vkCmdEndRenderPass - End the current render pass

C Specification

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

void vkCmdEndRenderPass(
    VkCommandBuffer                             commandBuffer);

Parameters

  • commandBuffer is the command buffer in which to end the current render pass instance.

Description

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

Valid Usage
  • The current subpass index must be equal to the number of subpasses in the render pass minus one
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
  • commandBuffer must be in the recording state
  • The VkCommandPool that commandBuffer was allocated from must support graphics operations
  • This command must only be called inside of a render pass instance
  • 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

See Also

VkCommandBuffer

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCmdEndRenderPass

vkCmdExecuteCommands(3)

Name

vkCmdExecuteCommands - Execute a secondary command buffer from a primary command buffer

C Specification

A secondary command buffer must not be directly submitted to a queue. Instead, secondary command buffers are recorded to execute as part of a primary command buffer with the command:

void vkCmdExecuteCommands(
    VkCommandBuffer                             commandBuffer,
    uint32_t                                    commandBufferCount,
    const VkCommandBuffer*                      pCommandBuffers);

Parameters

  • commandBuffer is a handle to a primary command buffer that the secondary command buffers are executed in.
  • commandBufferCount is the length of the pCommandBuffers array.
  • pCommandBuffers is an array of secondary command buffer handles, which are recorded to execute in the primary command buffer in the order they are listed in the array.

Description

If any element of pCommandBuffers was not recorded with the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT flag, and it was recorded into any other primary command buffer which is currently in the executable or recording state, that primary command buffer becomes invalid.

Valid Usage
  • commandBuffer must have been allocated with a level of VK_COMMAND_BUFFER_LEVEL_PRIMARY
  • Any given element of pCommandBuffers must have been allocated with a level of VK_COMMAND_BUFFER_LEVEL_SECONDARY
  • Any given element of pCommandBuffers must be in the pending or executable state.
  • If any element of pCommandBuffers was not recorded with the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT flag, and it was recorded into any other primary command buffer, that primary command buffer must not be in the pending state
  • If any given element of pCommandBuffers was not recorded with the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT flag, it must not be in the pending state.
  • If any given element of pCommandBuffers was not recorded with the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT flag, it must not have already been recorded to commandBuffer.
  • If any given element of pCommandBuffers was not recorded with the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT flag, it must not appear more than once in pCommandBuffers.
  • Any given element of pCommandBuffers must have been allocated from a VkCommandPool that was created for the same queue family as the VkCommandPool from which commandBuffer was allocated
  • If vkCmdExecuteCommands is being called within a render pass instance, that render pass instance must have been begun with the contents parameter of vkCmdBeginRenderPass set to VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS
  • If vkCmdExecuteCommands is being called within a render pass instance, any given element of pCommandBuffers must have been recorded with the VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT
  • If vkCmdExecuteCommands is being called within a render pass instance, any given element of pCommandBuffers must have been recorded with VkCommandBufferInheritanceInfo::subpass set to the index of the subpass which the given command buffer will be executed in
  • If vkCmdExecuteCommands is being called within a render pass instance, the render passes specified in the pname::pBeginInfo::pInheritanceInfo::renderPass members of the vkBeginCommandBuffer commands used to begin recording each element of pCommandBuffers must be compatible with the current render pass.
  • If vkCmdExecuteCommands is being called within a render pass instance, and any given element of pCommandBuffers was recorded with VkCommandBufferInheritanceInfo::framebuffer not equal to VK_NULL_HANDLE, that VkFramebuffer must match the VkFramebuffer used in the current render pass instance
  • If vkCmdExecuteCommands is not being called within a render pass instance, any given element of pCommandBuffers must not have been recorded with the VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT
  • If the inherited queries feature is not enabled, commandBuffer must not have any queries active
  • If commandBuffer has a VK_QUERY_TYPE_OCCLUSION query active, then each element of pCommandBuffers must have been recorded with VkCommandBufferInheritanceInfo::occlusionQueryEnable set to VK_TRUE
  • If commandBuffer has a VK_QUERY_TYPE_OCCLUSION query active, then each element of pCommandBuffers must have been recorded with VkCommandBufferInheritanceInfo::queryFlags having all bits set that are set for the query
  • If commandBuffer has a VK_QUERY_TYPE_PIPELINE_STATISTICS query active, then each element of pCommandBuffers must have been recorded with VkCommandBufferInheritanceInfo::pipelineStatistics having all bits set that are set in the VkQueryPool the query uses
  • Any given element of pCommandBuffers must not begin any query types that are active in commandBuffer
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
  • pCommandBuffers must be a pointer to an array of commandBufferCount valid VkCommandBuffer handles
  • commandBuffer must be in the recording state
  • The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations
  • commandBuffer must be a primary VkCommandBuffer
  • commandBufferCount must be greater than 0
  • Both of commandBuffer, and the elements of pCommandBuffers must have been created, allocated, or retrieved from the same VkDevice
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

See Also

VkCommandBuffer

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCmdExecuteCommands

vkCmdFillBuffer(3)

Name

vkCmdFillBuffer - Fill a region of a buffer with a fixed value

C Specification

To clear buffer data, call:

void vkCmdFillBuffer(
    VkCommandBuffer                             commandBuffer,
    VkBuffer                                    dstBuffer,
    VkDeviceSize                                dstOffset,
    VkDeviceSize                                size,
    uint32_t                                    data);

Parameters

  • commandBuffer is the command buffer into which the command will be recorded.
  • dstBuffer is the buffer to be filled.
  • dstOffset is the byte offset into the buffer at which to start filling, and must be a multiple of 4.
  • size is the number of bytes to fill, and must be either a multiple of 4, or VK_WHOLE_SIZE to fill the range from offset to the end of the buffer. If VK_WHOLE_SIZE is used and the remaining size of the buffer is not a multiple of 4, then the nearest smaller multiple is used.
  • data is the 4-byte word written repeatedly to the buffer to fill size bytes of data. The data word is written to memory according to the host endianness.

Description

vkCmdFillBuffer is treated as “transfer” operation for the purposes of synchronization barriers. The VK_BUFFER_USAGE_TRANSFER_DST_BIT must be specified in usage of VkBufferCreateInfo in order for the buffer to be compatible with vkCmdFillBuffer.

Valid Usage
  • dstOffset must be less than the size of dstBuffer
  • dstOffset must be a multiple of 4
  • If size is not equal to VK_WHOLE_SIZE, size must be greater than 0
  • If size is not equal to VK_WHOLE_SIZE, size must be less than or equal to the size of dstBuffer minus dstOffset
  • If size is not equal to VK_WHOLE_SIZE, size must be a multiple of 4
  • dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag
  • The VkCommandPool that commandBuffer was allocated from must support graphics or compute operations
  • If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
  • dstBuffer must be a valid VkBuffer handle
  • commandBuffer must be in the recording state
  • The VkCommandPool that commandBuffer was allocated from must support graphics or compute operations
  • This command must only be called outside of a render pass instance
  • Both of commandBuffer, and dstBuffer must have been created, allocated, or retrieved from the same VkDevice
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
Secondary

Outside

Graphics
Compute

Transfer

See Also

VkBuffer, VkCommandBuffer, VkDeviceSize

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCmdFillBuffer

vkCmdNextSubpass(3)

Name

vkCmdNextSubpass - Transition to the next subpass of a render pass

C Specification

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

void vkCmdNextSubpass(
    VkCommandBuffer                             commandBuffer,
    VkSubpassContents                           contents);

Parameters

  • 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.

Description

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. 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
  • The current subpass index must be less than the number of subpasses in the render pass minus one
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
  • contents must be a valid VkSubpassContents value
  • commandBuffer must be in the recording state
  • The VkCommandPool that commandBuffer was allocated from must support graphics operations
  • This command must only be called inside of a render pass instance
  • 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

See Also

VkCommandBuffer, VkSubpassContents

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCmdNextSubpass

vkCmdPipelineBarrier(3)

Name

vkCmdPipelineBarrier - Insert a memory dependency

C Specification

To record a pipeline barrier, call:

void vkCmdPipelineBarrier(
    VkCommandBuffer                             commandBuffer,
    VkPipelineStageFlags                        srcStageMask,
    VkPipelineStageFlags                        dstStageMask,
    VkDependencyFlags                           dependencyFlags,
    uint32_t                                    memoryBarrierCount,
    const VkMemoryBarrier*                      pMemoryBarriers,
    uint32_t                                    bufferMemoryBarrierCount,
    const VkBufferMemoryBarrier*                pBufferMemoryBarriers,
    uint32_t                                    imageMemoryBarrierCount,
    const VkImageMemoryBarrier*                 pImageMemoryBarriers);

Parameters

  • commandBuffer is the command buffer into which the command is recorded.
  • srcStageMask is a bitmask of VkPipelineStageFlagBits specifying the source stage mask.
  • dstStageMask is a bitmask of VkPipelineStageFlagBits specifying the destination stage mask.
  • dependencyFlags is a bitmask of VkDependencyFlagBits specifying how execution and memory dependencies are formed.
  • memoryBarrierCount is the length of the pMemoryBarriers array.
  • pMemoryBarriers is a pointer to an array of VkMemoryBarrier structures.
  • bufferMemoryBarrierCount is the length of the pBufferMemoryBarriers array.
  • pBufferMemoryBarriers is a pointer to an array of VkBufferMemoryBarrier structures.
  • imageMemoryBarrierCount is the length of the pImageMemoryBarriers array.
  • pImageMemoryBarriers is a pointer to an array of VkImageMemoryBarrier structures.

Description

When vkCmdPipelineBarrier is submitted to a queue, it defines a memory dependency between commands that were submitted before it, and those submitted after it.

If vkCmdPipelineBarrier was recorded outside a render pass instance, the first synchronization scope includes every command submitted to the same queue before it, including those in the same command buffer and batch. If vkCmdPipelineBarrier was recorded inside a render pass instance, the first synchronization scope includes only commands submitted before it within the same subpass. 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 vkCmdPipelineBarrier was recorded outside a render pass instance, the second synchronization scope includes every command submitted to the same queue after it, including those in the same command buffer and batch. If vkCmdPipelineBarrier was recorded inside a render pass instance, the second synchronization scope includes only commands submitted after it within the same subpass. 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. Within that, the first access scope only includes the first access scopes defined by elements of the pMemoryBarriers, pBufferMemoryBarriers and pImageMemoryBarriers arrays, which each define a set of memory barriers. If no memory barriers are specified, then the first access scope includes no accesses.

The second access scope is limited to access in the pipeline stages determined by the destination stage mask specified by dstStageMask. Within that, the second access scope only includes the second access scopes defined by elements of the pMemoryBarriers, pBufferMemoryBarriers and pImageMemoryBarriers arrays, which each define a set of memory barriers. If no memory barriers are specified, then the second access scope includes no accesses.

If dependencyFlags includes VK_DEPENDENCY_BY_REGION_BIT, then any dependency between framebuffer-space pipeline stages is framebuffer-local - otherwise it is framebuffer-global.

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
  • If vkCmdPipelineBarrier is called within a render pass instance, the render pass must have been created with a VkSubpassDependency instance in pDependencies that expresses a dependency from the current subpass to itself.
  • If vkCmdPipelineBarrier is called within a render pass instance, srcStageMask must contain a subset of the bit values in the srcStageMask member of that instance of VkSubpassDependency
  • If vkCmdPipelineBarrier is called within a render pass instance, dstStageMask must contain a subset of the bit values in the dstStageMask member of that instance of VkSubpassDependency
  • If vkCmdPipelineBarrier is called within a render pass instance, the srcAccessMask of any element of pMemoryBarriers or pImageMemoryBarriers must contain a subset of the bit values the srcAccessMask member of that instance of VkSubpassDependency
  • If vkCmdPipelineBarrier is called within a render pass instance, the dstAccessMask of any element of pMemoryBarriers or pImageMemoryBarriers must contain a subset of the bit values the dstAccessMask member of that instance of VkSubpassDependency
  • If vkCmdPipelineBarrier is called within a render pass instance, dependencyFlags must be equal to the dependencyFlags member of that instance of VkSubpassDependency
  • If vkCmdPipelineBarrier is called within a render pass instance, bufferMemoryBarrierCount must be 0
  • If vkCmdPipelineBarrier is called within a render pass instance, the image member of any element of pImageMemoryBarriers must be equal to one of the elements of pAttachments that the current framebuffer was created with, that is also referred to by one of the elements of the pColorAttachments, pResolveAttachments or pDepthStencilAttachment members of the VkSubpassDescription instance that the current subpass was created with
  • If vkCmdPipelineBarrier is called within a render pass instance, the oldLayout and newLayout members of any element of pImageMemoryBarriers must be equal to the layout member of an element of the pColorAttachments, pResolveAttachments or pDepthStencilAttachment members of the VkSubpassDescription instance that the current subpass was created with, that refers to the same image
  • If vkCmdPipelineBarrier is called within a render pass instance, the oldLayout and newLayout members of an element of pImageMemoryBarriers must be equal
  • If vkCmdPipelineBarrier is called within a render pass instance, the srcQueueFamilyIndex and dstQueueFamilyIndex members of any element of pImageMemoryBarriers must be VK_QUEUE_FAMILY_IGNORED
  • Any pipeline stage included in srcStageMask or dstStageMask must be supported by the capabilities of the queue family specified by the queueFamilyIndex member of the VkCommandPoolCreateInfo structure that was used to create the VkCommandPool that commandBuffer was allocated from, as specified in the table of supported pipeline stages.
  • Any given element of pMemoryBarriers, pBufferMemoryBarriers or pImageMemoryBarriers must not have any access flag included in its srcAccessMask member if that bit is not supported by any of the pipeline stages in srcStageMask, as specified in the table of supported access types.
  • Any given element of pMemoryBarriers, pBufferMemoryBarriers or pImageMemoryBarriers must not have any access flag included in its dstAccessMask member if that bit is not supported by any of the pipeline stages in dstStageMask, as specified in the table of supported access types.
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
  • 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
  • dependencyFlags must be a valid combination of VkDependencyFlagBits values
  • If memoryBarrierCount is not 0, pMemoryBarriers must be a pointer to an array of memoryBarrierCount valid VkMemoryBarrier structures
  • If bufferMemoryBarrierCount is not 0, pBufferMemoryBarriers must be a pointer to an array of bufferMemoryBarrierCount valid VkBufferMemoryBarrier structures
  • If imageMemoryBarrierCount is not 0, pImageMemoryBarriers must be a pointer to an array of imageMemoryBarrierCount valid VkImageMemoryBarrier structures
  • commandBuffer must be in the recording state
  • The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations
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
Secondary

Both

Transfer
graphics
compute

See Also

VkBufferMemoryBarrier, VkCommandBuffer, VkDependencyFlags, VkImageMemoryBarrier, VkMemoryBarrier, VkPipelineStageFlags

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCmdPipelineBarrier

vkCmdPushConstants(3)

Name

vkCmdPushConstants - Update the values of push constants

C Specification

To update push constants, call:

void vkCmdPushConstants(
    VkCommandBuffer                             commandBuffer,
    VkPipelineLayout                            layout,
    VkShaderStageFlags                          stageFlags,
    uint32_t                                    offset,
    uint32_t                                    size,
    const void*                                 pValues);

Parameters

  • commandBuffer is the command buffer in which the push constant update will be recorded.
  • layout is the pipeline layout used to program the push constant updates.
  • stageFlags is a bitmask of VkShaderStageFlagBits specifying the shader stages that will use the push constants in the updated range.
  • offset is the start offset of the push constant range to update, in units of bytes.
  • size is the size of the push constant range to update, in units of bytes.
  • pValues is an array of size bytes containing the new push constant values.

Description

Valid Usage
  • stageFlags must match exactly the shader stages used in layout for the range specified by offset and size
  • offset must be a multiple of 4
  • size must be a multiple of 4
  • offset must be less than VkPhysicalDeviceLimits::maxPushConstantsSize
  • size must be less than or equal to VkPhysicalDeviceLimits::maxPushConstantsSize minus offset
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
  • layout must be a valid VkPipelineLayout handle
  • stageFlags must be a valid combination of VkShaderStageFlagBits values
  • stageFlags must not be 0
  • pValues must be a pointer to an array of size bytes
  • commandBuffer must be in the recording state
  • The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations
  • size must be greater than 0
  • Both of commandBuffer, and layout must have been created, allocated, or retrieved from the same VkDevice
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

See Also

VkCommandBuffer, VkPipelineLayout, VkShaderStageFlags

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCmdPushConstants

vkCmdResetEvent(3)

Name

vkCmdResetEvent - Reset an event object to non-signaled state

C Specification

To set the state of an event to unsignaled from a device, call:

void vkCmdResetEvent(
    VkCommandBuffer                             commandBuffer,
    VkEvent                                     event,
    VkPipelineStageFlags                        stageMask);

Parameters

  • commandBuffer is the command buffer into which the command is recorded.
  • event is the event that will be unsignaled.
  • stageMask is a bitmask of VkPipelineStageFlagBits specifying the source stage mask used to determine when the event is unsignaled.

Description

When vkCmdResetEvent is submitted to a queue, it defines an execution dependency on commands that were submitted before it, and defines an event unsignal operation which resets the event to the unsignaled state.

The first synchronization scope includes every command previously submitted to the same queue, including those in the same command buffer and batch. The synchronization scope is limited to operations on the pipeline stages determined by the source stage mask specified by stageMask.

The second synchronization scope includes only the event unsignal operation.

If event is already in the unsignaled state when vkCmdResetEvent is executed on the device, then vkCmdResetEvent has no effect, no event unsignal operation occurs, and no execution dependency is generated.

Valid Usage
  • stageMask must not include VK_PIPELINE_STAGE_HOST_BIT
  • If the geometry shaders feature is not enabled, stageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT
  • If the tessellation shaders feature is not enabled, stageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT
  • When this command executes, event must not be waited on by a vkCmdWaitEvents command that is currently executing
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
  • event must be a valid VkEvent handle
  • stageMask must be a valid combination of VkPipelineStageFlagBits values
  • stageMask must not be 0
  • commandBuffer must be in the recording state
  • The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations
  • This command must only be called outside of a render pass instance
  • Both of commandBuffer, and event must have been created, allocated, or retrieved from the same VkDevice
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
Secondary

Outside

Graphics
compute

See Also

VkCommandBuffer, VkEvent, VkPipelineStageFlags

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCmdResetEvent

vkCmdResetQueryPool(3)

Name

vkCmdResetQueryPool - Reset queries in a query pool

C Specification

To reset a range of queries in a query pool, call:

void vkCmdResetQueryPool(
    VkCommandBuffer                             commandBuffer,
    VkQueryPool                                 queryPool,
    uint32_t                                    firstQuery,
    uint32_t                                    queryCount);

Parameters

  • commandBuffer is the command buffer into which this command will be recorded.
  • queryPool is the handle of the query pool managing the queries being reset.
  • firstQuery is the initial query index to reset.
  • queryCount is the number of queries to reset.

Description

When executed on a queue, this command sets the status of query indices [firstQuery, firstQuery + queryCount - 1] to unavailable.

Valid Usage
  • firstQuery must be less than the number of queries in queryPool
  • The sum of firstQuery and queryCount must be less than or equal to the number of queries in queryPool
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
  • queryPool must be a valid VkQueryPool handle
  • commandBuffer must be in the recording state
  • The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations
  • This command must only be called outside of a render pass instance
  • Both of commandBuffer, and queryPool must have been created, allocated, or retrieved from the same VkDevice
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
Secondary

Outside

Graphics
compute

See Also

VkCommandBuffer, VkQueryPool

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCmdResetQueryPool

vkCmdResolveImage(3)

Name

vkCmdResolveImage - Resolve regions of an image

C Specification

To resolve a multisample image to a non-multisample image, call:

void vkCmdResolveImage(
    VkCommandBuffer                             commandBuffer,
    VkImage                                     srcImage,
    VkImageLayout                               srcImageLayout,
    VkImage                                     dstImage,
    VkImageLayout                               dstImageLayout,
    uint32_t                                    regionCount,
    const VkImageResolve*                       pRegions);

Parameters

  • commandBuffer is the command buffer into which the command will be recorded.
  • srcImage is the source image.
  • srcImageLayout is the layout of the source image subresources for the resolve.
  • dstImage is the destination image.
  • dstImageLayout is the layout of the destination image subresources for the resolve.
  • regionCount is the number of regions to resolve.
  • pRegions is a pointer to an array of VkImageResolve structures specifying the regions to resolve.

Description

During the resolve the samples corresponding to each pixel location in the source are converted to a single sample before being written to the destination. If the source formats are floating-point or normalized types, the sample values for each pixel are resolved in an implementation-dependent manner. If the source formats are integer types, a single sample’s value is selected for each pixel.

srcOffset and dstOffset select the initial x, y, and z offsets in texels of the sub-regions of the source and destination image data. extent is the size in texels of the source image to resolve in width, height and depth.

Resolves are done layer by layer starting with baseArrayLayer member of srcSubresource for the source and dstSubresource for the destination. layerCount layers are resolved to the destination image.

Valid Usage
  • The source region specified by a given element of pRegions must be a region that is contained within srcImage
  • The destination region specified by a given element of pRegions must be a region that is contained within dstImage
  • The union of all source regions, and the union of all destination regions, specified by the elements of pRegions, must not overlap in memory
  • If srcImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
  • srcImage must have a sample count equal to any valid sample count value other than VK_SAMPLE_COUNT_1_BIT
  • If dstImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
  • dstImage must have a sample count equal to VK_SAMPLE_COUNT_1_BIT
  • srcImageLayout must specify the layout of the image subresources of srcImage specified in pRegions at the time this command is executed on a VkDevice
  • srcImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL
  • dstImageLayout must specify the layout of the image subresources of dstImage specified in pRegions at the time this command is executed on a VkDevice
  • dstImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL
  • If dstImage was created with tiling equal to VK_IMAGE_TILING_LINEAR, dstImage must have been created with a format that supports being a color attachment, as specified by the VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT flag in VkFormatProperties::linearTilingFeatures returned by vkGetPhysicalDeviceFormatProperties
  • If dstImage was created with tiling equal to VK_IMAGE_TILING_OPTIMAL, dstImage must have been created with a format that supports being a color attachment, as specified by the VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT flag in VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties
  • srcImage and dstImage must have been created with the same image format
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
  • srcImage must be a valid VkImage handle
  • srcImageLayout must be a valid VkImageLayout value
  • dstImage must be a valid VkImage handle
  • dstImageLayout must be a valid VkImageLayout value
  • pRegions must be a pointer to an array of regionCount valid VkImageResolve structures
  • commandBuffer must be in the recording state
  • The VkCommandPool that commandBuffer was allocated from must support graphics operations
  • This command must only be called outside of a render pass instance
  • regionCount must be greater than 0
  • Each of commandBuffer, dstImage, and srcImage must have been created, allocated, or retrieved from the same VkDevice
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
Secondary

Outside

Graphics

Transfer

See Also

VkCommandBuffer, VkImage, VkImageLayout, VkImageResolve

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCmdResolveImage

vkCmdSetBlendConstants(3)

Name

vkCmdSetBlendConstants - Set the values of blend constants

C Specification

Otherwise, to dynamically set and change the blend constant, call:

void vkCmdSetBlendConstants(
    VkCommandBuffer                             commandBuffer,
    const float                                 blendConstants[4]);

Parameters

  • commandBuffer is the command buffer into which the command will be recorded.
  • blendConstants is an array of four values specifying the R, G, B, and A components of the blend constant color used in blending, depending on the blend factor.

Description

Valid Usage
  • The currently bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_BLEND_CONSTANTS dynamic state enabled
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
  • commandBuffer must be in the recording state
  • The VkCommandPool that commandBuffer was allocated from must support graphics operations
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

See Also

VkCommandBuffer

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCmdSetBlendConstants

vkCmdSetDepthBias(3)

Name

vkCmdSetDepthBias - Set the depth bias dynamic state

C Specification

The depth values of all fragments generated by the rasterization of a polygon can be offset by a single value that is computed for that polygon. This behavior is controlled by the depthBiasEnable, depthBiasConstantFactor, depthBiasClamp, and depthBiasSlopeFactor members of VkPipelineRasterizationStateCreateInfo, or by the corresponding parameters to the vkCmdSetDepthBias command if depth bias state is dynamic.

void vkCmdSetDepthBias(
    VkCommandBuffer                             commandBuffer,
    float                                       depthBiasConstantFactor,
    float                                       depthBiasClamp,
    float                                       depthBiasSlopeFactor);

Parameters

  • commandBuffer is the command buffer into which the command will be recorded.
  • depthBiasConstantFactor is a scalar factor controlling the constant depth value added to each fragment.
  • depthBiasClamp is the maximum (or minimum) depth bias of a fragment.
  • depthBiasSlopeFactor is a scalar factor applied to a fragment’s slope in depth bias calculations.

Description

If depthBiasEnable is VK_FALSE, no depth bias is applied and the fragment’s depth values are unchanged.

depthBiasSlopeFactor scales the maximum depth slope of the polygon, and depthBiasConstantFactor scales an implementation-dependent constant that relates to the usable resolution of the depth buffer. The resulting values are summed to produce the depth bias value which is then clamped to a minimum or maximum value specified by depthBiasClamp. depthBiasSlopeFactor, depthBiasConstantFactor, and depthBiasClamp can each be positive, negative, or zero.

The maximum depth slope m of a triangle is

\[m = \sqrt{ \left({{\partial z_f} \over {\partial x_f}}\right)^2 + \left({{\partial z_f} \over {\partial y_f}}\right)^2}\]

where (xf, yf, zf) is a point on the triangle. m may be approximated as

\[m = \max\left( \left| { {\partial z_f} \over {\partial x_f} } \right|, \left| { {\partial z_f} \over {\partial y_f} } \right| \right).\]

The minimum resolvable difference r is an implementation-dependent parameter that depends on the depth buffer representation. It is the smallest difference in framebuffer coordinate z values that is guaranteed to remain distinct throughout polygon rasterization and in the depth buffer. All pairs of fragments generated by the rasterization of two polygons with otherwise identical vertices, but zf values that differ by $r$, will have distinct depth values.

For fixed-point depth buffer representations, r is constant throughout the range of the entire depth buffer. For floating-point depth buffers, there is no single minimum resolvable difference. In this case, the minimum resolvable difference for a given polygon is dependent on the maximum exponent, e, in the range of z values spanned by the primitive. If n is the number of bits in the floating-point mantissa, the minimum resolvable difference, r, for the given primitive is defined as

r = 2e-n

If no depth buffer is present, r is undefined.

The bias value o for a polygon is

\[o = \begin{cases} m \times depthBiasSlopeFactor + r \times depthBiasConstantFactor & depthBiasClamp = 0\ or\ NaN \\ \min(m \times depthBiasSlopeFactor + r \times depthBiasConstantFactor, depthBiasClamp) & depthBiasClamp > 0 \\ \max(m \times depthBiasSlopeFactor + r \times depthBiasConstantFactor, depthBiasClamp) & depthBiasClamp < 0 \\ \end{cases}\]

m is computed as described above. If the depth buffer uses a fixed-point representation, m is a function of depth values in the range [0,1], and o is applied to depth values in the same range.

For fixed-point depth buffers, fragment depth values are always limited to the range [0,1] by clamping after depth bias addition is performed. Fragment depth values are clamped even when the depth buffer uses a floating-point representation.

Valid Usage
  • The currently bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_DEPTH_BIAS dynamic state enabled
  • If the depth bias clamping feature is not enabled, depthBiasClamp must be 0.0
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
  • commandBuffer must be in the recording state
  • The VkCommandPool that commandBuffer was allocated from must support graphics operations
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

See Also

VkCommandBuffer

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCmdSetDepthBias

vkCmdSetDepthBounds(3)

Name

vkCmdSetDepthBounds - Set the depth bounds test values for a command buffer

C Specification

The depth bounds test conditionally disables coverage of a sample based on the outcome of a comparison between the value za in the depth attachment at location (xf,yf) (for the appropriate sample) and a range of values. The test is enabled or disabled by the depthBoundsTestEnable member of VkPipelineDepthStencilStateCreateInfo: If the pipeline state object is created without the VK_DYNAMIC_STATE_DEPTH_BOUNDS dynamic state enabled then the range of values used in the depth bounds test are defined by the minDepthBounds and maxDepthBounds members of the VkPipelineDepthStencilStateCreateInfo structure. Otherwise, to dynamically set the depth bounds range values call:

void vkCmdSetDepthBounds(
    VkCommandBuffer                             commandBuffer,
    float                                       minDepthBounds,
    float                                       maxDepthBounds);

Parameters

  • commandBuffer is the command buffer into which the command will be recorded.
  • minDepthBounds is the lower bound of the range of depth values used in the depth bounds test.
  • maxDepthBounds is the upper bound of the range.

Description

Valid Usage
  • The currently bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_DEPTH_BOUNDS dynamic state enabled
  • minDepthBounds must be between 0.0 and 1.0, inclusive
  • maxDepthBounds must be between 0.0 and 1.0, inclusive
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
  • commandBuffer must be in the recording state
  • The VkCommandPool that commandBuffer was allocated from must support graphics operations
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

See Also

VkCommandBuffer

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCmdSetDepthBounds

vkCmdSetEvent(3)

Name

vkCmdSetEvent - Set an event object to signaled state

C Specification

To set the state of an event to signaled from a device, call:

void vkCmdSetEvent(
    VkCommandBuffer                             commandBuffer,
    VkEvent                                     event,
    VkPipelineStageFlags                        stageMask);

Parameters

  • commandBuffer is the command buffer into which the command is recorded.
  • event is the event that will be signaled.
  • stageMask specifies the source stage mask used to determine when the event is signaled.

Description

When vkCmdSetEvent is submitted to a queue, it defines an execution dependency on commands that were submitted before it, and defines an event signal operation which sets the event to the signaled state.

The first synchronization scope includes every command previously submitted to the same queue, including those in the same command buffer and batch. The synchronization scope is limited to operations on the pipeline stages determined by the source stage mask specified by stageMask.

The second synchronization scope includes only the event signal operation.

If event is already in the signaled state when vkCmdSetEvent is executed on the device, then vkCmdSetEvent has no effect, no event signal operation occurs, and no execution dependency is generated.

Valid Usage
  • stageMask must not include VK_PIPELINE_STAGE_HOST_BIT
  • If the geometry shaders feature is not enabled, stageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT
  • If the tessellation shaders feature is not enabled, stageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
  • event must be a valid VkEvent handle
  • stageMask must be a valid combination of VkPipelineStageFlagBits values
  • stageMask must not be 0
  • commandBuffer must be in the recording state
  • The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations
  • This command must only be called outside of a render pass instance
  • Both of commandBuffer, and event must have been created, allocated, or retrieved from the same VkDevice
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
Secondary

Outside

Graphics
compute

See Also

VkCommandBuffer, VkEvent, VkPipelineStageFlags

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCmdSetEvent

vkCmdSetLineWidth(3)

Name

vkCmdSetLineWidth - Set the dynamic line width state

C Specification

The line width is specified by the VkPipelineRasterizationStateCreateInfo::lineWidth property of the currently active pipeline, if the pipeline was not created with VK_DYNAMIC_STATE_LINE_WIDTH enabled.

Otherwise, the line width is set by calling vkCmdSetLineWidth:

void vkCmdSetLineWidth(
    VkCommandBuffer                             commandBuffer,
    float                                       lineWidth);

Parameters

  • commandBuffer is the command buffer into which the command will be recorded.
  • lineWidth is the width of rasterized line segments.

Description

Valid Usage
  • The currently bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_LINE_WIDTH dynamic state enabled
  • If the wide lines feature is not enabled, lineWidth must be 1.0
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
  • commandBuffer must be in the recording state
  • The VkCommandPool that commandBuffer was allocated from must support graphics operations
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

See Also

VkCommandBuffer

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCmdSetLineWidth

vkCmdSetScissor(3)

Name

vkCmdSetScissor - Set the dynamic scissor rectangles on a command buffer

C Specification

The scissor test determines if a fragment’s framebuffer coordinates (xf,yf) lie within the scissor rectangle corresponding to the viewport index (see Controlling the Viewport) used by the primitive that generated the fragment. If the pipeline state object is created without VK_DYNAMIC_STATE_SCISSOR enabled then the scissor rectangles are set by the VkPipelineViewportStateCreateInfo state of the pipeline state object. Otherwise, to dynamically set the scissor rectangles call:

void vkCmdSetScissor(
    VkCommandBuffer                             commandBuffer,
    uint32_t                                    firstScissor,
    uint32_t                                    scissorCount,
    const VkRect2D*                             pScissors);

Parameters

  • commandBuffer is the command buffer into which the command will be recorded.
  • firstScissor is the index of the first scissor whose state is updated by the command.
  • scissorCount is the number of scissors whose rectangles are updated by the command.
  • pScissors is a pointer to an array of VkRect2D structures defining scissor rectangles.

Description

The scissor rectangles taken from element i of pScissors replace the current state for the scissor index firstScissor + i, for i in [0, scissorCount).

Each scissor rectangle is described by a VkRect2D structure, with the offset.x and offset.y values determining the upper left corner of the scissor rectangle, and the extent.width and extent.height values determining the size in pixels.

Valid Usage
  • The currently bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_SCISSOR dynamic state enabled
  • firstScissor must be less than VkPhysicalDeviceLimits::maxViewports
  • The sum of firstScissor and scissorCount must be between 1 and VkPhysicalDeviceLimits::maxViewports, inclusive
  • If the multiple viewports feature is not enabled, firstScissor must be 0
  • If the multiple viewports feature is not enabled, scissorCount must be 1
  • The x and y members of offset must be greater than or equal to 0
  • Evaluation of (offset.x + extent.width) must not cause a signed integer addition overflow
  • Evaluation of (offset.y + extent.height) must not cause a signed integer addition overflow
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
  • pScissors must be a pointer to an array of scissorCount VkRect2D structures
  • commandBuffer must be in the recording state
  • The VkCommandPool that commandBuffer was allocated from must support graphics operations
  • scissorCount must be greater than 0
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

See Also

VkCommandBuffer, VkRect2D

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCmdSetScissor

vkCmdSetStencilCompareMask(3)

Name

vkCmdSetStencilCompareMask - Set the stencil compare mask dynamic state

C Specification

If the pipeline state object is created with the VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK dynamic state enabled, then to dynamically set the stencil compare mask call:

void vkCmdSetStencilCompareMask(
    VkCommandBuffer                             commandBuffer,
    VkStencilFaceFlags                          faceMask,
    uint32_t                                    compareMask);

Parameters

  • commandBuffer is the command buffer into which the command will be recorded.
  • faceMask is a bitmask of VkStencilFaceFlagBits specifying the set of stencil state for which to update the compare mask.
  • compareMask is the new value to use as the stencil compare mask.

Description

Valid Usage
  • The currently bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK dynamic state enabled
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
  • faceMask must be a valid combination of VkStencilFaceFlagBits values
  • faceMask must not be 0
  • commandBuffer must be in the recording state
  • The VkCommandPool that commandBuffer was allocated from must support graphics operations
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

See Also

VkCommandBuffer, VkStencilFaceFlags

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCmdSetStencilCompareMask

vkCmdSetStencilReference(3)

Name

vkCmdSetStencilReference - Set the stencil reference dynamic state

C Specification

If the pipeline state object is created with the VK_DYNAMIC_STATE_STENCIL_REFERENCE dynamic state enabled, then to dynamically set the stencil reference value call:

void vkCmdSetStencilReference(
    VkCommandBuffer                             commandBuffer,
    VkStencilFaceFlags                          faceMask,
    uint32_t                                    reference);

Parameters

  • commandBuffer is the command buffer into which the command will be recorded.
  • faceMask is a bitmask of VkStencilFaceFlagBits specifying the set of stencil state for which to update the reference value, as described above for vkCmdSetStencilCompareMask.
  • reference is the new value to use as the stencil reference value.

Description

Valid Usage
  • The currently bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_STENCIL_REFERENCE dynamic state enabled
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
  • faceMask must be a valid combination of VkStencilFaceFlagBits values
  • faceMask must not be 0
  • commandBuffer must be in the recording state
  • The VkCommandPool that commandBuffer was allocated from must support graphics operations
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

See Also

VkCommandBuffer, VkStencilFaceFlags

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCmdSetStencilReference

vkCmdSetStencilWriteMask(3)

Name

vkCmdSetStencilWriteMask - Set the stencil write mask dynamic state

C Specification

If the pipeline state object is created with the VK_DYNAMIC_STATE_STENCIL_WRITE_MASK dynamic state enabled, then to dynamically set the stencil write mask call:

void vkCmdSetStencilWriteMask(
    VkCommandBuffer                             commandBuffer,
    VkStencilFaceFlags                          faceMask,
    uint32_t                                    writeMask);

Parameters

  • commandBuffer is the command buffer into which the command will be recorded.
  • faceMask is a bitmask of VkStencilFaceFlagBits specifying the set of stencil state for which to update the write mask, as described above for vkCmdSetStencilCompareMask.
  • writeMask is the new value to use as the stencil write mask.

Description

Valid Usage
  • The currently bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_STENCIL_WRITE_MASK dynamic state enabled
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
  • faceMask must be a valid combination of VkStencilFaceFlagBits values
  • faceMask must not be 0
  • commandBuffer must be in the recording state
  • The VkCommandPool that commandBuffer was allocated from must support graphics operations
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

See Also

VkCommandBuffer, VkStencilFaceFlags

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCmdSetStencilWriteMask

vkCmdSetViewport(3)

Name

vkCmdSetViewport - Set the viewport on a command buffer

C Specification

If the bound pipeline state object was not created with the VK_DYNAMIC_STATE_VIEWPORT dynamic state enabled, viewport transformation parameters are specified using the pViewports member of VkPipelineViewportStateCreateInfo in the pipeline state object. If the pipeline state object was created with the VK_DYNAMIC_STATE_VIEWPORT dynamic state enabled, the viewport transformation parameters are dynamically set and changed with the command:

void vkCmdSetViewport(
    VkCommandBuffer                             commandBuffer,
    uint32_t                                    firstViewport,
    uint32_t                                    viewportCount,
    const VkViewport*                           pViewports);

Parameters

  • commandBuffer is the command buffer into which the command will be recorded.
  • firstViewport is the index of the first viewport whose parameters are updated by the command.
  • viewportCount is the number of viewports whose parameters are updated by the command.
  • pViewports is a pointer to an array of VkViewport structures specifying viewport parameters.

Description

The viewport parameters taken from element i of pViewports replace the current state for the viewport index firstViewport + i, for i in [0, viewportCount).

Valid Usage
  • The currently bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_VIEWPORT dynamic state enabled
  • firstViewport must be less than VkPhysicalDeviceLimits::maxViewports
  • The sum of firstViewport and viewportCount must be between 1 and VkPhysicalDeviceLimits::maxViewports, inclusive
  • If the multiple viewports feature is not enabled, firstViewport must be 0
  • If the multiple viewports feature is not enabled, viewportCount must be 1
  • pViewports must be a pointer to an array of viewportCount valid VkViewport structures
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
  • commandBuffer must be in the recording state
  • The VkCommandPool that commandBuffer was allocated from must support graphics operations
  • viewportCount must be greater than 0
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

See Also

VkCommandBuffer, VkViewport

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCmdSetViewport

vkCmdUpdateBuffer(3)

Name

vkCmdUpdateBuffer - Update a buffer’s contents from host memory

C Specification

To update buffer data inline in a command buffer, call:

void vkCmdUpdateBuffer(
    VkCommandBuffer                             commandBuffer,
    VkBuffer                                    dstBuffer,
    VkDeviceSize                                dstOffset,
    VkDeviceSize                                dataSize,
    const void*                                 pData);

Parameters

  • commandBuffer is the command buffer into which the command will be recorded.
  • dstBuffer is a handle to the buffer to be updated.
  • dstOffset is the byte offset into the buffer to start updating, and must be a multiple of 4.
  • dataSize is the number of bytes to update, and must be a multiple of 4.
  • pData is a pointer to the source data for the buffer update, and must be at least dataSize bytes in size.

Description

dataSize must be less than or equal to 65536 bytes. For larger updates, applications can use buffer to buffer copies.

The source data is copied from the user pointer to the command buffer when the command is called.

vkCmdUpdateBuffer is only allowed outside of a render pass. This command is treated as “transfer” operation, for the purposes of synchronization barriers. The VK_BUFFER_USAGE_TRANSFER_DST_BIT must be specified in usage of VkBufferCreateInfo in order for the buffer to be compatible with vkCmdUpdateBuffer.

Valid Usage
  • dstOffset must be less than the size of dstBuffer
  • dataSize must be less than or equal to the size of dstBuffer minus dstOffset
  • dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag
  • If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
  • dstOffset must be a multiple of 4
  • dataSize must be less than or equal to 65536
  • dataSize must be a multiple of 4
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
  • dstBuffer must be a valid VkBuffer handle
  • pData must be a pointer to an array of dataSize bytes
  • commandBuffer must be in the recording state
  • The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations
  • This command must only be called outside of a render pass instance
  • dataSize must be greater than 0
  • Both of commandBuffer, and dstBuffer must have been created, allocated, or retrieved from the same VkDevice
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
Secondary

Outside

Transfer
graphics
compute

Transfer

See Also

VkBuffer, VkCommandBuffer, VkDeviceSize

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCmdUpdateBuffer

vkCmdWaitEvents(3)

Name

vkCmdWaitEvents - Wait for one or more events and insert a set of memory

C Specification

To wait for one or more events to enter the signaled state on a device, call:

void vkCmdWaitEvents(
    VkCommandBuffer                             commandBuffer,
    uint32_t                                    eventCount,
    const VkEvent*                              pEvents,
    VkPipelineStageFlags                        srcStageMask,
    VkPipelineStageFlags                        dstStageMask,
    uint32_t                                    memoryBarrierCount,
    const VkMemoryBarrier*                      pMemoryBarriers,
    uint32_t                                    bufferMemoryBarrierCount,
    const VkBufferMemoryBarrier*                pBufferMemoryBarriers,
    uint32_t                                    imageMemoryBarrierCount,
    const VkImageMemoryBarrier*                 pImageMemoryBarriers);

Parameters

  • commandBuffer is the command buffer into which the command is recorded.
  • eventCount is the length of the pEvents array.
  • pEvents is an array of event object handles to wait on.
  • srcStageMask is a bitmask of VkPipelineStageFlagBits specifying the source stage mask.
  • dstStageMask is a bitmask of VkPipelineStageFlagBits specifying the destination stage mask.
  • memoryBarrierCount is the length of the pMemoryBarriers array.
  • pMemoryBarriers is a pointer to an array of VkMemoryBarrier structures.
  • bufferMemoryBarrierCount is the length of the pBufferMemoryBarriers array.
  • pBufferMemoryBarriers is a pointer to an array of VkBufferMemoryBarrier structures.
  • imageMemoryBarrierCount is the length of the pImageMemoryBarriers array.
  • pImageMemoryBarriers is a pointer to an array of VkImageMemoryBarrier structures.

Description

When vkCmdWaitEvents is submitted to a queue, it defines a memory dependency between prior event signal operations, and subsequent commands.

The first synchronization scope only includes event signal operations that operate on members of pEvents, and the operations that happened-before the event signal operations. Event signal operations performed by vkCmdSetEvent that were previously submitted to the same queue are included in the first synchronization scope, if the logically latest pipeline stage in their stageMask parameter is logically earlier than or equal to the logically latest pipeline stage in srcStageMask. Event signal operations performed by vkSetEvent are only included in the first synchronization scope if VK_PIPELINE_STAGE_HOST_BIT is included in srcStageMask.

The second synchronization scope includes commands subsequently submitted to the same queue, including those in the same command buffer and batch. 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. Within that, the first access scope only includes the first access scopes defined by elements of the pMemoryBarriers, pBufferMemoryBarriers and pImageMemoryBarriers arrays, which each define a set of memory barriers. If no memory barriers are specified, then the first access scope includes no accesses.

The second access scope is limited to access in the pipeline stages determined by the destination stage mask specified by dstStageMask. Within that, the second access scope only includes the second access scopes defined by elements of the pMemoryBarriers, pBufferMemoryBarriers and pImageMemoryBarriers arrays, which each define a set of memory barriers. If no memory barriers are specified, then the second access scope includes no accesses.

Note

vkCmdWaitEvents is used with vkCmdSetEvent to define a memory dependency between two sets of action commands, roughly in the same way as pipeline barriers, but split into two commands such that work between the two may execute unhindered.

Note

Applications should be careful to avoid race conditions when using events. There is no direct ordering guarantee between a vkCmdResetEvent command and a vkCmdWaitEvents command submitted after it, so some other execution dependency must be included between these commands (e.g. a semaphore).

Valid Usage
  • srcStageMask must be the bitwise OR of the stageMask parameter used in previous calls to vkCmdSetEvent with any of the members of pEvents and VK_PIPELINE_STAGE_HOST_BIT if any of the members of pEvents was set using vkSetEvent
  • 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
  • If pEvents includes one or more events that will be signaled by vkSetEvent after commandBuffer has been submitted to a queue, then vkCmdWaitEvents must not be called inside a render pass instance
  • Any pipeline stage included in srcStageMask or dstStageMask must be supported by the capabilities of the queue family specified by the queueFamilyIndex member of the VkCommandPoolCreateInfo structure that was used to create the VkCommandPool that commandBuffer was allocated from, as specified in the table of supported pipeline stages.
  • Any given element of pMemoryBarriers, pBufferMemoryBarriers or pImageMemoryBarriers must not have any access flag included in its srcAccessMask member if that bit is not supported by any of the pipeline stages in srcStageMask, as specified in the table of supported access types.
  • Any given element of pMemoryBarriers, pBufferMemoryBarriers or pImageMemoryBarriers must not have any access flag included in its dstAccessMask member if that bit is not supported by any of the pipeline stages in dstStageMask, as specified in the table of supported access types.
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
  • pEvents must be a pointer to an array of eventCount valid VkEvent handles
  • 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
  • If memoryBarrierCount is not 0, pMemoryBarriers must be a pointer to an array of memoryBarrierCount valid VkMemoryBarrier structures
  • If bufferMemoryBarrierCount is not 0, pBufferMemoryBarriers must be a pointer to an array of bufferMemoryBarrierCount valid VkBufferMemoryBarrier structures
  • If imageMemoryBarrierCount is not 0, pImageMemoryBarriers must be a pointer to an array of imageMemoryBarrierCount valid VkImageMemoryBarrier structures
  • commandBuffer must be in the recording state
  • The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations
  • eventCount must be greater than 0
  • Both of commandBuffer, and the elements of pEvents must have been created, allocated, or retrieved from the same VkDevice
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

See Also

VkBufferMemoryBarrier, VkCommandBuffer, VkEvent, VkImageMemoryBarrier, VkMemoryBarrier, VkPipelineStageFlags

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCmdWaitEvents

vkCmdWriteTimestamp(3)

Name

vkCmdWriteTimestamp - Write a device timestamp into a query object

C Specification

To request a timestamp, call:

void vkCmdWriteTimestamp(
    VkCommandBuffer                             commandBuffer,
    VkPipelineStageFlagBits                     pipelineStage,
    VkQueryPool                                 queryPool,
    uint32_t                                    query);

Parameters

  • commandBuffer is the command buffer into which the command will be recorded.
  • pipelineStage is one of the VkPipelineStageFlagBits, specifying a stage of the pipeline.
  • queryPool is the query pool that will manage the timestamp.
  • query is the query within the query pool that will contain the timestamp.

Description

vkCmdWriteTimestamp latches the value of the timer when all previous commands have completed executing as far as the specified pipeline stage, and writes the timestamp value to memory. When the timestamp value is written, the availability status of the query is set to available.

Note

If an implementation is unable to detect completion and latch the timer at any specific stage of the pipeline, it may instead do so at any logically later stage.

vkCmdCopyQueryPoolResults can then be called to copy the timestamp value from the query pool into buffer memory, with ordering and synchronization behavior equivalent to how other queries operate. Timestamp values can also be retrieved from the query pool using vkGetQueryPoolResults. As with other queries, the query must be reset using vkCmdResetQueryPool before requesting the timestamp value be written to it.

While vkCmdWriteTimestamp can be called inside or outside of a render pass instance, vkCmdCopyQueryPoolResults must only be called outside of a render pass instance.

Valid Usage
  • queryPool must have been created with a queryType of VK_QUERY_TYPE_TIMESTAMP
  • The query identified by queryPool and query must be unavailable
  • The command pool’s queue family must support a non-zero timestampValidBits
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
  • pipelineStage must be a valid VkPipelineStageFlagBits value
  • queryPool must be a valid VkQueryPool handle
  • commandBuffer must be in the recording state
  • The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations
  • Both of commandBuffer, and queryPool must have been created, allocated, or retrieved from the same VkDevice
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
Secondary

Both

Graphics
compute

Transfer

See Also

VkCommandBuffer, VkPipelineStageFlagBits, VkQueryPool

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCmdWriteTimestamp

vkCreateBuffer(3)

Name

vkCreateBuffer - Create a new buffer object

C Specification

To create buffers, call:

VkResult vkCreateBuffer(
    VkDevice                                    device,
    const VkBufferCreateInfo*                   pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkBuffer*                                   pBuffer);

Parameters

  • device is the logical device that creates the buffer object.
  • pCreateInfo is a pointer to an instance of the VkBufferCreateInfo structure containing parameters affecting creation of the buffer.
  • pAllocator controls host memory allocation as described in the Memory Allocation chapter.
  • pBuffer points to a VkBuffer handle in which the resulting buffer object is returned.

Description

Valid Usage
  • If the flags member of pCreateInfo includes VK_BUFFER_CREATE_SPARSE_BINDING_BIT, creating this VkBuffer must not cause the total required sparse memory for all currently valid sparse resources on the device to exceed VkPhysicalDeviceLimits::sparseAddressSpaceSize
Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • pCreateInfo must be a pointer to a valid VkBufferCreateInfo structure
  • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
  • pBuffer must be a pointer to a VkBuffer handle
Return Codes
Success
  • VK_SUCCESS
Failure
  • VK_ERROR_OUT_OF_HOST_MEMORY
  • VK_ERROR_OUT_OF_DEVICE_MEMORY

See Also

VkAllocationCallbacks, VkBuffer, VkBufferCreateInfo, VkDevice

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCreateBuffer

vkCreateBufferView(3)

Name

vkCreateBufferView - Create a new buffer view object

C Specification

To create a buffer view, call:

VkResult vkCreateBufferView(
    VkDevice                                    device,
    const VkBufferViewCreateInfo*               pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkBufferView*                               pView);

Parameters

  • device is the logical device that creates the buffer view.
  • pCreateInfo is a pointer to an instance of the VkBufferViewCreateInfo structure containing parameters to be used to create the buffer.
  • pAllocator controls host memory allocation as described in the Memory Allocation chapter.
  • pView points to a VkBufferView handle in which the resulting buffer view object is returned.

Description

Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • pCreateInfo must be a pointer to a valid VkBufferViewCreateInfo structure
  • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
  • pView must be a pointer to a VkBufferView handle
Return Codes
Success
  • VK_SUCCESS
Failure
  • VK_ERROR_OUT_OF_HOST_MEMORY
  • VK_ERROR_OUT_OF_DEVICE_MEMORY

See Also

VkAllocationCallbacks, VkBufferView, VkBufferViewCreateInfo, VkDevice

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCreateBufferView

vkCreateCommandPool(3)

Name

vkCreateCommandPool - Create a new command pool object

C Specification

To create a command pool, call:

VkResult vkCreateCommandPool(
    VkDevice                                    device,
    const VkCommandPoolCreateInfo*              pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkCommandPool*                              pCommandPool);

Parameters

  • device is the logical device that creates the command pool.
  • pCreateInfo contains information used to create the command pool.
  • pAllocator controls host memory allocation as described in the Memory Allocation chapter.
  • pCommandPool points to a VkCommandPool handle in which the created pool is returned.

Description

Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • pCreateInfo must be a pointer to a valid VkCommandPoolCreateInfo structure
  • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
  • pCommandPool must be a pointer to a VkCommandPool handle
Return Codes
Success
  • VK_SUCCESS
Failure
  • VK_ERROR_OUT_OF_HOST_MEMORY
  • VK_ERROR_OUT_OF_DEVICE_MEMORY

See Also

VkAllocationCallbacks, VkCommandPool, VkCommandPoolCreateInfo, VkDevice

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCreateCommandPool

vkCreateComputePipelines(3)

Name

vkCreateComputePipelines - Creates a new compute pipeline object

C Specification

To create compute pipelines, call:

VkResult vkCreateComputePipelines(
    VkDevice                                    device,
    VkPipelineCache                             pipelineCache,
    uint32_t                                    createInfoCount,
    const VkComputePipelineCreateInfo*          pCreateInfos,
    const VkAllocationCallbacks*                pAllocator,
    VkPipeline*                                 pPipelines);

Parameters

  • device is the logical device that creates the compute pipelines.
  • pipelineCache is either VK_NULL_HANDLE, indicating that pipeline caching is disabled; or the handle of a valid pipeline cache object, in which case use of that cache is enabled for the duration of the command.
  • createInfoCount is the length of the pCreateInfos and pPipelines arrays.
  • pCreateInfos is an array of VkComputePipelineCreateInfo structures.
  • pAllocator controls host memory allocation as described in the Memory Allocation chapter.
  • pPipelines is a pointer to an array in which the resulting compute pipeline objects are returned.

Description

Valid Usage
  • If the flags member of any given element of pCreateInfos contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and the basePipelineIndex member of that same element is not -1, basePipelineIndex must be less than the index into pCreateInfos that corresponds to that element
  • If the flags member of any given element of pCreateInfos contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, the base pipeline must have been created with the VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT flag set
Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • If pipelineCache is not VK_NULL_HANDLE, pipelineCache must be a valid VkPipelineCache handle
  • pCreateInfos must be a pointer to an array of createInfoCount valid VkComputePipelineCreateInfo structures
  • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
  • pPipelines must be a pointer to an array of createInfoCount VkPipeline handles
  • createInfoCount must be greater than 0
  • If pipelineCache is a valid handle, it must have been created, allocated, or retrieved from device
Return Codes
Success
  • VK_SUCCESS
Failure
  • VK_ERROR_OUT_OF_HOST_MEMORY
  • VK_ERROR_OUT_OF_DEVICE_MEMORY

See Also

VkAllocationCallbacks, VkComputePipelineCreateInfo, VkDevice, VkPipeline, VkPipelineCache

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCreateComputePipelines

vkCreateDescriptorPool(3)

Name

vkCreateDescriptorPool - Creates a descriptor pool object

C Specification

To create a descriptor pool object, call:

VkResult vkCreateDescriptorPool(
    VkDevice                                    device,
    const VkDescriptorPoolCreateInfo*           pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkDescriptorPool*                           pDescriptorPool);

Parameters

  • device is the logical device that creates the descriptor pool.
  • pCreateInfo is a pointer to an instance of the VkDescriptorPoolCreateInfo structure specifying the state of the descriptor pool object.
  • pAllocator controls host memory allocation as described in the Memory Allocation chapter.
  • pDescriptorPool points to a VkDescriptorPool handle in which the resulting descriptor pool object is returned.

Description

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

The created descriptor pool is returned in pDescriptorPool.

Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • pCreateInfo must be a pointer to a valid VkDescriptorPoolCreateInfo structure
  • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
  • pDescriptorPool must be a pointer to a VkDescriptorPool handle
Return Codes
Success
  • VK_SUCCESS
Failure
  • VK_ERROR_OUT_OF_HOST_MEMORY
  • VK_ERROR_OUT_OF_DEVICE_MEMORY

See Also

VkAllocationCallbacks, VkDescriptorPool, VkDescriptorPoolCreateInfo, VkDevice

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCreateDescriptorPool

vkCreateDescriptorSetLayout(3)

Name

vkCreateDescriptorSetLayout - Create a new descriptor set layout

C Specification

To create descriptor set layout objects, call:

VkResult vkCreateDescriptorSetLayout(
    VkDevice                                    device,
    const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkDescriptorSetLayout*                      pSetLayout);

Parameters

  • device is the logical device that creates the descriptor set layout.
  • pCreateInfo is a pointer to an instance of the VkDescriptorSetLayoutCreateInfo structure specifying the state of the descriptor set layout object.
  • pAllocator controls host memory allocation as described in the Memory Allocation chapter.
  • pSetLayout points to a VkDescriptorSetLayout handle in which the resulting descriptor set layout object is returned.

Description

Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • pCreateInfo must be a pointer to a valid VkDescriptorSetLayoutCreateInfo structure
  • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
  • pSetLayout must be a pointer to a VkDescriptorSetLayout handle
Return Codes
Success
  • VK_SUCCESS
Failure
  • VK_ERROR_OUT_OF_HOST_MEMORY
  • VK_ERROR_OUT_OF_DEVICE_MEMORY

See Also

VkAllocationCallbacks, VkDescriptorSetLayout, VkDescriptorSetLayoutCreateInfo, VkDevice

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCreateDescriptorSetLayout

vkCreateDevice(3)

Name

vkCreateDevice - Create a new device instance

C Specification

A logical device is created as a connection to a physical device. To create a logical device, call:

VkResult vkCreateDevice(
    VkPhysicalDevice                            physicalDevice,
    const VkDeviceCreateInfo*                   pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkDevice*                                   pDevice);

Parameters

  • physicalDevice must be one of the device handles returned from a call to vkEnumeratePhysicalDevices (see Physical Device Enumeration).
  • pCreateInfo is a pointer to a VkDeviceCreateInfo structure containing information about how to create the device.
  • pAllocator controls host memory allocation as described in the Memory Allocation chapter.
  • pDevice points to a handle in which the created VkDevice is returned.

Description

vkCreateDevice verifies that extensions and features requested in the ppEnabledExtensionNames and pEnabledFeatures members of pCreateInfo, respectively, are supported by the implementation. If any requested extension is not supported, vkCreateDevice must return VK_ERROR_EXTENSION_NOT_PRESENT. If any requested feature is not supported, vkCreateDevice must return VK_ERROR_FEATURE_NOT_PRESENT. Support for extensions can be checked before creating a device by querying vkEnumerateDeviceExtensionProperties. Support for features can similarly be checked by querying vkGetPhysicalDeviceFeatures.

After verifying and enabling the extensions the VkDevice object is created and returned to the application. If a requested extension is only supported by a layer, both the layer and the extension need to be specified at vkCreateInstance time for the creation to succeed.

Multiple logical devices can be created from the same physical device. Logical device creation may fail due to lack of device-specific resources (in addition to the other errors). If that occurs, vkCreateDevice will return VK_ERROR_TOO_MANY_OBJECTS.

Valid Usage
Valid Usage (Implicit)
  • physicalDevice must be a valid VkPhysicalDevice handle
  • pCreateInfo must be a pointer to a valid VkDeviceCreateInfo structure
  • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
  • pDevice must be a pointer to a VkDevice handle
Return Codes
Success
  • VK_SUCCESS
Failure
  • VK_ERROR_OUT_OF_HOST_MEMORY
  • VK_ERROR_OUT_OF_DEVICE_MEMORY
  • VK_ERROR_INITIALIZATION_FAILED
  • VK_ERROR_EXTENSION_NOT_PRESENT
  • VK_ERROR_FEATURE_NOT_PRESENT
  • VK_ERROR_TOO_MANY_OBJECTS
  • VK_ERROR_DEVICE_LOST

See Also

VkAllocationCallbacks, VkDevice, VkDeviceCreateInfo, VkPhysicalDevice

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCreateDevice

vkCreateEvent(3)

Name

vkCreateEvent - Create a new event object

C Specification

To create an event, call:

VkResult vkCreateEvent(
    VkDevice                                    device,
    const VkEventCreateInfo*                    pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkEvent*                                    pEvent);

Parameters

  • device is the logical device that creates the event.
  • pCreateInfo is a pointer to an instance of the VkEventCreateInfo structure which contains information about how the event is to be created.
  • pAllocator controls host memory allocation as described in the Memory Allocation chapter.
  • pEvent points to a handle in which the resulting event object is returned.

Description

When created, the event object is in the unsignaled state.

Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • pCreateInfo must be a pointer to a valid VkEventCreateInfo structure
  • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
  • pEvent must be a pointer to a VkEvent handle
Return Codes
Success
  • VK_SUCCESS
Failure
  • VK_ERROR_OUT_OF_HOST_MEMORY
  • VK_ERROR_OUT_OF_DEVICE_MEMORY

See Also

VkAllocationCallbacks, VkDevice, VkEvent, VkEventCreateInfo

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCreateEvent

vkCreateFence(3)

Name

vkCreateFence - Create a new fence object

C Specification

To create a fence, call:

VkResult vkCreateFence(
    VkDevice                                    device,
    const VkFenceCreateInfo*                    pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkFence*                                    pFence);

Parameters

  • device is the logical device that creates the fence.
  • pCreateInfo is a pointer to an instance of the VkFenceCreateInfo structure which contains information about how the fence is to be created.
  • pAllocator controls host memory allocation as described in the Memory Allocation chapter.
  • pFence points to a handle in which the resulting fence object is returned.

Description

Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • pCreateInfo must be a pointer to a valid VkFenceCreateInfo structure
  • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
  • pFence must be a pointer to a VkFence handle
Return Codes
Success
  • VK_SUCCESS
Failure
  • VK_ERROR_OUT_OF_HOST_MEMORY
  • VK_ERROR_OUT_OF_DEVICE_MEMORY

See Also

VkAllocationCallbacks, VkDevice, VkFence, VkFenceCreateInfo

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCreateFence

vkCreateFramebuffer(3)

Name

vkCreateFramebuffer - Create a new framebuffer object

C Specification

To create a framebuffer, call:

VkResult vkCreateFramebuffer(
    VkDevice                                    device,
    const VkFramebufferCreateInfo*              pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkFramebuffer*                              pFramebuffer);

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 pointer to a valid VkFramebufferCreateInfo structure
  • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
  • pFramebuffer must be a pointer to a VkFramebuffer handle
Return Codes
Success
  • VK_SUCCESS
Failure
  • VK_ERROR_OUT_OF_HOST_MEMORY
  • VK_ERROR_OUT_OF_DEVICE_MEMORY

See Also

VkAllocationCallbacks, VkDevice, VkFramebuffer, VkFramebufferCreateInfo

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCreateFramebuffer

vkCreateGraphicsPipelines(3)

Name

vkCreateGraphicsPipelines - Create graphics pipelines

C Specification

To create graphics pipelines, call:

VkResult vkCreateGraphicsPipelines(
    VkDevice                                    device,
    VkPipelineCache                             pipelineCache,
    uint32_t                                    createInfoCount,
    const VkGraphicsPipelineCreateInfo*         pCreateInfos,
    const VkAllocationCallbacks*                pAllocator,
    VkPipeline*                                 pPipelines);

Parameters

  • device is the logical device that creates the graphics pipelines.
  • pipelineCache is either VK_NULL_HANDLE, indicating that pipeline caching is disabled; or the handle of a valid pipeline cache object, in which case use of that cache is enabled for the duration of the command.
  • createInfoCount is the length of the pCreateInfos and pPipelines arrays.
  • pCreateInfos is an array of VkGraphicsPipelineCreateInfo structures.
  • pAllocator controls host memory allocation as described in the Memory Allocation chapter.
  • pPipelines is a pointer to an array in which the resulting graphics pipeline objects are returned.

Description

The VkGraphicsPipelineCreateInfo structure includes an array of shader create info structures containing all the desired active shader stages, as well as creation info to define all relevant fixed-function stages, and a pipeline layout.

Valid Usage
  • If the flags member of any given element of pCreateInfos contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and the basePipelineIndex member of that same element is not -1, basePipelineIndex must be less than the index into pCreateInfos that corresponds to that element
  • If the flags member of any given element of pCreateInfos contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, the base pipeline must have been created with the VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT flag set
Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • If pipelineCache is not VK_NULL_HANDLE, pipelineCache must be a valid VkPipelineCache handle
  • pCreateInfos must be a pointer to an array of createInfoCount valid VkGraphicsPipelineCreateInfo structures
  • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
  • pPipelines must be a pointer to an array of createInfoCount VkPipeline handles
  • createInfoCount must be greater than 0
  • If pipelineCache is a valid handle, it must have been created, allocated, or retrieved from device
Return Codes
Success
  • VK_SUCCESS
Failure
  • VK_ERROR_OUT_OF_HOST_MEMORY
  • VK_ERROR_OUT_OF_DEVICE_MEMORY

See Also

VkAllocationCallbacks, VkDevice, VkGraphicsPipelineCreateInfo, VkPipeline, VkPipelineCache

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCreateGraphicsPipelines

vkCreateImage(3)

Name

vkCreateImage - Create a new image object

C Specification

To create images, call:

VkResult vkCreateImage(
    VkDevice                                    device,
    const VkImageCreateInfo*                    pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkImage*                                    pImage);

Parameters

  • device is the logical device that creates the image.
  • pCreateInfo is a pointer to an instance of the VkImageCreateInfo structure containing parameters to be used to create the image.
  • pAllocator controls host memory allocation as described in the Memory Allocation chapter.
  • pImage points to a VkImage handle in which the resulting image object is returned.

Description

Valid Usage
  • If the flags member of pCreateInfo includes VK_IMAGE_CREATE_SPARSE_BINDING_BIT, creating this VkImage must not cause the total required sparse memory for all currently valid sparse resources on the device to exceed VkPhysicalDeviceLimits::sparseAddressSpaceSize
Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • pCreateInfo must be a pointer to a valid VkImageCreateInfo structure
  • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
  • pImage must be a pointer to a VkImage handle
Return Codes
Success
  • VK_SUCCESS
Failure
  • VK_ERROR_OUT_OF_HOST_MEMORY
  • VK_ERROR_OUT_OF_DEVICE_MEMORY

See Also

VkAllocationCallbacks, VkDevice, VkImage, VkImageCreateInfo

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCreateImage

vkCreateImageView(3)

Name

vkCreateImageView - Create an image view from an existing image

C Specification

To create an image view, call:

VkResult vkCreateImageView(
    VkDevice                                    device,
    const VkImageViewCreateInfo*                pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkImageView*                                pView);

Parameters

  • device is the logical device that creates the image view.
  • pCreateInfo is a pointer to an instance of the VkImageViewCreateInfo structure containing parameters to be used to create the image view.
  • pAllocator controls host memory allocation as described in the Memory Allocation chapter.
  • pView points to a VkImageView handle in which the resulting image view object is returned.

Description

Some of the image creation parameters are inherited by the view. The remaining parameters are contained in the pCreateInfo.

Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • pCreateInfo must be a pointer to a valid VkImageViewCreateInfo structure
  • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
  • pView must be a pointer to a VkImageView handle
Return Codes
Success
  • VK_SUCCESS
Failure
  • VK_ERROR_OUT_OF_HOST_MEMORY
  • VK_ERROR_OUT_OF_DEVICE_MEMORY

See Also

VkAllocationCallbacks, VkDevice, VkImageView, VkImageViewCreateInfo

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCreateImageView

vkCreateInstance(3)

Name

vkCreateInstance - Create a new Vulkan instance

C Specification

To create an instance object, call:

VkResult vkCreateInstance(
    const VkInstanceCreateInfo*                 pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkInstance*                                 pInstance);

Parameters

  • pCreateInfo points to an instance of VkInstanceCreateInfo controlling creation of the instance.
  • pAllocator controls host memory allocation as described in the Memory Allocation chapter.
  • pInstance points a VkInstance handle in which the resulting instance is returned.

Description

vkCreateInstance verifies that the requested layers exist. If not, vkCreateInstance will return VK_ERROR_LAYER_NOT_PRESENT. Next vkCreateInstance verifies that the requested extensions are supported (e.g. in the implementation or in any enabled instance layer) and if any requested extension is not supported, vkCreateInstance must return VK_ERROR_EXTENSION_NOT_PRESENT. After verifying and enabling the instance layers and extensions the VkInstance object is created and returned to the application. If a requested extension is only supported by a layer, both the layer and the extension need to be specified at vkCreateInstance time for the creation to succeed.

Valid Usage
Valid Usage (Implicit)
  • pCreateInfo must be a pointer to a valid VkInstanceCreateInfo structure
  • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
  • pInstance must be a pointer to a VkInstance handle
Return Codes
Success
  • VK_SUCCESS
Failure
  • VK_ERROR_OUT_OF_HOST_MEMORY
  • VK_ERROR_OUT_OF_DEVICE_MEMORY
  • VK_ERROR_INITIALIZATION_FAILED
  • VK_ERROR_LAYER_NOT_PRESENT
  • VK_ERROR_EXTENSION_NOT_PRESENT
  • VK_ERROR_INCOMPATIBLE_DRIVER

See Also

VkAllocationCallbacks, VkInstance, VkInstanceCreateInfo

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCreateInstance

vkCreatePipelineCache(3)

Name

vkCreatePipelineCache - Creates a new pipeline cache

C Specification

To create pipeline cache objects, call:

VkResult vkCreatePipelineCache(
    VkDevice                                    device,
    const VkPipelineCacheCreateInfo*            pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkPipelineCache*                            pPipelineCache);

Parameters

  • device is the logical device that creates the pipeline cache object.
  • pCreateInfo is a pointer to a VkPipelineCacheCreateInfo structure that contains the initial parameters for the pipeline cache object.
  • pAllocator controls host memory allocation as described in the Memory Allocation chapter.
  • pPipelineCache is a pointer to a VkPipelineCache handle in which the resulting pipeline cache object is returned.

Description

Note

Applications can track and manage the total host memory size of a pipeline cache object using the pAllocator. Applications can limit the amount of data retrieved from a pipeline cache object in vkGetPipelineCacheData. Implementations should not internally limit the total number of entries added to a pipeline cache object or the total host memory consumed.

Once created, a pipeline cache can be passed to the vkCreateGraphicsPipelines and vkCreateComputePipelines commands. If the pipeline cache passed into these commands is not VK_NULL_HANDLE, the implementation will query it for possible reuse opportunities and update it with new content. The use of the pipeline cache object in these commands is internally synchronized, and the same pipeline cache object can be used in multiple threads simultaneously.

Note

Implementations should make every effort to limit any critical sections to the actual accesses to the cache, which is expected to be significantly shorter than the duration of the vkCreateGraphicsPipelines and vkCreateComputePipelines commands.

Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • pCreateInfo must be a pointer to a valid VkPipelineCacheCreateInfo structure
  • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
  • pPipelineCache must be a pointer to a VkPipelineCache handle
Return Codes
Success
  • VK_SUCCESS
Failure
  • VK_ERROR_OUT_OF_HOST_MEMORY
  • VK_ERROR_OUT_OF_DEVICE_MEMORY

See Also

VkAllocationCallbacks, VkDevice, VkPipelineCache, VkPipelineCacheCreateInfo

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCreatePipelineCache

vkCreatePipelineLayout(3)

Name

vkCreatePipelineLayout - Creates a new pipeline layout object

C Specification

To create a pipeline layout, call:

VkResult vkCreatePipelineLayout(
    VkDevice                                    device,
    const VkPipelineLayoutCreateInfo*           pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkPipelineLayout*                           pPipelineLayout);

Parameters

  • device is the logical device that creates the pipeline layout.
  • pCreateInfo is a pointer to an instance of the VkPipelineLayoutCreateInfo structure specifying the state of the pipeline layout object.
  • pAllocator controls host memory allocation as described in the Memory Allocation chapter.
  • pPipelineLayout points to a VkPipelineLayout handle in which the resulting pipeline layout object is returned.

Description

Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • pCreateInfo must be a pointer to a valid VkPipelineLayoutCreateInfo structure
  • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
  • pPipelineLayout must be a pointer to a VkPipelineLayout handle
Return Codes
Success
  • VK_SUCCESS
Failure
  • VK_ERROR_OUT_OF_HOST_MEMORY
  • VK_ERROR_OUT_OF_DEVICE_MEMORY

See Also

VkAllocationCallbacks, VkDevice, VkPipelineLayout, VkPipelineLayoutCreateInfo

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCreatePipelineLayout

vkCreateQueryPool(3)

Name

vkCreateQueryPool - Create a new query pool object

C Specification

To create a query pool, call:

VkResult vkCreateQueryPool(
    VkDevice                                    device,
    const VkQueryPoolCreateInfo*                pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkQueryPool*                                pQueryPool);

Parameters

  • device is the logical device that creates the query pool.
  • pCreateInfo is a pointer to an instance of the VkQueryPoolCreateInfo structure containing the number and type of queries to be managed by the pool.
  • pAllocator controls host memory allocation as described in the Memory Allocation chapter.
  • pQueryPool is a pointer to a VkQueryPool handle in which the resulting query pool object is returned.

Description

Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • pCreateInfo must be a pointer to a valid VkQueryPoolCreateInfo structure
  • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
  • pQueryPool must be a pointer to a VkQueryPool handle
Return Codes
Success
  • VK_SUCCESS
Failure
  • VK_ERROR_OUT_OF_HOST_MEMORY
  • VK_ERROR_OUT_OF_DEVICE_MEMORY

See Also

VkAllocationCallbacks, VkDevice, VkQueryPool, VkQueryPoolCreateInfo

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCreateQueryPool

vkCreateRenderPass(3)

Name

vkCreateRenderPass - Create a new render pass object

C Specification

To create a render pass, call:

VkResult vkCreateRenderPass(
    VkDevice                                    device,
    const VkRenderPassCreateInfo*               pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkRenderPass*                               pRenderPass);

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 pointer to a valid VkRenderPassCreateInfo structure
  • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
  • pRenderPass must be a pointer to a VkRenderPass handle
Return Codes
Success
  • VK_SUCCESS
Failure
  • VK_ERROR_OUT_OF_HOST_MEMORY
  • VK_ERROR_OUT_OF_DEVICE_MEMORY

See Also

VkAllocationCallbacks, VkDevice, VkRenderPass, VkRenderPassCreateInfo

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCreateRenderPass

vkCreateSampler(3)

Name

vkCreateSampler - Create a new sampler object

C Specification

To create a sampler object, call:

VkResult vkCreateSampler(
    VkDevice                                    device,
    const VkSamplerCreateInfo*                  pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkSampler*                                  pSampler);

Parameters

  • device is the logical device that creates the sampler.
  • pCreateInfo is a pointer to an instance of the VkSamplerCreateInfo structure specifying the state of the sampler object.
  • pAllocator controls host memory allocation as described in the Memory Allocation chapter.
  • pSampler points to a VkSampler handle in which the resulting sampler object is returned.

Description

Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • pCreateInfo must be a pointer to a valid VkSamplerCreateInfo structure
  • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
  • pSampler must be a pointer to a VkSampler handle
Return Codes
Success
  • VK_SUCCESS
Failure
  • VK_ERROR_OUT_OF_HOST_MEMORY
  • VK_ERROR_OUT_OF_DEVICE_MEMORY
  • VK_ERROR_TOO_MANY_OBJECTS

See Also

VkAllocationCallbacks, VkDevice, VkSampler, VkSamplerCreateInfo

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCreateSampler

vkCreateSemaphore(3)

Name

vkCreateSemaphore - Create a new queue semaphore object

C Specification

To create a semaphore, call:

VkResult vkCreateSemaphore(
    VkDevice                                    device,
    const VkSemaphoreCreateInfo*                pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkSemaphore*                                pSemaphore);

Parameters

  • device is the logical device that creates the semaphore.
  • pCreateInfo is a pointer to an instance of the VkSemaphoreCreateInfo structure which contains information about how the semaphore is to be created.
  • pAllocator controls host memory allocation as described in the Memory Allocation chapter.
  • pSemaphore points to a handle in which the resulting semaphore object is returned.

Description

When created, the semaphore is in the unsignaled state.

Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • pCreateInfo must be a pointer to a valid VkSemaphoreCreateInfo structure
  • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
  • pSemaphore must be a pointer to a VkSemaphore handle
Return Codes
Success
  • VK_SUCCESS
Failure
  • VK_ERROR_OUT_OF_HOST_MEMORY
  • VK_ERROR_OUT_OF_DEVICE_MEMORY

See Also

VkAllocationCallbacks, VkDevice, VkSemaphore, VkSemaphoreCreateInfo

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCreateSemaphore

vkCreateShaderModule(3)

Name

vkCreateShaderModule - Creates a new shader module object

C Specification

To create a shader module, call:

VkResult vkCreateShaderModule(
    VkDevice                                    device,
    const VkShaderModuleCreateInfo*             pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkShaderModule*                             pShaderModule);

Parameters

  • device is the logical device that creates the shader module.
  • pCreateInfo parameter is a pointer to an instance of the VkShaderModuleCreateInfo structure.
  • pAllocator controls host memory allocation as described in the Memory Allocation chapter.
  • pShaderModule points to a VkShaderModule handle in which the resulting shader module object is returned.

Description

Once a shader module has been created, any entry points it contains can be used in pipeline shader stages as described in Compute Pipelines and Graphics Pipelines.

Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • pCreateInfo must be a pointer to a valid VkShaderModuleCreateInfo structure
  • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
  • pShaderModule must be a pointer to a VkShaderModule handle
Return Codes
Success
  • VK_SUCCESS
Failure
  • VK_ERROR_OUT_OF_HOST_MEMORY
  • VK_ERROR_OUT_OF_DEVICE_MEMORY

See Also

VkAllocationCallbacks, VkDevice, VkShaderModule, VkShaderModuleCreateInfo

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkCreateShaderModule

vkDestroyBuffer(3)

Name

vkDestroyBuffer - Destroy a buffer object

C Specification

To destroy a buffer, call:

void vkDestroyBuffer(
    VkDevice                                    device,
    VkBuffer                                    buffer,
    const VkAllocationCallbacks*                pAllocator);

Parameters

  • device is the logical device that destroys the buffer.
  • buffer is the buffer to destroy.
  • pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Description

Valid Usage
  • All submitted commands that refer to buffer, either directly or via a VkBufferView, must have completed execution
  • If VkAllocationCallbacks were provided when buffer was created, a compatible set of callbacks must be provided here
  • If no VkAllocationCallbacks were provided when buffer was created, pAllocator must be NULL
Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • If buffer is not VK_NULL_HANDLE, buffer must be a valid VkBuffer handle
  • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
  • If buffer is a valid handle, it must have been created, allocated, or retrieved from device
Host Synchronization
  • Host access to buffer must be externally synchronized

See Also

VkAllocationCallbacks, VkBuffer, VkDevice

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkDestroyBuffer

vkDestroyBufferView(3)

Name

vkDestroyBufferView - Destroy a buffer view object

C Specification

To destroy a buffer view, call:

void vkDestroyBufferView(
    VkDevice                                    device,
    VkBufferView                                bufferView,
    const VkAllocationCallbacks*                pAllocator);

Parameters

  • device is the logical device that destroys the buffer view.
  • bufferView is the buffer view to destroy.
  • pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Description

Valid Usage
  • All submitted commands that refer to bufferView must have completed execution
  • If VkAllocationCallbacks were provided when bufferView was created, a compatible set of callbacks must be provided here
  • If no VkAllocationCallbacks were provided when bufferView was created, pAllocator must be NULL
Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • If bufferView is not VK_NULL_HANDLE, bufferView must be a valid VkBufferView handle
  • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
  • If bufferView is a valid handle, it must have been created, allocated, or retrieved from device
Host Synchronization
  • Host access to bufferView must be externally synchronized

See Also

VkAllocationCallbacks, VkBufferView, VkDevice

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkDestroyBufferView

vkDestroyCommandPool(3)

Name

vkDestroyCommandPool - Destroy a command pool object

C Specification

To destroy a command pool, call:

void vkDestroyCommandPool(
    VkDevice                                    device,
    VkCommandPool                               commandPool,
    const VkAllocationCallbacks*                pAllocator);

Parameters

  • device is the logical device that destroys the command pool.
  • commandPool is the handle of the command pool to destroy.
  • pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Description

When a pool is destroyed, all command buffers allocated from the pool are freed.

Any primary command buffer allocated from another VkCommandPool that is in the recording or executable state and has a secondary command buffer allocated from commandPool recorded into it, becomes invalid.

Valid Usage
  • All VkCommandBuffer objects allocated from commandPool must not be in the pending state.
  • If VkAllocationCallbacks were provided when commandPool was created, a compatible set of callbacks must be provided here
  • If no VkAllocationCallbacks were provided when commandPool was created, pAllocator must be NULL
Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • If commandPool is not VK_NULL_HANDLE, commandPool must be a valid VkCommandPool handle
  • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
  • If commandPool is a valid handle, it must have been created, allocated, or retrieved from device
Host Synchronization
  • Host access to commandPool must be externally synchronized

See Also

VkAllocationCallbacks, VkCommandPool, VkDevice

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkDestroyCommandPool

vkDestroyDescriptorPool(3)

Name

vkDestroyDescriptorPool - Destroy a descriptor pool object

C Specification

To destroy a descriptor pool, call:

void vkDestroyDescriptorPool(
    VkDevice                                    device,
    VkDescriptorPool                            descriptorPool,
    const VkAllocationCallbacks*                pAllocator);

Parameters

  • device is the logical device that destroys the descriptor pool.
  • descriptorPool is the descriptor pool to destroy.
  • pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Description

When a pool is destroyed, all descriptor sets allocated from the pool are implicitly freed and become invalid. Descriptor sets allocated from a given pool do not need to be freed before destroying that descriptor pool.

Valid Usage
  • All submitted commands that refer to descriptorPool (via any allocated descriptor sets) must have completed execution
  • If VkAllocationCallbacks were provided when descriptorPool was created, a compatible set of callbacks must be provided here
  • If no VkAllocationCallbacks were provided when descriptorPool was created, pAllocator must be NULL
Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • If descriptorPool is not VK_NULL_HANDLE, descriptorPool must be a valid VkDescriptorPool handle
  • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
  • If descriptorPool is a valid handle, it must have been created, allocated, or retrieved from device
Host Synchronization
  • Host access to descriptorPool must be externally synchronized

See Also

VkAllocationCallbacks, VkDescriptorPool, VkDevice

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkDestroyDescriptorPool

vkDestroyDescriptorSetLayout(3)

Name

vkDestroyDescriptorSetLayout - Destroy a descriptor set layout object

C Specification

To destroy a descriptor set layout, call:

void vkDestroyDescriptorSetLayout(
    VkDevice                                    device,
    VkDescriptorSetLayout                       descriptorSetLayout,
    const VkAllocationCallbacks*                pAllocator);

Parameters

  • device is the logical device that destroys the descriptor set layout.
  • descriptorSetLayout is the descriptor set layout to destroy.
  • pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Description

Valid Usage
  • If VkAllocationCallbacks were provided when descriptorSetLayout was created, a compatible set of callbacks must be provided here
  • If no VkAllocationCallbacks were provided when descriptorSetLayout was created, pAllocator must be NULL
Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • If descriptorSetLayout is not VK_NULL_HANDLE, descriptorSetLayout must be a valid VkDescriptorSetLayout handle
  • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
  • If descriptorSetLayout is a valid handle, it must have been created, allocated, or retrieved from device
Host Synchronization
  • Host access to descriptorSetLayout must be externally synchronized

See Also

VkAllocationCallbacks, VkDescriptorSetLayout, VkDevice

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkDestroyDescriptorSetLayout

vkDestroyDevice(3)

Name

vkDestroyDevice - Destroy a logical device

C Specification

To destroy a device, call:

void vkDestroyDevice(
    VkDevice                                    device,
    const VkAllocationCallbacks*                pAllocator);

Parameters

  • device is the logical device to destroy.
  • pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Description

To ensure that no work is active on the device, vkDeviceWaitIdle can be used to gate the destruction of the device. Prior to destroying a device, an application is responsible for destroying/freeing any Vulkan objects that were created using that device as the first parameter of the corresponding vkCreate* or vkAllocate* command.

Note

The lifetime of each of these objects is bound by the lifetime of the VkDevice object. Therefore, to avoid resource leaks, it is critical that an application explicitly free all of these resources prior to calling vkDestroyDevice.

Valid Usage
  • All child objects created on device must have been destroyed prior to destroying device
  • If VkAllocationCallbacks were provided when device was created, a compatible set of callbacks must be provided here
  • If no VkAllocationCallbacks were provided when device was created, pAllocator must be NULL
Valid Usage (Implicit)
  • If device is not NULL, device must be a valid VkDevice handle
  • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
Host Synchronization
  • Host access to device must be externally synchronized

See Also

VkAllocationCallbacks, VkDevice

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkDestroyDevice

vkDestroyEvent(3)

Name

vkDestroyEvent - Destroy an event object

C Specification

To destroy an event, call:

void vkDestroyEvent(
    VkDevice                                    device,
    VkEvent                                     event,
    const VkAllocationCallbacks*                pAllocator);

Parameters

  • device is the logical device that destroys the event.
  • event is the handle of the event to destroy.
  • pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Description

Valid Usage
  • All submitted commands that refer to event must have completed execution
  • If VkAllocationCallbacks were provided when event was created, a compatible set of callbacks must be provided here
  • If no VkAllocationCallbacks were provided when event was created, pAllocator must be NULL
Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • If event is not VK_NULL_HANDLE, event must be a valid VkEvent handle
  • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
  • If event is a valid handle, it must have been created, allocated, or retrieved from device
Host Synchronization
  • Host access to event must be externally synchronized

See Also

VkAllocationCallbacks, VkDevice, VkEvent

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkDestroyEvent

vkDestroyFence(3)

Name

vkDestroyFence - Destroy a fence object

C Specification

To destroy a fence, call:

void vkDestroyFence(
    VkDevice                                    device,
    VkFence                                     fence,
    const VkAllocationCallbacks*                pAllocator);

Parameters

  • device is the logical device that destroys the fence.
  • fence is the handle of the fence to destroy.
  • pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Description

Valid Usage
  • All queue submission commands that refer to fence must have completed execution
  • If VkAllocationCallbacks were provided when fence was created, a compatible set of callbacks must be provided here
  • If no VkAllocationCallbacks were provided when fence was created, pAllocator must be NULL
Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • If fence is not VK_NULL_HANDLE, fence must be a valid VkFence handle
  • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
  • If fence is a valid handle, it must have been created, allocated, or retrieved from device
Host Synchronization
  • Host access to fence must be externally synchronized

See Also

VkAllocationCallbacks, VkDevice, VkFence

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkDestroyFence

vkDestroyFramebuffer(3)

Name

vkDestroyFramebuffer - Destroy a framebuffer object

C Specification

To destroy a framebuffer, call:

void vkDestroyFramebuffer(
    VkDevice                                    device,
    VkFramebuffer                               framebuffer,
    const VkAllocationCallbacks*                pAllocator);

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 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

See Also

VkAllocationCallbacks, VkDevice, VkFramebuffer

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkDestroyFramebuffer

vkDestroyImage(3)

Name

vkDestroyImage - Destroy an image object

C Specification

To destroy an image, call:

void vkDestroyImage(
    VkDevice                                    device,
    VkImage                                     image,
    const VkAllocationCallbacks*                pAllocator);

Parameters

  • device is the logical device that destroys the image.
  • image is the image to destroy.
  • pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Description

Valid Usage
  • All submitted commands that refer to image, either directly or via a VkImageView, must have completed execution
  • If VkAllocationCallbacks were provided when image was created, a compatible set of callbacks must be provided here
  • If no VkAllocationCallbacks were provided when image was created, pAllocator must be NULL
Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • If image is not VK_NULL_HANDLE, image must be a valid VkImage handle
  • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
  • If image is a valid handle, it must have been created, allocated, or retrieved from device
Host Synchronization
  • Host access to image must be externally synchronized

See Also

VkAllocationCallbacks, VkDevice, VkImage

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkDestroyImage

vkDestroyImageView(3)

Name

vkDestroyImageView - Destroy an image view object

C Specification

To destroy an image view, call:

void vkDestroyImageView(
    VkDevice                                    device,
    VkImageView                                 imageView,
    const VkAllocationCallbacks*                pAllocator);

Parameters

  • device is the logical device that destroys the image view.
  • imageView is the image view to destroy.
  • pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Description

Valid Usage
  • All submitted commands that refer to imageView must have completed execution
  • If VkAllocationCallbacks were provided when imageView was created, a compatible set of callbacks must be provided here
  • If no VkAllocationCallbacks were provided when imageView was created, pAllocator must be NULL
Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • If imageView is not VK_NULL_HANDLE, imageView must be a valid VkImageView handle
  • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
  • If imageView is a valid handle, it must have been created, allocated, or retrieved from device
Host Synchronization
  • Host access to imageView must be externally synchronized

See Also

VkAllocationCallbacks, VkDevice, VkImageView

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkDestroyImageView

vkDestroyInstance(3)

Name

vkDestroyInstance - Destroy an instance of Vulkan

C Specification

To destroy an instance, call:

void vkDestroyInstance(
    VkInstance                                  instance,
    const VkAllocationCallbacks*                pAllocator);

Parameters

  • instance is the handle of the instance to destroy.
  • pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Description

Valid Usage
  • All child objects created using instance must have been destroyed prior to destroying instance
  • If VkAllocationCallbacks were provided when instance was created, a compatible set of callbacks must be provided here
  • If no VkAllocationCallbacks were provided when instance was created, pAllocator must be NULL
Valid Usage (Implicit)
  • If instance is not NULL, instance must be a valid VkInstance handle
  • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
Host Synchronization
  • Host access to instance must be externally synchronized

See Also

VkAllocationCallbacks, VkInstance

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkDestroyInstance

vkDestroyPipeline(3)

Name

vkDestroyPipeline - Destroy a pipeline object

C Specification

To destroy a graphics or compute pipeline, call:

void vkDestroyPipeline(
    VkDevice                                    device,
    VkPipeline                                  pipeline,
    const VkAllocationCallbacks*                pAllocator);

Parameters

  • device is the logical device that destroys the pipeline.
  • pipeline is the handle of the pipeline to destroy.
  • pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Description

Valid Usage
  • All submitted commands that refer to pipeline must have completed execution
  • If VkAllocationCallbacks were provided when pipeline was created, a compatible set of callbacks must be provided here
  • If no VkAllocationCallbacks were provided when pipeline was created, pAllocator must be NULL
Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • If pipeline is not VK_NULL_HANDLE, pipeline must be a valid VkPipeline handle
  • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
  • If pipeline is a valid handle, it must have been created, allocated, or retrieved from device
Host Synchronization
  • Host access to pipeline must be externally synchronized

See Also

VkAllocationCallbacks, VkDevice, VkPipeline

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkDestroyPipeline

vkDestroyPipelineCache(3)

Name

vkDestroyPipelineCache - Destroy a pipeline cache object

C Specification

To destroy a pipeline cache, call:

void vkDestroyPipelineCache(
    VkDevice                                    device,
    VkPipelineCache                             pipelineCache,
    const VkAllocationCallbacks*                pAllocator);

Parameters

  • device is the logical device that destroys the pipeline cache object.
  • pipelineCache is the handle of the pipeline cache to destroy.
  • pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Description

Valid Usage
  • If VkAllocationCallbacks were provided when pipelineCache was created, a compatible set of callbacks must be provided here
  • If no VkAllocationCallbacks were provided when pipelineCache was created, pAllocator must be NULL
Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • If pipelineCache is not VK_NULL_HANDLE, pipelineCache must be a valid VkPipelineCache handle
  • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
  • If pipelineCache is a valid handle, it must have been created, allocated, or retrieved from device
Host Synchronization
  • Host access to pipelineCache must be externally synchronized

See Also

VkAllocationCallbacks, VkDevice, VkPipelineCache

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkDestroyPipelineCache

vkDestroyPipelineLayout(3)

Name

vkDestroyPipelineLayout - Destroy a pipeline layout object

C Specification

To destroy a pipeline layout, call:

void vkDestroyPipelineLayout(
    VkDevice                                    device,
    VkPipelineLayout                            pipelineLayout,
    const VkAllocationCallbacks*                pAllocator);

Parameters

  • device is the logical device that destroys the pipeline layout.
  • pipelineLayout is the pipeline layout to destroy.
  • pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Description

Valid Usage
  • If VkAllocationCallbacks were provided when pipelineLayout was created, a compatible set of callbacks must be provided here
  • If no VkAllocationCallbacks were provided when pipelineLayout was created, pAllocator must be NULL
Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • If pipelineLayout is not VK_NULL_HANDLE, pipelineLayout must be a valid VkPipelineLayout handle
  • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
  • If pipelineLayout is a valid handle, it must have been created, allocated, or retrieved from device
Host Synchronization
  • Host access to pipelineLayout must be externally synchronized

See Also

VkAllocationCallbacks, VkDevice, VkPipelineLayout

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkDestroyPipelineLayout

vkDestroyQueryPool(3)

Name

vkDestroyQueryPool - Destroy a query pool object

C Specification

To destroy a query pool, call:

void vkDestroyQueryPool(
    VkDevice                                    device,
    VkQueryPool                                 queryPool,
    const VkAllocationCallbacks*                pAllocator);

Parameters

  • device is the logical device that destroys the query pool.
  • queryPool is the query pool to destroy.
  • pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Description

Valid Usage
  • All submitted commands that refer to queryPool must have completed execution
  • If VkAllocationCallbacks were provided when queryPool was created, a compatible set of callbacks must be provided here
  • If no VkAllocationCallbacks were provided when queryPool was created, pAllocator must be NULL
Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • If queryPool is not VK_NULL_HANDLE, queryPool must be a valid VkQueryPool handle
  • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
  • If queryPool is a valid handle, it must have been created, allocated, or retrieved from device
Host Synchronization
  • Host access to queryPool must be externally synchronized

See Also

VkAllocationCallbacks, VkDevice, VkQueryPool

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkDestroyQueryPool

vkDestroyRenderPass(3)

Name

vkDestroyRenderPass - Destroy a render pass object

C Specification

To destroy a render pass, call:

void vkDestroyRenderPass(
    VkDevice                                    device,
    VkRenderPass                                renderPass,
    const VkAllocationCallbacks*                pAllocator);

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 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

See Also

VkAllocationCallbacks, VkDevice, VkRenderPass

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkDestroyRenderPass

vkDestroySampler(3)

Name

vkDestroySampler - Destroy a sampler object

C Specification

To destroy a sampler, call:

void vkDestroySampler(
    VkDevice                                    device,
    VkSampler                                   sampler,
    const VkAllocationCallbacks*                pAllocator);

Parameters

  • device is the logical device that destroys the sampler.
  • sampler is the sampler to destroy.
  • pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Description

Valid Usage
  • All submitted commands that refer to sampler must have completed execution
  • If VkAllocationCallbacks were provided when sampler was created, a compatible set of callbacks must be provided here
  • If no VkAllocationCallbacks were provided when sampler was created, pAllocator must be NULL
Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • If sampler is not VK_NULL_HANDLE, sampler must be a valid VkSampler handle
  • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
  • If sampler is a valid handle, it must have been created, allocated, or retrieved from device
Host Synchronization
  • Host access to sampler must be externally synchronized

See Also

VkAllocationCallbacks, VkDevice, VkSampler

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkDestroySampler

vkDestroySemaphore(3)

Name

vkDestroySemaphore - Destroy a semaphore object

C Specification

To destroy a semaphore, call:

void vkDestroySemaphore(
    VkDevice                                    device,
    VkSemaphore                                 semaphore,
    const VkAllocationCallbacks*                pAllocator);

Parameters

  • device is the logical device that destroys the semaphore.
  • semaphore is the handle of the semaphore to destroy.
  • pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Description

Valid Usage
  • All submitted batches that refer to semaphore must have completed execution
  • If VkAllocationCallbacks were provided when semaphore was created, a compatible set of callbacks must be provided here
  • If no VkAllocationCallbacks were provided when semaphore was created, pAllocator must be NULL
Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • If semaphore is not VK_NULL_HANDLE, semaphore must be a valid VkSemaphore handle
  • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
  • If semaphore is a valid handle, it must have been created, allocated, or retrieved from device
Host Synchronization
  • Host access to semaphore must be externally synchronized

See Also

VkAllocationCallbacks, VkDevice, VkSemaphore

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkDestroySemaphore

vkDestroyShaderModule(3)

Name

vkDestroyShaderModule - Destroy a shader module module

C Specification

To destroy a shader module, call:

void vkDestroyShaderModule(
    VkDevice                                    device,
    VkShaderModule                              shaderModule,
    const VkAllocationCallbacks*                pAllocator);

Parameters

  • device is the logical device that destroys the shader module.
  • shaderModule is the handle of the shader module to destroy.
  • pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Description

A shader module can be destroyed while pipelines created using its shaders are still in use.

Valid Usage
  • If VkAllocationCallbacks were provided when shaderModule was created, a compatible set of callbacks must be provided here
  • If no VkAllocationCallbacks were provided when shaderModule was created, pAllocator must be NULL
Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • If shaderModule is not VK_NULL_HANDLE, shaderModule must be a valid VkShaderModule handle
  • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
  • If shaderModule is a valid handle, it must have been created, allocated, or retrieved from device
Host Synchronization
  • Host access to shaderModule must be externally synchronized

See Also

VkAllocationCallbacks, VkDevice, VkShaderModule

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkDestroyShaderModule

vkDeviceWaitIdle(3)

Name

vkDeviceWaitIdle - Wait for a device to become idle

C Specification

To wait on the host for the completion of outstanding queue operations for all queues on a given logical device, call:

VkResult vkDeviceWaitIdle(
    VkDevice                                    device);

Parameters

  • device is the logical device to idle.

Description

vkDeviceWaitIdle is equivalent to calling vkQueueWaitIdle for all queues owned by device.

Valid Usage (Implicit)
  • device must be a valid VkDevice handle
Host Synchronization
  • Host access to all VkQueue objects created from device must be externally synchronized
Return Codes
Success
  • VK_SUCCESS
Failure
  • VK_ERROR_OUT_OF_HOST_MEMORY
  • VK_ERROR_OUT_OF_DEVICE_MEMORY
  • VK_ERROR_DEVICE_LOST

See Also

VkDevice

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkDeviceWaitIdle

vkEndCommandBuffer(3)

Name

vkEndCommandBuffer - Finish recording a command buffer

C Specification

To complete recording of a command buffer, call:

VkResult vkEndCommandBuffer(
    VkCommandBuffer                             commandBuffer);

Parameters

  • commandBuffer is the command buffer to complete recording.

Description

If there was an error during recording, the application will be notified by an unsuccessful return code returned by vkEndCommandBuffer. If the application wishes to further use the command buffer, the command buffer must be reset. The command buffer must have been in the recording state, and is moved to the executable state.

Valid Usage
  • commandBuffer must be in the recording state.
  • If commandBuffer is a primary command buffer, there must not be an active render pass instance
  • All queries made active during the recording of commandBuffer must have been made inactive
Valid Usage (Implicit)
  • commandBuffer must be a valid VkCommandBuffer handle
Host Synchronization
  • Host access to commandBuffer must be externally synchronized
  • Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized
Return Codes
Success
  • VK_SUCCESS
Failure
  • VK_ERROR_OUT_OF_HOST_MEMORY
  • VK_ERROR_OUT_OF_DEVICE_MEMORY

See Also

VkCommandBuffer

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkEndCommandBuffer

vkEnumerateDeviceExtensionProperties(3)

Name

vkEnumerateDeviceExtensionProperties - Returns properties of available physical device extensions

C Specification

To query the extensions available to a given physical device, call:

VkResult vkEnumerateDeviceExtensionProperties(
    VkPhysicalDevice                            physicalDevice,
    const char*                                 pLayerName,
    uint32_t*                                   pPropertyCount,
    VkExtensionProperties*                      pProperties);

Parameters

  • physicalDevice is the physical device that will be queried.
  • pLayerName is either NULL or a pointer to a null-terminated UTF-8 string naming the layer to retrieve extensions from.
  • pPropertyCount is a pointer to an integer related to the number of extension properties available or queried, and is treated in the same fashion as the vkEnumerateInstanceExtensionProperties::pPropertyCount parameter.
  • pProperties is either NULL or a pointer to an array of VkExtensionProperties structures.

Description

When pLayerName parameter is NULL, only extensions provided by the Vulkan implementation or by implicitly enabled layers are returned. When pLayerName is the name of a layer, the device extensions provided by that layer are returned.

Valid Usage (Implicit)
  • physicalDevice must be a valid VkPhysicalDevice handle
  • If pLayerName is not NULL, pLayerName must be a null-terminated UTF-8 string
  • pPropertyCount must be a pointer to a uint32_t value
  • If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a pointer to an array of pPropertyCount VkExtensionProperties structures
Return Codes
Success
  • VK_SUCCESS
  • VK_INCOMPLETE
Failure
  • VK_ERROR_OUT_OF_HOST_MEMORY
  • VK_ERROR_OUT_OF_DEVICE_MEMORY
  • VK_ERROR_LAYER_NOT_PRESENT

See Also

VkExtensionProperties, VkPhysicalDevice

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkEnumerateDeviceExtensionProperties

vkEnumerateDeviceLayerProperties(3)

Name

vkEnumerateDeviceLayerProperties - Returns properties of available physical device layers

C Specification

To enumerate device layers, call:

VkResult vkEnumerateDeviceLayerProperties(
    VkPhysicalDevice                            physicalDevice,
    uint32_t*                                   pPropertyCount,
    VkLayerProperties*                          pProperties);

Parameters

  • pPropertyCount is a pointer to an integer related to the number of layer properties available or queried.
  • pProperties is either NULL or a pointer to an array of VkLayerProperties structures.

Description

If pProperties is NULL, then the number of layer properties available is returned in pPropertyCount. Otherwise, pPropertyCount must point to a variable set by the user to the number of elements in the pProperties array, and on return the variable is overwritten with the number of structures actually written to pProperties. If pPropertyCount is less than the number of layer properties available, at most pPropertyCount structures will be written. If pPropertyCount is smaller than the number of layers available, VK_INCOMPLETE will be returned instead of VK_SUCCESS, to indicate that not all the available layer properties were returned.

The list of layers enumerated by vkEnumerateDeviceLayerProperties must be exactly the sequence of layers enabled for the instance. The members of VkLayerProperties for each enumerated layer must be the same as the properties when the layer was enumerated by vkEnumerateInstanceLayerProperties.

Valid Usage (Implicit)
  • physicalDevice must be a valid VkPhysicalDevice handle
  • pPropertyCount must be a pointer to a uint32_t value
  • If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a pointer to an array of pPropertyCount VkLayerProperties structures
Return Codes
Success
  • VK_SUCCESS
  • VK_INCOMPLETE
Failure
  • VK_ERROR_OUT_OF_HOST_MEMORY
  • VK_ERROR_OUT_OF_DEVICE_MEMORY

See Also

VkLayerProperties, VkPhysicalDevice

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkEnumerateDeviceLayerProperties

vkEnumerateInstanceExtensionProperties(3)

Name

vkEnumerateInstanceExtensionProperties - Returns up to requested number of global extension properties

C Specification

To query the available instance extensions, call:

VkResult vkEnumerateInstanceExtensionProperties(
    const char*                                 pLayerName,
    uint32_t*                                   pPropertyCount,
    VkExtensionProperties*                      pProperties);

Parameters

  • pLayerName is either NULL or a pointer to a null-terminated UTF-8 string naming the layer to retrieve extensions from.
  • pPropertyCount is a pointer to an integer related to the number of extension properties available or queried, as described below.
  • pProperties is either NULL or a pointer to an array of VkExtensionProperties structures.

Description

When pLayerName parameter is NULL, only extensions provided by the Vulkan implementation or by implicitly enabled layers are returned. When pLayerName is the name of a layer, the instance extensions provided by that layer are returned.

If pProperties is NULL, then the number of extensions properties available is returned in pPropertyCount. Otherwise, pPropertyCount must point to a variable set by the user to the number of elements in the pProperties array, and on return the variable is overwritten with the number of structures actually written to pProperties. If pPropertyCount is less than the number of extension properties available, at most pPropertyCount structures will be written. If pPropertyCount is smaller than the number of extensions available, VK_INCOMPLETE will be returned instead of VK_SUCCESS, to indicate that not all the available properties were returned.

Because the list of available layers may change externally between calls to vkEnumerateInstanceExtensionProperties, two calls may retrieve different results if a pLayerName is available in one call but not in another. The extensions supported by a layer may also change between two calls, e.g. if the layer implementation is replaced by a different version between those calls.

Valid Usage (Implicit)
  • If pLayerName is not NULL, pLayerName must be a null-terminated UTF-8 string
  • pPropertyCount must be a pointer to a uint32_t value
  • If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a pointer to an array of pPropertyCount VkExtensionProperties structures
Return Codes
Success
  • VK_SUCCESS
  • VK_INCOMPLETE
Failure
  • VK_ERROR_OUT_OF_HOST_MEMORY
  • VK_ERROR_OUT_OF_DEVICE_MEMORY
  • VK_ERROR_LAYER_NOT_PRESENT

See Also

VkExtensionProperties

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkEnumerateInstanceExtensionProperties

vkEnumerateInstanceLayerProperties(3)

Name

vkEnumerateInstanceLayerProperties - Returns up to requested number of global layer properties

C Specification

To query the available layers, call:

VkResult vkEnumerateInstanceLayerProperties(
    uint32_t*                                   pPropertyCount,
    VkLayerProperties*                          pProperties);

Parameters

  • pPropertyCount is a pointer to an integer related to the number of layer properties available or queried, as described below.
  • pProperties is either NULL or a pointer to an array of VkLayerProperties structures.

Description

If pProperties is NULL, then the number of layer properties available is returned in pPropertyCount. Otherwise, pPropertyCount must point to a variable set by the user to the number of elements in the pProperties array, and on return the variable is overwritten with the number of structures actually written to pProperties. If pPropertyCount is less than the number of layer properties available, at most pPropertyCount structures will be written. If pPropertyCount is smaller than the number of layers available, VK_INCOMPLETE will be returned instead of VK_SUCCESS, to indicate that not all the available layer properties were returned.

The list of available layers may change at any time due to actions outside of the Vulkan implementation, so two calls to vkEnumerateInstanceLayerProperties with the same parameters may return different results, or retrieve different pPropertyCount values or pProperties contents. Once an instance has been created, the layers enabled for that instance will continue to be enabled and valid for the lifetime of that instance, even if some of them become unavailable for future instances.

Valid Usage (Implicit)
  • pPropertyCount must be a pointer to a uint32_t value
  • If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a pointer to an array of pPropertyCount VkLayerProperties structures
Return Codes
Success
  • VK_SUCCESS
  • VK_INCOMPLETE
Failure
  • VK_ERROR_OUT_OF_HOST_MEMORY
  • VK_ERROR_OUT_OF_DEVICE_MEMORY

See Also

VkLayerProperties

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkEnumerateInstanceLayerProperties

vkEnumeratePhysicalDevices(3)

Name

vkEnumeratePhysicalDevices - Enumerates the physical devices accessible to a Vulkan instance

C Specification

To retrieve a list of physical device objects representing the physical devices installed in the system, call:

VkResult vkEnumeratePhysicalDevices(
    VkInstance                                  instance,
    uint32_t*                                   pPhysicalDeviceCount,
    VkPhysicalDevice*                           pPhysicalDevices);

Parameters

  • instance is a handle to a Vulkan instance previously created with vkCreateInstance.
  • pPhysicalDeviceCount is a pointer to an integer related to the number of physical devices available or queried, as described below.
  • pPhysicalDevices is either NULL or a pointer to an array of VkPhysicalDevice handles.

Description

If pPhysicalDevices is NULL, then the number of physical devices available is returned in pPhysicalDeviceCount. Otherwise, pPhysicalDeviceCount must point to a variable set by the user to the number of elements in the pPhysicalDevices array, and on return the variable is overwritten with the number of handles actually written to pPhysicalDevices. If pPhysicalDeviceCount is less than the number of physical devices available, at most pPhysicalDeviceCount structures will be written. If pPhysicalDeviceCount is smaller than the number of physical devices available, VK_INCOMPLETE will be returned instead of VK_SUCCESS, to indicate that not all the available physical devices were returned.

Valid Usage (Implicit)
  • instance must be a valid VkInstance handle
  • pPhysicalDeviceCount must be a pointer to a uint32_t value
  • If the value referenced by pPhysicalDeviceCount is not 0, and pPhysicalDevices is not NULL, pPhysicalDevices must be a pointer to an array of pPhysicalDeviceCount VkPhysicalDevice handles
Return Codes
Success
  • VK_SUCCESS
  • VK_INCOMPLETE
Failure
  • VK_ERROR_OUT_OF_HOST_MEMORY
  • VK_ERROR_OUT_OF_DEVICE_MEMORY
  • VK_ERROR_INITIALIZATION_FAILED

See Also

VkInstance, VkPhysicalDevice

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkEnumeratePhysicalDevices

vkFlushMappedMemoryRanges(3)

Name

vkFlushMappedMemoryRanges - Flush mapped memory ranges

C Specification

To flush ranges of non-coherent memory from the host caches, call:

VkResult vkFlushMappedMemoryRanges(
    VkDevice                                    device,
    uint32_t                                    memoryRangeCount,
    const VkMappedMemoryRange*                  pMemoryRanges);

Parameters

  • device is the logical device that owns the memory ranges.
  • memoryRangeCount is the length of the pMemoryRanges array.
  • pMemoryRanges is a pointer to an array of VkMappedMemoryRange structures describing the memory ranges to flush.

Description

vkFlushMappedMemoryRanges guarantees that host writes to the memory ranges described by pMemoryRanges can be made available to device access, via availability operations from the VK_ACCESS_HOST_WRITE_BIT access type.

Unmapping non-coherent memory does not implicitly flush the mapped memory, and host writes that have not been flushed may not ever be visible to the device. However, implementations must ensure that writes that have not been flushed do not become visible to any other memory.

Note

The above guarantee avoids a potential memory corruption in scenarios where host writes to a mapped memory object have not been flushed before the memory is unmapped (or freed), and the virtual address range is subsequently reused for a different mapping (or memory allocation).

Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • pMemoryRanges must be a pointer to an array of memoryRangeCount valid VkMappedMemoryRange structures
  • memoryRangeCount must be greater than 0
Return Codes
Success
  • VK_SUCCESS
Failure
  • VK_ERROR_OUT_OF_HOST_MEMORY
  • VK_ERROR_OUT_OF_DEVICE_MEMORY

See Also

VkDevice, VkMappedMemoryRange

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkFlushMappedMemoryRanges

vkFreeCommandBuffers(3)

Name

vkFreeCommandBuffers - Free command buffers

C Specification

To free command buffers, call:

void vkFreeCommandBuffers(
    VkDevice                                    device,
    VkCommandPool                               commandPool,
    uint32_t                                    commandBufferCount,
    const VkCommandBuffer*                      pCommandBuffers);

Parameters

  • device is the logical device that owns the command pool.
  • commandPool is the command pool from which the command buffers were allocated.
  • commandBufferCount is the length of the pCommandBuffers array.
  • pCommandBuffers is an array of handles of command buffers to free.

Description

Any primary command buffer that is in the recording or executable state and has any element of pCommandBuffers recorded into it, becomes invalid.

Valid Usage
  • All elements of pCommandBuffers must not be in the pending state
  • pCommandBuffers must be a pointer to an array of commandBufferCount VkCommandBuffer handles, each element of which must either be a valid handle or NULL
Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • commandPool must be a valid VkCommandPool handle
  • commandBufferCount must be greater than 0
  • commandPool must have been created, allocated, or retrieved from device
  • Each element of pCommandBuffers that is a valid handle must have been created, allocated, or retrieved from commandPool
Host Synchronization
  • Host access to commandPool must be externally synchronized
  • Host access to each member of pCommandBuffers must be externally synchronized

See Also

VkCommandBuffer, VkCommandPool, VkDevice

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkFreeCommandBuffers

vkFreeDescriptorSets(3)

Name

vkFreeDescriptorSets - Free one or more descriptor sets

C Specification

To free allocated descriptor sets, call:

VkResult vkFreeDescriptorSets(
    VkDevice                                    device,
    VkDescriptorPool                            descriptorPool,
    uint32_t                                    descriptorSetCount,
    const VkDescriptorSet*                      pDescriptorSets);

Parameters

  • device is the logical device that owns the descriptor pool.
  • descriptorPool is the descriptor pool from which the descriptor sets were allocated.
  • descriptorSetCount is the number of elements in the pDescriptorSets array.
  • pDescriptorSets is an array of handles to VkDescriptorSet objects.

Description

After a successful call to vkFreeDescriptorSets, all descriptor sets in pDescriptorSets are invalid.

Valid Usage
  • All submitted commands that refer to any element of pDescriptorSets must have completed execution
  • pDescriptorSets must be a pointer to an array of descriptorSetCount VkDescriptorSet handles, each element of which must either be a valid handle or VK_NULL_HANDLE
  • Each valid handle in pDescriptorSets must have been allocated from descriptorPool
  • descriptorPool must have been created with the VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT flag
Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • descriptorPool must be a valid VkDescriptorPool handle
  • descriptorSetCount must be greater than 0
  • descriptorPool must have been created, allocated, or retrieved from device
  • Each element of pDescriptorSets that is a valid handle must have been created, allocated, or retrieved from descriptorPool
Host Synchronization
  • Host access to descriptorPool must be externally synchronized
  • Host access to each member of pDescriptorSets must be externally synchronized
Return Codes
Success
  • VK_SUCCESS
Failure
  • VK_ERROR_OUT_OF_HOST_MEMORY
  • VK_ERROR_OUT_OF_DEVICE_MEMORY

See Also

VkDescriptorPool, VkDescriptorSet, VkDevice

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkFreeDescriptorSets

vkFreeMemory(3)

Name

vkFreeMemory - Free GPU memory

C Specification

To free a memory object, call:

void vkFreeMemory(
    VkDevice                                    device,
    VkDeviceMemory                              memory,
    const VkAllocationCallbacks*                pAllocator);

Parameters

  • device is the logical device that owns the memory.
  • memory is the VkDeviceMemory object to be freed.
  • pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Description

Before freeing a memory object, an application must ensure the memory object is no longer in use by the device—​for example by command buffers queued for execution. The memory can remain bound to images or buffers at the time the memory object is freed, but any further use of them (on host or device) for anything other than destroying those objects will result in undefined behavior. If there are still any bound images or buffers, the memory may not be immediately released by the implementation, but must be released by the time all bound images and buffers have been destroyed. Once memory is released, it is returned to the heap from which it was allocated.

How memory objects are bound to Images and Buffers is described in detail in the Resource Memory Association section.

If a memory object is mapped at the time it is freed, it is implicitly unmapped.

Note

As described below, host writes are not implicitly flushed when the memory object is unmapped, but the implementation must guarantee that writes that have not been flushed do not affect any other memory.

Valid Usage
  • All submitted commands that refer to memory (via images or buffers) must have completed execution
Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • If memory is not VK_NULL_HANDLE, memory must be a valid VkDeviceMemory handle
  • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
  • If memory is a valid handle, it must have been created, allocated, or retrieved from device
Host Synchronization
  • Host access to memory must be externally synchronized

See Also

VkAllocationCallbacks, VkDevice, VkDeviceMemory

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkFreeMemory

vkGetBufferMemoryRequirements(3)

Name

vkGetBufferMemoryRequirements - Returns the memory requirements for specified Vulkan object

C Specification

To determine the memory requirements for a buffer resource, call:

void vkGetBufferMemoryRequirements(
    VkDevice                                    device,
    VkBuffer                                    buffer,
    VkMemoryRequirements*                       pMemoryRequirements);

Parameters

  • device is the logical device that owns the buffer.
  • buffer is the buffer to query.
  • pMemoryRequirements points to an instance of the VkMemoryRequirements structure in which the memory requirements of the buffer object are returned.

Description

Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • buffer must be a valid VkBuffer handle
  • pMemoryRequirements must be a pointer to a VkMemoryRequirements structure
  • buffer must have been created, allocated, or retrieved from device

See Also

VkBuffer, VkDevice, VkMemoryRequirements

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkGetBufferMemoryRequirements

vkGetDeviceMemoryCommitment(3)

Name

vkGetDeviceMemoryCommitment - Query the current commitment for a VkDeviceMemory

C Specification

To determine the amount of lazily-allocated memory that is currently committed for a memory object, call:

void vkGetDeviceMemoryCommitment(
    VkDevice                                    device,
    VkDeviceMemory                              memory,
    VkDeviceSize*                               pCommittedMemoryInBytes);

Parameters

  • device is the logical device that owns the memory.
  • memory is the memory object being queried.
  • pCommittedMemoryInBytes is a pointer to a VkDeviceSize value in which the number of bytes currently committed is returned, on success.

Description

The implementation may update the commitment at any time, and the value returned by this query may be out of date.

The implementation guarantees to allocate any committed memory from the heapIndex indicated by the memory type that the memory object was created with.

Valid Usage
  • memory must have been created with a memory type that reports VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT
Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • memory must be a valid VkDeviceMemory handle
  • pCommittedMemoryInBytes must be a pointer to a VkDeviceSize value
  • memory must have been created, allocated, or retrieved from device

See Also

VkDevice, VkDeviceMemory, VkDeviceSize

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkGetDeviceMemoryCommitment

vkGetDeviceProcAddr(3)

Name

vkGetDeviceProcAddr - Return a function pointer for a command

C Specification

In order to support systems with multiple Vulkan implementations comprising heterogeneous collections of hardware and software, the function pointers returned by vkGetInstanceProcAddr may point to dispatch code, which calls a different real implementation for different VkDevice objects (and objects created from them). The overhead of this internal dispatch can be avoided by obtaining device-specific function pointers for any commands that use a device or device-child object as their dispatchable object. Such function pointers can be obtained with the command:

PFN_vkVoidFunction vkGetDeviceProcAddr(
    VkDevice                                    device,
    const char*                                 pName);

Parameters

The table below defines the various use cases for vkGetDeviceProcAddr and expected return value for each case.

Description

The returned function pointer is of type PFN_vkVoidFunction, and must be cast to the type of the command being queried.

Table 1. vkGetDeviceProcAddr behavior
device pName return value

NULL

*

undefined

invalid device

*

undefined

device

NULL

undefined

device

core Vulkan command

fp1

device

enabled extension commands

fp1

device

* (any pName not covered above)

NULL

1
The returned function pointer must only be called with a dispatchable object (the first parameter) that is device or a child of device. e.g. VkDevice, VkQueue, or VkCommandBuffer.
Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • pName must be a null-terminated UTF-8 string

See Also

PFN_vkVoidFunction, VkDevice

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkGetDeviceProcAddr

vkGetDeviceQueue(3)

Name

vkGetDeviceQueue - Get a queue handle from a device

C Specification

To retrieve a handle to a VkQueue object, call:

void vkGetDeviceQueue(
    VkDevice                                    device,
    uint32_t                                    queueFamilyIndex,
    uint32_t                                    queueIndex,
    VkQueue*                                    pQueue);

Parameters

  • device is the logical device that owns the queue.
  • queueFamilyIndex is the index of the queue family to which the queue belongs.
  • queueIndex is the index within this queue family of the queue to retrieve.
  • pQueue is a pointer to a VkQueue object that will be filled with the handle for the requested queue.

Description

Valid Usage
  • queueFamilyIndex must be one of the queue family indices specified when device was created, via the VkDeviceQueueCreateInfo structure
  • queueIndex must be less than the number of queues created for the specified queue family index when device was created, via the queueCount member of the VkDeviceQueueCreateInfo structure
Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • pQueue must be a pointer to a VkQueue handle

See Also

VkDevice, VkQueue

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkGetDeviceQueue

vkGetEventStatus(3)

Name

vkGetEventStatus - Retrieve the status of an event object

C Specification

To query the state of an event from the host, call:

VkResult vkGetEventStatus(
    VkDevice                                    device,
    VkEvent                                     event);

Parameters

  • device is the logical device that owns the event.
  • event is the handle of the event to query.

Description

Upon success, vkGetEventStatus returns the state of the event object with the following return codes:

Table 2. Event Object Status Codes
Status Meaning

VK_EVENT_SET

The event specified by event is signaled.

VK_EVENT_RESET

The event specified by event is unsignaled.

If a vkCmdSetEvent or vkCmdResetEvent command is in a command buffer that is in the pending state, then the value returned by this command may immediately be out of date.

The state of an event can be updated by the host. The state of the event is immediately changed, and subsequent calls to vkGetEventStatus will return the new state. If an event is already in the requested state, then updating it to the same state has no effect.

Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • event must be a valid VkEvent handle
  • event must have been created, allocated, or retrieved from device
Return Codes
Success
  • VK_EVENT_SET
  • VK_EVENT_RESET
Failure
  • VK_ERROR_OUT_OF_HOST_MEMORY
  • VK_ERROR_OUT_OF_DEVICE_MEMORY
  • VK_ERROR_DEVICE_LOST

See Also

VkDevice, VkEvent

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkGetEventStatus

vkGetFenceStatus(3)

Name

vkGetFenceStatus - Return the status of a fence

C Specification

To query the status of a fence from the host, call:

VkResult vkGetFenceStatus(
    VkDevice                                    device,
    VkFence                                     fence);

Parameters

  • device is the logical device that owns the fence.
  • fence is the handle of the fence to query.

Description

Upon success, vkGetFenceStatus returns the status of the fence object, with the following return codes:

Table 3. Fence Object Status Codes
Status Meaning

VK_SUCCESS

The fence specified by fence is signaled.

VK_NOT_READY

The fence specified by fence is unsignaled.

VK_DEVICE_LOST

The device has been lost. See Lost Device.

If a queue submission command is pending execution, then the value returned by this command may immediately be out of date.

If the device has been lost (see Lost Device), vkGetFenceStatus may return any of the above status codes. If the device has been lost and vkGetFenceStatus is called repeatedly, it will eventually return either VK_SUCCESS or VK_DEVICE_LOST.

Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • fence must be a valid VkFence handle
  • fence must have been created, allocated, or retrieved from device
Return Codes
Success
  • VK_SUCCESS
  • VK_NOT_READY
Failure
  • VK_ERROR_OUT_OF_HOST_MEMORY
  • VK_ERROR_OUT_OF_DEVICE_MEMORY
  • VK_ERROR_DEVICE_LOST

See Also

VkDevice, VkFence

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkGetFenceStatus

vkGetImageMemoryRequirements(3)

Name

vkGetImageMemoryRequirements - Returns the memory requirements for specified Vulkan object

C Specification

To determine the memory requirements for an image resource, call:

void vkGetImageMemoryRequirements(
    VkDevice                                    device,
    VkImage                                     image,
    VkMemoryRequirements*                       pMemoryRequirements);

Parameters

  • device is the logical device that owns the image.
  • image is the image to query.
  • pMemoryRequirements points to an instance of the VkMemoryRequirements structure in which the memory requirements of the image object are returned.

Description

Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • image must be a valid VkImage handle
  • pMemoryRequirements must be a pointer to a VkMemoryRequirements structure
  • image must have been created, allocated, or retrieved from device

See Also

VkDevice, VkImage, VkMemoryRequirements

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkGetImageMemoryRequirements

vkGetImageSparseMemoryRequirements(3)

Name

vkGetImageSparseMemoryRequirements - Query the memory requirements for a sparse image

C Specification

To query sparse memory requirements for an image, call:

void vkGetImageSparseMemoryRequirements(
    VkDevice                                    device,
    VkImage                                     image,
    uint32_t*                                   pSparseMemoryRequirementCount,
    VkSparseImageMemoryRequirements*            pSparseMemoryRequirements);

Parameters

  • device is the logical device that owns the image.
  • image is the VkImage object to get the memory requirements for.
  • pSparseMemoryRequirementCount is a pointer to an integer related to the number of sparse memory requirements available or queried, as described below.
  • pSparseMemoryRequirements is either NULL or a pointer to an array of VkSparseImageMemoryRequirements structures.

Description

If pSparseMemoryRequirements is NULL, then the number of sparse memory requirements available is returned in pSparseMemoryRequirementCount. Otherwise, pSparseMemoryRequirementCount must point to a variable set by the user to the number of elements in the pSparseMemoryRequirements array, and on return the variable is overwritten with the number of structures actually written to pSparseMemoryRequirements. If pSparseMemoryRequirementCount is less than the number of sparse memory requirements available, at most pSparseMemoryRequirementCount structures will be written.

If the image was not created with VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT then pSparseMemoryRequirementCount will be set to zero and pSparseMemoryRequirements will not be written to.

Note

It is legal for an implementation to report a larger value in VkMemoryRequirements::size than would be obtained by adding together memory sizes for all VkSparseImageMemoryRequirements returned by vkGetImageSparseMemoryRequirements. This may occur when the hardware requires unused padding in the address range describing the resource.

Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • image must be a valid VkImage handle
  • pSparseMemoryRequirementCount must be a pointer to a uint32_t value
  • If the value referenced by pSparseMemoryRequirementCount is not 0, and pSparseMemoryRequirements is not NULL, pSparseMemoryRequirements must be a pointer to an array of pSparseMemoryRequirementCount VkSparseImageMemoryRequirements structures
  • image must have been created, allocated, or retrieved from device

See Also

VkDevice, VkImage, VkSparseImageMemoryRequirements

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkGetImageSparseMemoryRequirements

vkGetImageSubresourceLayout(3)

Name

vkGetImageSubresourceLayout - Retrieve information about an image subresource

C Specification

To query the host access layout of an image subresource, for an image created with linear tiling, call:

void vkGetImageSubresourceLayout(
    VkDevice                                    device,
    VkImage                                     image,
    const VkImageSubresource*                   pSubresource,
    VkSubresourceLayout*                        pLayout);

Parameters

  • device is the logical device that owns the image.
  • image is the image whose layout is being queried.
  • pSubresource is a pointer to a VkImageSubresource structure selecting a specific image for the image subresource.
  • pLayout points to a VkSubresourceLayout structure in which the layout is returned.

Description

vkGetImageSubresourceLayout is invariant for the lifetime of a single image.

Valid Usage
  • image must have been created with tiling equal to VK_IMAGE_TILING_LINEAR
  • The aspectMask member of pSubresource must only have a single bit set
Valid Usage (Implicit)
  • device must be a valid VkDevice handle
  • image must be a valid VkImage handle
  • pSubresource must be a pointer to a valid VkImageSubresource structure
  • pLayout must be a pointer to a VkSubresourceLayout structure
  • image must have been created, allocated, or retrieved from device

See Also

VkDevice, VkImage, VkImageSubresource, VkSubresourceLayout

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkGetImageSubresourceLayout

vkGetInstanceProcAddr(3)

Name

vkGetInstanceProcAddr - Return a function pointer for a command

C Specification

Vulkan commands are not necessarily exposed statically on a platform. Function pointers for all Vulkan commands can be obtained with the command:

PFN_vkVoidFunction vkGetInstanceProcAddr(
    VkInstance                                  instance,
    const char*                                 pName);

Parameters

  • instance is the instance that the function pointer will be compatible with, or NULL for commands not dependent on any instance.
  • pName is the name of the command to obtain.

Description

vkGetInstanceProcAddr itself is obtained in a platform- and loader- specific manner. Typically, the loader library will export this command as a function symbol, so applications can link against the loader library, or load it dynamically and look up the symbol using platform-specific APIs. Loaders are encouraged to export function symbols for all other core Vulkan commands as well; if this is done, then applications that use only the core Vulkan commands have no need to use vkGetInstanceProcAddr.

The table below defines the various use cases for vkGetInstanceProcAddr and expected return value ("fp" is function pointer) for each case.

The returned function pointer is of type PFN_vkVoidFunction, and must be cast to the type of the command being queried.

Table 4. vkGetInstanceProcAddr behavior
instance pName return value

*

NULL

undefined

invalid instance

*

undefined

NULL

vkEnumerateInstanceExtensionProperties

fp

NULL

vkEnumerateInstanceLayerProperties

fp

NULL

vkCreateInstance

fp

NULL

* (any pName not covered above)

NULL

instance

core Vulkan command

fp1

instance

enabled instance extension commands for instance

fp1

instance

available device extension2 commands for instance

fp1

instance

* (any pName not covered above)

NULL

1
The returned function pointer must only be called with a dispatchable object (the first parameter) that is instance or a child of instance. e.g. VkInstance, VkPhysicalDevice, VkDevice, VkQueue, or VkCommandBuffer.
2
An “available extension” is an extension function supported by any of the loader, driver or layer.
Valid Usage (Implicit)
  • If instance is not NULL, instance must be a valid VkInstance handle
  • pName must be a null-terminated UTF-8 string

See Also

PFN_vkVoidFunction, VkInstance

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkGetInstanceProcAddr

vkGetPhysicalDeviceFeatures(3)

Name

vkGetPhysicalDeviceFeatures - Reports capabilities of a physical device

C Specification

To query supported features, call:

void vkGetPhysicalDeviceFeatures(
    VkPhysicalDevice                            physicalDevice,
    VkPhysicalDeviceFeatures*                   pFeatures);

Parameters

  • physicalDevice is the physical device from which to query the supported features.
  • pFeatures is a pointer to a VkPhysicalDeviceFeatures structure in which the physical device features are returned. For each feature, a value of VK_TRUE indicates that the feature is supported on this physical device, and VK_FALSE indicates that the feature is not supported.

Description

Valid Usage (Implicit)
  • physicalDevice must be a valid VkPhysicalDevice handle
  • pFeatures must be a pointer to a VkPhysicalDeviceFeatures structure

See Also

VkPhysicalDevice, VkPhysicalDeviceFeatures

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkGetPhysicalDeviceFeatures

vkGetPhysicalDeviceFormatProperties(3)

Name

vkGetPhysicalDeviceFormatProperties - Lists physical device’s format capabilities

C Specification

To query supported format features which are properties of the physical device, call:

void vkGetPhysicalDeviceFormatProperties(
    VkPhysicalDevice                            physicalDevice,
    VkFormat                                    format,
    VkFormatProperties*                         pFormatProperties);

Parameters

  • physicalDevice is the physical device from which to query the format properties.
  • format is the format whose properties are queried.
  • pFormatProperties is a pointer to a VkFormatProperties structure in which physical device properties for format are returned.

Description

Valid Usage (Implicit)
  • physicalDevice must be a valid VkPhysicalDevice handle
  • format must be a valid VkFormat value
  • pFormatProperties must be a pointer to a VkFormatProperties structure

See Also

VkFormat, VkFormatProperties, VkPhysicalDevice

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkGetPhysicalDeviceFormatProperties

vkGetPhysicalDeviceImageFormatProperties(3)

Name

vkGetPhysicalDeviceImageFormatProperties - Lists physical device’s image format capabilities

C Specification

To query additional capabilities specific to image types, call:

VkResult vkGetPhysicalDeviceImageFormatProperties(
    VkPhysicalDevice                            physicalDevice,
    VkFormat                                    format,
    VkImageType                                 type,
    VkImageTiling                               tiling,
    VkImageUsageFlags                           usage,
    VkImageCreateFlags                          flags,
    VkImageFormatProperties*                    pImageFormatProperties);

Parameters

Description

The format, type, tiling, usage, and flags parameters correspond to parameters that would be consumed by vkCreateImage (as members of VkImageCreateInfo).

If format is not a supported image format, or if the combination of format, type, tiling, usage, and flags is not supported for images, then vkGetPhysicalDeviceImageFormatProperties returns VK_ERROR_FORMAT_NOT_SUPPORTED.

The limitations on an image format that are reported by vkGetPhysicalDeviceImageFormatProperties have the following property: if usage1 and usage2 of type VkImageUsageFlags are such that the bits set in usage1 are a subset of the bits set in usage2, and flags1 and flags2 of type VkImageCreateFlags are such that the bits set in flags1 are a subset of the bits set in flags2, then the limitations for usage1 and flags1 must be no more strict than the limitations for usage2 and flags2, for all values of format, type, and tiling.

Valid Usage (Implicit)
  • physicalDevice must be a valid VkPhysicalDevice handle
  • format must be a valid VkFormat value
  • type must be a valid VkImageType value
  • tiling must be a valid VkImageTiling value
  • usage must be a valid combination of VkImageUsageFlagBits values
  • usage must not be 0
  • flags must be a valid combination of VkImageCreateFlagBits values
  • pImageFormatProperties must be a pointer to a VkImageFormatProperties structure
Return Codes
Success
  • VK_SUCCESS
Failure
  • VK_ERROR_OUT_OF_HOST_MEMORY
  • VK_ERROR_OUT_OF_DEVICE_MEMORY
  • VK_ERROR_FORMAT_NOT_SUPPORTED

See Also

VkFormat, VkImageCreateFlags, VkImageFormatProperties, VkImageTiling, VkImageType, VkImageUsageFlags, VkPhysicalDevice

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkGetPhysicalDeviceImageFormatProperties

vkGetPhysicalDeviceMemoryProperties(3)

Name

vkGetPhysicalDeviceMemoryProperties - Reports memory information for the specified physical device

C Specification

To query memory properties, call:

void vkGetPhysicalDeviceMemoryProperties(
    VkPhysicalDevice                            physicalDevice,
    VkPhysicalDeviceMemoryProperties*           pMemoryProperties);

Parameters

  • physicalDevice is the handle to the device to query.
  • pMemoryProperties points to an instance of VkPhysicalDeviceMemoryProperties structure in which the properties are returned.

Description

Valid Usage (Implicit)
  • physicalDevice must be a valid VkPhysicalDevice handle
  • pMemoryProperties must be a pointer to a VkPhysicalDeviceMemoryProperties structure

See Also

VkPhysicalDevice, VkPhysicalDeviceMemoryProperties

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkGetPhysicalDeviceMemoryProperties

vkGetPhysicalDeviceProperties(3)

Name

vkGetPhysicalDeviceProperties - Returns properties of a physical device

C Specification

To query general properties of physical devices once enumerated, call:

void vkGetPhysicalDeviceProperties(
    VkPhysicalDevice                            physicalDevice,
    VkPhysicalDeviceProperties*                 pProperties);

Parameters

  • physicalDevice is the handle to the physical device whose properties will be queried.
  • pProperties points to an instance of the VkPhysicalDeviceProperties structure, that will be filled with returned information.

Description

Valid Usage (Implicit)
  • physicalDevice must be a valid VkPhysicalDevice handle
  • pProperties must be a pointer to a VkPhysicalDeviceProperties structure

See Also

VkPhysicalDevice, VkPhysicalDeviceProperties

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkGetPhysicalDeviceProperties

vkGetPhysicalDeviceQueueFamilyProperties(3)

Name

vkGetPhysicalDeviceQueueFamilyProperties - Reports properties of the queues of the specified physical device

C Specification

To query properties of queues available on a physical device, call:

void vkGetPhysicalDeviceQueueFamilyProperties(
    VkPhysicalDevice                            physicalDevice,
    uint32_t*                                   pQueueFamilyPropertyCount,
    VkQueueFamilyProperties*                    pQueueFamilyProperties);

Parameters

  • physicalDevice is the handle to the physical device whose properties will be queried.
  • pQueueFamilyPropertyCount is a pointer to an integer related to the number of queue families available or queried, as described below.
  • pQueueFamilyProperties is either NULL or a pointer to an array of VkQueueFamilyProperties structures.

Description

If pQueueFamilyProperties is NULL, then the number of queue families available is returned in pQueueFamilyPropertyCount. Otherwise, pQueueFamilyPropertyCount must point to a variable set by the user to the number of elements in the pQueueFamilyProperties array, and on return the variable is overwritten with the number of structures actually written to pQueueFamilyProperties. If pQueueFamilyPropertyCount is less than the number of queue families available, at most pQueueFamilyPropertyCount structures will be written.

Valid Usage (Implicit)
  • physicalDevice must be a valid VkPhysicalDevice handle
  • pQueueFamilyPropertyCount must be a pointer to a uint32_t value
  • If the value referenced by pQueueFamilyPropertyCount is not 0, and pQueueFamilyProperties is not NULL, pQueueFamilyProperties must be a pointer to an array of pQueueFamilyPropertyCount VkQueueFamilyProperties structures

See Also

VkPhysicalDevice, VkQueueFamilyProperties

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkGetPhysicalDeviceQueueFamilyProperties

vkGetPhysicalDeviceSparseImageFormatProperties(3)

Name

vkGetPhysicalDeviceSparseImageFormatProperties - Retrieve properties of an image format applied to sparse images

C Specification

vkGetPhysicalDeviceSparseImageFormatProperties returns an array of VkSparseImageFormatProperties. Each element will describe properties for one set of image aspects that are bound simultaneously in the image. This is usually one element for each aspect in the image, but for interleaved depth/stencil images there is only one element describing the combined aspects.

void vkGetPhysicalDeviceSparseImageFormatProperties(
    VkPhysicalDevice                            physicalDevice,
    VkFormat                                    format,
    VkImageType                                 type,
    VkSampleCountFlagBits                       samples,
    VkImageUsageFlags                           usage,
    VkImageTiling                               tiling,
    uint32_t*                                   pPropertyCount,
    VkSparseImageFormatProperties*              pProperties);

Parameters

  • physicalDevice is the physical device from which to query the sparse image capabilities.
  • format is the image format.
  • type is the dimensionality of image.
  • samples is the number of samples per pixel as defined in VkSampleCountFlagBits.
  • usage is a bitmask describing the intended usage of the image.
  • tiling is the tiling arrangement of the data elements in memory.
  • pPropertyCount is a pointer to an integer related to the number of sparse format properties available or queried, as described below.
  • pProperties is either NULL or a pointer to an array of VkSparseImageFormatProperties structures.

Description

If pProperties is NULL, then the number of sparse format properties available is returned in pPropertyCount. Otherwise, pPropertyCount must point to a variable set by the user to the number of elements in the pProperties array, and on return the variable is overwritten with the number of structures actually written to pProperties. If pPropertyCount is less than the number of sparse format properties available, at most pPropertyCount structures will be written.

If VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT is not supported for the given arguments, pPropertyCount will be set to zero upon return, and no data will be written to pProperties.

Multiple aspects are returned for depth/stencil images that are implemented as separate planes by the implementation. The depth and stencil data planes each have unique VkSparseImageFormatProperties data.

Depth/stencil images with depth and stencil data interleaved into a single plane will return a single VkSparseImageFormatProperties structure with the aspectMask set to VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT.

Valid Usage
  • samples must be a bit value that is set in VkImageFormatProperties::sampleCounts returned by vkGetPhysicalDeviceImageFormatProperties with format, type, tiling, and usage equal to those in this command and flags equal to the value that is set in VkImageCreateInfo::flags when the image is created
Valid Usage (Implicit)
  • physicalDevice must be a valid VkPhysicalDevice handle
  • format must be a valid VkFormat value
  • type must be a valid VkImageType value
  • samples must be a valid VkSampleCountFlagBits value
  • usage must be a valid combination of VkImageUsageFlagBits values
  • usage must not be 0
  • tiling must be a valid VkImageTiling value
  • pPropertyCount must be a pointer to a uint32_t value
  • If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a pointer to an array of pPropertyCount VkSparseImageFormatProperties structures

See Also

VkFormat, VkImageTiling, VkImageType, VkImageUsageFlags, VkPhysicalDevice, VkSampleCountFlagBits, VkSparseImageFormatProperties

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#vkGetPhysicalDeviceSparseImageFormatProperties

vkGetPipelineCacheData(3)

Name

vkGetPipelineCacheData - Get the data store from a pipeline cache

C Specification

Data can be retrieved from a pipeline cache object using the command:

VkResult vkGetPipelineCacheData(
    VkDevice                                    device,
    VkPipelineCache                             pipelineCache,
    size_t*                                     pDataSize,
    void*                                       pData);

Parameters

  • device is the logical device that owns the pipeline cache.
  • pipelineCache is the pipeline cache to retrieve data from.
  • pDataSize is a pointer to a value related to the amount of data in the pipeline cache, as described below.
  • pData is either NULL or a pointer to a buffer.

Description

If pData is NULL, then the maximum size of the data that can be retrieved from the pipeline cache, in bytes, is returned in pDataSize. Otherwise, pDataSize must point to a variable set by the user to the size of the buffer, in bytes, pointed to by pData, and on return the variable is overwritten with the amount of data actually written to pData.

If pDataSize is less than the maximum size that can be retrieved by the pipeline cache, at most pDataSize bytes will be written to pData, and vkGetPipelineCacheData will return VK_INCOMPLETE. Any data written to pData is valid and can be provided as the pInitialData member of the VkPipelineCacheCreateInfo structure passed to vkCreatePipelineCache.

Two calls to vkGetPipelineCacheData with the same parameters must retrieve the same data unless a command that modifies the contents of the cache is called between them.

Applications can store the data retrieved from the pipeline cache, and use these data, possibly in a future run of the application, to populate new pipeline cache objects. The results of pipeline compiles, however, may depend on the vendor ID, device ID, driver version, and other details of the device. To enable applications to detect when previously retrieved data is incompatible with the device, the initial bytes written to pData must be a header consisting of the following members:

Table 5. Layout for pipeline cache header version VK_PIPELINE_CACHE_HEADER_VERSION_ONE
Offset Size Meaning

0

4

length in bytes of the entire pipeline cache header written as a stream of bytes, with the least significant byte first

4

4

a VkPipelineCacheHeaderVersion value written as a stream of bytes, with the least significant byte first

8

4

a vendor ID equal to VkPhysicalDeviceProperties::vendorID written as a stream of bytes, with the least significant byte first

12

4