Vulkan 1.

1 Reference Guide Page 1

Vulkan® is a graphics and compute API consisting of procedures and
functions to specify shader programs, compute kernels, objects,
and operations involved in producing high-quality graphical images,
specifically color images of three-dimensional objects. Vulkan is Color coded names as follows: function names and structure names
also a pipeline with programmable and state-driven fixed-function [n.n.n] Indicates sections and text in the Vulkan API 1.1 Specification.
stages that are invoked by a set of specific drawing operations. P.# Indicates a page in this reference guide for more information.
= 0 Indicates reserved for future use.
Specification and additional resources at pNext must either be NULL, or point to a valid structure which extends the base
www.khronos.org/vulkan structure according to the valid usage rules of the base structure.

Return Codes [2.7.3] Command Function Pointers and Instances [3]

Return codes are reported via VkResult return values.
Command Function Pointers [3.1] const char* const* ppEnabledExtensionNames;
Success Codes PFN_vkVoidFunction vkGetInstanceProcAddr( } VkInstanceCreateInfo;
Success codes are non-negative. VkInstance instance, const char* pName);
typedef struct VkApplicationInfo {
VK_SUCCESS VK_NOT_READY PFN_vkVoidFunction vkGetDeviceProcAddr( VkStructureType sType; P.15
VK_TIMEOUT VK_EVENT_{SET, RESET} VkDevice device, const char* pName); const void* pNext;
VK_INCOMPLETE VK_SUBOPTIMAL_KHR PFN_vkVoidFunction is: const char* pApplicationName;
Error Codes typedef void(VKAPI_PTR* PFN_vkVoidFunction)(void); uint32_t applicationVersion;
const char* pEngineName;
Error codes are negative. Instances [3.2] uint32_t engineVersion;
VK_ERROR_OUT_OF_{HOST, DEVICE}_MEMORY VkResult vkEnumerateInstanceVersion( uint32_t apiVersion;
VK_ERROR_{INITIALIZATION, MEMORY_MAP}_FAILED uint32_t* pApiVersion); } VkApplicationInfo;
VK_ERROR_DEVICE_LOST
VK_ERROR_{EXTENSION, FEATURE, LAYER}_NOT_PRESENT VkResult vkCreateInstance( void vkDestroyInstance(
const VkInstanceCreateInfo* pCreateInfo, VkInstance instance,
VK_ERROR_INCOMPATIBLE_DRIVER const VkAllocationCallbacks* pAllocator, P.12 const VkAllocationCallbacks* pAllocator); P.12
VK_ERROR_TOO_MANY_OBJECTS VkInstance* pInstance);
VK_ERROR_FORMAT_NOT_SUPPORTED
VK_ERROR_FRAGMENTED_POOL typedef struct VkInstanceCreateInfo {
VK_ERROR_OUT_OF_POOL_MEMORY VkStructureType sType; P.15 Queues [4.3]
VK_ERROR_INVALID_EXTERNAL_HANDLE const void* pNext; typedef struct VkDeviceQueueCreateInfo {
VkInstanceCreateFlags flags; = 0 VkStructureType sType; P.15
VK_ERROR_SURFACE_LOST_KHR const VkApplicationInfo* pApplicationInfo;
VK_ERROR_NATIVE_WINDOW_IN_USE_KHR const void* pNext;
uint32_t enabledLayerCount; VkDeviceQueueCreateFlags flags;
VK_ERROR_OUT_OF_DATE_KHR const char* const* ppEnabledLayerNames;
VK_ERROR_INCOMPATIBLE_DISPLAY_KHR uint32_t queueFamilyIndex;
uint32_t enabledExtensionCount; uint32_t queueCount;
const float* pQueuePriorities;
} VkDeviceQueueCreateInfo;
Devices and Queues [4] Devices [4.2]
flags: VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT
VkResult vkEnumeratePhysicalDeviceGroups(
Physical Devices [4.1] VkInstance instance, void vkGetDeviceQueue(VkDevice device,
VkResult vkEnumeratePhysicalDevices( uint32_t* pPhysicalDeviceGroupCount, uint32_t queueFamilyIndex, uint32_t queueIndex,
VkInstance instance, VkPhysicalDeviceGroupProperties* VkQueue* pQueue);
uint32_t* pPhysicalDeviceCount, pPhysicalDeviceGroupProperties);
VkPhysicalDevice* pPhysicalDevices); void vkGetDeviceQueue2(VkDevice device,
typedef struct VkPhysicalDeviceGroupProperties { const VkDeviceQueueInfo2* pQueueInfo,
void vkGetPhysicalDeviceProperties( VkStructureType sType; P.15 VkQueue* pQueue);
VkPhysicalDevice physicalDevice, void* pNext;
VkPhysicalDeviceProperties* pProperties); P.14 uint32_t physicalDeviceCount; typedef struct VkDeviceQueueInfo2 {
VkPhysicalDevice physicalDevices[ VkStructureType sType; P.15
void vkGetPhysicalDeviceProperties2( VK_MAX_DEVICE_GROUP_SIZE]; const void* pNext;
VkPhysicalDevice physicalDevice, VkBool32 subsetAllocation; VkDeviceQueueCreateFlags flags;
VkPhysicalDeviceProperties2* pProperties); } VkPhysicalDeviceGroupProperties; uint32_t queueFamilyIndex; uint32_t queueIndex;
typedef struct VkPhysicalDeviceProperties2 { } VkDeviceQueueInfo2;
VkStructureType sType; P.15 Device Creation [4.2.1] flags: VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT
void* pNext; VkResult vkCreateDevice(
VkPhysicalDeviceProperties properties; P.14 VkPhysicalDevice physicalDevice,
const VkDeviceCreateInfo* pCreateInfo,
} VkPhysicalDeviceProperties2; const VkAllocationCallbacks* pAllocator, P.12 Command Buffers [5]
pNext must be NULL or point to one of: VkDevice* pDevice); Also see Command Buffer Lifecycle diagram. P.5
VkPhysicalDeviceIDProperties P.14
VkPhysicalDeviceMaintenance3Properties P.14 typedef struct VkDeviceCreateInfo { Command Pools [5.2]
VkPhysicalDeviceMultiviewProperties P.14 VkStructureType sType; P.15 VkResult vkCreateCommandPool(
VkPhysicalDevicePointClippingProperties P.14 const void* pNext; VkDevice device,
VkPhysicalDeviceProtectedMemoryProperties P.15 VkDeviceCreateFlags flags; = 0 const VkCommandPoolCreateInfo* pCreateInfo,
VkPhysicalDeviceSubgroupProperties P.15 uint32_t queueCreateInfoCount; const VkAllocationCallbacks* pAllocator, P.12
const VkDeviceQueueCreateInfo* pQueueCreateInfos; VkCommandPool* pCommandPool);
void vkGetPhysicalDeviceQueueFamilyProperties( uint32_t enabledLayerCount;
VkPhysicalDevice physicalDevice, const char* const* ppEnabledLayerNames; typedef struct VkCommandPoolCreateInfo {
uint32_t* pQueueFamilyPropertyCount, uint32_t enabledExtensionCount; VkStructureType sType; P.15
VkQueueFamilyProperties* const char* const* ppEnabledExtensionNames; const void* pNext;
pQueueFamilyProperties); const VkPhysicalDeviceFeatures* pEnabledFeatures; P.14 VkCommandPoolCreateFlags flags;
} VkDeviceCreateInfo; uint32_t queueFamilyIndex;
void vkGetPhysicalDeviceQueueFamilyProperties2( } VkCommandPoolCreateInfo;
VkPhysicalDevice physicalDevice, pNext must be NULL or point to one of:
VkDeviceGroupDeviceCreateInfo P.12 flags: VK_COMMAND_POOL_CREATE_X_BIT where X is
uint32_t* pQueueFamilyPropertyCount, PROTECTED, RESET_COMMAND_BUFFER, TRANSIENT
VkQueueFamilyProperties2*pQueueFamilyProperties); VkPhysicalDevice16BitStorageFeatures P.14
VkPhysicalDeviceFeatures2 P.14 void vkTrimCommandPool(VkDevice device,
typedef struct VkQueueFamilyProperties { VkPhysicalDeviceMultiviewFeatures P.14 VkCommandPool commandPool,
VkQueueFlags queueFlags; VkPhysicalDeviceProtectedMemoryFeatures P.15 VkCommandPoolTrimFlags flags); = 0
uint32_t queueCount; VkPhysicalDeviceSamplerYcbcrConversionFeatures P.15
uint32_t timestampValidBits; VkPhysicalDeviceVariablePointerFeatures P.15 VkResult vkResetCommandPool(
VkExtent3D minImageTransferGranularity; P.12 VkDevice device, VkCommandPool commandPool,
} VkQueueFamilyProperties; typedef struct VkDeviceGroupDeviceCreateInfo { VkCommandPoolResetFlags flags);
queueFlags: VkStructureType sType; P.15 flags: VK_COMMAND_POOL_RESET_RELEASE_-
VK_QUEUE_X_BIT where X is GRAPHICS, COMPUTE, const void* pNext; RESOURCES_BIT
TRANSFER, PROTECTED, SPARSE_BINDING uint32_t physicalDeviceCount;
const VkPhysicalDevice* pPhysicalDevices; void vkDestroyCommandPool(
typedef struct VkQueueFamilyProperties2 { } VkDeviceGroupDeviceCreateInfo; VkDevice device, VkCommandPool commandPool,
VkStructureType sType; P.15 const VkAllocationCallbacks* pAllocator); P.12
void* pNext; VkQueueFamilyProperties Device Destruction [4.2.4]
queueFamilyProperties; void vkDestroyDevice(
} VkQueueFamilyProperties2; VkDevice device, Continued on next page >
const VkAllocationCallbacks* pAllocator); P.12
©2018 Khronos Group - Rev. 1118 www.khronos.org/vulkan
Vulkan 1.1 Reference Guide Page 2
Command Buffers (continued) typedef struct VkCommandBufferInheritanceInfo {
VkStructureType sType; P.15
Version Number Macros [Appendix D]
Command Buffer Lifetime [5.3] const void* pNext; The vulkan.h header defines C preprocessor macros that are
VkRenderPass renderPass; described below. Version numbers are packed into integers.
VkResult vkAllocateCommandBuffers(
VkDevice device, uint32_t subpass; #define VK_VERSION_MAJOR(version) \
const VkCommandBufferAllocateInfo* pAllocateInfo, VkFramebuffer framebuffer; ((uint32_t)(version) >> 22)
VkCommandBuffer* pCommandBuffers); VkBool32 occlusionQueryEnable;
VkQueryControlFlags queryFlags; #define VK_VERSION_MINOR(version) \
typedef struct VkCommandBufferAllocateInfo{ VkQueryPipelineStatisticFlags pipelineStatistics; P.15 (((uint32_t)(version) >> 12) & 0x3ff)
VkStructureType sType; P.15 } VkCommandBufferInheritanceInfo;
const void* pNext; #define VK_VERSION_PATCH(version) \
VkCommandPool commandPool; queryFlags: VK_QUERY_CONTROL_PRECISE_BIT ((uint32_t)(version) & 0xfff)
VkCommandBufferLevel level; #define VK_API_VERSION_1_0 VK_MAKE_VERSION(1, 0, 0)
uint32_t commandBufferCount; VkResult vkEndCommandBuffer(
} VkCommandBufferAllocateInfo; VkCommandBuffer commandBuffer); #define VK_API_VERSION_1_1 VK_MAKE_VERSION(1, 1, 0)
level: Command Buffer Submission [5.5] #define VK_MAKE_VERSION(major, minor, patch) \
VK_COMMAND_BUFFER_LEVEL_{PRIMARY, SECONDARY} VkResult vkQueueSubmit( (((major) << 22) | ((minor) << 12) | (patch))
VkResult vkResetCommandBuffer( VkQueue queue, uint32_t submitCount, major: the major version number
VkCommandBuffer commandBuffer, const VkSubmitInfo* pSubmits, VkFence fence); minor: the minor version number
VkCommandBufferResetFlags flags); typedef struct VkSubmitInfo{ patch: the patch version number
flags: VkStructureType sType; P.15
VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT #define VK_HEADER_VERSION patch-version
const void* pNext;
uint32_t waitSemaphoreCount; patch-version: synchronized with the patch version of the
void vkFreeCommandBuffers( const VkSemaphore* pWaitSemaphores; released specification
VkDevice device, VkCommandPool commandPool, const VkPipelineStageFlags* pWaitDstStageMask; P.15
uint32_t commandBufferCount, VK_NULL_HANDLE
const VkCommandBuffer* pCommandBuffers); uint32_t commandBufferCount; This is a canonical invalid non-dispatchable handle. It is
const VkCommandBuffer* pCommandBuffers; returned by certain object creation functions if creation fails,
Command Buffer Recording [5.4] uint32_t signalSemaphoreCount; and can be passed as a parameter where permitted by VU
VkResult vkBeginCommandBuffer( const VkSemaphore* pSignalSemaphores; rules.
VkCommandBuffer commandBuffer, } VkSubmitInfo;
const VkCommandBufferBeginInfo* pBeginInfo); pNext must be NULL or point to one of:
VkDeviceGroupSubmitInfo P.12
typedef struct VkCommandBufferBeginInfo{
VkStructureType sType; P.15
VkProtectedSubmitInfo P.15 Notes
const void* pNext; Secondary Command Buffer Execution [5.7]
VkCommandBufferUsageFlags flags; void vkCmdExecuteCommands(
const VkCommandBufferInheritanceInfo* pInheritanceInfo; VkCommandBuffer commandBuffer,
} VkCommandBufferBeginInfo; uint32_t commandBufferCount,
flags: VK_COMMAND_BUFFER_USAGE_X _BIT where X is const VkCommandBuffer* pCommandBuffers);
ONE_TIME_SUBMIT, RENDER_PASS_CONTINUE,
SIMULTANEOUS_USE Command Buffer Device Mask [5.8]
void vkCmdSetDeviceMask(
pNext must be NULL or point to: VkCommandBuffer commandBuffer,
VkDeviceGroupCommandBufferBeginInfo P.12 uint32_t deviceMask);

Synchronization and Cache Control [6] void vkDestroySemaphore(

VkDevice device, VkSemaphore semaphore,
Fences [6.3] const VkAllocationCallbacks* pAllocator); P.12
Fence status is always either signaled or unsignaled.
Events [6.5]
VkResult vkCreateFence( Events represent a fine-grained synchronization primitive
VkDevice device, const VkFenceCreateInfo* pCreateInfo, that can be used to gauge progress through a sequence of
const VkAllocationCallbacks* pAllocator, P.12 commands executed on a queue.
VkFence* pFence);
VkResult vkCreateEvent(
typedef struct VkFenceCreateInfo { VkDevice device, const VkEventCreateInfo* pCreateInfo,
VkStructureType sType; P.15 const VkAllocationCallbacks* pAllocator, P.12
const void* pNext; VkEvent* pEvent);
VkFenceCreateFlags flags;
} VkFenceCreateInfo; typedef struct VkEventCreateInfo {
VkStructureType sType; P.15
flags: VK_FENCE_CREATE_SIGNALED_BIT const void* pNext;
pNext must be NULL or point to: VkEventCreateFlags flags; = 0
VkExportFenceCreateInfo P.12 } VkEventCreateInfo;
void vkDestroyFence( void vkDestroyEvent(VkDevice device, VkEvent event,
VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator); P.12
const VkAllocationCallbacks* pAllocator); P.12
VkResult vkGetEventStatus(
VkResult vkGetFenceStatus( VkDevice device, VkEvent event);
VkDevice device, VkFence fence);
VkResult vk[Set, Reset]Event(
VkResult vkResetFences(VkDevice device, VkDevice device, VkEvent event);
uint32_t fenceCount, const VkFence* pFences);
VkResult vkCmd[Set, Reset]Event(
VkResult vkWaitForFences(VkDevice device, VkCommandBuffer commandBuffer, VkEvent event,
uint32_t fenceCount, const VkFence* pFences, VkPipelineStageFlags stageMask); P.15 Pipeline Barriers [6.6]
VkBool32 waitAll, uint64_t timeout); void vkCmdPipelineBarrier(
void vkCmdWaitEvents( VkCommandBuffer commandBuffer,
Semaphores [6.4] VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, P.15
Semaphore status is always either signaled or unsignaled. uint32_t eventCount, VkPipelineStageFlags dstStageMask, P.15
const VkEvent* pEvents, VkDependencyFlags dependencyFlags, P.1512
VkResult vkCreateSemaphore( VkPipelineStageFlags srcStageMask, P.15
VkDevice device, uint32_t memoryBarrierCount,
VkPipelineStageFlags dstStageMask, P.15 const VkMemoryBarrier* pMemoryBarriers, P.13
const VkSemaphoreCreateInfo* pCreateInfo, uint32_t memoryBarrierCount,
const VkAllocationCallbacks* pAllocator, P.12 uint32_t bufferMemoryBarrierCount,
const VkMemoryBarrier* pMemoryBarriers, P.13 const VkBufferMemoryBarrier*
VkSemaphore* pSemaphore); uint32_t bufferMemoryBarrierCount, pBufferMemoryBarriers, P.12
typedef struct VkSemaphoreCreateInfo { const VkBufferMemoryBarrier* uint32_t imageMemoryBarrierCount,
VkStructureType sType; P.15 pBufferMemoryBarriers, P.12 const VkImageMemoryBarrier*
const void* pNext; uint32_t imageMemoryBarrierCount, pImageMemoryBarriers); P.13
VkSemaphoreCreateFlags flags; = 0 const VkImageMemoryBarrier*
} VkSemaphoreCreateInfo; pImageMemoryBarriers); P.13 Wait Idle Operations [6.8]
VkResult vkQueueWaitIdle(VkQueue queue);
pNext must be NULL or point to:
VkExportSemaphoreCreateInfo P.12 VkResult vkDeviceWaitIdle(VkDevice device);

©2018 Khronos Group - Rev. 1118 www.khronos.org/vulkan

Vulkan 1.1 Reference Guide Page 3
Render Pass [7] typedef struct VkSubpassDependency {
uint32_t srcSubpass;
Shaders [8]
A render pass represents a collection of attachments,
subpasses, and dependencies between the subpasses, and uint32_t dstSubpass; Shader Modules [8.1]
describes how the attachments are used over the course of VkPipelineStageFlags srcStageMask; P.15 VkResult vkCreateShaderModule(
the subpasses. VkPipelineStageFlags dstStageMask; P.12 VkDevice device,
VkAccessFlags srcAccessMask; P.12 const VkShaderModuleCreateInfo* pCreateInfo,
Render Pass Creation [7.1] VkAccessFlags dstAccessMask; P.12 const VkAllocationCallbacks* pAllocator, P.12
VkResult vkCreateRenderPass(VkDevice device, VkDependencyFlags dependencyFlags; P.1512 VkShaderModule* pShaderModule);
const VkRenderPassCreateInfo* pCreateInfo, } VkSubpassDependency;
const VkAllocationCallbacks* pAllocator, P.12 typedef struct VkShaderModuleCreateInfo {
VkRenderPass* pRenderPass); void vkDestroyRenderPass(VkDevice device, VkStructureType sType; P.15
VkRenderPass renderPass, const void* pNext;
typedef struct VkRenderPassCreateInfo { const VkAllocationCallbacks* pAllocator); P.12 VkShaderModuleCreateFlags flags; = 0
VkStructureType sType; P.15 size_t codeSize;
const void* pNext; Framebuffers [7.3] const uint32_t* pCode;
VkRenderPassCreateFlags flags; = 0 VkResult vkCreateFramebuffer(VkDevice device, } VkShaderModuleCreateInfo;
uint32_t attachmentCount; const VkFramebufferCreateInfo* pCreateInfo,
const VkAttachmentDescription* pAttachments; const VkAllocationCallbacks* pAllocator, P.12 void vkDestroyShaderModule(
uint32_t subpassCount; VkFramebuffer* pFramebuffer); VkDevice device,
const VkSubpassDescription* pSubpasses; VkShaderModule shaderModule,
typedef struct VkFramebufferCreateInfo { const VkAllocationCallbacks* pAllocator); P.12
uint32_t dependencyCount; VkStructureType sType; P.15
const VkSubpassDependency* pDependencies; const void* pNext; Built-in Variables [14.6]
} VkRenderPassCreateInfo; VkFramebufferCreateFlags flags; = 0 The built-in variables listed below are accessed in shaders by
pNext must be NULL or point to one of: VkRenderPass renderPass; declaring the variable using a BuiltIn decoration.
VkRenderPassInputAttachmentAspectCreateInfo P.1315 uint32_t attachmentCount; Decoration Type
VkRenderPassMultiviewCreateInfo P.1315 const VkImageView* pAttachments;
uint32_t width; BaseInstance Scalar 32-bit integer
typedef struct VkAttachmentDescription { uint32_t height; BaseVertex Scalar 32-bit integer
VkAttachmentDescriptionFlags flags; uint32_t layers;
VkFormat format; P.13 ClipDistance Array of 32-bit floats
} VkFramebufferCreateInfo;
VkSampleCountFlagBits samples; P.15 CullDistance Array of 32-bit floats
VkAttachmentLoadOp loadOp; void vkDestroyFramebuffer( DeviceIndex Scalar 32-bit integer
VkAttachmentStoreOp storeOp; VkDevice device, VkFramebuffer framebuffer,
const VkAllocationCallbacks* pAllocator); P.12 DrawIndex Scalar 32-bit integer
VkAttachmentLoadOp stencilLoadOp;
VkAttachmentStoreOp stencilStoreOp; FragCoord 4-component vector of 32-bit floats
VkImageLayout initialLayout; P.13 Render Pass Commands [7.4] FragDepth Scalar 32-bit float
VkImageLayout finalLayout; P.13 void vkCmdBeginRenderPass(
VkCommandBuffer commandBuffer, FrontFacing Scalar 32-bit integer
} VkAttachmentDescription;
const VkRenderPassBeginInfo* pRenderPassBegin, GlobalInvocationID 3-component vector of 32-bit ints
flags: VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT VkSubpassContents contents); HelperInvocation Scalar 32-bit integer
loadOp, stencilLoadOp: VK_ATTACHMENT_LOAD_OP_X contents: VK_SUBPASS_CONTENTS_X where X is INLINE, InvocationID Scalar 32-bit integer
where X is LOAD, CLEAR, DONT_CARE SECONDARY_COMMAND_BUFFERS
InstanceIndex Scalar 32-bit integer
storeOp, stencilStoreOp: VK_ATTACHMENT_STORE_OP_X typedef struct VkRenderPassBeginInfo {
where X is STORE, DONT_CARE Layer Scalar 32-bit integer
VkStructureType sType; P.15
const void* pNext; LocalInvocationID 3-component vector of 32-bit ints
typedef struct VkSubpassDescription {
VkSubpassDescriptionFlags flags; VkRenderPass renderPass; NumSubgroups Scalar 32-bit integer
VkPipelineBindPoint pipelineBindPoint; P.1315 VkFramebuffer framebuffer; NumWorkGroups 3-component vector of 32-bit ints
uint32_t inputAttachmentCount; VkRect2D renderArea; P.15 PatchVertices Scalar 32-bit integer
const VkAttachmentReference* pInputAttachments; uint32_t clearValueCount;
const VkClearValue* pClearValues; P.12 PointCoord 2-component vector of 32-bit floats
uint32_t colorAttachmentCount;
const VkAttachmentReference* pColorAttachments; } VkRenderPassBeginInfo; PointSize Scalar 32-bit float value
const VkAttachmentReference* pNext must be NULL or point to: Position 4-component vector of 32-bit floats
pResolveAttachments; VkDeviceGroupRenderPassBeginInfo P.12 PrimitiveID Scalar 32-bit integer
const VkAttachmentReference* SampleID Scalar 32-bit integer
pDepthStencilAttachment; void vkGetRenderAreaGranularity(
uint32_t preserveAttachmentCount; VkDevice device, VkRenderPass renderPass, SampleMask Array of 32-bit integers
const uint32_t* pPreserveAttachments; VkExtent2D* pGranularity); P.12 SamplePosition 2-component vector of float values
} VkSubpassDescription; void vkCmdNextSubpass( SubgroupId Scalar 32-bit integer
typedef struct VkAttachmentReference { VkCommandBuffer commandBuffer, Subgroup{Eq,Ge,Gt,Le,Lt}Mask 4-component vector of 32-bit ints
uint32_t attachment; VkSubpassContents contents);
SubgroupLocalInvocationId Scalar 32-bit integer
VkImageLayout layout; P.13 contents: VK_SUBPASS_CONTENTS_X where X is
INLINE, SECONDARY_COMMAND_BUFFERS SubgroupSize Scalar 32-bit integer
} VkAttachmentReference;
TessCoord 3-component vector of 32-bit floats
void vkCmdEndRenderPass( TessLevelOuter Array of size 2 of 32-bit floats
VkCommandBuffer commandBuffer);
TessLevelInner Array of size 4 of 32-bit floats
VertexIndex 32-bit integer
Pipelines [9] In VkGraphicsPipelineCreateInfo below, replace X with
VkPipeline and replace Y with StateCreateInfo. For example,
ViewIndex Scalar 32-bit integer
Compute Pipelines [9.1] XVertexInputY would be VxPipelineVertexInputStateCreateInfo. ViewportIndex 32-bit integer
Compute pipelines consist of a single static compute shader WorkgroupSize 3-component vector of 32-bit ints
typedef struct VkGraphicsPipelineCreateInfo {
stage and the pipeline layout. VkStructureType sType; P.15 WorkgroupID 3-component vector of 32-bit ints
VkResult vkCreateComputePipelines( const void* pNext;
VkDevice device, VkPipelineCache pipelineCache, VkPipelineCreateFlags flags; P.15
uint32_t createInfoCount, uint32_t stageCount; typedef struct VkPipelineVertexInputStateCreateInfo {
const VkComputePipelineCreateInfo* pCreateInfos, const VkPipelineShaderStageCreateInfo* pStages; P.15 VkStructureType sType; P.15
const VkAllocationCallbacks* pAllocator, P.12 const XVertexInputY* pVertexInputState; const void* pNext;
VkPipeline* pPipelines); const XInputAssemblyY* pInputAssemblyState; VkPipelineVertexInputStateCreateFlags flags; = 0
const XTessellationY* pTessellationState; uint32_t vertexBindingDescriptionCount;
typedef struct VkComputePipelineCreateInfo { const XViewportY* pViewportState; const VkVertexInputBindingDescription*
VkStructureType sType; P.15 const XRasterizationY* pRasterizationState; pVertexBindingDescriptions;
const void* pNext; const XMultisampleY* pMultisampleState;
VkPipelineCreateFlags flags; P.15 uint32_t vertexAttributeDescriptionCount;
const XDepthStencilY* pDepthStencilState; const VkVertexInputAttributeDescription*
VkPipelineShaderStageCreateInfo stage; P.15 const XColorBlendY* pColorBlendState;
VkPipelineLayout layout; pVertexAttributeDescriptions;
const XDynamicY* pDynamicState; } VkPipelineVertexInputStateCreateInfo;
VkPipeline basePipelineHandle; VkPipelineLayout layout;
int32_t basePipelineIndex; VkRenderPass renderPass; typedef struct VkVertexInputBindingDescription {
} VkComputePipelineCreateInfo; uint32_t subpass; uint32_t binding;
Graphics Pipelines [9.2] VkPipeline basePipelineHandle; uint32_t stride;
VkResult vkCreateGraphicsPipelines( int32_t basePipelineIndex; VkVertexInputRate inputRate;
VkDevice device, VkPipelineCache pipelineCache, } VkGraphicsPipelineCreateInfo; } VkVertexInputBindingDescription;
uint32_t createInfoCount, inputRate:
const VkGraphicsPipelineCreateInfo* pCreateInfos, VK_VERTEX_INPUT_RATE_{VERTEX, INSTANCE}
const VkAllocationCallbacks* pAllocator, P.12
VkPipeline* pPipelines); Continued on next page >
©2018 Khronos Group - Rev. 1118 www.khronos.org/vulkan
Vulkan 1.1 Reference Guide Page 4
Pipelines (continued) typedef struct VkPipelineMultisampleStateCreateInfo { typedef struct VkPipelineColorBlendAttachmentState {
VkStructureType sType; P.15 VkBool32 blendEnable;
typedef struct VkVertexInputAttributeDescription { const void* pNext; VkBlendFactor srcColorBlendFactor;
uint32_t location; VkPipelineMultisampleStateCreateFlags flags; = 0 VkBlendFactor dstColorBlendFactor;
uint32_t binding; VkSampleCountFlagBits rasterizationSamples; P.15 VkBlendOp colorBlendOp; P.12
VkFormat format; P.13 VkBool32 sampleShadingEnable; VkBlendFactor srcAlphaBlendFactor;
uint32_t offset; float minSampleShading; VkBlendFactor dstAlphaBlendFactor;
} VkVertexInputAttributeDescription; const VkSampleMask* pSampleMask; VkBlendOp alphaBlendOp; P.12
VkBool32 alphaToCoverageEnable; VkColorComponentFlags colorWriteMask;
typedef struct VkPipelineInputAssemblyStateCreateInfo { VkBool32 alphaToOneEnable; } VkPipelineColorBlendAttachmentState;
VkStructureType sType; P.15 } VkPipelineMultisampleStateCreateInfo;
const void* pNext; enum VkBlendFactor: VK_BLEND_FACTOR_X where X is
VkPipelineInputAssemblyStateCreateFlags flags; = 0 typedef struct VkPipelineDepthStencilStateCreateInfo { ZERO, ONE, SRC_ALPHA_SATURATE,
VkPrimitiveTopology topology; VkStructureType sType; P.15 [ONE_MINUS_]SRC_COLOR, [ONE_MINUS_]DST_COLOR,
VkBool32 primitiveRestartEnable; const void* pNext; [ONE_MINUS_]SRC_ALPHA, [ONE_MINUS_]DST_ALPHA,
} VkPipelineInputAssemblyStateCreateInfo; VkPipelineDepthStencilStateCreateFlags flags; = 0 [ONE_MINUS_]CONSTANT_COLOR,
VkBool32 depthTestEnable; [ONE_MINUS_]CONSTANT_ALPHA,
topology: VK_PRIMITIVE_TOPOLOGY_X where X is [ONE_MINUS_]SRC1_COLOR,
POINT_LIST, LINE_LIST, LINE_STRIP, TRIANGLE_LIST, VkBool32 depthWriteEnable;
VkCompareOp depthCompareOp; P.12 [ONE_MINUS_]SRC1_ALPHA
TRIANGLE_STRIP, TRIANGLE_FAN,
LINE_{LIST, STRIP}_WITH_ADJACENCY, VkBool32 depthBoundsTestEnable; colorWriteMask:
TRIANGLE_{LIST, STRIP}_WITH_ADJACENCY, PATCH_LIST VkBool32 stencilTestEnable; VK_COLOR_COMPONENT_X_BIT where X is R, G, B, A
VkStencilOpState front; typedef struct VkPipelineDynamicStateCreateInfo {
typedef struct VkPipelineTessellationStateCreateInfo { VkStencilOpState back;
VkStructureType sType; P.15 VkStructureType sType; P.15
float minDepthBounds; const void* pNext;
const void* pNext; float maxDepthBounds;
VkPipelineTessellationStateCreateFlags flags; = 0 VkPipelineDynamicStateCreateFlags flags; = 0
} VkPipelineDepthStencilStateCreateInfo; uint32_t dynamicStateCount;
uint32_t patchControlPoints;
} VkPipelineTessellationStateCreateInfo; typedef struct VkStencilOpState { const VkDynamicState* pDynamicStates;
pNext must be NULL or point to: VkStencilOp failOp; } VkPipelineDynamicStateCreateInfo;
VkPipelineTessellationDomainOriginStateCreateInfo P.15 VkStencilOp passOp; pDynamicStates: Array of VK_DYNAMIC_STATE_X
VkStencilOp depthFailOp; where X is VIEWPORT, SCISSOR,
typedef struct VkPipelineViewportStateCreateInfo { VkCompareOp compareOp; P.12 LINE_WIDTH, DEPTH_BIAS, BLEND_CONSTANTS,
VkStructureType sType; P.15 uint32_t compareMask; DEPTH_BOUNDS, STENCIL_REFERENCE,
const void* pNext; uint32_t writeMask; STENCIL_COMPARE_MASK, STENCIL_WRITE_MASK
VkPipelineViewportStateCreateFlags flags; = 0 uint32_t reference;
uint32_t viewportCount; } VkStencilOpState; Pipeline Destruction [9.3]
const VkViewport* pViewports; P.15 enum VkStencilOp: VK_STENCIL_OP_X where X is KEEP, void vkDestroyPipeline(
uint32_t scissorCount; ZERO, REPLACE, INCREMENT_AND_{CLAMP, WRAP}, VkDevice device, VkPipeline pipeline,
const VkRect2D* pScissors; P.15 INVERT, DECREMENT_AND_{CLAMP, WRAP} const VkAllocationCallbacks* pAllocator); P.12
} VkPipelineViewportStateCreateInfo;
typedef struct VkPipelineColorBlendStateCreateInfo { Pipeline Cache [9.6]
typedef struct VkPipelineRasterizationStateCreateInfo { VkStructureType sType; P.15 Pipeline cache objects allow the result of pipeline construction
VkStructureType sType; P.15 const void* pNext; to be reused between pipelines and between runs of an
const void* pNext; VkPipelineColorBlendStateCreateFlags flags; = 0 application.
VkPipelineRasterizationStateCreateFlags flags; = 0 VkBool32 logicOpEnable;
VkBool32 depthClampEnable; VkResult vkCreatePipelineCache(VkDevice device,
VkLogicOp logicOp; const VkPipelineCacheCreateInfo* pCreateInfo,
VkBool32 rasterizerDiscardEnable; uint32_t attachmentCount;
VkPolygonMode polygonMode; const VkAllocationCallbacks* pAllocator, P.12
const VkPipelineColorBlendAttachmentState* VkPipelineCache* pPipelineCache);
VkCullModeFlags cullMode; pAttachments;
VkFrontFace frontFace; float blendConstants[4]; typedef struct VkPipelineCacheCreateInfo {
VkBool32 depthBiasEnable; } VkPipelineColorBlendStateCreateInfo; VkStructureType sType; P.15
float depthBiasConstantFactor; const void* pNext;
float depthBiasClamp; logicOp: VK_LOGIC_OP_X where X is CLEAR, AND,
AND_REVERSE, COPY, AND_INVERTED, NO_OP, XOR, OR, VkPipelineCacheCreateFlags flags; = 0
float depthBiasSlopeFactor; size_t initialDataSize;
float lineWidth; NOR, EQUIVALENT, INVERT, OR_REVERSE,
COPY_INVERTED, OR_INVERTED, NAND, SET const void* pInitialData;
} VkPipelineRasterizationStateCreateInfo; } VkPipelineCacheCreateInfo;
polygonMode: VK_POLYGON_MODE_{FILL, LINE, POINT} blendOp: VK_BLEND_OP_X where X is ADD, SUBTRACT,
REVERSE_SUBTRACT, MIN, MAX VkResult vkMergePipelineCaches(VkDevice device,
cullMode: VK_CULL_MODE_X where X is NONE, FRONT_BIT, VkPipelineCache dstCache, uint32_t srcCacheCount,
BACK_BIT, FRONT_AND_BACK colorWriteMask: VK_COLOR_COMPONENT_X where X is
R_BIT, G_BIT, B_BIT, A_BIT const VkPipelineCache* pSrcCaches);
frontFace: VK_FRONT_FACE_[COUNTER_]CLOCKWISE
VkResult vkGetPipelineCacheData(VkDevice device,
VkPipelineCache pipelineCache,
size_t* pDataSize, void* pData);
Memory Allocation [10] void vkFreeMemory(
VkDevice device, void vkDestroyPipelineCache(VkDevice device,
Device Memory [10.2] VkDeviceMemory memory, VkPipelineCache pipelineCache,
Device memory is memory that is visible to the device. const VkAllocationCallbacks* pAllocator); P.12 const VkAllocationCallbacks* pAllocator); P.12
void vkGetPhysicalDeviceMemoryProperties( Host Access to Device Memory Objects [10.2.1] Pipeline Binding [9.8]
VkPhysicalDevice physicalDevice, Memory objects created with vkAllocateMemory are not void vkCmdBindPipeline(
VkPhysicalDeviceMemoryProperties* directly host accessible. Memory objects created with memory VkCommandBuffer commandBuffer,
pMemoryProperties); P.14 property VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT are VkPipelineBindPoint pipelineBindPoint, P.13
considered mappable. Memory objects must be mappable in VkPipeline pipeline);
void vkGetPhysicalDeviceMemoryProperties2( order to be successfully mapped on the host.
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceMemoryProperties2* VkResult vkMapMemory(
pMemoryProperties); VkDevice device, void vkUnmapMemory(
VkDeviceMemory memory, VkDevice device,
typedef struct VkPhysicalDeviceMemoryProperties2 { VkDeviceSize offset, VkDeviceMemory memory);
VkStructureType sType; P.15 VkDeviceSize size,
void* pNext; VkMemoryMapFlags flags, = 0 Lazily Allocated Memory [10.2.2]
VkPhysicalDeviceMemoryProperties void** ppData); If the memory object is allocated from a heap with the
memoryProperties; P.14 VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT bit set,
} VkPhysicalDeviceMemoryProperties2; VkResult vkFlushMappedMemoryRanges( that object’s backing memory may be provided by the
VkDevice device, implementation lazily.
VkResult vkAllocateMemory( uint32_t memoryRangeCount,
VkDevice device, const VkMappedMemoryRange* pMemoryRanges); void vkGetDeviceMemoryCommitment(
const VkMemoryAllocateInfo* pAllocateInfo, VkDevice device,
const VkAllocationCallbacks* pAllocator, P.12 VkResult vkInvalidateMappedMemoryRanges( VkDeviceMemory memory,
VkDeviceMemory* pMemory); VkDevice device, VkDeviceSize* pCommittedMemoryInBytes);
uint32_t memoryRangeCount,
typedef struct VkMemoryAllocateInfo { const VkMappedMemoryRange* pMemoryRanges); Peer Memory Features [10.2.4]
VkStructureType sType; P.15 const void* pNext; void vkGetDeviceGroupPeerMemoryFeatures(
VkDeviceSize* allocationSize; uint32_t memoryTypeIndex; typedef struct VkMappedMemoryRange { VkDevice device, uint32_t heapIndex,
} VkMemoryAllocateInfo; VkStructureType sType; P.15 uint32_t localDeviceIndex, uint32_t remoteDeviceIndex,
pNext must be NULL or point to one of: const void* pNext; VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);
VkExportMemoryAllocateInfo P.12 VkDeviceMemory memory; pPeerMemoryFeatures: VK_PEER_MEMORY_FEATURE_X
VkMemoryAllocateFlagsInfo P.13 VkDeviceSize offset; VkDeviceSize size; where X is COPY_SRC_BIT, COPY_DST_BIT,
VkMemoryDedicatedAllocateInfo P.13 } VkMappedMemoryRange; GENERIC_SRC_BIT, GENERIC_DST_BIT
©2018 Khronos Group - Rev. 1118 www.khronos.org/vulkan
Vulkan 1.1 Reference Guide Page 5
Vulkan Pipeline Diagram [9]
Draw Indirect Buffer Dispatch

Input Assembler Index Buffer

Vertex Shader Vertex Buffer

Tessella�on Control Shader Descriptor Sets

Push Constants
Tessella�on Primi�ve Generator
Uniform Buffer
Tessella�on Evalua�on Shader Uniform Texel Buffers
Compute Shader
Sampled Images
Geometry Shader Storage Buffers
Storage Texel Buffers Some Vulkan commands specify geometric objects
to be drawn or computational work to be performed,
Storage Images while others specify state controlling how objects
Vertex Post-Processing
are handled by the various pipeline stages, or control
data transfer between memory organized as images
Rasteriza�on and buffers. Commands are effectively sent through
a processing pipeline, either a graphics pipeline or a
Early Per-Fragment Tests Depth/Stencil Attachments compute pipeline.
Fixed Function Stage
Fragment Shader Input Attachments
Shader Stage
Late Post-Fragment Tests Storage Images
Blending Color Attachments

Command Buffer Lifecycle [5.1] Allocate

A command buffer is always in one of the five states shown below:
Initial state Initial
The state when a command buffer is first Executable command buffers can be Reset Reset
allocated. The command buffer may be reset submitted, reset, or recorded to another Begin
back to this state from any of the executable, command buffer.
recording, or invalid states. Command buffers Pending state
in the initial state can only be moved to
recording, or freed. Queue submission changes the state from
executable to pending, in which applications Invalid Recording
must not attempt to modify the command Invalidate
Recording state
vkBeginCommandBuffer changes the buffer in any way. The state reverts back
state from initial to recording. Once in the to executable when current executions
recording state, vkCmd* commands can be complete, or to invalid. Completion with End
used to record to the command buffer. One Time Submit
Invalid state Completion
Executable state Some operations will transition the command Pending Executable
vkEndCommandBuffer moves a command buffer into the invalid state, in which it can
only be reset or freed. Submission
buffer state from recording to executable.

Resource Creation [11] Buffer Views [11.2] typedef struct VkImageCreateInfo {

VkStructureType sType; P.15
A buffer view represents a contiguous range of a buffer and a
Buffers [11.1] specific format to be used to interpret the data. const void* pNext;
Buffers represent linear arrays of data which are used for various VkImageCreateFlags flags; P.13
purposes by binding them to a graphics or compute pipeline via VkResult vkCreateBufferView( VkImageType imageType; P.13
descriptor sets or via certain commands, or by directly specifying VkDevice device, VkFormat format; P.13
them as parameters to certain commands. const VkBufferViewCreateInfo* pCreateInfo, VkExtent3D extent; PP.12
const VkAllocationCallbacks* pAllocator, P.12 uint32_t mipLevels; uint32_t arrayLayers;
VkResult vkCreateBuffer( VkBufferView* pView); VkSampleCountFlagBits samples; P.15
VkDevice device, VkImageTiling tiling; P.13
const VkBufferCreateInfo* pCreateInfo, typedef struct VkBufferViewCreateInfo {
VkStructureType sType; P.15 VkImageUsageFlags usage; P.13
const VkAllocationCallbacks* pAllocator, P.12 VkSharingMode sharingMode; P.15
VkBuffer* pBuffer); const void* pNext;
VkBufferViewCreateFlags flags; = 0 uint32_t queueFamilyIndexCount;
typedef struct VkBufferCreateInfo { VkBuffer buffer; const uint32_t* pQueueFamilyIndices;
VkStructureType sType; P.15 VkFormat format; P.13 VkImageLayout initialLayout; P.13
const void* pNext; VkDeviceSize offset; VkDeviceSize range; } VkImageCreateInfo;
VkBufferCreateFlags flags; } VkBufferViewCreateInfo; pNext must be NULL or point to:
VkDeviceSize size; VkExternalMemoryImageCreateInfo P.13
VkBufferUsageFlags usage; P.12 void vkDestroyBufferView(
VkSharingMode sharingMode; P.15 VkDevice device, typedef struct VkImageSwapchainCreateInfoKHR {
uint32_t queueFamilyIndexCount; VkBufferView bufferView, VkStructureType sType; P.15
const uint32_t* pQueueFamilyIndices; const VkAllocationCallbacks* pAllocator); P.12 const void* pNext;
} VkBufferCreateInfo; VkSwapchainKHR swapchain;
Images [11.3] } VkImageSwapchainCreateInfoKHR;
flags: Images represent multidimensional (up to 3) arrays of data which
VK_BUFFER_CREATE_SPARSE_X_BIT where X is ALIASED, can be used for various purposes by binding them to the graphics void vkGetImageSubresourceLayout(
BINDING, PROTECTED, RESIDENCY or compute pipeline via descriptor sets, or by directly specifying VkDevice device, VkImage image,
pNext must be NULL or point to: them as parameters to certain commands. const VkImageSubresource* pSubresource,
VkExternalMemoryBufferCreateInfo P.12 VkSubresourceLayout* pLayout);
VkResult vkCreateImage(
void vkDestroyBuffer( VkDevice device, typedef struct VkImageSubresource {
VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImageAspectFlags aspectMask; P.13
VkBuffer buffer, const VkAllocationCallbacks* pAllocator, P.12 uint32_t mipLevel;
const VkAllocationCallbacks* pAllocator); P.12 VkImage* pImage); uint32_t arrayLayer;
} VkImageSubresource;

©2018 Khronos Group - Rev. 1118 www.khronos.org/vulkan

Vulkan 1.1 Reference Guide Page 6
Continued on next page > typedef struct VkComponentMapping { typedef struct VkImageMemoryRequirementsInfo2 {
VkComponentSwizzle r; VkStructureType sType; P.15
Resource Creation (continued) VkComponentSwizzle g; const void* pNext;
typedef struct VkSubresourceLayout { VkComponentSwizzle b; VkImage image;
VkDeviceSize offset; VkComponentSwizzle a; } VkImageMemoryRequirementsInfo2;
VkDeviceSize size; } VkComponentMapping; pNext must be NULL or point to:
VkDeviceSize rowPitch; enum VkComponentSwizzle: VK_COMPONENT_SWIZZLE_X VkImagePlaneMemoryRequirementsInfo P.13
VkDeviceSize arrayPitch; where X is IDENTITY, ZERO, ONE, R, G, B, A VkResult vkBindBufferMemory(VkDevice device,
VkDeviceSize depthPitch; void vkDestroyImageView(VkDevice device, VkBuffer buffer, VkDeviceMemory memory,
} VkSubresourceLayout; VkImageView imageView, VkDeviceSize memoryOffset);
void vkDestroyImage( const VkAllocationCallbacks* pAllocator); P.12 VkResult vkBindBufferMemory2(VkDevice device,
VkDevice device, VkImage image, uint32_t bindInfoCount,
const VkAllocationCallbacks* pAllocator); P.12 Resource Memory Association [11.6]
Resources are initially created as virtual allocations with no const VkBindBufferMemoryInfo* pBindInfos);
Image Views [11.5] backing memory. Device memory is allocated separately and typedef struct VkBindBufferMemoryInfo {
Image objects are not directly accessed by pipeline shaders for then associated with the resource. VkStructureType sType; P.15
reading or writing image data. Instead, image views representing void vkGetBufferMemoryRequirements( const void* pNext;
contiguous ranges of the image subresources and containing VkDevice device, VkBuffer buffer;
additional metadata are used for that purpose. VkBuffer buffer, VkDeviceMemory memory;
VkResult vkCreateImageView( VkMemoryRequirements* pMemoryRequirements); P.13 VkDeviceSize memoryOffset;
VkDevice device, } VkBindBufferMemoryInfo;
void vkGetBufferMemoryRequirements2(VkDevice device, pNext must be NULL or point to:
const VkImageViewCreateInfo* pCreateInfo, const VkBufferMemoryRequirementsInfo2* pInfo,
const VkAllocationCallbacks* pAllocator, P.12 VkBindBufferMemoryDeviceGroupInfo P.12
VkMemoryRequirements2* pMemoryRequirements); P.13
VkImageView* pView); VkResult vkBindImageMemory(VkDevice device,
typedef struct VkBufferMemoryRequirementsInfo2 { VkImage image, VkDeviceMemory memory,
typedef struct VkImageViewCreateInfo { VkStructureType sType; P.15
VkStructureType sType; P.15 VkDeviceSize memoryOffset);
const void* pNext;
const void* pNext; VkBuffer buffer; VkResult vkBindImageMemory2(VkDevice device,
VkImageViewCreateFlags flags; = 0 } VkBufferMemoryRequirementsInfo2; uint32_t bindInfoCount,
VkImage image; const VkBindImageMemoryInfo* pBindInfos);
VkImageViewType viewType; void vkGetImageMemoryRequirements(
VkFormat format; P.13 VkDevice device, VkImage image, typedef struct VkBindImageMemoryInfo {
VkComponentMapping components; VkMemoryRequirements* pMemoryRequirements); P.13 VkStructureType sType; P.15
VkImageSubresourceRange subresourceRange; P.13 const void* pNext;
} VkImageViewCreateInfo; void vkGetImageMemoryRequirements2(VkDevice device, VkImage image;
const VkImageMemoryRequirementsInfo2* pInfo, VkDeviceMemory memory;
viewType: VK_IMAGE_VIEW_TYPE_X where X is 1D, 2D, 3D, VkMemoryRequirements2* pMemoryRequirements); P.13
CUBE, 1D_ARRAY, 2D_ARRAY, CUBE_ARRAY VkDeviceSize memoryOffset;
} VkBindImageMemoryInfo;
pNext must be NULL or point to one of:
VkImageViewUsageCreateInfo P.13 pNext must be NULL or point to one of:
VkSamplerYcbcrConversionInfo P.15 VkBindImageMemoryDeviceGroupInfo P.12
VkBindImagePlaneMemoryInfo P.12

Samplers [12] magFilter, minFilter: VK_FILTER_NEAREST,

VK_FILTER_LINEAR
typedef struct VkSamplerYcbcrConversionCreateInfo {
VkStructureType sType; P.15
VkSampler objects encapsulate the state of an image sampler
which is used by the implementation to read image data and mipmapMode: const void* pNext;
apply filtering and other transformations for the shader. VK_SAMPLER_MIPMAP_MODE_{NEAREST, LINEAR} VkFormat format; P.13
VkSamplerYcbcrModelConversion ycbcrModel;
VkResult vkCreateSampler( borderColor: VK_BORDER_COLOR_{FLOAT, INT}_X VkSamplerYcbcrRange ycbcrRange;
VkDevice device, where X is TRANSPARENT_BLACK, OPAQUE_BLACK, VkComponentMapping components;
const VkSamplerCreateInfo* pCreateInfo, OPAQUE_WHITE VkChromaLocation xChromaOffset;
const VkAllocationCallbacks* pAllocator, P.12 addressMode{U, V, W}: VkChromaLocation yChromaOffset;
VkSampler* pSampler); VK_SAMPLER_ADDRESS_MODE_X where X is REPEAT, VkFilter chromaFilter;
MIRRORED_REPEAT, MIRROR_CLAMP_TO_EDGE, VkBool32 forceExplicitReconstruction;
typedef struct VkSamplerCreateInfo { CLAMP_TO_EDGE, CLAMP_TO_BORDER } VkSamplerYcbcrConversionCreateInfo;
VkStructureType sType; P.15 pNext must be NULL or point to:
const void* pNext; VkSamplerYcbcrModelConversion:
VkSamplerYcbcrConversionInfo P.15 VK_SAMPLER_YCBCR_MODEL_CONVERSION_X where X
VkSamplerCreateFlags flags; = 0
VkFilter magFilter; VkFilter minFilter; void vkDestroySampler( is {RGB, YCBCR}_IDENTITY, YCBCR_{709, 601, 2020}
VkSamplerMipmapMode mipmapMode; VkDevice device, VkSamplerYcbcrRange:
VkSamplerAddressMode addressModeU; VkSampler sampler, VK_SAMPLER_YCBCR_RANGE_ITU_{FULL, NARROW}
VkSamplerAddressMode addressModeV; const VkAllocationCallbacks* pAllocator); P.12 VkChromaLocation:
VkSamplerAddressMode addressModeW; VK_CHROMA_LOCATION_{COSITED_EVEN, MIDPOINT}
float mipLodBias; VkBool32 anisotropyEnable; Sampler Y’CBCR Conversion [12.1]
float maxAnisotropy; VkBool32 compareEnable; VkFilter:
VkResult vkCreateSamplerYcbcrConversion( VK_FILTER_{NEAREST, LINEAR}
VkCompareOp compareOp; P.12 VkDevice device,
float minLod; float maxLod; const VkSamplerYcbcrConversionCreateInfo* void vkDestroySamplerYcbcrConversion(VkDevice device,
VkBorderColor borderColor; pCreateInfo, VkSamplerYcbcrConversion ycbcrConversion,
VkBool32 unnormalizedCoordinates; const VkAllocationCallbacks* pAllocator, P.12 const VkAllocationCallbacks* pAllocator); P.12
} VkSamplerCreateInfo; VkSamplerYcbcrConversion* pYcbcrConversion);

Resource Descriptors [13] void vkDestroyDescriptorSetLayout(

VkDevice device,
typedef struct VkPushConstantRange {
VkShaderStageFlags stageFlags; P.15
An opaque data structure representing a shader resource e.g., a
buffer view, image view, sampler, or combined image sampler. VkDescriptorSetLayout descriptorSetLayout,, uint32_t offset; uint32_t size;
const VkAllocationCallbacks* pAllocator); P.12 } VkPushConstantRange;
Descriptor Set Layout [13.2.1] void vkDestroyPipelineLayout(
VkResult vkCreateDescriptorSetLayout( Pipeline Layouts [13.2.2]
VkResult vkCreatePipelineLayout( VkDevice device, VkPipelineLayout pipelineLayout,
VkDevice device, const VkAllocationCallbacks* pAllocator); P.12
const VkDescriptorSetLayoutCreateInfo* pCreateInfo, P.12 VkDevice device,
const VkAllocationCallbacks* pAllocator, P.12 const VkPipelineLayoutCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator, P.12 Allocation of Descriptor Sets [13.2.3]
VkDescriptorSetLayout* pSetLayout); VkResult vkCreateDescriptorPool(
VkPipelineLayout* pPipelineLayout);
void vkGetDescriptorSetLayoutSupport( VkDevice device,
VkDevice device, typedef struct VkPipelineLayoutCreateInfo { const VkDescriptorPoolCreateInfo* pCreateInfo,
const VkDescriptorSetLayoutCreateInfo* pCreateInfo, P.1512 VkStructureType sType; P.15 const VkAllocationCallbacks* pAllocator, P.12
VkDescriptorSetLayoutSupport* pSupport); const void* pNext; VkDescriptorPool* pDescriptorPool);
VkPipelineLayoutCreateFlags flags; = 0
typedef struct VkDescriptorSetLayoutSupport { uint32_t setLayoutCount; typedef struct VkDescriptorPoolCreateInfo {
VkStructureType sType; P.15 const VkDescriptorSetLayout* pSetLayouts; VkStructureType sType; P.15
void* pNext; VkBool32 supported; uint32_t pushConstantRangeCount; const void* pNext; VkDescriptorPoolCreateFlags flags;
} VkDescriptorSetLayoutSupport; const VkPushConstantRange* pPushConstantRanges; uint32_t maxSets; uint32_t poolSizeCount;
} VkPipelineLayoutCreateInfo; const VkDescriptorPoolSize* pPoolSizes;
} VkDescriptorPoolCreateInfo;
Continued on next page >

©2018 Khronos Group - Rev. 1118 www.khronos.org/vulkan

Vulkan 1.1 Reference Guide Page 7
Resource Descriptors (continued) typedef struct VkDescriptorImageInfo {
VkSampler sampler;
void vkDestroyDescriptorUpdateTemplate(
flags: VkDevice device,
VkImageView imageView; VkDescriptorUpdateTemplate
VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT VkImageLayout imageLayout; P.13 descriptorUpdateTemplate,
typedef struct VkDescriptorPoolSize { } VkDescriptorImageInfo; const VkAllocationCallbacks* pAllocator); P.12
VkDescriptorType type; P.12 typedef struct VkDescriptorBufferInfo { void vkUpdateDescriptorSetWithTemplate(
uint32_t descriptorCount; VkBuffer buffer; VkDevice device,
} VkDescriptorPoolSize; VkDeviceSize offset; VkDeviceSize range; VkDescriptorSet descriptorSet,
void vkDestroyDescriptorPool( } VkDescriptorBufferInfo; VkDescriptorUpdateTemplate
VkDevice device, typedef struct VkCopyDescriptorSet { descriptorUpdateTemplate,
VkDescriptorPool descriptorPool, VkStructureType sType; P.15 const void* pData);
const VkAllocationCallbacks* pAllocator); P.12 const void* pNext; VkDescriptorSet srcSet; Descriptor Set Binding [13.2.7]
VkResult vkAllocateDescriptorSets( uint32_t srcBinding; void vkCmdBindDescriptorSets(
VkDevice device, uint32_t srcArrayElement; VkCommandBuffer commandBuffer,
const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet dstSet; VkPipelineBindPoint pipelineBindPoint, P.1315
VkDescriptorSet* pDescriptorSets); uint32_t dstBinding; VkPipelineLayout layout, P.15
uint32_t dstArrayElement; uint32_t firstSet,
typedef struct VkDescriptorSetAllocateInfo { uint32_t descriptorCount; uint32_t descriptorSetCount,
VkStructureType sType; P.15 } VkCopyDescriptorSet; const VkDescriptorSet* pDescriptorSets,
const void* pNext; VkDescriptorPool descriptorPool; uint32_t dynamicOffsetCount,
uint32_t descriptorSetCount; Descriptor Set Updates with Templates [13.2.6] const uint32_t* pDynamicOffsets);
const VkDescriptorSetLayout* pSetLayouts; VkResult vkCreateDescriptorUpdateTemplate(
} VkDescriptorSetAllocateInfo; VkDevice device, Push Constant Updates [13.2.8]
const VkDescriptorUpdateTemplateCreateInfo* The pipeline layout defines shader push constants which
VkResult vkFreeDescriptorSets( pCreateInfo,
VkDevice device, are updated via Vulkan commands rather than via writes to
const VkAllocationCallbacks* pAllocator, P.12 memory or copy commands.
VkDescriptorPool descriptorPool, VkDescriptorUpdateTemplate*
uint32_t descriptorSetCount, pDescriptorUpdateTemplate); void vkCmdPushConstants(
const VkDescriptorSet* pDescriptorSets); VkCommandBuffer commandBuffer,
typedef struct VkDescriptorUpdateTemplateCreateInfo { VkPipelineLayout layout, P.15
VkResult vkResetDescriptorPool( VkStructureType sType; P.15 VkShaderStageFlags stageFlags, P.15
VkDevice device, void* pNext; uint32_t offset, uint32_t size,
VkDescriptorPool descriptorPool, VkDescriptorUpdateTemplateCreateFlags flags; = 0 const void* pValues);
VkDescriptorPoolResetFlags flags); uint32_t descriptorUpdateEntryCount;
Descriptor Set Updates [13.2.4] const VkDescriptorUpdateTemplateEntry*
pDescriptorUpdateEntries;
void vkUpdateDescriptorSets(
VkDevice device,
VkDescriptorUpdateTemplateType templateType; Clear Commands [17]
uint32_t descriptorWriteCount, VkDescriptorSetLayout descriptorSetLayout;
VkPipelineBindPoint pipelineBindPoint; P.1315 Outside a Render Pass Instance [17.1]
const VkWriteDescriptorSet* pDescriptorWrites, void vkCmdClearColorImage(
uint32_t descriptorCopyCount, VkPipelineLayout pipelineLayout;
uint32_t set; = 0 VkCommandBuffer commandBuffer,
const VkCopyDescriptorSet* pDescriptorCopies); VkImage image,
} VkDescriptorUpdateTemplateCreateInfo;
typedef struct VkWriteDescriptorSet { VkImageLayout imageLayout, P.13
VKPipelineBindPoint: VK_PIPELINE_BIND_POINT_X const VkClearColorValue* pColor, P.12
VkStructureType sType; P.15 where X is GRAPHICS, COMPUTE uint32_t rangeCount,
const void* pNext; VkDescriptorSet dstSet; const VkImageSubresourceRange* pRanges); P.13
uint32_t dstBinding; templateType: VK_DESCRIPTOR_UPDATE_TEMPLATE_-
uint32_t dstArrayElement; TYPE_DESCRIPTOR_SET imageLayout:
uint32_t descriptorCount; VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
typedef struct VkDescriptorUpdateTemplateEntry { VK_IMAGE_LAYOUT_GENERAL.
VkDescriptorType descriptorType; P.12 uint32_t dstBinding;
const VkDescriptorImageInfo* pImageInfo; VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR
uint32_t dstArrayElement;
const VkDescriptorBufferInfo* pBufferInfo; uint32_t descriptorCount; void vkCmdClearDepthStencilImage(
const VkBufferView* pTexelBufferView; VkDescriptorType descriptorType; P.12 VkCommandBuffer commandBuffer,
} VkWriteDescriptorSet; size_t offset; size_t stride; VkImage image,
} VkDescriptorUpdateTemplateEntry; VkImageLayout imageLayout, P.13
const VkClearDepthStencilValue* pDepthStencil, P.12
uint32_t rangeCount,
Queries [16] void vkCmdEndQuery( const VkImageSubresourceRange* pRanges); P.13
VkCommandBuffer commandBuffer, imageLayout:
Query Pools [16.1] VkQueryPool queryPool, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
uint32_t query); VK_IMAGE_LAYOUT_GENERAL
VkResult vkCreateQueryPool(
VkDevice device, VkResult vkGetQueryPoolResults( Inside a Render Pass Instance [17.2]
const VkQueryPoolCreateInfo* pCreateInfo, VkDevice device, void vkCmdClearAttachments(
const VkAllocationCallbacks* pAllocator, P.12 VkQueryPool queryPool, VkCommandBuffer commandBuffer,
VkQueryPool* pQueryPool); uint32_t firstQuery, uint32_t attachmentCount,
uint32_t queryCount, const VkClearAttachment* pAttachments,
typedef struct VkQueryPoolCreateInfo { size_t dataSize, uint32_t rectCount,
VkStructureType sType; P.15 void* pData, const VkClearRect* pRects);
const void* pNext; VkDeviceSize stride,
VkQueryPoolCreateFlags flags; = 0 VkQueryResultFlags flags); typedef struct VkClearRect {
VkQueryType queryType; VkRect2D rect; P.15
uint32_t queryCount; flags: VK_QUERY_RESULT_X_BIT where X is
64, WAIT, WITH_AVAILABILITY, PARTIAL
uint32_t baseArrayLayer;
VkQueryPipelineStatisticFlags pipelineStatistics; P.15 uint32_t layerCount;
} VkQueryPoolCreateInfo; void vkCmdCopyQueryPoolResults( } VkClearRect;
queryType: VK_QUERY_TYPE_OCCLUSION, VkCommandBuffer commandBuffer, typedef struct VkClearAttachment {
VK_QUERY_TYPE_PIPELINE_STATISTICS, VkQueryPool queryPool, VkImageAspectFlags aspectMask; P.13
VK_QUERY_TYPE_TIMESTAMP uint32_t firstQuery, uint32_t colorAttachment;
uint32_t queryCount, VkClearValue clearValue; P.12
void vkDestroyQueryPool( VkBuffer dstBuffer,
VkDevice device, VkDeviceSize dstOffset, } VkClearAttachment;
VkQueryPool queryPool, VkDeviceSize stride, Filling Buffers [17.4]
const VkAllocationCallbacks* pAllocator); P.12 VkQueryResultFlags flags); void vkCmdFillBuffer(
Query Operation [16.2] flags: VK_QUERY_RESULT_X_BIT where X is VkCommandBuffer commandBuffer,
void vkCmdResetQueryPool( 64, WAIT, WITH_AVAILABILITY, PARTIAL VkBuffer dstBuffer, VkDeviceSize dstOffset,
VkCommandBuffer commandBuffer, VkDeviceSize size, uint32_t data);
VkQueryPool queryPool,
Timestamp Queries [16.5]
uint32_t firstQuery, void vkCmdWriteTimestamp( Updating Buffers [17.5]
uint32_t queryCount); VkCommandBuffer commandBuffer, void vkCmdUpdateBuffer(
VkPipelineStageFlagBits pipelineStage, P.15 VkCommandBuffer commandBuffer,
void vkCmdBeginQuery( VkQueryPool queryPool, VkBuffer dstBuffer, VkDeviceSize dstOffset,
VkCommandBuffer commandBuffer, uint32_t query); VkDeviceSize dataSize, const void* pData);
VkQueryPool queryPool,
uint32_t entry,
VkQueryControlFlags flags);
flags: VK_QUERY_CONTROL_PRECISE_BIT

©2018 Khronos Group - Rev. 1118 www.khronos.org/vulkan

Vulkan 1.1 Reference Guide Page 8
Drawing Commands [19] Copy Commands [18] void vkCmdCopyImageToBuffer(
VkCommandBuffer commandBuffer,
void vkCmdBindIndexBuffer( Copying Data Between Buffers [18.2] VkImage srcImage,
VkCommandBuffer commandBuffer, void vkCmdCopyBuffer( VkImageLayout srcImageLayout, P.13
VkBuffer buffer, VkDeviceSize offset, VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
VkIndexType indexType); VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount,
indexType: VK_INDEX_TYPE_UINT{16, 32} uint32_t regionCount, const VkBufferImageCopy* pRegions);
const VkBufferCopy* pRegions); typedef struct VkBufferImageCopy {
void vkCmdDraw(
VkCommandBuffer commandBuffer, typedef struct VkBufferCopy { VkDeviceSize bufferOffset;
uint32_t vertexCount, uint32_t instanceCount, VkDeviceSize srcOffset; VkDeviceSize dstOffset; uint32_t bufferRowLength;
uint32_t firstVertex, uint32_t firstInstance); VkDeviceSize size; uint32_t bufferImageHeight;
} VkBufferCopy; VkImageSubresourceLayers imageSubresource; P.13
void vkCmdDrawIndexed( VkOffset3D imageOffset; P14
VkCommandBuffer commandBuffer, Copying Data Between Images [18.3] VkExtent3D imageExtent; P12
uint32_t indexCount, uint32_t instanceCount, void vkCmdCopyImage( } VkBufferImageCopy;
uint32_t firstIndex, int32_t vertexOffset, VkCommandBuffer commandBuffer, Image Copies With Scaling [18.5]
uint32_t firstInstance); VkImage srcImage, void vkCmdBlitImage(
void vkCmdDrawIndirect( VkImageLayout srcImageLayout, P.13 VkCommandBuffer commandBuffer,
VkCommandBuffer commandBuffer, VkImage dstImage, VkImage srcImage,
VkBuffer buffer, VkDeviceSize offset, VkImageLayout dstImageLayout, P.13 VkImageLayout srcImageLayout, P.13
uint32_t regionCount, VkImage dstImage,
uint32_t drawCount, const VkImageCopy* pRegions);
uint32_t stride); VkImageLayout dstImageLayout, P.13
typedef struct VkImageCopy { uint32_t regionCount,
typedef struct VkDrawIndirectCommand { VkImageSubresourceLayers srcSubresource; P.13 const VkImageBlit* pRegions,
uint32_t vertexCount; uint32_t instanceCount; VkFilter filter);
VkOffset3D srcOffset; P14
uint32_t firstVertex; uint32_t firstInstance; VkImageSubresourceLayers dstSubresource; P.13 filter: VK_FILTER_NEAREST, VK_FILTER_LINEAR
} VkDrawIndirectCommand; VkOffset3D dstOffset; P.13 typedef struct VkImageBlit {
void vkCmdDrawIndexedIndirect( VkExtent3D extent; P12 VkImageSubresourceLayers srcSubresource; P.13
VkCommandBuffer commandBuffer, } VkImageCopy; VkOffset3D srcOffsets[2]; P14
VkBuffer buffer, VkDeviceSize offset, VkImageSubresourceLayers dstSubresource; P.13
uint32_t drawCount, uint32_t stride); Copying Data Between Buffers and Images [18.4] VkOffset3D dstOffsets[2]; P.13
void vkCmdCopyBufferToImage( } VkImageBlit;
typedef struct VkDrawIndexedIndirectCommand { VkCommandBuffer commandBuffer,
uint32_t indexCount; uint32_t instanceCount; VkBuffer srcBuffer, VkImage dstImage, Resolving Multisample Images [18.6]
uint32_t firstIndex; int32_t vertexOffset; VkImageLayout dstImageLayout, P.13 void vkCmdResolveImage(
uint32_t firstInstance; uint32_t regionCount, VkCommandBuffer commandBuffer,
} VkDrawIndexedIndirectCommand; const VkBufferImageCopy* pRegions); VkImage srcImage,
VkImageLayout srcImageLayout, P.13
VkImage dstImage,
Vertex Input Description [20.2] VkImageLayout dstImageLayout, P.13
uint32_t regionCount,
Fixed-Function Vertex Postprocessing [23] void vkCmdBindVertexBuffers( const VkImageResolve* pRegions);
VkCommandBuffer commandBuffer,
Controlling the Viewport [23.5] uint32_t firstBinding, uint32_t bindingCount, typedef struct VkImageResolve {
void vkCmdSetViewport( const VkBuffer* pBuffers, VkImageSubresourceLayers srcSubresource; P.13
VkCommandBuffer commandBuffer, const VkDeviceSize* pOffsets); VkOffset3D srcOffset; P14
uint32_t firstViewport, VkImageSubresourceLayers dstSubresource; P.13
uint32_t viewportCount, VkOffset3D dstOffset; P14
const VkViewport* pViewports); P.15 Fragment Operations [25] VkExtent3D extent; P12
} VkImageResolve;
Scissor Test [25.2]
void vkCmdSetScissor(
VkCommandBuffer commandBuffer,
Rasterization [24] uint32_t firstScissor, uint32_t scissorCount, Dispatching Commands [27]
const VkRect2D* pScissors); P.15
Basic Line Segment Rasterization [24.6] void vkCmdDispatch(
void vkCmdSetLineWidth( Depth Bounds Test [25.8] VkCommandBuffer commandBuffer,
VkCommandBuffer commandBuffer, void vkCmdSetDepthBounds( uint32_t groupCountX,
float lineWidth); VkCommandBuffer commandBuffer, uint32_t groupCountY,
float minDepthBounds, float maxDepthBounds); uint32_t groupCountZ);
Depth Bias [24.7.3]
void vkCmdSetDepthBias( Stencil Test [25.9] void vkCmdDispatchIndirect(
VkCommandBuffer commandBuffer, void vkCmdSetStencilCompareMask( VkCommandBuffer commandBuffer,
float depthBiasConstantFactor, VkCommandBuffer commandBuffer, VkBuffer buffer,
float depthBiasClamp, VkStencilFaceFlags faceMask, uint32_t compareMask); VkDeviceSize offset);
float depthBiasSlopeFactor); void vkCmdSetStencilWriteMask( typedef struct VkDispatchIndirectCommand {
VkCommandBuffer commandBuffer, uint32_t x;
VkStencilFaceFlags faceMask, uint32_t y;
uint32_t writeMask); uint32_t z;
Framebuffer: Blend Factors [26.1.1] void vkCmdSetStencilReference(
} VkDispatchIndirectCommand;
void vkCmdSetBlendConstants( VkCommandBuffer commandBuffer, void vkCmdDispatchBase(
VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkCommandBuffer commandBuffer,
const float blendConstants[4]); uint32_t reference); uint32_t baseGroupX, uint32_t baseGroupY,
faceMask: VK_STENCIL_FACE_{FRONT, BACK}_BIT, uint32_t baseGroupZ, uint32_t groupCountX,
VK_STENCIL_FRONT_AND_BACK uint32_t groupCountY, uint32_t groupCountZ);

Sparse Resources [28] flags: VK_SPARSE_IMAGE_FORMAT_X where X is

SINGLE_MIPTAIL_BIT, ALIGNED_MIP_SIZE_BIT,
typedef struct VkPhysicalDeviceSparseImageFormatInfo2 {
VkStructureType sType; P.15
Sparse Image Format Properties [28.7.3] NONSTANDARD_BLOCK_SIZE_BIT const void* pNext;
void vkGetPhysicalDeviceSparseImageFormatProperties( VkFormat format, P.13
VkPhysicalDevice physicalDevice, VkFormat format, P.13 void vkGetPhysicalDeviceSparseImageFormatProperties2( VkImageType type, P.13
VkImageType type, P.13 VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, P.15
VkSampleCountFlagBits samples, P.15 const VkPhysicalDeviceSparseImageFormatInfo2* VkImageUsageFlags usage, P.13
VkImageUsageFlags usage, P.13 pFormatInfo, VkImageTiling tiling, P.13
VkImageTiling tiling, P.13 uint32_t* pPropertyCount, } VkPhysicalDeviceSparseImageFormatInfo2;
uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties);
VkSparseImageFormatProperties* pProperties); Sparse Resource Memory Requirements [28.7.5]
typedef struct VkSparseImageFormatProperties2 { void vkGetImageSparseMemoryRequirements(
typedef struct VkSparseImageFormatProperties { VkStructureType sType; P.15 VkDevice device, VkImage image,
VkImageAspectFlags aspectMask; P.13 void* pNext; uint32_t* pSparseMemoryRequirementCount,
VkExtent3D imageGranularity; P12 VkSparseImageFormatProperties properties; VkSparseImageMemoryRequirements*
VkSparseImageFormatFlags flags; } VkSparseImageFormatProperties2; pSparseMemoryRequirements);
} VkSparseImageFormatProperties; Continued on next page >

©2018 Khronos Group - Rev. 1118 www.khronos.org/vulkan

Vulkan 1.1 Reference Guide Page 9
Sparse Resources (continued) Binding Resource Memory [28.7.6] typedef struct VkSparseImageOpaqueMemoryBindInfo {
VkImage image;
typedef struct VkBindSparseInfo {
typedef struct VkSparseImageMemoryRequirements { VkStructureType sType; P.15 uint32_t bindCount;
VkSparseImageFormatProperties formatProperties; const void* pNext; const VkSparseMemoryBind* pBinds; P.15
uint32_t imageMipTailFirstLod; uint32_t waitSemaphoreCount; } VkSparseImageOpaqueMemoryBindInfo;
VkDeviceSize imageMipTailSize; const VkSemaphore* pWaitSemaphores;
VkDeviceSize imageMipTailOffset; typedef struct VkSparseImageMemoryBindInfo {
uint32_t bufferBindCount; VkImage image;
VkDeviceSize imageMipTailStride; const VkSparseBufferMemoryBindInfo* pBufferBinds;
} VkSparseImageMemoryRequirements; uint32_t bindCount;
uint32_t imageOpaqueBindCount; const VkSparseImageMemoryBind* pBinds;
void vkGetImageSparseMemoryRequirements2( const VkSparseImageOpaqueMemoryBindInfo* } VkSparseImageMemoryBindInfo;
VkDevice device, pImageOpaqueBinds;
const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t imageBindCount; typedef struct VkSparseImageMemoryBind {
uint32_t* pSparseMemoryRequirementCount, const VkSparseImageMemoryBindInfo* pImageBinds; VkImageSubresource subresource;
VkSparseImageMemoryRequirements2* uint32_t signalSemaphoreCount; VkOffset3D offset; P14
pSparseMemoryRequirements); const VkSemaphore* pSignalSemaphores; VkExtent3D extent; P12
} VkBindSparseInfo; VkDeviceMemory memory;
typedef struct VkImageSparseMemoryRequirementsInfo2 { pNext must be NULL or point to: VkDeviceSize memoryOffset;
VkStructureType sType; P.15 VkDeviceGroupBindSparseInfo P.12 VkSparseMemoryBindFlags flags;
const void* pNext; } VkSparseImageMemoryBind;
VkImage image; typedef struct VkSparseBufferMemoryBindInfo { flags: VK_SPARSE_MEMORY_BIND_METADATA_BIT
} VkImageSparseMemoryRequirementsInfo2; VkBuffer buffer;
uint32_t bindCount; VkResult vkQueueBindSparse(
typedef struct VkSparseImageMemoryRequirements2 { const VkSparseMemoryBind* pBinds; P.15 VkQueue queue,
VkStructureType sType; P.15 } VkSparseBufferMemoryBindInfo; uint32_t bindInfoCount,
void* pNext; const VkBindSparseInfo* pBindInfo,
VkSparseImageMemoryRequirements VkFence fence);
memoryRequirements;
} VkSparseImageMemoryRequirements2;

Window System Integration (WSI) [29] typedef struct VkXlibSurfaceCreateInfoKHR {

VkStructureType sType; P.15
typedef struct VkDisplayModePropertiesKHR {
VkDisplayModeKHR displayMode;
Android Platform [29.2.1] const void* pNext; VkDisplayModeParametersKHR parameters;
VkResult vkCreateAndroidSurfaceKHR( VkXlibSurfaceCreateFlagsKHR flags; = 0 } VkDisplayModePropertiesKHR;
VkInstance instance, Display* dpy; Window window;
const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, } VkXlibSurfaceCreateInfoKHR; typedef struct VkDisplayModeParametersKHR {
const VkAllocationCallbacks* pAllocator, P.12 VkExtent2D visibleRegion; P12
VkSurfaceKHR* pSurface); Platform-Independent Information [29.2.7] uint32_t refreshRate;
void vkDestroySurfaceKHR( } VkDisplayModeParametersKHR;
typedef struct VkAndroidSurfaceCreateInfoKHR { VkInstance instance, VkSurfaceKHR surface,
VkStructureType sType; P.15 VkResult vkGetDisplayModeProperties2KHR (
const VkAllocationCallbacks* pAllocator); P.12 VkPhysicalDevice physicalDevice,
const void* pNext;
VkAndroidSurfaceCreateFlagsKHR flags; = 0 Display Enumeration [29.3.1] VkDisplayKHR display, uint32_t* pPropertyCount,
struct ANativeWindow* window; VkResult vkGetPhysicalDeviceDisplayPropertiesKHR( VkDisplayModeProperties2KHR* pProperties);
} VkAndroidSurfaceCreateInfoKHR; VkPhysicalDevice physicalDevice, typedef struct VkDisplayModeProperties2KHR {
uint32_t* pPropertyCount, VkStructureType sType; P.15
Wayland Platform [29.2.3] VkDisplayPropertiesKHR* pProperties); void* pNext;
VkResult vkCreateWaylandSurfaceKHR( VkDisplayModePropertiesKHR displayModeProperties;
VkInstance instance, typedef struct VkDisplayPropertiesKHR {
VkDisplayKHR display; const char* displayName; } VkDisplayModeProperties2KHR;
const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator, P.12 VkExtent2D physicalDimensions; P12
VkSurfaceKHR* pSurface); VkExtent2D physicalResolution; P12 VkResult vkCreateDisplayModeKHR(
VkSurfaceTransformFlagsKHR supportedTransforms; P.15 VkPhysicalDevice physicalDevice, VkDisplayKHR display,
typedef struct VkWaylandSurfaceCreateInfoKHR { VkBool32 planeReorderPossible; const VkDisplayModeCreateInfoKHR* pCreateInfo,
VkStructureType sType; P.15 VkBool32 persistentContent; const VkAllocationCallbacks* pAllocator, P.12
const void* pNext; } VkDisplayPropertiesKHR; VkDisplayModeKHR* pMode);
VkWaylandSurfaceCreateFlagsKHR flags; = 0 typedef struct VkDisplayModeCreateInfoKHR {
struct wl_display* display; VkResult vkGetPhysicalDeviceDisplayProperties2KHR (
VkPhysicalDevice physicalDevice, VkStructureType sType; P.15
struct wl_surface* surface; const void* pNext;
} VkWaylandSurfaceCreateInfoKHR; uint32_t* pPropertyCount,
VkDisplayProperties2KHR* pProperties); VkDisplayModeCreateFlagsKHR flags; = 0
Win32 Platform [29.2.4] VkDisplayModeParametersKHR parameters;
VkResult vkCreateWin32SurfaceKHR( typedef struct VkDisplayProperties2KHR { } VkDisplayModeCreateInfoKHR;
VkInstance instance, VkStructureType sType; P.15
void* pNext; VkResult vkGetDisplayPlaneCapabilitiesKHR(
const VkWin32SurfaceCreateInfoKHR* pCreateInfo, VkPhysicalDevice physicalDevice,
const VkAllocationCallbacks* pAllocator, P.12 VkDisplayPropertiesKHR displayProperties;
} VkDisplayProperties2KHR; VkDisplayModeKHR mode, uint32_t planeIndex,
VkSurfaceKHR* pSurface); VkDisplayPlaneCapabilitiesKHR* pCapabilities);
typedef struct VkWin32SurfaceCreateInfoKHR { Display Planes
VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR( typedef struct VkDisplayPlaneCapabilitiesKHR {
VkStructureType sType; P.15 VkDisplayPlaneAlphaFlagsKHR supportedAlpha;
const void* pNext; VkPhysicalDevice physicalDevice,
uint32_t* pPropertyCount, VkOffset2D minSrcPosition; P14
VkWin32SurfaceCreateFlagsKHR flags; = 0 VkOffset2D maxSrcPosition; P14
HINSTANCE hinstance; HWND hwnd; VkDisplayPlanePropertiesKHR* pProperties);
VkExtent2D minSrcExtent; P12
} VkWin32SurfaceCreateInfoKHR; typedef struct VkDisplayPlanePropertiesKHR { VkExtent2D maxSrcExtent; P12
XCB Platform [29.2.5] VkDisplayKHR currentDisplay; uint32_t currentStackIndex; VkOffset2D minDstPosition; P14
VkResult vkCreateXcbSurfaceKHR( } VkDisplayPlanePropertiesKHR; VkOffset2D maxDstPosition; P14
VkInstance instance, VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR ( VkExtent2D minDstExtent; P12
const VkXcbSurfaceCreateInfoKHR* pCreateInfo, VkPhysicalDevice physicalDevice, VkExtent2D maxDstExtent; P12
const VkAllocationCallbacks* pAllocator, P.12 uint32_t* pPropertyCount, } VkDisplayPlaneCapabilitiesKHR;
VkSurfaceKHR* pSurface); VkDisplayPlaneProperties2KHR* pProperties); VkResult vkGetDisplayPlaneCapabilities2KHR (
typedef struct VkXcbSurfaceCreateInfoKHR { typedef struct VkDisplayPlaneProperties2KHR { VkPhysicalDevice physicalDevice,
VkStructureType sType; P.15 VkStructureType sType; P.15 const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo,
const void* pNext; void* pNext; VkDisplayPlaneCapabilities2KHR* pCapabilities);
VkXcbSurfaceCreateFlagsKHR flags; = 0 VkDisplayPlanePropertiesKHR displayPlaneProperties; typedef struct VkDisplayPlaneInfo2KHR {
xcb_connection_t* connection; xcb_window_t window; } VkDisplayPlaneProperties2KHR; VkStructureType sType; P.15
} VkXcbSurfaceCreateInfoKHR; const void* pNext;
VkResult vkGetDisplayPlaneSupportedDisplaysKHR(
Xlib Platform [29.2.6] VkPhysicalDevice physicalDevice, uint32_t planeIndex, VkDisplayModeKHR mode; uint32_t planeIndex;
VkResult vkCreateXlibSurfaceKHR( uint32_t* pDisplayCount, VkDisplayKHR* pDisplays); } VkDisplayPlaneInfo2KHR;
VkInstance instance, typedef struct VkDisplayPlaneCapabilities2KHR {
const VkXlibSurfaceCreateInfoKHR* pCreateInfo, Display Modes
VkStructureType sType; P.15
const VkAllocationCallbacks* pAllocator, P.12 VkResult vkGetDisplayModePropertiesKHR( void* pNext;
VkSurfaceKHR* pSurface); VkPhysicalDevice physicalDevice, VkDisplayKHR display, VkDisplayPlaneCapabilitiesKHR capabilities;
uint32_t* pPropertyCount,
VkDisplayModePropertiesKHR* pProperties); } VkDisplayPlaneCapabilities2KHR;

Continued on next page >

©2018 Khronos Group - Rev. 1118 www.khronos.org/vulkan

Vulkan 1.1 Reference Guide Page 10
WSI (continued) VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(
VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
VkResult vkAcquireNextImage2KHR(
VkDevice device,
Display Surfaces [29.3.2] uint32_t* pPresentModeCount, const VkAcquireNextImageInfoKHR* pAcquireInfo,
VkResult vkCreateDisplayPlaneSurfaceKHR( VkPresentModeKHR* pPresentModes); uint32_t* pImageIndex);
VkInstance instance, pPresentModes: VK_PRESENT_MODE_X_KHR typedef struct VkAcquireNextImageInfoKHR {
const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, where X is IMMEDIATE, MAILBOX, FIFO, FIFO_RELAXED,
const VkAllocationCallbacks* pAllocator, P.12 VkStructureType sType; P.15 const void* pNext;
SHARED_DEMAND_REFRESH, VkSwapchainKHR swapchain; uint64_t timeout;
VkSurfaceKHR* pSurface); SHARED_CONTINUOUS_REFRESH VkSemaphore semaphore;
typedef struct VkDisplaySurfaceCreateInfoKHR { Device Group Queries [29.6] VkFence fence; uint32_t deviceMask;
VkStructureType sType; P.15 VkResult vkGetDeviceGroupPresentCapabilitiesKHR( } VkAcquireNextImageInfoKHR;
const void* pNext; VkDevice device,
VkDisplaySurfaceCreateFlagsKHR flags; = 0 VkResult vkQueuePresentKHR(
VkDeviceGroupPresentCapabilitiesKHR* VkQueue queue,
VkDisplayModeKHR displayMode; pDeviceGroupPresentCapabilities);
uint32_t planeIndex; uint32_t planeStackIndex; const VkPresentInfoKHR* pPresentInfo);
VkSurfaceTransformFlagBitsKHR transform; P.15 typedef struct VkDeviceGroupPresentCapabilitiesKHR { typedef struct VkPresentInfoKHR {
float globalAlpha; VkStructureType sType; P.15 VkStructureType sType; P.15
VkDisplayPlaneAlphaFlagBitsKHR alphaMode; const void* pNext; const void* pNext; uint32_t waitSemaphoreCount;
VkExtent2D imageExtent; P12 uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE]; const VkSemaphore* pWaitSemaphores;
} VkDisplaySurfaceCreateInfoKHR; VkDeviceGroupPresentModeFlagsKHR modes; P.12 uint32_t swapchainCount;
alphaMode: VK_DISPLAY_PLANE_ALPHA_X_BIT_KHR } VkDeviceGroupPresentCapabilitiesKHR; const VkSwapchainKHR* pSwapchains;
where X is OPAQUE, GLOBAL, PER_PIXEL, VkResult vkGetDeviceGroupSurfacePresentModesKHR( const uint32_t* pImageIndices; VkResult* pResults;
PER_PIXEL_PREMULTIPLIED VkDevice device, VkSurfaceKHR surface, } VkPresentInfoKHR;
VkDeviceGroupPresentModeFlagsKHR* pModes); P.12 pNext must be NULL or point to one of:
Querying for WSI Support [29.4] VkDeviceGroupPresentInfoKHR,
VkResult vkGetPhysicalDeviceSurfaceSupportKHR( VkResult vkGetPhysicalDevicePresentRectanglesKHR( VkDisplayPresentInfoKHR, or VkPresentRegionsKHR
VkPhysicalDevice physicalDevice, VkPhysicalDevice physicalDevice,
uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkSurfaceKHR surface, uint32_t* pRectCount, typedef struct VkDeviceGroupPresentInfoKHR {
VkBool32* pSupported); VkRect2D* pRects); P.15 VkStructureType sType; P.15
const void* pNext; uint32_t swapchainCount;
Wayland Platform Querying [29.4.3] WSI Swapchain [29.7] const uint32_t* pDeviceMasks;
VkBool32 VkResult vkGetSwapchainStatusKHR( VkDeviceGroupPresentModeFlagBitsKHR mode;
vkGetPhysicalDeviceWaylandPresentationSupportKHR( VkDevice device, } VkDeviceGroupPresentInfoKHR;
VkPhysicalDevice physicalDevice, VkSwapchainKHR swapchain);
uint32_t queueFamilyIndex, mode: VK_DEVICE_GROUP_PRESENT_MODE_X_BIT_KHR
struct wl_display* display); VkResult vkCreateSwapchainKHR( where X is REMOTE, SUM, LOCAL, LOCAL_MULTI_DEVICE
VkDevice device, typedef struct VkDisplayPresentInfoKHR {
Win32 Platform Querying [29.4.4] const VkSwapchainCreateInfoKHR* pCreateInfo,
VkBool32 VkStructureType sType; P.15 const void* pNext;
const VkAllocationCallbacks* pAllocator, P.12 VkRect2D srcRect; P.15
vkGetPhysicalDeviceWin32PresentationSupportKHR( VkSwapchainKHR* pSwapchain);
VkPhysicalDevice physicalDevice, VkRect2D dstRect; P.15
uint32_t queueFamilyIndex); typedef struct VkSwapchainCreateInfoKHR { VkBool32 persistent;
VkStructureType sType; P.15 } VkDisplayPresentInfoKHR;
XCB Platform Querying [29.4.5] const void* pNext;
VkBool32 typedef struct VkPresentRegionsKHR {
VkSwapchainCreateFlagsKHR flags; VkStructureType sType; P.15
vkGetPhysicalDeviceXcbPresentationSupportKHR( VkSurfaceKHR surface; uint32_t minImageCount;
VkPhysicalDevice physicalDevice, const void* pNext; uint32_t swapchainCount;
VkFormat imageFormat; P.13 const VkPresentRegionKHR* pRegions;
uint32_t queueFamilyIndex, VkColorSpaceKHR imageColorSpace;
xcb_connection_t* connection, } VkPresentRegionsKHR;
VkExtent2D imageExtent; P12
xcb_visualid_t visual_id); uint32_t imageArrayLayers; typedef struct VkPresentRegionKHR {
Xlib Platform Querying [29.4.6] VkImageUsageFlags imageUsage; P.13 uint32_t rectangleCount;
VkBool32 VkSharingMode imageSharingMode; P.15 const VkRectLayerKHR* pRectangles;
vkGetPhysicalDeviceXlibPresentationSupportKHR( uint32_t queueFamilyIndexCount; } VkPresentRegionKHR;
VkPhysicalDevice physicalDevice, const uint32_t* pQueueFamilyIndices; typedef struct VkRectLayerKHR {
uint32_t queueFamilyIndex, VkSurfaceTransformFlagBitsKHR preTransform; P.15 VkOffset2D offset; P.14
Display* dpy, VisualID visualID); VkCompositeAlphaFlagBitsKHR compositeAlpha; P.12 VkExtent2D extent; P.12
VkPresentModeKHR presentMode; uint32_t layer;
Surface Queries [29.5] VkBool32 clipped; VkSwapchainKHR oldSwapchain;
VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR( } VkRectLayerKHR;
} VkSwapchainCreateInfoKHR;
VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, pNext: may point to struct: typedef struct VkDisplayPresentInfoKHR {
VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); P.15 VkDeviceGroupSwapchainCreateInfoKHR VkStructureType sType; P.15 const void* pNext;
VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR( VkRect2D srcRect; P.15
flags: VK_SWAPCHAIN_CREATE_X_KHR where X is VkRect2D dstRect; P.15
VkPhysicalDevice physicalDevice, SPLIT_INSTANCE_BIND_REGIONS, PROTECTED
const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, P.15 VkBool32 persistent;
colorSpace: VK_COLOR_SPACE_SRGB_NONLINEAR_KHR } VkDisplayPresentInfoKHR;
VkSurfaceCapabilities2KHR* pSurfaceCapabilities);
presentMode: VK_PRESENT_MODE_X_KHR
typedef struct VkSurfaceCapabilities2KHR { where X is IMMEDIATE, MAILBOX, FIFO, FIFO_RELAXED,
VkStructureType sType; P.15
void* pNext;
DEMAND_REFRESH, CONTINUOUS_REFRESH Extended Functionality
VkSurfaceCapabilitiesKHR surfaceCapabilities; P.15 typedef struct VkDeviceGroupSwapchainCreateInfoKHR { Layers [30.1]
} VkSurfaceCapabilities2KHR; VkStructureType sType; P.15 VkResult vkEnumerateInstanceLayerProperties(
pNext must be NULL or point to:
const void* pNext; uint32_t* pPropertyCount,
VkSharedPresentSurfaceCapabilitiesKHR
VkDeviceGroupPresentModeFlagsKHR modes; VkLayerProperties* pProperties);
} VkDeviceGroupSwapchainCreateInfoKHR;
typedef struct VkSharedPresentSurfaceCapabilitiesKHR { modes: VK_DEVICE_GROUP_PRESENT_MODE_X_BIT_KHR VkResult vkEnumerateDeviceLayerProperties(
VkStructureType sType; P.15 where X is LOCAL, REMOTE, SUM, LOCAL_MULTI_DEVICE VkPhysicalDevice physicalDevice,
void* pNext; uint32_t* pPropertyCount,
VkImageUsageFlags void vkDestroySwapchainKHR( VkLayerProperties* pProperties);
sharedPresentSupportedUsageFlags; P.13 VkDevice device, VkSwapchainKHR swapchain,
} VkSharedPresentSurfaceCapabilitiesKHR; const VkAllocationCallbacks* pAllocator); P.12 typedef struct VkLayerProperties {
char layerName [VK_MAX_EXTENSION_NAME_SIZE];
VkResult vkGetPhysicalDeviceSurfaceFormatsKHR( VkResult vkCreateSharedSwapchainsKHR( uint32_t specVersion;
VkPhysicalDevice physicalDevice, VkDevice device, uint32_t implementationVersion;
VkSurfaceKHR surface, uint32_t swapchainCount, char description [VK_MAX_DESCRIPTION_SIZE];
uint32_t* pSurfaceFormatCount, const VkSwapchainCreateInfoKHR* pCreateInfos, } VkLayerProperties;
VkSurfaceFormatKHR* pSurfaceFormats); P.15 const VkAllocationCallbacks* pAllocator, P.12
VkSwapchainKHR* pSwapchains); Extensions [30.2]
VkResult vkGetPhysicalDeviceSurfaceFormats2KHR( VkResult vkEnumerateInstanceExtensionProperties(
VkPhysicalDevice physicalDevice, VkResult vkGetSwapchainImagesKHR( const char* pLayerName,
const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, P.15 VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPropertyCount,
uint32_t* pSurfaceFormatCount, uint32_t* pSwapchainImageCount, VkExtensionProperties* pProperties);
VkSurfaceFormat2KHR* pSurfaceFormats); VkImage* pSwapchainImages);
VkResult vkEnumerateDeviceExtensionProperties(
typedef struct VkSurfaceFormat2KHR { VkResult vkAcquireNextImageKHR( VkPhysicalDevice physicalDevice,
VkStructureType sType; P.15 VkDevice device, VkSwapchainKHR swapchain, const char* pLayerName,
void* pNext; uint64_t timeout, VkSemaphore semaphore, uint32_t* pPropertyCount,
VkSurfaceFormatKHR surfaceFormat; P.15 VkFence fence, VkExtensionProperties* pProperties);
} VkSurfaceFormat2KHR; uint32_t* pImageIndex);
Continued on next page >
©2018 Khronos Group - Rev. 1118 www.khronos.org/vulkan
Vulkan 1.1 Reference Guide Page 11
Extended Functionality (continued) Optional Semaphore Capabilities [31.6] Optional Fence Capabilities [31.7]
void vkGetPhysicalDeviceExternalSemaphoreProperties( void vkGetPhysicalDeviceExternalFenceProperties(
typedef struct VkExtensionProperties { VkPhysicalDevice physicalDevice, VkPhysicalDevice physicalDevice,
char extensionName [VK_MAX_EXTENSION_NAME_SIZE]; const VkPhysicalDeviceExternalSemaphoreInfo* const VkPhysicalDeviceExternalFenceInfo*
uint32_t specVersion; pExternalSemaphoreInfo, pExternalFenceInfo,
} VkExtensionProperties; VkExternalSemaphoreProperties* VkExternalFenceProperties* pExternalFenceProperties);
pExternalSemaphoreProperties);
Additional Buffer Capabilities [31.5] typedef struct VkPhysicalDeviceExternalFenceInfo {
void vkGetPhysicalDeviceExternalBufferProperties( typedef struct VkPhysicalDeviceExternalSemaphoreInfo { VkStructureType sType; P.15
VkPhysicalDevice physicalDevice, VkStructureType sType; P.15 const void* pNext;
const VkPhysicalDeviceExternalBufferInfo* const void* pNext; VkExternalFenceHandleTypeFlagBits handleType; P.12
pExternalBufferInfo, VkExternalSemaphoreHandleTypeFlagBits } VkPhysicalDeviceExternalFenceInfo;
VkExternalBufferProperties* handleType; P.13
pExternalBufferProperties); } VkPhysicalDeviceExternalSemaphoreInfo; typedef struct VkExternalFenceProperties {
VkStructureType sType; P.15
typedef struct VkPhysicalDeviceExternalBufferInfo { enum VkExternalSemaphoreHandleTypeFlagBits: void* pNext;
VkStructureType sType; P.15 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_X_BIT VkExternalFenceHandleTypeFlags
const void* pNext; where X is OPAQUE_FD, exportFromImportedHandleTypes; P.12
VkBufferCreateFlags flags; P.12 OPAQUE_WIN32[_KMT], VkExternalFenceHandleTypeFlags
VkBufferUsageFlags usage; P.12 D3D12_FENCE, SYNC_FD compatibleHandleTypes; P.12
VkExternalMemoryHandleTypeFlagBits handleType; P.12 typedef struct VkExternalSemaphoreProperties { VkExternalFenceFeatureFlags externalFenceFeatures;
} VkPhysicalDeviceExternalBufferInfo; VkStructureType sType; P.15 } VkExternalFenceProperties;
typedef struct VkExternalBufferProperties { void* pNext; enum VkExternalFenceFeatureFlagBits:
VkStructureType sType; P.15 VkExternalSemaphoreHandleTypeFlags VK_EXTERNAL_FENCE_FEATURE_X_BIT where X is
void* pNext; exportFromImportedHandleTypes; P.13 EXPORTABLE, IMPORTABLE
VkExternalMemoryProperties VkExternalSemaphoreHandleTypeFlags
externalMemoryProperties; P.13 compatibleHandleTypes;
} VkExternalBufferProperties; VkExternalSemaphoreFeatureFlags
externalSemaphoreFeatures;
} VkExternalSemaphoreProperties;
VkExternalSemaphoreFeatureFlagBits:
VK_EXTERNAL_SEMAPHORE_FEATURE_X_BIT where X is
EXPORTABLE, IMPORTABLE

