Vulkan API Reference Pages

VK_SUCCESS
VK_TIMEOUT
VK_NOT_READY
VK_SUBOPTIMAL_KHR

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkAcquireNextImage2KHR

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_DEVICE_LOST
VK_ERROR_OUT_OF_DATE_KHR
VK_ERROR_SURFACE_LOST_KHR

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkAcquireNextImageKHR(3)

Name

vkAcquireNextImageKHR - Retrieve the index of the next available presentable image

C Specification

To acquire an available presentable image to use, and retrieve the index of that image, call:

VkResult vkAcquireNextImageKHR(
    VkDevice                                    device,
    VkSwapchainKHR                              swapchain,
    uint64_t                                    timeout,
    VkSemaphore                                 semaphore,
    VkFence                                     fence,
    uint32_t*                                   pImageIndex);

Parameters

device is the device associated with swapchain.
swapchain is the non-retired swapchain from which an image is being acquired.
timeout specifies how long the function waits, in nanoseconds, if no image is available.
semaphore is VK_NULL_HANDLE or a semaphore to signal.
fence is VK_NULL_HANDLE or a fence to signal.
pImageIndex is a pointer to a uint32_t that is set to the index of the next image to use (i.e. an index into the array of images returned by vkGetSwapchainImagesKHR).

Description

Valid Usage

swapchain must not be in the retired state
If semaphore is not VK_NULL_HANDLE it must be unsignaled
If semaphore is not VK_NULL_HANDLE it must not have any uncompleted signal or wait operations pending
If fence is not VK_NULL_HANDLE it must be unsignaled and must not be associated with any other queue command that has not yet completed execution on that queue
semaphore and fence must not both be equal to VK_NULL_HANDLE
If the number of currently acquired images is greater than the difference between the number of images in swapchain and the value of VkSurfaceCapabilitiesKHR::minImageCount as returned by a call to vkGetPhysicalDeviceSurfaceCapabilities2KHR with the surface used to create swapchain, timeout must not be UINT64_MAX

Valid Usage (Implicit)

device must be a valid VkDevice handle
swapchain must be a valid VkSwapchainKHR handle
If semaphore is not VK_NULL_HANDLE, semaphore must be a valid VkSemaphore handle
If fence is not VK_NULL_HANDLE, fence must be a valid VkFence handle
pImageIndex must be a valid pointer to a uint32_t value
If semaphore is a valid handle, it must have been created, allocated, or retrieved from device
If fence is a valid handle, it must have been created, allocated, or retrieved from device
Both of device, and swapchain that are valid handles must have been created, allocated, or retrieved from the same VkInstance

Host Synchronization

Host access to swapchain must be externally synchronized
Host access to semaphore must be externally synchronized
Host access to fence must be externally synchronized

Return Codes

VK_SUCCESS
VK_TIMEOUT
VK_NOT_READY
VK_SUBOPTIMAL_KHR

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkAcquireNextImageKHR

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_DEVICE_LOST
VK_ERROR_OUT_OF_DATE_KHR
VK_ERROR_SURFACE_LOST_KHR

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkAcquireXlibDisplayEXT(3)

Name

vkAcquireXlibDisplayEXT - Acquire access to a VkDisplayKHR using Xlib

C Specification

To acquire permission to directly access a display in Vulkan from an X11 server, call:

VkResult vkAcquireXlibDisplayEXT(
    VkPhysicalDevice                            physicalDevice,
    Display*                                    dpy,
    VkDisplayKHR                                display);

Parameters

physicalDevice The physical device the display is on.
dpy A connection to the X11 server that currently owns display.
display The display the caller wishes to control in Vulkan.

Description

All permissions necessary to control the display are granted to the Vulkan instance associated with physicalDevice until the display is released or the X11 connection specified by dpy is terminated. Permission to access the display may be temporarily revoked during periods when the X11 server from which control was acquired itself looses access to display. During such periods, operations which require access to the display must fail with an approriate error code. If the X11 server associated with dpy does not own display, or if permission to access it has already been acquired by another entity, the call must return the error code VK_ERROR_INITIALIZATION_FAILED.

Note

One example of when an X11 server loses access to a display is when it loses ownership of its virtual terminal.

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle
dpy must be a valid pointer to a Display value
display must be a valid VkDisplayKHR handle

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkAcquireXlibDisplayEXT

VK_ERROR_INITIALIZATION_FAILED

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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

vkAllocateCommandBuffers can be used to create multiple command buffers. If the creation of any of those command buffers fails, the implementation must destroy all successfully created command buffer objects from this command, set all entries of the pCommandBuffers array to NULL and return the error.

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 valid pointer to a valid VkCommandBufferAllocateInfo structure
pCommandBuffers must be a valid pointer to an array of pAllocateInfo::commandBufferCount VkCommandBuffer handles

Host Synchronization

Host access to pAllocateInfo::commandPool must be externally synchronized

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkAllocateCommandBuffers

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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.

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. For descriptor set bindings created with the VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT bit set, all descriptors in that binding that are dynamically used must have been populated before the descriptor set is consumed. For descriptor set bindings created without the VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT bit set, all descriptors in that binding that are statically used must have been populated before the descriptor set is consumed. Entries that are not 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 a call to vkAllocateDescriptorSets would cause the total number of descriptor sets allocated from the pool to exceed the value of VkDescriptorPoolCreateInfo::maxSets used to create pAllocateInfo→descriptorPool, then the allocation may fail due to lack of space in the descriptor pool. Similarly, the allocation may fail due to lack of space if the call to vkAllocateDescriptorSets would cause the number of any given descriptor type to exceed the sum of all the descriptorCount members of each element of VkDescriptorPoolCreateInfo::pPoolSizes with a member equal to that type. If the allocation fails due to no more space in the descriptor pool, and not because of system or device memory exhaustion, then VK_ERROR_OUT_OF_POOL_MEMORY must be returned.

vkAllocateDescriptorSets can be used to create multiple descriptor sets. If the creation of any of those descriptor sets fails, then the implementation must destroy all successfully created descriptor set objects from this command, set all entries of the pDescriptorSets array to VK_NULL_HANDLE and return the error.

Valid Usage (Implicit)

device must be a valid VkDevice handle
pAllocateInfo must be a valid pointer to a valid VkDescriptorSetAllocateInfo structure
pDescriptorSets must be a valid pointer to an array of pAllocateInfo::descriptorSetCount VkDescriptorSet handles

Host Synchronization

Host access to pAllocateInfo::descriptorPool must be externally synchronized

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkAllocateDescriptorSets

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_FRAGMENTED_POOL
VK_ERROR_OUT_OF_POOL_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkAllocateMemory(3)

Name

vkAllocateMemory - Allocate device 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 of 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 with the following constraint:

The contents of unprotected memory must not be a function of data protected memory objects, even if those memory objects were previously freed.

Note

The contents of memory allocated by one application should not be a function of data from protected memory objects of another application, even if those memory objects were previously freed.

The maximum number of valid memory allocations that can exist simultaneously within a VkDevice may be restricted by implementation- or platform-dependent limits. If a call to vkAllocateMemory would cause the total number of allocations to exceed these limits, such a call will fail and must return VK_ERROR_TOO_MANY_OBJECTS. The maxMemoryAllocationCount feature describes the number of allocations that can exist simultaneously before encountering these internal limits.

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 must be returned. This limit is advertised in VkPhysicalDeviceMaintenance3Properties::maxMemoryAllocationSize.

Valid Usage

pAllocateInfo->allocationSize must be less than or equal to VkPhysicalDeviceMemoryProperties::memoryHeaps[pAllocateInfo->memoryTypeIndex].size as returned by vkGetPhysicalDeviceMemoryProperties for the VkPhysicalDevice that device was created from.
pAllocateInfo->memoryTypeIndex must be less than VkPhysicalDeviceMemoryProperties::memoryTypeCount as returned by vkGetPhysicalDeviceMemoryProperties for the VkPhysicalDevice that device was created from.

Valid Usage (Implicit)

device must be a valid VkDevice handle
pAllocateInfo must be a valid pointer to a valid VkMemoryAllocateInfo structure
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pMemory must be a valid pointer to a VkDeviceMemory handle

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkAllocateMemory

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_TOO_MANY_OBJECTS
VK_ERROR_INVALID_EXTERNAL_HANDLE

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkBeginCommandBuffer

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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

vkBindBufferMemory is equivalent to passing the same parameters through VkBindBufferMemoryInfo to vkBindBufferMemory2.

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
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
If buffer requires a dedicated allocation(as reported by vkGetBufferMemoryRequirements2 in VkMemoryDedicatedRequirements::requiresDedicatedAllocation for buffer), memory must have been created with VkMemoryDedicatedAllocateInfo::buffer equal to buffer
If the VkMemoryAllocateInfo provided when memory was allocated included an instance of VkMemoryDedicatedAllocateInfo in its pNext chain, and VkMemoryDedicatedAllocateInfo::buffer was not VK_NULL_HANDLE, then buffer must equal VkMemoryDedicatedAllocateInfo::buffer, and memoryOffset must be zero.
If buffer was created with the VK_BUFFER_CREATE_PROTECTED_BIT bit set, the buffer must be bound to a memory object allocated with a memory type that reports VK_MEMORY_PROPERTY_PROTECTED_BIT
If buffer was created with the VK_BUFFER_CREATE_PROTECTED_BIT bit not set, the buffer must not be bound to a memory object created with a memory type that reports VK_MEMORY_PROPERTY_PROTECTED_BIT
If buffer was created with VkDedicatedAllocationBufferCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must have been created with VkDedicatedAllocationMemoryAllocateInfoNV::buffer equal to a buffer handle created with identical creation parameters to buffer and memoryOffset must be zero

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

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkBindBufferMemory

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkBindBufferMemory2(3)

Name

vkBindBufferMemory2 - Bind device memory to buffer objects

C Specification

To attach memory to buffer objects for one or more buffers at a time, call:

VkResult vkBindBufferMemory2(
    VkDevice                                    device,
    uint32_t                                    bindInfoCount,
    const VkBindBufferMemoryInfo*               pBindInfos);

or the equivalent command

VkResult vkBindBufferMemory2KHR(
    VkDevice                                    device,
    uint32_t                                    bindInfoCount,
    const VkBindBufferMemoryInfo*               pBindInfos);

Parameters

device is the logical device that owns the buffers and memory.
bindInfoCount is the number of elements in pBindInfos.
pBindInfos is a pointer to an array of structures of type VkBindBufferMemoryInfo, describing buffers and memory to bind.

Description

On some implementations, it may be more efficient to batch memory bindings into a single command.

Valid Usage (Implicit)

device must be a valid VkDevice handle
pBindInfos must be a valid pointer to an array of bindInfoCount valid VkBindBufferMemoryInfo structures
bindInfoCount must be greater than 0

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkBindBufferMemory2

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

Unresolved directive in apispec.txt - include::vkBindBufferMemory2KHR.txt[]

vkBindImageMemory(3)

Name

vkBindImageMemory - Bind device memory to an image object

C Specification

To attach memory to a VkImage object created without the VK_IMAGE_CREATE_DISJOINT_BIT set, 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

vkBindImageMemory is equivalent to passing the same parameters through VkBindImageMemoryInfo to vkBindImageMemory2.

Valid Usage

image must not have been created with the VK_IMAGE_CREATE_DISJOINT_BIT set.
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
If image requires a dedicated allocation (as reported by vkGetImageMemoryRequirements2 in VkMemoryDedicatedRequirements::requiresDedicatedAllocation for image), memory must have been created with VkMemoryDedicatedAllocateInfo::image equal to image
If the VkMemoryAllocateInfo provided when memory was allocated included an instance of VkMemoryDedicatedAllocateInfo in its pNext chain, and VkMemoryDedicatedAllocateInfo::image was not VK_NULL_HANDLE, then image must equal VkMemoryDedicatedAllocateInfo::image and memoryOffset must be zero.
If image was created with the VK_IMAGE_CREATE_PROTECTED_BIT bit set, the image must be bound to a memory object allocated with a memory type that reports VK_MEMORY_PROPERTY_PROTECTED_BIT
If image was created with the VK_IMAGE_CREATE_PROTECTED_BIT bit not set, the image must not be bound to a memory object created with a memory type that reports VK_MEMORY_PROPERTY_PROTECTED_BIT
If image was created with VkDedicatedAllocationImageCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must have been created with VkDedicatedAllocationMemoryAllocateInfoNV::image equal to an image handle created with identical creation parameters to image and memoryOffset must be zero

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

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkBindImageMemory

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkBindImageMemory2(3)

Name

vkBindImageMemory2 - Bind device memory to image objects

C Specification

To attach memory to image objects for one or more images at a time, call:

VkResult vkBindImageMemory2(
    VkDevice                                    device,
    uint32_t                                    bindInfoCount,
    const VkBindImageMemoryInfo*                pBindInfos);

or the equivalent command

VkResult vkBindImageMemory2KHR(
    VkDevice                                    device,
    uint32_t                                    bindInfoCount,
    const VkBindImageMemoryInfo*                pBindInfos);

Parameters

device is the logical device that owns the images and memory.
bindInfoCount is the number of elements in pBindInfos.
pBindInfos is a pointer to an array of structures of type VkBindImageMemoryInfo, describing images and memory to bind.

Description

On some implementations, it may be more efficient to batch memory bindings into a single command.

Valid Usage (Implicit)

device must be a valid VkDevice handle
pBindInfos must be a valid pointer to an array of bindInfoCount valid VkBindImageMemoryInfo structures
bindInfoCount must be greater than 0

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkBindImageMemory2

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

Unresolved directive in apispec.txt - include::vkBindImageMemory2KHR.txt[]

vkCmdBeginConditionalRenderingEXT(3)

Name

vkCmdBeginConditionalRenderingEXT - Define the beginning of a conditional rendering block

C Specification

To begin conditional rendering, call:

void vkCmdBeginConditionalRenderingEXT(
    VkCommandBuffer                             commandBuffer,
    const VkConditionalRenderingBeginInfoEXT*   pConditionalRenderingBegin);

Parameters

commandBuffer is the command buffer into which this command will be recorded.
pConditionalRenderingBegin is a pointer to an instance of the VkConditionalRenderingBeginInfoEXT structure specifying the parameters of conditional rendering.

Description

Valid Usage

Conditional rendering must not already be active

Valid Usage (Implicit)

commandBuffer must be a valid VkCommandBuffer handle
pConditionalRenderingBegin must be a valid pointer to a valid VkConditionalRenderingBeginInfoEXT structure
commandBuffer must be in the recording state
The VkCommandPool that commandBuffer was allocated from must support 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	Graphics Compute

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdBeginConditionalRenderingEXT

Primary
Secondary

Both

Graphics
Compute

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCmdBeginDebugUtilsLabelEXT(3)

Name

vkCmdBeginDebugUtilsLabelEXT - Open a command buffer debug label region

C Specification

A command buffer debug label region can be opened by calling:

void vkCmdBeginDebugUtilsLabelEXT(
    VkCommandBuffer                             commandBuffer,
    const VkDebugUtilsLabelEXT*                 pLabelInfo);

Parameters

commandBuffer is the command buffer into which the command is recorded.
pLabelInfo is a pointer to an instance of the VkDebugUtilsLabelEXT structure specifying the parameters of the label region to open.

Description

Valid Usage (Implicit)

commandBuffer must be a valid VkCommandBuffer handle
pLabelInfo must be a valid pointer to a valid VkDebugUtilsLabelEXT structure
commandBuffer must be in the recording state
The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations

Host Synchronization

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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdBeginDebugUtilsLabelEXT

Primary
Secondary

Both

Graphics
Compute

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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

queryPool must have been created with a queryType that differs from that of any queries that are active within commandBuffer
All queries used by the command 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
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
commandBuffer must not be a protected command buffer
If vkCmdBeginQuery is called within a render pass instance, the sum of query and the number of bits set in the current subpass’s view mask 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
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

Command Buffer Levels	Render Pass Scope	Supported Queue Types	Pipeline Type
Primary Secondary	Both	Graphics Compute

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdBeginQuery

Primary
Secondary

Both

Graphics
Compute

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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 specifies 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_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image 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 valid 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

Command Buffer Levels	Render Pass Scope	Supported Queue Types	Pipeline Type
Primary	Outside	Graphics	Graphics

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdBeginRenderPass

Primary

Outside

Graphics

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCmdBeginRenderPass2KHR(3)

Name

vkCmdBeginRenderPass2KHR - Begin a new render pass

C Specification

Alternatively to begin a render pass, call:

void vkCmdBeginRenderPass2KHR(
    VkCommandBuffer                             commandBuffer,
    const VkRenderPassBeginInfo*                pRenderPassBegin,
    const VkSubpassBeginInfoKHR*                pSubpassBeginInfo);

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.
pSubpassBeginInfo is a pointer to a VkSubpassBeginInfoKHR structure which contains information about the subpass which is about to begin rendering.

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_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image 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 valid pointer to a valid VkRenderPassBeginInfo structure
pSubpassBeginInfo must be a valid pointer to a valid VkSubpassBeginInfoKHR structure
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

Command Buffer Levels	Render Pass Scope	Supported Queue Types	Pipeline Type
Primary	Outside	Graphics	Graphics

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdBeginRenderPass2KHR

Primary

Outside

Graphics

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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 range 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 at the following times:

For descriptor bindings created with the VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT bit set, the contents may be consumed when the command buffer is submitted to a queue, or during shader execution of the resulting draws and dispatches, or any time in between. Otherwise,
during host execution of the command, or during shader execution of the resulting draws and dispatches, or any time in between.

Thus, the contents of a descriptor set binding must not be altered (overwritten by an update command, or freed) between the first point in time that it may be consumed, 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

Each 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
Each element of pDynamicOffsets which corresponds to a descriptor binding with type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC must be a multiple of VkPhysicalDeviceLimits::minUniformBufferOffsetAlignment
Each element of pDynamicOffsets which corresponds to a descriptor binding with type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC must be a multiple of VkPhysicalDeviceLimits::minStorageBufferOffsetAlignment
For each dynamic uniform or storage buffer binding in pDescriptorSets, the sum of the effective offset, as defined above, and the range of the binding must be less than or equal to the size of the buffer

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 valid pointer to an array of descriptorSetCount valid VkDescriptorSet handles
If dynamicOffsetCount is not 0, pDynamicOffsets must be a valid 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

Command Buffer Levels	Render Pass Scope	Supported Queue Types	Pipeline Type
Primary Secondary	Both	Graphics Compute

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdBindDescriptorSets

Primary
Secondary

Both

Graphics
Compute

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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

Command Buffer Levels	Render Pass Scope	Supported Queue Types	Pipeline Type
Primary Secondary	Both	Graphics

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdBindIndexBuffer

Primary
Secondary

Both

Graphics

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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 all drawing commands. 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
If VkPhysicalDeviceSampleLocationsPropertiesEXT::variableSampleLocations is VK_FALSE, and pipeline is a graphics pipeline created with a VkPipelineSampleLocationsStateCreateInfoEXT structure having its sampleLocationsEnable member set to VK_TRUE but without VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT enabled then the current render pass instance must have been begun by specifying a VkRenderPassSampleLocationsBeginInfoEXT structure whose pPostSubpassSampleLocations member contains an element with a subpassIndex matching the current subpass index and the sampleLocationsInfo member of that element must match the sampleLocationsInfo specified in VkPipelineSampleLocationsStateCreateInfoEXT when the pipeline was created

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

Command Buffer Levels	Render Pass Scope	Supported Queue Types	Pipeline Type
Primary Secondary	Both	Graphics Compute

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdBindPipeline

Primary
Secondary

Both

Graphics
Compute

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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 valid pointer to an array of bindingCount valid VkBuffer handles
pOffsets must be a valid 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

Command Buffer Levels	Render Pass Scope	Supported Queue Types	Pipeline Type
Primary Secondary	Both	Graphics

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdBindVertexBuffers

Primary
Secondary

Both

Graphics

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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:

u_base = i + ½

v_base = j + ½

w_base = k + ½
These base coordinates are then offset by the first destination offset:

u_offset = u_base - x_dst0

v_offset = v_base - y_dst0

w_offset = w_base - z_dst0

a_offset = a - baseArrayCount_dst
The scale is determined from the source and destination regions, and applied to the offset coordinates:

scale_u = (x_src1 - x_src0) / (x_dst1 - x_dst0)

scale_v = (y_src1 - y_src0) / (y_dst1 - y_dst0)

scale_w = (z_src1 - z_src0) / (z_dst1 - z_dst0)

u_scaled = u_offset * scale_u

v_scaled = v_offset * scale_v

w_scaled = w_offset * scale_w
Finally the source offset is added to the scaled coordinates, to determine the final unnormalized coordinates used to sample from srcImage:

u = u_scaled + x_src0

v = v_scaled + y_src0

w = w_scaled + z_src0

q = mipLevel

a = a_offset + baseArrayCount_src

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 each element of pRegions must be a region that is contained within srcImage
The destination region specified by each 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
The format features of srcImage must contain VK_FORMAT_FEATURE_BLIT_SRC_BIT.
srcImage must not use a format listed in html/vkspec.html#features-formats-requiring-sampler-ycbcr-conversion
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_SHARED_PRESENT_KHR, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL
The format features of dstImage must contain VK_FORMAT_FEATURE_BLIT_DST_BIT.
dstImage must not use a format listed in html/vkspec.html#features-formats-requiring-sampler-ycbcr-conversion
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_SHARED_PRESENT_KHR, 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, then the format features of srcImage must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT.
If filter is VK_FILTER_CUBIC_IMG, then the format features of srcImage must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG.
If filter is VK_FILTER_CUBIC_IMG, srcImage must have a VkImageType of VK_IMAGE_TYPE_2D
If commandBuffer is an unprotected command buffer, then srcImage must not be a protected image
If commandBuffer is an unprotected command buffer, then dstImage must not be a protected image
If commandBuffer is a protected command buffer, then dstImage must not be an unprotected image
The srcSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when srcImage was created
The dstSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when dstImage was created
The srcSubresource.baseArrayLayer + srcSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when srcImage was created
The dstSubresource.baseArrayLayer + dstSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when dstImage was created

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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdBlitImage

Primary
Secondary

Outside

Graphics

Transfer

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCmdClearAttachments(3)

Name

vkCmdClearAttachments - Clear regions within 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 element of pAttachments contains VK_IMAGE_ASPECT_COLOR_BIT, the colorAttachment member of that element must refer to a valid color attachment in the current subpass
The rectangular region specified by each element of pRects must be contained within the render area of the current render pass instance
The layers specified by each element of pRects must be contained within every attachment that pAttachments refers to
The layerCount member of each element of pRects must not be 0
If the render pass instance this is recorded in uses multiview, then baseArrayLayer must be zero and layerCount must be one.

Valid Usage (Implicit)

commandBuffer must be a valid VkCommandBuffer handle
pAttachments must be a valid pointer to an array of attachmentCount valid VkClearAttachment structures
pRects must be a valid 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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdClearAttachments

Primary
Secondary

Inside

Graphics

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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

The format features of image must contain VK_FORMAT_FEATURE_TRANSFER_DST_BIT.
image must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag
image must not use a format listed in html/vkspec.html#features-formats-requiring-sampler-ycbcr-conversion
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, VK_IMAGE_LAYOUT_GENERAL, or VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR
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
For each VkImageSubresourceRange element of pRanges, if the levelCount member is not VK_REMAINING_MIP_LEVELS, then baseMipLevel + levelCount must be less than 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
For each VkImageSubresourceRange element of pRanges, if the layerCount member is not VK_REMAINING_ARRAY_LAYERS, then baseArrayLayer + layerCount must be less than the arrayLayers specified in VkImageCreateInfo when image was created
image must not have a compressed or depth/stencil format
If commandBuffer is an unprotected command buffer, then image must not be a protected image
If commandBuffer is a protected command buffer, then image must not be an unprotected image

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 valid pointer to a valid VkClearColorValue union
pRanges must be a valid 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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdClearColorImage

Primary
Secondary

Outside

Graphics
Compute

Transfer

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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.

Description

Valid Usage

The format features of image must contain VK_FORMAT_FEATURE_TRANSFER_DST_BIT.
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
For each VkImageSubresourceRange element of pRanges, if the levelCount member is not VK_REMAINING_MIP_LEVELS, then baseMipLevel + levelCount must be less than 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
For each VkImageSubresourceRange element of pRanges, if the layerCount member is not VK_REMAINING_ARRAY_LAYERS, then baseArrayLayer + layerCount must be less than the arrayLayers specified in VkImageCreateInfo when image was created
image must have a depth/stencil format
If commandBuffer is an unprotected command buffer, then image must not be a protected image
If commandBuffer is a protected command buffer, then image must not be an unprotected image

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 valid pointer to a valid VkClearDepthStencilValue structure
pRanges must be a valid 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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdClearDepthStencilImage

Primary
Secondary

Outside

Graphics

Transfer

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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 srcOffset member of each element of pRegions must be less than the size of srcBuffer
The dstOffset member of each element of pRegions must be less than the size of dstBuffer
The size member of each element of pRegions must be less than or equal to the size of srcBuffer minus srcOffset
The size member of each 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
If commandBuffer is an unprotected command buffer, then srcBuffer must not be a protected buffer
If commandBuffer is an unprotected command buffer, then dstBuffer must not be a protected buffer
If commandBuffer is a protected command buffer, then dstBuffer must not be an unprotected buffer

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 valid pointer to an array of regionCount valid 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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdCopyBuffer

Primary
Secondary

Outside

Transfer
Graphics
Compute

Transfer

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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.

If the format of dstImage is a multi-planar image format), regions of each plane to be a target of a copy must be specified separately using the pRegions member of the VkBufferImageCopy structure. In this case, the aspectMask of imageSubresource must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT. For the purposes of vkCmdCopyBufferToImage, each plane of a multi-planar image is treated as having the format listed in html/vkspec.html#features-formats-compatible-planes for the plane identified by the aspectMask of the corresponding subresource. This applies both to VkFormat and to coordinates used in the copy, which correspond to texels in the plane rather than how these texels map to coordinates in the image as a whole.

Valid Usage

srcBuffer must be large enough to contain all buffer locations that are accessed according to Buffer and Image Addressing, for each element of pRegions
The image region specified by each element of pRegions must be a region that is contained within dstImage if the dstImage’s VkFormat is not a multi-planar format, and must be a region that is contained within the plane being copied to if the dstImage’s VkFormat is a multi-planar format
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
The format features of dstImage must contain VK_FORMAT_FEATURE_TRANSFER_DST_BIT.
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, VK_IMAGE_LAYOUT_GENERAL, or VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR
If commandBuffer is an unprotected command buffer, then srcBuffer must not be a protected buffer
If commandBuffer is an unprotected command buffer, then dstImage must not be a protected image
If commandBuffer is a protected command buffer, then dstImage must not be an unprotected image
The imageSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when dstImage was created
The imageSubresource.baseArrayLayer + imageSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when dstImage was created
The imageOffset and imageExtent members of each element of pRegions must respect the image transfer granularity requirements of commandBuffer’s command pool’s queue family, as described in VkQueueFamilyProperties

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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdCopyBufferToImage

Primary
Secondary

Outside

Transfer
Graphics
Compute

Transfer

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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.

If the format of srcImage or dstImage is a multi-planar image format, regions of each plane to be copied must be specified separately using the srcSubresource and dstSubresource members of the VkImageCopy structure. In this case, the aspectMask of the srcSubresource or dstSubresource that refers to the multi-planar image must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT. For the purposes of vkCmdCopyImage, each plane of a multi-planar image is treated as having the format listed in html/vkspec.html#features-formats-compatible-planes for the plane identified by the aspectMask of the corresponding subresource. This applies both to VkFormat and to coordinates used in the copy, which correspond to texels in the plane rather than how these texels map to coordinates in the image as a whole.

Note

For example, the VK_IMAGE_ASPECT_PLANE_1_BIT plane of a VK_FORMAT_G8_B8R8_2PLANE_420_UNORM image is compatible with an image of format VK_FORMAT_R8G8_UNORM and (less usefully) with the VK_IMAGE_ASPECT_PLANE_0_BIT plane of an image of format VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, as each texel is 2 bytes in size.

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.

“_422” image formats that are not multi-planar are treated as having a 2×1 compressed texel block for the purposes of these rules.

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 each element of pRegions must be a region that is contained within srcImage if the srcImage’s VkFormat is not a multi-planar format, and must be a region that is contained within the plane being copied if the srcImage’s VkFormat is a multi-planar format
The destination region specified by each element of pRegions must be a region that is contained within dstImage if the dstImage’s VkFormat is not a multi-planar format, and must be a region that is contained within the plane being copied to if the dstImage’s VkFormat is a multi-planar format
The union of all source regions, and the union of all destination regions, specified by the elements of pRegions, must not overlap in memory
The format features of srcImage must contain VK_FORMAT_FEATURE_TRANSFER_SRC_BIT.
srcImage must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag
If srcImage is non-sparse then the image or disjoint plane to be copied 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, VK_IMAGE_LAYOUT_GENERAL, or VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR
The format features of dstImage must contain VK_FORMAT_FEATURE_TRANSFER_DST_BIT.
dstImage must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag
If dstImage is non-sparse then the image or disjoint plane that is the destination of the copy 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, VK_IMAGE_LAYOUT_GENERAL, or VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR
If the VkFormat of each of srcImage and dstImage is not a multi-planar format, the VkFormat of each of srcImage and dstImage must be compatible, as defined below
In a copy to or from a plane of a multi-planar image, the VkFormat of the image and plane must be compatible according to the description of compatible planes for the plane being copied
When a copy is performed to or from an image with a multi-planar format, the aspectMask of the srcSubresource and/or dstSubresource that refers to the multi-planar image must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT (with VK_IMAGE_ASPECT_PLANE_2_BIT valid only for a VkFormat with three planes)
The sample count of srcImage and dstImage must match
If commandBuffer is an unprotected command buffer, then srcImage must not be a protected image
If commandBuffer is an unprotected command buffer, then dstImage must not be a protected image
If commandBuffer is a protected command buffer, then dstImage must not be an unprotected image
The srcSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when srcImage was created
The dstSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when dstImage was created
The srcSubresource.baseArrayLayer + srcSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when srcImage was created
The dstSubresource.baseArrayLayer + dstSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when dstImage was created
The srcOffset and extent members of each element of pRegions must respect the image transfer granularity requirements of commandBuffer’s command pool’s queue family, as described in VkQueueFamilyProperties
The dstOffset and extent members of each element of pRegions must respect the image transfer granularity requirements of commandBuffer’s command pool’s queue family, as described in VkQueueFamilyProperties

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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdCopyImage

Primary
Secondary

Outside

Transfer
Graphics
Compute

Transfer

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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.

If the VkFormat of srcImage is a multi-planar image format, regions of each plane to be a source of a copy must be specified separately using the pRegions member of the VkBufferImageCopy structure. In this case, the aspectMask of imageSubresource must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT. For the purposes of vkCmdCopyBufferToImage, each plane of a multi-planar image is treated as having the format listed in html/vkspec.html#features-formats-compatible-planes for the plane identified by the aspectMask of the corresponding subresource. This applies both to VkFormat and to coordinates used in the copy, which correspond to texels in the plane rather than how these texels map to coordinates in the image as a whole.

Valid Usage

The image region specified by each element of pRegions must be a region that is contained within srcImage if the srcImage’s VkFormat is not a multi-planar format, and must be a region that is contained within the plane being copied if the srcImage’s VkFormat is a multi-planar format
dstBuffer must be large enough to contain all buffer locations that are accessed according to Buffer and Image Addressing, for each element of pRegions
The union of all source regions, and the union of all destination regions, specified by the elements of pRegions, must not overlap in memory
The format features of srcImage must contain VK_FORMAT_FEATURE_TRANSFER_SRC_BIT.
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_SHARED_PRESENT_KHR, 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
If commandBuffer is an unprotected command buffer, then srcImage must not be a protected image
If commandBuffer is an unprotected command buffer, then dstBuffer must not be a protected buffer
If commandBuffer is a protected command buffer, then dstBuffer must not be an unprotected buffer
The imageSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when srcImage was created
The imageSubresource.baseArrayLayer + imageSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when srcImage was created
The imageOffset and imageExtent members of each element of pRegions must respect the image transfer granularity requirements of commandBuffer’s command pool’s queue family, as described in VkQueueFamilyProperties

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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdCopyImageToBuffer

Primary
Secondary

Outside

Transfer
Graphics
Compute

Transfer

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdCopyQueryPoolResults

Primary
Secondary

Outside

Graphics
Compute

Transfer

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCmdDebugMarkerBeginEXT(3)

Name

vkCmdDebugMarkerBeginEXT - Open a command buffer marker region

C Specification

A marker region can be opened by calling:

void vkCmdDebugMarkerBeginEXT(
    VkCommandBuffer                             commandBuffer,
    const VkDebugMarkerMarkerInfoEXT*           pMarkerInfo);

Parameters

commandBuffer is the command buffer into which the command is recorded.
pMarkerInfo is a pointer to an instance of the VkDebugMarkerMarkerInfoEXT structure specifying the parameters of the marker region to open.

Description

Valid Usage (Implicit)

commandBuffer must be a valid VkCommandBuffer handle
pMarkerInfo must be a valid pointer to a valid VkDebugMarkerMarkerInfoEXT structure
commandBuffer must be in the recording state
The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations

Host Synchronization

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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdDebugMarkerBeginEXT

Primary
Secondary

Both

Graphics
Compute

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCmdDebugMarkerEndEXT(3)

Name

vkCmdDebugMarkerEndEXT - Close a command buffer marker region

C Specification

A marker region can be closed by calling:

void vkCmdDebugMarkerEndEXT(
    VkCommandBuffer                             commandBuffer);

Parameters

commandBuffer is the command buffer into which the command is recorded.

Description

An application may open a marker region in one command buffer and close it in another, or otherwise split marker regions across multiple command buffers or multiple queue submissions. When viewed from the linear series of submissions to a single queue, the calls to vkCmdDebugMarkerBeginEXT and vkCmdDebugMarkerEndEXT must be matched and balanced.

Valid Usage

There must be an outstanding vkCmdDebugMarkerBeginEXT command prior to the vkCmdDebugMarkerEndEXT on the queue that commandBuffer is submitted to
If commandBuffer is a secondary command buffer, there must be an outstanding vkCmdDebugMarkerBeginEXT command recorded to commandBuffer that has not previously been ended by a call to vkCmdDebugMarkerEndEXT.

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, or compute operations

Host Synchronization

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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdDebugMarkerEndEXT

Primary
Secondary

Both

Graphics
Compute

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCmdDebugMarkerInsertEXT(3)

Name

vkCmdDebugMarkerInsertEXT - Insert a marker label into a command buffer

C Specification

A single marker label can be inserted into a command buffer by calling:

void vkCmdDebugMarkerInsertEXT(
    VkCommandBuffer                             commandBuffer,
    const VkDebugMarkerMarkerInfoEXT*           pMarkerInfo);

Parameters

commandBuffer is the command buffer into which the command is recorded.
pMarkerInfo is a pointer to an instance of the VkDebugMarkerMarkerInfoEXT structure specifying the parameters of the marker to insert.

Description

Valid Usage (Implicit)

commandBuffer must be a valid VkCommandBuffer handle
pMarkerInfo must be a valid pointer to a valid VkDebugMarkerMarkerInfoEXT structure
commandBuffer must be in the recording state
The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations

Host Synchronization

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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdDebugMarkerInsertEXT

Primary
Secondary

Both

Graphics
Compute

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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 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 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 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 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 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 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 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 bound descriptor set
If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object 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 bound descriptor set
If a VkImageView is sampled with with VK_FILTER_LINEAR as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT.
If a VkImageView is sampled with with VK_FILTER_CUBIC_IMG as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG.
Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY
If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_COMPUTE reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer.
If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_POINT_COMPUTE writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer.
If commandBuffer is a protected command buffer, and any pipeline stage other than the compute pipeline stage in the VkPipeline object bound to VK_PIPELINE_POINT_COMPUTE reads from any image or buffer, the image or buffer must not be a protected image or protected buffer.

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

Command Buffer Levels	Render Pass Scope	Supported Queue Types	Pipeline Type
Primary Secondary	Outside	Compute	Compute

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdDispatch

Primary
Secondary

Outside

Compute

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCmdDispatchBase(3)

Name

vkCmdDispatchBase - Dispatch compute work items

C Specification

To record a dispatch using non-zero base values for the components of WorkgroupId, call:

void vkCmdDispatchBase(
    VkCommandBuffer                             commandBuffer,
    uint32_t                                    baseGroupX,
    uint32_t                                    baseGroupY,
    uint32_t                                    baseGroupZ,
    uint32_t                                    groupCountX,
    uint32_t                                    groupCountY,
    uint32_t                                    groupCountZ);