Features, Limits, and Formats [31]

Features [31.1] void vkGetPhysicalDeviceFormatProperties2( typedef struct VkImageFormatProperties2 {
void vkGetPhysicalDeviceFeatures( VkPhysicalDevice physicalDevice, VkStructureType sType; P.15
VkPhysicalDevice physicalDevice, VkFormat format, P.13 void* pNext;
VkPhysicalDeviceFeatures* pFeatures); P14 VkFormatProperties2* pFormatProperties); VkImageFormatProperties imageFormatProperties;
} VkImageFormatProperties2;
void vkGetPhysicalDeviceFeatures2( typedef struct VkFormatProperties2 {
VkPhysicalDevice physicalDevice, VkStructureType sType; P.15 pNext must be NULL or point to:
VkPhysicalDeviceFeatures2* pFeatures); P.14 void* pNext; VkExternalImageFormatProperties P.12
VkFormatProperties formatProperties; VkSamplerYcbcrConversionImageFormatProperties P.15
Format Properties [31.3.2] } VkFormatProperties2; typedef struct VkPhysicalDeviceImageFormatInfo2 {
void vkGetPhysicalDeviceFormatProperties( VkStructureType sType; P.15
VkPhysicalDevice physicalDevice, Additional Image Capabilities [31.4] const void* pNext;
VkFormat format, P.13 VkResult vkGetPhysicalDeviceImageFormatProperties( VkFormat format, P.13
VkFormatProperties* pFormatProperties); VkPhysicalDevice physicalDevice, VkImageType type, P.13
VkFormat format, P.13 VkImageTiling tiling, P.13
typedef struct VkFormatProperties { VkImageType type, P.13
VkFormatFeatureFlags linearTilingFeatures; VkImageUsageFlags usage, P.13
VkImageTiling tiling, P.13 VkImageCreateFlags flags, P.13
VkFormatFeatureFlags optimalTilingFeatures; VkImageUsageFlags usage, P.13
VkFormatFeatureFlags bufferFeatures; } VkPhysicalDeviceImageFormatInfo2;
VkImageCreateFlags flags, P.13
} VkFormatProperties; VkImageFormatProperties* pImageFormatProperties); pNext must be NULL or point to:
enum VkFormatFeatureFlagBits: VkPhysicalDeviceExternalImageFormatInfo P.14
VK_FORMAT_FEATURE_X_BIT where X is typedef struct VkImageFormatProperties {
SAMPLED_IMAGE, STORAGE_IMAGE[_ATOMIC], VkExtent3D maxExtent; P12
UNIFORM_TEXEL_BUFFER, uint32_t maxMipLevels;
STORAGE_TEXEL_BUFFER[_ATOMIC], uint32_t maxArrayLayers;
VERTEX_BUFFER, COLOR_ATTACHMENT[_BLEND], VkSampleCountFlags sampleCounts; P.15
DEPTH_STENCIL_ATTACHMENT, VkDeviceSize maxResourceSize;
SAMPLED_IMAGE_FILTER_LINEAR, DISJOINT, } VkImageFormatProperties;
BLIT_{SRC, DST}, TRANSFER_{SRC, DST}, VkResult vkGetPhysicalDeviceImageFormatProperties2(
{MIDPOINT, COSITED}_CHROMA_SAMPLES, VkPhysicalDevice physicalDevice,
and VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_- const VkPhysicalDeviceImageFormatInfo2*
CONVERSION_X where X is LINEAR_FILTER, pImageFormatInfo,
SEPARATE_RECONSTRUCTION_FILTER, VkImageFormatProperties2* pImageFormatProperties);
CHROMA_RECONSTRUCTION_EXPLICIT,
CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE

Notes

©2018 Khronos Group - Rev. 1118 www.khronos.org/vulkan

Vulkan 1.1 Reference Guide Page 12
Structures and Enumerations typedef struct VkBufferMemoryBarrier {
VkStructureType sType; P.15
typedef struct VkDeviceGroupDeviceCreateInfo {
VkStructureType sType; P.15
This section contains an alphabetic reference to types enums
and structs referenced in multiple places on preceding pages. const void* pNext; const void* pNext; uint32_t physicalDeviceCount;
VkAccessFlags srcAccessMask; P.12 const VkPhysicalDevice* pPhysicalDevices;
enum VkAccessFlagBits: VkAccessFlags dstAccessMask; P.12 } VkDeviceGroupDeviceCreateInfo;
VK_ACCESS_X_BIT where X is uint32_t srcQueueFamilyIndex;
INDIRECT_COMMAND_READ, uint32_t dstQueueFamilyIndex; enum VkDeviceGroupPresentModeFlagBitsKHR:
INDEX_READ, VkBuffer buffer; VK_DEVICE_GROUP_PRESENT_MODE_X_BIT_KHR where X is
VERTEX_ATTRIBUTE_READ, VkDeviceSize offset; VkDeviceSize size; LOCAL, REMOTE, SUM, LOCAL_MULTI_DEVICE
UNIFORM_READ, } VkBufferMemoryBarrier;
INPUT_ATTACHMENT_READ, typedef struct VkDeviceGroupRenderPassBeginInfo {
SHADER_[READ, WRITE], enum VkBufferUsageFlagBits: VkStructureType sType; P.15
COLOR_ATTACHMENT_[READ, WRITE], VK_BUFFER_USAGE_X_BIT where X is const void* pNext; uint32_t deviceMask;
DEPTH_STENCIL_ATTACHMENT_[READ, WRITE], TRANSFER_SRC, TRANSFER_DST, uint32_t deviceRenderAreaCount;
TRANSFER_[READ, WRITE], UNIFORM_TEXEL_BUFFER, STORAGE_TEXEL_BUFFER, const VkRect2D* pDeviceRenderAreas; P.15
HOST_[READ, WRITE], UNIFORM_BUFFER, STORAGE_BUFFER, INDEX_BUFFER, } VkDeviceGroupRenderPassBeginInfo;
MEMORY_[READ, WRITE] VERTEX_BUFFER, INDIRECT_BUFFER
typedef struct VkDeviceGroupSubmitInfo {
typedef struct VkAllocationCallbacks { typedef union VkClearColorValue { VkStructureType sType; P.15
void* pUserData; float float32[4]; const void* pNext;
PFN_vkAllocationFunction pfnAllocation; int32_t int32[4]; uint32_t waitSemaphoreCount;
PFN_vkReallocationFunction pfnReallocation; uint32_t uint32[4]; const uint32_t* pWaitSemaphoreDeviceIndices;
PFN_vkFreeFunction pfnFree; } VkClearColorValue; uint32_t commandBufferCount;
PFN_vkInternalAllocationNotification const uint32_t* pCommandBufferDeviceMasks;
pfnInternalAllocation; typedef struct VkClearDepthStencilValue { uint32_t signalSemaphoreCount;
PFN_vkInternalFreeNotification pfnInternalFree; float depth; const uint32_t* pSignalSemaphoreDeviceIndices;
} VkAllocationCallbacks; uint32_t stencil; } VkDeviceGroupSubmitInfo;
} VkClearDepthStencilValue;
typedef void* (VKAPI_PTR* PFN_vkAllocationFunction)( typedef struct VkExportFenceCreateInfo {
void* pUserData, typedef union VkClearValue { VkStructureType sType; P.15
size_t size, VkClearColorValue color; P.12 const void* pNext;
size_t alignment, VkClearDepthStencilValue depthStencil; P.12 VkExternalFenceHandleTypeFlags handleTypes; P.12
VkSystemAllocationScope allocationScope); } VkClearValue; } VkExportFenceCreateInfo;
typedef void* (VKAPI_PTR* PFN_vkReallocationFunction)(
void* pUserData, enum VkCompareOp: typedef struct VkExportMemoryAllocateInfo {
void* pOriginal, VK_COMPARE_OP_X where X is VkStructureType sType; P.15
size_t size, NEVER, LESS, EQUAL, const void* pNext;
size_t alignment, LESS_OR_EQUAL, VkExternalMemoryHandleTypeFlags handleTypes; P.12
VkSystemAllocationScope allocationScope); GREATER, } VkExportMemoryAllocateInfo;
typedef void (VKAPI_PTR* PFN_vkFreeFunction)( NOT_EQUAL,
GREATER_OR_EQUAL, typedef struct VkExportSemaphoreCreateInfo {
void* pUserData, VkStructureType sType; P.15
void* pMemory); ALWAYS
const void* pNext;
typedef void ( enum VkCompositeAlphaFlagBitsKHR: VkExternalSemaphoreHandleTypeFlags handleTypes; P.13
VKAPI_PTR* PFN_vkInternalAllocationNotification)( VK_COMPOSITE_ALPHA_X_BIT_KHR where X is } VkExportSemaphoreCreateInfo;
void* pUserData, OPAQUE, PRE_MULTIPLIED, POST_MULTIPLIED, INHERIT
size_t size, typedef struct VkExtent2D {
VkInternalAllocationType allocationType, enum VkDependencyFlagBits: uint32_t width;
VkSystemAllocationScope allocationScope); uint32_t height;
VK_DEPENDENCY_BY_REGION_BIT, } VkExtent2D;
typedef void ( VK_DEPENDENCY_DEVICE_GROUP_BIT,
VKAPI_PTR* PFN_vkInternalFreeNotification)( VK_DEPENDENCY_VIEW_LOCAL_BIT typedef struct VkExtent3D {
void* pUserData, uint32_t width;
size_t size, enum VkDescriptorType: uint32_t height;
VkInternalAllocationType allocationType, VK_DESCRIPTOR_TYPE_X where X is uint32_t depth;
VkSystemAllocationScope allocationScope); SAMPLER, COMBINED_IMAGE_SAMPLER, } VkExtent3D;
allocationType: SAMPLED_IMAGE, STORAGE_IMAGE,
VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE UNIFORM_TEXEL_BUFFER, enum VkExternalFenceHandleTypeFlagBits:
STORAGE_TEXEL_BUFFER, VK_EXTERNAL_FENCE_HANDLE_TYPE_X_BIT where X is
allocationScope: VK_SYSTEM_ALLOCATION_SCOPE_X where UNIFORM_BUFFER[_DYNAMIC],
X is COMMAND, OBJECT, CACHE, DEVICE, INSTANCE OPAQUE_FD,
STORAGE_BUFFER[_DYNAMIC], OPAQUE_WIN32,
INPUT_ATTACHMENT OPAQUE_WIN32_KMT,
typedef struct VkBindBufferMemoryDeviceGroupInfo {
VkStructureType sType; P.15 SYNC_FD
typedef struct VkDescriptorSetLayoutBinding {
const void* pNext; uint32_t deviceIndexCount; uint32_t binding;
const uint32_t* pDeviceIndices; typedef struct VkExternalImageFormatProperties {
VkDescriptorType descriptorType; P.12 VkStructureType sType; P.15
} VkBindBufferMemoryDeviceGroupInfo; uint32_t descriptorCount; void* pNext;
VkShaderStageFlags stageFlags; P.15 VkExternalMemoryProperties
typedef struct VkBindImageMemoryDeviceGroupInfo { const VkSampler* pImmutableSamplers;
VkStructureType sType; P.15 externalMemoryProperties; P13
} VkDescriptorSetLayoutBinding; } VkExternalImageFormatProperties;
const void* pNext; uint32_t deviceIndexCount;
const uint32_t* pDeviceIndices; typedef struct VkDescriptorSetLayoutCreateInfo {
uint32_t splitInstanceBindRegionCount; typedef struct VkExternalMemoryBufferCreateInfo {
VkStructureType sType; P.15 VkStructureType sType; P.15
const VkRect2D* pSplitInstanceBindRegions; P.15 const void* pNext;
} VkBindImageMemoryDeviceGroupInfo; const void* pNext;
VkDescriptorSetLayoutCreateFlags flags; VkExternalMemoryHandleTypeFlags handleTypes; P.12
uint32_t bindingCount; } VkExternalMemoryBufferCreateInfo;
typedef struct VkBindImagePlaneMemoryInfo { const VkDescriptorSetLayoutBinding* pBindings;
VkStructureType sType; P.15 } VkDescriptorSetLayoutCreateInfo;
const void* pNext; enum VkExternalMemoryFeatureFlagBits:
VkImageAspectFlagBits planeAspect; P.13 typedef struct VkDeviceGroupBindSparseInfo { VK_EXTERNAL_MEMORY_FEATURE_X_BIT where X is
} VkBindImagePlaneMemoryInfo; VkStructureType sType; P.15 DEDICATED_ONLY,
const void* pNext; EXPORTABLE,
enum VkBlendOp: uint32_t resourceDeviceIndex; IMPORTABLE
VK_BLEND_OP_ADD, uint32_t memoryDeviceIndex;
VK_BLEND_OP_SUBTRACT, } VkDeviceGroupBindSparseInfo; enum VkExternalMemoryHandleTypeFlagBits:
VK_BLEND_OP_REVERSE_SUBTRACT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_X_BIT where X is
VK_BLEND_OP_MIN, typedef struct VkDeviceGroupCommandBufferBeginInfo { OPAQUE_FD,
VK_BLEND_OP_MAX VkStructureType sType; P.15 OPAQUE_WIN32,
const void* pNext; OPAQUE_WIN32_KMT,
enum VkBufferCreateFlagBits: uint32_t deviceMask; D3D11_TEXTURE,
VK_BUFFER_CREATE_SPARSE_BINDING_BIT, } VkDeviceGroupCommandBufferBeginInfo; D3D11_TEXTURE_KMT,
VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT, D3D12_HEAP,
VK_BUFFER_CREATE_SPARSE_ALIASED_BIT, D3D12_RESOURCE
VK_BUFFER_CREATE_PROTECTED_BIT Continued on next page >