or the equivalent command

void vkCmdDispatchBaseKHR(
    VkCommandBuffer                             commandBuffer,
    uint32_t                                    baseGroupX,
    uint32_t                                    baseGroupY,
    uint32_t                                    baseGroupZ,
    uint32_t                                    groupCountX,
    uint32_t                                    groupCountY,
    uint32_t                                    groupCountZ);

Parameters

commandBuffer is the command buffer into which the command will be recorded.
baseGroupX is the start value for the X component of WorkgroupId.
baseGroupY is the start value for the Y component of WorkgroupId.
baseGroupZ is the start value for the Z component of WorkgroupId.
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, with WorkgroupId values ranging from [baseGroup, baseGroup + groupCount) in each component. vkCmdDispatch is equivalent to vkCmdDispatchBase(0,0,0,groupCountX,groupCountY,groupCountZ).

Valid Usage

All valid usage rules from vkCmdDispatch apply
baseGroupX must be less than VkPhysicalDeviceLimits::maxComputeWorkGroupCount[0]
baseGroupX must be less than VkPhysicalDeviceLimits::maxComputeWorkGroupCount[1]
baseGroupZ must be less than VkPhysicalDeviceLimits::maxComputeWorkGroupCount[2]
groupCountX must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[0] minus baseGroupX
groupCountY must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[1] minus baseGroupY
groupCountZ must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[2] minus baseGroupZ
If any of baseGroupX, baseGroupY, or baseGroupZ are not zero, then the bound compute pipeline must have been created with the VK_PIPELINE_CREATE_DISPATCH_BASE flag.

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

Command Buffer Levels	Render Pass Scope	Supported Queue Types	Pipeline Type
Primary Secondary	Outside	Compute

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdDispatchBase

Primary
Secondary

Outside

Compute

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

Unresolved directive in apispec.txt - include::vkCmdDispatchBaseKHR.txt[]

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 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 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 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 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 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 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 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 bound descriptor set
If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object 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 bound descriptor set
If a VkImageView is sampled with with VK_FILTER_LINEAR as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT.
If a VkImageView is sampled with with VK_FILTER_CUBIC_IMG as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG.
Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY
If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_COMPUTE reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer.
If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_POINT_COMPUTE writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer.
If commandBuffer is a protected command buffer, and any pipeline stage other than the compute pipeline stage in the VkPipeline object bound to VK_PIPELINE_POINT_COMPUTE reads from any image or buffer, the image or buffer must not be a protected image or protected buffer.

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

Command Buffer Levels	Render Pass Scope	Supported Queue Types	Pipeline Type
Primary Secondary	Outside	Compute	Compute

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdDispatchIndirect

Primary
Secondary

Outside

Compute

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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 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 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 bound to VK_PIPELINE_BIND_POINT_GRAPHICS.
For each set n that is statically used by the VkPipeline 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 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 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 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 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 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 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 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 bound descriptor set
If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object 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 bound descriptor set
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.
If a VkImageView is sampled with VK_FILTER_LINEAR as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT.
If a VkImageView is sampled with VK_FILTER_CUBIC_IMG as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG.
Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY
If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex.
If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer.
If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer.
If commandBuffer is a protected command buffer, and any pipeline stage other than the framebuffer-space pipeline stages in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, the image or buffer must not be a protected image or protected buffer.
If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set

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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdDraw

Primary
Secondary

Inside

Graphics

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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 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 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 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 bound to VK_PIPELINE_BIND_POINT_GRAPHICS.
For each set n that is statically used by the VkPipeline 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 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 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 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 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 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 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 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 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 bound descriptor set
If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object 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 bound descriptor set
If a VkImageView is sampled with VK_FILTER_LINEAR as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT.
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.
If a VkImageView is sampled with VK_FILTER_CUBIC_IMG as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG.
Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY
If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex.
If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer.
If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer.
If commandBuffer is a protected command buffer, and any pipeline stage other than the framebuffer-space pipeline stages in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, the image or buffer must not be a protected image or protected buffer.
If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set

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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdDrawIndexed

Primary
Secondary

Inside

Graphics

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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
buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set
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 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 bound to VK_PIPELINE_BIND_POINT_GRAPHICS.
For each set n that is statically used by the VkPipeline 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 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 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 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 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 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 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 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 bound descriptor set
If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object 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 bound descriptor set
If a VkImageView is sampled with VK_FILTER_LINEAR as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT.
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.
If a VkImageView is sampled with VK_FILTER_CUBIC_IMG as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG.
Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY
If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex.
If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer.
If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer.
If commandBuffer is a protected command buffer, and any pipeline stage other than the framebuffer-space pipeline stages in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, the image or buffer must not be a protected image or protected buffer.
If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set

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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdDrawIndexedIndirect

Primary
Secondary

Inside

Graphics

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCmdDrawIndexedIndirectCountAMD(3)

Name

vkCmdDrawIndexedIndirectCountAMD - Perform an indexed indirect draw with the draw count sourced from a buffer

C Specification

To record an indexed draw call with a draw call count sourced from a buffer, call:

void vkCmdDrawIndexedIndirectCountAMD(
    VkCommandBuffer                             commandBuffer,
    VkBuffer                                    buffer,
    VkDeviceSize                                offset,
    VkBuffer                                    countBuffer,
    VkDeviceSize                                countBufferOffset,
    uint32_t                                    maxDrawCount,
    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.
countBuffer is the buffer containing the draw count.
countBufferOffset is the byte offset into countBuffer where the draw count begins.
maxDrawCount specifies the maximum number of draws that will be executed. The actual number of executed draw calls is the minimum of the count specified in countBuffer and maxDrawCount.
stride is the byte stride between successive sets of draw parameters.

Description

vkCmdDrawIndexedIndirectCountAMD behaves similarly to vkCmdDrawIndexedIndirect except that the draw count is read by the device from a buffer during execution. The command will read an unsigned 32-bit integer from countBuffer located at countBufferOffset and use this as the draw count.

Valid Usage

If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set
If countBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
countBuffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set
offset must be a multiple of 4
countBufferOffset must be a multiple of 4
stride must be a multiple of 4 and must be greater than or equal to sizeof(VkDrawIndexedIndirectCommand)
If maxDrawCount is greater than or equal to 1, (stride × (maxDrawCount - 1) + offset + sizeof(VkDrawIndexedIndirectCommand)) must be less than or equal to the size of buffer
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 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 bound to VK_PIPELINE_BIND_POINT_GRAPHICS.
For each set n that is statically used by the VkPipeline 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 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 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 bound to VK_PIPELINE_BIND_POINT_GRAPHICS requires any dynamic state, that state must have been set on the current command buffer
If count stored in countBuffer is equal to 1, (offset + sizeof(VkDrawIndexedIndirectCommand)) must be less than or equal to the size of buffer
If count stored in countBuffer 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 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 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 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 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 bound descriptor set
If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object 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 bound descriptor set
If a VkImageView is sampled with VK_FILTER_LINEAR as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT.
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.
If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex.
If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer.
If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer.
If commandBuffer is a protected command buffer, and any pipeline stage other than the framebuffer-space pipeline stages in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, the image or buffer must not be a protected image or protected buffer.
If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set

Valid Usage (Implicit)

commandBuffer must be a valid VkCommandBuffer handle
buffer must be a valid VkBuffer handle
countBuffer 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
Each of buffer, commandBuffer, and countBuffer 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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdDrawIndexedIndirectCountAMD

Primary
Secondary

Inside

Graphics

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCmdDrawIndexedIndirectCountKHR(3)

Name

vkCmdDrawIndexedIndirectCountKHR - Perform an indexed indirect draw with the draw count sourced from a buffer

C Specification

To record an indexed draw call with a draw call count sourced from a buffer, call:

void vkCmdDrawIndexedIndirectCountKHR(
    VkCommandBuffer                             commandBuffer,
    VkBuffer                                    buffer,
    VkDeviceSize                                offset,
    VkBuffer                                    countBuffer,
    VkDeviceSize                                countBufferOffset,
    uint32_t                                    maxDrawCount,
    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.
countBuffer is the buffer containing the draw count.
countBufferOffset is the byte offset into countBuffer where the draw count begins.
maxDrawCount specifies the maximum number of draws that will be executed. The actual number of executed draw calls is the minimum of the count specified in countBuffer and maxDrawCount.
stride is the byte stride between successive sets of draw parameters.

Description

vkCmdDrawIndexedIndirectCountKHR behaves similarly to vkCmdDrawIndexedIndirect except that the draw count is read by the device from a buffer during execution. The command will read an unsigned 32-bit integer from countBuffer located at countBufferOffset and use this as the draw count.

Valid Usage

If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set
If countBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
countBuffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set
offset must be a multiple of 4
countBufferOffset must be a multiple of 4
stride must be a multiple of 4 and must be greater than or equal to sizeof(VkDrawIndexedIndirectCommand)
If maxDrawCount is greater than or equal to 1, (stride × (maxDrawCount - 1) + offset + sizeof(VkDrawIndexedIndirectCommand)) must be less than or equal to the size of buffer
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 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 bound to VK_PIPELINE_BIND_POINT_GRAPHICS.
For each set n that is statically used by the VkPipeline 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 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 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 bound to VK_PIPELINE_BIND_POINT_GRAPHICS requires any dynamic state, that state must have been set on the current command buffer
If count stored in countBuffer is equal to 1, (offset + sizeof(VkDrawIndexedIndirectCommand)) must be less than or equal to the size of buffer
If count stored in countBuffer 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 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 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 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 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 bound descriptor set
If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object 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 bound descriptor set
If a VkImageView is sampled with VK_FILTER_LINEAR as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT.
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.
If a VkImageView is sampled with VK_FILTER_CUBIC_IMG as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG.
Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY
If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex.
If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer.
If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer.
If commandBuffer is a protected command buffer, and any pipeline stage other than the framebuffer-space pipeline stages in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, the image or buffer must not be a protected image or protected buffer.
If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set

Valid Usage (Implicit)

commandBuffer must be a valid VkCommandBuffer handle
buffer must be a valid VkBuffer handle
countBuffer 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
Each of buffer, commandBuffer, and countBuffer 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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdDrawIndexedIndirectCountKHR

Primary
Secondary

Inside

Graphics

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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
buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set
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 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 bound to VK_PIPELINE_BIND_POINT_GRAPHICS.
For each set n that is statically used by the VkPipeline 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 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 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 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 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 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 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 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 bound descriptor set
If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object 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 bound descriptor set
If a VkImageView is sampled with VK_FILTER_LINEAR as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT.
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.
If a VkImageView is sampled with VK_FILTER_CUBIC_IMG as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG.
Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY
If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex.
If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer.
If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer.
If commandBuffer is a protected command buffer, and any pipeline stage other than the framebuffer-space pipeline stages in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, the image or buffer must not be a protected image or protected buffer.
If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set

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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdDrawIndirect

Primary
Secondary

Inside

Graphics

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCmdDrawIndirectCountAMD(3)

Name

vkCmdDrawIndirectCountAMD - Perform an indirect draw with the draw count sourced from a buffer

C Specification

To record a non-indexed draw call with a draw call count sourced from a buffer, call:

void vkCmdDrawIndirectCountAMD(
    VkCommandBuffer                             commandBuffer,
    VkBuffer                                    buffer,
    VkDeviceSize                                offset,
    VkBuffer                                    countBuffer,
    VkDeviceSize                                countBufferOffset,
    uint32_t                                    maxDrawCount,
    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.
countBuffer is the buffer containing the draw count.
countBufferOffset is the byte offset into countBuffer where the draw count begins.
maxDrawCount specifies the maximum number of draws that will be executed. The actual number of executed draw calls is the minimum of the count specified in countBuffer and maxDrawCount.
stride is the byte stride between successive sets of draw parameters.

Description

vkCmdDrawIndirectCountAMD behaves similarly to vkCmdDrawIndirect except that the draw count is read by the device from a buffer during execution. The command will read an unsigned 32-bit integer from countBuffer located at countBufferOffset and use this as the draw count.

Valid Usage

If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set
If countBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
countBuffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set
offset must be a multiple of 4
countBufferOffset must be a multiple of 4
stride must be a multiple of 4 and must be greater than or equal to sizeof(VkDrawIndirectCommand)
If maxDrawCount is greater than or equal to 1, (stride × (maxDrawCount - 1) + offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer
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 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 bound to VK_PIPELINE_BIND_POINT_GRAPHICS.
For each set n that is statically used by the VkPipeline 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 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 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 bound to VK_PIPELINE_BIND_POINT_GRAPHICS requires any dynamic state, that state must have been set on the current command buffer
If the count stored in countBuffer is equal to 1, (offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer
If the count stored in countBuffer is greater than 1, (stride × (drawCount - 1) + offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer
The count stored in countBuffer 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 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 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 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 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 bound descriptor set
If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object 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 bound descriptor set
If a VkImageView is sampled with VK_FILTER_LINEAR as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT.
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.
If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex.
If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer.
If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer.
If commandBuffer is a protected command buffer, and any pipeline stage other than the framebuffer-space pipeline stages in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, the image or buffer must not be a protected image or protected buffer.
If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set

Valid Usage (Implicit)

commandBuffer must be a valid VkCommandBuffer handle
buffer must be a valid VkBuffer handle
countBuffer 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
Each of buffer, commandBuffer, and countBuffer 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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdDrawIndirectCountAMD

Primary
Secondary

Inside

Graphics

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCmdDrawIndirectCountKHR(3)

Name

vkCmdDrawIndirectCountKHR - Perform an indirect draw with the draw count sourced from a buffer

C Specification

To record a non-indexed draw call with a draw call count sourced from a buffer, call:

void vkCmdDrawIndirectCountKHR(
    VkCommandBuffer                             commandBuffer,
    VkBuffer                                    buffer,
    VkDeviceSize                                offset,
    VkBuffer                                    countBuffer,
    VkDeviceSize                                countBufferOffset,
    uint32_t                                    maxDrawCount,
    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.
countBuffer is the buffer containing the draw count.
countBufferOffset is the byte offset into countBuffer where the draw count begins.
maxDrawCount specifies the maximum number of draws that will be executed. The actual number of executed draw calls is the minimum of the count specified in countBuffer and maxDrawCount.
stride is the byte stride between successive sets of draw parameters.

Description

vkCmdDrawIndirectCountKHR behaves similarly to vkCmdDrawIndirect except that the draw count is read by the device from a buffer during execution. The command will read an unsigned 32-bit integer from countBuffer located at countBufferOffset and use this as the draw count.

Valid Usage

If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set
If countBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
countBuffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set
offset must be a multiple of 4
countBufferOffset must be a multiple of 4
stride must be a multiple of 4 and must be greater than or equal to sizeof(VkDrawIndirectCommand)
If maxDrawCount is greater than or equal to 1, (stride × (maxDrawCount - 1) + offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer
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 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 bound to VK_PIPELINE_BIND_POINT_GRAPHICS.
For each set n that is statically used by the VkPipeline 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 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 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 bound to VK_PIPELINE_BIND_POINT_GRAPHICS requires any dynamic state, that state must have been set on the current command buffer
If the count stored in countBuffer is equal to 1, (offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer
If the count stored in countBuffer is greater than 1, (stride × (drawCount - 1) + offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer
The count stored in countBuffer 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 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 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 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 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 bound descriptor set
If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object 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 bound descriptor set
If a VkImageView is sampled with VK_FILTER_LINEAR as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT.
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.
If a VkImageView is sampled with VK_FILTER_CUBIC_IMG as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG.
Any VkImageView being sampled with VK_FILTER_CUBIC_IMG as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY
If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex.
If commandBuffer is an unprotected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, that image or buffer must not be a protected image or protected buffer.
If commandBuffer is a protected command buffer, and any pipeline stage in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS writes to any image or buffer, that image or buffer must not be an unprotected image or unprotected buffer.
If commandBuffer is a protected command buffer, and any pipeline stage other than the framebuffer-space pipeline stages in the VkPipeline object bound to VK_PIPELINE_BIND_POINT_GRAPHICS reads from or writes to any image or buffer, the image or buffer must not be a protected image or protected buffer.
If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set

Valid Usage (Implicit)

commandBuffer must be a valid VkCommandBuffer handle
buffer must be a valid VkBuffer handle
countBuffer 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
Each of buffer, commandBuffer, and countBuffer 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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdDrawIndirectCountKHR

Primary
Secondary

Inside

Graphics

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCmdEndConditionalRenderingEXT(3)

Name

vkCmdEndConditionalRenderingEXT - Define the end of a conditional rendering block

C Specification

To end conditional rendering, call:

void vkCmdEndConditionalRenderingEXT(
    VkCommandBuffer                             commandBuffer);

Parameters

commandBuffer is the command buffer into which this command will be recorded.

Description

Once ended, conditional rendering becomes inactive.

Valid Usage

Conditional rendering must be active
If conditional rendering was made active outside of a render pass instance, it must not be ended inside a render pass instance
If conditional rendering was made active within a subpass it must be ended in the same subpass

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, 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	Graphics Compute

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdEndConditionalRenderingEXT

Primary
Secondary

Both

Graphics
Compute

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCmdEndDebugUtilsLabelEXT(3)

Name

vkCmdEndDebugUtilsLabelEXT - Close a command buffer label region

C Specification

A command buffer label region can be closed by calling:

void vkCmdEndDebugUtilsLabelEXT(
    VkCommandBuffer                             commandBuffer);

Parameters

commandBuffer is the command buffer into which the command is recorded.

Description

An application may open a debug label region in one command buffer and close it in another, or otherwise split debug label regions across multiple command buffers or multiple queue submissions. When viewed from the linear series of submissions to a single queue, the calls to vkCmdBeginDebugUtilsLabelEXT and vkCmdEndDebugUtilsLabelEXT must be matched and balanced.

Valid Usage

There must be an outstanding vkCmdBeginDebugUtilsLabelEXT command prior to the vkCmdEndDebugUtilsLabelEXT on the queue that commandBuffer is submitted to
If commandBuffer is a secondary command buffer, there must be an outstanding vkCmdBeginDebugUtilsLabelEXT command recorded to commandBuffer that has not previously been ended by a call to vkCmdEndDebugUtilsLabelEXT.

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, or compute operations

Host Synchronization

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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdEndDebugUtilsLabelEXT

Primary
Secondary

Both

Graphics
Compute

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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

All queries used by the command must be active
query must be less than the number of queries in queryPool
commandBuffer must not be a protected command buffer
If vkCmdEndQuery is called within a render pass instance, the sum of query and the number of bits set in the current subpass’s view mask 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
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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdEndQuery

Primary
Secondary

Both

Graphics
Compute

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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

Command Buffer Levels	Render Pass Scope	Supported Queue Types	Pipeline Type
Primary	Inside	Graphics	Graphics

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdEndRenderPass

Primary

Inside

Graphics

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCmdEndRenderPass2KHR(3)

Name

vkCmdEndRenderPass2KHR - 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 vkCmdEndRenderPass2KHR(
    VkCommandBuffer                             commandBuffer,
    const VkSubpassEndInfoKHR*                  pSubpassEndInfo);

Parameters

commandBuffer is the command buffer in which to end the current render pass instance.
pSubpassEndInfo is a pointer to a VkSubpassEndInfoKHR structure which contains information about how the previous subpass will be ended.

Description

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

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
pSubpassEndInfo must be a valid pointer to a valid VkSubpassEndInfoKHR structure
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

Command Buffer Levels	Render Pass Scope	Supported Queue Types	Pipeline Type
Primary	Inside	Graphics	Graphics

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdEndRenderPass2KHR

Primary

Inside

Graphics

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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
Each element of pCommandBuffers must have been allocated with a level of VK_COMMAND_BUFFER_LEVEL_SECONDARY
Each 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 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 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 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.
Each 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, each 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, each 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 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 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, each 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
Each element of pCommandBuffers must not begin any query types that are active in commandBuffer
If commandBuffer is a protected command buffer, then each element of pCommandBuffers must be a protected command buffer.
If commandBuffer is an unprotected command buffer, then each element of pCommandBuffers must be an unprotected command buffer.

Valid Usage (Implicit)

commandBuffer must be a valid VkCommandBuffer handle
pCommandBuffers must be a valid 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

Command Buffer Levels	Render Pass Scope	Supported Queue Types	Pipeline Type
Primary	Both	Transfer Graphics Compute

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdExecuteCommands

Primary

Both

Transfer
Graphics
Compute

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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
If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object
If commandBuffer is an unprotected command buffer, then dstBuffer must not be a protected buffer
If commandBuffer is a protected command buffer, then dstBuffer must not be an unprotected buffer

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 transfer, 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	Transfer Graphics Compute	Transfer

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdFillBuffer

Primary
Secondary

Outside

Transfer
Graphics
Compute

Transfer

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCmdInsertDebugUtilsLabelEXT(3)

Name

vkCmdInsertDebugUtilsLabelEXT - Insert a label into a command buffer

C Specification

A single debug label can be inserted into a command buffer by calling:

void vkCmdInsertDebugUtilsLabelEXT(
    VkCommandBuffer                             commandBuffer,
    const VkDebugUtilsLabelEXT*                 pLabelInfo);

Parameters

commandBuffer is the command buffer into which the command is recorded.
pInfo is a pointer to an instance of the VkDebugUtilsLabelEXT structure specifying the parameters of the label to insert.

Description

Valid Usage (Implicit)

commandBuffer must be a valid VkCommandBuffer handle
pLabelInfo must be a valid pointer to a valid VkDebugUtilsLabelEXT structure
commandBuffer must be in the recording state
The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations

Host Synchronization

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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdInsertDebugUtilsLabelEXT

Primary
Secondary

Both

Graphics
Compute

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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

Command Buffer Levels	Render Pass Scope	Supported Queue Types	Pipeline Type
Primary	Inside	Graphics	Graphics

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdNextSubpass

Primary

Inside

Graphics

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCmdNextSubpass2KHR(3)

Name

vkCmdNextSubpass2KHR - 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 vkCmdNextSubpass2KHR(
    VkCommandBuffer                             commandBuffer,
    const VkSubpassBeginInfoKHR*                pSubpassBeginInfo,
    const VkSubpassEndInfoKHR*                  pSubpassEndInfo);

Parameters

commandBuffer is the command buffer in which to record the command.
pSubpassBeginInfo is a pointer to a VkSubpassBeginInfoKHR structure which contains information about the subpass which is about to begin rendering.
pSubpassEndInfo is a pointer to a VkSubpassEndInfoKHR structure which contains information about how the previous subpass will be ended.

Description

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

Valid Usage

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
pSubpassBeginInfo must be a valid pointer to a valid VkSubpassBeginInfoKHR structure
pSubpassEndInfo must be a valid pointer to a valid VkSubpassEndInfoKHR structure
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

Command Buffer Levels	Render Pass Scope	Supported Queue Types	Pipeline Type
Primary	Inside	Graphics	Graphics

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdNextSubpass2KHR

Primary

Inside

Graphics

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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 all commands that occur earlier in submission order. If vkCmdPipelineBarrier was recorded inside a render pass instance, the first synchronization scope includes only commands that occur earlier in submission order 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 all commands that occur later in submission order. If vkCmdPipelineBarrier was recorded inside a render pass instance, the second synchronization scope includes only commands that occur later in submission order 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 at least one VkSubpassDependency instance in VkRenderPassCreateInfo::pDependencies that expresses a dependency from the current subpass to itself, and for which srcStageMask contains a subset of the bit values in VkSubpassDependency::srcStageMask, dstStageMask contains a subset of the bit values in VkSubpassDependency::dstStageMask, and dependencyFlags is equal to VkSubpassDependency::dependencyFlags.
If vkCmdPipelineBarrier is called within a render pass instance, for each element of pMemoryBarriers and pImageMemoryBarriers, the render pass must have been defined with a VkSubpassDependency self-dependency for the current subpass with valid srcStageMask, dstStageMask, and dependencyFlags values such that Vk*Barrier::srcAccessMask contains a subset of the bit values in VkSubpassDependency::srcAccessMask and Vk*Barrier::dstAccessMask contains a subset of the bit values in VkSubpassDependency::dstAccessMask.
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.
Each element of pMemoryBarriers, pBufferMemoryBarriers and 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.
Each element of pMemoryBarriers, pBufferMemoryBarriers and 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.
If vkCmdPipelineBarrier is called outside of a render pass instance, dependencyFlags must not include VK_DEPENDENCY_VIEW_LOCAL_BIT

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 valid pointer to an array of memoryBarrierCount valid VkMemoryBarrier structures
If bufferMemoryBarrierCount is not 0, pBufferMemoryBarriers must be a valid pointer to an array of bufferMemoryBarrierCount valid VkBufferMemoryBarrier structures
If imageMemoryBarrierCount is not 0, pImageMemoryBarriers must be a valid 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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdPipelineBarrier

Primary
Secondary

Both

Transfer
Graphics
Compute

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCmdProcessCommandsNVX(3)

Name

vkCmdProcessCommandsNVX - Performs the generation of commands on the device

C Specification

The actual generation on the device is handled with:

void vkCmdProcessCommandsNVX(
    VkCommandBuffer                             commandBuffer,
    const VkCmdProcessCommandsInfoNVX*          pProcessCommandsInfo);

Parameters

commandBuffer is the primary command buffer in which the generation process takes space.
pProcessCommandsInfo is a pointer to an instance of the VkCmdProcessCommandsInfoNVX structure containing parameters affecting the processing of commands.

Description

Valid Usage (Implicit)

commandBuffer must be a valid VkCommandBuffer handle
pProcessCommandsInfo must be a valid pointer to a valid VkCmdProcessCommandsInfoNVX structure
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 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 Compute

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdProcessCommandsNVX

Primary
Secondary

Inside

Graphics
Compute

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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

For each byte in the range specified by offset and size and for each shader stage in stageFlags, there must be a push constant range in layout that includes that byte and that stage
For each byte in the range specified by offset and size and for each push constant range that overlaps that byte, stageFlags must include all stages in that push constant range’s VkPushConstantRange::stageFlags
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 valid 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

Command Buffer Levels	Render Pass Scope	Supported Queue Types	Pipeline Type
Primary Secondary	Both	Graphics Compute

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdPushConstants

Primary
Secondary

Both

Graphics
Compute

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCmdPushDescriptorSetKHR(3)

Name

vkCmdPushDescriptorSetKHR - Pushes descriptor updates into a command buffer

C Specification

In addition to allocating descriptor sets and binding them to a command buffer, an application can record descriptor updates into the command buffer.

To push descriptor updates into a command buffer, call:

void vkCmdPushDescriptorSetKHR(
    VkCommandBuffer                             commandBuffer,
    VkPipelineBindPoint                         pipelineBindPoint,
    VkPipelineLayout                            layout,
    uint32_t                                    set,
    uint32_t                                    descriptorWriteCount,
    const VkWriteDescriptorSet*                 pDescriptorWrites);

Parameters

commandBuffer is the command buffer that the descriptors will be recorded in.
pipelineBindPoint is a VkPipelineBindPoint indicating whether the descriptors will be used by graphics pipelines or compute pipelines. There is a separate set of push descriptor bindings for each of graphics and compute, so binding one does not disturb the other.
layout is a VkPipelineLayout object used to program the bindings.
set is the set number of the descriptor set in the pipeline layout that will be updated.
descriptorWriteCount is the number of elements in the pDescriptorWrites array.
pDescriptorWrites is a pointer to an array of VkWriteDescriptorSet structures describing the descriptors to be updated.

Description

Push descriptors are a small bank of descriptors whose storage is internally managed by the command buffer rather than being written into a descriptor set and later bound to a command buffer. Push descriptors allow for incremental updates of descriptors without managing the lifetime of descriptor sets.

When a command buffer begins recording, all push descriptors have undefined contents. Push descriptors can be updated incrementally and cause shaders to use the updated descriptors for subsequent rendering commands (either compute or graphics, according to the pipelineBindPoint) until the descriptor is overwritten, or else until the set is disturbed as described in Pipeline Layout Compatibility. When the set is disturbed or push descriptors with a different descriptor set layout are set, all push descriptors become invalid.

Valid descriptors must be pushed for all bindings that any shaders in a pipeline access, at the time that a draw or dispatch command is recorded to execute using that pipeline. This includes immutable sampler descriptors, which must be pushed before they are accessed by a pipeline. However, if none of the shaders in a pipeline statically use certain bindings in the push descriptor set, then those descriptors need not be valid.

Push descriptors do not use dynamic offsets. Instead, the corresponding non-dynamic descriptor types can be used and the offset member of VkDescriptorBufferInfo can be changed each time the descriptor is written.

Each element of pDescriptorWrites is interpreted as in VkWriteDescriptorSet, except the dstSet member is ignored.

To push an immutable sampler, use a VkWriteDescriptorSet with dstBinding and dstArrayElement selecting the immutable sampler’s binding. If the descriptor type is VK_DESCRIPTOR_TYPE_SAMPLER, the pImageInfo parameter is ignored and the immutable sampler is taken from the push descriptor set layout in the pipeline layout. If the descriptor type is VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, the sampler member of the pImageInfo parameter is ignored and the immutable sampler is taken from the push descriptor set layout in the pipeline layout.

Valid Usage

pipelineBindPoint must be supported by the commandBuffer’s parent VkCommandPool’s queue family
set must be less than VkPipelineLayoutCreateInfo::setLayoutCount provided when layout was created
set must be the unique set number in the pipeline layout that uses a descriptor set layout that was created with VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR

Valid Usage (Implicit)

commandBuffer must be a valid VkCommandBuffer handle
pipelineBindPoint must be a valid VkPipelineBindPoint value
layout must be a valid VkPipelineLayout handle
pDescriptorWrites must be a valid pointer to an array of descriptorWriteCount valid VkWriteDescriptorSet structures
commandBuffer must be in the recording state
The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations
descriptorWriteCount 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

Command Buffer Levels	Render Pass Scope	Supported Queue Types	Pipeline Type
Primary Secondary	Both	Graphics Compute

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdPushDescriptorSetKHR

Primary
Secondary

Both

Graphics
Compute

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCmdPushDescriptorSetWithTemplateKHR(3)

Name

vkCmdPushDescriptorSetWithTemplateKHR - Pushes descriptor updates into a command buffer using a descriptor update template

C Specification

It is also possible to use a descriptor update template to specify the push descriptors to update. To do so, call:

void vkCmdPushDescriptorSetWithTemplateKHR(
    VkCommandBuffer                             commandBuffer,
    VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
    VkPipelineLayout                            layout,
    uint32_t                                    set,
    const void*                                 pData);

Parameters

commandBuffer is the command buffer that the descriptors will be recorded in.
descriptorUpdateTemplate A descriptor update template which defines how to interpret the descriptor information in pData.
layout is a VkPipelineLayout object used to program the bindings. It must be compatible with the layout used to create the descriptorUpdateTemplate handle.
set is the set number of the descriptor set in the pipeline layout that will be updated. This must be the same number used to create the descriptorUpdateTemplate handle.
pData Points to memory which contains the descriptors for the templated update.

Description

Valid Usage

The pipelineBindPoint specified during the creation of the descriptor update template must be supported by the commandBuffer’s parent VkCommandPool’s queue family
pData must be a valid pointer to a memory that contains one or more valid instances of VkDescriptorImageInfo, VkDescriptorBufferInfo, or VkBufferView in a layout defined by descriptorUpdateTemplate when it was created with vkCreateDescriptorUpdateTemplateKHR

Valid Usage (Implicit)

commandBuffer must be a valid VkCommandBuffer handle
descriptorUpdateTemplate must be a valid VkDescriptorUpdateTemplate handle
layout must be a valid VkPipelineLayout handle
commandBuffer must be in the recording state
The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations
Each of commandBuffer, descriptorUpdateTemplate, 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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdPushDescriptorSetWithTemplateKHR

Primary
Secondary

Both

Graphics
Compute

API example

struct AppBufferView {
    VkBufferView bufferView;
    uint32_t     applicationRelatedInformation;
};

struct AppDataStructure
{
    VkDescriptorImageInfo  imageInfo;          // a single image info
    // ... some more application related data
};

const VkDescriptorUpdateTemplateEntry descriptorUpdateTemplateEntries[] =
{
    // binding to a single image descriptor
    {
        0,                                           // binding
        0,                                           // dstArrayElement
        1,                                           // descriptorCount
        VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,   // descriptorType
        offsetof(AppDataStructure, imageInfo),       // offset
        0                                            // stride is not required if descriptorCount is 1.
    }

};

// create a descriptor update template for descriptor set updates
const VkDescriptorUpdateTemplateCreateInfo createInfo =
{
    VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO,  // sType
    NULL,                                                          // pNext
    0,                                                             // flags
    1,                                                             // descriptorUpdateEntryCount
    descriptorUpdateTemplateEntries,                               // pDescriptorUpdateEntries
    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR,       // templateType
    0,                                                             // descriptorSetLayout, ignored by given templateType
    VK_PIPELINE_BIND_POINT_GRAPHICS,                               // pipelineBindPoint
    myPipelineLayout,                                              // pipelineLayout
    0,                                                             // set
};

VkDescriptorUpdateTemplate myDescriptorUpdateTemplate;
myResult = vkCreateDescriptorUpdateTemplate(
    myDevice,
    &createInfo,
    NULL,
    &myDescriptorUpdateTemplate);
}

AppDataStructure appData;
// fill appData here or cache it in your engine
vkCmdPushDescriptorSetWithTemplateKHR(myCmdBuffer, myDescriptorUpdateTemplate, myPipelineLayout, 0,&appData);

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCmdReserveSpaceForCommandsNVX(3)

Name

vkCmdReserveSpaceForCommandsNVX - Perform a reservation of command buffer space

C Specification

Command space for generated commands recorded into a secondary command buffer must be reserved by calling:

void vkCmdReserveSpaceForCommandsNVX(
    VkCommandBuffer                             commandBuffer,
    const VkCmdReserveSpaceForCommandsInfoNVX*  pReserveSpaceInfo);

Parameters

commandBuffer is the secondary command buffer in which the space for device-generated commands is reserved.
pProcessCommandsInfo is a pointer to an instance of the vkCmdReserveSpaceForCommandsNVX structure containing parameters affecting the reservation of command buffer space.

Description

Valid Usage

The provided commandBuffer must not have had a prior space reservation since its creation or the last reset.
The state of the commandBuffer must be legal to execute all commands within the sequence provided by the indirectCommandsLayout member of pProcessCommandsInfo.

Valid Usage (Implicit)

commandBuffer must be a valid VkCommandBuffer handle
pReserveSpaceInfo must be a valid pointer to a valid VkCmdReserveSpaceForCommandsInfoNVX structure
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 inside of a render pass instance
commandBuffer must be a secondary 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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdReserveSpaceForCommandsNVX

Secondary

Inside

Graphics
Compute

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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 all commands that occur earlier in submission order. 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
commandBuffer’s current device mask must include exactly one physical device.

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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdResetEvent

Primary
Secondary

Outside

Graphics
Compute

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdResetQueryPool

Primary
Secondary

Outside

Graphics
Compute

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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 each element of pRegions must be a region that is contained within srcImage
The destination region specified by each 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_SHARED_PRESENT_KHR, 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_SHARED_PRESENT_KHR, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL
The format features of dstImage must contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT.
srcImage and dstImage must have been created with the same image format
If commandBuffer is an unprotected command buffer, then srcImage must not be a protected image
If commandBuffer is an unprotected command buffer, then dstImage must not be a protected image
If commandBuffer is a protected command buffer, then dstImage must not be an unprotected image
The srcSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when srcImage was created
The dstSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when dstImage was created
The srcSubresource.baseArrayLayer + srcSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when srcImage was created
The dstSubresource.baseArrayLayer + dstSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when dstImage was created

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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdResolveImage

Primary
Secondary

Outside

Graphics

Transfer

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdSetBlendConstants

Primary
Secondary

Both

Graphics

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCmdSetCheckpointNV(3)

Name

vkCmdSetCheckpointNV - insert diagnostic checkpoint in command stream

C Specification

Device diagnostic checkpoints are inserted into the command stream by calling vkCmdSetCheckpointNV.

void vkCmdSetCheckpointNV(
    VkCommandBuffer                             commandBuffer,
    const void*                                 pCheckpointMarker);

Parameters

commandBuffer is the command buffer that will receive the marker
pCheckpointMarker is an opaque application-provided value that will be associated with the checkpoint.

Description

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, compute, or transfer operations

Host Synchronization

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

Command Properties

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdSetCheckpointNV

Primary
Secondary

Both

Graphics
Compute
Transfer

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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 (x_f, y_f, z_f) 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 z_f 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 = 2^e-n

If a triangle is rasterized using the VK_POLYGON_MODE_FILL_RECTANGLE_NV polygon mode, then this minimum resolvable difference may not be resolvable for samples outside of the triangle, where the depth is extrapolated.

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. Unless the html/vkspec.html#VK_EXT_depth_range_unrestricted extension is enabled, fragment depth values are clamped even when the depth buffer uses a floating-point representation.

Valid Usage

The 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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdSetDepthBias

Primary
Secondary

Both

Graphics

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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 z_a in the depth attachment at location (x_f,y_f) (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 bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_DEPTH_BOUNDS dynamic state enabled
Unless the html/vkspec.html#VK_EXT_depth_range_unrestricted extension is enabled minDepthBounds must be between 0.0 and 1.0, inclusive
Unless the html/vkspec.html#VK_EXT_depth_range_unrestricted extension is enabled 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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdSetDepthBounds

Primary
Secondary

Both

Graphics

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCmdSetDeviceMask(3)

Name

vkCmdSetDeviceMask - Modify device mask of a command buffer

C Specification

To update the current device mask of a command buffer, call:

void vkCmdSetDeviceMask(
    VkCommandBuffer                             commandBuffer,
    uint32_t                                    deviceMask);

or the equivalent command

void vkCmdSetDeviceMaskKHR(
    VkCommandBuffer                             commandBuffer,
    uint32_t                                    deviceMask);

Parameters

commandBuffer is command buffer whose current device mask is modified.
deviceMask is the new value of the current device mask.

Description

deviceMask is used to filter out subsequent commands from executing on all physical devices whose bit indices are not set in the mask.

Valid Usage

deviceMask must be a valid device mask value
deviceMask must not be zero
deviceMask must not include any set bits that were not in the VkDeviceGroupCommandBufferBeginInfo::deviceMask value when the command buffer began recording.
If vkCmdSetDeviceMask is called inside a render pass instance, deviceMask must not include any set bits that were not in the VkDeviceGroupRenderPassBeginInfo::deviceMask value when the render pass instance began recording.

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, compute, or transfer 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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdSetDeviceMask

Primary
Secondary

Both

Graphics
Compute
Transfer

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

Unresolved directive in apispec.txt - include::vkCmdSetDeviceMaskKHR.txt[]

vkCmdSetDiscardRectangleEXT(3)

Name

vkCmdSetDiscardRectangleEXT - Set discard rectangles dynamically

C Specification

If the pipeline state object was created with the VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT dynamic state enabled, the discard rectangles are dynamically set and changed with the command:

void vkCmdSetDiscardRectangleEXT(
    VkCommandBuffer                             commandBuffer,
    uint32_t                                    firstDiscardRectangle,
    uint32_t                                    discardRectangleCount,
    const VkRect2D*                             pDiscardRectangles);

Parameters

commandBuffer is the command buffer into which the command will be recorded.
firstDiscardRectangle is the index of the first discard rectangle whose state is updated by the command.
discardRectangleCount is the number of discard rectangles whose state are updated by the command.
pDiscardRectangles is a pointer to an array of VkRect2D structures specifying discard rectangles.

Description

The discard rectangle taken from element i of pDiscardRectangles replace the current state for the discard rectangle index firstDiscardRectangle + i, for i in [0, discardRectangleCount).

Valid Usage

The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT dynamic state enabled
The sum of firstDiscardRectangle and discardRectangleCount must be less than or equal to VkPhysicalDeviceDiscardRectanglePropertiesEXT::maxDiscardRectangles
The x and y member of offset in each VkRect2D element of pDiscardRectangles must be greater than or equal to 0
Evaluation of (offset.x + extent.width) in each VkRect2D element of pDiscardRectangles must not cause a signed integer addition overflow
Evaluation of (offset.y + extent.height) in each VkRect2D element of pDiscardRectangles must not cause a signed integer addition overflow

Valid Usage (Implicit)

commandBuffer must be a valid VkCommandBuffer handle
pDiscardRectangles must be a valid pointer to an array of discardRectangleCount VkRect2D structures
commandBuffer must be in the recording state
The VkCommandPool that commandBuffer was allocated from must support graphics operations
discardRectangleCount 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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdSetDiscardRectangleEXT

Primary
Secondary

Both

Graphics

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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 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
commandBuffer’s current device mask must include exactly one physical device.

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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdSetEvent

Primary
Secondary

Outside

Graphics
Compute

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdSetLineWidth

Primary
Secondary

Both

Graphics

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCmdSetSampleLocationsEXT(3)

Name

vkCmdSetSampleLocationsEXT - Set the dynamic sample locations state

C Specification

The custom sample locations used for rasterization when VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable is VK_TRUE are specified by the VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsInfo property of the bound graphics pipeline, if the pipeline was not created with VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT enabled.

Otherwise, the sample locations used for rasterization are set by calling vkCmdSetSampleLocationsEXT:

void vkCmdSetSampleLocationsEXT(
    VkCommandBuffer                             commandBuffer,
    const VkSampleLocationsInfoEXT*             pSampleLocationsInfo);

Parameters

commandBuffer is the command buffer into which the command will be recorded.
pSampleLocationsInfo is the sample locations state to set.

Description

Valid Usage

The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT dynamic state enabled
The sampleLocationsPerPixel member of pSampleLocationsInfo must equal the rasterizationSamples member of the VkPipelineMultisampleStateCreateInfo structure the bound graphics pipeline has been created with
If VkPhysicalDeviceSampleLocationsPropertiesEXT::variableSampleLocations is VK_FALSE then the current render pass must have been begun by specifying a VkRenderPassSampleLocationsBeginInfoEXT structure whose pPostSubpassSampleLocations member contains an element with a subpassIndex matching the current subpass index and the sampleLocationsInfo member of that element must match the sample locations state pointed to by pSampleLocationsInfo

Valid Usage (Implicit)

commandBuffer must be a valid VkCommandBuffer handle
pSampleLocationsInfo must be a valid pointer to a valid VkSampleLocationsInfoEXT structure
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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdSetSampleLocationsEXT

Primary
Secondary

Both

Graphics

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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 (x_f,y_f) 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 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 valid 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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdSetScissor

Primary
Secondary

Both

Graphics

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdSetStencilCompareMask

Primary
Secondary

Both

Graphics

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdSetStencilReference

Primary
Secondary

Both

Graphics

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdSetStencilWriteMask

Primary
Secondary

Both

Graphics

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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

Valid Usage (Implicit)

commandBuffer must be a valid VkCommandBuffer handle
pViewports must be a valid pointer to an array of viewportCount valid VkViewport structures
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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdSetViewport

Primary
Secondary

Both

Graphics

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCmdSetViewportWScalingNV(3)

Name

vkCmdSetViewportWScalingNV - Set the viewport W scaling on a command buffer

C Specification

If the bound pipeline state object was not created with the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic state enabled, viewport W scaling parameters are specified using the pViewportWScalings member of VkPipelineViewportWScalingStateCreateInfoNV in the pipeline state object. If the pipeline state object was created with the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic state enabled, the viewport transformation parameters are dynamically set and changed with the command:

void vkCmdSetViewportWScalingNV(
    VkCommandBuffer                             commandBuffer,
    uint32_t                                    firstViewport,
    uint32_t                                    viewportCount,
    const VkViewportWScalingNV*                 pViewportWScalings);

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.
pViewportWScalings is a pointer to an array of VkViewportWScalingNV structures specifying viewport parameters.

Description

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

Valid Usage

The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic state enabled
firstViewport must be less than VkPhysicalDeviceLimits::maxViewports
The sum of firstViewport and viewportCount must be between 1 and VkPhysicalDeviceLimits::maxViewports, inclusive

Valid Usage (Implicit)

commandBuffer must be a valid VkCommandBuffer handle
pViewportWScalings must be a valid pointer to an array of viewportCount VkViewportWScalingNV structures
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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdSetViewportWScalingNV

Primary
Secondary

Both

Graphics

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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.

Note

Buffer updates performed with vkCmdUpdateBuffer first copy the data into command buffer memory when the command is recorded (which requires additional storage and may incur an additional allocation), and then copy the data from the command buffer into dstBuffer when the command is executed on a device.

The additional cost of this functionality compared to buffer to buffer copies means it is only recommended for very small amounts of data, and is why it is limited to only 65536 bytes.

Applications can work around this by issuing multiple vkCmdUpdateBuffer commands to different ranges of the same buffer, but it is strongly recommended that they should not.

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
If commandBuffer is an unprotected command buffer, then dstBuffer must not be a protected buffer
If commandBuffer is a protected command buffer, then dstBuffer must not be an unprotected buffer

Valid Usage (Implicit)

commandBuffer must be a valid VkCommandBuffer handle
dstBuffer must be a valid VkBuffer handle
pData must be a valid 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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdUpdateBuffer

Primary
Secondary

Outside

Transfer
Graphics
Compute

Transfer

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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 on the same queue or the host, and subsequent commands. vkCmdWaitEvents must not be used to wait on event signal operations occuring on other queues.

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 occur earlier in submission order 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 all commands that occur later in submission order. The second synchronization scope is limited to operations on the pipeline stages determined by the destination stage mask specified by dstStageMask.

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.
Each 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.
Each 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.
commandBuffer’s current device mask must include exactly one physical device.

Valid Usage (Implicit)

commandBuffer must be a valid VkCommandBuffer handle
pEvents must be a valid 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 valid pointer to an array of memoryBarrierCount valid VkMemoryBarrier structures
If bufferMemoryBarrierCount is not 0, pBufferMemoryBarriers must be a valid pointer to an array of bufferMemoryBarrierCount valid VkBufferMemoryBarrier structures
If imageMemoryBarrierCount is not 0, pImageMemoryBarriers must be a valid 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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdWaitEvents

Primary
Secondary

Both

Graphics
Compute

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCmdWriteBufferMarkerAMD(3)

Name

vkCmdWriteBufferMarkerAMD - Execute a pipelined write of a marker value into a buffer

C Specification

To write a 32-bit marker value into a buffer as a pipelined operation, call:

void vkCmdWriteBufferMarkerAMD(
    VkCommandBuffer                             commandBuffer,
    VkPipelineStageFlagBits                     pipelineStage,
    VkBuffer                                    dstBuffer,
    VkDeviceSize                                dstOffset,
    uint32_t                                    marker);

Parameters

commandBuffer is the command buffer into which the command will be recorded.
pipelineStage is one of the VkPipelineStageFlagBits values, specifying the pipeline stage whose completion triggers the marker write.
dstBuffer is the buffer where the marker will be written to.
dstOffset is the byte offset into the buffer where the marker will be written to.
marker is the 32-bit value of the marker.

Description

The command will write the 32-bit marker value into the buffer only after all preceding commands have finished executing up to at least the specified pipeline stage. This includes the completion of other preceding vkCmdWriteBufferMarkerAMD commands so long as their specified pipeline stages occur either at the same time or earlier than this command’s specified pipelineStage.

While consecutive buffer marker writes with the same pipelineStage parameter are implicitly complete in submission order, memory and execution dependencies between buffer marker writes and other operations must still be explicitly ordered using synchronization commands. The access scope for buffer marker writes falls under the VK_ACCESS_TRANSFER_WRITE_BIT, and the pipeline stages for identifying the synchronization scope must include both pipelineStage and VK_PIPELINE_STAGE_TRANSFER_BIT.

Note

Similar to vkCmdWriteTimestamp, if an implementation is unable to write a marker at any specific pipeline stage, it may instead do so at any logically later stage.

Note

Implementations may only support a limited number of pipelined marker write operations in flight at a given time, thus excessive number of marker write operations may degrade command execution performance.

Valid Usage

dstOffset must be less than or equal to the size of dstBuffer minus 4.
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

Valid Usage (Implicit)

commandBuffer must be a valid VkCommandBuffer handle
pipelineStage must be a valid VkPipelineStageFlagBits value
dstBuffer must be a valid VkBuffer handle
commandBuffer must be in the recording state
The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations
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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdWriteBufferMarkerAMD

Primary
Secondary

Both

Transfer
Graphics
Compute

Transfer

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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.

Timestamps may only be meaningfully compared if they are written by commands submitted to the same queue.

Note

An example of such a comparison is determining the execution time of a sequence of commands.

If vkCmdWriteTimestamp is called while executing a render pass instance that has multiview enabled, the timestamp uses N consecutive query indices in the query pool (starting at query) where N is the number of bits set in the view mask of the subpass the command is executed in. The resulting query values are determined by an implementation-dependent choice of one of the following behaviors:

The first query is a timestamp value and (if more than one bit is set in the view mask) zero is written to the remaining queries. If two timestamps are written in the same subpass, the sum of the execution time of all views between those commands is the difference between the first query written by each command.
All N queries are timestamp values. If two timestamps are written in the same subpass, the sum of the execution time of all views between those commands is the sum of the difference between corresponding queries written by each command. The difference between corresponding queries may be the execution time of a single view.

In either case, the application can sum the differences between all N queries to determine the total execution time.

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
All queries used by the command must be unavailable
If vkCmdWriteTimestamp is called within a render pass instance, the sum of query and the number of bits set in the current subpass’s view mask must be less than or equal to the number of queries in queryPool

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

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCmdWriteTimestamp

Primary
Secondary

Both

Transfer
Graphics
Compute

Transfer

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCreateAndroidSurfaceKHR(3)

Name

vkCreateAndroidSurfaceKHR - Create a VkSurfaceKHR object for an Android native window

C Specification

To create a VkSurfaceKHR object for an Android native window, call:

VkResult vkCreateAndroidSurfaceKHR(
    VkInstance                                  instance,
    const VkAndroidSurfaceCreateInfoKHR*        pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkSurfaceKHR*                               pSurface);

Parameters

instance is the instance to associate the surface with.
pCreateInfo is a pointer to an instance of the VkAndroidSurfaceCreateInfoKHR structure containing parameters affecting the creation of the surface object.
pAllocator is the allocator used for host memory allocated for the surface object when there is no more specific allocator available (see Memory Allocation).
pSurface points to a VkSurfaceKHR handle in which the created surface object is returned.

Description

During the lifetime of a surface created using a particular ANativeWindow handle any attempts to create another surface for the same ANativeWindow and any attempts to connect to the same ANativeWindow through other platform mechanisms will fail.

Note

In particular, only one VkSurfaceKHR can exist at a time for a given window. Similarly, a native window cannot be used by both a VkSurfaceKHR and EGLSurface simultaneously.

If successful, vkCreateAndroidSurfaceKHR increments the ANativeWindow’s reference count, and vkDestroySurfaceKHR will decrement it.

On Android, when a swapchain’s imageExtent does not match the surface’s currentExtent, the presentable images will be scaled to the surface’s dimensions during presentation. minImageExtent is (1,1), and maxImageExtent is the maximum image size supported by the consumer. For the system compositor, currentExtent is the window size (i.e. the consumer’s preferred size).

Valid Usage (Implicit)

instance must be a valid VkInstance handle
pCreateInfo must be a valid pointer to a valid VkAndroidSurfaceCreateInfoKHR structure
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pSurface must be a valid pointer to a VkSurfaceKHR handle

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCreateAndroidSurfaceKHR

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_NATIVE_WINDOW_IN_USE_KHR

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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 valid pointer to a valid VkBufferCreateInfo structure
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pBuffer must be a valid pointer to a VkBuffer handle

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCreateBuffer

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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 valid pointer to a valid VkBufferViewCreateInfo structure
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pView must be a valid pointer to a VkBufferView handle

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCreateBufferView

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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 is a pointer to an instance of the VkCommandPoolCreateInfo structure specifying the state of the command pool object.
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

pCreateInfo::queueFamilyIndex must be the index of a queue family available in the logical device device.

Valid Usage (Implicit)

device must be a valid VkDevice handle
pCreateInfo must be a valid pointer to a valid VkCommandPoolCreateInfo structure
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pCommandPool must be a valid pointer to a VkCommandPool handle

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCreateCommandPool

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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.

editing-note

TODO (Jon) - Should we say something like “the i’th element of the pPipelines array is created based on the corresponding element of the pCreateInfos array”? Also for vkCreateGraphicsPipelines below.

Description

Valid Usage

If the flags member of any 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 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 valid pointer to an array of createInfoCount valid VkComputePipelineCreateInfo structures
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pPipelines must be a valid 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

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCreateComputePipelines

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_INVALID_SHADER_NV

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCreateDebugReportCallbackEXT(3)

Name

vkCreateDebugReportCallbackEXT - Create a debug report callback object

C Specification

Debug report callbacks give more detailed feedback on the application’s use of Vulkan when events of interest occur.

To register a debug report callback, an application uses vkCreateDebugReportCallbackEXT.

VkResult vkCreateDebugReportCallbackEXT(
    VkInstance                                  instance,
    const VkDebugReportCallbackCreateInfoEXT*   pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkDebugReportCallbackEXT*                   pCallback);

Parameters

instance the instance the callback will be logged on.
pCreateInfo points to a VkDebugReportCallbackCreateInfoEXT structure which defines the conditions under which this callback will be called.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.
pCallback is a pointer to record the VkDebugReportCallbackEXT object created.

Description

Valid Usage (Implicit)

instance must be a valid VkInstance handle
pCreateInfo must be a valid pointer to a valid VkDebugReportCallbackCreateInfoEXT structure
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pCallback must be a valid pointer to a VkDebugReportCallbackEXT handle

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCreateDebugReportCallbackEXT

VK_ERROR_OUT_OF_HOST_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCreateDebugUtilsMessengerEXT(3)

Name

vkCreateDebugUtilsMessengerEXT - Create a debug messenger object

C Specification

A debug messenger triggers a debug callback with a debug message when an event of interest occurs. To create a debug messenger which will trigger a debug callback, call:

VkResult vkCreateDebugUtilsMessengerEXT(
    VkInstance                                  instance,
    const VkDebugUtilsMessengerCreateInfoEXT*   pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkDebugUtilsMessengerEXT*                   pMessenger);

Parameters

instance the instance the messenger will be used with.
pCreateInfo points to a VkDebugUtilsMessengerCreateInfoEXT structure which contains the callback pointer as well as defines the conditions under which this messenger will trigger the callback.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.
pMessenger is a pointer to record the VkDebugUtilsMessengerEXT object created.

Description

Valid Usage (Implicit)

instance must be a valid VkInstance handle
pCreateInfo must be a valid pointer to a valid VkDebugUtilsMessengerCreateInfoEXT structure
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pMessenger must be a valid pointer to a VkDebugUtilsMessengerEXT handle

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCreateDebugUtilsMessengerEXT

VK_ERROR_OUT_OF_HOST_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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 valid pointer to a valid VkDescriptorPoolCreateInfo structure
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pDescriptorPool must be a valid pointer to a VkDescriptorPool handle

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCreateDescriptorPool

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_FRAGMENTATION_EXT

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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 valid pointer to a valid VkDescriptorSetLayoutCreateInfo structure
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pSetLayout must be a valid pointer to a VkDescriptorSetLayout handle

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCreateDescriptorSetLayout

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCreateDescriptorUpdateTemplate(3)

Name

vkCreateDescriptorUpdateTemplate - Create a new descriptor update template

C Specification

Updating a large VkDescriptorSet array can be an expensive operation since an application must specify one VkWriteDescriptorSet structure for each descriptor or descriptor array to update, each of which re-specifies the same state when updating the same descriptor in multiple descriptor sets. For cases when an application wishes to update the same set of descriptors in multiple descriptor sets allocated using the same VkDescriptorSetLayout, vkUpdateDescriptorSetWithTemplate can be used as a replacement for vkUpdateDescriptorSets.

VkDescriptorUpdateTemplate allows implementations to convert a set of descriptor update operations on a single descriptor set to an internal format that, in conjunction with vkUpdateDescriptorSetWithTemplate or vkCmdPushDescriptorSetWithTemplateKHR , can be more efficient compared to calling vkUpdateDescriptorSets or vkCmdPushDescriptorSetKHR . The descriptors themselves are not specified in the VkDescriptorUpdateTemplate, rather, offsets into an application provided pointer to host memory are specified, which are combined with a pointer passed to vkUpdateDescriptorSetWithTemplate or vkCmdPushDescriptorSetWithTemplateKHR . This allows large batches of updates to be executed without having to convert application data structures into a strictly-defined Vulkan data structure.

To create a descriptor update template, call:

VkResult vkCreateDescriptorUpdateTemplate(
    VkDevice                                    device,
    const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkDescriptorUpdateTemplate*                 pDescriptorUpdateTemplate);

or the equivalent command

VkResult vkCreateDescriptorUpdateTemplateKHR(
    VkDevice                                    device,
    const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkDescriptorUpdateTemplate*                 pDescriptorUpdateTemplate);

Parameters

device is the logical device that creates the descriptor update template.
pCreateInfo is a pointer to an instance of the VkDescriptorUpdateTemplateCreateInfo structure specifying the set of descriptors to update with a single call to vkCmdPushDescriptorSetWithTemplateKHR or vkUpdateDescriptorSetWithTemplate.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.
pDescriptorUpdateTemplate points to a VkDescriptorUpdateTemplate handle in which the resulting descriptor update template object is returned.

Description

Valid Usage (Implicit)

device must be a valid VkDevice handle
pCreateInfo must be a valid pointer to a valid VkDescriptorUpdateTemplateCreateInfo structure
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pDescriptorUpdateTemplate must be a valid pointer to a VkDescriptorUpdateTemplate handle

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCreateDescriptorUpdateTemplate

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

Unresolved directive in apispec.txt - include::vkCreateDescriptorUpdateTemplateKHR.txt[]

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

All required extensions for each extension in the VkDeviceCreateInfo::ppEnabledExtensionNames list must also be present in that list.

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle
pCreateInfo must be a valid pointer to a valid VkDeviceCreateInfo structure
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pDevice must be a valid pointer to a VkDevice handle

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCreateDevice

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

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCreateDisplayModeKHR(3)

Name

vkCreateDisplayModeKHR - Create a display mode

C Specification

Additional modes may also be created by calling:

VkResult vkCreateDisplayModeKHR(
    VkPhysicalDevice                            physicalDevice,
    VkDisplayKHR                                display,
    const VkDisplayModeCreateInfoKHR*           pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkDisplayModeKHR*                           pMode);

Parameters

physicalDevice is the physical device associated with display.
display is the display to create an additional mode for.
pCreateInfo is a VkDisplayModeCreateInfoKHR structure describing the new mode to create.
pAllocator is the allocator used for host memory allocated for the display mode object when there is no more specific allocator available (see Memory Allocation).
pMode returns the handle of the mode created.

Description

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle
display must be a valid VkDisplayKHR handle
pCreateInfo must be a valid pointer to a valid VkDisplayModeCreateInfoKHR structure
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pMode must be a valid pointer to a VkDisplayModeKHR handle

Host Synchronization

Host access to display must be externally synchronized

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCreateDisplayModeKHR

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_INITIALIZATION_FAILED

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCreateDisplayPlaneSurfaceKHR(3)

Name

vkCreateDisplayPlaneSurfaceKHR - Create a VkSurfaceKHR structure representing a display plane and mode

C Specification

A complete display configuration includes a mode, one or more display planes and any parameters describing their behavior, and parameters describing some aspects of the images associated with those planes. Display surfaces describe the configuration of a single plane within a complete display configuration. To create a VkSurfaceKHR structure for a display surface, call:

VkResult vkCreateDisplayPlaneSurfaceKHR(
    VkInstance                                  instance,
    const VkDisplaySurfaceCreateInfoKHR*        pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkSurfaceKHR*                               pSurface);

Parameters

instance is the instance corresponding to the physical device the targeted display is on.
pCreateInfo is a pointer to an instance of the VkDisplaySurfaceCreateInfoKHR structure specifying which mode, plane, and other parameters to use, as described below.
pAllocator is the allocator used for host memory allocated for the surface object when there is no more specific allocator available (see Memory Allocation).
pSurface points to a VkSurfaceKHR handle in which the created surface is returned.

Description

Valid Usage (Implicit)

instance must be a valid VkInstance handle
pCreateInfo must be a valid pointer to a valid VkDisplaySurfaceCreateInfoKHR structure
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pSurface must be a valid pointer to a VkSurfaceKHR handle

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCreateDisplayPlaneSurfaceKHR

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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 valid pointer to a valid VkEventCreateInfo structure
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pEvent must be a valid pointer to a VkEvent handle

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCreateEvent

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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 valid pointer to a valid VkFenceCreateInfo structure
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pFence must be a valid pointer to a VkFence handle

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCreateFence

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCreateFramebuffer

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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 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 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 valid pointer to an array of createInfoCount valid VkGraphicsPipelineCreateInfo structures
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pPipelines must be a valid 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

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCreateGraphicsPipelines

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_INVALID_SHADER_NV

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCreateIOSSurfaceMVK(3)

Name

vkCreateIOSSurfaceMVK - Create a VkSurfaceKHR object for an iOS UIView

C Specification

To create a VkSurfaceKHR object for an iOS UIView, call:

VkResult vkCreateIOSSurfaceMVK(
    VkInstance                                  instance,
    const VkIOSSurfaceCreateInfoMVK*            pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkSurfaceKHR*                               pSurface);

Parameters

instance is the instance with which to associate the surface.
pCreateInfo is a pointer to an instance of the VkIOSSurfaceCreateInfoMVK structure containing parameters affecting the creation of the surface object.
pAllocator is the allocator used for host memory allocated for the surface object when there is no more specific allocator available (see Memory Allocation).
pSurface points to a VkSurfaceKHR handle in which the created surface object is returned.

Description

Valid Usage (Implicit)

instance must be a valid VkInstance handle
pCreateInfo must be a valid pointer to a valid VkIOSSurfaceCreateInfoMVK structure
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pSurface must be a valid pointer to a VkSurfaceKHR handle

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCreateIOSSurfaceMVK

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_NATIVE_WINDOW_IN_USE_KHR

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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 valid pointer to a valid VkImageCreateInfo structure
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pImage must be a valid pointer to a VkImage handle

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCreateImage

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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. In particular, image view creation inherits the implicit parameter usage specifying the allowed usages of the image view that, by default, takes the value of the corresponding usage parameter specified in VkImageCreateInfo at image creation time. This implicit parameter can be overriden by chaining a VkImageViewUsageCreateInfo structure through the pNext member to VkImageViewCreateInfo as described later in this section.

The remaining parameters are contained in the pCreateInfo.

Valid Usage (Implicit)

device must be a valid VkDevice handle
pCreateInfo must be a valid pointer to a valid VkImageViewCreateInfo structure
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pView must be a valid pointer to a VkImageView handle

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCreateImageView

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCreateIndirectCommandsLayoutNVX(3)

Name

vkCreateIndirectCommandsLayoutNVX - Create an indirect command layout object

C Specification

Indirect command layouts are created by:

VkResult vkCreateIndirectCommandsLayoutNVX(
    VkDevice                                    device,
    const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkIndirectCommandsLayoutNVX*                pIndirectCommandsLayout);

Parameters

device is the logical device that creates the indirect command layout.
pCreateInfo is a pointer to an instance of the VkIndirectCommandsLayoutCreateInfoNVX structure containing parameters affecting creation of the indirect command layout.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.
pIndirectCommandsLayout points to a VkIndirectCommandsLayoutNVX handle in which the resulting indirect command layout is returned.

Description

Valid Usage (Implicit)

device must be a valid VkDevice handle
pCreateInfo must be a valid pointer to a valid VkIndirectCommandsLayoutCreateInfoNVX structure
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pIndirectCommandsLayout must be a valid pointer to a VkIndirectCommandsLayoutNVX handle

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCreateIndirectCommandsLayoutNVX

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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

All required extensions for each extension in the VkInstanceCreateInfo::ppEnabledExtensionNames list must also be present in that list.

Valid Usage (Implicit)

pCreateInfo must be a valid pointer to a valid VkInstanceCreateInfo structure
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pInstance must be a valid pointer to a VkInstance handle

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCreateInstance

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

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCreateMacOSSurfaceMVK(3)

Name

vkCreateMacOSSurfaceMVK - Create a VkSurfaceKHR object for a macOS NSView

C Specification

To create a VkSurfaceKHR object for a macOS NSView, call:

VkResult vkCreateMacOSSurfaceMVK(
    VkInstance                                  instance,
    const VkMacOSSurfaceCreateInfoMVK*          pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkSurfaceKHR*                               pSurface);

Parameters

instance is the instance with which to associate the surface.
pCreateInfo is a pointer to an instance of the VkMacOSSurfaceCreateInfoMVK structure containing parameters affecting the creation of the surface object.
pAllocator is the allocator used for host memory allocated for the surface object when there is no more specific allocator available (see Memory Allocation).
pSurface points to a VkSurfaceKHR handle in which the created surface object is returned.

Description

Valid Usage (Implicit)

instance must be a valid VkInstance handle
pCreateInfo must be a valid pointer to a valid VkMacOSSurfaceCreateInfoMVK structure
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pSurface must be a valid pointer to a VkSurfaceKHR handle

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCreateMacOSSurfaceMVK

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_NATIVE_WINDOW_IN_USE_KHR

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCreateMirSurfaceKHR(3)

Name

vkCreateMirSurfaceKHR - Create a VkSurfaceKHR object for a Mir window

C Specification

To create a VkSurfaceKHR object for a Mir window, call:

VkResult vkCreateMirSurfaceKHR(
    VkInstance                                  instance,
    const VkMirSurfaceCreateInfoKHR*            pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkSurfaceKHR*                               pSurface);

Parameters

instance is the instance to associate the surface with.
pCreateInfo is a pointer to an instance of the VkMirSurfaceCreateInfoKHR structure containing parameters affecting the creation of the surface object.
pAllocator is the allocator used for host memory allocated for the surface object when there is no more specific allocator available (see Memory Allocation).
pSurface points to a VkSurfaceKHR handle in which the created surface object is returned.

Description

Valid Usage (Implicit)

instance must be a valid VkInstance handle
pCreateInfo must be a valid pointer to a valid VkMirSurfaceCreateInfoKHR structure
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pSurface must be a valid pointer to a VkSurfaceKHR handle

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCreateMirSurfaceKHR

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCreateObjectTableNVX(3)

Name

vkCreateObjectTableNVX - Create an object table

C Specification

To create object tables, call:

VkResult vkCreateObjectTableNVX(
    VkDevice                                    device,
    const VkObjectTableCreateInfoNVX*           pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkObjectTableNVX*                           pObjectTable);

Parameters

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

Description

Valid Usage (Implicit)

device must be a valid VkDevice handle
pCreateInfo must be a valid pointer to a valid VkObjectTableCreateInfoNVX structure
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pObjectTable must be a valid pointer to a VkObjectTableNVX handle

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCreateObjectTableNVX

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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 valid pointer to a valid VkPipelineCacheCreateInfo structure
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pPipelineCache must be a valid pointer to a VkPipelineCache handle

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCreatePipelineCache

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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 valid pointer to a valid VkPipelineLayoutCreateInfo structure
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pPipelineLayout must be a valid pointer to a VkPipelineLayout handle

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCreatePipelineLayout

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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 valid pointer to a valid VkQueryPoolCreateInfo structure
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pQueryPool must be a valid pointer to a VkQueryPool handle

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCreateQueryPool

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCreateRenderPass

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCreateRenderPass2KHR(3)

Name

vkCreateRenderPass2KHR - Create a new render pass object

C Specification

To create a render pass, call:

VkResult vkCreateRenderPass2KHR(
    VkDevice                                    device,
    const VkRenderPassCreateInfo2KHR*           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 VkRenderPassCreateInfo2KHR 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

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

Valid Usage (Implicit)

device must be a valid VkDevice handle
pCreateInfo must be a valid pointer to a valid VkRenderPassCreateInfo2KHR structure
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pRenderPass must be a valid pointer to a VkRenderPass handle

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCreateRenderPass2KHR

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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 valid pointer to a valid VkSamplerCreateInfo structure
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pSampler must be a valid pointer to a VkSampler handle

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCreateSampler

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_TOO_MANY_OBJECTS

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCreateSamplerYcbcrConversion(3)

Name

vkCreateSamplerYcbcrConversion - Create a new Ycbcr conversion

C Specification

To create a VkSamplerYcbcrConversion, call:

VkResult vkCreateSamplerYcbcrConversion(
    VkDevice                                    device,
    const VkSamplerYcbcrConversionCreateInfo*   pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkSamplerYcbcrConversion*                   pYcbcrConversion);

or the equivalent command

VkResult vkCreateSamplerYcbcrConversionKHR(
    VkDevice                                    device,
    const VkSamplerYcbcrConversionCreateInfo*   pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkSamplerYcbcrConversion*                   pYcbcrConversion);

Parameters

device is the logical device that creates the sampler Y’C_BC_R conversion.
pCreateInfo is a pointer to an instance of the VkSamplerYcbcrConversionCreateInfo specifying the requested sampler Y’C_BC_R conversion.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.
pYcbcrConversion points to a VkSamplerYcbcrConversion handle in which the resulting sampler Y’C_BC_R conversion is returned.

Description

The interpretation of the configured sampler Y’C_BC_R conversion is described in more detail in the description of sampler Y’C_BC_R conversion in the Image Operations chapter.

Valid Usage

The sampler Y’C_BC_R conversion feature must be enabled

Valid Usage (Implicit)

device must be a valid VkDevice handle
pCreateInfo must be a valid pointer to a valid VkSamplerYcbcrConversionCreateInfo structure
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pYcbcrConversion must be a valid pointer to a VkSamplerYcbcrConversion handle

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCreateSamplerYcbcrConversion

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

Unresolved directive in apispec.txt - include::vkCreateSamplerYcbcrConversionKHR.txt[]

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 valid pointer to a valid VkSemaphoreCreateInfo structure
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pSemaphore must be a valid pointer to a VkSemaphore handle

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCreateSemaphore

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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

If the shader stage fails to compile VK_ERROR_INVALID_SHADER_NV will be generated and the compile log will be reported back to the application by html/vkspec.html#VK_EXT_debug_report if enabled.

Valid Usage (Implicit)

device must be a valid VkDevice handle
pCreateInfo must be a valid pointer to a valid VkShaderModuleCreateInfo structure
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pShaderModule must be a valid pointer to a VkShaderModule handle

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCreateShaderModule

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_INVALID_SHADER_NV

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCreateSharedSwapchainsKHR(3)

Name

vkCreateSharedSwapchainsKHR - Create multiple swapchains that share presentable images

C Specification

When the VK_KHR_display_swapchain extension is enabled, multiple swapchains that share presentable images are created by calling:

VkResult vkCreateSharedSwapchainsKHR(
    VkDevice                                    device,
    uint32_t                                    swapchainCount,
    const VkSwapchainCreateInfoKHR*             pCreateInfos,
    const VkAllocationCallbacks*                pAllocator,
    VkSwapchainKHR*                             pSwapchains);

Parameters

device is the device to create the swapchains for.
swapchainCount is the number of swapchains to create.
pCreateInfos is a pointer to an array of VkSwapchainCreateInfoKHR structures specifying the parameters of the created swapchains.
pAllocator is the allocator used for host memory allocated for the swapchain objects when there is no more specific allocator available (see Memory Allocation).
pSwapchains is a pointer to an array of VkSwapchainKHR handles in which the created swapchain objects will be returned.

Description

vkCreateSharedSwapchains is similar to vkCreateSwapchainKHR, except that it takes an array of VkSwapchainCreateInfoKHR structures, and returns an array of swapchain objects.

The swapchain creation parameters that affect the properties and number of presentable images must match between all the swapchains. If the displays used by any of the swapchains do not use the same presentable image layout or are incompatible in a way that prevents sharing images, swapchain creation will fail with the result code VK_ERROR_INCOMPATIBLE_DISPLAY_KHR. If any error occurs, no swapchains will be created. Images presented to multiple swapchains must be re-acquired from all of them before transitioning away from VK_IMAGE_LAYOUT_PRESENT_SRC_KHR. After destroying one or more of the swapchains, the remaining swapchains and the presentable images can continue to be used.

Valid Usage (Implicit)

device must be a valid VkDevice handle
pCreateInfos must be a valid pointer to an array of swapchainCount valid VkSwapchainCreateInfoKHR structures
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pSwapchains must be a valid pointer to an array of swapchainCount VkSwapchainKHR handles
swapchainCount must be greater than 0

Host Synchronization

Host access to pCreateInfos[].surface must be externally synchronized
Host access to pCreateInfos[].oldSwapchain must be externally synchronized

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCreateSharedSwapchainsKHR

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_INCOMPATIBLE_DISPLAY_KHR
VK_ERROR_DEVICE_LOST
VK_ERROR_SURFACE_LOST_KHR

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCreateSwapchainKHR(3)

Name

vkCreateSwapchainKHR - Create a swapchain

C Specification

To create a swapchain, call:

VkResult vkCreateSwapchainKHR(
    VkDevice                                    device,
    const VkSwapchainCreateInfoKHR*             pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkSwapchainKHR*                             pSwapchain);

Parameters

device is the device to create the swapchain for.
pCreateInfo is a pointer to an instance of the VkSwapchainCreateInfoKHR structure specifying the parameters of the created swapchain.
pAllocator is the allocator used for host memory allocated for the swapchain object when there is no more specific allocator available (see Memory Allocation).
pSwapchain is a pointer to a VkSwapchainKHR handle in which the created swapchain object will be returned.

Description

Valid Usage (Implicit)

device must be a valid VkDevice handle
pCreateInfo must be a valid pointer to a valid VkSwapchainCreateInfoKHR structure
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pSwapchain must be a valid pointer to a VkSwapchainKHR handle

Host Synchronization

Host access to pCreateInfo.surface must be externally synchronized
Host access to pCreateInfo.oldSwapchain must be externally synchronized

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCreateSwapchainKHR

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_DEVICE_LOST
VK_ERROR_SURFACE_LOST_KHR
VK_ERROR_NATIVE_WINDOW_IN_USE_KHR

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCreateValidationCacheEXT(3)

Name

vkCreateValidationCacheEXT - Creates a new validation cache

C Specification

To create validation cache objects, call:

VkResult vkCreateValidationCacheEXT(
    VkDevice                                    device,
    const VkValidationCacheCreateInfoEXT*       pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkValidationCacheEXT*                       pValidationCache);

Parameters

device is the logical device that creates the validation cache object.
pCreateInfo is a pointer to a VkValidationCacheCreateInfoEXT structure that contains the initial parameters for the validation cache object.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.
pValidationCache is a pointer to a VkValidationCacheEXT handle in which the resulting validation cache object is returned.

Description

Note

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

Once created, a validation cache can be passed to the vkCreateShaderModule command as part of the VkShaderModuleCreateInfo pNext chain. If a VkShaderModuleValidationCacheCreateInfoEXT object is part of the VkShaderModuleCreateInfo::pNext chain, and its validationCache field is not VK_NULL_HANDLE, the implementation will query it for possible reuse opportunities and update it with new content. The use of the validation cache object in these commands is internally synchronized, and the same validation cache object can be used in multiple threads simultaneously.

Note

Valid Usage (Implicit)

device must be a valid VkDevice handle
pCreateInfo must be a valid pointer to a valid VkValidationCacheCreateInfoEXT structure
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pValidationCache must be a valid pointer to a VkValidationCacheEXT handle

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCreateValidationCacheEXT

VK_ERROR_OUT_OF_HOST_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCreateViSurfaceNN(3)

Name

vkCreateViSurfaceNN - Create a VkSurfaceKHR object for a VI layer

C Specification

To create a VkSurfaceKHR object for an nn::vi::Layer, query the layer’s native handle using nn::vi::GetNativeWindow, and then call:

VkResult vkCreateViSurfaceNN(
    VkInstance                                  instance,
    const VkViSurfaceCreateInfoNN*              pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkSurfaceKHR*                               pSurface);

Parameters

instance is the instance with which to associate the surface.
pCreateInfo is a pointer to an instance of the VkViSurfaceCreateInfoNN structure containing parameters affecting the creation of the surface object.
pAllocator is the allocator used for host memory allocated for the surface object when there is no more specific allocator available (see Memory Allocation).
pSurface points to a VkSurfaceKHR handle in which the created surface object is returned.

Description

During the lifetime of a surface created using a particular nn::vi::NativeWindowHandle any attempts to create another surface for the same nn::vi::Layer and any attempts to connect to the same nn::vi::Layer through other platform mechanisms will have undefined results.

The currentExtent of a VI surface is always undefined. Applications are expected to choose an appropriate size for the swapchain’s imageExtent (e.g., by matching the result of a call to nn::vi::GetDisplayResolution).

Valid Usage (Implicit)

instance must be a valid VkInstance handle
pCreateInfo must be a valid pointer to a valid VkViSurfaceCreateInfoNN structure
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pSurface must be a valid pointer to a VkSurfaceKHR handle

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCreateViSurfaceNN

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_NATIVE_WINDOW_IN_USE_KHR

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCreateWaylandSurfaceKHR(3)

Name

vkCreateWaylandSurfaceKHR - Create a VkSurfaceKHR object for a Wayland window

C Specification

To create a VkSurfaceKHR object for a Wayland surface, call:

VkResult vkCreateWaylandSurfaceKHR(
    VkInstance                                  instance,
    const VkWaylandSurfaceCreateInfoKHR*        pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkSurfaceKHR*                               pSurface);

Parameters

instance is the instance to associate the surface with.
pCreateInfo is a pointer to an instance of the VkWaylandSurfaceCreateInfoKHR structure containing parameters affecting the creation of the surface object.
pAllocator is the allocator used for host memory allocated for the surface object when there is no more specific allocator available (see Memory Allocation).
pSurface points to a VkSurfaceKHR handle in which the created surface object is returned.

Description

Valid Usage (Implicit)

instance must be a valid VkInstance handle
pCreateInfo must be a valid pointer to a valid VkWaylandSurfaceCreateInfoKHR structure
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pSurface must be a valid pointer to a VkSurfaceKHR handle

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCreateWaylandSurfaceKHR

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCreateWin32SurfaceKHR(3)

Name

vkCreateWin32SurfaceKHR - Create a VkSurfaceKHR object for an Win32 native window

C Specification

To create a VkSurfaceKHR object for a Win32 window, call:

VkResult vkCreateWin32SurfaceKHR(
    VkInstance                                  instance,
    const VkWin32SurfaceCreateInfoKHR*          pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkSurfaceKHR*                               pSurface);

Parameters

instance is the instance to associate the surface with.
pCreateInfo is a pointer to an instance of the VkWin32SurfaceCreateInfoKHR structure containing parameters affecting the creation of the surface object.
pAllocator is the allocator used for host memory allocated for the surface object when there is no more specific allocator available (see Memory Allocation).
pSurface points to a VkSurfaceKHR handle in which the created surface object is returned.

Description

Valid Usage (Implicit)

instance must be a valid VkInstance handle
pCreateInfo must be a valid pointer to a valid VkWin32SurfaceCreateInfoKHR structure
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pSurface must be a valid pointer to a VkSurfaceKHR handle

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCreateWin32SurfaceKHR

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCreateXcbSurfaceKHR(3)

Name

vkCreateXcbSurfaceKHR - Create a VkSurfaceKHR object for a X11 window, using the XCB client-side library

C Specification

To create a VkSurfaceKHR object for an X11 window, using the XCB client-side library, call:

VkResult vkCreateXcbSurfaceKHR(
    VkInstance                                  instance,
    const VkXcbSurfaceCreateInfoKHR*            pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkSurfaceKHR*                               pSurface);

Parameters

instance is the instance to associate the surface with.
pCreateInfo is a pointer to an instance of the VkXcbSurfaceCreateInfoKHR structure containing parameters affecting the creation of the surface object.
pAllocator is the allocator used for host memory allocated for the surface object when there is no more specific allocator available (see Memory Allocation).
pSurface points to a VkSurfaceKHR handle in which the created surface object is returned.

Description

Valid Usage (Implicit)

instance must be a valid VkInstance handle
pCreateInfo must be a valid pointer to a valid VkXcbSurfaceCreateInfoKHR structure
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pSurface must be a valid pointer to a VkSurfaceKHR handle

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCreateXcbSurfaceKHR

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkCreateXlibSurfaceKHR(3)

Name

vkCreateXlibSurfaceKHR - Create a VkSurfaceKHR object for an X11 window, using the Xlib client-side library

C Specification

To create a VkSurfaceKHR object for an X11 window, using the Xlib client-side library, call:

VkResult vkCreateXlibSurfaceKHR(
    VkInstance                                  instance,
    const VkXlibSurfaceCreateInfoKHR*           pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkSurfaceKHR*                               pSurface);

Parameters

instance is the instance to associate the surface with.
pCreateInfo is a pointer to an instance of the VkXlibSurfaceCreateInfoKHR structure containing the parameters affecting the creation of the surface object.
pAllocator is the allocator used for host memory allocated for the surface object when there is no more specific allocator available (see Memory Allocation).
pSurface points to a VkSurfaceKHR handle in which the created surface object is returned.

Description

Valid Usage (Implicit)

instance must be a valid VkInstance handle
pCreateInfo must be a valid pointer to a valid VkXlibSurfaceCreateInfoKHR structure
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pSurface must be a valid pointer to a VkSurfaceKHR handle

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCreateXlibSurfaceKHR

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkDebugMarkerSetObjectNameEXT(3)

Name

vkDebugMarkerSetObjectNameEXT - Give a user-friendly name to an object

C Specification

An object can be given a user-friendly name by calling:

VkResult vkDebugMarkerSetObjectNameEXT(
    VkDevice                                    device,
    const VkDebugMarkerObjectNameInfoEXT*       pNameInfo);

Parameters

device is the device that created the object.
pNameInfo is a pointer to an instance of the VkDebugMarkerObjectNameInfoEXT structure specifying the parameters of the name to set on the object.

Description

Valid Usage (Implicit)

device must be a valid VkDevice handle
pNameInfo must be a valid pointer to a valid VkDebugMarkerObjectNameInfoEXT structure

Host Synchronization

Host access to pNameInfo.object must be externally synchronized

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkDebugMarkerSetObjectNameEXT

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkDebugMarkerSetObjectTagEXT(3)

Name

vkDebugMarkerSetObjectTagEXT - Attach arbitrary data to an object

C Specification

In addition to setting a name for an object, debugging and validation layers may have uses for additional binary data on a per-object basis that has no other place in the Vulkan API. For example, a VkShaderModule could have additional debugging data attached to it to aid in offline shader tracing. To attach data to an object, call:

VkResult vkDebugMarkerSetObjectTagEXT(
    VkDevice                                    device,
    const VkDebugMarkerObjectTagInfoEXT*        pTagInfo);

Parameters

device is the device that created the object.
pTagInfo is a pointer to an instance of the VkDebugMarkerObjectTagInfoEXT structure specifying the parameters of the tag to attach to the object.

Description

Valid Usage (Implicit)

device must be a valid VkDevice handle
pTagInfo must be a valid pointer to a valid VkDebugMarkerObjectTagInfoEXT structure

Host Synchronization

Host access to pTagInfo.object must be externally synchronized

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkDebugMarkerSetObjectTagEXT

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkDebugReportMessageEXT(3)

Name

vkDebugReportMessageEXT - Inject a message into a debug stream

C Specification

To inject its own messages into the debug stream, call:

void vkDebugReportMessageEXT(
    VkInstance                                  instance,
    VkDebugReportFlagsEXT                       flags,
    VkDebugReportObjectTypeEXT                  objectType,
    uint64_t                                    object,
    size_t                                      location,
    int32_t                                     messageCode,
    const char*                                 pLayerPrefix,
    const char*                                 pMessage);

Parameters

instance is the debug stream’s VkInstance.
flags specifies the VkDebugReportFlagBitsEXT classification of this event/message.
objectType is a VkDebugReportObjectTypeEXT specifying the type of object being used or created at the time the event was triggered.
object this is the object where the issue was detected. object can be VK_NULL_HANDLE if there is no object associated with the event.
location is an application defined value.
messageCode is an application defined value.
pLayerPrefix is the abbreviation of the component making this event/message.
pMessage is a null-terminated string detailing the trigger conditions.

Description

The call will propagate through the layers and generate callback(s) as indicated by the message’s flags. The parameters are passed on to the callback in addition to the pUserData value that was defined at the time the callback was registered.

Valid Usage

object must be a Vulkan object or VK_NULL_HANDLE
If objectType is not VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT and object is not VK_NULL_HANDLE, object must be a Vulkan object of the corresponding type associated with objectType as defined in html/vkspec.html#debug-report-object-types.

Valid Usage (Implicit)

instance must be a valid VkInstance handle
flags must be a valid combination of VkDebugReportFlagBitsEXT values
flags must not be 0
objectType must be a valid VkDebugReportObjectTypeEXT value
pLayerPrefix must be a null-terminated UTF-8 string
pMessage must be a null-terminated UTF-8 string

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkDebugReportMessageEXT

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkDestroyBuffer

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkDestroyBufferView

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkDestroyCommandPool

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkDestroyDebugReportCallbackEXT(3)

Name

vkDestroyDebugReportCallbackEXT - Destroy a debug report callback object

C Specification

To destroy a VkDebugReportCallbackEXT object, call:

void vkDestroyDebugReportCallbackEXT(
    VkInstance                                  instance,
    VkDebugReportCallbackEXT                    callback,
    const VkAllocationCallbacks*                pAllocator);

Parameters

instance the instance where the callback was created.
callback the VkDebugReportCallbackEXT object to destroy. callback is an externally synchronized object and must not be used on more than one thread at a time. This means that vkDestroyDebugReportCallbackEXT must not be called when a callback is active.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Description

Valid Usage

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

Valid Usage (Implicit)

instance must be a valid VkInstance handle
callback must be a valid VkDebugReportCallbackEXT handle
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
callback must have been created, allocated, or retrieved from instance

Host Synchronization

Host access to callback must be externally synchronized

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkDestroyDebugReportCallbackEXT

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkDestroyDebugUtilsMessengerEXT(3)

Name

vkDestroyDebugUtilsMessengerEXT - Destroy a debug messenger object

C Specification

To destroy a VkDebugUtilsMessengerEXT object, call:

void vkDestroyDebugUtilsMessengerEXT(
    VkInstance                                  instance,
    VkDebugUtilsMessengerEXT                    messenger,
    const VkAllocationCallbacks*                pAllocator);

Parameters

instance the instance where the callback was created.
messenger the VkDebugUtilsMessengerEXT object to destroy. messenger is an externally synchronized object and must not be used on more than one thread at a time. This means that vkDestroyDebugUtilsMessengerEXT must not be called when a callback is active.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Description

Valid Usage

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

Valid Usage (Implicit)

instance must be a valid VkInstance handle
messenger must be a valid VkDebugUtilsMessengerEXT handle
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
messenger must have been created, allocated, or retrieved from instance

Host Synchronization

Host access to messenger must be externally synchronized

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkDestroyDebugUtilsMessengerEXT

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkDestroyDescriptorPool

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkDestroyDescriptorSetLayout

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkDestroyDescriptorUpdateTemplate(3)

Name

vkDestroyDescriptorUpdateTemplate - Destroy a descriptor update template object

C Specification

To destroy a descriptor update template, call:

void vkDestroyDescriptorUpdateTemplate(
    VkDevice                                    device,
    VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
    const VkAllocationCallbacks*                pAllocator);

or the equivalent command

void vkDestroyDescriptorUpdateTemplateKHR(
    VkDevice                                    device,
    VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
    const VkAllocationCallbacks*                pAllocator);

Parameters

device is the logical device that has been used to create the descriptor update template
descriptorUpdateTemplate is the descriptor update template 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 descriptorUpdateTemplate is not VK_NULL_HANDLE, descriptorUpdateTemplate must be a valid VkDescriptorUpdateTemplate handle
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
If descriptorUpdateTemplate is a valid handle, it must have been created, allocated, or retrieved from device

Host Synchronization

Host access to descriptorUpdateTemplate must be externally synchronized

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkDestroyDescriptorUpdateTemplate

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

Unresolved directive in apispec.txt - include::vkDestroyDescriptorUpdateTemplateKHR.txt[]

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 valid pointer to a valid VkAllocationCallbacks structure

Host Synchronization

Host access to device must be externally synchronized

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkDestroyDevice

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkDestroyEvent

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkDestroyFence

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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 valid pointer to a valid VkAllocationCallbacks structure
If framebuffer is a valid handle, it must have been created, allocated, or retrieved from device

Host Synchronization

Host access to framebuffer must be externally synchronized

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkDestroyFramebuffer

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkDestroyImage

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkDestroyImageView

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkDestroyIndirectCommandsLayoutNVX(3)

Name

vkDestroyIndirectCommandsLayoutNVX - Destroy an object table

C Specification

Indirect command layouts are destroyed by:

void vkDestroyIndirectCommandsLayoutNVX(
    VkDevice                                    device,
    VkIndirectCommandsLayoutNVX                 indirectCommandsLayout,
    const VkAllocationCallbacks*                pAllocator);

Parameters

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

Description

Valid Usage

All submitted commands that refer to indirectCommandsLayout must have completed execution
If VkAllocationCallbacks were provided when objectTable was created, a compatible set of callbacks must be provided here
If no VkAllocationCallbacks were provided when objectTable was created, pAllocator must be NULL

Valid Usage (Implicit)

device must be a valid VkDevice handle
indirectCommandsLayout must be a valid VkIndirectCommandsLayoutNVX handle
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
indirectCommandsLayout must have been created, allocated, or retrieved from device

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkDestroyIndirectCommandsLayoutNVX

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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 valid pointer to a valid VkAllocationCallbacks structure

Host Synchronization

Host access to instance must be externally synchronized

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkDestroyInstance

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkDestroyObjectTableNVX(3)

Name

vkDestroyObjectTableNVX - Destroy an object table

C Specification

To destroy an object table, call:

void vkDestroyObjectTableNVX(
    VkDevice                                    device,
    VkObjectTableNVX                            objectTable,
    const VkAllocationCallbacks*                pAllocator);

Parameters

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

Description

Valid Usage

All submitted commands that refer to objectTable must have completed execution.
If VkAllocationCallbacks were provided when objectTable was created, a compatible set of callbacks must be provided here.
If no VkAllocationCallbacks were provided when objectTable was created, pAllocator must be NULL.

Valid Usage (Implicit)

device must be a valid VkDevice handle
objectTable must be a valid VkObjectTableNVX handle
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
objectTable must have been created, allocated, or retrieved from device

Host Synchronization

Host access to objectTable must be externally synchronized

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkDestroyObjectTableNVX

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkDestroyPipeline

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkDestroyPipelineCache

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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
pipelineLayout must not have been passed to any vkCmd* command for any command buffers that are still in the recording state when vkDestroyPipelineLayout is called

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

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkDestroyPipelineLayout

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkDestroyQueryPool

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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 valid pointer to a valid VkAllocationCallbacks structure
If renderPass is a valid handle, it must have been created, allocated, or retrieved from device

Host Synchronization

Host access to renderPass must be externally synchronized

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkDestroyRenderPass

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkDestroySampler

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkDestroySamplerYcbcrConversion(3)

Name

vkDestroySamplerYcbcrConversion - Destroy a created Y’CbCr conversion

C Specification

To destroy a sampler Y’C_BC_R conversion, call:

void vkDestroySamplerYcbcrConversion(
    VkDevice                                    device,
    VkSamplerYcbcrConversion                    ycbcrConversion,
    const VkAllocationCallbacks*                pAllocator);

or the equivalent command

void vkDestroySamplerYcbcrConversionKHR(
    VkDevice                                    device,
    VkSamplerYcbcrConversion                    ycbcrConversion,
    const VkAllocationCallbacks*                pAllocator);

Parameters

device is the logical device that destroys the Y’C_BC_R conversion.
ycbcrConversion is the conversion to destroy.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Description

Valid Usage (Implicit)

device must be a valid VkDevice handle
If ycbcrConversion is not VK_NULL_HANDLE, ycbcrConversion must be a valid VkSamplerYcbcrConversion handle
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
If ycbcrConversion is a valid handle, it must have been created, allocated, or retrieved from device

Host Synchronization

Host access to ycbcrConversion must be externally synchronized

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkDestroySamplerYcbcrConversion

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

Unresolved directive in apispec.txt - include::vkDestroySamplerYcbcrConversionKHR.txt[]

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

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkDestroySemaphore

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkDestroyShaderModule

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkDestroySurfaceKHR(3)

Name

vkDestroySurfaceKHR - Destroy a VkSurfaceKHR object

C Specification

To destroy a VkSurfaceKHR object, call:

void vkDestroySurfaceKHR(
    VkInstance                                  instance,
    VkSurfaceKHR                                surface,
    const VkAllocationCallbacks*                pAllocator);

Parameters

instance is the instance used to create the surface.
surface is the surface to destroy.
pAllocator is the allocator used for host memory allocated for the surface object when there is no more specific allocator available (see Memory Allocation).

Description

Destroying a VkSurfaceKHR merely severs the connection between Vulkan and the native surface, and does not imply destroying the native surface, closing a window, or similar behavior.

Valid Usage

All VkSwapchainKHR objects created for surface must have been destroyed prior to destroying surface
If VkAllocationCallbacks were provided when surface was created, a compatible set of callbacks must be provided here
If no VkAllocationCallbacks were provided when surface was created, pAllocator must be NULL

Valid Usage (Implicit)

instance must be a valid VkInstance handle
If surface is not VK_NULL_HANDLE, surface must be a valid VkSurfaceKHR handle
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
If surface is a valid handle, it must have been created, allocated, or retrieved from instance

Host Synchronization

Host access to surface must be externally synchronized

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkDestroySurfaceKHR

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkDestroySwapchainKHR(3)

Name

vkDestroySwapchainKHR - Destroy a swapchain object

C Specification

To destroy a swapchain object call:

void vkDestroySwapchainKHR(
    VkDevice                                    device,
    VkSwapchainKHR                              swapchain,
    const VkAllocationCallbacks*                pAllocator);

Parameters

device is the VkDevice associated with swapchain.
swapchain is the swapchain to destroy.
pAllocator is the allocator used for host memory allocated for the swapchain object when there is no more specific allocator available (see Memory Allocation).

Description

The application must not destroy a swapchain until after completion of all outstanding operations on images that were acquired from the swapchain. swapchain and all associated VkImage handles are destroyed, and must not be acquired or used any more by the application. The memory of each VkImage will only be freed after that image is no longer used by the presentation engine. For example, if one image of the swapchain is being displayed in a window, the memory for that image may not be freed until the window is destroyed, or another swapchain is created for the window. Destroying the swapchain does not invalidate the parent VkSurfaceKHR, and a new swapchain can be created with it.

When a swapchain associated with a display surface is destroyed, if the image most recently presented to the display surface is from the swapchain being destroyed, then either any display resources modified by presenting images from any swapchain associated with the display surface must be reverted by the implementation to their state prior to the first present performed on one of these swapchains, or such resources must be left in their current state.

Valid Usage

All uses of presentable images acquired from swapchain must have completed execution
If VkAllocationCallbacks were provided when swapchain was created, a compatible set of callbacks must be provided here
If no VkAllocationCallbacks were provided when swapchain was created, pAllocator must be NULL

Valid Usage (Implicit)

device must be a valid VkDevice handle
If swapchain is not VK_NULL_HANDLE, swapchain must be a valid VkSwapchainKHR handle
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
Both of device, and swapchain that are valid handles must have been created, allocated, or retrieved from the same VkInstance

Host Synchronization

Host access to swapchain must be externally synchronized

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkDestroySwapchainKHR

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkDestroyValidationCacheEXT(3)

Name

vkDestroyValidationCacheEXT - Destroy a validation cache object

C Specification

To destroy a validation cache, call:

void vkDestroyValidationCacheEXT(
    VkDevice                                    device,
    VkValidationCacheEXT                        validationCache,
    const VkAllocationCallbacks*                pAllocator);

Parameters

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

Description

Valid Usage

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

Valid Usage (Implicit)

device must be a valid VkDevice handle
If validationCache is not VK_NULL_HANDLE, validationCache must be a valid VkValidationCacheEXT handle
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
If validationCache is a valid handle, it must have been created, allocated, or retrieved from device

Host Synchronization

Host access to validationCache must be externally synchronized

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkDestroyValidationCacheEXT

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkDeviceWaitIdle

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_DEVICE_LOST

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkDisplayPowerControlEXT(3)

Name

vkDisplayPowerControlEXT - Set the power state of a display

C Specification

To set the power state of a display, call:

VkResult vkDisplayPowerControlEXT(
    VkDevice                                    device,
    VkDisplayKHR                                display,
    const VkDisplayPowerInfoEXT*                pDisplayPowerInfo);

Parameters

device is a logical device associated with display.
display is the display whose power state is modified.
pDisplayPowerInfo is an instance of VkDisplayPowerInfoEXT specifying the new power state of display.

Description

Valid Usage (Implicit)

device must be a valid VkDevice handle
display must be a valid VkDisplayKHR handle
pDisplayPowerInfo must be a valid pointer to a valid VkDisplayPowerInfoEXT structure

Return Codes

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkDisplayPowerControlEXT

VK_SUCCESS

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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
Conditional rendering must not be active
If commandBuffer is a secondary command buffer, there must not be an outstanding vkCmdBeginDebugUtilsLabelEXT command recorded to commandBuffer that has not previously been ended by a call to vkCmdEndDebugUtilsLabelEXT.
If commandBuffer is a secondary command buffer, there must not be an outstanding vkCmdDebugMarkerBeginEXT command recorded to commandBuffer that has not previously been ended by a call to vkCmdDebugMarkerEndEXT.

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

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkEndCommandBuffer

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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 valid pointer to a uint32_t value
If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkExtensionProperties structures

Return Codes

VK_SUCCESS
VK_INCOMPLETE

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkEnumerateDeviceExtensionProperties

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_LAYER_NOT_PRESENT

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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 valid pointer to a uint32_t value
If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkLayerProperties structures

Return Codes

VK_SUCCESS
VK_INCOMPLETE

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkEnumerateDeviceLayerProperties

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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 valid pointer to a uint32_t value
If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkExtensionProperties structures

Return Codes

VK_SUCCESS
VK_INCOMPLETE

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkEnumerateInstanceExtensionProperties

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_LAYER_NOT_PRESENT

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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

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 valid pointer to a uint32_t value
If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkLayerProperties structures

Return Codes

VK_SUCCESS
VK_INCOMPLETE

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkEnumerateInstanceLayerProperties

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkEnumerateInstanceVersion(3)

Name

vkEnumerateInstanceVersion - Query instance-level version before instance creation

C Specification

The version of Vulkan that is supported by an instance may be different than the version of Vulkan supported by a device or physical device. To query properties that can be used in creating an instance, call:

VkResult vkEnumerateInstanceVersion(
    uint32_t*                                   pApiVersion);

Parameters

pApiVersion points to a uint32_t, which is the version of Vulkan supported by instance-level functionality, encoded as described in the API Version Numbers and Semantics section.

Description

Valid Usage (Implicit)

pApiVersion must be a valid pointer to a uint32_t value

Return Codes

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkEnumerateInstanceVersion

VK_SUCCESS

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkEnumeratePhysicalDeviceGroups(3)

Name

vkEnumeratePhysicalDeviceGroups - Enumerates groups of physical devices that can be used to create a single logical device

C Specification

To retrieve a list of the device groups present in the system, call:

VkResult vkEnumeratePhysicalDeviceGroups(
    VkInstance                                  instance,
    uint32_t*                                   pPhysicalDeviceGroupCount,
    VkPhysicalDeviceGroupProperties*            pPhysicalDeviceGroupProperties);

or the equivalent command

VkResult vkEnumeratePhysicalDeviceGroupsKHR(
    VkInstance                                  instance,
    uint32_t*                                   pPhysicalDeviceGroupCount,
    VkPhysicalDeviceGroupProperties*            pPhysicalDeviceGroupProperties);

Parameters

instance is a handle to a Vulkan instance previously created with vkCreateInstance.
pPhysicalDeviceGroupCount is a pointer to an integer related to the number of device groups available or queried, as described below.
pPhysicalDeviceGroupProperties is either NULL or a pointer to an array of VkPhysicalDeviceGroupProperties structures.

Description

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

Every physical device must be in exactly one device group.

Valid Usage (Implicit)

instance must be a valid VkInstance handle
pPhysicalDeviceGroupCount must be a valid pointer to a uint32_t value
If the value referenced by pPhysicalDeviceGroupCount is not 0, and pPhysicalDeviceGroupProperties is not NULL, pPhysicalDeviceGroupProperties must be a valid pointer to an array of pPhysicalDeviceGroupCount VkPhysicalDeviceGroupProperties structures

Return Codes

VK_SUCCESS
VK_INCOMPLETE

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkEnumeratePhysicalDeviceGroups

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_INITIALIZATION_FAILED

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

Unresolved directive in apispec.txt - include::vkEnumeratePhysicalDeviceGroupsKHR.txt[]

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 valid pointer to a uint32_t value
If the value referenced by pPhysicalDeviceCount is not 0, and pPhysicalDevices is not NULL, pPhysicalDevices must be a valid pointer to an array of pPhysicalDeviceCount VkPhysicalDevice handles

Return Codes

VK_SUCCESS
VK_INCOMPLETE

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkEnumeratePhysicalDevices

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_INITIALIZATION_FAILED

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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.

Within each range described by pMemoryRanges, each set of nonCoherentAtomSize bytes in that range is flushed if any byte in that set has been written by the host since it was first mapped, or the last time it was flushed. If pMemoryRanges includes sets of nonCoherentAtomSize bytes where no bytes have been written by the host, those bytes must not be flushed.

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 valid pointer to an array of memoryRangeCount valid VkMappedMemoryRange structures
memoryRangeCount must be greater than 0

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkFlushMappedMemoryRanges

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkFreeCommandBuffers

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkFreeDescriptorSets

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkFreeMemory(3)

Name

vkFreeMemory - Free device 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 in the pending state. 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 valid 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

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkFreeMemory

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetAndroidHardwareBufferPropertiesANDROID(3)

Name

vkGetAndroidHardwareBufferPropertiesANDROID - Get Properties of External Memory Android Hardware Buffers

C Specification

To determine the memory parameters to use when importing an Android hardware buffer, call:

VkResult vkGetAndroidHardwareBufferPropertiesANDROID(
    VkDevice                                    device,
    const struct AHardwareBuffer*               buffer,
    VkAndroidHardwareBufferPropertiesANDROID*   pProperties);

Parameters

device is the logical device that will be importing buffer.
buffer is the Android hardware buffer which will be imported.
pProperties will return properties of buffer.

Description

Valid Usage

buffer must be a valid Android hardware buffer object with at least one of the AHARDWAREBUFFER_USAGE_GPU_* usage flags.

Valid Usage (Implicit)

device must be a valid VkDevice handle
buffer must be a valid pointer to a valid AHardwareBuffer value
pProperties must be a valid pointer to a VkAndroidHardwareBufferPropertiesANDROID structure

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetAndroidHardwareBufferPropertiesANDROID

VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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 valid pointer to a VkMemoryRequirements structure
buffer must have been created, allocated, or retrieved from device

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetBufferMemoryRequirements

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetBufferMemoryRequirements2(3)

Name

vkGetBufferMemoryRequirements2 - Returns the memory requirements for specified Vulkan object

C Specification

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

void vkGetBufferMemoryRequirements2(
    VkDevice                                    device,
    const VkBufferMemoryRequirementsInfo2*      pInfo,
    VkMemoryRequirements2*                      pMemoryRequirements);

or the equivalent command

void vkGetBufferMemoryRequirements2KHR(
    VkDevice                                    device,
    const VkBufferMemoryRequirementsInfo2*      pInfo,
    VkMemoryRequirements2*                      pMemoryRequirements);

Parameters

device is the logical device that owns the buffer.
pInfo is a pointer to an instance of the VkBufferMemoryRequirementsInfo2 structure containing parameters required for the memory requirements query.
pMemoryRequirements points to an instance of the VkMemoryRequirements2 structure in which the memory requirements of the buffer object are returned.

Description

Valid Usage (Implicit)

device must be a valid VkDevice handle
pInfo must be a valid pointer to a valid VkBufferMemoryRequirementsInfo2 structure
pMemoryRequirements must be a valid pointer to a VkMemoryRequirements2 structure

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetBufferMemoryRequirements2

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

Unresolved directive in apispec.txt - include::vkGetBufferMemoryRequirements2KHR.txt[]

vkGetDescriptorSetLayoutSupport(3)

Name

vkGetDescriptorSetLayoutSupport - Query whether a descriptor set layout can be created

C Specification

To query information about whether a descriptor set layout can be created, call:

void vkGetDescriptorSetLayoutSupport(
    VkDevice                                    device,
    const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
    VkDescriptorSetLayoutSupport*               pSupport);

or the equivalent command

void vkGetDescriptorSetLayoutSupportKHR(
    VkDevice                                    device,
    const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
    VkDescriptorSetLayoutSupport*               pSupport);

Parameters

device is the logical device that would create the descriptor set layout.
pCreateInfo is a pointer to an instance of the VkDescriptorSetLayoutCreateInfo structure specifying the state of the descriptor set layout object.
pSupport points to a VkDescriptorSetLayoutSupport structure in which information about support for the descriptor set layout object is returned.

Description

Some implementations have limitations on what fits in a descriptor set which are not easily expressible in terms of existing limits like maxDescriptorSet*, for example if all descriptor types share a limited space in memory but each descriptor is a different size or alignment. This command returns information about whether a descriptor set satisfies this limit. If the descriptor set layout satisfies the VkPhysicalDeviceMaintenance3Properties::maxPerSetDescriptors limit, this command is guaranteed to return VK_TRUE in VkDescriptorSetLayoutSupport::supported. If the descriptor set layout exceeds the VkPhysicalDeviceMaintenance3Properties::maxPerSetDescriptors limit, whether the descriptor set layout is supported is implementation-dependent and may depend on whether the descriptor sizes and alignments cause the layout to exceed an internal limit.

This command does not consider other limits such as maxPerStageDescriptor*, and so a descriptor set layout that is supported according to this command must still satisfy the pipeline layout limits such as maxPerStageDescriptor* in order to be used in a pipeline layout.

Note

This is a VkDevice query rather than VkPhysicalDevice because the answer may depend on enabled features.

Valid Usage (Implicit)

device must be a valid VkDevice handle
pCreateInfo must be a valid pointer to a valid VkDescriptorSetLayoutCreateInfo structure
pSupport must be a valid pointer to a VkDescriptorSetLayoutSupport structure

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetDescriptorSetLayoutSupport

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

Unresolved directive in apispec.txt - include::vkGetDescriptorSetLayoutSupportKHR.txt[]

vkGetDeviceGroupPeerMemoryFeatures(3)

Name

vkGetDeviceGroupPeerMemoryFeatures - Query supported peer memory features of a device

C Specification

Peer memory is memory that is allocated for a given physical device and then bound to a resource and accessed by a different physical device, in a logical device that represents multiple physical devices. Some ways of reading and writing peer memory may not be supported by a device.

To determine how peer memory can be accessed, call:

void vkGetDeviceGroupPeerMemoryFeatures(
    VkDevice                                    device,
    uint32_t                                    heapIndex,
    uint32_t                                    localDeviceIndex,
    uint32_t                                    remoteDeviceIndex,
    VkPeerMemoryFeatureFlags*                   pPeerMemoryFeatures);

or the equivalent command

void vkGetDeviceGroupPeerMemoryFeaturesKHR(
    VkDevice                                    device,
    uint32_t                                    heapIndex,
    uint32_t                                    localDeviceIndex,
    uint32_t                                    remoteDeviceIndex,
    VkPeerMemoryFeatureFlags*                   pPeerMemoryFeatures);

Parameters

device is the logical device that owns the memory.
heapIndex is the index of the memory heap from which the memory is allocated.
localDeviceIndex is the device index of the physical device that performs the memory access.
remoteDeviceIndex is the device index of the physical device that the memory is allocated for.
pPeerMemoryFeatures is a pointer to a bitmask of VkPeerMemoryFeatureFlagBits indicating which types of memory accesses are supported for the combination of heap, local, and remote devices.

Description

Valid Usage

heapIndex must be less than memoryHeapCount
localDeviceIndex must be a valid device index
remoteDeviceIndex must be a valid device index
localDeviceIndex must not equal remoteDeviceIndex

Valid Usage (Implicit)

device must be a valid VkDevice handle
pPeerMemoryFeatures must be a valid pointer to a VkPeerMemoryFeatureFlags value

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetDeviceGroupPeerMemoryFeatures

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

Unresolved directive in apispec.txt - include::vkGetDeviceGroupPeerMemoryFeaturesKHR.txt[]

vkGetDeviceGroupPresentCapabilitiesKHR(3)

Name

vkGetDeviceGroupPresentCapabilitiesKHR - Query present capabilities from other physical devices

C Specification

A logical device that represents multiple physical devices may support presenting from images on more than one physical device, or combining images from multiple physical devices.

To query these capabilities, call:

VkResult vkGetDeviceGroupPresentCapabilitiesKHR(
    VkDevice                                    device,
    VkDeviceGroupPresentCapabilitiesKHR*        pDeviceGroupPresentCapabilities);

Parameters

device is the logical device.
pDeviceGroupPresentCapabilities is a pointer to a structure of type VkDeviceGroupPresentCapabilitiesKHR that is filled with the logical device’s capabilities.

Description

Valid Usage (Implicit)

device must be a valid VkDevice handle
pDeviceGroupPresentCapabilities must be a valid pointer to a VkDeviceGroupPresentCapabilitiesKHR structure

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetDeviceGroupPresentCapabilitiesKHR

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetDeviceGroupSurfacePresentModesKHR(3)

Name

vkGetDeviceGroupSurfacePresentModesKHR - Query present capabilities for a surface

C Specification

Some surfaces may not be capable of using all the device group present modes.

To query the supported device group present modes for a particular surface, call:

VkResult vkGetDeviceGroupSurfacePresentModesKHR(
    VkDevice                                    device,
    VkSurfaceKHR                                surface,
    VkDeviceGroupPresentModeFlagsKHR*           pModes);

Parameters

device is the logical device.
surface is the surface.
pModes is a pointer to a value of type VkDeviceGroupPresentModeFlagsKHR that is filled with the supported device group present modes for the surface.

Description

The modes returned by this command are not invariant, and may change in response to the surface being moved, resized, or occluded. These modes must be a subset of the modes returned by vkGetDeviceGroupPresentCapabilitiesKHR.

Valid Usage (Implicit)

device must be a valid VkDevice handle
surface must be a valid VkSurfaceKHR handle
pModes must be a valid pointer to a VkDeviceGroupPresentModeFlagsKHR value
Both of device, and surface must have been created, allocated, or retrieved from the same VkInstance

Host Synchronization

Host access to surface must be externally synchronized

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetDeviceGroupSurfacePresentModesKHR

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_SURFACE_LOST_KHR

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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 valid pointer to a VkDeviceSize value
memory must have been created, allocated, or retrieved from device

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetDeviceMemoryCommitment

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetDeviceProcAddr(3)

Name

vkGetDeviceProcAddr - Return a function pointer for a command

C Specification

In order to support systems with multiple Vulkan implementations, the function pointers returned by vkGetInstanceProcAddr may point to dispatch code that calls a different real implementation for different VkDevice objects or their child objects. The overhead of the internal dispatch for VkDevice objects 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. The function pointer must only be called with a dispatchable object (the first parameter) that is device or a child of device.

Table 1. vkGetDeviceProcAddr behavior
`device`	`pName`	return value
`NULL`	*	undefined
invalid device	*	undefined
device	`NULL`	undefined
device	core device-level Vulkan command	fp
device	enabled device extension commands	fp
device	* (any `pName` not covered above)	`NULL`

Valid Usage (Implicit)

device must be a valid VkDevice handle
pName must be a null-terminated UTF-8 string

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetDeviceProcAddr

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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

vkGetDeviceQueue must only be used to get queues that were created with the flags parameter of VkDeviceQueueCreateInfo set to zero. To get queues that were created with a non-zero flags parameter use vkGetDeviceQueue2.

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
VkDeviceQueueCreateInfo::flags must have been set to zero when device was created

Valid Usage (Implicit)

device must be a valid VkDevice handle
pQueue must be a valid pointer to a VkQueue handle

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetDeviceQueue

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetDeviceQueue2(3)

Name

vkGetDeviceQueue2 - Get a queue handle from a device

C Specification

To retrieve a handle to a VkQueue object with specific VkDeviceQueueCreateFlags creation flags, call:

void vkGetDeviceQueue2(
    VkDevice                                    device,
    const VkDeviceQueueInfo2*                   pQueueInfo,
    VkQueue*                                    pQueue);

Parameters

device is the logical device that owns the queue.
pQueueInfo points to an instance of the VkDeviceQueueInfo2 structure, describing the parameters used to create the device queue.
pQueue is a pointer to a VkQueue object that will be filled with the handle for the requested queue.

Description

Valid Usage (Implicit)

device must be a valid VkDevice handle
pQueueInfo must be a valid pointer to a valid VkDeviceQueueInfo2 structure
pQueue must be a valid pointer to a VkQueue handle

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetDeviceQueue2

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetDisplayModeProperties2KHR(3)

Name

vkGetDisplayModeProperties2KHR - Query information about the available display modes.

C Specification

To query the properties of a device’s built-in display modes, call:

VkResult vkGetDisplayModeProperties2KHR(
    VkPhysicalDevice                            physicalDevice,
    VkDisplayKHR                                display,
    uint32_t*                                   pPropertyCount,
    VkDisplayModeProperties2KHR*                pProperties);

Parameters

physicalDevice is the physical device associated with display.
display is the display to query.
pPropertyCount is a pointer to an integer related to the number of display modes available or queried, as described below.
pProperties is either NULL or a pointer to an array of VkDisplayModeProperties2KHR structures.

Description

vkGetDisplayModeProperties2KHR behaves similarly to vkGetDisplayModePropertiesKHR, with the ability to return extended information via chained output structures.

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle
display must be a valid VkDisplayKHR handle
pPropertyCount must be a valid pointer to a uint32_t value
If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkDisplayModeProperties2KHR structures

Return Codes

VK_SUCCESS
VK_INCOMPLETE

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetDisplayModeProperties2KHR

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetDisplayModePropertiesKHR(3)

Name

vkGetDisplayModePropertiesKHR - Query the set of mode properties supported by the display

C Specification

Each display has one or more supported modes associated with it by default. These built-in modes are queried by calling:

VkResult vkGetDisplayModePropertiesKHR(
    VkPhysicalDevice                            physicalDevice,
    VkDisplayKHR                                display,
    uint32_t*                                   pPropertyCount,
    VkDisplayModePropertiesKHR*                 pProperties);

Parameters

physicalDevice is the physical device associated with display.
display is the display to query.
pPropertyCount is a pointer to an integer related to the number of display modes available or queried, as described below.
pProperties is either NULL or a pointer to an array of VkDisplayModePropertiesKHR structures.

Description

If pProperties is NULL, then the number of display modes available on the specified display for physicalDevice 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 the value of pPropertyCount is less than the number of display modes for physicalDevice, at most pPropertyCount structures will be written. If pPropertyCount is smaller than the number of display modes available on the specified display for physicalDevice, VK_INCOMPLETE will be returned instead of VK_SUCCESS to indicate that not all the available values were returned.

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle
display must be a valid VkDisplayKHR handle
pPropertyCount must be a valid pointer to a uint32_t value
If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkDisplayModePropertiesKHR structures

Return Codes

VK_SUCCESS
VK_INCOMPLETE

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetDisplayModePropertiesKHR

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetDisplayPlaneCapabilities2KHR(3)

Name

vkGetDisplayPlaneCapabilities2KHR - Query capabilities of a mode and plane combination

C Specification

To query the capabilities of a given mode and plane combination, call:

VkResult vkGetDisplayPlaneCapabilities2KHR(
    VkPhysicalDevice                            physicalDevice,
    const VkDisplayPlaneInfo2KHR*               pDisplayPlaneInfo,
    VkDisplayPlaneCapabilities2KHR*             pCapabilities);

Parameters

physicalDevice is the physical device associated with pDisplayPlaneInfo.
pDisplayPlaneInfo is a pointer to an instance of the VkDisplayPlaneInfo2KHR structure describing the plane and mode.
pCapabilities is a pointer to a VkDisplayPlaneCapabilities2KHR structure in which the capabilities are returned.

Description

vkGetDisplayPlaneCapabilities2KHR behaves similarly to vkGetDisplayPlaneCapabilitiesKHR, with the ability to specify extended inputs via chained input structures, and to return extended information via chained output structures.

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle
pDisplayPlaneInfo must be a valid pointer to a valid VkDisplayPlaneInfo2KHR structure
pCapabilities must be a valid pointer to a VkDisplayPlaneCapabilities2KHR structure

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetDisplayPlaneCapabilities2KHR

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetDisplayPlaneCapabilitiesKHR(3)

Name

vkGetDisplayPlaneCapabilitiesKHR - Query capabilities of a mode and plane combination

C Specification

Applications that wish to present directly to a display must select which layer, or “plane” of the display they wish to target, and a mode to use with the display. Each display supports at least one plane. The capabilities of a given mode and plane combination are determined by calling:

VkResult vkGetDisplayPlaneCapabilitiesKHR(
    VkPhysicalDevice                            physicalDevice,
    VkDisplayModeKHR                            mode,
    uint32_t                                    planeIndex,
    VkDisplayPlaneCapabilitiesKHR*              pCapabilities);

Parameters

physicalDevice is the physical device associated with display
mode is the display mode the application intends to program when using the specified plane. Note this parameter also implicitly specifies a display.
planeIndex is the plane which the application intends to use with the display, and is less than the number of display planes supported by the device.
pCapabilities is a pointer to a VkDisplayPlaneCapabilitiesKHR structure in which the capabilities are returned.

Description

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle
mode must be a valid VkDisplayModeKHR handle
pCapabilities must be a valid pointer to a VkDisplayPlaneCapabilitiesKHR structure

Host Synchronization

Host access to mode must be externally synchronized

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetDisplayPlaneCapabilitiesKHR

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetDisplayPlaneSupportedDisplaysKHR(3)

Name

vkGetDisplayPlaneSupportedDisplaysKHR - Query the list of displays a plane supports

C Specification

To determine which displays a plane is usable with, call

VkResult vkGetDisplayPlaneSupportedDisplaysKHR(
    VkPhysicalDevice                            physicalDevice,
    uint32_t                                    planeIndex,
    uint32_t*                                   pDisplayCount,
    VkDisplayKHR*                               pDisplays);

Parameters

physicalDevice is a physical device.
planeIndex is the plane which the application wishes to use, and must be in the range [0, physical device plane count - 1].
pDisplayCount is a pointer to an integer related to the number of displays available or queried, as described below.
pDisplays is either NULL or a pointer to an array of VkDisplayKHR handles.

Description

If pDisplays is NULL, then the number of displays usable with the specified planeIndex for physicalDevice is returned in pDisplayCount. Otherwise, pDisplayCount must point to a variable set by the user to the number of elements in the pDisplays array, and on return the variable is overwritten with the number of handles actually written to pDisplays. If the value of pDisplayCount is less than the number of display planes for physicalDevice, at most pDisplayCount handles will be written. If pDisplayCount is smaller than the number of displays usable with the specified planeIndex for physicalDevice, VK_INCOMPLETE will be returned instead of VK_SUCCESS to indicate that not all the available values were returned.

Valid Usage

planeIndex must be less than the number of display planes supported by the device as determined by calling vkGetPhysicalDeviceDisplayPlanePropertiesKHR

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle
pDisplayCount must be a valid pointer to a uint32_t value
If the value referenced by pDisplayCount is not 0, and pDisplays is not NULL, pDisplays must be a valid pointer to an array of pDisplayCount VkDisplayKHR handles

Return Codes

VK_SUCCESS
VK_INCOMPLETE

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetDisplayPlaneSupportedDisplaysKHR

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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

VK_EVENT_SET
VK_EVENT_RESET

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetEventStatus

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_DEVICE_LOST

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetFenceFdKHR(3)

Name

vkGetFenceFdKHR - Get a POSIX file descriptor handle for a fence

C Specification

To export a POSIX file descriptor representing the payload of a fence, call:

VkResult vkGetFenceFdKHR(
    VkDevice                                    device,
    const VkFenceGetFdInfoKHR*                  pGetFdInfo,
    int*                                        pFd);

Parameters

device is the logical device that created the fence being exported.
pGetFdInfo is a pointer to an instance of the VkFenceGetFdInfoKHR structure containing parameters of the export operation.
pFd will return the file descriptor representing the fence payload.

Description

Each call to vkGetFenceFdKHR must create a new file descriptor and transfer ownership of it to the application. To avoid leaking resources, the application must release ownership of the file descriptor when it is no longer needed.

Note

Ownership can be released in many ways. For example, the application can call close() on the file descriptor, or transfer ownership back to Vulkan by using the file descriptor to import a fence payload.

If pGetFdInfo->handleType is VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT and the fence is signaled at the time vkGetFenceFdKHR is called, pFd may return the value -1 instead of a valid file descriptor.

Where supported by the operating system, the implementation must set the file descriptor to be closed automatically when an execve system call is made.

Exporting a file descriptor from a fence may have side effects depending on the transference of the specified handle type, as described in Importing Fence State.

Valid Usage (Implicit)

device must be a valid VkDevice handle
pGetFdInfo must be a valid pointer to a valid VkFenceGetFdInfoKHR structure
pFd must be a valid pointer to a int value

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetFenceFdKHR

VK_ERROR_TOO_MANY_OBJECTS
VK_ERROR_OUT_OF_HOST_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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

VK_SUCCESS
VK_NOT_READY

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetFenceStatus

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_DEVICE_LOST

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetFenceWin32HandleKHR(3)

Name

vkGetFenceWin32HandleKHR - Get a Windows HANDLE for a fence

C Specification

To export a Windows handle representing the state of a fence, call:

VkResult vkGetFenceWin32HandleKHR(
    VkDevice                                    device,
    const VkFenceGetWin32HandleInfoKHR*         pGetWin32HandleInfo,
    HANDLE*                                     pHandle);

Parameters

device is the logical device that created the fence being exported.
pGetWin32HandleInfo is a pointer to an instance of the VkFenceGetWin32HandleInfoKHR structure containing parameters of the export operation.
pHandle will return the Windows handle representing the fence state.

Description

For handle types defined as NT handles, the handles returned by vkGetFenceWin32HandleKHR are owned by the application. To avoid leaking resources, the application must release ownership of them using the CloseHandle system call when they are no longer needed.

Exporting a Windows handle from a fence may have side effects depending on the transference of the specified handle type, as described in Importing Fence Payloads.

Valid Usage (Implicit)

device must be a valid VkDevice handle
pGetWin32HandleInfo must be a valid pointer to a valid VkFenceGetWin32HandleInfoKHR structure
pHandle must be a valid pointer to a HANDLE value

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetFenceWin32HandleKHR

VK_ERROR_TOO_MANY_OBJECTS
VK_ERROR_OUT_OF_HOST_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetImageMemoryRequirements(3)

Name

vkGetImageMemoryRequirements - Returns the memory requirements for specified Vulkan object

C Specification

To determine the memory requirements for an image resource which is not created with the VK_IMAGE_CREATE_DISJOINT_BIT flag set, 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

image must not have been created with the VK_IMAGE_CREATE_DISJOINT_BIT flag set

Valid Usage (Implicit)

device must be a valid VkDevice handle
image must be a valid VkImage handle
pMemoryRequirements must be a valid pointer to a VkMemoryRequirements structure
image must have been created, allocated, or retrieved from device

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetImageMemoryRequirements

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetImageMemoryRequirements2(3)

Name

vkGetImageMemoryRequirements2 - Returns the memory requirements for specified Vulkan object

C Specification

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

void vkGetImageMemoryRequirements2(
    VkDevice                                    device,
    const VkImageMemoryRequirementsInfo2*       pInfo,
    VkMemoryRequirements2*                      pMemoryRequirements);

or the equivalent command

void vkGetImageMemoryRequirements2KHR(
    VkDevice                                    device,
    const VkImageMemoryRequirementsInfo2*       pInfo,
    VkMemoryRequirements2*                      pMemoryRequirements);

Parameters

device is the logical device that owns the image.
pInfo is a pointer to an instance of the VkImageMemoryRequirementsInfo2 structure containing parameters required for the memory requirements query.
pMemoryRequirements points to an instance of the VkMemoryRequirements2 structure in which the memory requirements of the image object are returned.

Description

Valid Usage (Implicit)

device must be a valid VkDevice handle
pInfo must be a valid pointer to a valid VkImageMemoryRequirementsInfo2 structure
pMemoryRequirements must be a valid pointer to a VkMemoryRequirements2 structure

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetImageMemoryRequirements2

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

Unresolved directive in apispec.txt - include::vkGetImageMemoryRequirements2KHR.txt[]

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 implementation 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 valid pointer to a uint32_t value
If the value referenced by pSparseMemoryRequirementCount is not 0, and pSparseMemoryRequirements is not NULL, pSparseMemoryRequirements must be a valid pointer to an array of pSparseMemoryRequirementCount VkSparseImageMemoryRequirements structures
image must have been created, allocated, or retrieved from device

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetImageSparseMemoryRequirements

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetImageSparseMemoryRequirements2(3)

Name

vkGetImageSparseMemoryRequirements2 - Query the memory requirements for a sparse image

C Specification

To query sparse memory requirements for an image, call:

void vkGetImageSparseMemoryRequirements2(
    VkDevice                                    device,
    const VkImageSparseMemoryRequirementsInfo2* pInfo,
    uint32_t*                                   pSparseMemoryRequirementCount,
    VkSparseImageMemoryRequirements2*           pSparseMemoryRequirements);

or the equivalent command

void vkGetImageSparseMemoryRequirements2KHR(
    VkDevice                                    device,
    const VkImageSparseMemoryRequirementsInfo2* pInfo,
    uint32_t*                                   pSparseMemoryRequirementCount,
    VkSparseImageMemoryRequirements2*           pSparseMemoryRequirements);

Parameters

device is the logical device that owns the image.
pInfo is a pointer to an instance of the VkImageSparseMemoryRequirementsInfo2 structure containing parameters required for the memory requirements query.
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 VkSparseImageMemoryRequirements2 structures.

Description

Valid Usage (Implicit)

device must be a valid VkDevice handle
pInfo must be a valid pointer to a valid VkImageSparseMemoryRequirementsInfo2 structure
pSparseMemoryRequirementCount must be a valid pointer to a uint32_t value
If the value referenced by pSparseMemoryRequirementCount is not 0, and pSparseMemoryRequirements is not NULL, pSparseMemoryRequirements must be a valid pointer to an array of pSparseMemoryRequirementCount VkSparseImageMemoryRequirements2 structures

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetImageSparseMemoryRequirements2

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

Unresolved directive in apispec.txt - include::vkGetImageSparseMemoryRequirements2KHR.txt[]

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

If the VkFormat of image is a multi-planar format, vkGetImageSubresourceLayout describes one plane of the image.

vkGetImageSubresourceLayout is invariant for the lifetime of a single image. However, the subresource layout of images in Android hardware buffer external memory is not known until the image has been bound to memory, so calling vkGetImageSubresourceLayout for such an image before it has been bound will result in undefined behavior.

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
The mipLevel member of pSubresource must be less than the mipLevels specified in VkImageCreateInfo when image was created
The arrayLayer member of pSubresource must be less than the arrayLayers specified in VkImageCreateInfo when image was created
If the format of image is a multi-planar format with two planes, the aspectMask member of pSubresource must be VK_IMAGE_ASPECT_PLANE_0_BIT or VK_IMAGE_ASPECT_PLANE_1_BIT
If the format of image is a multi-planar format with three planes, the aspectMask member of pSubresource must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT or VK_IMAGE_ASPECT_PLANE_2_BIT
If image was created with the VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID external memory handle type, then image must be bound to memory.

Valid Usage (Implicit)

device must be a valid VkDevice handle
image must be a valid VkImage handle
pSubresource must be a valid pointer to a valid VkImageSubresource structure
pLayout must be a valid pointer to a VkSubresourceLayout structure
image must have been created, allocated, or retrieved from device

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetImageSubresourceLayout

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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.

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`	vkEnumerateInstanceVersion	fp
`NULL`	vkEnumerateInstanceExtensionProperties	fp
`NULL`	vkEnumerateInstanceLayerProperties	fp
`NULL`	vkCreateInstance	fp
`NULL`	* (any `pName` not covered above)	`NULL`
instance	core Vulkan command	fp¹
instance	enabled instance extension commands for `instance`	fp¹
instance	available device extension² commands for `instance`	fp¹
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 device extension” is a device extension supported by any physical device enumerated by instance.

Valid Usage (Implicit)

If instance is not NULL, instance must be a valid VkInstance handle
pName must be a null-terminated UTF-8 string

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetInstanceProcAddr

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetMemoryAndroidHardwareBufferANDROID(3)

Name

vkGetMemoryAndroidHardwareBufferANDROID - Get an Android hardware buffer for a memory object

C Specification

To export an Android hardware buffer representing the underlying resources of a Vulkan device memory object, call:

VkResult vkGetMemoryAndroidHardwareBufferANDROID(
    VkDevice                                    device,
    const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
    struct AHardwareBuffer**                    pBuffer);

Parameters

device is the logical device that created the device memory being exported.
pInfo is a pointer to an instance of the VkMemoryGetAndroidHardwareBufferInfoANDROID structure containing parameters of the export operation.
pBuffer will return an Android hardware buffer representing the underlying resources of the device memory object.

Description

Each call to vkGetMemoryAndroidHardwareBufferANDROID must return an Android hardware buffer with a new reference acquired in addition to the reference held by the VkDeviceMemory. To avoid leaking resources, the application must release the reference by calling AHardwareBuffer_release when it is no longer needed. When called with the same handle in VkMemoryGetAndroidHardwareBufferInfoANDROID::memory, vkGetMemoryAndroidHardwareBufferANDROID must return the same Android hardware buffer object. If the device memory was created by importing an Android hardware buffer, vkGetMemoryAndroidHardwareBufferANDROID must return that same Android hardware buffer object.

Valid Usage (Implicit)

device must be a valid VkDevice handle
pInfo must be a valid pointer to a valid VkMemoryGetAndroidHardwareBufferInfoANDROID structure
pBuffer must be a valid pointer to a valid pointer to a AHardwareBuffer value

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetMemoryAndroidHardwareBufferANDROID

VK_ERROR_TOO_MANY_OBJECTS
VK_ERROR_OUT_OF_HOST_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetMemoryFdKHR(3)

Name

vkGetMemoryFdKHR - Get a POSIX file descriptor for a memory object

C Specification

To export a POSIX file descriptor representing the underlying resources of a Vulkan device memory object, call:

VkResult vkGetMemoryFdKHR(
    VkDevice                                    device,
    const VkMemoryGetFdInfoKHR*                 pGetFdInfo,
    int*                                        pFd);

Parameters

device is the logical device that created the device memory being exported.
pGetFdInfo is a pointer to an instance of the VkMemoryGetFdInfoKHR structure containing parameters of the export operation.
pFd will return a file descriptor representing the underlying resources of the device memory object.

Description

Each call to vkGetMemoryFdKHR must create a new file descriptor and transfer ownership of it to the application. To avoid leaking resources, the application must release ownership of the file descriptor using the close system call when it is no longer needed, or by importing a Vulkan memory object from it. Where supported by the operating system, the implementation must set the file descriptor to be closed automatically when an execve system call is made.

Valid Usage (Implicit)

device must be a valid VkDevice handle
pGetFdInfo must be a valid pointer to a valid VkMemoryGetFdInfoKHR structure
pFd must be a valid pointer to a int value

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetMemoryFdKHR

VK_ERROR_TOO_MANY_OBJECTS
VK_ERROR_OUT_OF_HOST_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetMemoryFdPropertiesKHR(3)

Name

vkGetMemoryFdPropertiesKHR - Get Properties of External Memory File Descriptors

C Specification

POSIX file descriptor memory handles compatible with Vulkan may also be created by non-Vulkan APIs using methods beyond the scope of this specification. To determine the correct parameters to use when importing such handles, call:

VkResult vkGetMemoryFdPropertiesKHR(
    VkDevice                                    device,
    VkExternalMemoryHandleTypeFlagBits          handleType,
    int                                         fd,
    VkMemoryFdPropertiesKHR*                    pMemoryFdProperties);

Parameters

device is the logical device that will be importing fd.
handleType is the type of the handle fd.
fd is the handle which will be imported.
pMemoryFdProperties will return properties of the handle fd.

Description

Valid Usage

fd must be an external memory handle created outside of the Vulkan API.
handleType must not be VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR.

Valid Usage (Implicit)

device must be a valid VkDevice handle
handleType must be a valid VkExternalMemoryHandleTypeFlagBits value
pMemoryFdProperties must be a valid pointer to a VkMemoryFdPropertiesKHR structure

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetMemoryFdPropertiesKHR

VK_ERROR_INVALID_EXTERNAL_HANDLE

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetMemoryHostPointerPropertiesEXT(3)

Name

vkGetMemoryHostPointerPropertiesEXT - Get properties of external memory host pointer

C Specification

To determine the correct parameters to use when importing host pointers, call:

VkResult vkGetMemoryHostPointerPropertiesEXT(
    VkDevice                                    device,
    VkExternalMemoryHandleTypeFlagBits          handleType,
    const void*                                 pHostPointer,
    VkMemoryHostPointerPropertiesEXT*           pMemoryHostPointerProperties);

Parameters

device is the logical device that will be importing pHostPointer.
handleType is the type of the handle pHostPointer.
pHostPointer is the host pointer to import from.

Description

Valid Usage

handleType must be VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT or VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT
pHostPointer must be a pointer aligned to an integer multiple of VkPhysicalDeviceExternalMemoryHostPropertiesEXT::minImportedHostPointerAlignment
If handleType is VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT, pHostPointer must be a pointer to host memory
If handleType is VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT, pHostPointer must be a pointer to host mapped foreign memory

Valid Usage (Implicit)

device must be a valid VkDevice handle
handleType must be a valid VkExternalMemoryHandleTypeFlagBits value
pMemoryHostPointerProperties must be a valid pointer to a VkMemoryHostPointerPropertiesEXT structure

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetMemoryHostPointerPropertiesEXT

VK_ERROR_INVALID_EXTERNAL_HANDLE

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetMemoryWin32HandleKHR(3)

Name

vkGetMemoryWin32HandleKHR - Get a Windows HANDLE for a memory object

C Specification

To export a Windows handle representing the underlying resources of a Vulkan device memory object, call:

VkResult vkGetMemoryWin32HandleKHR(
    VkDevice                                    device,
    const VkMemoryGetWin32HandleInfoKHR*        pGetWin32HandleInfo,
    HANDLE*                                     pHandle);

Parameters

device is the logical device that created the device memory being exported.
pGetWin32HandleInfo is a pointer to an instance of the VkMemoryGetWin32HandleInfoKHR structure containing parameters of the export operation.
pHandle will return the Windows handle representing the underlying resources of the device memory object.

Description

For handle types defined as NT handles, the handles returned by vkGetMemoryWin32HandleKHR are owned by the application. To avoid leaking resources, the application must release ownership of them using the CloseHandle system call when they are no longer needed.

Valid Usage (Implicit)

device must be a valid VkDevice handle
pGetWin32HandleInfo must be a valid pointer to a valid VkMemoryGetWin32HandleInfoKHR structure
pHandle must be a valid pointer to a HANDLE value

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetMemoryWin32HandleKHR

VK_ERROR_TOO_MANY_OBJECTS
VK_ERROR_OUT_OF_HOST_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetMemoryWin32HandleNV(3)

Name

vkGetMemoryWin32HandleNV - retrieve Win32 handle to a device memory object

C Specification

To retrieve the handle corresponding to a device memory object created with VkExportMemoryAllocateInfoNV::handleTypes set to include VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV or VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV, call:

VkResult vkGetMemoryWin32HandleNV(
    VkDevice                                    device,
    VkDeviceMemory                              memory,
    VkExternalMemoryHandleTypeFlagsNV           handleType,
    HANDLE*                                     pHandle);

Parameters

device is the logical device that owns the memory.
memory is the VkDeviceMemory object.
handleType is a bitmask of VkExternalMemoryHandleTypeFlagBitsNV containing a single bit specifying the type of handle requested.
handle points to a Windows HANDLE in which the handle is returned.

Description

Valid Usage

handleType must be a flag specified in VkExportMemoryAllocateInfoNV::handleTypes when allocating memory

Valid Usage (Implicit)

device must be a valid VkDevice handle
memory must be a valid VkDeviceMemory handle
handleType must be a valid combination of VkExternalMemoryHandleTypeFlagBitsNV values
handleType must not be 0
pHandle must be a valid pointer to a HANDLE value
memory must have been created, allocated, or retrieved from device

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetMemoryWin32HandleNV

VK_ERROR_TOO_MANY_OBJECTS
VK_ERROR_OUT_OF_HOST_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetMemoryWin32HandlePropertiesKHR(3)

Name

vkGetMemoryWin32HandlePropertiesKHR - Get Properties of External Memory Win32 Handles

C Specification

Windows memory handles compatible with Vulkan may also be created by non-Vulkan APIs using methods beyond the scope of this specification. To determine the correct parameters to use when importing such handles, call:

VkResult vkGetMemoryWin32HandlePropertiesKHR(
    VkDevice                                    device,
    VkExternalMemoryHandleTypeFlagBits          handleType,
    HANDLE                                      handle,
    VkMemoryWin32HandlePropertiesKHR*           pMemoryWin32HandleProperties);

Parameters

device is the logical device that will be importing handle.
handleType is the type of the handle handle.
handle is the handle which will be imported.
pMemoryWin32HandleProperties will return properties of handle.

Description

Valid Usage

handle must be an external memory handle created outside of the Vulkan API.
handleType must not be one of the handle types defined as opaque.

Valid Usage (Implicit)

device must be a valid VkDevice handle
handleType must be a valid VkExternalMemoryHandleTypeFlagBits value
pMemoryWin32HandleProperties must be a valid pointer to a VkMemoryWin32HandlePropertiesKHR structure

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetMemoryWin32HandlePropertiesKHR

VK_ERROR_INVALID_EXTERNAL_HANDLE

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetPastPresentationTimingGOOGLE(3)

Name

vkGetPastPresentationTimingGOOGLE - Obtain timing of a previously-presented image

C Specification

The implementation will maintain a limited amount of history of timing information about previous presents. Because of the asynchronous nature of the presentation engine, the timing information for a given vkQueuePresentKHR command will become available some time later. These time values can be asynchronously queried, and will be returned if available. All time values are in nanoseconds, relative to a monotonically-increasing clock (e.g. CLOCK_MONOTONIC (see clock_gettime(2)) on Android and Linux).

To asynchronously query the presentation engine, for newly-available timing information about one or more previous presents to a given swapchain, call:

VkResult vkGetPastPresentationTimingGOOGLE(
    VkDevice                                    device,
    VkSwapchainKHR                              swapchain,
    uint32_t*                                   pPresentationTimingCount,
    VkPastPresentationTimingGOOGLE*             pPresentationTimings);

Parameters

device is the device associated with swapchain.
swapchain is the swapchain to obtain presentation timing information duration for.
pPresentationTimingCount is a pointer to an integer related to the number of VkPastPresentationTimingGOOGLE structures to query, as described below.
pPresentationTimings is either NULL or a pointer to an array of VkPastPresentationTimingGOOGLE structures.

Description

If pPresentationTimings is NULL, then the number of newly-available timing records for the given swapchain is returned in pPresentationTimingCount. Otherwise, pPresentationTimingCount must point to a variable set by the user to the number of elements in the pPresentationTimings array, and on return the variable is overwritten with the number of structures actually written to pPresentationTimings. If the value of pPresentationTimingCount is less than the number of newly-available timing records, at most pPresentationTimingCount structures will be written. If pPresentationTimingCount is smaller than the number of newly-available timing records for the given swapchain, VK_INCOMPLETE will be returned instead of VK_SUCCESS to indicate that not all the available values were returned.

Valid Usage (Implicit)

device must be a valid VkDevice handle
swapchain must be a valid VkSwapchainKHR handle
pPresentationTimingCount must be a valid pointer to a uint32_t value
If the value referenced by pPresentationTimingCount is not 0, and pPresentationTimings is not NULL, pPresentationTimings must be a valid pointer to an array of pPresentationTimingCount VkPastPresentationTimingGOOGLE structures
Both of device, and swapchain must have been created, allocated, or retrieved from the same VkInstance

Host Synchronization

Host access to swapchain must be externally synchronized

Return Codes

VK_SUCCESS
VK_INCOMPLETE

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPastPresentationTimingGOOGLE

VK_ERROR_DEVICE_LOST
VK_ERROR_OUT_OF_DATE_KHR
VK_ERROR_SURFACE_LOST_KHR

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetPhysicalDeviceDisplayPlaneProperties2KHR(3)

Name

vkGetPhysicalDeviceDisplayPlaneProperties2KHR - Query information about the available display planes.

C Specification

To query the properties of a device’s display planes, call:

VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
    VkPhysicalDevice                            physicalDevice,
    uint32_t*                                   pPropertyCount,
    VkDisplayPlaneProperties2KHR*               pProperties);

Parameters

physicalDevice is a physical device.
pPropertyCount is a pointer to an integer related to the number of display planes available or queried, as described below.
pProperties is either NULL or a pointer to an array of VkDisplayPlaneProperties2KHR structures.

Description

vkGetPhysicalDeviceDisplayPlaneProperties2KHR behaves similarly to vkGetPhysicalDeviceDisplayPlanePropertiesKHR, with the ability to return extended information via chained output structures.

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle
pPropertyCount must be a valid pointer to a uint32_t value
If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkDisplayPlaneProperties2KHR structures

Return Codes

VK_SUCCESS
VK_INCOMPLETE

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPhysicalDeviceDisplayPlaneProperties2KHR

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetPhysicalDeviceDisplayPlanePropertiesKHR(3)

Name

vkGetPhysicalDeviceDisplayPlanePropertiesKHR - Query the plane properties

C Specification

Images are presented to individual planes on a display. Devices must support at least one plane on each display. Planes can be stacked and blended to composite multiple images on one display. Devices may support only a fixed stacking order and fixed mapping between planes and displays, or they may allow arbitrary application specified stacking orders and mappings between planes and displays. To query the properties of device display planes, call:

VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
    VkPhysicalDevice                            physicalDevice,
    uint32_t*                                   pPropertyCount,
    VkDisplayPlanePropertiesKHR*                pProperties);

Parameters

physicalDevice is a physical device.
pPropertyCount is a pointer to an integer related to the number of display planes available or queried, as described below.
pProperties is either NULL or a pointer to an array of VkDisplayPlanePropertiesKHR structures.

Description

If pProperties is NULL, then the number of display planes available for physicalDevice 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 the value of pPropertyCount is less than the number of display planes for physicalDevice, at most pPropertyCount structures will be written.

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle
pPropertyCount must be a valid pointer to a uint32_t value
If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkDisplayPlanePropertiesKHR structures

Return Codes

VK_SUCCESS
VK_INCOMPLETE

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPhysicalDeviceDisplayPlanePropertiesKHR

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetPhysicalDeviceDisplayProperties2KHR(3)

Name

vkGetPhysicalDeviceDisplayProperties2KHR - Query information about the available displays

C Specification

To query information about the available displays, call:

VkResult vkGetPhysicalDeviceDisplayProperties2KHR(
    VkPhysicalDevice                            physicalDevice,
    uint32_t*                                   pPropertyCount,
    VkDisplayProperties2KHR*                    pProperties);

Parameters

physicalDevice is a physical device.
pPropertyCount is a pointer to an integer related to the number of display devices available or queried, as described below.
pProperties is either NULL or a pointer to an array of VkDisplayProperties2KHR structures.

Description

vkGetPhysicalDeviceDisplayProperties2KHR behaves similarly to vkGetPhysicalDeviceDisplayPropertiesKHR, with the ability to return extended information via chained output structures.

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle
pPropertyCount must be a valid pointer to a uint32_t value
If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkDisplayProperties2KHR structures

Return Codes

VK_SUCCESS
VK_INCOMPLETE

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPhysicalDeviceDisplayProperties2KHR

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetPhysicalDeviceDisplayPropertiesKHR(3)

Name

vkGetPhysicalDeviceDisplayPropertiesKHR - Query information about the available displays

C Specification

Various functions are provided for enumerating the available display devices present on a Vulkan physical device. To query information about the available displays, call:

VkResult vkGetPhysicalDeviceDisplayPropertiesKHR(
    VkPhysicalDevice                            physicalDevice,
    uint32_t*                                   pPropertyCount,
    VkDisplayPropertiesKHR*                     pProperties);

Parameters

physicalDevice is a physical device.
pPropertyCount is a pointer to an integer related to the number of display devices available or queried, as described below.
pProperties is either NULL or a pointer to an array of VkDisplayPropertiesKHR structures.

Description

If pProperties is NULL, then the number of display devices available for physicalDevice 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 the value of pPropertyCount is less than the number of display devices for physicalDevice, at most pPropertyCount structures will be written. If pPropertyCount is smaller than the number of display devices available for physicalDevice, VK_INCOMPLETE will be returned instead of VK_SUCCESS to indicate that not all the available values were returned.

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle
pPropertyCount must be a valid pointer to a uint32_t value
If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkDisplayPropertiesKHR structures

Return Codes

VK_SUCCESS
VK_INCOMPLETE

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPhysicalDeviceDisplayPropertiesKHR

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetPhysicalDeviceExternalBufferProperties(3)

Name

vkGetPhysicalDeviceExternalBufferProperties - Query external handle types supported by buffers

C Specification

To query the external handle types supported by buffers, call:

void vkGetPhysicalDeviceExternalBufferProperties(
    VkPhysicalDevice                            physicalDevice,
    const VkPhysicalDeviceExternalBufferInfo*   pExternalBufferInfo,
    VkExternalBufferProperties*                 pExternalBufferProperties);

or the equivalent command

void vkGetPhysicalDeviceExternalBufferPropertiesKHR(
    VkPhysicalDevice                            physicalDevice,
    const VkPhysicalDeviceExternalBufferInfo*   pExternalBufferInfo,
    VkExternalBufferProperties*                 pExternalBufferProperties);

Parameters

physicalDevice is the physical device from which to query the buffer capabilities.
pExternalBufferInfo points to an instance of the VkPhysicalDeviceExternalBufferInfo structure, describing the parameters that would be consumed by vkCreateBuffer.
pExternalBufferProperties points to an instance of the VkExternalBufferProperties structure in which capabilities are returned.

Description

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle
pExternalBufferInfo must be a valid pointer to a valid VkPhysicalDeviceExternalBufferInfo structure
pExternalBufferProperties must be a valid pointer to a VkExternalBufferProperties structure

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPhysicalDeviceExternalBufferProperties

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

Unresolved directive in apispec.txt - include::vkGetPhysicalDeviceExternalBufferPropertiesKHR.txt[]

vkGetPhysicalDeviceExternalFenceProperties(3)

Name

vkGetPhysicalDeviceExternalFenceProperties - Function for querying external fence handle capabilities.

C Specification

Fences may support import and export of their payload to external handles. To query the external handle types supported by fences, call:

void vkGetPhysicalDeviceExternalFenceProperties(
    VkPhysicalDevice                            physicalDevice,
    const VkPhysicalDeviceExternalFenceInfo*    pExternalFenceInfo,
    VkExternalFenceProperties*                  pExternalFenceProperties);

or the equivalent command

void vkGetPhysicalDeviceExternalFencePropertiesKHR(
    VkPhysicalDevice                            physicalDevice,
    const VkPhysicalDeviceExternalFenceInfo*    pExternalFenceInfo,
    VkExternalFenceProperties*                  pExternalFenceProperties);

Parameters

physicalDevice is the physical device from which to query the fence capabilities.
pExternalFenceInfo points to an instance of the VkPhysicalDeviceExternalFenceInfo structure, describing the parameters that would be consumed by vkCreateFence.
pExternalFenceProperties points to an instance of the VkExternalFenceProperties structure in which capabilities are returned.

Description

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle
pExternalFenceInfo must be a valid pointer to a valid VkPhysicalDeviceExternalFenceInfo structure
pExternalFenceProperties must be a valid pointer to a VkExternalFenceProperties structure

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPhysicalDeviceExternalFenceProperties

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

Unresolved directive in apispec.txt - include::vkGetPhysicalDeviceExternalFencePropertiesKHR.txt[]

vkGetPhysicalDeviceExternalImageFormatPropertiesNV(3)

Name

vkGetPhysicalDeviceExternalImageFormatPropertiesNV - determine image capabilities compatible with external memory handle types

C Specification

To determine the image capabilities compatible with an external memory handle type, call:

VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
    VkPhysicalDevice                            physicalDevice,
    VkFormat                                    format,
    VkImageType                                 type,
    VkImageTiling                               tiling,
    VkImageUsageFlags                           usage,
    VkImageCreateFlags                          flags,
    VkExternalMemoryHandleTypeFlagsNV           externalHandleType,
    VkExternalImageFormatPropertiesNV*          pExternalImageFormatProperties);

Parameters

physicalDevice is the physical device from which to query the image capabilities
format is the image format, corresponding to VkImageCreateInfo::format.
type is the image type, corresponding to VkImageCreateInfo::imageType.
tiling is the image tiling, corresponding to VkImageCreateInfo::tiling.
usage is the intended usage of the image, corresponding to VkImageCreateInfo::usage.
flags is a bitmask describing additional parameters of the image, corresponding to VkImageCreateInfo::flags.
externalHandleType is either one of the bits from VkExternalMemoryHandleTypeFlagBitsNV, or 0.
pExternalImageFormatProperties points to an instance of the VkExternalImageFormatPropertiesNV structure in which capabilities are returned.

Description

If externalHandleType is 0, pExternalImageFormatProperties::imageFormatProperties will return the same values as a call to vkGetPhysicalDeviceImageFormatProperties, and the other members of pExternalImageFormatProperties will all be 0. Otherwise, they are filled in as described for VkExternalImageFormatPropertiesNV.

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
externalHandleType must be a valid combination of VkExternalMemoryHandleTypeFlagBitsNV values
pExternalImageFormatProperties must be a valid pointer to a VkExternalImageFormatPropertiesNV structure

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPhysicalDeviceExternalImageFormatPropertiesNV

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_FORMAT_NOT_SUPPORTED

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetPhysicalDeviceExternalSemaphoreProperties(3)

Name

vkGetPhysicalDeviceExternalSemaphoreProperties - Function for querying external semaphore handle capabilities.

C Specification

Semaphores may support import and export of their payload to external handles. To query the external handle types supported by semaphores, call:

void vkGetPhysicalDeviceExternalSemaphoreProperties(
    VkPhysicalDevice                            physicalDevice,
    const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
    VkExternalSemaphoreProperties*              pExternalSemaphoreProperties);

or the equivalent command

void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
    VkPhysicalDevice                            physicalDevice,
    const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
    VkExternalSemaphoreProperties*              pExternalSemaphoreProperties);

Parameters

physicalDevice is the physical device from which to query the semaphore capabilities.
pExternalSemaphoreInfo points to an instance of the VkPhysicalDeviceExternalSemaphoreInfo structure, describing the parameters that would be consumed by vkCreateSemaphore.
pExternalSemaphoreProperties points to an instance of the VkExternalSemaphoreProperties structure in which capabilities are returned.

Description

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle
pExternalSemaphoreInfo must be a valid pointer to a valid VkPhysicalDeviceExternalSemaphoreInfo structure
pExternalSemaphoreProperties must be a valid pointer to a VkExternalSemaphoreProperties structure

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPhysicalDeviceExternalSemaphoreProperties

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

Unresolved directive in apispec.txt - include::vkGetPhysicalDeviceExternalSemaphorePropertiesKHR.txt[]

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 specifies that the feature is supported on this physical device, and VK_FALSE specifies that the feature is not supported.

Description

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle
pFeatures must be a valid pointer to a VkPhysicalDeviceFeatures structure

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPhysicalDeviceFeatures

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetPhysicalDeviceFeatures2(3)

Name

vkGetPhysicalDeviceFeatures2 - Reports capabilities of a physical device

C Specification

To query supported features defined by the core or extensions, call:

void vkGetPhysicalDeviceFeatures2(
    VkPhysicalDevice                            physicalDevice,
    VkPhysicalDeviceFeatures2*                  pFeatures);

or the equivalent command

void vkGetPhysicalDeviceFeatures2KHR(
    VkPhysicalDevice                            physicalDevice,
    VkPhysicalDeviceFeatures2*                  pFeatures);

Parameters

physicalDevice is the physical device from which to query the supported features.
pFeatures is a pointer to a VkPhysicalDeviceFeatures2 structure in which the physical device features are returned.

Description

Each structure in pFeatures and its pNext chain contain members corresponding to fine-grained features. vkGetPhysicalDeviceFeatures2 writes each member to a boolean value indicating whether that feature is supported.

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle
pFeatures must be a valid pointer to a VkPhysicalDeviceFeatures2 structure

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPhysicalDeviceFeatures2

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

Unresolved directive in apispec.txt - include::vkGetPhysicalDeviceFeatures2KHR.txt[]

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 valid pointer to a VkFormatProperties structure

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPhysicalDeviceFormatProperties

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetPhysicalDeviceFormatProperties2(3)

Name

vkGetPhysicalDeviceFormatProperties2 - Lists physical device’s format capabilities

C Specification

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

void vkGetPhysicalDeviceFormatProperties2(
    VkPhysicalDevice                            physicalDevice,
    VkFormat                                    format,
    VkFormatProperties2*                        pFormatProperties);

or the equivalent command

void vkGetPhysicalDeviceFormatProperties2KHR(
    VkPhysicalDevice                            physicalDevice,
    VkFormat                                    format,
    VkFormatProperties2*                        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 VkFormatProperties2 structure in which physical device properties for format are returned.

Description

vkGetPhysicalDeviceFormatProperties2 behaves similarly to vkGetPhysicalDeviceFormatProperties, with the ability to return extended information in a pNext chain of output structures.

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle
format must be a valid VkFormat value
pFormatProperties must be a valid pointer to a VkFormatProperties2 structure

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPhysicalDeviceFormatProperties2

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

Unresolved directive in apispec.txt - include::vkGetPhysicalDeviceFormatProperties2KHR.txt[]

vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(3)

Name

vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX - Returns device-generated commands related properties of a physical device

C Specification

To query the support of related features and limitations, call:

void vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
    VkPhysicalDevice                            physicalDevice,
    VkDeviceGeneratedCommandsFeaturesNVX*       pFeatures,
    VkDeviceGeneratedCommandsLimitsNVX*         pLimits);

Parameters

physicalDevice is the handle to the physical device whose properties will be queried.
pFeatures points to an instance of the VkDeviceGeneratedCommandsFeaturesNVX structure, that will be filled with returned information.
pLimits points to an instance of the VkDeviceGeneratedCommandsLimitsNVX structure, that will be filled with returned information.

Description

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle
pFeatures must be a valid pointer to a VkDeviceGeneratedCommandsFeaturesNVX structure
pLimits must be a valid pointer to a VkDeviceGeneratedCommandsLimitsNVX structure

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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

physicalDevice is the physical device from which to query the image capabilities.
format is a VkFormat value specifying the image format, corresponding to VkImageCreateInfo::format.
type is a VkImageType value specifying the image type, corresponding to VkImageCreateInfo::imageType.
tiling is a VkImageTiling value specifying the image tiling, corresponding to VkImageCreateInfo::tiling.
usage is a bitmask of VkImageUsageFlagBits specifying the intended usage of the image, corresponding to VkImageCreateInfo::usage.
flags is a bitmask of VkImageCreateFlagBits specifying additional parameters of the image, corresponding to VkImageCreateInfo::flags.
pImageFormatProperties points to an instance of the VkImageFormatProperties structure in which capabilities are returned.

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 valid pointer to a VkImageFormatProperties structure

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPhysicalDeviceImageFormatProperties

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_FORMAT_NOT_SUPPORTED

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetPhysicalDeviceImageFormatProperties2(3)

Name

vkGetPhysicalDeviceImageFormatProperties2 - Lists physical device’s image format capabilities

C Specification

To query additional capabilities specific to image types, call:

VkResult vkGetPhysicalDeviceImageFormatProperties2(
    VkPhysicalDevice                            physicalDevice,
    const VkPhysicalDeviceImageFormatInfo2*     pImageFormatInfo,
    VkImageFormatProperties2*                   pImageFormatProperties);

or the equivalent command

VkResult vkGetPhysicalDeviceImageFormatProperties2KHR(
    VkPhysicalDevice                            physicalDevice,
    const VkPhysicalDeviceImageFormatInfo2*     pImageFormatInfo,
    VkImageFormatProperties2*                   pImageFormatProperties);

Parameters

physicalDevice is the physical device from which to query the image capabilities.
pImageFormatInfo points to an instance of the VkPhysicalDeviceImageFormatInfo2 structure, describing the parameters that would be consumed by vkCreateImage.
pImageFormatProperties points to an instance of the VkImageFormatProperties2 structure in which capabilities are returned.

Description

vkGetPhysicalDeviceImageFormatProperties2 behaves similarly to vkGetPhysicalDeviceImageFormatProperties, with the ability to return extended information in a pNext chain of output structures.

Valid Usage

If the pNext chain of pImageFormatProperties contains an instance of VkAndroidHardwareBufferUsageANDROID, the pNext chain of pImageFormatInfo must contain an instance of VkPhysicalDeviceExternalImageFormatInfo with handleType set to VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID.

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle
pImageFormatInfo must be a valid pointer to a valid VkPhysicalDeviceImageFormatInfo2 structure
pImageFormatProperties must be a valid pointer to a VkImageFormatProperties2 structure

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPhysicalDeviceImageFormatProperties2

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_FORMAT_NOT_SUPPORTED

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

Unresolved directive in apispec.txt - include::vkGetPhysicalDeviceImageFormatProperties2KHR.txt[]

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 valid pointer to a VkPhysicalDeviceMemoryProperties structure

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPhysicalDeviceMemoryProperties

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetPhysicalDeviceMemoryProperties2(3)

Name

vkGetPhysicalDeviceMemoryProperties2 - Reports memory information for the specified physical device

C Specification

To query memory properties, call:

void vkGetPhysicalDeviceMemoryProperties2(
    VkPhysicalDevice                            physicalDevice,
    VkPhysicalDeviceMemoryProperties2*          pMemoryProperties);

or the equivalent command

void vkGetPhysicalDeviceMemoryProperties2KHR(
    VkPhysicalDevice                            physicalDevice,
    VkPhysicalDeviceMemoryProperties2*          pMemoryProperties);

Parameters

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

Description

vkGetPhysicalDeviceMemoryProperties2 behaves similarly to vkGetPhysicalDeviceMemoryProperties, with the ability to return extended information in a pNext chain of output structures.

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle
pMemoryProperties must be a valid pointer to a VkPhysicalDeviceMemoryProperties2 structure

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPhysicalDeviceMemoryProperties2

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

Unresolved directive in apispec.txt - include::vkGetPhysicalDeviceMemoryProperties2KHR.txt[]

vkGetPhysicalDeviceMirPresentationSupportKHR(3)

Name

vkGetPhysicalDeviceMirPresentationSupportKHR - Query physical device for presentation to Mir

C Specification

To determine whether a queue family of a physical device supports presentation to the Mir compositor, call:

VkBool32 vkGetPhysicalDeviceMirPresentationSupportKHR(
    VkPhysicalDevice                            physicalDevice,
    uint32_t                                    queueFamilyIndex,
    MirConnection*                              connection);

Parameters

physicalDevice is the physical device.
queueFamilyIndex is the queue family index.
connection is a pointer to the MirConnection, and identifies the desired Mir compositor.

Description

This platform-specific function can be called prior to creating a surface.

Valid Usage

queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the given physicalDevice

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle
connection must be a valid pointer to a MirConnection value

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPhysicalDeviceMirPresentationSupportKHR

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetPhysicalDeviceMultisamplePropertiesEXT(3)

Name

vkGetPhysicalDeviceMultisamplePropertiesEXT - Report sample count specific multisampling capabilities of a physical device

C Specification

In addition to the minimum capabilities described in the previous section (Limits), implementations may support additional multisampling capabilities specific to a particular sample count.

To query additional sample count specific multisampling capabilities, call:

void vkGetPhysicalDeviceMultisamplePropertiesEXT(
    VkPhysicalDevice                            physicalDevice,
    VkSampleCountFlagBits                       samples,
    VkMultisamplePropertiesEXT*                 pMultisampleProperties);

Parameters

physicalDevice is the physical device from which to query the additional multisampling capabilities.
samples is the sample count to query the capabilities for.
pMultisampleProperties is a pointer to a structure of type VkMultisamplePropertiesEXT, in which information about the additional multisampling capabilities specific to the sample count is returned.

Description

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle
samples must be a valid VkSampleCountFlagBits value
pMultisampleProperties must be a valid pointer to a VkMultisamplePropertiesEXT structure

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPhysicalDeviceMultisamplePropertiesEXT

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetPhysicalDevicePresentRectanglesKHR(3)

Name

vkGetPhysicalDevicePresentRectanglesKHR - Query present rectangles for a surface on a physical device

C Specification

When using VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR, the application may need to know which regions of the surface are used when presenting locally on each physical device. Presentation of swapchain images to this surface need only have valid contents in the regions returned by this command.

To query a set of rectangles used in presentation on the physical device, call:

VkResult vkGetPhysicalDevicePresentRectanglesKHR(
    VkPhysicalDevice                            physicalDevice,
    VkSurfaceKHR                                surface,
    uint32_t*                                   pRectCount,
    VkRect2D*                                   pRects);

Parameters

physicalDevice is the physical device.
surface is the surface.
pRectCount is a pointer to an integer related to the number of rectangles available or queried, as described below.
pRects is either NULL or a pointer to an array of VkRect2D structures.

Description

If pRects is NULL, then the number of rectangles used when presenting the given surface is returned in pRectCount. Otherwise, pRectCount must point to a variable set by the user to the number of elements in the pRects array, and on return the variable is overwritten with the number of structures actually written to pRects. If the value of pRectCount is less than the number of rectangles, at most pRectCount structures will be written. If pRectCount is smaller than the number of rectangles used for the given surface, VK_INCOMPLETE will be returned instead of VK_SUCCESS to indicate that not all the available values were returned.

The values returned by this command are not invariant, and may change in response to the surface being moved, resized, or occluded.

The rectangles returned by this command must not overlap.

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle
surface must be a valid VkSurfaceKHR handle
pRectCount must be a valid pointer to a uint32_t value
If the value referenced by pRectCount is not 0, and pRects is not NULL, pRects must be a valid pointer to an array of pRectCount VkRect2D structures
Both of physicalDevice, and surface must have been created, allocated, or retrieved from the same VkInstance

Host Synchronization

Host access to surface must be externally synchronized

Return Codes

VK_SUCCESS
VK_INCOMPLETE

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPhysicalDevicePresentRectanglesKHR

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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 valid pointer to a VkPhysicalDeviceProperties structure

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPhysicalDeviceProperties

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetPhysicalDeviceProperties2(3)

Name

vkGetPhysicalDeviceProperties2 - Returns properties of a physical device

C Specification

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

void vkGetPhysicalDeviceProperties2(
    VkPhysicalDevice                            physicalDevice,
    VkPhysicalDeviceProperties2*                pProperties);

or the equivalent command

void vkGetPhysicalDeviceProperties2KHR(
    VkPhysicalDevice                            physicalDevice,
    VkPhysicalDeviceProperties2*                pProperties);

Parameters

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

Description

Each structure in pProperties and its pNext chain contain members corresponding to properties or implementation-dependent limits. vkGetPhysicalDeviceProperties2 writes each member to a value indicating the value of that property or limit.

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle
pProperties must be a valid pointer to a VkPhysicalDeviceProperties2 structure

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPhysicalDeviceProperties2

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

Unresolved directive in apispec.txt - include::vkGetPhysicalDeviceProperties2KHR.txt[]

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 valid pointer to a uint32_t value
If the value referenced by pQueueFamilyPropertyCount is not 0, and pQueueFamilyProperties is not NULL, pQueueFamilyProperties must be a valid pointer to an array of pQueueFamilyPropertyCount VkQueueFamilyProperties structures

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPhysicalDeviceQueueFamilyProperties

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetPhysicalDeviceQueueFamilyProperties2(3)

Name

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

C Specification

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

void vkGetPhysicalDeviceQueueFamilyProperties2(
    VkPhysicalDevice                            physicalDevice,
    uint32_t*                                   pQueueFamilyPropertyCount,
    VkQueueFamilyProperties2*                   pQueueFamilyProperties);

or the equivalent command

void vkGetPhysicalDeviceQueueFamilyProperties2KHR(
    VkPhysicalDevice                            physicalDevice,
    uint32_t*                                   pQueueFamilyPropertyCount,
    VkQueueFamilyProperties2*                   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 in vkGetPhysicalDeviceQueueFamilyProperties.
pQueueFamilyProperties is either NULL or a pointer to an array of VkQueueFamilyProperties2 structures.

Description

vkGetPhysicalDeviceQueueFamilyProperties2 behaves similarly to vkGetPhysicalDeviceQueueFamilyProperties, with the ability to return extended information in a pNext chain of output structures.

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle
pQueueFamilyPropertyCount must be a valid pointer to a uint32_t value
If the value referenced by pQueueFamilyPropertyCount is not 0, and pQueueFamilyProperties is not NULL, pQueueFamilyProperties must be a valid pointer to an array of pQueueFamilyPropertyCount VkQueueFamilyProperties2 structures

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPhysicalDeviceQueueFamilyProperties2

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

Unresolved directive in apispec.txt - include::vkGetPhysicalDeviceQueueFamilyProperties2KHR.txt[]

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 texel 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 valid pointer to a uint32_t value
If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkSparseImageFormatProperties structures

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPhysicalDeviceSparseImageFormatProperties

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetPhysicalDeviceSparseImageFormatProperties2(3)

Name

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

C Specification

vkGetPhysicalDeviceSparseImageFormatProperties2 returns an array of VkSparseImageFormatProperties2. 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 vkGetPhysicalDeviceSparseImageFormatProperties2(
    VkPhysicalDevice                            physicalDevice,
    const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
    uint32_t*                                   pPropertyCount,
    VkSparseImageFormatProperties2*             pProperties);

or the equivalent command

void vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
    VkPhysicalDevice                            physicalDevice,
    const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
    uint32_t*                                   pPropertyCount,
    VkSparseImageFormatProperties2*             pProperties);

Parameters

physicalDevice is the physical device from which to query the sparse image capabilities.
pFormatInfo is a pointer to a structure of type VkPhysicalDeviceSparseImageFormatInfo2 containing input parameters to the command.
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 VkSparseImageFormatProperties2 structures.

Description

vkGetPhysicalDeviceSparseImageFormatProperties2 behaves identically to vkGetPhysicalDeviceSparseImageFormatProperties, with the ability to return extended information by adding extension structures to the pNext chain of its pProperties parameter.

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle
pFormatInfo must be a valid pointer to a valid VkPhysicalDeviceSparseImageFormatInfo2 structure
pPropertyCount must be a valid pointer to a uint32_t value
If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkSparseImageFormatProperties2 structures

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPhysicalDeviceSparseImageFormatProperties2

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

Unresolved directive in apispec.txt - include::vkGetPhysicalDeviceSparseImageFormatProperties2KHR.txt[]

vkGetPhysicalDeviceSurfaceCapabilities2EXT(3)

Name

vkGetPhysicalDeviceSurfaceCapabilities2EXT - Query surface capabilities

C Specification

To query the basic capabilities of a surface, needed in order to create a swapchain, call:

VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT(
    VkPhysicalDevice                            physicalDevice,
    VkSurfaceKHR                                surface,
    VkSurfaceCapabilities2EXT*                  pSurfaceCapabilities);

Parameters

physicalDevice is the physical device that will be associated with the swapchain to be created, as described for vkCreateSwapchainKHR.
surface is the surface that will be associated with the swapchain.
pSurfaceCapabilities is a pointer to an instance of the VkSurfaceCapabilities2EXT structure in which the capabilities are returned.

Description

vkGetPhysicalDeviceSurfaceCapabilities2EXT behaves similarly to vkGetPhysicalDeviceSurfaceCapabilitiesKHR, with the ability to return extended information by adding extension structures to the pNext chain of its pSurfaceCapabilities parameter.

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle
surface must be a valid VkSurfaceKHR handle
pSurfaceCapabilities must be a valid pointer to a VkSurfaceCapabilities2EXT structure
Both of physicalDevice, and surface must have been created, allocated, or retrieved from the same VkInstance

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPhysicalDeviceSurfaceCapabilities2EXT

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_SURFACE_LOST_KHR

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetPhysicalDeviceSurfaceCapabilities2KHR(3)

Name

vkGetPhysicalDeviceSurfaceCapabilities2KHR - Reports capabilities of a surface on a physical device

C Specification

To query the basic capabilities of a surface defined by the core or extensions, call:

VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR(
    VkPhysicalDevice                            physicalDevice,
    const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
    VkSurfaceCapabilities2KHR*                  pSurfaceCapabilities);

Parameters

physicalDevice is the physical device that will be associated with the swapchain to be created, as described for vkCreateSwapchainKHR.
pSurfaceInfo points to an instance of the VkPhysicalDeviceSurfaceInfo2KHR structure, describing the surface and other fixed parameters that would be consumed by vkCreateSwapchainKHR.
pSurfaceCapabilities points to an instance of the VkSurfaceCapabilities2KHR structure in which the capabilities are returned.

Description

vkGetPhysicalDeviceSurfaceCapabilities2KHR behaves similarly to vkGetPhysicalDeviceSurfaceCapabilitiesKHR, with the ability to specify extended inputs via chained input structures, and to return extended information via chained output structures.

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle
pSurfaceInfo must be a valid pointer to a valid VkPhysicalDeviceSurfaceInfo2KHR structure
pSurfaceCapabilities must be a valid pointer to a VkSurfaceCapabilities2KHR structure

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPhysicalDeviceSurfaceCapabilities2KHR

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_SURFACE_LOST_KHR

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetPhysicalDeviceSurfaceCapabilitiesKHR(3)

Name

vkGetPhysicalDeviceSurfaceCapabilitiesKHR - Query surface capabilities

C Specification

To query the basic capabilities of a surface, needed in order to create a swapchain, call:

VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
    VkPhysicalDevice                            physicalDevice,
    VkSurfaceKHR                                surface,
    VkSurfaceCapabilitiesKHR*                   pSurfaceCapabilities);

Parameters

physicalDevice is the physical device that will be associated with the swapchain to be created, as described for vkCreateSwapchainKHR.
surface is the surface that will be associated with the swapchain.
pSurfaceCapabilities is a pointer to an instance of the VkSurfaceCapabilitiesKHR structure in which the capabilities are returned.

Description

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle
surface must be a valid VkSurfaceKHR handle
pSurfaceCapabilities must be a valid pointer to a VkSurfaceCapabilitiesKHR structure
Both of physicalDevice, and surface must have been created, allocated, or retrieved from the same VkInstance

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPhysicalDeviceSurfaceCapabilitiesKHR

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_SURFACE_LOST_KHR

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetPhysicalDeviceSurfaceFormats2KHR(3)

Name

vkGetPhysicalDeviceSurfaceFormats2KHR - Query color formats supported by surface

C Specification

To query the supported swapchain format tuples for a surface, call:

VkResult vkGetPhysicalDeviceSurfaceFormats2KHR(
    VkPhysicalDevice                            physicalDevice,
    const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
    uint32_t*                                   pSurfaceFormatCount,
    VkSurfaceFormat2KHR*                        pSurfaceFormats);

Parameters

physicalDevice is the physical device that will be associated with the swapchain to be created, as described for vkCreateSwapchainKHR.
pSurfaceInfo points to an instance of the VkPhysicalDeviceSurfaceInfo2KHR structure, describing the surface and other fixed parameters that would be consumed by vkCreateSwapchainKHR.
pSurfaceFormatCount is a pointer to an integer related to the number of format tuples available or queried, as described below.
pSurfaceFormats is either NULL or a pointer to an array of VkSurfaceFormat2KHR structures.

Description

If pSurfaceFormats is NULL, then the number of format tuples supported for the given surface is returned in pSurfaceFormatCount. The number of format tuples supported will be greater than or equal to 1. Otherwise, pSurfaceFormatCount must point to a variable set by the user to the number of elements in the pSurfaceFormats array, and on return the variable is overwritten with the number of structures actually written to pSurfaceFormats. If the value of pSurfaceFormatCount is less than the number of format tuples supported, at most pSurfaceFormatCount structures will be written. If pSurfaceFormatCount is smaller than the number of format tuples supported for the surface parameters described in pSurfaceInfo, VK_INCOMPLETE will be returned instead of VK_SUCCESS to indicate that not all the available values were returned.

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle
pSurfaceInfo must be a valid pointer to a valid VkPhysicalDeviceSurfaceInfo2KHR structure
pSurfaceFormatCount must be a valid pointer to a uint32_t value
If the value referenced by pSurfaceFormatCount is not 0, and pSurfaceFormats is not NULL, pSurfaceFormats must be a valid pointer to an array of pSurfaceFormatCount VkSurfaceFormat2KHR structures

Return Codes

VK_SUCCESS
VK_INCOMPLETE

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPhysicalDeviceSurfaceFormats2KHR

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_SURFACE_LOST_KHR

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetPhysicalDeviceSurfaceFormatsKHR(3)

Name

vkGetPhysicalDeviceSurfaceFormatsKHR - Query color formats supported by surface

C Specification

To query the supported swapchain format-color space pairs for a surface, call:

VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(
    VkPhysicalDevice                            physicalDevice,
    VkSurfaceKHR                                surface,
    uint32_t*                                   pSurfaceFormatCount,
    VkSurfaceFormatKHR*                         pSurfaceFormats);

Parameters

physicalDevice is the physical device that will be associated with the swapchain to be created, as described for vkCreateSwapchainKHR.
surface is the surface that will be associated with the swapchain.
pSurfaceFormatCount is a pointer to an integer related to the number of format pairs available or queried, as described below.
pSurfaceFormats is either NULL or a pointer to an array of VkSurfaceFormatKHR structures.

Description

If pSurfaceFormats is NULL, then the number of format pairs supported for the given surface is returned in pSurfaceFormatCount. The number of format pairs supported will be greater than or equal to 1. Otherwise, pSurfaceFormatCount must point to a variable set by the user to the number of elements in the pSurfaceFormats array, and on return the variable is overwritten with the number of structures actually written to pSurfaceFormats. If the value of pSurfaceFormatCount is less than the number of format pairs supported, at most pSurfaceFormatCount structures will be written. If pSurfaceFormatCount is smaller than the number of format pairs supported for the given surface, VK_INCOMPLETE will be returned instead of VK_SUCCESS to indicate that not all the available values were returned.

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle
surface must be a valid VkSurfaceKHR handle
pSurfaceFormatCount must be a valid pointer to a uint32_t value
If the value referenced by pSurfaceFormatCount is not 0, and pSurfaceFormats is not NULL, pSurfaceFormats must be a valid pointer to an array of pSurfaceFormatCount VkSurfaceFormatKHR structures
Both of physicalDevice, and surface must have been created, allocated, or retrieved from the same VkInstance

Return Codes

VK_SUCCESS
VK_INCOMPLETE

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPhysicalDeviceSurfaceFormatsKHR

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_SURFACE_LOST_KHR

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetPhysicalDeviceSurfacePresentModesKHR(3)

Name

vkGetPhysicalDeviceSurfacePresentModesKHR - Query supported presentation modes

C Specification

To query the supported presentation modes for a surface, call:

VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(
    VkPhysicalDevice                            physicalDevice,
    VkSurfaceKHR                                surface,
    uint32_t*                                   pPresentModeCount,
    VkPresentModeKHR*                           pPresentModes);

Parameters

physicalDevice is the physical device that will be associated with the swapchain to be created, as described for vkCreateSwapchainKHR.
surface is the surface that will be associated with the swapchain.
pPresentModeCount is a pointer to an integer related to the number of presentation modes available or queried, as described below.
pPresentModes is either NULL or a pointer to an array of VkPresentModeKHR values, indicating the supported presentation modes.

Description

If pPresentModes is NULL, then the number of presentation modes supported for the given surface is returned in pPresentModeCount. Otherwise, pPresentModeCount must point to a variable set by the user to the number of elements in the pPresentModes array, and on return the variable is overwritten with the number of values actually written to pPresentModes. If the value of pPresentModeCount is less than the number of presentation modes supported, at most pPresentModeCount values will be written. If pPresentModeCount is smaller than the number of presentation modes supported for the given surface, VK_INCOMPLETE will be returned instead of VK_SUCCESS to indicate that not all the available values were returned.

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle
surface must be a valid VkSurfaceKHR handle
pPresentModeCount must be a valid pointer to a uint32_t value
If the value referenced by pPresentModeCount is not 0, and pPresentModes is not NULL, pPresentModes must be a valid pointer to an array of pPresentModeCount VkPresentModeKHR values
Both of physicalDevice, and surface must have been created, allocated, or retrieved from the same VkInstance

Return Codes

VK_SUCCESS
VK_INCOMPLETE

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPhysicalDeviceSurfacePresentModesKHR

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_SURFACE_LOST_KHR

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetPhysicalDeviceSurfaceSupportKHR(3)

Name

vkGetPhysicalDeviceSurfaceSupportKHR - Query if presentation is supported

C Specification

To determine whether a queue family of a physical device supports presentation to a given surface, call:

VkResult vkGetPhysicalDeviceSurfaceSupportKHR(
    VkPhysicalDevice                            physicalDevice,
    uint32_t                                    queueFamilyIndex,
    VkSurfaceKHR                                surface,
    VkBool32*                                   pSupported);

Parameters

physicalDevice is the physical device.
queueFamilyIndex is the queue family.
surface is the surface.
pSupported is a pointer to a VkBool32, which is set to VK_TRUE to indicate support, and VK_FALSE otherwise.

Description

Valid Usage

queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the given physicalDevice

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle
surface must be a valid VkSurfaceKHR handle
pSupported must be a valid pointer to a VkBool32 value
Both of physicalDevice, and surface must have been created, allocated, or retrieved from the same VkInstance

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPhysicalDeviceSurfaceSupportKHR

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_SURFACE_LOST_KHR

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetPhysicalDeviceWaylandPresentationSupportKHR(3)

Name

vkGetPhysicalDeviceWaylandPresentationSupportKHR - Query physical device for presentation to Wayland

C Specification

To determine whether a queue family of a physical device supports presentation to a Wayland compositor, call:

VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR(
    VkPhysicalDevice                            physicalDevice,
    uint32_t                                    queueFamilyIndex,
    struct wl_display*                          display);

Parameters

physicalDevice is the physical device.
queueFamilyIndex is the queue family index.
display is a pointer to the wl_display associated with a Wayland compositor.

Description

This platform-specific function can be called prior to creating a surface.

Valid Usage

queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the given physicalDevice

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle
display must be a valid pointer to a wl_display value

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPhysicalDeviceWaylandPresentationSupportKHR

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetPhysicalDeviceWin32PresentationSupportKHR(3)

Name

vkGetPhysicalDeviceWin32PresentationSupportKHR - query queue family support for presentation on a Win32 display

C Specification

To determine whether a queue family of a physical device supports presentation to the Microsoft Windows desktop, call:

VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR(
    VkPhysicalDevice                            physicalDevice,
    uint32_t                                    queueFamilyIndex);

Parameters

physicalDevice is the physical device.
queueFamilyIndex is the queue family index.

Description

This platform-specific function can be called prior to creating a surface.

Valid Usage

queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the given physicalDevice

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPhysicalDeviceWin32PresentationSupportKHR

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetPhysicalDeviceXcbPresentationSupportKHR(3)

Name

vkGetPhysicalDeviceXcbPresentationSupportKHR - Query physical device for presentation to X11 server using XCB

C Specification

To determine whether a queue family of a physical device supports presentation to an X11 server, using the XCB client-side library, call:

VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR(
    VkPhysicalDevice                            physicalDevice,
    uint32_t                                    queueFamilyIndex,
    xcb_connection_t*                           connection,
    xcb_visualid_t                              visual_id);

Parameters

physicalDevice is the physical device.
queueFamilyIndex is the queue family index.
connection is a pointer to an xcb_connection_t to the X server. visual_id is an X11 visual (xcb_visualid_t).

Description

This platform-specific function can be called prior to creating a surface.

Valid Usage

queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the given physicalDevice

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle
connection must be a valid pointer to a xcb_connection_t value

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPhysicalDeviceXcbPresentationSupportKHR

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetPhysicalDeviceXlibPresentationSupportKHR(3)

Name

vkGetPhysicalDeviceXlibPresentationSupportKHR - Query physical device for presentation to X11 server using Xlib

C Specification

To determine whether a queue family of a physical device supports presentation to an X11 server, using the Xlib client-side library, call:

VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR(
    VkPhysicalDevice                            physicalDevice,
    uint32_t                                    queueFamilyIndex,
    Display*                                    dpy,
    VisualID                                    visualID);

Parameters

physicalDevice is the physical device.
queueFamilyIndex is the queue family index.
dpy is a pointer to an Xlib Display connection to the server.
visualId is an X11 visual (VisualID).

Description

This platform-specific function can be called prior to creating a surface.

Valid Usage

queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the given physicalDevice

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle
dpy must be a valid pointer to a Display value

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPhysicalDeviceXlibPresentationSupportKHR

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

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	a device ID equal to `VkPhysicalDeviceProperties`::`deviceID` written as a stream of bytes, with the least significant byte first
16	`VK_UUID_SIZE`	a pipeline cache ID equal to `VkPhysicalDeviceProperties`::`pipelineCacheUUID`

The first four bytes encode the length of the entire pipeline cache header, in bytes. This value includes all fields in the header including the pipeline cache version field and the size of the length field.

The next four bytes encode the pipeline cache version, as described for VkPipelineCacheHeaderVersion. A consumer of the pipeline cache should use the cache version to interpret the remainder of the cache header.

If pDataSize is less than what is necessary to store this header, nothing will be written to pData and zero will be written to pDataSize.

Valid Usage (Implicit)

device must be a valid VkDevice handle
pipelineCache must be a valid VkPipelineCache handle
pDataSize must be a valid pointer to a size_t value
If the value referenced by pDataSize is not 0, and pData is not NULL, pData must be a valid pointer to an array of pDataSize bytes
pipelineCache must have been created, allocated, or retrieved from device

Return Codes

VK_SUCCESS
VK_INCOMPLETE

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPipelineCacheData

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetQueryPoolResults(3)

Name

vkGetQueryPoolResults - Copy results of queries in a query pool to a host memory region

C Specification

To retrieve status and results for a set of queries, call:

VkResult vkGetQueryPoolResults(
    VkDevice                                    device,
    VkQueryPool                                 queryPool,
    uint32_t                                    firstQuery,
    uint32_t                                    queryCount,
    size_t                                      dataSize,
    void*                                       pData,
    VkDeviceSize                                stride,
    VkQueryResultFlags                          flags);

Parameters

device is the logical device that owns the query pool.
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. For pipeline statistics queries, each query index in the pool contains one integer value for each bit that is enabled in VkQueryPoolCreateInfo::pipelineStatistics when the pool is created.
dataSize is the size in bytes of the buffer pointed to by pData.
pData is a pointer to a user-allocated buffer where the results will be written
stride is the stride in bytes between results for individual queries within pData.
flags is a bitmask of VkQueryResultFlagBits specifying how and when results are returned.

Description

If no bits are set in flags, and all requested queries are in the available state, results are written as an array of 32-bit unsigned integer values. The behavior when not all queries are available, is described below.

If VK_QUERY_RESULT_64_BIT is not set and the result overflows a 32-bit value, the value may either wrap or saturate. Similarly, if VK_QUERY_RESULT_64_BIT is set and the result overflows a 64-bit value, the value may either wrap or saturate.

If VK_QUERY_RESULT_WAIT_BIT is set, Vulkan will wait for each query to be in the available state before retrieving the numerical results for that query. In this case, vkGetQueryPoolResults is guaranteed to succeed and return VK_SUCCESS if the queries become available in a finite time (i.e. if they have been issued and not reset). If queries will never finish (e.g. due to being reset but not issued), then vkGetQueryPoolResults may not return in finite time.

If VK_QUERY_RESULT_WAIT_BIT and VK_QUERY_RESULT_PARTIAL_BIT are both not set then no result values are written to pData for queries that are in the unavailable state at the time of the call, and vkGetQueryPoolResults returns VK_NOT_READY. However, availability state is still written to pData for those queries if VK_QUERY_RESULT_WITH_AVAILABILITY_BIT is set.

Note

Applications must take care to ensure that use of the VK_QUERY_RESULT_WAIT_BIT bit has the desired effect.

For example, if a query has been used previously and a command buffer records the commands vkCmdResetQueryPool, vkCmdBeginQuery, and vkCmdEndQuery for that query, then the query will remain in the available state until the vkCmdResetQueryPool command executes on a queue. Applications can use fences or events to ensure that a query has already been reset before checking for its results or availability status. Otherwise, a stale value could be returned from a previous use of the query.

The above also applies when VK_QUERY_RESULT_WAIT_BIT is used in combination with VK_QUERY_RESULT_WITH_AVAILABILITY_BIT. In this case, the returned availability status may reflect the result of a previous use of the query unless the vkCmdResetQueryPool command has been executed since the last use of the query.

Note

Applications can double-buffer query pool usage, with a pool per frame, and reset queries at the end of the frame in which they are read.

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

If VK_QUERY_RESULT_WITH_AVAILABILITY_BIT is set, the final integer value written for each query is non-zero if the query’s status was available or zero if the status was unavailable. When VK_QUERY_RESULT_WITH_AVAILABILITY_BIT is used, implementations must guarantee that if they return a non-zero availability value then the numerical results must be valid, assuming the results are not reset by a subsequent command.

Note

Satisfying this guarantee may require careful ordering by the application, e.g. to read the availability status before reading the results.

Valid Usage

firstQuery must be less than the number of queries in queryPool
If VK_QUERY_RESULT_64_BIT is not set in flags then pData and stride must be multiples of 4
If VK_QUERY_RESULT_64_BIT is set in flags then pData and stride must be multiples of 8
The sum of firstQuery and queryCount must be less than or equal to the number of queries in queryPool
dataSize must be large enough to contain the result of each query, as described here
If the queryType used to create queryPool was VK_QUERY_TYPE_TIMESTAMP, flags must not contain VK_QUERY_RESULT_PARTIAL_BIT

Valid Usage (Implicit)

device must be a valid VkDevice handle
queryPool must be a valid VkQueryPool handle
pData must be a valid pointer to an array of dataSize bytes
flags must be a valid combination of VkQueryResultFlagBits values
dataSize must be greater than 0
queryPool must have been created, allocated, or retrieved from device

Return Codes

VK_SUCCESS
VK_NOT_READY

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetQueryPoolResults

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_DEVICE_LOST

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetQueueCheckpointDataNV(3)

Name

vkGetQueueCheckpointDataNV - retrieve diagnostic checkpoint data

C Specification

If the device encounters an error during execution, the implementation will return a VK_ERROR_DEVICE_LOST error to the application at a certain point during host execution. When this happens, the application can call vkGetQueueCheckpointDataNV to retrieve information on the most recent diagnostic checkpoints that were executed by the device.

void vkGetQueueCheckpointDataNV(
    VkQueue                                     queue,
    uint32_t*                                   pCheckpointDataCount,
    VkCheckpointDataNV*                         pCheckpointData);

Parameters

queue is the VkQueue object the caller would like to retrieve checkpoint data for
pCheckpointDataCount is a pointer to an integer related to the number of checkpoint markers available or queried, as described below.
pCheckpointData is either NULL or a pointer to an array of VkCheckpointDataNV structures.

Description

If pCheckpointData is NULL, then the number of checkpoint markers available is returned in pCheckpointDataCount.

Otherwise, pCheckpointDataCount must point to a variable set by the user to the number of elements in the pCheckpointData array, and on return the variable is overwritten with the number of structures actually written to pCheckpointData.

If pCheckpointDataCount is less than the number of checkpoint markers available, at most pCheckpointDataCount structures will be written.

Valid Usage

The device that queue belongs to must be in the lost state

Valid Usage (Implicit)

queue must be a valid VkQueue handle
pCheckpointDataCount must be a valid pointer to a uint32_t value
If the value referenced by pCheckpointDataCount is not 0, and pCheckpointData is not NULL, pCheckpointData must be a valid pointer to an array of pCheckpointDataCount VkCheckpointDataNV structures

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetQueueCheckpointDataNV

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetRandROutputDisplayEXT(3)

Name

vkGetRandROutputDisplayEXT - Query the VkDisplayKHR corresponding to an X11 RandR Output

C Specification

When acquiring displays from an X11 server, an application may also wish to enumerate and identify them using a native handle rather than a VkDisplayKHR handle. To determine the VkDisplayKHR handle corresponding to an X11 RandR Output, call:

VkResult vkGetRandROutputDisplayEXT(
    VkPhysicalDevice                            physicalDevice,
    Display*                                    dpy,
    RROutput                                    rrOutput,
    VkDisplayKHR*                               pDisplay);

Parameters

physicalDevice The physical device to query the display handle on.
dpy A connection to the X11 server from which rrOutput was queried.
rrOutput An X11 RandR output ID.
pDisplay The corresponding VkDisplayKHR handle will be returned here.

Description

If there is no VkDisplayKHR corresponding to rrOutput on physicalDevice, VK_NULL_HANDLE must be returned in pDisplay.

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle
dpy must be a valid pointer to a Display value
pDisplay must be a valid pointer to a VkDisplayKHR handle

Return Codes

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetRandROutputDisplayEXT

VK_SUCCESS

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetRefreshCycleDurationGOOGLE(3)

Name

vkGetRefreshCycleDurationGOOGLE - Obtain the RC duration of the PE’s display

C Specification

To query the duration of a refresh cycle (RC) for the presentation engine’s display, call:

VkResult vkGetRefreshCycleDurationGOOGLE(
    VkDevice                                    device,
    VkSwapchainKHR                              swapchain,
    VkRefreshCycleDurationGOOGLE*               pDisplayTimingProperties);

Parameters

device is the device associated with swapchain.
swapchain is the swapchain to obtain the refresh duration for.
pDisplayTimingProperties is a pointer to an instance of the VkRefreshCycleDurationGOOGLE structure.

Description

Valid Usage (Implicit)

device must be a valid VkDevice handle
swapchain must be a valid VkSwapchainKHR handle
pDisplayTimingProperties must be a valid pointer to a VkRefreshCycleDurationGOOGLE structure
Both of device, and swapchain must have been created, allocated, or retrieved from the same VkInstance

Host Synchronization

Host access to swapchain must be externally synchronized

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetRefreshCycleDurationGOOGLE

VK_ERROR_DEVICE_LOST
VK_ERROR_SURFACE_LOST_KHR

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetRenderAreaGranularity(3)

Name

vkGetRenderAreaGranularity - Returns the granularity for optimal render area

C Specification

To query the render area granularity, call:

void vkGetRenderAreaGranularity(
    VkDevice                                    device,
    VkRenderPass                                renderPass,
    VkExtent2D*                                 pGranularity);

Parameters

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

Description

The conditions leading to an optimal renderArea are:

the offset.x member in renderArea is a multiple of the width member of the returned VkExtent2D (the horizontal granularity).
the offset.y member in renderArea is a multiple of the height of the returned VkExtent2D (the vertical granularity).
either the offset.width member in renderArea is a multiple of the horizontal granularity or offset.x+offset.width is equal to the width of the framebuffer in the VkRenderPassBeginInfo.
either the offset.height member in renderArea is a multiple of the vertical granularity or offset.y+offset.height is equal to the height of the framebuffer in the VkRenderPassBeginInfo.

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

Valid Usage (Implicit)

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

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetRenderAreaGranularity

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetSemaphoreFdKHR(3)

Name

vkGetSemaphoreFdKHR - Get a POSIX file descriptor handle for a semaphore

C Specification

To export a POSIX file descriptor representing the payload of a semaphore, call:

VkResult vkGetSemaphoreFdKHR(
    VkDevice                                    device,
    const VkSemaphoreGetFdInfoKHR*              pGetFdInfo,
    int*                                        pFd);

Parameters

device is the logical device that created the semaphore being exported.
pGetFdInfo is a pointer to an instance of the VkSemaphoreGetFdInfoKHR structure containing parameters of the export operation.
pFd will return the file descriptor representing the semaphore payload.

Description

Each call to vkGetSemaphoreFdKHR must create a new file descriptor and transfer ownership of it to the application. To avoid leaking resources, the application must release ownership of the file descriptor when it is no longer needed.

Note

Where supported by the operating system, the implementation must set the file descriptor to be closed automatically when an execve system call is made.

Exporting a file descriptor from a semaphore may have side effects depending on the transference of the specified handle type, as described in Importing Semaphore State.

Valid Usage (Implicit)

device must be a valid VkDevice handle
pGetFdInfo must be a valid pointer to a valid VkSemaphoreGetFdInfoKHR structure
pFd must be a valid pointer to a int value

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetSemaphoreFdKHR

VK_ERROR_TOO_MANY_OBJECTS
VK_ERROR_OUT_OF_HOST_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetSemaphoreWin32HandleKHR(3)

Name

vkGetSemaphoreWin32HandleKHR - Get a Windows HANDLE for a semaphore

C Specification

To export a Windows handle representing the payload of a semaphore, call:

VkResult vkGetSemaphoreWin32HandleKHR(
    VkDevice                                    device,
    const VkSemaphoreGetWin32HandleInfoKHR*     pGetWin32HandleInfo,
    HANDLE*                                     pHandle);

Parameters

device is the logical device that created the semaphore being exported.
pGetWin32HandleInfo is a pointer to an instance of the VkSemaphoreGetWin32HandleInfoKHR structure containing parameters of the export operation.
pHandle will return the Windows handle representing the semaphore state.

Description

For handle types defined as NT handles, the handles returned by vkGetSemaphoreWin32HandleKHR are owned by the application. To avoid leaking resources, the application must release ownership of them using the CloseHandle system call when they are no longer needed.

Exporting a Windows handle from a semaphore may have side effects depending on the transference of the specified handle type, as described in Importing Semaphore Payloads.

Valid Usage (Implicit)

device must be a valid VkDevice handle
pGetWin32HandleInfo must be a valid pointer to a valid VkSemaphoreGetWin32HandleInfoKHR structure
pHandle must be a valid pointer to a HANDLE value

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetSemaphoreWin32HandleKHR

VK_ERROR_TOO_MANY_OBJECTS
VK_ERROR_OUT_OF_HOST_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetShaderInfoAMD(3)

Name

vkGetShaderInfoAMD - Get information about a shader in a pipeline

C Specification

Information about a particular shader that has been compiled as part of a pipeline object can be extracted by calling:

VkResult vkGetShaderInfoAMD(
    VkDevice                                    device,
    VkPipeline                                  pipeline,
    VkShaderStageFlagBits                       shaderStage,
    VkShaderInfoTypeAMD                         infoType,
    size_t*                                     pInfoSize,
    void*                                       pInfo);

Parameters

device is the device that created pipeline.
pipeline is the target of the query.
shaderStage identifies the particular shader within the pipeline about which information is being queried.
infoType describes what kind of information is being queried.
pInfoSize is a pointer to a value related to the amount of data the query returns, as described below.
pInfo is either NULL or a pointer to a buffer.

Description

If pInfo is NULL, then the maximum size of the information that can be retrieved about the shader, in bytes, is returned in pInfoSize. Otherwise, pInfoSize must point to a variable set by the user to the size of the buffer, in bytes, pointed to by pInfo, and on return the variable is overwritten with the amount of data actually written to pInfo.

If pInfoSize is less than the maximum size that can be retrieved by the pipeline cache, then at most pInfoSize bytes will be written to pInfo, and vkGetShaderInfoAMD will return VK_INCOMPLETE.

Not all information is available for every shader and implementations may not support all kinds of information for any shader. When a certain type of information is unavailable, the function returns VK_ERROR_FEATURE_NOT_PRESENT.

If information is successfully and fully queried, the function will return VK_SUCCESS.

For VK_SHADER_INFO_TYPE_STATISTICS_AMD, an instance of VkShaderStatisticsInfoAMD will be written to the buffer pointed to by pInfo. This structure will be populated with statistics regarding the physical device resources used by that shader along with other miscellaneous information and is described in further detail below.

For VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD, pInfo points to a UTF-8 null-terminated string containing human-readable disassembly. The exact formatting and contents of the disassembly string are vendor-specific.

The formatting and contents of all other types of information, including VK_SHADER_INFO_TYPE_BINARY_AMD, are left to the vendor and are not further specified by this extension.

Valid Usage (Implicit)

device must be a valid VkDevice handle
pipeline must be a valid VkPipeline handle
shaderStage must be a valid VkShaderStageFlagBits value
infoType must be a valid VkShaderInfoTypeAMD value
pInfoSize must be a valid pointer to a size_t value
If the value referenced by pInfoSize is not 0, and pInfo is not NULL, pInfo must be a valid pointer to an array of pInfoSize bytes
pipeline must have been created, allocated, or retrieved from device

Return Codes

VK_SUCCESS
VK_INCOMPLETE

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetShaderInfoAMD

VK_ERROR_FEATURE_NOT_PRESENT
VK_ERROR_OUT_OF_HOST_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetSwapchainCounterEXT(3)

Name

vkGetSwapchainCounterEXT - Query the current value of a surface counter

C Specification

The requested counters become active when the first presentation command for the associated swapchain is processed by the presentation engine. To query the value of an active counter, use:

VkResult vkGetSwapchainCounterEXT(
    VkDevice                                    device,
    VkSwapchainKHR                              swapchain,
    VkSurfaceCounterFlagBitsEXT                 counter,
    uint64_t*                                   pCounterValue);

Parameters

device is the VkDevice associated with swapchain.
swapchain is the swapchain from which to query the counter value.
counter is the counter to query.
pCounterValue will return the current value of the counter.

Description

If a counter is not available because the swapchain is out of date, the implementation may return VK_ERROR_OUT_OF_DATE_KHR.

Valid Usage

One or more present commands on swapchain must have been processed by the presentation engine.

Valid Usage (Implicit)

device must be a valid VkDevice handle
swapchain must be a valid VkSwapchainKHR handle
counter must be a valid VkSurfaceCounterFlagBitsEXT value
pCounterValue must be a valid pointer to a uint64_t value
Both of device, and swapchain must have been created, allocated, or retrieved from the same VkInstance

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetSwapchainCounterEXT

VK_ERROR_DEVICE_LOST
VK_ERROR_OUT_OF_DATE_KHR

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetSwapchainImagesKHR(3)

Name

vkGetSwapchainImagesKHR - Obtain the array of presentable images associated with a swapchain

C Specification

To obtain the array of presentable images associated with a swapchain, call:

VkResult vkGetSwapchainImagesKHR(
    VkDevice                                    device,
    VkSwapchainKHR                              swapchain,
    uint32_t*                                   pSwapchainImageCount,
    VkImage*                                    pSwapchainImages);

Parameters

device is the device associated with swapchain.
swapchain is the swapchain to query.
pSwapchainImageCount is a pointer to an integer related to the number of presentable images available or queried, as described below.
pSwapchainImages is either NULL or a pointer to an array of VkImage handles.

Description

If pSwapchainImages is NULL, then the number of presentable images for swapchain is returned in pSwapchainImageCount. Otherwise, pSwapchainImageCount must point to a variable set by the user to the number of elements in the pSwapchainImages array, and on return the variable is overwritten with the number of structures actually written to pSwapchainImages. If the value of pSwapchainImageCount is less than the number of presentable images for swapchain, at most pSwapchainImageCount structures will be written. If pSwapchainImageCount is smaller than the number of presentable images for swapchain, VK_INCOMPLETE will be returned instead of VK_SUCCESS to indicate that not all the available values were returned.

Valid Usage (Implicit)

device must be a valid VkDevice handle
swapchain must be a valid VkSwapchainKHR handle
pSwapchainImageCount must be a valid pointer to a uint32_t value
If the value referenced by pSwapchainImageCount is not 0, and pSwapchainImages is not NULL, pSwapchainImages must be a valid pointer to an array of pSwapchainImageCount VkImage handles
Both of device, and swapchain must have been created, allocated, or retrieved from the same VkInstance

Return Codes

VK_SUCCESS
VK_INCOMPLETE

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetSwapchainImagesKHR

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetSwapchainStatusKHR(3)

Name

vkGetSwapchainStatusKHR - Get a swapchain’s status

C Specification

In order to query a swapchain’s status when rendering to a shared presentable image, call:

VkResult vkGetSwapchainStatusKHR(
    VkDevice                                    device,
    VkSwapchainKHR                              swapchain);

Parameters

device is the device associated with swapchain.
swapchain is the swapchain to query.

Description

Valid Usage (Implicit)

device must be a valid VkDevice handle
swapchain must be a valid VkSwapchainKHR handle
Both of device, and swapchain must have been created, allocated, or retrieved from the same VkInstance

Host Synchronization

Host access to swapchain must be externally synchronized

Return Codes

VK_SUCCESS
VK_SUBOPTIMAL_KHR

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetSwapchainStatusKHR

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_DEVICE_LOST
VK_ERROR_OUT_OF_DATE_KHR
VK_ERROR_SURFACE_LOST_KHR

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkGetValidationCacheDataEXT(3)

Name

vkGetValidationCacheDataEXT - Get the data store from a validation cache

C Specification

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

VkResult vkGetValidationCacheDataEXT(
    VkDevice                                    device,
    VkValidationCacheEXT                        validationCache,
    size_t*                                     pDataSize,
    void*                                       pData);

Parameters

device is the logical device that owns the validation cache.
validationCache is the validation cache to retrieve data from.
pDataSize is a pointer to a value related to the amount of data in the validation 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 validation 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 validation cache, at most pDataSize bytes will be written to pData, and vkGetValidationCacheDataEXT will return VK_INCOMPLETE. Any data written to pData is valid and can be provided as the pInitialData member of the VkValidationCacheCreateInfoEXT structure passed to vkCreateValidationCacheEXT.

Two calls to vkGetValidationCacheDataEXT 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 validation cache, and use these data, possibly in a future run of the application, to populate new validation cache objects. The results of validation, 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 6. Layout for validation cache header version `VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT`
Offset	Size	Meaning
0	4	length in bytes of the entire validation cache header written as a stream of bytes, with the least significant byte first
4	4	a VkValidationCacheHeaderVersionEXT value written as a stream of bytes, with the least significant byte first
8	`VK_UUID_SIZE`	a layer commit ID expressed as a UUID, which uniquely identifies the version of the validation layers used to generate these validation results

The first four bytes encode the length of the entire validation cache header, in bytes. This value includes all fields in the header including the validation cache version field and the size of the length field.

The next four bytes encode the validation cache version, as described for VkValidationCacheHeaderVersionEXT. A consumer of the validation cache should use the cache version to interpret the remainder of the cache header.

If pDataSize is less than what is necessary to store this header, nothing will be written to pData and zero will be written to pDataSize.

Valid Usage (Implicit)

device must be a valid VkDevice handle
validationCache must be a valid VkValidationCacheEXT handle
pDataSize must be a valid pointer to a size_t value
If the value referenced by pDataSize is not 0, and pData is not NULL, pData must be a valid pointer to an array of pDataSize bytes
validationCache must have been created, allocated, or retrieved from device

Return Codes

VK_SUCCESS
VK_INCOMPLETE

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetValidationCacheDataEXT

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkImportFenceFdKHR(3)

Name

vkImportFenceFdKHR - Import a fence from a POSIX file descriptor

C Specification

To import a fence payload from a POSIX file descriptor, call:

VkResult vkImportFenceFdKHR(
    VkDevice                                    device,
    const VkImportFenceFdInfoKHR*               pImportFenceFdInfo);

Parameters

device is the logical device that created the fence.
pImportFenceFdInfo points to a VkImportFenceFdInfoKHR structure specifying the fence and import parameters.

Description

Importing a fence payload from a file descriptor transfers ownership of the file descriptor from the application to the Vulkan implementation. The application must not perform any operations on the file descriptor after a successful import.

Applications can import the same fence payload into multiple instances of Vulkan, into the same instance from which it was exported, and multiple times into a given Vulkan instance.

Valid Usage

fence must not be associated with any queue command that has not yet completed execution on that queue

Valid Usage (Implicit)

device must be a valid VkDevice handle
pImportFenceFdInfo must be a valid pointer to a valid VkImportFenceFdInfoKHR structure

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkImportFenceFdKHR

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_INVALID_EXTERNAL_HANDLE

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkImportFenceWin32HandleKHR(3)

Name

vkImportFenceWin32HandleKHR - Import a fence from a Windows HANDLE

C Specification

To import a fence payload from a Windows handle, call:

VkResult vkImportFenceWin32HandleKHR(
    VkDevice                                    device,
    const VkImportFenceWin32HandleInfoKHR*      pImportFenceWin32HandleInfo);

Parameters

device is the logical device that created the fence.
pImportFenceWin32HandleInfo points to a VkImportFenceWin32HandleInfoKHR structure specifying the fence and import parameters.

Description

Importing a fence payload from Windows handles does not transfer ownership of the handle to the Vulkan implementation. For handle types defined as NT handles, the application must release ownership using the CloseHandle system call when the handle is no longer needed.

Applications can import the same fence payload into multiple instances of Vulkan, into the same instance from which it was exported, and multiple times into a given Vulkan instance.

Valid Usage (Implicit)

device must be a valid VkDevice handle
pImportFenceWin32HandleInfo must be a valid pointer to a valid VkImportFenceWin32HandleInfoKHR structure

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkImportFenceWin32HandleKHR

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_INVALID_EXTERNAL_HANDLE

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkImportSemaphoreFdKHR(3)

Name

vkImportSemaphoreFdKHR - Import a semaphore from a POSIX file descriptor

C Specification

To import a semaphore payload from a POSIX file descriptor, call:

VkResult vkImportSemaphoreFdKHR(
    VkDevice                                    device,
    const VkImportSemaphoreFdInfoKHR*           pImportSemaphoreFdInfo);

Parameters

device is the logical device that created the semaphore.
pImportSemaphoreFdInfo points to a VkImportSemaphoreFdInfoKHR structure specifying the semaphore and import parameters.

Description

Importing a semaphore payload from a file descriptor transfers ownership of the file descriptor from the application to the Vulkan implementation. The application must not perform any operations on the file descriptor after a successful import.

Applications can import the same semaphore payload into multiple instances of Vulkan, into the same instance from which it was exported, and multiple times into a given Vulkan instance.

Valid Usage

semaphore must not be associated with any queue command that has not yet completed execution on that queue

Valid Usage (Implicit)

device must be a valid VkDevice handle
pImportSemaphoreFdInfo must be a valid pointer to a valid VkImportSemaphoreFdInfoKHR structure

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkImportSemaphoreFdKHR

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_INVALID_EXTERNAL_HANDLE

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkImportSemaphoreWin32HandleKHR(3)

Name

vkImportSemaphoreWin32HandleKHR - Import a semaphore from a Windows HANDLE

C Specification

To import a semaphore payload from a Windows handle, call:

VkResult vkImportSemaphoreWin32HandleKHR(
    VkDevice                                    device,
    const VkImportSemaphoreWin32HandleInfoKHR*  pImportSemaphoreWin32HandleInfo);

Parameters

device is the logical device that created the semaphore.
pImportSemaphoreWin32HandleInfo points to a VkImportSemaphoreWin32HandleInfoKHR structure specifying the semaphore and import parameters.

Description

Importing a semaphore payload from Windows handles does not transfer ownership of the handle to the Vulkan implementation. For handle types defined as NT handles, the application must release ownership using the CloseHandle system call when the handle is no longer needed.

Applications can import the same semaphore payload into multiple instances of Vulkan, into the same instance from which it was exported, and multiple times into a given Vulkan instance.

Valid Usage (Implicit)

device must be a valid VkDevice handle
pImportSemaphoreWin32HandleInfo must be a valid pointer to a valid VkImportSemaphoreWin32HandleInfoKHR structure

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkImportSemaphoreWin32HandleKHR

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_INVALID_EXTERNAL_HANDLE

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkInvalidateMappedMemoryRanges(3)

Name

vkInvalidateMappedMemoryRanges - Invalidate ranges of mapped memory objects

C Specification

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

VkResult vkInvalidateMappedMemoryRanges(
    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 invalidate.

Description

vkInvalidateMappedMemoryRanges guarantees that device writes to the memory ranges described by pMemoryRanges, which have been made visible to the VK_ACCESS_HOST_WRITE_BIT and VK_ACCESS_HOST_READ_BIT access types, are made visible to the host. If a range of non-coherent memory is written by the host and then invalidated without first being flushed, its contents are undefined.

Within each range described by pMemoryRanges, each set of nonCoherentAtomSize bytes in that range is invalidated if any byte in that set has been written by the device since it was first mapped, or the last time it was invalidated.

Note

Mapping non-coherent memory does not implicitly invalidate the mapped memory, and device writes that have not been invalidated must be made visible before the host reads or overwrites them.

Valid Usage (Implicit)

device must be a valid VkDevice handle
pMemoryRanges must be a valid pointer to an array of memoryRangeCount valid VkMappedMemoryRange structures
memoryRangeCount must be greater than 0

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkInvalidateMappedMemoryRanges

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkMapMemory(3)

Name

vkMapMemory - Map a memory object into application address space

C Specification

To retrieve a host virtual address pointer to a region of a mappable memory object, call:

VkResult vkMapMemory(
    VkDevice                                    device,
    VkDeviceMemory                              memory,
    VkDeviceSize                                offset,
    VkDeviceSize                                size,
    VkMemoryMapFlags                            flags,
    void**                                      ppData);

Parameters

device is the logical device that owns the memory.
memory is the VkDeviceMemory object to be mapped.
offset is a zero-based byte offset from the beginning of the memory object.
size is the size of the memory range to map, or VK_WHOLE_SIZE to map from offset to the end of the allocation.
flags is reserved for future use.
ppData points to a pointer in which is returned a host-accessible pointer to the beginning of the mapped range. This pointer minus offset must be aligned to at least VkPhysicalDeviceLimits::minMemoryMapAlignment.

Description

It is an application error to call vkMapMemory on a memory object that is already mapped.

Note

vkMapMemory will fail if the implementation is unable to allocate an appropriately sized contiguous virtual address range, e.g. due to virtual address space fragmentation or platform limits. In such cases, vkMapMemory must return VK_ERROR_MEMORY_MAP_FAILED. The application can improve the likelihood of success by reducing the size of the mapped range and/or removing unneeded mappings using VkUnmapMemory.

vkMapMemory does not check whether the device memory is currently in use before returning the host-accessible pointer. The application must guarantee that any previously submitted command that writes to this range has completed before the host reads from or writes to that range, and that any previously submitted command that reads from that range has completed before the host writes to that region (see here for details on fulfilling such a guarantee). If the device memory was allocated without the VK_MEMORY_PROPERTY_HOST_COHERENT_BIT set, these guarantees must be made for an extended range: the application must round down the start of the range to the nearest multiple of VkPhysicalDeviceLimits::nonCoherentAtomSize, and round the end of the range up to the nearest multiple of VkPhysicalDeviceLimits::nonCoherentAtomSize.

While a range of device memory is mapped for host access, the application is responsible for synchronizing both device and host access to that memory range.

Note

It is important for the application developer to become meticulously familiar with all of the mechanisms described in the chapter on Synchronization and Cache Control as they are crucial to maintaining memory access ordering.

Valid Usage

memory must not be currently mapped
offset must be less than the size of memory
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 the memory minus offset
memory must have been created with a memory type that reports VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
memory must not have been allocated with multiple instances.

Valid Usage (Implicit)

device must be a valid VkDevice handle
memory must be a valid VkDeviceMemory handle
flags must be 0
ppData must be a valid pointer to a pointer value
memory must have been created, allocated, or retrieved from device

Host Synchronization

Host access to memory must be externally synchronized

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkMapMemory

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_MEMORY_MAP_FAILED

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkMergePipelineCaches(3)

Name

vkMergePipelineCaches - Combine the data stores of pipeline caches

C Specification

Pipeline cache objects can be merged using the command:

VkResult vkMergePipelineCaches(
    VkDevice                                    device,
    VkPipelineCache                             dstCache,
    uint32_t                                    srcCacheCount,
    const VkPipelineCache*                      pSrcCaches);

Parameters

device is the logical device that owns the pipeline cache objects.
dstCache is the handle of the pipeline cache to merge results into.
srcCacheCount is the length of the pSrcCaches array.
pSrcCaches is an array of pipeline cache handles, which will be merged into dstCache. The previous contents of dstCache are included after the merge.

Description

Note

The details of the merge operation are implementation dependent, but implementations should merge the contents of the specified pipelines and prune duplicate entries.

Valid Usage

dstCache must not appear in the list of source caches

Valid Usage (Implicit)

device must be a valid VkDevice handle
dstCache must be a valid VkPipelineCache handle
pSrcCaches must be a valid pointer to an array of srcCacheCount valid VkPipelineCache handles
srcCacheCount must be greater than 0
dstCache must have been created, allocated, or retrieved from device
Each element of pSrcCaches must have been created, allocated, or retrieved from device

Host Synchronization

Host access to dstCache must be externally synchronized

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkMergePipelineCaches

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkMergeValidationCachesEXT(3)

Name

vkMergeValidationCachesEXT - Combine the data stores of validation caches

C Specification

Validation cache objects can be merged using the command:

VkResult vkMergeValidationCachesEXT(
    VkDevice                                    device,
    VkValidationCacheEXT                        dstCache,
    uint32_t                                    srcCacheCount,
    const VkValidationCacheEXT*                 pSrcCaches);

Parameters

device is the logical device that owns the validation cache objects.
dstCache is the handle of the validation cache to merge results into.
srcCacheCount is the length of the pSrcCaches array.
pSrcCaches is an array of validation cache handles, which will be merged into dstCache. The previous contents of dstCache are included after the merge.

Description

Note

The details of the merge operation are implementation dependent, but implementations should merge the contents of the specified validation caches and prune duplicate entries.

Valid Usage

dstCache must not appear in the list of source caches

Valid Usage (Implicit)

device must be a valid VkDevice handle
dstCache must be a valid VkValidationCacheEXT handle
pSrcCaches must be a valid pointer to an array of srcCacheCount valid VkValidationCacheEXT handles
srcCacheCount must be greater than 0
dstCache must have been created, allocated, or retrieved from device
Each element of pSrcCaches must have been created, allocated, or retrieved from device

Host Synchronization

Host access to dstCache must be externally synchronized

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkMergeValidationCachesEXT

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkQueueBeginDebugUtilsLabelEXT(3)

Name

vkQueueBeginDebugUtilsLabelEXT - Open a queue debug label region

C Specification

A queue debug label region is opened by calling:

void vkQueueBeginDebugUtilsLabelEXT(
    VkQueue                                     queue,
    const VkDebugUtilsLabelEXT*                 pLabelInfo);

Parameters

queue is the queue in which to start a debug label region.
pLabelInfo is a pointer to an instance of the VkDebugUtilsLabelEXT structure specifying the parameters of the label region to open.

Description

Valid Usage (Implicit)

queue must be a valid VkQueue handle
pLabelInfo must be a valid pointer to a valid VkDebugUtilsLabelEXT structure

Command Properties

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkQueueBeginDebugUtilsLabelEXT

Any

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkQueueBindSparse(3)

Name

vkQueueBindSparse - Bind device memory to a sparse resource object

C Specification

To submit sparse binding operations to a queue, call:

VkResult vkQueueBindSparse(
    VkQueue                                     queue,
    uint32_t                                    bindInfoCount,
    const VkBindSparseInfo*                     pBindInfo,
    VkFence                                     fence);

Parameters

queue is the queue that the sparse binding operations will be submitted to.
bindInfoCount is the number of elements in the pBindInfo array.
pBindInfo is an array of VkBindSparseInfo structures, each specifying a sparse binding submission batch.
fence is an optional handle to a fence to be signaled. If fence is not VK_NULL_HANDLE, it defines a fence signal operation.

Description

vkQueueBindSparse is a queue submission command, with each batch defined by an element of pBindInfo as an instance of the VkBindSparseInfo structure. Batches begin execution in the order they appear in pBindInfo, but may complete out of order.

Within a batch, a given range of a resource must not be bound more than once. Across batches, if a range is to be bound to one allocation and offset and then to another allocation and offset, then the application must guarantee (usually using semaphores) that the binding operations are executed in the correct order, as well as to order binding operations against the execution of command buffer submissions.

As no operation to vkQueueBindSparse causes any pipeline stage to access memory, synchronization primitives used in this command effectively only define execution dependencies.

Additional information about fence and semaphore operation is described in the synchronization chapter.

Valid Usage

If fence is not VK_NULL_HANDLE, fence must be unsignaled
If fence is not VK_NULL_HANDLE, fence must not be associated with any other queue command that has not yet completed execution on that queue
Each element of the pSignalSemaphores member of each element of pBindInfo must be unsignaled when the semaphore signal operation it defines is executed on the device
When a semaphore unsignal operation defined by any element of the pWaitSemaphores member of any element of pBindInfo executes on queue, no other queue must be waiting on the same semaphore.
All elements of the pWaitSemaphores member of all elements of pBindInfo must be semaphores that are signaled, or have semaphore signal operations previously submitted for execution.

Valid Usage (Implicit)

queue must be a valid VkQueue handle
If bindInfoCount is not 0, pBindInfo must be a valid pointer to an array of bindInfoCount valid VkBindSparseInfo structures
If fence is not VK_NULL_HANDLE, fence must be a valid VkFence handle
The queue must support sparse binding operations
Both of fence, and queue that are valid handles must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to queue must be externally synchronized
Host access to pBindInfo[].pWaitSemaphores[] must be externally synchronized
Host access to pBindInfo[].pSignalSemaphores[] must be externally synchronized
Host access to pBindInfo[].pBufferBinds[].buffer must be externally synchronized
Host access to pBindInfo[].pImageOpaqueBinds[].image must be externally synchronized
Host access to pBindInfo[].pImageBinds[].image must be externally synchronized
Host access to fence must be externally synchronized

Command Properties

SPARSE_BINDING

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkQueueBindSparse

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_DEVICE_LOST

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkQueueEndDebugUtilsLabelEXT(3)

Name

vkQueueEndDebugUtilsLabelEXT - Close a queue debug label region

C Specification

A queue debug label region is closed by calling:

void vkQueueEndDebugUtilsLabelEXT(
    VkQueue                                     queue);

Parameters

queue is the queue in which a debug label region should be closed.

Description

The calls to vkQueueBeginDebugUtilsLabelEXT and vkQueueEndDebugUtilsLabelEXT must be matched and balanced.

Valid Usage

There must be an outstanding vkQueueBeginDebugUtilsLabelEXT command prior to the vkQueueEndDebugUtilsLabelEXT on the queue

Valid Usage (Implicit)

queue must be a valid VkQueue handle

Command Properties

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkQueueEndDebugUtilsLabelEXT

Any

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkQueueInsertDebugUtilsLabelEXT(3)

Name

vkQueueInsertDebugUtilsLabelEXT - Insert a label into a queue

C Specification

A single label can be inserted into a queue by calling:

void vkQueueInsertDebugUtilsLabelEXT(
    VkQueue                                     queue,
    const VkDebugUtilsLabelEXT*                 pLabelInfo);

Parameters

queue is the queue into which a debug label will be inserted.
pLabelInfo is a pointer to an instance of the VkDebugUtilsLabelEXT structure specifying the parameters of the label to insert.

Description

Valid Usage (Implicit)

queue must be a valid VkQueue handle
pLabelInfo must be a valid pointer to a valid VkDebugUtilsLabelEXT structure

Command Properties

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkQueueInsertDebugUtilsLabelEXT

Any

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkQueuePresentKHR(3)

Name

vkQueuePresentKHR - Queue an image for presentation

C Specification

After queueing all rendering commands and transitioning the image to the correct layout, to queue an image for presentation, call:

VkResult vkQueuePresentKHR(
    VkQueue                                     queue,
    const VkPresentInfoKHR*                     pPresentInfo);

Parameters

queue is a queue that is capable of presentation to the target surface’s platform on the same device as the image’s swapchain.
pPresentInfo is a pointer to an instance of the VkPresentInfoKHR structure specifying the parameters of the presentation.

Description

Note

There is no requirement for an application to present images in the same order that they were acquired - applications can arbitrarily present any image that is currently acquired.

Valid Usage

Each element of pSwapchains member of pPresentInfo must be a swapchain that is created for a surface for which presentation is supported from queue as determined using a call to vkGetPhysicalDeviceSurfaceSupportKHR
If more than one member of pSwapchains was created from a display surface, all display surfaces referenced that refer to the same display must use the same display mode
When a semaphore unsignal operation defined by the elements of the pWaitSemaphores member of pPresentInfo executes on queue, no other queue must be waiting on the same semaphore.
All elements of the pWaitSemaphores member of pPresentInfo must be semaphores that are signaled, or have semaphore signal operations previously submitted for execution.

Any writes to memory backing the images referenced by the pImageIndices and pSwapchains members of pPresentInfo, that are available before vkQueuePresentKHR is executed, are automatically made visible to the read access performed by the presentation engine. This automatic visibility operation for an image happens-after the semaphore signal operation, and happens-before the presentation engine accesses the image.

Queueing an image for presentation defines a set of queue operations, including waiting on the semaphores and submitting a presentation request to the presentation engine. However, the scope of this set of queue operations does not include the actual processing of the image by the presentation engine.

If vkQueuePresentKHR fails to enqueue the corresponding set of queue operations, it may return VK_ERROR_OUT_OF_HOST_MEMORY or VK_ERROR_OUT_OF_DEVICE_MEMORY. If it does, the implementation must ensure that the state and contents of any resources or synchronization primitives referenced is unaffected by the call or its failure.

If vkQueuePresentKHR fails in such a way that the implementation is unable to make that guarantee, the implementation must return VK_ERROR_DEVICE_LOST.

However, if the presentation request is rejected by the presentation engine with an error VK_ERROR_OUT_OF_DATE_KHR or VK_ERROR_SURFACE_LOST_KHR, the set of queue operations are still considered to be enqueued and thus any semaphore to be waited on gets unsignaled when the corresponding queue operation is complete.

Valid Usage (Implicit)

queue must be a valid VkQueue handle
pPresentInfo must be a valid pointer to a valid VkPresentInfoKHR structure

Host Synchronization

Host access to queue must be externally synchronized
Host access to pPresentInfo.pWaitSemaphores[] must be externally synchronized
Host access to pPresentInfo.pSwapchains[] must be externally synchronized

Command Properties

Any

Return Codes

VK_SUCCESS
VK_SUBOPTIMAL_KHR

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkQueuePresentKHR

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_DEVICE_LOST
VK_ERROR_OUT_OF_DATE_KHR
VK_ERROR_SURFACE_LOST_KHR

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkQueueSubmit(3)

Name

vkQueueSubmit - Submits a sequence of semaphores or command buffers to a queue

C Specification

To submit command buffers to a queue, call:

VkResult vkQueueSubmit(
    VkQueue                                     queue,
    uint32_t                                    submitCount,
    const VkSubmitInfo*                         pSubmits,
    VkFence                                     fence);

Parameters

queue is the queue that the command buffers will be submitted to.
submitCount is the number of elements in the pSubmits array.
pSubmits is a pointer to an array of VkSubmitInfo structures, each specifying a command buffer submission batch.
fence is an optional handle to a fence to be signaled once all submitted command buffers have completed execution. If fence is not VK_NULL_HANDLE, it defines a fence signal operation.

Description

Note

Submission can be a high overhead operation, and applications should attempt to batch work together into as few calls to vkQueueSubmit as possible.

vkQueueSubmit is a queue submission command, with each batch defined by an element of pSubmits as an instance of the VkSubmitInfo structure. Batches begin execution in the order they appear in pSubmits, but may complete out of order.

Fence and semaphore operations submitted with vkQueueSubmit have additional ordering constraints compared to other submission commands, with dependencies involving previous and subsequent queue operations. Information about these additional constraints can be found in the semaphore and fence sections of the synchronization chapter.

Details on the interaction of pWaitDstStageMask with synchronization are described in the semaphore wait operation section of the synchronization chapter.

The order that batches appear in pSubmits is used to determine submission order, and thus all the implicit ordering guarantees that respect it. Other than these implicit ordering guarantees and any explicit synchronization primitives, these batches may overlap or otherwise execute out of order.

If any command buffer submitted to this queue is in the executable state, it is moved to the pending state. Once execution of all submissions of a command buffer complete, it moves from the pending state, back to the executable state. If a command buffer was recorded with the VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT flag, it instead moves back to the invalid state.

If vkQueueSubmit fails, it may return VK_ERROR_OUT_OF_HOST_MEMORY or VK_ERROR_OUT_OF_DEVICE_MEMORY. If it does, the implementation must ensure that the state and contents of any resources or synchronization primitives referenced by the submitted command buffers and any semaphores referenced by pSubmits is unaffected by the call or its failure. If vkQueueSubmit fails in such a way that the implementation is unable to make that guarantee, the implementation must return VK_ERROR_DEVICE_LOST. See Lost Device.

Valid Usage

If fence is not VK_NULL_HANDLE, fence must be unsignaled
If fence is not VK_NULL_HANDLE, fence must not be associated with any other queue command that has not yet completed execution on that queue
Any calls to vkCmdSetEvent, vkCmdResetEvent or vkCmdWaitEvents that have been recorded into any of the command buffer elements of the pCommandBuffers member of any element of pSubmits, must not reference any VkEvent that is referenced by any of those commands in a command buffer that has been submitted to another queue and is still in the pending state.
Any stage flag included in any element of the pWaitDstStageMask member of any element of pSubmits must be a pipeline stage supported by one of the capabilities of queue, as specified in the table of supported pipeline stages.
Each element of the pSignalSemaphores member of any element of pSubmits must be unsignaled when the semaphore signal operation it defines is executed on the device
When a semaphore unsignal operation defined by any element of the pWaitSemaphores member of any element of pSubmits executes on queue, no other queue must be waiting on the same semaphore.
All elements of the pWaitSemaphores member of all elements of pSubmits must be semaphores that are signaled, or have semaphore signal operations previously submitted for execution.
Each element of the pCommandBuffers member of each element of pSubmits must be in the pending or executable state.
If any element of the pCommandBuffers member of any element of pSubmits was not recorded with the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT, it must not be in the pending state.
Any secondary command buffers recorded into any element of the pCommandBuffers member of any element of pSubmits must be in the pending or executable state.
If any secondary command buffers recorded into any element of the pCommandBuffers member of any element of pSubmits was not recorded with the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT, it must not be in the pending state.
Each element of the pCommandBuffers member of each element of pSubmits must have been allocated from a VkCommandPool that was created for the same queue family queue belongs to.
If any element of pSubmits→pCommandBuffers includes a Queue Family Transfer Acquire Operation, there must exist a previously submitted Queue Family Transfer Release Operation on a queue in the queue family identified by the acquire operation, with parameters matching the acquire operation as defined in the definition of such acquire operations, and which happens before the acquire operation.

Valid Usage (Implicit)

queue must be a valid VkQueue handle
If submitCount is not 0, pSubmits must be a valid pointer to an array of submitCount valid VkSubmitInfo structures
If fence is not VK_NULL_HANDLE, fence must be a valid VkFence handle
Both of fence, and queue that are valid handles must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

Host access to queue must be externally synchronized
Host access to pSubmits[].pWaitSemaphores[] must be externally synchronized
Host access to pSubmits[].pSignalSemaphores[] must be externally synchronized
Host access to fence must be externally synchronized

Command Properties

Any

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkQueueSubmit

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_DEVICE_LOST

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkQueueWaitIdle(3)

Name

vkQueueWaitIdle - Wait for a queue to become idle

C Specification

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

VkResult vkQueueWaitIdle(
    VkQueue                                     queue);

Parameters

queue is the queue on which to wait.

Description

vkQueueWaitIdle is equivalent to submitting a fence to a queue and waiting with an infinite timeout for that fence to signal.

Valid Usage (Implicit)

queue must be a valid VkQueue handle

Command Properties

Any

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkQueueWaitIdle

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY
VK_ERROR_DEVICE_LOST

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkRegisterDeviceEventEXT(3)

Name

vkRegisterDeviceEventEXT - Signal a fence when a device event occurs

C Specification

To create a fence that will be signaled when an event occurs on a device, call:

VkResult vkRegisterDeviceEventEXT(
    VkDevice                                    device,
    const VkDeviceEventInfoEXT*                 pDeviceEventInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkFence*                                    pFence);

Parameters

device is a logical device on which the event may occur.
pDeviceEventInfo is a pointer to an instance of the VkDeviceEventInfoEXT structure describing the event of interest to the application.
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
pDeviceEventInfo must be a valid pointer to a valid VkDeviceEventInfoEXT structure
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pFence must be a valid pointer to a VkFence handle

Return Codes

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkRegisterDeviceEventEXT

VK_SUCCESS

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkRegisterDisplayEventEXT(3)

Name

vkRegisterDisplayEventEXT - Signal a fence when a display event occurs

C Specification

To create a fence that will be signaled when an event occurs on a VkDisplayKHR object, call:

VkResult vkRegisterDisplayEventEXT(
    VkDevice                                    device,
    VkDisplayKHR                                display,
    const VkDisplayEventInfoEXT*                pDisplayEventInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkFence*                                    pFence);

Parameters

device is a logical device associated with display
display is the display on which the event may occur.
pDisplayEventInfo is a pointer to an instance of the VkDisplayEventInfoEXT structure describing the event of interest to the application.
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
display must be a valid VkDisplayKHR handle
pDisplayEventInfo must be a valid pointer to a valid VkDisplayEventInfoEXT structure
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pFence must be a valid pointer to a VkFence handle

Return Codes

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkRegisterDisplayEventEXT

VK_SUCCESS

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkRegisterObjectsNVX(3)

Name

vkRegisterObjectsNVX - Register resource bindings in an object table

C Specification

Resource bindings of Vulkan objects are registered at an arbitrary uint32_t index within an object table. As long as the object table references such objects, they must not be deleted.

VkResult vkRegisterObjectsNVX(
    VkDevice                                    device,
    VkObjectTableNVX                            objectTable,
    uint32_t                                    objectCount,
    const VkObjectTableEntryNVX* const*         ppObjectTableEntries,
    const uint32_t*                             pObjectIndices);

Parameters

device is the logical device that creates the object table.
objectTable is the table for which the resources are registered.
objectCount is the number of resources to register.
ppObjectTableEntries provides an array for detailed binding informations, each array element is a pointer to a struct of type VkObjectTablePipelineEntryNVX, VkObjectTableDescriptorSetEntryNVX, VkObjectTableVertexBufferEntryNVX, VkObjectTableIndexBufferEntryNVX or VkObjectTablePushConstantEntryNVX (see below for details).
pObjectIndices are the indices at which each resource is registered.

Description

Valid Usage

The contents of pObjectTableEntry must yield plausible bindings supported by the device.
At any pObjectIndices there must not be a registered resource already.
Any value inside pObjectIndices must be below the appropriate VkObjectTableCreateInfoNVX::pObjectEntryCounts limits provided at objectTable creation time.

Valid Usage (Implicit)

device must be a valid VkDevice handle
objectTable must be a valid VkObjectTableNVX handle
ppObjectTableEntries must be a valid pointer to an array of objectCount valid VkObjectTableEntryNVX structures
pObjectIndices must be a valid pointer to an array of objectCount uint32_t values
objectCount must be greater than 0
objectTable must have been created, allocated, or retrieved from device

Host Synchronization

Host access to objectTable must be externally synchronized

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkRegisterObjectsNVX

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkReleaseDisplayEXT(3)

Name

vkReleaseDisplayEXT - Release access to an acquired VkDisplayKHR

C Specification

To release a previously acquired display, call:

VkResult vkReleaseDisplayEXT(
    VkPhysicalDevice                            physicalDevice,
    VkDisplayKHR                                display);

Parameters

physicalDevice The physical device the display is on.
display The display to release control of.

Description

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle
display must be a valid VkDisplayKHR handle

Return Codes

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkReleaseDisplayEXT

VK_SUCCESS

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkResetCommandBuffer(3)

Name

vkResetCommandBuffer - Reset a command buffer to the initial state

C Specification

To reset command buffers, call:

VkResult vkResetCommandBuffer(
    VkCommandBuffer                             commandBuffer,
    VkCommandBufferResetFlags                   flags);

Parameters

commandBuffer is the command buffer to reset. The command buffer can be in any state other than pending, and is moved into the initial state.
flags is a bitmask of VkCommandBufferResetFlagBits controlling the reset operation.

Description

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

Valid Usage

commandBuffer must not be in the pending state
commandBuffer must have been allocated from a pool that was created with the VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT

Valid Usage (Implicit)

commandBuffer must be a valid VkCommandBuffer handle
flags must be a valid combination of VkCommandBufferResetFlagBits values

Host Synchronization

Host access to commandBuffer must be externally synchronized

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkResetCommandBuffer

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkResetCommandPool(3)

Name

vkResetCommandPool - Reset a command pool

C Specification

To reset a command pool, call:

VkResult vkResetCommandPool(
    VkDevice                                    device,
    VkCommandPool                               commandPool,
    VkCommandPoolResetFlags                     flags);

Parameters

device is the logical device that owns the command pool.
commandPool is the command pool to reset.
flags is a bitmask of VkCommandPoolResetFlagBits controlling the reset operation.

Description

Resetting a command pool recycles all of the resources from all of the command buffers allocated from the command pool back to the command pool. All command buffers that have been allocated from the command pool are put in the initial state.

Valid Usage

All VkCommandBuffer objects allocated from commandPool must not be in the pending state

Valid Usage (Implicit)

device must be a valid VkDevice handle
commandPool must be a valid VkCommandPool handle
flags must be a valid combination of VkCommandPoolResetFlagBits values
commandPool must have been created, allocated, or retrieved from device

Host Synchronization

Host access to commandPool must be externally synchronized

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkResetCommandPool

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkResetDescriptorPool(3)

Name

vkResetDescriptorPool - Resets a descriptor pool object

C Specification

To return all descriptor sets allocated from a given pool to the pool, rather than freeing individual descriptor sets, call:

VkResult vkResetDescriptorPool(
    VkDevice                                    device,
    VkDescriptorPool                            descriptorPool,
    VkDescriptorPoolResetFlags                  flags);

Parameters

device is the logical device that owns the descriptor pool.
descriptorPool is the descriptor pool to be reset.
flags is reserved for future use.

Description

Resetting a descriptor pool recycles all of the resources from all of the descriptor sets allocated from the descriptor pool back to the descriptor pool, and the descriptor sets are implicitly freed.

Valid Usage

All uses of descriptorPool (via any allocated descriptor sets) must have completed execution

Valid Usage (Implicit)

device must be a valid VkDevice handle
descriptorPool must be a valid VkDescriptorPool handle
flags must be 0
descriptorPool must have been created, allocated, or retrieved from device

Host Synchronization

Host access to descriptorPool must be externally synchronized
Host access to any VkDescriptorSet objects allocated from descriptorPool must be externally synchronized

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkResetDescriptorPool

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkResetEvent(3)

Name

vkResetEvent - Reset an event to non-signaled state

C Specification

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

VkResult vkResetEvent(
    VkDevice                                    device,
    VkEvent                                     event);

Parameters

device is the logical device that owns the event.
event is the event to reset.

Description

When vkResetEvent is executed on the host, it defines an event unsignal operation which resets the event to the unsignaled state.

If event is already in the unsignaled state when vkResetEvent is executed, then vkResetEvent has no effect, and no event unsignal operation occurs.

Valid Usage

event must not be waited on by a vkCmdWaitEvents command that is currently executing

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

Host Synchronization

Host access to event must be externally synchronized

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkResetEvent

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkResetFences(3)

Name

vkResetFences - Resets one or more fence objects

C Specification

To set the state of fences to unsignaled from the host, call:

VkResult vkResetFences(
    VkDevice                                    device,
    uint32_t                                    fenceCount,
    const VkFence*                              pFences);

Parameters

device is the logical device that owns the fences.
fenceCount is the number of fences to reset.
pFences is a pointer to an array of fence handles to reset.

Description

If any member of pFences currently has its payload imported with temporary permanence, that fence’s prior permanent payload is first restored. The remaining operations described therefore operate on the restored payload.

When vkResetFences is executed on the host, it defines a fence unsignal operation for each fence, which resets the fence to the unsignaled state.

If any member of pFences is already in the unsignaled state when vkResetFences is executed, then vkResetFences has no effect on that fence.

Valid Usage

Each element of pFences must not be currently associated with any queue command that has not yet completed execution on that queue

Valid Usage (Implicit)

device must be a valid VkDevice handle
pFences must be a valid pointer to an array of fenceCount valid VkFence handles
fenceCount must be greater than 0
Each element of pFences must have been created, allocated, or retrieved from device

Host Synchronization

Host access to each member of pFences must be externally synchronized

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkResetFences

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkSetDebugUtilsObjectNameEXT(3)

Name

vkSetDebugUtilsObjectNameEXT - Give a user-friendly name to an object

C Specification

VkResult vkSetDebugUtilsObjectNameEXT(
    VkDevice                                    device,
    const VkDebugUtilsObjectNameInfoEXT*        pNameInfo);

Parameters

device is the device that created the object.
pNameInfo is a pointer to an instance of the VkDebugUtilsObjectNameInfoEXT structure specifying the parameters of the name to set on the object.

Description

Valid Usage (Implicit)

device must be a valid VkDevice handle
pNameInfo must be a valid pointer to a valid VkDebugUtilsObjectNameInfoEXT structure

Host Synchronization

Host access to pNameInfo.objectHandle must be externally synchronized

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkSetDebugUtilsObjectNameEXT

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkSetDebugUtilsObjectTagEXT(3)

Name

vkSetDebugUtilsObjectTagEXT - Attach arbitrary data to an object

C Specification

VkResult vkSetDebugUtilsObjectTagEXT(
    VkDevice                                    device,
    const VkDebugUtilsObjectTagInfoEXT*         pTagInfo);

Parameters

device is the device that created the object.
pTagInfo is a pointer to an instance of the VkDebugUtilsObjectTagInfoEXT structure specifying the parameters of the tag to attach to the object.

Description

Valid Usage (Implicit)

device must be a valid VkDevice handle
pTagInfo must be a valid pointer to a valid VkDebugUtilsObjectTagInfoEXT structure

Host Synchronization

Host access to pTagInfo.objectHandle must be externally synchronized

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkSetDebugUtilsObjectTagEXT

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkSetEvent(3)

Name

vkSetEvent - Set an event to signaled state

C Specification

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

VkResult vkSetEvent(
    VkDevice                                    device,
    VkEvent                                     event);

Parameters

device is the logical device that owns the event.
event is the event to set.

Description

When vkSetEvent is executed on the host, it defines an event signal operation which sets the event to the signaled state.

If event is already in the signaled state when vkSetEvent is executed, then vkSetEvent has no effect, and no event signal operation occurs.

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

Host Synchronization

Host access to event must be externally synchronized

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkSetEvent

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkSetHdrMetadataEXT(3)

Name

vkSetHdrMetadataEXT - function to set Hdr metadata

C Specification

void vkSetHdrMetadataEXT(
    VkDevice                                    device,
    uint32_t                                    swapchainCount,
    const VkSwapchainKHR*                       pSwapchains,
    const VkHdrMetadataEXT*                     pMetadata);

Parameters

device is the logical device where the swapchain(s) were created.
swapchainCount is the number of swapchains included in pSwapchains.
pSwapchains is a pointer to the array of swapchainCount VkSwapchainKHR handles.
pMetadata is a pointer to the array of swapchainCount VkHdrMetadataEXT structures.

Description

Valid Usage (Implicit)

device must be a valid VkDevice handle
pSwapchains must be a valid pointer to an array of swapchainCount valid VkSwapchainKHR handles
pMetadata must be a valid pointer to an array of swapchainCount valid VkHdrMetadataEXT structures
swapchainCount must be greater than 0
Both of device, and the elements of pSwapchains must have been created, allocated, or retrieved from the same VkInstance

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkSetHdrMetadataEXT

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkSubmitDebugUtilsMessageEXT(3)

Name

vkSubmitDebugUtilsMessageEXT - Inject a message into a debug stream

C Specification

There may be times that a user wishes to intentionally submit a debug message. To do this, call:

void vkSubmitDebugUtilsMessageEXT(
    VkInstance                                  instance,
    VkDebugUtilsMessageSeverityFlagBitsEXT      messageSeverity,
    VkDebugUtilsMessageTypeFlagsEXT             messageTypes,
    const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData);

Parameters

instance is the debug stream’s VkInstance.
messageSeverity is the VkDebugUtilsMessageSeverityFlagBitsEXT severity of this event/message.
messageTypes is a bitmask of VkDebugUtilsMessageTypeFlagBitsEXT specifying which type of event(s) to identify with this message.
pCallbackData contains all the callback related data in the VkDebugUtilsMessengerCallbackDataEXT structure.

Description

Valid Usage (Implicit)

instance must be a valid VkInstance handle
messageSeverity must be a valid VkDebugUtilsMessageSeverityFlagBitsEXT value
messageTypes must be a valid combination of VkDebugUtilsMessageTypeFlagBitsEXT values
messageTypes must not be 0
pCallbackData must be a valid pointer to a valid VkDebugUtilsMessengerCallbackDataEXT structure

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkSubmitDebugUtilsMessageEXT

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkTrimCommandPool(3)

Name

vkTrimCommandPool - Trim a command pool

C Specification

To trim a command pool, call:

void vkTrimCommandPool(
    VkDevice                                    device,
    VkCommandPool                               commandPool,
    VkCommandPoolTrimFlags                      flags);

or the equivalent command

void vkTrimCommandPoolKHR(
    VkDevice                                    device,
    VkCommandPool                               commandPool,
    VkCommandPoolTrimFlags                      flags);

Parameters

device is the logical device that owns the command pool.
commandPool is the command pool to trim.
flags is reserved for future use.

Description

Trimming a command pool recycles unused memory from the command pool back to the system. Command buffers allocated from the pool are not affected by the command.

Note

This command provides applications with some control over the internal memory allocations used by command pools.

Unused memory normally arises from command buffers that have been recorded and later reset, such that they are no longer using the memory. On reset, a command buffer can return memory to its command pool, but the only way to release memory from a command pool to the system requires calling vkResetCommandPool, which cannot be executed while any command buffers from that pool are still in use. Subsequent recording operations into command buffers will re-use this memory but since total memory requirements fluctuate over time, unused memory can accumulate.

In this situation, trimming a command pool may be useful to return unused memory back to the system, returning the total outstanding memory allocated by the pool back to a more “average” value.

Implementations utilize many internal allocation strategies that make it impossible to guarantee that all unused memory is released back to the system. For instance, an implementation of a command pool may involve allocating memory in bulk from the system and sub-allocating from that memory. In such an implementation any live command buffer that holds a reference to a bulk allocation would prevent that allocation from being freed, even if only a small proportion of the bulk allocation is in use.

In most cases trimming will result in a reduction in allocated but unused memory, but it does not guarantee the “ideal” behaviour.

Trimming may be an expensive operation, and should not be called frequently. Trimming should be treated as a way to relieve memory pressure after application-known points when there exists enough unused memory that the cost of trimming is “worth” it.

Valid Usage (Implicit)

device must be a valid VkDevice handle
commandPool must be a valid VkCommandPool handle
flags must be 0
commandPool must have been created, allocated, or retrieved from device

Host Synchronization

Host access to commandPool must be externally synchronized

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkTrimCommandPool

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

Unresolved directive in apispec.txt - include::vkTrimCommandPoolKHR.txt[]

vkUnmapMemory(3)

Name

vkUnmapMemory - Unmap a previously mapped memory object

C Specification

To unmap a memory object once host access to it is no longer needed by the application, call:

void vkUnmapMemory(
    VkDevice                                    device,
    VkDeviceMemory                              memory);

Parameters

device is the logical device that owns the memory.
memory is the memory object to be unmapped.

Description

Valid Usage

memory must be currently mapped

Valid Usage (Implicit)

device must be a valid VkDevice handle
memory must be a valid VkDeviceMemory handle
memory must have been created, allocated, or retrieved from device

Host Synchronization

Host access to memory must be externally synchronized

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkUnmapMemory

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkUnregisterObjectsNVX(3)

Name

vkUnregisterObjectsNVX - Unregister resource bindings in an object table

C Specification

Use the following command to unregister resources from an object table:

VkResult vkUnregisterObjectsNVX(
    VkDevice                                    device,
    VkObjectTableNVX                            objectTable,
    uint32_t                                    objectCount,
    const VkObjectEntryTypeNVX*                 pObjectEntryTypes,
    const uint32_t*                             pObjectIndices);

Parameters

device is the logical device that creates the object table.
objectTable is the table from which the resources are unregistered.
objectCount is the number of resources being removed from the object table.
pObjectEntryType provides an array of VkObjectEntryTypeNVX for the resources being removed.
pObjectIndices provides the array of object indices to be removed.

Description

Valid Usage

At any pObjectIndices there must be a registered resource already.
The pObjectEntryTypes of the resource at pObjectIndices must match.
All operations on the device using the registered resource must have been completed.

Valid Usage (Implicit)

device must be a valid VkDevice handle
objectTable must be a valid VkObjectTableNVX handle
pObjectEntryTypes must be a valid pointer to an array of objectCount valid VkObjectEntryTypeNVX values
pObjectIndices must be a valid pointer to an array of objectCount uint32_t values
objectCount must be greater than 0
objectTable must have been created, allocated, or retrieved from device

Host Synchronization

Host access to objectTable must be externally synchronized

Return Codes

VK_SUCCESS

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkUnregisterObjectsNVX

VK_ERROR_OUT_OF_HOST_MEMORY
VK_ERROR_OUT_OF_DEVICE_MEMORY

Document Notes

For more information, see the Vulkan Specification at URL

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkUpdateDescriptorSetWithTemplate(3)

Name

vkUpdateDescriptorSetWithTemplate - Update the contents of a descriptor set object using an update template

C Specification

Once a VkDescriptorUpdateTemplate has been created, descriptor sets can be updated by calling:

void vkUpdateDescriptorSetWithTemplate(
    VkDevice                                    device,
    VkDescriptorSet                             descriptorSet,
    VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
    const void*                                 pData);

or the equivalent command

void vkUpdateDescriptorSetWithTemplateKHR(
    VkDevice                                    device,
    VkDescriptorSet                             descriptorSet,
    VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
    const void*                                 pData);

Parameters

device is the logical device that updates the descriptor sets.
descriptorSet is the descriptor set to update
descriptorUpdateTemplate is the VkDescriptorUpdateTemplate which specifies the update mapping between pData and the descriptor set to update.
pData is a pointer to memory which contains one or more structures of VkDescriptorImageInfo, VkDescriptorBufferInfo, or VkBufferView used to write the descriptors.

Description

Valid Usage

pData must be a valid pointer to a memory that contains one or more valid instances of VkDescriptorImageInfo, VkDescriptorBufferInfo, or VkBufferView in a layout defined by descriptorUpdateTemplate when it was created with vkCreateDescriptorUpdateTemplate

Valid Usage (Implicit)

device must be a valid VkDevice handle
descriptorSet must be a valid VkDescriptorSet handle
descriptorUpdateTemplate must be a valid VkDescriptorUpdateTemplate handle
descriptorUpdateTemplate must have been created, allocated, or retrieved from device

Host Synchronization

Host access to descriptorSet must be externally synchronized

API example

struct AppBufferView {
    VkBufferView bufferView;
    uint32_t     applicationRelatedInformation;
};

struct AppDataStructure
{
    VkDescriptorImageInfo  imageInfo;          // a single image info
    VkDescriptorBufferInfo bufferInfoArray[3]; // 3 buffer infos in an array
    AppBufferView          bufferView[2];      // An application defined structure containing a bufferView
    // ... some more application related data
};

const VkDescriptorUpdateTemplateEntry descriptorUpdateTemplateEntries[] =
{
    // binding to a single image descriptor
    {
        0,                                           // binding
        0,                                           // dstArrayElement
        1,                                           // descriptorCount
        VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,   // descriptorType
        offsetof(AppDataStructure, imageInfo),       // offset
        0                                            // stride is not required if descriptorCount is 1.
    },

    // binding to an array of buffer descriptors
    {
        0,                                           // binding
        0,                                           // dstArrayElement
        3,                                           // descriptorCount
        VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,           // descriptorType
        offsetof(AppDataStructure, bufferInfoArray), // offset
        sizeof(VkDescriptorBufferInfo)               // stride, descriptor buffer infos are compact
    },

    // binding to an array of buffer views
    {
        0,                                           // binding
        3,                                           // dstArrayElement
        1,                                           // descriptorCount
        VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER,     // descriptorType
        offsetof(AppDataStructure, bufferView),      // offset
        sizeof(AppBufferView)                        // stride, bufferViews do not have to be compact
    },
};

// create a descriptor update template for descriptor set updates
const VkDescriptorUpdateTemplateCreateInfo createInfo =
{
    VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO,  // sType
    NULL,                                                          // pNext
    0,                                                             // flags
    3,                                                             // descriptorUpdateEntryCount
    descriptorUpdateTemplateEntries,                               // pDescriptorUpdateEntries
    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET,         // templateType
    myLayout,                                                      // descriptorSetLayout
    0,                                                             // pipelineBindPoint, ignored by given templateType
    0,                                                             // pipelineLayout, ignored by given templateType
    0,                                                             // set, ignored by given templateType
};

VkDescriptorUpdateTemplate myDescriptorUpdateTemplate;
myResult = vkCreateDescriptorUpdateTemplate(
    myDevice,
    &createInfo,
    NULL,
    &myDescriptorUpdateTemplate);
}


AppDataStructure appData;

// fill appData here or cache it in your engine
vkUpdateDescriptorSetWithTemplate(myDevice, myDescriptorSet, myDescriptorUpdateTemplate, &appData);

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkUpdateDescriptorSetWithTemplate

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

Unresolved directive in apispec.txt - include::vkUpdateDescriptorSetWithTemplateKHR.txt[]

vkUpdateDescriptorSets(3)

Name

vkUpdateDescriptorSets - Update the contents of a descriptor set object

C Specification

Once allocated, descriptor sets can be updated with a combination of write and copy operations. To update descriptor sets, call:

void vkUpdateDescriptorSets(
    VkDevice                                    device,
    uint32_t                                    descriptorWriteCount,
    const VkWriteDescriptorSet*                 pDescriptorWrites,
    uint32_t                                    descriptorCopyCount,
    const VkCopyDescriptorSet*                  pDescriptorCopies);

Parameters

device is the logical device that updates the descriptor sets.
descriptorWriteCount is the number of elements in the pDescriptorWrites array.
pDescriptorWrites is a pointer to an array of VkWriteDescriptorSet structures describing the descriptor sets to write to.
descriptorCopyCount is the number of elements in the pDescriptorCopies array.
pDescriptorCopies is a pointer to an array of VkCopyDescriptorSet structures describing the descriptor sets to copy between.

Description

The operations described by pDescriptorWrites are performed first, followed by the operations described by pDescriptorCopies. Within each array, the operations are performed in the order they appear in the array.

Each element in the pDescriptorWrites array describes an operation updating the descriptor set using descriptors for resources specified in the structure.

Each element in the pDescriptorCopies array is a VkCopyDescriptorSet structure describing an operation copying descriptors between sets.

If the dstSet member of any element of pDescriptorWrites or pDescriptorCopies is bound, accessed, or modified by any command that was recorded to a command buffer which is currently in the recording or executable state, and any of the descriptor bindings that are updated were not created with the VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT or VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT bits set, that command buffer becomes invalid.

Valid Usage

Descriptor bindings updated by this command which were created without the VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT or VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT bits set must not be used by any command that was recorded to a command buffer which is in the pending state.

Valid Usage (Implicit)

device must be a valid VkDevice handle
If descriptorWriteCount is not 0, pDescriptorWrites must be a valid pointer to an array of descriptorWriteCount valid VkWriteDescriptorSet structures
If descriptorCopyCount is not 0, pDescriptorCopies must be a valid pointer to an array of descriptorCopyCount valid VkCopyDescriptorSet structures

Host Synchronization

Host access to pDescriptorWrites[].dstSet must be externally synchronized
Host access to pDescriptorCopies[].dstSet must be externally synchronized

Document Notes

For more information, see the Vulkan Specification at URL

https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkUpdateDescriptorSets

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

vkWaitForFences(3)

Name

vkWaitForFences - Wait for one or more fences to become signaled

C Specification

To wait for one or more fences to enter the signaled state on the host, call:

VkResult vkWaitForFences(
    VkDevice                                    device,
    uint32_t                                    fenceCount,
    const VkFence*                              pFences,
    VkBool32                                    waitAll,
    uint64_t                                    timeout);

Parameters

device is the logical device that owns the fences.
fenceCount is the number of fences to wait on.
pFences is a pointer to an array of fenceCount fence handles.
waitAll is the condition that must be satisfied to successfully unblock the wait. If waitAll is VK_TRUE, then the condition is that all fences in pFences are signaled. Otherwise, the condition is that at least one fence in pFences is signaled.
timeout is the timeout period in units of nanoseconds. timeout is adjusted to the closest value allowed by the implementation-dependent timeout accuracy, which may be substantially longer than one nanosecond, and may be longer than the requested period.

Description

If the condition is satisfied when vkWaitForFences is called, then vkWaitForFences returns immediately. If the condition is not satisfied at the time vkWaitForFences is called, then vkWaitForFences will block and wait up to timeout nanoseconds for the condition to become satisfied.

If timeout is zero, then vkWaitForFences does not wait, but simply returns the current state of the fences. VK_TIMEOUT will be returned in this case if the condition is not satisfied, even though no actual wait was performed.

If the specified timeout period expires before the condition is satisfied, vkWaitForFences returns VK_TIMEOUT. If the condition is satisfied before timeout nanoseconds has expired, vkWaitForFences returns VK_SUCCESS.

If device loss occurs (see Lost Device) before the timeout has expired, vkWaitForFences must return in finite time with either VK_SUCCESS or VK_ERROR_DEVICE_LOST.

Note

While we guarantee that vkWaitForFences must return in finite time, no guarantees are made that it returns immediately upon device loss. However, the client can reasonably expect that the delay will be on the order of seconds and that calling vkWaitForFences will not result in a permanently (or seemingly permanently) dead process.

Valid Usage (Implicit)

device must be a valid VkDevice handle
pFences must be a valid pointer to an array of fenceCount valid VkFence handles
fenceCount must be greater than 0
Each element of pFences must have been created, allocated, or retrieved from device

Return Codes

VK_SUCCESS
VK_TIMEOUT