©2018 Khronos Group - Rev. 1118 www.khronos.org/vulkan

Vulkan 1.1 Reference Guide Page 13
Structures and Enumerations (continued) ASTC_10x5_[UNORM, SRGB]_BLOCK,
ASTC_10x6_[UNORM, SRGB]_BLOCK,
typedef struct VkImageSubresourceLayers {
VkImageAspectFlags aspectMask; P.13
typedef struct VkExternalMemoryImageCreateInfo { ASTC_10x8_[UNORM, SRGB]_BLOCK, uint32_t mipLevel;
VkStructureType sType; P.15 ASTC_10x10_[UNORM, SRGB]_BLOCK, uint32_t baseArrayLayer;
const void* pNext; ASTC_12x10_[UNORM, SRGB]_BLOCK, uint32_t layerCount;
VkExternalMemoryHandleTypeFlags handleTypes; P.12 ASTC_12x12_[UNORM, SRGB]_BLOCK, } VkImageSubresourceLayers;
} VkExternalMemoryImageCreateInfo; G8B8G8R8_422_UNORM,
B8G8R8G8_422_UNORM, typedef struct VkImageSubresourceRange {
typedef struct VkExternalMemoryProperties { G8_B8_R8_3PLANE_420_UNORM, VkImageAspectFlags aspectMask; P.13
VkExternalMemoryFeatureFlags G8_B8R8_2PLANE_{420, 422}_UNORM, uint32_t baseMipLevel;
externalMemoryFeatures; P.12 G8_B8_R8_3PLANE_{422, 444}_UNORM, uint32_t levelCount;
VkExternalMemoryHandleTypeFlags R10X6_UNORM_PACK16, uint32_t baseArrayLayer;
exportFromImportedHandleTypes; P12 R10X6G10X6_UNORM_2PACK16, uint32_t layerCount;
VkExternalMemoryHandleTypeFlags R10X6G10X6B10X6A10X6_UNORM_4PACK16, } VkImageSubresourceRange;
compatibleHandleTypes; P12 G10X6B10X6G10X6R10X6_422_UNORM_4PACK16,
} VkExternalMemoryProperties; B10X6G10X6R10X6G10X6_422_UNORM_4PACK16, enum VkImageTiling:
G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, VK_IMAGE_TILING_{OPTIMAL, LINEAR}
enum VkExternalSemaphoreHandleTypeFlagBits: G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16,
G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16, enum VkImageType:
VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_X_BIT where G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16,
X is OPAQUE_FD, OPAQUE_WIN32, OPAQUE_WIN32_KMT, VK_IMAGE_TYPE_{1D, 2D, 3D}
G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16,
D3D12_FENCE, SYNC_FD R12X4_UNORM_PACK16, enum VkImageUsageFlagBits:
R12X4G12X4_UNORM_2PACK16,
enum VkFormat: R12X4G12X4B12X4A12X4_UNORM_4PACK16, VK_IMAGE_USAGE_X_BIT where X is
VK_FORMAT_X where X is G12X4B12X4G12X4R12X4_422_UNORM_4PACK16, TRANSFER_SRC,
UNDEFINED, B12X4G12X4R12X4G12X4_422_UNORM_4PACK16, TRANSFER_DST,
R4G4_UNORM_PACK8, G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16, SAMPLED,
R4G4B4A4_UNORM_PACK16, G12X4_B12X4R12X4_2PLANE_{420, 422}_UNORM_3PACK16, STORAGE,
B4G4R4A4_UNORM_PACK16, G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16, COLOR_ATTACHMENT,
R5G6B5_UNORM_PACK16, G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16, DEPTH_STENCIL_ATTACHMENT,
B5G6R5_UNORM_PACK16, G16B16G16R16_422_UNORM, TRANSIENT_ATTACHMENT,
R5G5B5A1_UNORM_PACK16, B16G16R16G16_422_UNORM, INPUT_ATTACHMENT
B5G5R5A1_UNORM_PACK16, G16_B16_R16_3PLANE_{420, 422, 444}_UNORM,
A1R5G5B5_UNORM_PACK16, G16_B16R16_2PLANE_{420, 422}_UNORM typedef struct VkImageViewUsageCreateInfo {
R8_[UNORM, SNORM, USCALED], VkStructureType sType; P.15
R8_[SSCALED, UINT, SINT, SRGB], enum VkImageAspectFlagBits: const void* pNext;
R8G8_[UNORM, SNORM, USCALED], VkImageUsageFlags usage; P.13
VK_IMAGE_ASPECT_X_BIT where X is } VkImageViewUsageCreateInfo;
R8G8_[SSCALED, UINT, SINT, SRGB], COLOR, DEPTH, STENCIL, METADATA, PLANE_[0,1,2]
R8G8B8_[UNORM, SNORM, USCALED],
R8G8B8_[SSCALED, UINT, SINT, SRGB], typedef struct VkInputAttachmentAspectReference {
enum VkImageCreateFlagBits: uint32_t subpass;
B8G8R8_[UNORM, SNORM, USCALED],
B8G8R8_[SSCALED, UINT, SINT, SRGB], VK_IMAGE_CREATE_X_BIT where X is uint32_t inputAttachmentIndex;
R8G8B8A8_[UNORM, SNORM, USCALED], SPARSE_{BINDING, RESIDENCY, ALIASED}, VkImageAspectFlags aspectMask; P.13
R8G8B8A8_[SSCALED, UINT, SINT, SRGB], MUTABLE_FORMAT, } VkInputAttachmentAspectReference;
B8G8R8A8_[UNORM, SNORM, USCALED], {CUBE, 2D_ARRAY, TEXEL_VIEW}_COMPATIBLE,
B8G8R8A8_[SSCALED, UINT, SINT, SRGB], ALIAS, BIND_SFR, typedef struct VkMemoryAllocateFlagsInfo {
A8B8G8R8_[UNORM, SNORM, USCALED]_PACK32, EXTENDED_USAGE, VkStructureType sType; P.15
A8B8G8R8_[SSCALED, UINT, SINT, SRGB]_PACK32, PROTECTED, const void* pNext;
A2R10G10B10_[UNORM, SNORM, USCALED]_PACK32, DISJOINT VkMemoryAllocateFlags flags;
A2R10G10B10_[SSCALED, UINT, SINT]_PACK32, uint32_t deviceMask;
A2B10G10R10_[UNORM, SNORM, USCALED]_PACK32, enum VkImageLayout: } VkMemoryAllocateFlagsInfo;
A2B10G10R10_[SSCALED, UINT, SINT]_PACK32, VK_IMAGE_LAYOUT_X where X is flags: VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT
R16_[UNORM, SNORM, USCALED], UNDEFINED, GENERAL, PREINITIALIZED,
R16_[SSCALED, UINT, SINT, SFLOAT], COLOR_ATTACHMENT_OPTIMAL, typedef struct VkMemoryBarrier {
R16G16_[UNORM, SNORM, USCALED], DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, VkStructureType sType; P.15
R16G16_[SSCALED, UINT, SINT, SFLOAT], DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, const void* pNext;
R16G16B16_[UNORM, SNORM, USCALED], DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VkAccessFlags srcAccessMask; P.12
R16G16B16_[SSCALED, UINT, SINT, SFLOAT], DEPTH_STENCIL_READ_ONLY_OPTIMAL, VkAccessFlags dstAccessMask; P.12
R16G16B16A16_[UNORM, SNORM, USCALED], SHADER_READ_ONLY_OPTIMAL, } VkMemoryBarrier;
R16G16B16A16_[SSCALED, UINT, SINT, SFLOAT], TRANSFER_{SRC, DST}_OPTIMAL,
R32_[UINT, SINT, SFLOAT], DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, typedef struct VkMemoryDedicatedAllocateInfo {
R32G32_[UINT, SINT, SFLOAT], DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, VkStructureType sType; P.15
R32G32B32_[UINT, SINT, SFLOAT], VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, const void* pNext;
R32G32B32A32_[UINT, SINT, SFLOAT], VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR VkImage image; VkBuffer buffer;
R64_[UINT, SINT, SFLOAT], NOTE: For the functions vkCmdCopyImage, } VkMemoryDedicatedAllocateInfo;
R64G64_[UINT, SINT, SFLOAT], vkCmdCopyBufferToImage, vkCmdCopyImageToBuffer,
R64G64B64_[UINT, SINT, SFLOAT], vkCmdBlitImage, and vkCmdResolveImage, the enum typedef struct VkMemoryDedicatedRequirements {
R64G64B64A64_[UINT, SINT, SFLOAT], VkImageLayout for the following parameters may be: VkStructureType sType; P.15
B10G11R11_UFLOAT_PACK32, void* pNext;
E5B9G9R9_UFLOAT_PACK32, srcImageLayout: VK_IMAGE_LAYOUT_GENERAL,
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VkBool32 prefersDedicatedAllocation;
X8_D24_UNORM_PACK32, VkBool32 requiresDedicatedAllocation;
D32_SFLOAT[_S8_UINT], VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR
} VkMemoryDedicatedRequirements;
S8_UINT, dstImageLayout: VK_IMAGE_LAYOUT_GENERAL,
D[16, 24]_UNORM_S8_UINT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, typedef struct VkMemoryHeap {
BC1_[RGB, RGBA]_UNORM_BLOCK, VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR VkDeviceSize size;
BC1_[RGB, RGBA]_SRGB_BLOCK, VkMemoryHeapFlags flags;
BC2_[UNORM, SRGB]_BLOCK, typedef struct VkImageMemoryBarrier { } VkMemoryHeap;
BC3_[UNORM, SRGB]_BLOCK, VkStructureType sType; P.15
BC4_[UNORM, SRGB]_BLOCK, const void* pNext; flags: VK_MEMORY_HEAP_X_BIT where X is
BC5_[UNORM, SRGB]_BLOCK, VkAccessFlags srcAccessMask; P.12 DEVICE_LOCAL, MULTI_INSTANCE
BC6H_[UFLOAT, SFLOAT]_BLOCK, VkAccessFlags dstAccessMask; P.12
BC7_[UNORM, SRGB]_BLOCK, VkImageLayout oldLayout; P.13 typedef struct VkMemoryRequirements {
ETC2_R8G8B8_[UNORM, SRGB]_BLOCK, VkImageLayout newLayout; P.13 VkDeviceSize size;
ETC2_R8G8B8A1_[UNORM, SRGB]_BLOCK, uint32_t srcQueueFamilyIndex; VkDeviceSize alignment;
ETC2_R8G8B8A8_[UNORM, SRGB]_BLOCK, uint32_t dstQueueFamilyIndex; uint32_t memoryTypeBits;
EAC_R11_[UNORM, SRGB]_BLOCK, VkImage image; } VkMemoryRequirements;
EAC_R11G11_[UNORM, SRGB]_BLOCK, VkImageSubresourceRange subresourceRange; P.1313
ASTC_4x4_[UNORM, SRGB]_BLOCK, } VkImageMemoryBarrier; typedef struct VkMemoryRequirements2 {
ASTC_5x4_[UNORM, SRGB]_BLOCK, VkStructureType sType; P.15
ASTC_5x5_[UNORM, SRGB]_BLOCK, typedef struct VkImagePlaneMemoryRequirementsInfo { void* pNext;
ASTC_6x5_[UNORM, SRGB]_BLOCK, VkStructureType sType; P.15 VkMemoryRequirements memoryRequirements; P.13
ASTC_6x6_[UNORM, SRGB]_BLOCK, const void* pNext; } VkMemoryRequirements2;
ASTC_8x5_[UNORM, SRGB]_BLOCK, VkImageAspectFlagBits planeAspect; P.1313 pNext must be NULL or point to:
ASTC_8x6_[UNORM, SRGB]_BLOCK, } VkImagePlaneMemoryRequirementsInfo; VkMemoryDedicatedRequirements P13
ASTC_8x8_[UNORM, SRGB]_BLOCK,
Continued on next page >
©2018 Khronos Group - Rev. 1118 www.khronos.org/vulkan
Vulkan 1.1 Reference Guide Page 14
Structures and Enumerations (continued) VkStructureType sType; P.15
void* pNext;
VkDeviceSize minStorageBufferOffsetAlignment;
int32_t minTexelOffset; uint32_t maxTexelOffset;
typedef struct VkMemoryType { VkPhysicalDeviceFeatures features; P.14 int32_t minTexelGatherOffset;
VkMemoryPropertyFlags propertyFlags; } VkPhysicalDeviceFeatures2; uint32_t maxTexelGatherOffset;
uint32_t heapIndex; pNext must be NULL or point to one of: float minInterpolationOffset;
} VkMemoryType; VkPhysicalDevice16BitStorageFeatures P.14 float maxInterpolationOffset;
VkPhysicalDeviceMultiviewFeatures P.14 uint32_t subPixelInterpolationOffsetBits;
propertyFlags: VK_MEMORY_PROPERTY_X_BIT where X is uint32_t maxFramebufferWidth;
DEVICE_LOCAL, HOST_VISIBLE, HOST_COHERENT, VkPhysicalDeviceProtectedMemoryFeatures P.15
VkPhysicalDeviceSamplerYcbcrConversionFeatures P.15 uint32_t maxFramebufferHeight;
HOST_CACHED, LAZILY_ALLOCATED, PROTECTED uint32_t maxFramebufferLayers;
VkPhysicalDeviceShaderDrawParameterFeatures P.15
typedef struct VkOffset2D { VkPhysicalDeviceVariablePointerFeatures P.15 VkSampleCountFlags framebufferColorSampleCounts; P.15
int32_t x; VkSampleCountFlags framebufferDepthSampleCounts; P.15
int32_t y; typedef struct VkPhysicalDeviceIDProperties { VkSampleCountFlags framebufferStencilSampleCounts; P.15
} VkOffset2D; VkStructureType sType; P.15 VkSampleCountFlags
void* pNext; framebufferNoAttachmentsSampleCounts; P.15
typedef struct VkOffset3D { uint8_t deviceUUID[VK_UUID_SIZE]; uint32_t maxColorAttachments;
int32_t x; uint8_t driverUUID[VK_UUID_SIZE]; VkSampleCountFlags
int32_t y; uint8_t deviceLUID[VK_LUID_SIZE]; sampledImageColorSampleCounts; P.15
int32_t z; uint32_t deviceNodeMask; VkSampleCountFlags
} VkOffset3D; VkBool32 deviceLUIDValid; sampledImageIntegerSampleCounts; P.15
} VkPhysicalDeviceIDProperties; VkSampleCountFlags
typedef struct VkPhysicalDevice16BitStorageFeatures { sampledImageDepthSampleCounts; P.15
VkStructureType sType; P.15 typedef struct VkPhysicalDeviceLimits { VkSampleCountFlags
void* pNext; uint32_t maxImageDimension1D; sampledImageStencilSampleCounts; P.15
VkBool32 storageBuffer16BitAccess; uint32_t maxImageDimension2D; VkSampleCountFlags storageImageSampleCounts; P.15
VkBool32 uniformAndStorageBuffer16BitAccess; uint32_t maxImageDimension3D; uint32_t maxSampleMaskWords;
VkBool32 storagePushConstant16; uint32_t maxImageDimensionCube; VkBool32 timestampComputeAndGraphics;
VkBool32 storageInputOutput16; uint32_t maxImageArrayLayers; float timestampPeriod;
} VkPhysicalDevice16BitStorageFeatures; uint32_t maxTexelBufferElements; uint32_t maxClipDistances;
uint32_t maxUniformBufferRange; uint32_t maxCullDistances;
typedef struct VkPhysicalDeviceExternalImageFormatInfo { uint32_t maxStorageBufferRange; uint32_t maxCombinedClipAndCullDistances;
VkStructureType sType; P.15 uint32_t maxPushConstantsSize; uint32_t discreteQueuePriorities;
const void* pNext; uint32_t maxMemoryAllocationCount; float pointSizeRange[2]; float lineWidthRange[2];
VkExternalMemoryHandleTypeFlagBits handleType; P.1512 uint32_t maxSamplerAllocationCount; float pointSizeGranularity;
} VkPhysicalDeviceExternalImageFormatInfo; VkDeviceSize bufferImageGranularity; float lineWidthGranularity;
VkDeviceSize sparseAddressSpaceSize; VkBool32 strictLines;
typedef struct VkPhysicalDeviceFeatures { uint32_t maxBoundDescriptorSets; VkBool32 standardSampleLocations;
VkBool32 robustBufferAccess; uint32_t maxPerStageDescriptorSamplers; VkDeviceSize optimalBufferCopyOffsetAlignment;
VkBool32 fullDrawIndexUint32; uint32_t maxPerStageDescriptorUniformBuffers; VkDeviceSize optimalBufferCopyRowPitchAlignment;
VkBool32 imageCubeArray; uint32_t maxPerStageDescriptorStorageBuffers; VkDeviceSize nonCoherentAtomSize;
VkBool32 independentBlend; uint32_t maxPerStageDescriptorSampledImages; } VkPhysicalDeviceLimits;
VkBool32 geometryShader; uint32_t maxPerStageDescriptorStorageImages;
VkBool32 tessellationShader; uint32_t maxPerStageDescriptorInputAttachments; typedef struct VkPhysicalDeviceMaintenance3Properties {
VkBool32 sampleRateShading; uint32_t maxPerStageResources; VkStructureType sType; P.15
VkBool32 dualSrcBlend; uint32_t maxDescriptorSetSamplers; void* pNext;
VkBool32 logicOp; uint32_t maxDescriptorSetUniformBuffers; uint32_t maxPerSetDescriptors;
VkBool32 multiDrawIndirect; uint32_t maxDescriptorSetUniformBuffersDynamic; VkDeviceSize maxMemoryAllocationSize;
VkBool32 drawIndirectFirstInstance; uint32_t maxDescriptorSetStorageBuffers; } VkPhysicalDeviceMaintenance3Properties;
VkBool32 depthClamp; uint32_t maxDescriptorSetStorageBuffersDynamic;
uint32_t maxDescriptorSetSampledImages; typedef struct VkPhysicalDeviceMemoryProperties {
VkBool32 depthBiasClamp; uint32_t memoryTypeCount; VkMemoryType
VkBool32 fillModeNonSolid; uint32_t maxDescriptorSetStorageImages;
uint32_t maxDescriptorSetInputAttachments; memoryTypes[VK_MAX_MEMORY_TYPES]; P.14
VkBool32 depthBounds; uint32_t memoryHeapCount; VkMemoryHeap
VkBool32 wideLines; uint32_t maxVertexInputAttributes;
uint32_t maxVertexInputBindings; memoryHeaps[VK_MAX_MEMORY_HEAPS]; P.13
VkBool32 largePoints; } VkPhysicalDeviceMemoryProperties;
VkBool32 alphaToOne; uint32_t maxVertexInputAttributeOffset;
VkBool32 multiViewport; uint32_t maxVertexInputBindingStride; typedef struct VkPhysicalDeviceMultiviewFeatures {
VkBool32 samplerAnisotropy; uint32_t maxVertexOutputComponents; VkStructureType sType; P.15
VkBool32 textureCompressionETC2; uint32_t maxTessellationGenerationLevel; void* pNext;
VkBool32 textureCompressionASTC_LDR; uint32_t maxTessellationPatchSize; VkBool32 multiview;
VkBool32 textureCompressionBC; uint32_t VkBool32 multiviewGeometryShader;
VkBool32 occlusionQueryPrecise; maxTessellationControlPerVertexInputComponents; VkBool32 multiviewTessellationShader;
VkBool32 pipelineStatisticsQuery; uint32_t } VkPhysicalDeviceMultiviewFeatures;
VkBool32 vertexPipelineStoresAndAtomics; maxTessellationControlPerVertexOutputComponents;
VkBool32 fragmentStoresAndAtomics; uint32_t typedef struct VkPhysicalDeviceMultiviewProperties {
VkBool32 shaderTessellationAndGeometryPointSize; maxTessellationControlPerPatchOutputComponents; VkStructureType sType; P.15
VkBool32 shaderImageGatherExtended; uint32_t maxTessellationControlTotalOutputComponents; void* pNext;
VkBool32 shaderStorageImageExtendedFormats; uint32_t maxTessellationEvaluationInputComponents; uint32_t maxMultiviewViewCount;
VkBool32 shaderStorageImageMultisample; uint32_t maxTessellationEvaluationOutputComponents; uint32_t maxMultiviewInstanceIndex;
VkBool32 shaderStorageImageReadWithoutFormat; uint32_t maxGeometryShaderInvocations; } VkPhysicalDeviceMultiviewProperties;
VkBool32 shaderStorageImageWriteWithoutFormat; uint32_t maxGeometryInputComponents;
VkBool32 shaderUniformBufferArrayDynamicIndexing; uint32_t maxGeometryOutputComponents; typedef struct VkPhysicalDevicePointClippingProperties {
VkBool32 shaderSampledImageArrayDynamicIndexing; uint32_t maxGeometryOutputVertices; VkStructureType sType; P.15
VkBool32 shaderStorageBufferArrayDynamicIndexing; uint32_t maxGeometryTotalOutputComponents; void* pNext;
VkBool32 shaderStorageImageArrayDynamicIndexing; uint32_t maxFragmentInputComponents; VkPointClippingBehavior pointClippingBehavior;
VkBool32 shaderClipDistance; uint32_t maxFragmentOutputAttachments; } VkPhysicalDevicePointClippingProperties;
VkBool32 shaderCullDistance; uint32_t maxFragmentDualSrcAttachments; pointClippingBehavior:
VkBool32 shaderFloat64; uint32_t maxFragmentCombinedOutputResources; VK_POINT_CLIPPING_BEHAVIOR_X where X is
VkBool32 shaderInt64; uint32_t maxComputeSharedMemorySize; ALL_CLIP_PLANES, USER_CLIP_PLANES_ONLY
VkBool32 shaderInt16; uint32_t maxComputeWorkGroupCount[3];
VkBool32 shaderResourceResidency; uint32_t maxComputeWorkGroupInvocations; typedef struct VkPhysicalDeviceProperties {
VkBool32 shaderResourceMinLod; uint32_t maxComputeWorkGroupSize[3]; uint32_t apiVersion; uint32_t driverVersion;
VkBool32 sparseBinding; uint32_t subPixelPrecisionBits; uint32_t vendorID; uint32_t deviceID;
VkBool32 sparseResidencyBuffer; uint32_t subTexelPrecisionBits; VkPhysicalDeviceType deviceType;
VkBool32 sparseResidencyImage2D; uint32_t mipmapPrecisionBits; char deviceName[
VkBool32 sparseResidencyImage3D; uint32_t maxDrawIndexedIndexValue; VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
VkBool32 sparseResidency2Samples; uint32_t maxDrawIndirectCount; uint8_t pipelineCacheUUID[VK_UUID_SIZE];
VkBool32 sparseResidency4Samples; float maxSamplerLodBias; VkPhysicalDeviceLimits limits; P.14
VkBool32 sparseResidency8Samples; float maxSamplerAnisotropy; VkPhysicalDeviceSparseProperties sparseProperties; P.15
VkBool32 sparseResidency16Samples; uint32_t maxViewports; } VkPhysicalDeviceProperties;
VkBool32 sparseResidencyAliased; uint32_t maxViewportDimensions[2]; deviceType:
VkBool32 variableMultisampleRate; float viewportBoundsRange[2]; VK_PHYSICAL_DEVICE_TYPE_X where X is
VkBool32 inheritedQueries; uint32_t viewportSubPixelBits; OTHER, INTEGRATED_GPU, DISCRETE_GPU,
} VkPhysicalDeviceFeatures; size_t minMemoryMapAlignment; VIRTUAL_GPU, CPU
VkDeviceSize minTexelBufferOffsetAlignment;
typedef struct VkPhysicalDeviceFeatures2 { VkDeviceSize minUniformBufferOffsetAlignment; Continued on next page >
©2018 Khronos Group - Rev. 1118 www.khronos.org/vulkan
Vulkan 1.1 Reference Guide Page 15
Structures and Enumerations (continued) enum VkPipelineStageFlagBits: VkStructureType
The name of each VkStructureType value is obtained by
VK_PIPELINE_STAGE_X_BIT where X is
typedef struct TOP_OF_PIPE, DRAW_INDIRECT, VERTEX_[INPUT, SHADER], taking the name of the structure, stripping the leading
VkPhysicalDeviceProtectedMemoryFeatures { TESSELLATION_[CONTROL, EVALUATION]_SHADER, Vk, prefixing each capital letter with _, converting the
VkStructureType sType; P.15 [COMPUTE, GEOMETRY, FRAGMENT]_SHADER, entire resulting string to upper case, and prefixing it
void* pNext; VkBool32 protectedMemory; [EARLY, LATE]_FRAGMENT_TESTS, with VK_STRUCTURE_TYPE_.
} VkPhysicalDeviceProtectedMemoryFeatures; COLOR_ATTACHMENT_OUTPUT,
TRANSFER, BOTTOM_OF_PIPE, HOST, typedef struct VkSurfaceCapabilitiesKHR {
typedef struct ALL_{GRAPHICS, COMMANDS} uint32_t minImageCount;
VkPhysicalDeviceProtectedMemoryProperties { uint32_t maxImageCount;
VkStructureType sType; P.15 typedef struct VkExtent2D currentExtent; P.12
void* pNext; VkBool32 protectedNoFault; VkPipelineTessellationDomainOriginStateCreateInfo{ VkExtent2D minImageExtent; P.12
} VkPhysicalDeviceProtectedMemoryProperties; VkStructureType sType; P.15 VkExtent2D maxImageExtent; P.12
const void* pNext; uint32_t maxImageArrayLayers;
typedef struct VkTessellationDomainOrigin domainOrigin; VkSurfaceTransformFlagsKHR supportedTransforms; P.15
VkPhysicalDeviceSamplerYcbcrConversionFeatures { } VkPipelineTessellationDomainOriginStateCreateInfo; VkSurfaceTransformFlagBitsKHR currentTransform; P.15
VkStructureType sType; P.15 domainOrigin: VkCompositeAlphaFlagsKHR
void* pNext; VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT supportedCompositeAlpha; P.12
VkBool32 samplerYcbcrConversion; VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT VkImageUsageFlags supportedUsageFlags; P.13
} VkPhysicalDeviceSamplerYcbcrConversionFeatures; } VkSurfaceCapabilitiesKHR;
typedef struct VkProtectedSubmitInfo { enum VkCompositeAlphaFlagBitsKHR:
typedef struct VkStructureType sType; P.15 VK_COMPOSITE_ALPHA_X_BIT_KHR where X is
VkPhysicalDeviceShaderDrawParameterFeatures { const void* pNext; VkBool32 protectedSubmit; OPAQUE, PRE_MULTIPLIED, POST_MULTIPLIED, INHERIT
VkStructureType sType; P.15 } VkProtectedSubmitInfo;
void* pNext; typedef struct VkSurfaceFormatKHR {
VkBool32 shaderDrawParameters; enum VkQueryPipelineStatisticFlagBits: VkFormat format; P.13
} VkPhysicalDeviceShaderDrawParameterFeatures; VK_QUERY_PIPELINE_STATISTIC_X_BIT where X is VkColorSpaceKHR colorSpace;
INPUT_ASSEMBLY_{VERTICES, PRIMITIVES}, } VkSurfaceFormatKHR;
typedef struct VkPhysicalDeviceSparseProperties { VERTEX_SHADER_INVOCATIONS, colorSpace: VK_COLOR_SPACE_SRGB_NONLINEAR_KHR
VkBool32 residencyStandard2DBlockShape; GEOMETRY_SHADER_{INVOCATIONS, PRIMITIVES},
VkBool32 residencyStandard2DMultisampleBlockShape; CLIPPING_{INVOCATIONS, PRIMITIVES}, enum VkSurfaceTransformFlagBitsKHR {
VkBool32 residencyStandard3DBlockShape; FRAGMENT_SHADER_INVOCATIONS, VK_SURFACE_TRANSFORM_X_BIT_KHR where X is
VkBool32 residencyAlignedMipSize; TESSELLATION_CONTROL_SHADER_PATCHES, IDENTITY,
VkBool32 residencyNonResidentStrict; TESSELLATION_EVALUATION_SHADER_INVOCATIONS, ROTATE_{90, 180, 270},
} VkPhysicalDeviceSparseProperties; COMPUTE_SHADER_INVOCATIONS HORIZONTAL_MIRROR
HORIZONTAL_MIRROR_ROTATE_{90, 180, 270},
typedef struct VkPhysicalDeviceSubgroupProperties { typedef struct VkRect2D { INHERIT
VkStructureType sType; P.15 VkOffset2D offset; P14
void* pNext; uint32_t subgroupSize; VkExtent2D extent; P.12 typedef struct VkViewport {
VkShaderStageFlags supportedStages; P.15 } VkRect2D; float x; float y;
VkSubgroupFeatureFlags supportedOperations; float width; float height;
VkBool32 quadOperationsInAllStages; typedef struct float minDepth; float maxDepth;
} VkPhysicalDeviceSubgroupProperties; VkRenderPassInputAttachmentAspectCreateInfo { } VkViewport;
supportedOperations: VkStructureType sType; P.15
VK_SUBGROUP_FEATURE_X_BIT where X is const void* pNext; uint32_t aspectReferenceCount;
ARITHMETIC, BALLOT, BASIC, CLUSTERED, QUAD, SHUFFLE, const VkInputAttachmentAspectReference*
SHUFFLE_RELATIVE, VOTE pAspectReferences; P.13
} VkRenderPassInputAttachmentAspectCreateInfo;
typedef struct VkPhysicalDeviceSurfaceInfo2KHR { Learn more about Vulkan
VkStructureType sType; P.15 typedef struct VkRenderPassMultiviewCreateInfo { Vulkan is maintained by the Khronos Group, a worldwide
const void* pNext; VkSurfaceKHR surface; VkStructureType sType; P.15 consortium of organizations that work to create and maintain
} VkPhysicalDeviceSurfaceInfo2KHR; const void* pNext; uint32_t subpassCount; key standards used across many industries. Visit Khronos
const uint32_t* pViewMasks; online for resources to help you use and master Vulkan:
typedef struct VkPhysicalDeviceVariablePointerFeatures { uint32_t dependencyCount;
VkStructureType sType; P.15 const int32_t* pViewOffsets; Main Vulkan Resource Page: khronos.org/vulkan/
void* pNext; uint32_t correlationMaskCount;
VkBool32 variablePointersStorageBuffer; const uint32_t* pCorrelationMasks; Vulkan Registry: khronos.org/registry/vulkan/
VkBool32 variablePointers; } VkRenderPassMultiviewCreateInfo; Forums: forums.khronos.org/
} VkPhysicalDeviceVariablePointerFeatures;
enum VkSampleCountFlagBits: Courses: khronos.org/developers/training/
enum VkPipelineBindPoint: VK_SAMPLE_COUNT_X_BIT where X is
VK_PIPELINE_BIND_POINT_COMPUTE, 1, 2, 4, 8, 16, 32, 64 Videos & Presentations: khr.io/library/
VK_PIPELINE_BIND_POINT_GRAPHICS
Khronos Events: khronos.org/news/events/
typedef struct
enum VkPipelineCreateFlagBits: VkSamplerYcbcrConversionImageFormatProperties { Khronos Blog: khronos.org/blog/
VK_PIPELINE_CREATE_X where X is VkStructureType sType; P.15
DISABLE_OPTIMIZATION_BIT, void* pNext; Reference Guides: khr.io/refguides/
ALLOW_DERIVATIVES_BIT, uint32_t combinedImageSamplerDescriptorCount;
DERIVATIVE_BIT, } VkSamplerYcbcrConversionImageFormatProperties; Khronos Books: khronos.org/developers/books/
VIEW_INDEX_FROM_DEVICE_INDEX_BIT, Khronos Merchandise: khronos.org/store/
DISPATCH_BASE typedef struct VkSamplerYcbcrConversionInfo {
VkStructureType sType; P.15
typedef struct VkPipelineShaderStageCreateInfo { const void* pNext;
VkStructureType sType; P.15 VkSamplerYcbcrConversion conversion;
const void* pNext; } VkSamplerYcbcrConversionInfo
VkPipelineShaderStageCreateFlags flags; = 0
VkShaderStageFlagBits stage; P.15 enum VkShaderStageFlagBits:
VkShaderModule module; VK_SHADER_STAGE_X where X is
const char* pName; {VERTEX, GEOMETRY, FRAGMENT, COMPUTE}_BIT,
const VkSpecializationInfo* pSpecializationInfo; P.15 TESSELLATION_CONTROL_BIT,
} VkPipelineShaderStageCreateInfo; TESSELLATION_EVALUATION_BIT,
ALL_GRAPHICS, ALL
typedef struct VkSpecializationInfo {
uint32_t mapEntryCount; enum VkSharingMode:
const VkSpecializationMapEntry* pMapEntries; P.15 VK_SHARING_MODE_EXCLUSIVE,
size_t dataSize; const void* pData; VK_SHARING_MODE_CONCURRENT
} VkSpecializationInfo;
typedef struct VkSparseMemoryBind {
typedef struct VkSpecializationMapEntry { VkDeviceSize resourceOffset;VkDeviceSize size;
uint32_t constantID; VkDeviceMemory memory; VkDeviceSize memoryOffset;
uint32_t offset; VkSparseMemoryBindFlags flags;
size_t size; } VkSparseMemoryBind;
} VkSpecializationMapEntry;
flags: VK_SPARSE_MEMORY_BIND_METADATA_BIT
@thekhronosgroup khronos.org
©2018 Khronos Group - Rev. 1118 www.khronos.org/vulkan
Vulkan 1.1 Reference Guide Page 16
Vulkan Reference Guide Index
The following index shows each item included on this card along with the page on which it is described. The color of the row in the table below is the color of the pane to which you should refer.
A-G VkGr-VkP
Android Platform 9 vkCmdBindPipeline 4 vkDestroyDevice 1 VkGraphicsPipelineCreateInfo 3
Blending 8 vkCmdBindVertexBuffers 8 vkDestroyFramebuffer 3 VkImageBlit 8
Buffers 5 vkCmdBlitImage 8 vkDestroyImage[View] 6 VkImageCopy 8
Cache Control 2 vkCmdClearAttachments 7 vkDestroyInstance 1 VkImageCreateInfo 5
Clear Commands 7-8 vkCmdClearColorImage 7 vkDestroyPipeline[Cache] 4 VkImageFormatProperties* 11
Command Buffers 1-2 vkCmdClearDepthStencilImage 7 vkDestroyPipelineLayout 6 VkImageMemoryRequirementsInfo2 6
Command Funciton Pointers 1 vkCmdCopyBuffer[ToImage] 8 vkDestroyQueryPool 7 VkImageResolve 8
Command Pools 1 vkCmdCopyImage[ToBuffer] 8 vkDestroyRenderPass 3 VkImageSparseMemoryRequirementsInfo2 9
Compute Pipelines 3 vkCmdCopyQueryPoolResults 7 vkDestroySampler[YcbcrConversion] 6 VkImageSubresource 5
Copy Commands 8 vkCmdDispatch* 8 vkDestroySemaphore 2 VkImageSwapchainCreateInfoKHR 5
Depth Bias 8 vkCmdDraw[Indirect] 8 vkDestroyShaderModule 3 VkImageViewCreateInfo 6
Depth Bounds 8 vkCmdDrawIndexed[Indirect] 8 vkDestroySurfaceKHR 9 VkInstanceCreateInfo 1
Descriptors, Resource 6-7 vkCmdEndQuery 7 vkDestroySwapchainKHR 10 vkInvalidateMappedMemoryRanges 4
Devices 1 vkCmdEndRenderPass 3 VkDev - vkF VkLayerProperties 10
Dispatching Commands 8 vkCmdExecuteCommands 2 VkDevice[GroupDevice]CreateInfo 1 vkMapMemory 4
Display Enumeration 9 vkCmdFillBuffer 8 VkDeviceGroupPresentCapabilitiesKHR 10 VkMappedMemoryRange 4
Drawing Commands 8 vkCmdNextSubpass 3 VkDeviceGroupPresentInfoKHR 10 VkMemoryAllocateInfo 4
Enumerations 12-15 vkCmdPipelineBarrier 2 VkDeviceGroupSwapchainCreateInfoKHR 10 vkMergePipelineCaches 4
Events 2 vkCmdPushConstants 7 VkDeviceQueue[Create]Info* 1 VkPhysicalDeviceExternalBufferInfo 11
Extensions 10 vkCmdResetQueryPool 7 vkDeviceWaitIdle 2 VkPhysicalDeviceExternalFenceInfo 11
Fences 2 vkCmdResolveImage 8 VkDispatchIndirectCommand 8 VkPhysicalDeviceExternalSemaphoreInfo 11
Format Properties 11 vkCmdSetBlendConstants 8 VkDisplayMode* 9 VkPhysicalDevice[Group]Properties* 1
Fragment Operations 8 vkCmdSetDepthBias 8 VkDisplayPlane* 9 VkPhysicalDeviceImageFormatInfo2 11
Framebuffers 3 vkCmdSetDepthBounds 8 VkDisplayPresentInfoKHR 10 VkPhysicalDeviceMemoryProperties2 4
Graphics Pipelines 3 vkCmdSetDeviceMask 2 VkDisplayPropertiesKHR 9 VkPhysicalDeviceSparseImageFormatInfo2 9
I-R vkCmdSetLineWidth 8 VkDisplaySurfaceCreateInfoKHR 9 VkPipelineCacheCreateInfo 4
Image Capabilities 11 vkCmdSetScissor 8 VkDraw[Indexed]IndirectCommand 8 VkPipelineColorBlend* 4
Image Views 6 vkCmdSetStencil{Compare, Write}Mask 8 vkEndCommandBuffer 2 VkPipelineDepthStencilStateCreateInfo 4
Images 5 vkCmdSetStencilReference 8 vkEnumerateDevice* 10 VkPipelineDynamicStateCreateInfo 4
Instances 1 vkCmdSetViewport 8 vkEnumerateInstance* 10 VkPipelineInputAssemblyStateCreateInfo 4
Layers 10 vkCmdUpdateBuffer 8 vkEnumerateInstanceVersion 1 VkPipelineLayoutCreateInfo 6
Line Width 8 vkCmdWaitEvents 2 vkEnumeratePhysicalDevice* 1 VkPipelineMultisampleStateCreateInfo 4
Memory Allocation 4 vkCmdWriteTimestamp 7 Vk{Event, Fence}CreateInfo 2 VkPipelineRasterizationStateCreateInfo 4
Pipeline Barriers 2 VkCo - vkCr VkExtensionProperties 11 VkPipelineTessellationStateCreateInfo 4
VkExternalBufferProperties 11 VkPipelineVertexInputStateCreateInfo 3
Pipeline Layouts 6 VkCommandBuffer* 2
VkExternalFenceProperties 11 VkPipelineViewportStateCreateInfo 4
Pipelines 3-4 VkCommandPoolCreateInfo 1
VkExternalSemaphoreProperties 11
Queries 7 VkComponentMapping 6 VkPr-VkSt
vkFlushMappedMemoryRanges 4
Queues 1 VkComputePipelineCreateInfo 3 VkPresentInfoKHR 10
VkFormatProperties* 11
Rasterization 8 VkCopyDescriptorSet 7 VkPresentRegion[s]KHR 10
VkFramebufferCreateInfo 3
Render Pass 3 vkCreate{Event, Fence} 2 VkPushConstantRange 6
vkFreeCommandBuffers 2
Resource Creation 5-6 vkCreateAndroidSurfaceKHR 9 VkQueryPoolCreateInfo 7
vkFreeDescriptorSets 7
Resource Descriptors 6-7 vkCreateBuffer[View] 5 vkQueueBindSparse 9
vkFreeMemory 4
Return Codes 1 vkCreateCommandPool 1 VkQueueFamilyProperties* 1
vkCreateComputePipelines 3 vkG vkQueuePresentKHR 10
S-V
vkCreateDescriptorPool 6 vkGet{Event, Fence}Status 2 vkQueueSubmit 2
Samplers 6
vkCreateDescriptorSetLayout 6 vkGetBufferMemoryRequirements* 6 vkQueueWaitIdle 2
Scissor Test 8
vkCreateDescriptorUpdateTemplate 7 vkGetDescriptorSetLayoutSupport 6 VkRectLayerKHR 10
Semaphores 2
vkCreateDevice 1 vkGetDeviceGroupPeerMemoryFeatures 4 VkRenderPass{Begin, Create}Info 3
Shaders 3
vkCreateDisplayModeKHR 9 vkGetDeviceGroupPresentCapabilitiesKHR 10 vkResetCommandBuffer 2
Sparse Resources 8-9
vkCreateDisplayPlaneSurfaceKHR 9 vkGetDeviceGroupSurfacePresentModesKHR 10 vkResetCommandPool 1
Stencil Test 8
vkCreateFramebuffer 3 vkGetDeviceMemoryCommitment 4 vkResetDescriptorPool 7
Structures 12-15
vkCreateGraphicsPipelines 3 vkGetDeviceProcAddr 1 vkResetFences 2
Synchronization 2 vkGetDeviceQueue* 1
Timestamp Queries 7 vkCreateImage 5 VkSampler[YcbcrConversion]CreateInfo 6
vkCreateImageView 6 vkGetDisplayModePropertiesKHR 9 VkSemaphoreCreateInfo 2
Variables, Built-in 3 vkGetDisplayPlaneCapabilitiesKHR 9
Vertex Input Description 8 vkCreateInstance 1 vk{Set, Reset}Event 2
vkCreatePipelineCache 4 vkGetDisplayPlaneSupportedDisplaysKHR 9 VkShaderModuleCreateInfo 3
Viewport 8 vkGetImageMemoryRequirements* 6
vkCreatePipelineLayout 6 VkSharedPresentSurfaceCapabilitiesKHR 10
vkA - vkCl vkGetImageSparseMemoryRequirements* 9
vkCreateQueryPool 7 VkSparseBufferMemoryBindInfo 9
vkAcquireNextImage* 10 vkGetImageSubresourceLayout 5
vkCreateRenderPass 3 VkSparseImageFormatProperties* 8
VkAcquireNextImageInfoKHR 10 vkGetInstanceProcAddr 1
vkCreateSampler[YcbcrConversion] 6 VkSparseImage[Opaque]Memory* 9
vkAllocateCommandBuffers 2 vkGetPhysicalDeviceDisplay[Plane]PropertiesKHR 9
vkCreateSemaphore 2 VkStencilOpState 4
vkAllocateDescriptorSets 7 vkGetPhysicalDeviceExternalBufferProperties 11
vkCreateShaderModule 3 VkSu - W
vkAllocateMemory 4 vkGetPhysicalDeviceExternalFenceProperties 11
vkCreateSharedSwapchainsKHR 10 VkSubmitInfo 2
VkAndroidSurfaceCreateInfoKHR 9 vkGetPhysicalDeviceExternalSemaphoreProperties 11
vkCreateSwapchainKHR 10 VkSubpass* 3
VkApplicationInfo 1 vkGetPhysicalDeviceFeatures* 11
vkCreateWaylandSurfaceKHR 9 VkSubresourceLayout 6
VkAttachment* 3 vkGetPhysicalDeviceFormatProperties* 11
vkCreateWin32SurfaceKHR 9 VkSurface* 10
vkBeginCommandBuffer 2 vkGetPhysicalDeviceImageFormatProperties* 11
vkCreateXcbSurfaceKHR 9 VkSwapchainCreateInfoKHR 10
vkBind{Buffer, Image}Memory* 6 vkGetPhysicalDeviceMemoryProperties* 4
vkCreateXlibSurfaceKHR 9 vkTrimCommandPool 1
VkBindImageMemoryInfo 6 vkGetPhysicalDevicePresentRectanglesKHR 10
VkBindSparseInfo 9 VkDesc - vkDest vkGetPhysicalDeviceProperties* 1 vkUnmapMemory 4
VkBuffer[Image]Copy 8 VkDescriptor{Buffer, Image}Info 7 vkGetPhysicalDeviceQueueFamilyProperties* 1 vkUpdateDescriptorSet* 7
VkBuffer[View]CreateInfo 5 VkDescriptorPool* 7 vkGetPhysicalDeviceSparseImageFormat* 8 VkVertexInputAttributeDescription 4
VkBufferMemoryRequirementsInfo2 6 VkDescriptorSetAllocateInfo 7 vkGetPhysicalDeviceSurface* 10 VkVertexInputBindingDescription 3
VkClear{Attachment, Rect} 7 VkDescriptorSetLayoutSupport 6 vkGetPhysicalDeviceWaylandPresentationSupport* 10 vkWaitForFences 2
VkDescriptorUpdateTemplate* 7 vkGetPhysicalDeviceWin32PresentationSupport* 10 VkWaylandSurfaceCreateInfoKHR 9
vkCm
vkDestroy{Event, Fence} 2 vkGetPhysicalDeviceXcbPresentationSupportKHR 10 VkWin32SurfaceCreateInfoKHR 9
vkCmd{Set, Reset}Event 2
vkDestroyBuffer[View] 5 vkGetPhysicalDeviceXlibPresentationSupportKHR 10 VkWriteDescriptorSet 7
vkCmdBeginQuery 7
vkDestroyCommandPool 1 vkGetPipelineCacheData 4 VkXcbSurfaceCreateInfoKHR 9
vkCmdBeginRenderPass 3
vkDestroyDescriptorPool 7 vkGetQueryPoolResults 7 VkXlibSurfaceCreateInfoKHR 9
vkCmdBindDescriptorSets 7
vkDestroyDescriptorSetLayout 6 vkGetRenderAreaGranularity 3 Wait Idle Operations 2
vkCmdBindIndexBuffer 8
vkDestroyDescriptorUpdateTemplate 7 vkGetSwapchain* 10 WSI (Window System Integration) 9-10

Vulkan is a registered trademark of the Khronos Group. The Khronos Group is an industry
consortium creating open standards for the authoring and acceleration of parallel
computing, graphics and dynamic media on a wide variety of platforms and devices.
See www.khronos.org to learn more about the Khronos Group.
See www.khronos.org/vulkan to learn more about Vulkan.

©2018 Khronos Group - Rev. 1118 Reference guide production by Miller & Mattson www.millermattson.com www.khronos.org/vulkan