Vulkan11 Reference Guide

User Manual:

Open the PDF directly: View PDF .
Page Count: 16

Download
Open PDF In Browser	View PDF

Vulkan 1.1 Quick Reference

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
also a pipeline with programmable and state-driven fixed-function
stages that are invoked by a set of specific drawing operations.
Specification and additional resources at
www.khronos.org/vulkan

Return Codes [2.7.3]

Return codes are reported via VkResult return values.

Success Codes

Success codes are non-negative.
VK_SUCCESS
VK_NOT_READY
VK_TIMEOUT
VK_EVENT_{SET, RESET}
VK_INCOMPLETE
VK_SUBOPTIMAL_KHR

Error Codes

Error codes are negative.
VK_ERROR_OUT_OF_{HOST, DEVICE}_MEMORY
VK_ERROR_{INITIALIZATION, MEMORY_MAP}_FAILED
VK_ERROR_DEVICE_LOST
VK_ERROR_{EXTENSION, FEATURE, LAYER}_NOT_PRESENT
VK_ERROR_INCOMPATIBLE_DRIVER
VK_ERROR_TOO_MANY_OBJECTS
VK_ERROR_FORMAT_NOT_SUPPORTED
VK_ERROR_FRAGMENTED_POOL
VK_ERROR_OUT_OF_POOL_MEMORY
VK_ERROR_INVALID_EXTERNAL_HANDLE
VK_ERROR_SURFACE_LOST_KHR
VK_ERROR_NATIVE_WINDOW_IN_USE_KHR
VK_ERROR_OUT_OF_DATE_KHR
VK_ERROR_INCOMPATIBLE_DISPLAY_KHR

Devices and Queues [4]
Physical Devices [4.1]

VkResult vkEnumeratePhysicalDevices(
VkInstance instance,
uint32_t* pPhysicalDeviceCount,
VkPhysicalDevice* pPhysicalDevices);
void vkGetPhysicalDeviceProperties(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceProperties* pProperties); P.14
void vkGetPhysicalDeviceProperties2(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceProperties2* pProperties);
typedef struct VkPhysicalDeviceProperties2 {
VkStructureType sType;
void* pNext;
VkPhysicalDeviceProperties properties; P.14
} VkPhysicalDeviceProperties2;
pNext may point to structs:
VkPhysicalDeviceIDProperties P.14
VkPhysicalDeviceMaintenance3Properties P.14
VkPhysicalDeviceMultiviewProperties P.14
VkPhysicalDevicePointClippingProperties P.14
VkPhysicalDeviceProtectedMemoryProperties P.15
VkPhysicalDeviceSubgroupProperties P.15

void vkGetPhysicalDeviceQueueFamilyProperties(
VkPhysicalDevice physicalDevice,
uint32_t* pQueueFamilyPropertyCount,
VkQueueFamilyProperties*
pQueueFamilyProperties);
void vkGetPhysicalDeviceQueueFamilyProperties2(
VkPhysicalDevice physicalDevice,
uint32_t* pQueueFamilyPropertyCount,
VkQueueFamilyProperties2*pQueueFamilyProperties);
typedef struct VkQueueFamilyProperties {
VkQueueFlags queueFlags;
uint32_t queueCount;
uint32_t timestampValidBits;
VkExtent3D minImageTransferGranularity; P.12
} VkQueueFamilyProperties;
queueFlags:
VK_QUEUE_X_BIT where X is GRAPHICS, COMPUTE,
TRANSFER, PROTECTED, SPARSE_BINDING

typedef struct VkQueueFamilyProperties2 {
VkStructureType sType;
void* pNext; VkQueueFamilyProperties
queueFamilyProperties;
} VkQueueFamilyProperties2;
©2018 Khronos Group - Rev. 0318

Color coded names as follows: function names and structure names
[n.n.n] Indicates sections and text in the Vulkan API 1.1 Specification.
P.# Indicates a page in this reference guide for more information.
= 0 Indicates reserved for future use.

Command Function Pointers and Instances [3]
Command Function Pointers [3.1]

PFN_vkVoidFunction vkGetInstanceProcAddr(
VkInstance instance, const char *pName);
PFN_vkVoidFunction vkGetDeviceProcAddr(
VkDevice device, const char *pName);
PFN_vkVoidFunction is:
typedef void(VKAPI_PTR *PFN_vkVoidFunction)(void);

Instances [3.2]

VkResult vkEnumerateInstanceVersion(
uint32_t* pApiVersion);
VkResult vkCreateInstance(
const VkInstanceCreateInfo* pCreateInfo,
const VkAllocationCallbacks *pAllocator, P.12
VkInstance *pInstance);
typedef struct VkInstanceCreateInfo {
VkStructureType sType;
const void *pNext;
VkInstanceCreateFlags flags; = 0
const VkApplicationInfo* pApplicationInfo;
uint32_t enabledLayerCount;
const char* const* ppEnabledLayerNames;
uint32_t enabledExtensionCount;

Devices [4.2]

VkResult vkEnumeratePhysicalDeviceGroups(
VkInstance instance,
uint32_t* pPhysicalDeviceGroupCount,
VkPhysicalDeviceGroupProperties*
pPhysicalDeviceGroupProperties);
typedef struct VkPhysicalDeviceGroupProperties {
VkStructureType sType;
void* pNext;
uint32_t physicalDeviceCount;
VkPhysicalDevice physicalDevices[
VK_MAX_DEVICE_GROUP_SIZE];
VkBool32 subsetAllocation;
} VkPhysicalDeviceGroupProperties;

Device Creation [4.2.1]

VkResult vkCreateDevice(
VkPhysicalDevice physicalDevice,
const VkDeviceCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator, P.12
VkDevice* pDevice);
typedef struct VkDeviceCreateInfo {
VkStructureType sType;
const void* pNext;
VkDeviceCreateFlags flags; = 0
uint32_t queueCreateInfoCount;
const VkDeviceQueueCreateInfo* pQueueCreateInfos;
uint32_t enabledLayerCount;
const char* const* ppEnabledLayerNames;
uint32_t enabledExtensionCount;
const char* const* ppEnabledExtensionNames;
const VkPhysicalDeviceFeatures* pEnabledFeatures; P.14
} VkDeviceCreateInfo;
pNext may point to structs:
VkDeviceGroupDeviceCreateInfo P.12
VkPhysicalDevice16BitStorageFeatures P.14
VkPhysicalDeviceFeatures2 P.14
VkPhysicalDeviceMultiviewFeatures P.14
VkPhysicalDeviceProtectedMemoryFeatures P.15
VkPhysicalDeviceSamplerYcbcrConversionFeatures P.15
VkPhysicalDeviceVariablePointerFeatures P.15

typedef struct VkDeviceGroupDeviceCreateInfo {
VkStructureType sType;
const void* pNext;
uint32_t physicalDeviceCount;
const VkPhysicalDevice* pPhysicalDevices;
} VkDeviceGroupDeviceCreateInfo;

Device Destruction [4.2.4]

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

const char* const* ppEnabledExtensionNames;
} VkInstanceCreateInfo;
typedef struct VkApplicationInfo {
VkStructureType sType;
const void *pNext;
const char* pApplicationName;
uint32_t applicationVersion;
const char* pEngineName;
uint32_t engineVersion;
uint32_t apiVersion;
} VkApplicationInfo;
void vkDestroyInstance(
VkInstance instance,
const VkAllocationCallbacks *pAllocator); P.12

Queues [4.3]

typedef struct VkDeviceQueueCreateInfo {
VkStructureType sType;
const void* pNext;
VkDeviceQueueCreateFlags flags;
uint32_t queueFamilyIndex;
uint32_t queueCount;
const float* pQueuePriorities;
} VkDeviceQueueCreateInfo;
flags: VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT

void vkGetDeviceQueue(VkDevice device,
uint32_t queueFamilyIndex, uint32_t queueIndex,
VkQueue* pQueue);
void vkGetDeviceQueue2(VkDevice device,
const VkDeviceQueueInfo2* pQueueInfo,
VkQueue* pQueue);
typedef struct VkDeviceQueueInfo2 {
VkStructureType sType; const void* pNext;
VkDeviceQueueCreateFlags flags;
uint32_t queueFamilyIndex; uint32_t queueIndex;
} VkDeviceQueueInfo2;
flags: VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT

Command Buffers [5]

Also see Command Buffer Lifecycle diagram. P.11

Command Pools [5.2]

VkResult vkCreateCommandPool(
VkDevice device,
const VkCommandPoolCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator, P.12
VkCommandPool* pCommandPool);
typedef struct VkCommandPoolCreateInfo {
VkStructureType sType;
const void* pNext;
VkCommandPoolCreateFlags flags;
uint32_t queueFamilyIndex;
} VkCommandPoolCreateInfo;
flags: VK_COMMAND_POOL_CREATE_X_BIT where X is
PROTECTED, RESET_COMMAND_BUFFER, TRANSIENT

void vkTrimCommandPool(VkDevice device,
VkCommandPool commandPool,
VkCommandPoolTrimFlags flags); = 0
VkResult vkResetCommandPool(
VkDevice device, VkCommandPool commandPool,
VkCommandPoolResetFlags flags);
flags: VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT

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

Continued on next page >
www.khronos.org/vulkan

Vulkan 1.1 Quick Reference
Command Buffers (continued)
Command Buffer Lifetime [5.3]

VkResult vkAllocateCommandBuffers(
VkDevice device,
const VkCommandBufferAllocateInfo* pAllocateInfo,
VkCommandBuffer* pCommandBuffers);
typedef struct VkCommandBufferAllocateInfo{
VkStructureType sType;
const void* pNext;
VkCommandPool commandPool;
VkCommandBufferLevel level;
uint32_t commandBufferCount;
} VkCommandBufferAllocateInfo;
level:
VK_COMMAND_BUFFER_LEVEL_{PRIMARY, SECONDARY}

VkResult vkResetCommandBuffer(
VkCommandBuffer commandBuffer,
VkCommandBufferResetFlags flags);
flags:
VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT

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

Command Buffer Recording [5.4]

VkResult vkBeginCommandBuffer(
VkCommandBuffer commandBuffer,
const VkCommandBufferBeginInfo* pBeginInfo);
typedef struct VkCommandBufferBeginInfo{
VkStructureType sType;
const void* pNext;
VkCommandBufferUsageFlags flags;
const VkCommandBufferInheritanceInfo* pInheritanceInfo;
} VkCommandBufferBeginInfo;
flags: VK_COMMAND_BUFFER_USAGE_X _BIT where X is
ONE_TIME_SUBMIT, RENDER_PASS_CONTINUE,
SIMULTANEOUS_USE
pNext may point to struct:
VkDeviceGroupCommandBufferBeginInfo P.12

Synchronization and Cache Control [6]
Fences [6.3]

Fence status is always either signaled or unsignaled.

VkResult vkCreateFence(
VkDevice device, const VkFenceCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator, P.12
VkFence* pFence);
typedef struct VkFenceCreateInfo {
VkStructureType sType;
const void* pNext;
VkFenceCreateFlags flags;
} VkFenceCreateInfo;
flags: VK_FENCE_CREATE_SIGNALED_BIT
pNext may point to struct:
VkExportFenceCreateInfo P.12

void vkDestroyFence(
VkDevice device, VkFence fence,
const VkAllocationCallbacks* pAllocator); P.12
VkResult vkGetFenceStatus(
VkDevice device, VkFence fence);
VkResult vkResetFences(VkDevice device,
uint32_t fenceCount, const VkFence* pFences);
VkResult vkWaitForFences(VkDevice device,
uint32_t fenceCount, const VkFence* pFences,
VkBool32 waitAll, uint64_t timeout);

Semaphores [6.4]

Semaphore status is always either signaled or unsignaled.

VkResult vkCreateSemaphore(
VkDevice device,
const VkSemaphoreCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator, P.12
VkSemaphore* pSemaphore);
typedef struct VkSemaphoreCreateInfo {
VkStructureType sType; const void* pNext;
VkSemaphoreCreateFlags flags; = 0
} VkSemaphoreCreateInfo;
pNext may point to struct:
VkExportSemaphoreCreateInfo P.12

©2018 Khronos Group - Rev. 0318

Page 2
typedef struct VkCommandBufferInheritanceInfo {
VkStructureType sType;
const void* pNext;
VkRenderPass renderPass;
uint32_t subpass;
VkFramebuffer framebuffer;
VkBool32 occlusionQueryEnable;
VkQueryControlFlags queryFlags;
VkQueryPipelineStatisticFlags pipelineStatistics; P.15
} VkCommandBufferInheritanceInfo;

Notes

queryFlags: VK_QUERY_CONTROL_PRECISE_BIT

VkResult vkEndCommandBuffer(
VkCommandBuffer commandBuffer);

Command Buffer Submission [5.5]

VkResult vkQueueSubmit(
VkQueue queue, uint32_t submitCount,
const VkSubmitInfo* pSubmits, VkFence fence);

typedef struct VkSubmitInfo{
VkStructureType sType;
const void* pNext;
uint32_t waitSemaphoreCount;
const VkSemaphore* pWaitSemaphores;
const VkPipelineStageFlags* pWaitDstStageMask; P.15
uint32_t commandBufferCount;
const VkCommandBuffer* pCommandBuffers;
uint32_t signalSemaphoreCount;
const VkSemaphore* pSignalSemaphores;
} VkSubmitInfo;
pNext may point to structs:
VkDeviceGroupSubmitInfo P.12
VkProtectedSubmitInfo P.15

Secondary Command Buffer Execution [5.7]
void vkCmdExecuteCommands(
VkCommandBuffer commandBuffer,
uint32_t commandBufferCount,
const VkCommandBuffer* pCommandBuffers);

Command Buffer Device Mask [5.8]
void vkCmdSetDeviceMask(
VkCommandBuffer commandBuffer,
uint32_t deviceMask);

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

Events [6.5]

Events represent a fine-grained synchronization primitive
that can be used to gauge progress through a sequence of
commands executed on a queue.

VkResult vkCreateEvent(
VkDevice device, const VkEventCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator, P.12
VkEvent* pEvent);
typedef struct VkEventCreateInfo {
VkStructureType sType;
const void* pNext;
VkEventCreateFlags flags; = 0
} VkEventCreateInfo;
void vkDestroyEvent(VkDevice device, VkEvent event,
const VkAllocationCallbacks* pAllocator); P.12
VkResult vkGetEventStatus(
VkDevice device, VkEvent event);
VkResult vk[Set, Reset]Event(
VkDevice device, VkEvent event);
VkResult vkCmd[Set, Reset]Event(
VkCommandBuffer commandBuffer, VkEvent event,
VkPipelineStageFlags stageMask); P.15

Pipeline Barriers [6.6]

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

Wait Idle Operations [6.8]

void vkCmdPipelineBarrier(
VkCommandBuffer commandBuffer,
VkPipelineStageFlags srcStageMask, P.15
VkPipelineStageFlags dstStageMask, P.15
VkDependencyFlags dependencyFlags, P.1512
uint32_t memoryBarrierCount,
const VkMemoryBarrier* pMemoryBarriers, P.13
uint32_t bufferMemoryBarrierCount,
const VkBufferMemoryBarrier*
pBufferMemoryBarriers, P.12
uint32_t imageMemoryBarrierCount,
const VkImageMemoryBarrier*
pImageMemoryBarriers); P.13
VkResult vkQueueWaitIdle(VkQueue queue);
VkResult vkDeviceWaitIdle(VkDevice device);

www.khronos.org/vulkan

Vulkan 1.1 Quick Reference
Render Pass [7]

A render pass represents a collection of attachments,
subpasses, and dependencies between the subpasses, and
describes how the attachments are used over the course of
the subpasses.

Render Pass Creation [7.1]

VkResult vkCreateRenderPass(VkDevice device,
const VkRenderPassCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator, P.12
VkRenderPass* pRenderPass);
typedef struct VkRenderPassCreateInfo {
VkStructureType sType;
const void* pNext;
VkRenderPassCreateFlags flags; = 0
uint32_t attachmentCount;
const VkAttachmentDescription* pAttachments;
uint32_t subpassCount;
const VkSubpassDescription* pSubpasses;
uint32_t dependencyCount;
const VkSubpassDependency* pDependencies;
} VkRenderPassCreateInfo;
pNext may point to structs:
VkRenderPassInputAttachmentAspectCreateInfo P.1315
VkRenderPassMultiviewCreateInfo P.1315

typedef struct VkAttachmentDescription {
VkAttachmentDescriptionFlags flags;
VkFormat format; P.13
VkSampleCountFlagBits samples; P.15
VkAttachmentLoadOp loadOp;
VkAttachmentStoreOp storeOp;
VkAttachmentLoadOp stencilLoadOp;
VkAttachmentStoreOp stencilStoreOp;
VkImageLayout initialLayout; P.13
VkImageLayout finalLayout; P.13
} VkAttachmentDescription;
flags: VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT
loadOp, stencilLoadOp: VK_ATTACHMENT_LOAD_OP_X
where X is LOAD, CLEAR, DONT_CARE
storeOp, stencilStoreOp: VK_ATTACHMENT_STORE_OP_X
where X is STORE, DONT_CARE

typedef struct VkSubpassDescription {
VkSubpassDescriptionFlags flags;
VkPipelineBindPoint pipelineBindPoint; P.1315
uint32_t inputAttachmentCount;
const VkAttachmentReference* pInputAttachments;
uint32_t colorAttachmentCount;
const VkAttachmentReference* pColorAttachments;
const VkAttachmentReference*
pResolveAttachments;
const VkAttachmentReference*
pDepthStencilAttachment;
uint32_t preserveAttachmentCount;
const uint32_t* pPreserveAttachments;
} VkSubpassDescription;
typedef struct VkAttachmentReference {
uint32_t attachment;
VkImageLayout layout; P.13
} VkAttachmentReference;

Page 3
typedef struct VkSubpassDependency {
uint32_t srcSubpass;
uint32_t dstSubpass;
VkPipelineStageFlags srcStageMask; P.15
VkPipelineStageFlags dstStageMask; P.12
VkAccessFlags srcAccessMask; P.12
VkAccessFlags dstAccessMask; P.12
VkDependencyFlags dependencyFlags; P.1512
} VkSubpassDependency;
void vkDestroyRenderPass(VkDevice device,
VkRenderPass renderPass,
const VkAllocationCallbacks* pAllocator); P.12

Framebuffers [7.3]

VkResult vkCreateFramebuffer(VkDevice device,
const VkFramebufferCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator, P.12
VkFramebuffer* pFramebuffer);
typedef struct VkFramebufferCreateInfo {
VkStructureType sType;
const void* pNext;
VkFramebufferCreateFlags flags; = 0
VkRenderPass renderPass;
uint32_t attachmentCount;
const VkImageView* pAttachments;
uint32_t width;
uint32_t height;
uint32_t layers;
} VkFramebufferCreateInfo;
void vkDestroyFramebuffer(
VkDevice device, VkFramebuffer framebuffer,
const VkAllocationCallbacks* pAllocator); P.12

Render Pass Commands [7.4]

void vkCmdBeginRenderPass(
VkCommandBuffer commandBuffer,
const VkRenderPassBeginInfo* pRenderPassBegin,
VkSubpassContents contents);
contents: VK_SUBPASS_CONTENTS_X where X is INLINE,
SECONDARY_COMMAND_BUFFERS

typedef struct VkRenderPassBeginInfo {
VkStructureType sType;
const void* pNext;
VkRenderPass renderPass;
VkFramebuffer framebuffer;
VkRect2D renderArea; P.15
uint32_t clearValueCount;
const VkClearValue* pClearValues; P.12
} VkRenderPassBeginInfo;
pNext may point to struct:
VkDeviceGroupRenderPassBeginInfo P.12

void vkGetRenderAreaGranularity(
VkDevice device, VkRenderPass renderPass,
VkExtent2D* pGranularity); P.12
void vkCmdNextSubpass(
VkCommandBuffer commandBuffer,
VkSubpassContents contents);
contents: VK_SUBPASS_CONTENTS_X where X is
INLINE, SECONDARY_COMMAND_BUFFERS

void vkCmdEndRenderPass(
VkCommandBuffer commandBuffer);

Pipelines [9]
Compute Pipelines [9.1]

Compute pipelines consist of a single static compute shader
stage and the pipeline layout.

VkResult vkCreateComputePipelines(
VkDevice device, VkPipelineCache pipelineCache,
uint32_t createInfoCount,
const VkComputePipelineCreateInfo* pCreateInfos,
const VkAllocationCallbacks* pAllocator, P.12
VkPipeline* pPipelines);
typedef struct VkComputePipelineCreateInfo {
VkStructureType sType; const void* pNext;
VkPipelineCreateFlags flags; P.15
VkPipelineShaderStageCreateInfo stage; P.15
VkPipelineLayout layout;
VkPipeline basePipelineHandle;
int32_t basePipelineIndex;
} VkComputePipelineCreateInfo;

Graphics Pipelines [9.2]

VkResult vkCreateGraphicsPipelines(
VkDevice device,
VkPipelineCache pipelineCache,
uint32_t createInfoCount,
const VkGraphicsPipelineCreateInfo* pCreateInfos,
const VkAllocationCallbacks* pAllocator, P.12
VkPipeline* pPipelines);
©2018 Khronos Group - Rev. 0318

In VkGraphicsPipelineCreateInfo below, replace X with
VkPipeline and replace Y with StateCreateInfo. For example,
XVertexInputY would be VxPipelineVertexInputStateCreateInfo.

typedef struct VkGraphicsPipelineCreateInfo {
VkStructureType sType;
const void* pNext;
VkPipelineCreateFlags flags; P.15
uint32_t stageCount;
const VkPipelineShaderStageCreateInfo* pStages; P.15
const XVertexInputY* pVertexInputState;
const XInputAssemblyY* pInputAssemblyState;
const XTessellationY* pTessellationState;
const XViewportY* pViewportState;
const XRasterizationY* pRasterizationState;
const XMultisampleY* pMultisampleState;
const XDepthStencilY* pDepthStencilState;
const XColorBlendY* pColorBlendState;
const XDynamicY* pDynamicState;
VkPipelineLayout layout;
VkRenderPass renderPass;
uint32_t subpass;
VkPipeline basePipelineHandle;
int32_t basePipelineIndex;
} VkGraphicsPipelineCreateInfo;

Shaders [8]
Shader Modules [8.1]

VkResult vkCreateShaderModule(
VkDevice device,
const VkShaderModuleCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator, P.12
VkShaderModule* pShaderModule);
typedef struct VkShaderModuleCreateInfo {
VkStructureType sType;
const void* pNext;
VkShaderModuleCreateFlags flags; = 0
size_t codeSize;
const uint32_t* pCode;
} VkShaderModuleCreateInfo;
void vkDestroyShaderModule(
VkDevice device,
VkShaderModule shaderModule,
const VkAllocationCallbacks* pAllocator); P.12

Built-in Variables [14.6]

The built-in variables listed below are accessed in shaders by
declaring the variable using a BuiltIn decoration.
Decoration
Type
BaseInstance
Scalar 32-bit integer
BaseVertex
Scalar 32-bit integer
ClipDistance
Array of 32-bit floats
CullDistance
Array of 32-bit floats
DeviceIndex
Scalar 32-bit integer
DrawIndex
Scalar 32-bit integer
FragCoord
4-component vector of 32-bit floats
FragDepth
Scalar 32-bit float
FrontFacing
Scalar 32-bit integer
GlobalInvocationID
3-component vector of 32-bit ints
HelperInvocation
Scalar 32-bit integer
InvocationID
Scalar 32-bit integer
InstanceIndex
Scalar 32-bit integer
Layer
Scalar 32-bit integer
LocalInvocationID
3-component vector of 32-bit ints
NumSubgroups
Scalar 32-bit integer
NumWorkGroups
3-component vector of 32-bit ints
PatchVertices
Scalar 32-bit integer
PointCoord
2-component vector of 32-bit floats
PointSize
Scalar 32-bit float value
Position
4-component vector of 32-bit floats
PrimitiveID
Scalar 32-bit integer
SampleID
Scalar 32-bit integer
SampleMask
Array of 32-bit integers
SamplePosition
2-component vector of float values
SubgroupId
Scalar 32-bit integer
Subgroup{Eq,Ge,Gt,Le,Lt}Mask 4-component vector of 32-bit ints
SubgroupLocalInvocationId
Scalar 32-bit integer
SubgroupSize
Scalar 32-bit integer
TessCoord
3-component vector of 32-bit floats
TessLevelOuter
Array of size 2 of 32-bit floats
TessLevelInner
Array of size 4 of 32-bit floats
VertexIndex
32-bit integer
ViewIndex
Scalar 32-bit integer
ViewportIndex
32-bit integer
WorkgroupSize
3-component vector of 32-bit ints
WorkgroupID
3-component vector of 32-bit ints

typedef struct VkPipelineVertexInputStateCreateInfo {
VkStructureType sType;
const void* pNext;
VkPipelineVertexInputStateCreateFlags flags; = 0
uint32_t vertexBindingDescriptionCount;
const VkVertexInputBindingDescription*
pVertexBindingDescriptions;
uint32_t vertexAttributeDescriptionCount;
const VkVertexInputAttributeDescription*
pVertexAttributeDescriptions;
} VkPipelineVertexInputStateCreateInfo;
typedef struct VkVertexInputBindingDescription {
uint32_t binding;
uint32_t stride;
VkVertexInputRate inputRate;
} VkVertexInputBindingDescription;
inputRate:
VK_VERTEX_INPUT_RATE_{VERTEX, INSTANCE}

Continued on next page >
www.khronos.org/vulkan

Vulkan 1.1 Quick Reference
Pipelines (continued)
typedef struct VkVertexInputAttributeDescription {
uint32_t location;
uint32_t binding;
VkFormat format; P.13
uint32_t offset;
} VkVertexInputAttributeDescription;
typedef struct VkPipelineInputAssemblyStateCreateInfo {
VkStructureType sType;
const void* pNext;
VkPipelineInputAssemblyStateCreateFlags flags; = 0
VkPrimitiveTopology topology;
VkBool32 primitiveRestartEnable;
} VkPipelineInputAssemblyStateCreateInfo;
topology: VK_PRIMITIVE_TOPOLOGY_X where X is

POINT_LIST, LINE_LIST, LINE_STRIP, TRIANGLE_LIST,
TRIANGLE_STRIP, TRIANGLE_FAN,
LINE_{LIST, STRIP}_WITH_ADJACENCY,
TRIANGLE_{LIST, STRIP}_WITH_ADJACENCY, PATCH_LIST

typedef struct VkPipelineTessellationStateCreateInfo {
VkStructureType sType;
const void* pNext;
VkPipelineTessellationStateCreateFlags flags; = 0
uint32_t patchControlPoints;
} VkPipelineTessellationStateCreateInfo;
pNext may point to structs:
VkPipelineTessellationDomainOriginStateCreateInfo P.15

typedef struct VkPipelineViewportStateCreateInfo {
VkStructureType sType;
const void* pNext;
VkPipelineViewportStateCreateFlags flags; = 0
uint32_t viewportCount;
const VkViewport* pViewports; P.15
uint32_t scissorCount;
const VkRect2D* pScissors; P.15
} VkPipelineViewportStateCreateInfo;
typedef struct VkPipelineRasterizationStateCreateInfo {
VkStructureType sType;
const void* pNext;
VkPipelineRasterizationStateCreateFlags flags; = 0
VkBool32 depthClampEnable;
VkBool32 rasterizerDiscardEnable;
VkPolygonMode polygonMode;
VkCullModeFlags cullMode;
VkFrontFace frontFace;
VkBool32 depthBiasEnable;
float depthBiasConstantFactor;
float depthBiasClamp;
float depthBiasSlopeFactor;
float lineWidth;
} VkPipelineRasterizationStateCreateInfo;
polygonMode: VK_POLYGON_MODE_{FILL, LINE, POINT}
cullMode: VK_CULL_MODE_X where X is NONE, FRONT_BIT,
BACK_BIT, FRONT_AND_BACK
frontFace: VK_FRONT_FACE_[COUNTER_]CLOCKWISE

Memory Allocation [10]
Device Memory [10.2]

Device memory is memory that is visible to the device.

void vkGetPhysicalDeviceMemoryProperties(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceMemoryProperties*
pMemoryProperties); P.14
void vkGetPhysicalDeviceMemoryProperties2(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceMemoryProperties2*
pMemoryProperties);
typedef struct VkPhysicalDeviceMemoryProperties2 {
VkStructureType sType; void* pNext;
VkPhysicalDeviceMemoryProperties
memoryProperties; P.14
} VkPhysicalDeviceMemoryProperties2;
VkResult vkAllocateMemory(
VkDevice device,
const VkMemoryAllocateInfo* pAllocateInfo,
const VkAllocationCallbacks* pAllocator, P.12
VkDeviceMemory* pMemory);
typedef struct VkMemoryAllocateInfo {
VkStructureType sType; const void* pNext;
VkDeviceSize* allocationSize;
uint32_t memoryTypeIndex;
} VkMemoryAllocateInfo;
pNext may point to structs:
VkExportMemoryAllocateInfo P.12
VkMemoryAllocateFlagsInfo P.13
VkMemoryDedicatedAllocateInfo P.13

©2018 Khronos Group - Rev. 0318

Page 4
typedef struct VkPipelineMultisampleStateCreateInfo {
VkStructureType sType;
const void* pNext;
VkPipelineMultisampleStateCreateFlags flags; = 0
VkSampleCountFlagBits rasterizationSamples; P.15
VkBool32 sampleShadingEnable;
float minSampleShading;
const VkSampleMask* pSampleMask;
VkBool32 alphaToCoverageEnable;
VkBool32 alphaToOneEnable;
} VkPipelineMultisampleStateCreateInfo;
typedef struct VkPipelineDepthStencilStateCreateInfo {
VkStructureType sType;
const void* pNext;
VkPipelineDepthStencilStateCreateFlags flags; = 0
VkBool32 depthTestEnable;
VkBool32 depthWriteEnable;
VkCompareOp depthCompareOp; P.12
VkBool32 depthBoundsTestEnable;
VkBool32 stencilTestEnable;
VkStencilOpState front;
VkStencilOpState back;
float minDepthBounds;
float maxDepthBounds;
} VkPipelineDepthStencilStateCreateInfo;
typedef struct VkStencilOpState {
VkStencilOp failOp;
VkStencilOp passOp;
VkStencilOp depthFailOp;
VkCompareOp compareOp; P.12
uint32_t compareMask;
uint32_t writeMask;
uint32_t reference;
} VkStencilOpState;
enum VkStencilOp: VK_STENCIL_OP_X where X is KEEP,
ZERO, REPLACE, INCREMENT_AND_{CLAMP, WRAP},
INVERT, DECREMENT_AND_{CLAMP, WRAP}

typedef struct VkPipelineColorBlendStateCreateInfo {
VkStructureType sType;
const void* pNext;
VkPipelineColorBlendStateCreateFlags flags; = 0
VkBool32 logicOpEnable;
VkLogicOp logicOp;
uint32_t attachmentCount;
const VkPipelineColorBlendAttachmentState*
pAttachments;
float blendConstants[4];
} VkPipelineColorBlendStateCreateInfo;
logicOp: VK_LOGIC_OP_X where X is CLEAR, AND,
AND_REVERSE, COPY, AND_INVERTED, NO_OP, XOR, OR,
NOR, EQUIVALENT, INVERT, OR_REVERSE,
COPY_INVERTED, OR_INVERTED, NAND, SET
blendOp: VK_BLEND_OP_X where X is ADD, SUBTRACT,
REVERSE_SUBTRACT, MIN, MAX
colorWriteMask: VK_COLOR_COMPONENT_X where X is
R_BIT, G_BIT, B_BIT, A_BIT

void vkFreeMemory(
VkDevice device,
VkDeviceMemory memory,
const VkAllocationCallbacks* pAllocator); P.12
Host Access to Device Memory Objects [10.2.1]
Memory objects created with vkAllocateMemory are not
directly host accessible. Memory objects created with memory
property VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT are
considered mappable. Memory objects must be mappable in
order to be successfully mapped on the host.

VkResult vkMapMemory(
VkDevice device,
VkDeviceMemory memory,
VkDeviceSize offset,
VkDeviceSize size,
VkMemoryMapFlags flags, = 0
void** ppData);
VkResult vkFlushMappedMemoryRanges(
VkDevice device,
uint32_t memoryRangeCount,
const VkMappedMemoryRange* pMemoryRanges);
VkResult vkInvalidateMappedMemoryRanges(
VkDevice device,
uint32_t memoryRangeCount,
const VkMappedMemoryRange* pMemoryRanges);
typedef struct VkMappedMemoryRange {
VkStructureType sType; const void* pNext;
VkDeviceMemory memory;
VkDeviceSize offset;
VkDeviceSize size;
} VkMappedMemoryRange;

typedef struct VkPipelineColorBlendAttachmentState {
VkBool32 blendEnable;
VkBlendFactor srcColorBlendFactor;
VkBlendFactor dstColorBlendFactor;
VkBlendOp colorBlendOp; P.12
VkBlendFactor srcAlphaBlendFactor;
VkBlendFactor dstAlphaBlendFactor;
VkBlendOp alphaBlendOp; P.12
VkColorComponentFlags colorWriteMask;
} VkPipelineColorBlendAttachmentState;
enum VkBlendFactor: VK_BLEND_FACTOR_X where X is

ZERO, ONE, SRC_ALPHA_SATURATE,
[ONE_MINUS_]SRC_COLOR, [ONE_MINUS_]DST_COLOR,
[ONE_MINUS_]SRC_ALPHA, [ONE_MINUS_]DST_ALPHA,
[ONE_MINUS_]CONSTANT_COLOR,
[ONE_MINUS_]CONSTANT_ALPHA,
[ONE_MINUS_]SRC1_COLOR,
[ONE_MINUS_]SRC1_ALPHA
colorWriteMask:
VK_COLOR_COMPONENT_X_BIT where X is R, G, B, A

typedef struct VkPipelineDynamicStateCreateInfo {
VkStructureType sType;
const void* pNext;
VkPipelineDynamicStateCreateFlags flags; = 0
uint32_t dynamicStateCount;
const VkDynamicState* pDynamicStates;
} VkPipelineDynamicStateCreateInfo;
pDynamicStates: Array of VK_DYNAMIC_STATE_X
where X is VIEWPORT, SCISSOR,
LINE_WIDTH, DEPTH_BIAS, BLEND_CONSTANTS,
DEPTH_BOUNDS, STENCIL_REFERENCE,
STENCIL_COMPARE_MASK, STENCIL_WRITE_MASK

Pipeline Destruction [9.3]

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

Pipeline Cache [9.6]

Pipeline cache objects allow the result of pipeline construction
to be reused between pipelines and between runs of an
application.

VkResult vkCreatePipelineCache(VkDevice device,
const VkPipelineCacheCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator, P.12
VkPipelineCache* pPipelineCache);
typedef struct VkPipelineCacheCreateInfo {
VkStructureType sType;
const void* pNext;
VkPipelineCacheCreateFlags flags; = 0
size_t initialDataSize;
const void* pInitialData;
} VkPipelineCacheCreateInfo;
VkResult vkMergePipelineCaches(VkDevice device,
VkPipelineCache dstCache, uint32_t srcCacheCount,
const VkPipelineCache* pSrcCaches);
VkResult vkGetPipelineCacheData(VkDevice device,
VkPipelineCache pipelineCache,
size_t* pDataSize, void* pData);
void vkDestroyPipelineCache(VkDevice device,
VkPipelineCache pipelineCache,
const VkAllocationCallbacks* pAllocator); P.12

Pipeline Binding [9.8]

void vkCmdBindPipeline(
VkCommandBuffer commandBuffer,
VkPipelineBindPoint pipelineBindPoint, P.1315
VkPipeline pipeline);
void vkUnmapMemory(
VkDevice device,
VkDeviceMemory memory);
Lazily Allocated Memory [10.2.2]
If the memory object is allocated from a heap with the
VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT bit set,
that object’s backing memory may be provided by the
implementation lazily.

void vkGetDeviceMemoryCommitment(
VkDevice device,
VkDeviceMemory memory,
VkDeviceSize* pCommittedMemoryInBytes);
Peer Memory Features [10.2.4]

void vkGetDeviceGroupPeerMemoryFeatures(
VkDevice device, uint32_t heapIndex,
uint32_t localDeviceIndex, uint32_t remoteDeviceIndex,
VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);
pPeerMemoryFeatures: VK_PEER_MEMORY_FEATURE_X
where X is COPY_SRC_BIT, COPY_DST_BIT,
GENERIC_SRC_BIT, GENERIC_DST_BIT

www.khronos.org/vulkan

Vulkan 1.1 Quick Reference

Page 5

Vulkan Pipeline Diagram [9]

Some Vulkan commands specify geometric
objects to be drawn or computational work to be
performed, while others specify state controlling
how objects are handled by the various pipeline
stages, or control data transfer between memory
organized as images and buffers. Commands are
effectively sent through a processing pipeline,
either a graphics pipeline or a compute pipeline.
The heavy black arrows in this illustration show
the Vulkan graphics and compute pipelines and
indicate data flow
Fixed function stage
Programmable stage
Buffer
Image
Constants

Resource Creation [11]
Buffers [11.1]

Buffer Views [11.2]

A buffer view represents a contiguous range of a buffer and a
specific format to be used to interpret the data.

Buffers represent linear arrays of data which are used for various
purposes by binding them to a graphics or compute pipeline via VkResult vkCreateBufferView(
VkDevice device,
descriptor sets or via certain commands, or by directly specifying
const VkBufferViewCreateInfo* pCreateInfo,
them as parameters to certain commands.

VkResult vkCreateBuffer(
VkDevice device,
const VkBufferCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator, P.12
VkBuffer* pBuffer);
typedef struct VkBufferCreateInfo {
VkStructureType sType;
const void* pNext;
VkBufferCreateFlags flags;
VkDeviceSize size;
VkBufferUsageFlags usage; P.12
VkSharingMode sharingMode; P.15
uint32_t queueFamilyIndexCount;
const uint32_t* pQueueFamilyIndices;
} VkBufferCreateInfo;
flags:

VK_BUFFER_CREATE_SPARSE_X_BIT where X is
ALIASED, BINDING, PROTECTED, RESIDENCY

pNext may point to struct:
VkExternalMemoryBufferCreateInfo P.12

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

const VkAllocationCallbacks* pAllocator, P.12
VkBufferView* pView);

typedef struct VkBufferViewCreateInfo {
VkStructureType sType;
const void* pNext;
VkBufferViewCreateFlags flags; = 0
VkBuffer buffer;
VkFormat format; P.13
VkDeviceSize offset;
VkDeviceSize range;
} VkBufferViewCreateInfo;
void vkDestroyBufferView(
VkDevice device,
VkBufferView bufferView,
const VkAllocationCallbacks* pAllocator); P.12

Images [11.3]

typedef struct VkImageCreateInfo {
VkStructureType sType;
const void* pNext;
VkImageCreateFlags flags; P.13
VkImageType imageType; P.13
VkFormat format; P.13
VkExtent3D extent; PP.12
uint32_t mipLevels;
uint32_t arrayLayers;
VkSampleCountFlagBits samples; P.15
VkImageTiling tiling; P.13
VkImageUsageFlags usage; P.13
VkSharingMode sharingMode; P.15
uint32_t queueFamilyIndexCount;
const uint32_t* pQueueFamilyIndices;
VkImageLayout initialLayout; P.13
} VkImageCreateInfo;
pNext may point to struct:
VkExternalMemoryImageCreateInfo P.P.13

typedef struct VkImageSwapchainCreateInfoKHR {
VkStructureType sType;
const void* pNext;
VkSwapchainKHR swapchain;
} VkImageSwapchainCreateInfoKHR;

Images represent multidimensional (up to 3) arrays of data which
can be used for various purposes by binding them to the graphics void vkGetImageSubresourceLayout(
VkDevice device,
or compute pipeline via descriptor sets, or by directly specifying
VkImage image,
them as parameters to certain commands.

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

const VkImageSubresource* pSubresource,
VkSubresourceLayout* pLayout);

typedef struct VkImageSubresource {
VkImageAspectFlags aspectMask; P.13
uint32_t mipLevel;
uint32_t arrayLayer;
} VkImageSubresource;

Continued on next page >
©2018 Khronos Group - Rev. 0318

www.khronos.org/vulkan

Vulkan 1.1 Quick Reference
Resource Creation (continued)
typedef struct VkSubresourceLayout {
VkDeviceSize offset;
VkDeviceSize size;
VkDeviceSize rowPitch;
VkDeviceSize arrayPitch;
VkDeviceSize depthPitch;
} VkSubresourceLayout;
void vkDestroyImage(
VkDevice device, VkImage image,
const VkAllocationCallbacks* pAllocator); P.12

Image Views [11.5]

Page 6
typedef struct VkComponentMapping {
VkComponentSwizzle r;
VkComponentSwizzle g;
VkComponentSwizzle b;
VkComponentSwizzle a;
} VkComponentMapping;
enum VkComponentSwizzle: VK_COMPONENT_SWIZZLE_X
where X is IDENTITY, ZERO, ONE, R, G, B, A

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

Resource Memory Association [11.6]

Resources are initially created as virtual allocations with no
Image objects are not directly accessed by pipeline shaders for
backing memory. Device memory is allocated separately and
reading or writing image data. Instead, image views representing then associated with the resource.
contiguous ranges of the image subresources and containing
void vkGetBufferMemoryRequirements(
additional metadata are used for that purpose.

VkResult vkCreateImageView(
VkDevice device,
const VkImageViewCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator, P.12
VkImageView* pView);
typedef struct VkImageViewCreateInfo {
VkStructureType sType; const void* pNext;
VkImageViewCreateFlags flags; = 0
VkImage image;
VkImageViewType viewType;
VkFormat format; P.13
VkComponentMapping components;
VkImageSubresourceRange subresourceRange; P.13
} VkImageViewCreateInfo;
viewType: VK_IMAGE_VIEW_TYPE_X where X is 1D, 2D, 3D,
CUBE, 1D_ARRAY, 2D_ARRAY, CUBE_ARRAY
pNext may point to structs:
VkImageViewUsageCreateInfo P.13
VkSamplerYcbcrConversionInfo P.15

Samplers [12]

VkSampler objects encapsulate the state of an image sampler
which is used by the implementation to read image data and
apply filtering and other transformations for the shader.

VkResult vkCreateSampler(
VkDevice device,
const VkSamplerCreateInfo* pCreateInfo,
const VkAllocationCallbacks *pAllocator, P.12
VkSampler *pSampler);
typedef struct VkSamplerCreateInfo {
VkStructureType sType; const void *pNext;
VkSamplerCreateFlags flags; = 0
VkFilter magFilter; VkFilter minFilter;
VkSamplerMipmapMode mipmapMode;
VkSamplerAddressMode addressModeU;
VkSamplerAddressMode addressModeV;
VkSamplerAddressMode addressModeW;
float mipLodBias;
VkBool32 anisotropyEnable;
float maxAnisotropy;
VkBool32 compareEnable;
VkCompareOp compareOp; P.12
float minLod; float maxLod;
VkBorderColor borderColor;
VkBool32 unnormalizedCoordinates;
} VkSamplerCreateInfo;

VkDevice device,
VkBuffer buffer,
VkMemoryRequirements* pMemoryRequirements); P.13

typedef struct VkImageMemoryRequirementsInfo2 {
VkStructureType sType; const void* pNext;
VkImage image;
} VkImageMemoryRequirementsInfo2;
pNext may point to struct:
VkImagePlaneMemoryRequirementsInfo P.13

VkResult vkBindBufferMemory(VkDevice device,
VkBuffer buffer, VkDeviceMemory memory,
VkDeviceSize memoryOffset);
VkResult vkBindBufferMemory2(VkDevice device,
uint32_t bindInfoCount,
const VkBindBufferMemoryInfo* pBindInfos);
typedef struct VkBindBufferMemoryInfo {
VkStructureType sType;
const void* pNext;
VkBuffer buffer;
VkDeviceMemory memory;
VkDeviceSize memoryOffset;
} VkBindBufferMemoryInfo;
pNext may point to struct:

void vkGetBufferMemoryRequirements2(VkDevice device,
VkBindBufferMemoryDeviceGroupInfo P.12
const VkBufferMemoryRequirementsInfo2* pInfo,
VkResult
vkBindImageMemory(VkDevice device,
VkMemoryRequirements2* pMemoryRequirements); P.13
VkImage image, VkDeviceMemory memory,
typedef struct VkBufferMemoryRequirementsInfo2 {
VkDeviceSize memoryOffset);
VkStructureType sType;
VkResult
vkBindImageMemory2(VkDevice device,
const void* pNext;
uint32_t bindInfoCount,
VkBuffer buffer;
const VkBindImageMemoryInfo* pBindInfos);
} VkBufferMemoryRequirementsInfo2;
typedef struct VkBindImageMemoryInfo {
VkStructureType sType;
const void* pNext;
VkImage image;
void vkGetImageMemoryRequirements2(VkDevice device,
VkDeviceMemory memory;
const VkImageMemoryRequirementsInfo2* pInfo,
VkDeviceSize memoryOffset;
VkMemoryRequirements2* pMemoryRequirements); P.13 } VkBindImageMemoryInfo;
void vkGetImageMemoryRequirements(
VkDevice device, VkImage image,
VkMemoryRequirements* pMemoryRequirements); P.13

pNext may point to structs:
VkBindImageMemoryDeviceGroupInfo P.12
VkBindImagePlaneMemoryInfo P.12

magFilter, minFilter: VK_FILTER_NEAREST,
VK_FILTER_LINEAR
mipmapMode:
VK_SAMPLER_MIPMAP_MODE_{NEAREST, LINEAR}
borderColor: VK_BORDER_COLOR_{FLOAT, INT}_X
where X is TRANSPARENT_BLACK, OPAQUE_BLACK,
OPAQUE_WHITE
addressMode{U, V, W}:
VK_SAMPLER_ADDRESS_MODE_X where X is REPEAT,
MIRRORED_REPEAT, MIRROR_CLAMP_TO_EDGE,
CLAMP_TO_EDGE, CLAMP_TO_BORDER
pNext may point to structs:
VkSamplerYcbcrConversionInfo P.15

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

Sampler Y’CBCR Conversion [12.1]

typedef struct VkSamplerYcbcrConversionCreateInfo {
VkStructureType sType;
const void* pNext;
VkFormat format; P.13
VkSamplerYcbcrModelConversion ycbcrModel;
VkSamplerYcbcrRange ycbcrRange;
VkComponentMapping components;
VkChromaLocation xChromaOffset;
VkChromaLocation yChromaOffset;
VkFilter chromaFilter;
VkBool32 forceExplicitReconstruction;
} VkSamplerYcbcrConversionCreateInfo;
VkSamplerYcbcrModelConversion:
VK_SAMPLER_YCBCR_MODEL_CONVERSION_X where X
is {RGB, YCBCR}_IDENTITY, YCBCR_{709, 601, 2020}
VkSamplerYcbcrRange:
VK_SAMPLER_YCBCR_RANGE_ITU_{FULL, NARROW}
VkChromaLocation:
VK_CHROMA_LOCATION_{COSITED_EVEN, MIDPOINT}
VkFilter:
VK_FILTER_{NEAREST, LINEAR}

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

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

Resource Descriptors [13]

A descriptor is an opaque data structure representing a
shader resource such as a buffer view, image view, sampler, or
combined image sampler.

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

Descriptor Set Layout [13.2.1]

Pipeline Layouts [13.2.2]

typedef struct VkPushConstantRange {
VkShaderStageFlags stageFlags; P.15
uint32_t offset;
uint32_t size;
} VkPushConstantRange;

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

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

void vkGetDescriptorSetLayoutSupport(
VkDevice device,
const VkDescriptorSetLayoutCreateInfo* pCreateInfo, P.1512
VkDescriptorSetLayoutSupport* pSupport);

typedef struct VkPipelineLayoutCreateInfo {
VkStructureType sType;
const void* pNext;
VkPipelineLayoutCreateFlags flags; = 0
uint32_t setLayoutCount;
const VkDescriptorSetLayout* pSetLayouts;
uint32_t pushConstantRangeCount;
const VkPushConstantRange* pPushConstantRanges;
} VkPipelineLayoutCreateInfo;

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

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

typedef struct VkDescriptorSetLayoutSupport {
VkStructureType sType; void* pNext;
VkBool32 supported;
} VkDescriptorSetLayoutSupport;
©2018 Khronos Group - Rev. 0318

Allocation of Descriptor Sets [13.2.3]

Continued on next page >
www.khronos.org/vulkan

Vulkan 1.1 Quick Reference
Resource Descriptors (continued)
typedef struct VkDescriptorPoolCreateInfo {
VkStructureType sType;
const void* pNext;
VkDescriptorPoolCreateFlags flags;
uint32_t maxSets;
uint32_t poolSizeCount;
const VkDescriptorPoolSize* pPoolSizes;
} VkDescriptorPoolCreateInfo;
flags: VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT

typedef struct VkDescriptorPoolSize {
VkDescriptorType type; P.12
uint32_t descriptorCount;
} VkDescriptorPoolSize;
void vkDestroyDescriptorPool(
VkDevice device,
VkDescriptorPool descriptorPool,
const VkAllocationCallbacks* pAllocator); P.12
VkResult vkAllocateDescriptorSets(
VkDevice device,
const VkDescriptorSetAllocateInfo* pAllocateInfo,
VkDescriptorSet* pDescriptorSets);
typedef struct VkDescriptorSetAllocateInfo {
VkStructureType sType; const void* pNext;
VkDescriptorPool descriptorPool;
uint32_t descriptorSetCount;
const VkDescriptorSetLayout* pSetLayouts;
} VkDescriptorSetAllocateInfo;
VkResult vkFreeDescriptorSets(
VkDevice device,
VkDescriptorPool descriptorPool,
uint32_t descriptorSetCount,
const VkDescriptorSet* pDescriptorSets);
VkResult vkResetDescriptorPool(
VkDevice device,
VkDescriptorPool descriptorPool,
VkDescriptorPoolResetFlags flags);

Descriptor Set Updates [13.2.4]

void vkUpdateDescriptorSets(
VkDevice device,
uint32_t descriptorWriteCount,
const VkWriteDescriptorSet* pDescriptorWrites,
uint32_t descriptorCopyCount,
const VkCopyDescriptorSet* pDescriptorCopies);

Queries [16]
Query Pools [16.1]
VkResult vkCreateQueryPool(
VkDevice device,
const VkQueryPoolCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator, P.12
VkQueryPool* pQueryPool);
typedef struct VkQueryPoolCreateInfo {
VkStructureType sType;
const void* pNext;
VkQueryPoolCreateFlags flags; = 0
VkQueryType queryType;
uint32_t queryCount;
VkQueryPipelineStatisticFlags pipelineStatistics; P.15
} VkQueryPoolCreateInfo;
queryType: VK_QUERY_TYPE_OCCLUSION,
VK_QUERY_TYPE_PIPELINE_STATISTICS,
VK_QUERY_TYPE_TIMESTAMP

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

Query Operation [16.2]

void vkCmdResetQueryPool(
VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
uint32_t firstQuery,
uint32_t queryCount);
void vkCmdBeginQuery(
VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
uint32_t entry,
VkQueryControlFlags flags);
flags: VK_QUERY_CONTROL_PRECISE_BIT

©2018 Khronos Group - Rev. 0318

Page 7
typedef struct VkWriteDescriptorSet {
VkStructureType sType; const void* pNext;
VkDescriptorSet dstSet;
uint32_t dstBinding;
uint32_t dstArrayElement;
uint32_t descriptorCount;
VkDescriptorType descriptorType; P.12
const VkDescriptorImageInfo* pImageInfo;
const VkDescriptorBufferInfo* pBufferInfo;
const VkBufferView* pTexelBufferView;
} VkWriteDescriptorSet;
typedef struct VkDescriptorImageInfo {
VkSampler sampler;
VkImageView imageView;
VkImageLayout imageLayout; P.13
} VkDescriptorImageInfo;
typedef struct VkDescriptorBufferInfo {
VkBuffer buffer;
VkDeviceSize offset;
VkDeviceSize range;
} VkDescriptorBufferInfo;
typedef struct VkCopyDescriptorSet {
VkStructureType sType; const void* pNext;
VkDescriptorSet srcSet;
uint32_t srcBinding;
uint32_t srcArrayElement;
VkDescriptorSet dstSet;
uint32_t dstBinding;
uint32_t dstArrayElement;
uint32_t descriptorCount;
} VkCopyDescriptorSet;

Descriptor Set Updates with Templates [13.2.6]
VkResult vkCreateDescriptorUpdateTemplate(
VkDevice device,
const VkDescriptorUpdateTemplateCreateInfo*
pCreateInfo,
const VkAllocationCallbacks* pAllocator, P.12
VkDescriptorUpdateTemplate*
pDescriptorUpdateTemplate);

typedef struct VkDescriptorUpdateTemplateCreateInfo {
VkStructureType sType;
void* pNext;
VkDescriptorUpdateTemplateCreateFlags flags; = 0
uint32_t descriptorUpdateEntryCount;
const VkDescriptorUpdateTemplateEntry*
pDescriptorUpdateEntries;
VkDescriptorUpdateTemplateType templateType;
VkDescriptorSetLayout descriptorSetLayout;
VkPipelineBindPoint pipelineBindPoint; P.1315
VkPipelineLayout pipelineLayout;
uint32_t set; = 0
} VkDescriptorUpdateTemplateCreateInfo;
void vkCmdEndQuery(
VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
uint32_t query);
VkResult vkGetQueryPoolResults(
VkDevice device,
VkQueryPool queryPool,
uint32_t firstQuery,
uint32_t queryCount,
size_t dataSize,
void* pData,
VkDeviceSize stride,
VkQueryResultFlags flags);
flags: VK_QUERY_RESULT_X_BIT where X is
64, WAIT, WITH_AVAILABILITY, PARTIAL

void vkCmdCopyQueryPoolResults(
VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
uint32_t firstQuery,
uint32_t queryCount,
VkBuffer dstBuffer,
VkDeviceSize dstOffset,
VkDeviceSize stride,
VkQueryResultFlags flags);
flags: VK_QUERY_RESULT_X_BIT where X is
64, WAIT, WITH_AVAILABILITY, PARTIAL

Timestamp Queries [16.5]

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

VKPipelineBindPoint: VK_PIPELINE_BIND_POINT_X
where X is GRAPHICS, COMPUTE
templateType: VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET

typedef struct VkDescriptorUpdateTemplateEntry {
uint32_t dstBinding;
uint32_t dstArrayElement;
uint32_t descriptorCount;
VkDescriptorType descriptorType; P.12
size_t offset;
size_t stride;
} VkDescriptorUpdateTemplateEntry;
void vkDestroyDescriptorUpdateTemplate(
VkDevice device,
VkDescriptorUpdateTemplate
descriptorUpdateTemplate,
const VkAllocationCallbacks* pAllocator); P.12
void vkUpdateDescriptorSetWithTemplate(
VkDevice device,
VkDescriptorSet descriptorSet,
VkDescriptorUpdateTemplate
descriptorUpdateTemplate,
const void* pData);

Descriptor Set Binding [13.2.7]

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

Push Constant Updates [13.2.8]

The pipeline layout defines shader push constants which
are updated via Vulkan commands rather than via writes to
memory or copy commands.

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

Clear Commands [17]
Outside a Render Pass Instance [17.1]

void vkCmdClearColorImage(
VkCommandBuffer commandBuffer,
VkImage image,
VkImageLayout imageLayout, P.P.13
const VkClearColorValue* pColor, P.12
uint32_t rangeCount,
const VkImageSubresourceRange* pRanges); P.13
imageLayout:
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
VK_IMAGE_LAYOUT_GENERAL.
VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR

void vkCmdClearDepthStencilImage(
VkCommandBuffer commandBuffer,
VkImage image,
VkImageLayout imageLayout, P.P.13
const VkClearDepthStencilValue* pDepthStencil, P.12
uint32_t rangeCount,
const VkImageSubresourceRange* pRanges); P.13
imageLayout:
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
VK_IMAGE_LAYOUT_GENERAL

Inside a Render Pass Instance [17.2]

void vkCmdClearAttachments(
VkCommandBuffer commandBuffer,
uint32_t attachmentCount,
const VkClearAttachment* pAttachments,
uint32_t rectCount,
const VkClearRect* pRects);
typedef struct VkClearRect {
VkRect2D rect; P.15
uint32_t baseArrayLayer;
uint32_t layerCount;
} VkClearRect;
typedef struct VkClearAttachment {
VkImageAspectFlags aspectMask; P.13
uint32_t colorAttachment;
VkClearValue clearValue; P.12
} VkClearAttachment;

Continued on next page >
www.khronos.org/vulkan

Vulkan 1.1 Quick Reference

Page 8

Clear Commands (continued)

Copy Commands [18]

Filling Buffers [17.4]

Copying Data Between Buffers [18.2]

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

Updating Buffers [17.5]

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

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

typedef struct VkBufferCopy {
VkDeviceSize srcOffset; VkDeviceSize dstOffset;
VkDeviceSize size;
} VkBufferCopy;

Copying Data Between Images [18.3]

Drawing Commands [19]
void vkCmdBindIndexBuffer(
VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
VkIndexType indexType);
indexType: VK_INDEX_TYPE_UINT{16, 32}

void vkCmdDraw(
VkCommandBuffer commandBuffer,
uint32_t vertexCount,
uint32_t instanceCount,
uint32_t firstVertex,
uint32_t firstInstance);
void vkCmdDrawIndexed(
VkCommandBuffer commandBuffer,
uint32_t indexCount,
uint32_t instanceCount,
uint32_t firstIndex,
int32_t vertexOffset,
uint32_t firstInstance);
void vkCmdDrawIndirect(
VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
uint32_t drawCount,
uint32_t stride);
typedef struct VkDrawIndirectCommand {
uint32_t vertexCount;
uint32_t instanceCount;
uint32_t firstVertex;
uint32_t firstInstance;
} VkDrawIndirectCommand;

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

typedef struct VkImageCopy {
VkImageSubresourceLayers srcSubresource; P.13
VkOffset3D srcOffset; P14
VkImageSubresourceLayers dstSubresource; P.13
VkOffset3D dstOffset; P.13
VkExtent3D extent; P12
} VkImageCopy;

Copying Data Between Buffers and Images [18.4]
void vkCmdCopyBufferToImage(
VkCommandBuffer commandBuffer,
VkBuffer srcBuffer, VkImage dstImage,
VkImageLayout dstImageLayout, P.13
uint32_t regionCount,
const VkBufferImageCopy* pRegions);

Vertex Input Description [20.2]
void vkCmdBindVertexBuffers(
VkCommandBuffer commandBuffer,
uint32_t firstBinding, uint32_t bindingCount,
const VkBuffer* pBuffers,
const VkDeviceSize* pOffsets);

Fragment Operations [25]
Scissor Test [25.2]

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

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

typedef struct VkDrawIndexedIndirectCommand {
uint32_t indexCount; uint32_t instanceCount;
uint32_t firstIndex;
int32_t vertexOffset;
uint32_t firstInstance;
} VkDrawIndexedIndirectCommand;

Depth Bounds Test [25.8]

Fixed-Function Vertex Postprocessing [23]
Controlling the Viewport [23.5]

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

Rasterization [24]
Basic Line Segment Rasterization [24.6]
void vkCmdSetLineWidth(
VkCommandBuffer commandBuffer,
float lineWidth);

Depth Bias [24.7.3]

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

Framebuffer: Blend Factors [26.1.1]
void vkCmdSetBlendConstants(
VkCommandBuffer commandBuffer,
const float blendConstants[4]);
©2018 Khronos Group - Rev. 0318

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

void vkCmdCopyImageToBuffer(
VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout, P.13
VkBuffer dstBuffer,
uint32_t regionCount,
const VkBufferImageCopy* pRegions);
typedef struct VkBufferImageCopy {
VkDeviceSize bufferOffset;
uint32_t bufferRowLength;
uint32_t bufferImageHeight;
VkImageSubresourceLayers imageSubresource; P.13
VkOffset3D imageOffset; P14
VkExtent3D imageExtent; P12
} VkBufferImageCopy;

Image Copies With Scaling [18.5]

void vkCmdBlitImage(
VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout, P.13
VkImage dstImage,
VkImageLayout dstImageLayout, P.13
uint32_t regionCount,
const VkImageBlit* pRegions,
VkFilter filter);
filter: VK_FILTER_NEAREST, VK_FILTER_LINEAR

typedef struct VkImageBlit {
VkImageSubresourceLayers srcSubresource; P.13
VkOffset3D srcOffsets[2]; P14
VkImageSubresourceLayers dstSubresource; P.13
VkOffset3D dstOffsets[2]; P.13
} VkImageBlit;

Resolving Multisample Images [18.6]
void vkCmdResolveImage(
VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout, P.13
VkImage dstImage,
VkImageLayout dstImageLayout, P.13
uint32_t regionCount,
const VkImageResolve* pRegions);

typedef struct VkImageResolve {
VkImageSubresourceLayers srcSubresource; P.13
VkOffset3D srcOffset; P14
VkImageSubresourceLayers dstSubresource; P.13
VkOffset3D dstOffset; P14
VkExtent3D extent; P12
} VkImageResolve;

Dispatching Commands [27]
void vkCmdDispatch(
VkCommandBuffer commandBuffer,
uint32_t groupCountX,
uint32_t groupCountY,
uint32_t groupCountZ);

Stencil Test [25.9]

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

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

typedef struct VkDispatchIndirectCommand {
uint32_t x;
uint32_t y;
uint32_t z;
} VkDispatchIndirectCommand;

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

void vkCmdSetStencilReference(
VkCommandBuffer commandBuffer,
VkStencilFaceFlags faceMask,
uint32_t reference);
faceMask: VK_STENCIL_FACE_{FRONT, BACK}_BIT,
VK_STENCIL_FRONT_AND_BACK

Sparse Resources [28]
Sparse Image Format Properties [28.7.3]

void vkGetPhysicalDeviceSparseImageFormatProperties(
VkPhysicalDevice physicalDevice,
VkFormat format, P.13
VkImageType type, P.13
VkSampleCountFlagBits samples, P.15
VkImageUsageFlags usage, P.13
VkImageTiling tiling, P.13
uint32_t* pPropertyCount,
VkSparseImageFormatProperties* pProperties);
typedef struct VkSparseImageFormatProperties {
VkImageAspectFlags aspectMask; P.13
VkExtent3D imageGranularity; P12
VkSparseImageFormatFlags flags;
} VkSparseImageFormatProperties;

void vkCmdDispatchBase(
VkCommandBuffer commandBuffer,
uint32_t baseGroupX, uint32_t baseGroupY,
uint32_t baseGroupZ, uint32_t groupCountX,
uint32_t groupCountY, uint32_t groupCountZ);
flags: VK_SPARSE_IMAGE_FORMAT_X where X is
SINGLE_MIPTAIL_BIT, ALIGNED_MIP_SIZE_BIT,
NONSTANDARD_BLOCK_SIZE_BIT

void vkGetPhysicalDeviceSparseImageFormatProperties2(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceSparseImageFormatInfo2*
pFormatInfo,
uint32_t* pPropertyCount,
VkSparseImageFormatProperties2* pProperties);
typedef struct VkSparseImageFormatProperties2 {
VkStructureType sType;
void* pNext;
VkSparseImageFormatProperties properties;
} VkSparseImageFormatProperties2;

Continued on next page >
www.khronos.org/vulkan

Vulkan 1.1 Quick Reference
Sparse Resources (continued)
typedef struct VkPhysicalDeviceSparseImageFormatInfo2 {
VkStructureType sType;
const void* pNext;
VkFormat format, P.13
VkImageType type, P.13
VkSampleCountFlagBits samples, P.15
VkImageUsageFlags usage, P.13
VkImageTiling tiling, P.13
} VkPhysicalDeviceSparseImageFormatInfo2;

Sparse Resource Memory Requirements [28.7.5]
void vkGetImageSparseMemoryRequirements(
VkDevice device,
VkImage image,
uint32_t* pSparseMemoryRequirementCount,
VkSparseImageMemoryRequirements*
pSparseMemoryRequirements);

typedef struct VkSparseImageMemoryRequirements {
VkSparseImageFormatProperties formatProperties;
uint32_t imageMipTailFirstLod;
VkDeviceSize imageMipTailSize;
VkDeviceSize imageMipTailOffset;
VkDeviceSize imageMipTailStride;
} VkSparseImageMemoryRequirements;
void vkGetImageSparseMemoryRequirements2(
VkDevice device,
const VkImageSparseMemoryRequirementsInfo2* pInfo,
uint32_t* pSparseMemoryRequirementCount,
VkSparseImageMemoryRequirements2*
pSparseMemoryRequirements);

Window System Integration (WSI) [29]
Android Platform [29.2.1]

VkResult vkCreateAndroidSurfaceKHR(
VkInstance instance,
const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator, P.12
VkSurfaceKHR* pSurface);
typedef struct VkAndroidSurfaceCreateInfoKHR {
VkStructureType sType;
const void* pNext;
VkAndroidSurfaceCreateFlagsKHR flags; = 0
struct ANativeWindow* window;
} VkAndroidSurfaceCreateInfoKHR;

Wayland Platform [29.2.2]

VkResult vkCreateWaylandSurfaceKHR(
VkInstance instance,
const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator, P.12
VkSurfaceKHR* pSurface);
typedef struct VkWaylandSurfaceCreateInfoKHR {
VkStructureType sType;
const void* pNext;
VkWaylandSurfaceCreateFlagsKHR flags; = 0
struct wl_display* display;
struct wl_surface* surface;
} VkWaylandSurfaceCreateInfoKHR;

Win32 Platform [29.2.3]

VkResult vkCreateWin32SurfaceKHR(
VkInstance instance,
const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator, P.12
VkSurfaceKHR* pSurface);
typedef struct VkWin32SurfaceCreateInfoKHR {
VkStructureType sType;
const void* pNext;
VkWin32SurfaceCreateFlagsKHR flags; = 0
HINSTANCE hinstance;
HWND hwnd;
} VkWin32SurfaceCreateInfoKHR;

XCB Platform [29.2.4]

VkResult vkCreateXcbSurfaceKHR(
VkInstance instance,
const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator, P.12
VkSurfaceKHR* pSurface);
typedef struct VkXcbSurfaceCreateInfoKHR {
VkStructureType sType;
const void* pNext;
VkXcbSurfaceCreateFlagsKHR flags;
xcb_connection_t* connection;
xcb_window_t window;
} VkXcbSurfaceCreateInfoKHR;

©2018 Khronos Group - Rev. 0318

Page 9
typedef struct VkImageSparseMemoryRequirementsInfo2 {
VkStructureType sType;
const void* pNext;
VkImage image;
} VkImageSparseMemoryRequirementsInfo2;

typedef struct VkSparseBufferMemoryBindInfo {
VkBuffer buffer;
uint32_t bindCount;
const VkSparseMemoryBind* pBinds; P.15
} VkSparseBufferMemoryBindInfo;

typedef struct VkSparseImageMemoryRequirements2 {
VkStructureType sType;
void* pNext;
VkSparseImageMemoryRequirements
memoryRequirements;
} VkSparseImageMemoryRequirements2;

typedef struct VkSparseImageOpaqueMemoryBindInfo {
VkImage image;
uint32_t bindCount;
const VkSparseMemoryBind* pBinds; P.15
} VkSparseImageOpaqueMemoryBindInfo;

Binding Resource Memory [28.7.6]

typedef struct VkBindSparseInfo {
VkStructureType sType;
const void* pNext;
uint32_t waitSemaphoreCount;
const VkSemaphore* pWaitSemaphores;
uint32_t bufferBindCount;
const VkSparseBufferMemoryBindInfo* pBufferBinds;
uint32_t imageOpaqueBindCount;
const VkSparseImageOpaqueMemoryBindInfo*
pImageOpaqueBinds;
uint32_t imageBindCount;
const VkSparseImageMemoryBindInfo* pImageBinds;
uint32_t signalSemaphoreCount;
const VkSemaphore* pSignalSemaphores;
} VkBindSparseInfo;
pNext may point to structs:
VkDeviceGroupBindSparseInfo P.12

Xlib Platform [29.2.5]

VkResult vkCreateXlibSurfaceKHR(
VkInstance instance,
const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator, P.12
VkSurfaceKHR* pSurface);
typedef struct VkXlibSurfaceCreateInfoKHR {
VkStructureType sType; const void* pNext;
VkXlibSurfaceCreateFlagsKHR flags;
Display* dpy;
Window window;
} VkXlibSurfaceCreateInfoKHR;

Platform-Independent Information [29.2.6]
void vkDestroySurfaceKHR(
VkInstance instance, VkSurfaceKHR surface,
const VkAllocationCallbacks* pAllocator); P.12

typedef struct VkSparseImageMemoryBindInfo {
VkImage image;
uint32_t bindCount;
const VkSparseImageMemoryBind* pBinds;
} VkSparseImageMemoryBindInfo;
typedef struct VkSparseImageMemoryBind {
VkImageSubresource subresource;
VkOffset3D offset; P14
VkExtent3D extent; P12
VkDeviceMemory memory;
VkDeviceSize memoryOffset;
VkSparseMemoryBindFlags flags;
} VkSparseImageMemoryBind;
flags: VK_SPARSE_MEMORY_BIND_METADATA_BIT

VkResult vkQueueBindSparse(
VkQueue queue,
uint32_t bindInfoCount,
const VkBindSparseInfo* pBindInfo,
VkFence fence);

typedef struct VkDisplayModeParametersKHR {
VkExtent2D visibleRegion; P12
uint32_t refreshRate;
} VkDisplayModeParametersKHR;
VkResult vkCreateDisplayModeKHR(
VkPhysicalDevice physicalDevice,
VkDisplayKHR display,
const VkDisplayModeCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator, P.12
VkDisplayModeKHR* pMode);
typedef struct VkDisplayModeCreateInfoKHR {
VkStructureType sType;
const void* pNext;
VkDisplayModeCreateFlagsKHR flags;
VkDisplayModeParametersKHR parameters;
} VkDisplayModeCreateInfoKHR;

Display Enumeration [29.3.1]

VkResult vkGetDisplayPlaneCapabilitiesKHR(
VkPhysicalDevice physicalDevice,
VkDisplayModeKHR mode,
uint32_t planeIndex,
VkDisplayPlaneCapabilitiesKHR* pCapabilities);

typedef struct VkDisplayPropertiesKHR {
VkDisplayKHR display;
const char* displayName;
VkExtent2D physicalDimensions; P12
VkExtent2D physicalResolution; P12
VkSurfaceTransformFlagsKHR supportedTransforms; P.15
VkBool32 planeReorderPossible;
VkBool32 persistentContent;
} VkDisplayPropertiesKHR;

typedef struct VkDisplayPlaneCapabilitiesKHR {
VkDisplayPlaneAlphaFlagsKHR supportedAlpha;
VkOffset2D minSrcPosition; P14
VkOffset2D maxSrcPosition; P14
VkExtent2D minSrcExtent; P12
VkExtent2D maxSrcExtent; P12
VkOffset2D minDstPosition; P14
VkOffset2D maxDstPosition; P14
VkExtent2D minDstExtent; P12
VkExtent2D maxDstExtent; P12
} VkDisplayPlaneCapabilitiesKHR;

VkResult vkGetPhysicalDeviceDisplayPropertiesKHR(
VkPhysicalDevice physicalDevice,
uint32_t* pPropertyCount,
VkDisplayPropertiesKHR* pProperties);

Display Planes

VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
VkPhysicalDevice physicalDevice,
uint32_t* pPropertyCount,
VkDisplayPlanePropertiesKHR* pProperties);
typedef struct VkDisplayPlanePropertiesKHR {
VkDisplayKHR currentDisplay;
uint32_t currentStackIndex;
} VkDisplayPlanePropertiesKHR;
VkResult vkGetDisplayPlaneSupportedDisplaysKHR(
VkPhysicalDevice physicalDevice,
uint32_t planeIndex,
uint32_t* pDisplayCount,
VkDisplayKHR* pDisplays);
Display Modes

VkResult vkGetDisplayModePropertiesKHR(
VkPhysicalDevice physicalDevice,
VkDisplayKHR display,
uint32_t* pPropertyCount,
VkDisplayModePropertiesKHR* pProperties);
typedef struct VkDisplayModePropertiesKHR {
VkDisplayModeKHR displayMode;
VkDisplayModeParametersKHR parameters;
} VkDisplayModePropertiesKHR;

Display Surfaces [29.3.2]

VkResult vkCreateDisplayPlaneSurfaceKHR(
VkInstance instance,
const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator, P.12
VkSurfaceKHR* pSurface);
typedef struct VkDisplaySurfaceCreateInfoKHR {
VkStructureType sType;
const void* pNext;
VkDisplaySurfaceCreateFlagsKHR flags;
VkDisplayModeKHR displayMode;
uint32_t planeIndex;
uint32_t planeStackIndex;
VkSurfaceTransformFlagBitsKHR transform; P.15
float globalAlpha;
VkDisplayPlaneAlphaFlagBitsKHR alphaMode;
VkExtent2D imageExtent; P12
} VkDisplaySurfaceCreateInfoKHR;
alphaMode: VK_DISPLAY_PLANE_ALPHA_X_BIT_KHR
where X is OPAQUE, GLOBAL, PER_PIXEL,
PER_PIXEL_PREMULTIPLIED

Continued on next page >
www.khronos.org/vulkan

Vulkan 1.1 Quick Reference
WSI (continued)
Querying for WSI Support [29.4]

VkResult vkGetPhysicalDeviceSurfaceSupportKHR(
VkPhysicalDevice physicalDevice,
uint32_t queueFamilyIndex, VkSurfaceKHR surface,
VkBool32* pSupported);
Wayland Platform Querying [29.4.2]

VkBool32
vkGetPhysicalDeviceWaylandPresentationSupportKHR(
VkPhysicalDevice physicalDevice,
uint32_t queueFamilyIndex,
struct wl_display* display);
Win32 Platform Querying [29.4.3]

VkBool32
vkGetPhysicalDeviceWin32PresentationSupportKHR(
VkPhysicalDevice physicalDevice,
uint32_t queueFamilyIndex);
XCB Platform Querying [29.4.4]

VkBool32
vkGetPhysicalDeviceXcbPresentationSupportKHR(
VkPhysicalDevice physicalDevice,
uint32_t queueFamilyIndex,
xcb_connection_t* connection,
xcb_visualid_t visual_id);
Xlib Platform Querying [29.4.5]

VkBool32
vkGetPhysicalDeviceXlibPresentationSupportKHR(
VkPhysicalDevice physicalDevice,
uint32_t queueFamilyIndex,
Display* dpy, VisualID visualID);

Surface Queries [29.5]

VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
VkPhysicalDevice physicalDevice,
VkSurfaceKHR surface,
VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); P.15
VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, P.15
VkSurfaceCapabilities2KHR* pSurfaceCapabilities);
typedef struct VkSurfaceCapabilities2KHR {
VkStructureType sType; void* pNext;
VkSurfaceCapabilitiesKHR surfaceCapabilities; P.15
} VkSurfaceCapabilities2KHR;
pNext may point to struct:

VkSharedPresentSurfaceCapabilitiesKHR

typedef struct VkSharedPresentSurfaceCapabilitiesKHR {
VkStructureType sType; void* pNext;
VkImageUsageFlags
sharedPresentSupportedUsageFlags; P.13
} VkSharedPresentSurfaceCapabilitiesKHR;
VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(
VkPhysicalDevice physicalDevice,
VkSurfaceKHR surface,
uint32_t* pSurfaceFormatCount,
VkSurfaceFormatKHR* pSurfaceFormats); P.15
VkResult vkGetPhysicalDeviceSurfaceFormats2KHR(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, P.15
uint32_t* pSurfaceFormatCount,
VkSurfaceFormat2KHR* pSurfaceFormats);
typedef struct VkSurfaceFormat2KHR {
VkStructureType sType; void* pNext;
VkSurfaceFormatKHR surfaceFormat; P.15
} VkSurfaceFormat2KHR;
VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(
VkPhysicalDevice physicalDevice,
VkSurfaceKHR surface,
uint32_t* pPresentModeCount,
VkPresentModeKHR* pPresentModes);
pPresentModes: VK_PRESENT_MODE_X_KHR
where X is IMMEDIATE, MAILBOX, FIFO, FIFO_RELAXED,
SHARED_DEMAND_REFRESH,
SHARED_CONTINUOUS_REFRESH

Device Group Queries [29.6]

VkResult vkGetDeviceGroupPresentCapabilitiesKHR(
VkDevice device,
VkDeviceGroupPresentCapabilitiesKHR*
pDeviceGroupPresentCapabilities);
typedef struct VkDeviceGroupPresentCapabilitiesKHR {
VkStructureType sType; const void* pNext;
uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE];
VkDeviceGroupPresentModeFlagsKHR modes; P.12
} VkDeviceGroupPresentCapabilitiesKHR;

Page 10
VkResult vkGetDeviceGroupSurfacePresentModesKHR(
VkDevice device, VkSurfaceKHR surface,
VkDeviceGroupPresentModeFlagsKHR* pModes); P.12

VkResult vkQueuePresentKHR(
VkQueue queue,
const VkPresentInfoKHR* pPresentInfo);

VkResult vkGetPhysicalDevicePresentRectanglesKHR(
VkPhysicalDevice physicalDevice,
VkSurfaceKHR surface, uint32_t* pRectCount,
VkRect2D* pRects); P.15

typedef struct VkPresentInfoKHR {
VkStructureType sType; const void* pNext;
uint32_t waitSemaphoreCount;
const VkSemaphore* pWaitSemaphores;
uint32_t swapchainCount;
const VkSwapchainKHR* pSwapchains;
const uint32_t* pImageIndices;
VkResult* pResults;
} VkPresentInfoKHR;

WSI Swapchain [29.7]

VkResult vkGetSwapchainStatusKHR(
VkDevice device,
VkSwapchainKHR swapchain);
VkResult vkCreateSwapchainKHR(
VkDevice device,
const VkSwapchainCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator, P.12
VkSwapchainKHR* pSwapchain);
typedef struct VkSwapchainCreateInfoKHR {
VkStructureType sType; const void* pNext;
VkSwapchainCreateFlagsKHR flags;
VkSurfaceKHR surface;
uint32_t minImageCount;
VkFormat imageFormat; P.13
VkColorSpaceKHR imageColorSpace;
VkExtent2D imageExtent; P12
uint32_t imageArrayLayers;
VkImageUsageFlags imageUsage; P.13
VkSharingMode imageSharingMode; P.15
uint32_t queueFamilyIndexCount;
const uint32_t* pQueueFamilyIndices;
VkSurfaceTransformFlagBitsKHR preTransform; P.15
VkCompositeAlphaFlagBitsKHR compositeAlpha; P.12
VkPresentModeKHR presentMode;
VkBool32 clipped;
VkSwapchainKHR oldSwapchain;
} VkSwapchainCreateInfoKHR;
pNext: may point to struct:
VkDeviceGroupSwapchainCreateInfoKHR
flags: VK_SWAPCHAIN_CREATE_X_KHR where X is
SPLIT_INSTANCE_BIND_REGIONS, PROTECTED
colorSpace: VK_COLOR_SPACE_SRGB_NONLINEAR_KHR
presentMode: VK_PRESENT_MODE_X_KHR
where X is IMMEDIATE, MAILBOX, FIFO, FIFO_RELAXED,
DEMAND_REFRESH, CONTINUOUS_REFRESH

typedef struct VkDeviceGroupSwapchainCreateInfoKHR {
VkStructureType sType; const void* pNext;
VkDeviceGroupPresentModeFlagsKHR modes;
} VkDeviceGroupSwapchainCreateInfoKHR;
modes: VK_DEVICE_GROUP_PRESENT_MODE_X_BIT_KHR
where X is LOCAL, REMOTE, SUM, LOCAL_MULTI_DEVICE

pNext may point to structs:
VkDeviceGroupPresentInfoKHR,
VkDisplayPresentInfoKHR, or VkPresentRegionsKHR

typedef struct VkDeviceGroupPresentInfoKHR {
VkStructureType sType; const void* pNext;
uint32_t swapchainCount;
const uint32_t* pDeviceMasks;
VkDeviceGroupPresentModeFlagBitsKHR mode;
} VkDeviceGroupPresentInfoKHR;
mode: VK_DEVICE_GROUP_PRESENT_MODE_X_BIT_KHR
where X is REMOTE, SUM, LOCAL, LOCAL_MULTI_DEVICE

typedef struct VkDisplayPresentInfoKHR {
VkStructureType sType; const void* pNext;
VkRect2D srcRect; P.15
VkRect2D dstRect; P.15
VkBool32 persistent;
} VkDisplayPresentInfoKHR;
typedef struct VkPresentRegionsKHR {
VkStructureType sType; const void* pNext;
uint32_t swapchainCount;
const VkPresentRegionKHR* pRegions;
} VkPresentRegionsKHR;
typedef struct VkPresentRegionKHR {
uint32_t rectangleCount;
const VkRectLayerKHR* pRectangles;
} VkPresentRegionKHR;
typedef struct VkRectLayerKHR {
VkOffset2D offset; P.14
VkExtent2D extent; P.12
uint32_t layer;
} VkRectLayerKHR;
typedef struct VkDisplayPresentInfoKHR {
VkStructureType sType; const void* pNext;
VkRect2D srcRect; P.15
VkRect2D dstRect; P.15
VkBool32 persistent;
} VkDisplayPresentInfoKHR;

void vkDestroySwapchainKHR(
VkDevice device,
VkSwapchainKHR swapchain,
const VkAllocationCallbacks* pAllocator); P.12
VkResult vkCreateSharedSwapchainsKHR(
VkDevice device,
uint32_t swapchainCount,
const VkSwapchainCreateInfoKHR* pCreateInfos,
const VkAllocationCallbacks* pAllocator, P.12
VkSwapchainKHR* pSwapchains);
VkResult vkGetSwapchainImagesKHR(
VkDevice device,
VkSwapchainKHR swapchain,
uint32_t* pSwapchainImageCount,
VkImage* pSwapchainImages);
VkResult vkAcquireNextImageKHR(
VkDevice device,
VkSwapchainKHR swapchain,
uint64_t timeout,
VkSemaphore semaphore,
VkFence fence,
uint32_t* pImageIndex);
VkResult vkAcquireNextImage2KHR(
VkDevice device,
const VkAcquireNextImageInfoKHR* pAcquireInfo,
uint32_t* pImageIndex);
typedef struct VkAcquireNextImageInfoKHR {
VkStructureType sType; const void* pNext;
VkSwapchainKHR swapchain;
uint64_t timeout;
VkSemaphore semaphore;
VkFence fence;
uint32_t deviceMask;
} VkAcquireNextImageInfoKHR;

Extended Functionality
Layers [30.1]

VkResult vkEnumerateInstanceLayerProperties(
uint32_t* pPropertyCount,
VkLayerProperties* pProperties);
VkResult vkEnumerateDeviceLayerProperties(
VkPhysicalDevice physicalDevice,
uint32_t* pPropertyCount,
VkLayerProperties* pProperties);
typedef struct VkLayerProperties {
char layerName [VK_MAX_EXTENSION_NAME_SIZE];
uint32_t specVersion;
uint32_t implementationVersion;
char description [VK_MAX_DESCRIPTION_SIZE];
} VkLayerProperties;

Extensions [30.2]

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

Continued on next page >
©2018 Khronos Group - Rev. 0318

www.khronos.org/vulkan

Vulkan 1.1 Quick Reference
Extended Functionality (continued)
typedef struct VkExtensionProperties {
char layerName [VK_MAX_EXTENSION_NAME_SIZE];
uint32_t specVersion;
} VkExtensionProperties;

Additional Buffer Capabilities [31.5]

void vkGetPhysicalDeviceExternalBufferProperties(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceExternalBufferInfo*
pExternalBufferInfo,
VkExternalBufferProperties*
pExternalBufferProperties);
typedef struct VkPhysicalDeviceExternalBufferInfo {
VkStructureType sType;
const void* pNext;
VkBufferCreateFlags flags; P.12
VkBufferUsageFlags usage; P.12
VkExternalMemoryHandleTypeFlagBits handleType; P.12
} VkPhysicalDeviceExternalBufferInfo;
typedef struct VkExternalBufferProperties {
VkStructureType sType;
void* pNext;
VkExternalMemoryProperties
externalMemoryProperties; P.13
} VkExternalBufferProperties;

Page 11
Optional Semaphore Capabilities [31.6]

void vkGetPhysicalDeviceExternalSemaphoreProperties(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceExternalSemaphoreInfo*
pExternalSemaphoreInfo,
VkExternalSemaphoreProperties*
pExternalSemaphoreProperties);
typedef struct VkPhysicalDeviceExternalSemaphoreInfo {
VkStructureType sType;
const void* pNext;
VkExternalSemaphoreHandleTypeFlagBits
handleType; P.13
} VkPhysicalDeviceExternalSemaphoreInfo;
enum VkExternalSemaphoreHandleTypeFlagBits:
VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_X_BIT
where X is OPAQUE_FD,
OPAQUE_WIN32[_KMT],
D3D12_FENCE, SYNC_FD

typedef struct VkExternalSemaphoreProperties {
VkStructureType sType; void* pNext;
VkExternalSemaphoreHandleTypeFlags
exportFromImportedHandleTypes; P.13
VkExternalSemaphoreHandleTypeFlags
compatibleHandleTypes;
VkExternalSemaphoreFeatureFlags
externalSemaphoreFeatures;
} VkExternalSemaphoreProperties;

Optional Fence Capabilities [31.7]

void vkGetPhysicalDeviceExternalFenceProperties(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceExternalFenceInfo*
pExternalFenceInfo,
VkExternalFenceProperties* pExternalFenceProperties);
typedef struct VkPhysicalDeviceExternalFenceInfo {
VkStructureType sType;
const void* pNext;
VkExternalFenceHandleTypeFlagBits handleType; P.12
} VkPhysicalDeviceExternalFenceInfo;
typedef struct VkExternalFenceProperties {
VkStructureType sType;
void* pNext;
VkExternalFenceHandleTypeFlags
exportFromImportedHandleTypes; P.12
VkExternalFenceHandleTypeFlags
compatibleHandleTypes; P.12
VkExternalFenceFeatureFlags externalFenceFeatures;
} VkExternalFenceProperties;
enum VkExternalFenceFeatureFlagBits:
VK_EXTERNAL_FENCE_FEATURE_X_BIT where X is
EXPORTABLE, IMPORTABLE

VkExternalSemaphoreFeatureFlagBits:
VK_EXTERNAL_SEMAPHORE_FEATURE_X_BIT where X is
EXPORTABLE, IMPORTABLE

Features, Limits, and Formats [31]
Features [31.1]

void vkGetPhysicalDeviceFeatures(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceFeatures* pFeatures); P14

void vkGetPhysicalDeviceFormatProperties2(
VkPhysicalDevice physicalDevice,
VkFormat format, P.13
VkFormatProperties2* pFormatProperties);

void vkGetPhysicalDeviceFeatures2(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceFeatures2* pFeatures); P.14

typedef struct VkFormatProperties2 {
VkStructureType sType;
void* pNext;
VkFormatProperties formatProperties;
} VkFormatProperties2;

Format Properties [31.3.2]

Additional Image Capabilities [31.4]

void vkGetPhysicalDeviceFormatProperties(
VkPhysicalDevice physicalDevice,
VkFormat format, P.13
VkFormatProperties* pFormatProperties);
typedef struct VkFormatProperties {
VkFormatFeatureFlags linearTilingFeatures;
VkFormatFeatureFlags optimalTilingFeatures;
VkFormatFeatureFlags bufferFeatures;
} VkFormatProperties;
enum VkFormatFeatureFlagBits:
VK_FORMAT_FEATURE_X_BIT where X is
SAMPLED_IMAGE, STORAGE_IMAGE[_ATOMIC],
UNIFORM_TEXEL_BUFFER,
STORAGE_TEXEL_BUFFER[_ATOMIC],
VERTEX_BUFFER, COLOR_ATTACHMENT[_BLEND],
DEPTH_STENCIL_ATTACHMENT,
SAMPLED_IMAGE_FILTER_LINEAR, DISJOINT,
BLIT_{SRC, DST}, TRANSFER_{SRC, DST},
{MIDPOINT, COSITED}_CHROMA_SAMPLES,
and VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_X where X is LINEAR_FILTER,
SEPARATE_RECONSTRUCTION_FILTER,
CHROMA_RECONSTRUCTION_EXPLICIT,
CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE

VkResult vkGetPhysicalDeviceImageFormatProperties(
VkPhysicalDevice physicalDevice,
VkFormat format, P.13
VkImageType type, P.13
VkImageTiling tiling, P.13
VkImageUsageFlags usage, P.13
VkImageCreateFlags flags, P.13
VkImageFormatProperties* pImageFormatProperties);
typedef struct VkImageFormatProperties {
VkExtent3D maxExtent; P12
uint32_t maxMipLevels;
uint32_t maxArrayLayers;
VkSampleCountFlags sampleCounts; P.15
VkDeviceSize maxResourceSize;
} VkImageFormatProperties;

typedef struct VkImageFormatProperties2 {
VkStructureType sType;
void* pNext;
VkImageFormatProperties imageFormatProperties;
} VkImageFormatProperties2;
pNext may point to struct:
VkExternalImageFormatProperties P.12
VkSamplerYcbcrConversionImageFormatProperties P.15

typedef struct VkPhysicalDeviceImageFormatInfo2 {
VkStructureType sType;
const void* pNext;
VkFormat format, P.13
VkImageType type, P.13
VkImageTiling tiling, P.13
VkImageUsageFlags usage, P.13
VkImageCreateFlags flags, P.13
} VkPhysicalDeviceImageFormatInfo2;
pNext may point to struct:
VkPhysicalDeviceExternalImageFormatInfo P.14

VkResult vkGetPhysicalDeviceImageFormatProperties2(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceImageFormatInfo2*
pImageFormatInfo,
VkImageFormatProperties2* pImageFormatProperties);

Command Buffer Lifecycle [5.1]

A command buffer is always in one of the five states shown below:

Initial

Pending

Recording

Invalid

A command buffer in the initial state
can only be moved to the recording
state or freed.
In this state, vkCmd* commands
record to the command buffer.

Executable

Attempting to modify the command
buffer in this state will cause a
transition to the invalid state.
In this state, a command buffer may
be reset, moved to recording state, or
freed.

In this state, the command buffer
may be submitted, reset, or recorded
to another command buffer.

©2018 Khronos Group - Rev. 0318

www.khronos.org/vulkan

Vulkan 1.1 Quick Reference
Structures and Enumerations

This section contains an alphabetic reference to types enums
and structs referenced in multiple places on preceding pages.

enum VkAccessFlagBits:
VK_ACCESS_X_BIT where X is
INDIRECT_COMMAND_READ,
INDEX_READ,
VERTEX_ATTRIBUTE_READ,
UNIFORM_READ,
INPUT_ATTACHMENT_READ,
SHADER_[READ, WRITE],
COLOR_ATTACHMENT_[READ, WRITE],
DEPTH_STENCIL_ATTACHMENT_[READ, WRITE],
TRANSFER_[READ, WRITE],
HOST_[READ, WRITE],
MEMORY_[READ, WRITE]

typedef struct VkAllocationCallbacks {
void* pUserData;
PFN_vkAllocationFunction pfnAllocation;
PFN_vkReallocationFunction pfnReallocation;
PFN_vkFreeFunction pfnFree;
PFN_vkInternalAllocationNotification
pfnInternalAllocation;
PFN_vkInternalFreeNotification pfnInternalFree;
} VkAllocationCallbacks;
typedef void* (VKAPI_PTR* PFN_vkAllocationFunction)(
void* pUserData,
size_t size,
size_t alignment,
VkSystemAllocationScope allocationScope);
typedef void* (VKAPI_PTR* PFN_vkReallocationFunction)(
void* pUserData,
void* pOriginal,
size_t size,
size_t alignment,
VkSystemAllocationScope allocationScope);
typedef void (VKAPI_PTR* PFN_vkFreeFunction)(
void* pUserData,
void* pMemory);
typedef void (
VKAPI_PTR* PFN_vkInternalAllocationNotification)(
void* pUserData,
size_t size,
VkInternalAllocationType allocationType,
VkSystemAllocationScope allocationScope);
typedef void (
VKAPI_PTR* PFN_vkInternalFreeNotification)(
void* pUserData,
size_t size,
VkInternalAllocationType allocationType,
VkSystemAllocationScope allocationScope);
allocationType:
VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE
allocationScope: VK_SYSTEM_ALLOCATION_SCOPE_X where
X is COMMAND, OBJECT, CACHE, DEVICE, INSTANCE

typedef struct VkBindBufferMemoryDeviceGroupInfo {
VkStructureType sType; const void* pNext;
uint32_t deviceIndexCount;
const uint32_t* pDeviceIndices;
} VkBindBufferMemoryDeviceGroupInfo;
typedef struct VkBindImageMemoryDeviceGroupInfo {
VkStructureType sType; const void* pNext;
uint32_t deviceIndexCount;
const uint32_t* pDeviceIndices;
uint32_t splitInstanceBindRegionCount;
const VkRect2D* pSplitInstanceBindRegions; P.15
} VkBindImageMemoryDeviceGroupInfo;
typedef struct VkBindImagePlaneMemoryInfo {
VkStructureType sType; const void* pNext;
VkImageAspectFlagBits planeAspect; P.13
} VkBindImagePlaneMemoryInfo;
enum VkBlendOp:
VK_BLEND_OP_ADD,
VK_BLEND_OP_SUBTRACT,
VK_BLEND_OP_REVERSE_SUBTRACT,
VK_BLEND_OP_MIN,
VK_BLEND_OP_MAX

enum VkBufferCreateFlagBits:
VK_BUFFER_CREATE_SPARSE_BINDING_BIT,
VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT,
VK_BUFFER_CREATE_SPARSE_ALIASED_BIT,
VK_BUFFER_CREATE_PROTECTED_BIT

©2018 Khronos Group - Rev. 0318

Page 12
typedef struct VkBufferMemoryBarrier {
VkStructureType sType; const void* pNext;
VkAccessFlags srcAccessMask; P.12
VkAccessFlags dstAccessMask; P.12
uint32_t srcQueueFamilyIndex;
uint32_t dstQueueFamilyIndex;
VkBuffer buffer;
VkDeviceSize offset;
VkDeviceSize size;
} VkBufferMemoryBarrier;
enum VkBufferUsageFlagBits:
VK_BUFFER_USAGE_X_BIT where X is

TRANSFER_SRC, TRANSFER_DST,
UNIFORM_TEXEL_BUFFER, STORAGE_TEXEL_BUFFER,
UNIFORM_BUFFER, STORAGE_BUFFER, INDEX_BUFFER,
VERTEX_BUFFER, INDIRECT_BUFFER

typedef union VkClearColorValue {
float float32[4];
int32_t int32[4];
uint32_t uint32[4];
} VkClearColorValue;
typedef struct VkClearDepthStencilValue {
float depth;
uint32_t stencil;
} VkClearDepthStencilValue;
typedef union VkClearValue {
VkClearColorValue color; P.12
VkClearDepthStencilValue depthStencil; P.12
} VkClearValue;
enum VkCompareOp:
VK_COMPARE_OP_X where X is
NEVER, LESS, EQUAL,
LESS_OR_EQUAL,
GREATER,
NOT_EQUAL,
GREATER_OR_EQUAL,
ALWAYS

enum VkCompositeAlphaFlagBitsKHR:
VK_COMPOSITE_ALPHA_X_BIT_KHR where X is
OPAQUE,
PRE_MULTIPLIED,
POST_MULTIPLIED,
INHERIT

enum VkDependencyFlagBits:
VK_DEPENDENCY_BY_REGION_BIT,
VK_DEPENDENCY_DEVICE_GROUP_BIT,
VK_DEPENDENCY_VIEW_LOCAL_BIT

enum VkDescriptorType:
VK_DESCRIPTOR_TYPE_X where X is
SAMPLER,
COMBINED_IMAGE_SAMPLER,
SAMPLED_IMAGE,
STORAGE_IMAGE,
UNIFORM_TEXEL_BUFFER,
STORAGE_TEXEL_BUFFER,
UNIFORM_BUFFER[_DYNAMIC],
STORAGE_BUFFER[_DYNAMIC],
INPUT_ATTACHMENT

typedef struct VkDescriptorSetLayoutBinding {
uint32_t binding;
VkDescriptorType descriptorType; P.12
uint32_t descriptorCount;
VkShaderStageFlags stageFlags; P.15
const VkSampler* pImmutableSamplers;
} VkDescriptorSetLayoutBinding;
typedef struct VkDescriptorSetLayoutCreateInfo {
VkStructureType sType; const void *pNext;
VkDescriptorSetLayoutCreateFlags flags;
uint32_t bindingCount;
const VkDescriptorSetLayoutBinding* pBindings;
} VkDescriptorSetLayoutCreateInfo;
typedef struct VkDeviceGroupBindSparseInfo {
VkStructureType sType; const void* pNext;
uint32_t resourceDeviceIndex;
uint32_t memoryDeviceIndex;
} VkDeviceGroupBindSparseInfo;
typedef struct VkDeviceGroupCommandBufferBeginInfo {
VkStructureType sType; const void* pNext;
uint32_t deviceMask;
} VkDeviceGroupCommandBufferBeginInfo;

typedef struct VkDeviceGroupDeviceCreateInfo {
VkStructureType sType; const void* pNext;
uint32_t physicalDeviceCount;
const VkPhysicalDevice* pPhysicalDevices;
} VkDeviceGroupDeviceCreateInfo;
enum VkDeviceGroupPresentModeFlagBitsKHR:
VK_DEVICE_GROUP_PRESENT_MODE_X_BIT_KHR where X is
LOCAL,
REMOTE,
SUM,
LOCAL_MULTI_DEVICE

typedef struct VkDeviceGroupRenderPassBeginInfo {
VkStructureType sType; const void* pNext;
uint32_t deviceMask;
uint32_t deviceRenderAreaCount;
const VkRect2D* pDeviceRenderAreas; P.15
} VkDeviceGroupRenderPassBeginInfo;
typedef struct VkDeviceGroupSubmitInfo {
VkStructureType sType; const void* pNext;
uint32_t waitSemaphoreCount;
const uint32_t* pWaitSemaphoreDeviceIndices;
uint32_t commandBufferCount;
const uint32_t* pCommandBufferDeviceMasks;
uint32_t signalSemaphoreCount;
const uint32_t* pSignalSemaphoreDeviceIndices;
} VkDeviceGroupSubmitInfo;
typedef struct VkExportFenceCreateInfo {
VkStructureType sType;
const void* pNext;
VkExternalFenceHandleTypeFlags handleTypes; P.12
} VkExportFenceCreateInfo;
typedef struct VkExportMemoryAllocateInfo {
VkStructureType sType; const void* pNext;
VkExternalMemoryHandleTypeFlags handleTypes; P.12
} VkExportMemoryAllocateInfo;
typedef struct VkExportSemaphoreCreateInfo {
VkStructureType sType;
const void* pNext;
VkExternalSemaphoreHandleTypeFlags handleTypes; P.13
} VkExportSemaphoreCreateInfo;
typedef struct VkExtent2D {
uint32_t width;
uint32_t height;
} VkExtent2D;
typedef struct VkExtent3D {
uint32_t width;
uint32_t height;
uint32_t depth;
} VkExtent3D;
enum VkExternalFenceHandleTypeFlagBits:
VK_EXTERNAL_FENCE_HANDLE_TYPE_X_BIT where X is
OPAQUE_FD,
OPAQUE_WIN32,
OPAQUE_WIN32_KMT,
SYNC_FD

typedef struct VkExternalImageFormatProperties {
VkStructureType sType; void* pNext;
VkExternalMemoryProperties
externalMemoryProperties; P13
} VkExternalImageFormatProperties;
typedef struct VkExternalMemoryBufferCreateInfo {
VkStructureType sType; const void* pNext;
VkExternalMemoryHandleTypeFlags handleTypes; P.12
} VkExternalMemoryBufferCreateInfo;
enum VkExternalMemoryFeatureFlagBits:
VK_EXTERNAL_MEMORY_FEATURE_X_BIT where X is
DEDICATED_ONLY,
EXPORTABLE,
IMPORTABLE

enum VkExternalMemoryHandleTypeFlagBits:
VK_EXTERNAL_MEMORY_HANDLE_TYPE_X_BIT where X is
OPAQUE_FD,
OPAQUE_WIN32,
OPAQUE_WIN32_KMT,
D3D11_TEXTURE,
D3D11_TEXTURE_KMT,
D3D12_HEAP,
D3D12_RESOURCE

Continued on next page >
www.khronos.org/vulkan

Vulkan 1.1 Quick Reference
Structures and Enumerations (continued)
typedef struct VkExternalMemoryImageCreateInfo {
VkStructureType sType; const void* pNext;
VkExternalMemoryHandleTypeFlags handleTypes; P.12
} VkExternalMemoryImageCreateInfo;
typedef struct VkExternalMemoryProperties {
VkExternalMemoryFeatureFlags
externalMemoryFeatures; P.12
VkExternalMemoryHandleTypeFlags
exportFromImportedHandleTypes; P12
VkExternalMemoryHandleTypeFlags
compatibleHandleTypes; P12
} VkExternalMemoryProperties;
enum VkExternalSemaphoreHandleTypeFlagBits:
VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_X_BIT where
X is OPAQUE_FD, OPAQUE_WIN32, OPAQUE_WIN32_KMT,
D3D12_FENCE, SYNC_FD

enum VkFormat:
VK_FORMAT_X where X is
UNDEFINED,
R4G4_UNORM_PACK8,
R4G4B4A4_UNORM_PACK16,
B4G4R4A4_UNORM_PACK16,
R5G6B5_UNORM_PACK16,
B5G6R5_UNORM_PACK16,
R5G5B5A1_UNORM_PACK16,
B5G5R5A1_UNORM_PACK16,
A1R5G5B5_UNORM_PACK16,
R8_[UNORM, SNORM, USCALED],
R8_[SSCALED, UINT, SINT, SRGB],
R8G8_[UNORM, SNORM, USCALED],
R8G8_[SSCALED, UINT, SINT, SRGB],
R8G8B8_[UNORM, SNORM, USCALED],
R8G8B8_[SSCALED, UINT, SINT, SRGB],
B8G8R8_[UNORM, SNORM, USCALED],
B8G8R8_[SSCALED, UINT, SINT, SRGB],
R8G8B8A8_[UNORM, SNORM, USCALED],
R8G8B8A8_[SSCALED, UINT, SINT, SRGB],
B8G8R8A8_[UNORM, SNORM, USCALED],
B8G8R8A8_[SSCALED, UINT, SINT, SRGB],
A8B8G8R8_[UNORM, SNORM, USCALED]_PACK32,
A8B8G8R8_[SSCALED, UINT, SINT, SRGB]_PACK32,
A2R10G10B10_[UNORM, SNORM, USCALED]_PACK32,
A2R10G10B10_[SSCALED, UINT, SINT]_PACK32,
A2B10G10R10_[UNORM, SNORM, USCALED]_PACK32,
A2B10G10R10_[SSCALED, UINT, SINT]_PACK32,
R16_[UNORM, SNORM, USCALED],
R16_[SSCALED, UINT, SINT, SFLOAT],
R16G16_[UNORM, SNORM, USCALED],
R16G16_[SSCALED, UINT, SINT, SFLOAT],
R16G16B16_[UNORM, SNORM, USCALED],
R16G16B16_[SSCALED, UINT, SINT, SFLOAT],
R16G16B16A16_[UNORM, SNORM, USCALED],
R16G16B16A16_[SSCALED, UINT, SINT, SFLOAT],
R32_[UINT, SINT, SFLOAT],
R32G32_[UINT, SINT, SFLOAT],
R32G32B32_[UINT, SINT, SFLOAT],
R32G32B32A32_[UINT, SINT, SFLOAT],
R64_[UINT, SINT, SFLOAT],
R64G64_[UINT, SINT, SFLOAT],
R64G64B64_[UINT, SINT, SFLOAT],
R64G64B64A64_[UINT, SINT, SFLOAT],
B10G11R11_UFLOAT_PACK32,
E5B9G9R9_UFLOAT_PACK32,
X8_D24_UNORM_PACK32,
D32_SFLOAT[_S8_UINT],
S8_UINT,
D[16, 24]_UNORM_S8_UINT,
BC1_[RGB, RGBA]_UNORM_BLOCK,
BC1_[RGB, RGBA]_SRGB_BLOCK,
BC2_[UNORM, SRGB]_BLOCK,
BC3_[UNORM, SRGB]_BLOCK,
BC4_[UNORM, SRGB]_BLOCK,
BC5_[UNORM, SRGB]_BLOCK,
BC6H_[UFLOAT, SFLOAT]_BLOCK,
BC7_[UNORM, SRGB]_BLOCK,
ETC2_R8G8B8_[UNORM, SRGB]_BLOCK,
ETC2_R8G8B8A1_[UNORM, SRGB]_BLOCK,
ETC2_R8G8B8A8_[UNORM, SRGB]_BLOCK,
EAC_R11_[UNORM, SRGB]_BLOCK,
EAC_R11G11_[UNORM, SRGB]_BLOCK,
ASTC_4x4_[UNORM, SRGB]_BLOCK,
ASTC_5x4_[UNORM, SRGB]_BLOCK,
ASTC_5x5_[UNORM, SRGB]_BLOCK,
ASTC_6x5_[UNORM, SRGB]_BLOCK,
ASTC_6x6_[UNORM, SRGB]_BLOCK,
ASTC_8x5_[UNORM, SRGB]_BLOCK,
ASTC_8x6_[UNORM, SRGB]_BLOCK,
ASTC_8x8_[UNORM, SRGB]_BLOCK,
ASTC_10x5_[UNORM, SRGB]_BLOCK,

©2018 Khronos Group - Rev. 0318

Page 13
ASTC_10x6_[UNORM, SRGB]_BLOCK,
ASTC_10x8_[UNORM, SRGB]_BLOCK,
ASTC_10x10_[UNORM, SRGB]_BLOCK,
ASTC_12x10_[UNORM, SRGB]_BLOCK,
ASTC_12x12_[UNORM, SRGB]_BLOCK,
G8B8G8R8_422_UNORM,
B8G8R8G8_422_UNORM,
G8_B8_R8_3PLANE_420_UNORM,
G8_B8R8_2PLANE_{420, 422}_UNORM,
G8_B8_R8_3PLANE_{422, 444}_UNORM,
R10X6_UNORM_PACK16,
R10X6G10X6_UNORM_2PACK16,
R10X6G10X6B10X6A10X6_UNORM_4PACK16,
G10X6B10X6G10X6R10X6_422_UNORM_4PACK16,
B10X6G10X6R10X6G10X6_422_UNORM_4PACK16,
G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16,
G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16,
G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16,
G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16,
G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16,
R12X4_UNORM_PACK16,
R12X4G12X4_UNORM_2PACK16,
R12X4G12X4B12X4A12X4_UNORM_4PACK16,
G12X4B12X4G12X4R12X4_422_UNORM_4PACK16,
B12X4G12X4R12X4G12X4_422_UNORM_4PACK16,
G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16,
G12X4_B12X4R12X4_2PLANE_{420, 422}_UNORM_3PACK16,
G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16,
G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16,
G16B16G16R16_422_UNORM,
B16G16R16G16_422_UNORM,
G16_B16_R16_3PLANE_{420, 422, 444}_UNORM,
G16_B16R16_2PLANE_{420, 422}_UNORM

enum VkImageAspectFlagBits:
VK_IMAGE_ASPECT_X_BIT where X is
COLOR,
DEPTH,
STENCIL,
METADATA,
PLANE_[0,1,2]

enum VkImageCreateFlagBits:
VK_IMAGE_CREATE_X_BIT where X is

SPARSE_{BINDING, RESIDENCY, ALIASED},
MUTABLE_FORMAT,
{CUBE, 2D_ARRAY, TEXEL_VIEW}_COMPATIBLE,
ALIAS, BIND_SFR,
EXTENDED_USAGE,
PROTECTED,
DISJOINT

enum VkImageLayout:
VK_IMAGE_LAYOUT_X where X is

UNDEFINED, GENERAL, PREINITIALIZED,
COLOR_ATTACHMENT_OPTIMAL,
DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL,
DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL,
DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
DEPTH_STENCIL_READ_ONLY_OPTIMAL,
SHADER_READ_ONLY_OPTIMAL,
TRANSFER_{SRC, DST}_OPTIMAL,
DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL,
DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL,
VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR

NOTE: For the functions vkCmdCopyImage,
vkCmdCopyBufferToImage, vkCmdCopyImageToBuffer,
vkCmdBlitImage, and vkCmdResolveImage, the enum
VkImageLayout for the following parameters may be:
srcImageLayout: VK_IMAGE_LAYOUT_GENERAL,
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR
dstImageLayout: VK_IMAGE_LAYOUT_GENERAL,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR

typedef struct VkImageMemoryBarrier {
VkStructureType sType; const void* pNext;
VkAccessFlags srcAccessMask; P.12
VkAccessFlags dstAccessMask; P.12
VkImageLayout oldLayout; P.13
VkImageLayout newLayout; P.13
uint32_t srcQueueFamilyIndex;
uint32_t dstQueueFamilyIndex;
VkImage image;
VkImageSubresourceRange subresourceRange; P.1313
} VkImageMemoryBarrier;
typedef struct VkImagePlaneMemoryRequirementsInfo {
VkStructureType sType; const void* pNext;
VkImageAspectFlagBits planeAspect; P.1313
} VkImagePlaneMemoryRequirementsInfo;

typedef struct VkImageSubresourceLayers {
VkImageAspectFlags aspectMask; P.13
uint32_t mipLevel;
uint32_t baseArrayLayer;
uint32_t layerCount;
} VkImageSubresourceLayers;
typedef struct VkImageSubresourceRange {
VkImageAspectFlags aspectMask; P.13
uint32_t baseMipLevel;
uint32_t levelCount;
uint32_t baseArrayLayer;
uint32_t layerCount;
} VkImageSubresourceRange;
enum VkImageTiling:
VK_IMAGE_TILING_{OPTIMAL, LINEAR}

enum VkImageType:
VK_IMAGE_TYPE_{1D, 2D, 3D}

enum VkImageUsageFlagBits:
VK_IMAGE_USAGE_X_BIT where X is
TRANSFER_SRC,
TRANSFER_DST,
SAMPLED,
STORAGE,
COLOR_ATTACHMENT,
DEPTH_STENCIL_ATTACHMENT,
TRANSIENT_ATTACHMENT,
INPUT_ATTACHMENT

typedef struct VkImageViewUsageCreateInfo {
VkStructureType sType; const void* pNext;
VkImageUsageFlags usage; P.13
} VkImageViewUsageCreateInfo;
typedef struct VkInputAttachmentAspectReference {
uint32_t subpass;
uint32_t inputAttachmentIndex;
VkImageAspectFlags aspectMask; P.13
} VkInputAttachmentAspectReference;
typedef struct VkMemoryAllocateFlagsInfo {
VkStructureType sType; const void* pNext;
VkMemoryAllocateFlags flags;
uint32_t deviceMask;
} VkMemoryAllocateFlagsInfo;
flags: VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT

typedef struct VkMemoryBarrier {
VkStructureType sType; const void* pNext;
VkAccessFlags srcAccessMask; P.12
VkAccessFlags dstAccessMask; P.12
} VkMemoryBarrier;
typedef struct VkMemoryDedicatedAllocateInfo {
VkStructureType sType; const void* pNext;
VkImage image;
VkBuffer buffer;
} VkMemoryDedicatedAllocateInfo;
typedef struct VkMemoryDedicatedRequirements {
VkStructureType sType; void* pNext;
VkBool32 prefersDedicatedAllocation;
VkBool32 requiresDedicatedAllocation;
} VkMemoryDedicatedRequirements;
typedef struct VkMemoryHeap {
VkDeviceSize size;
VkMemoryHeapFlags flags;
} VkMemoryHeap;
flags: VK_MEMORY_HEAP_X_BIT where X is
DEVICE_LOCAL, MULTI_INSTANCE

typedef struct VkMemoryRequirements {
VkDeviceSize size;
VkDeviceSize alignment;
uint32_t memoryTypeBits;
} VkMemoryRequirements;
typedef struct VkMemoryRequirements2 {
VkStructureType sType; void* pNext;
VkMemoryRequirements memoryRequirements; P.13
} VkMemoryRequirements2;
pNext may point to structs:
VkMemoryDedicatedRequirements P13

Continued on next page >
www.khronos.org/vulkan

Vulkan 1.1 Quick Reference
Structures and Enumerations (continued)
typedef struct VkMemoryType {
VkMemoryPropertyFlags propertyFlags;
uint32_t heapIndex;
} VkMemoryType;
propertyFlags: VK_MEMORY_PROPERTY_X_BIT where X is
DEVICE_LOCAL, HOST_VISIBLE, HOST_COHERENT,
HOST_CACHED, LAZILY_ALLOCATED, PROTECTED

typedef struct VkOffset2D {
int32_t x;
int32_t y;
} VkOffset2D;
typedef struct VkOffset3D {
int32_t x;
int32_t y;
int32_t z;
} VkOffset3D;
typedef struct VkPhysicalDevice16BitStorageFeatures {
VkStructureType sType; void* pNext;
VkBool32 storageBuffer16BitAccess;
VkBool32 uniformAndStorageBuffer16BitAccess;
VkBool32 storagePushConstant16;
VkBool32 storageInputOutput16;
} VkPhysicalDevice16BitStorageFeatures;
typedef struct VkPhysicalDeviceExternalImageFormatInfo {
VkStructureType sType; const void* pNext;
VkExternalMemoryHandleTypeFlagBits handleType; P.1512
} VkPhysicalDeviceExternalImageFormatInfo;
typedef struct VkPhysicalDeviceFeatures {
VkBool32 robustBufferAccess;
VkBool32 fullDrawIndexUint32;
VkBool32 imageCubeArray;
VkBool32 independentBlend;
VkBool32 geometryShader;
VkBool32 tessellationShader;
VkBool32 sampleRateShading;
VkBool32 dualSrcBlend;
VkBool32 logicOp;
VkBool32 multiDrawIndirect;
VkBool32 drawIndirectFirstInstance;
VkBool32 depthClamp;
VkBool32 depthBiasClamp;
VkBool32 fillModeNonSolid;
VkBool32 depthBounds;
VkBool32 wideLines;
VkBool32 largePoints;
VkBool32 alphaToOne;
VkBool32 multiViewport;
VkBool32 samplerAnisotropy;
VkBool32 textureCompressionETC2;
VkBool32 textureCompressionASTC_LDR;
VkBool32 textureCompressionBC;
VkBool32 occlusionQueryPrecise;
VkBool32 pipelineStatisticsQuery;
VkBool32 vertexPipelineStoresAndAtomics;
VkBool32 fragmentStoresAndAtomics;
VkBool32 shaderTessellationAndGeometryPointSize;
VkBool32 shaderImageGatherExtended;
VkBool32 shaderStorageImageExtendedFormats;
VkBool32 shaderStorageImageMultisample;
VkBool32 shaderStorageImageReadWithoutFormat;
VkBool32 shaderStorageImageWriteWithoutFormat;
VkBool32 shaderUniformBufferArrayDynamicIndexing;
VkBool32 shaderSampledImageArrayDynamicIndexing;
VkBool32 shaderStorageBufferArrayDynamicIndexing;
VkBool32 shaderStorageImageArrayDynamicIndexing;
VkBool32 shaderClipDistance;
VkBool32 shaderCullDistance;
VkBool32 shaderFloat64;
VkBool32 shaderInt64;
VkBool32 shaderInt16;
VkBool32 shaderResourceResidency;
VkBool32 shaderResourceMinLod;
VkBool32 sparseBinding;
VkBool32 sparseResidencyBuffer;
VkBool32 sparseResidencyImage2D;
VkBool32 sparseResidencyImage3D;
VkBool32 sparseResidency2Samples;
VkBool32 sparseResidency4Samples;
VkBool32 sparseResidency8Samples;
VkBool32 sparseResidency16Samples;
VkBool32 sparseResidencyAliased;
VkBool32 variableMultisampleRate;
VkBool32 inheritedQueries;
} VkPhysicalDeviceFeatures;

©2018 Khronos Group - Rev. 0318

Page 14
typedef struct VkPhysicalDeviceFeatures2 {
VkStructureType sType; void* pNext;
VkPhysicalDeviceFeatures features; P.14
} VkPhysicalDeviceFeatures2;
pNext may point to these structs:
VkPhysicalDevice16BitStorageFeatures P.14
VkPhysicalDeviceMultiviewFeatures P.14
VkPhysicalDeviceProtectedMemoryFeatures P.15
VkPhysicalDeviceSamplerYcbcrConversionFeatures P.15
VkPhysicalDeviceShaderDrawParameterFeatures P.15
VkPhysicalDeviceVariablePointerFeatures P.15

typedef struct VkPhysicalDeviceIDProperties {
VkStructureType sType; void* pNext;
uint8_t deviceUUID[VK_UUID_SIZE];
uint8_t driverUUID[VK_UUID_SIZE];
uint8_t deviceLUID[VK_LUID_SIZE];
uint32_t deviceNodeMask;
VkBool32 deviceLUIDValid;
} VkPhysicalDeviceIDProperties;
typedef struct VkPhysicalDeviceLimits {
uint32_t maxImageDimension1D;
uint32_t maxImageDimension2D;
uint32_t maxImageDimension3D;
uint32_t maxImageDimensionCube;
uint32_t maxImageArrayLayers;
uint32_t maxTexelBufferElements;
uint32_t maxUniformBufferRange;
uint32_t maxStorageBufferRange;
uint32_t maxPushConstantsSize;
uint32_t maxMemoryAllocationCount;
uint32_t maxSamplerAllocationCount;
VkDeviceSize bufferImageGranularity;
VkDeviceSize sparseAddressSpaceSize;
uint32_t maxBoundDescriptorSets;
uint32_t maxPerStageDescriptorSamplers;
uint32_t maxPerStageDescriptorUniformBuffers;
uint32_t maxPerStageDescriptorStorageBuffers;
uint32_t maxPerStageDescriptorSampledImages;
uint32_t maxPerStageDescriptorStorageImages;
uint32_t maxPerStageDescriptorInputAttachments;
uint32_t maxPerStageResources;
uint32_t maxDescriptorSetSamplers;
uint32_t maxDescriptorSetUniformBuffers;
uint32_t maxDescriptorSetUniformBuffersDynamic;
uint32_t maxDescriptorSetStorageBuffers;
uint32_t maxDescriptorSetStorageBuffersDynamic;
uint32_t maxDescriptorSetSampledImages;
uint32_t maxDescriptorSetStorageImages;
uint32_t maxDescriptorSetInputAttachments;
uint32_t maxVertexInputAttributes;
uint32_t maxVertexInputBindings;
uint32_t maxVertexInputAttributeOffset;
uint32_t maxVertexInputBindingStride;
uint32_t maxVertexOutputComponents;
uint32_t maxTessellationGenerationLevel;
uint32_t maxTessellationPatchSize;
uint32_t
maxTessellationControlPerVertexInputComponents;
uint32_t
maxTessellationControlPerVertexOutputComponents;
uint32_t
maxTessellationControlPerPatchOutputComponents;
uint32_t maxTessellationControlTotalOutputComponents;
uint32_t maxTessellationEvaluationInputComponents;
uint32_t maxTessellationEvaluationOutputComponents;
uint32_t maxGeometryShaderInvocations;
uint32_t maxGeometryInputComponents;
uint32_t maxGeometryOutputComponents;
uint32_t maxGeometryOutputVertices;
uint32_t maxGeometryTotalOutputComponents;
uint32_t maxFragmentInputComponents;
uint32_t maxFragmentOutputAttachments;
uint32_t maxFragmentDualSrcAttachments;
uint32_t maxFragmentCombinedOutputResources;
uint32_t maxComputeSharedMemorySize;
uint32_t maxComputeWorkGroupCount[3];
uint32_t maxComputeWorkGroupInvocations;
uint32_t maxComputeWorkGroupSize[3];
uint32_t subPixelPrecisionBits;
uint32_t subTexelPrecisionBits;
uint32_t mipmapPrecisionBits;
uint32_t maxDrawIndexedIndexValue;
uint32_t maxDrawIndirectCount;
float maxSamplerLodBias;
float maxSamplerAnisotropy;
uint32_t maxViewports;
uint32_t maxViewportDimensions[2];
float viewportBoundsRange[2];
uint32_t viewportSubPixelBits;
size_t minMemoryMapAlignment;
VkDeviceSize minTexelBufferOffsetAlignment;
VkDeviceSize minUniformBufferOffsetAlignment;
VkDeviceSize minStorageBufferOffsetAlignment;

int32_t minTexelOffset;
uint32_t maxTexelOffset;
int32_t minTexelGatherOffset;
uint32_t maxTexelGatherOffset;
float minInterpolationOffset;
float maxInterpolationOffset;
uint32_t subPixelInterpolationOffsetBits;
uint32_t maxFramebufferWidth;
uint32_t maxFramebufferHeight;
uint32_t maxFramebufferLayers;
VkSampleCountFlags framebufferColorSampleCounts; P.15
VkSampleCountFlags framebufferDepthSampleCounts; P.15
VkSampleCountFlags framebufferStencilSampleCounts; P.15
VkSampleCountFlags
framebufferNoAttachmentsSampleCounts; P.15
uint32_t maxColorAttachments;
VkSampleCountFlags
sampledImageColorSampleCounts; P.15
VkSampleCountFlags
sampledImageIntegerSampleCounts; P.15
VkSampleCountFlags
sampledImageDepthSampleCounts; P.15
VkSampleCountFlags
sampledImageStencilSampleCounts; P.15
VkSampleCountFlags storageImageSampleCounts; P.15
uint32_t maxSampleMaskWords;
VkBool32 timestampComputeAndGraphics;
float timestampPeriod;
uint32_t maxClipDistances;
uint32_t maxCullDistances;
uint32_t maxCombinedClipAndCullDistances;
uint32_t discreteQueuePriorities;
float pointSizeRange[2];
float lineWidthRange[2];
float pointSizeGranularity;
float lineWidthGranularity;
VkBool32 strictLines;
VkBool32 standardSampleLocations;
VkDeviceSize optimalBufferCopyOffsetAlignment;
VkDeviceSize optimalBufferCopyRowPitchAlignment;
VkDeviceSize nonCoherentAtomSize;
} VkPhysicalDeviceLimits;
typedef struct VkPhysicalDeviceMaintenance3Properties {
VkStructureType sType; void* pNext;
uint32_t maxPerSetDescriptors;
VkDeviceSize maxMemoryAllocationSize;
} VkPhysicalDeviceMaintenance3Properties;
typedef struct VkPhysicalDeviceMemoryProperties {
uint32_t memoryTypeCount; VkMemoryType
memoryTypes[VK_MAX_MEMORY_TYPES]; P.14
uint32_t memoryHeapCount; VkMemoryHeap
memoryHeaps[VK_MAX_MEMORY_HEAPS]; P.13
} VkPhysicalDeviceMemoryProperties;
typedef struct VkPhysicalDeviceMultiviewFeatures {
VkStructureType sType; void* pNext;
VkBool32 multiview;
VkBool32 multiviewGeometryShader;
VkBool32 multiviewTessellationShader;
} VkPhysicalDeviceMultiviewFeatures;
typedef struct VkPhysicalDeviceMultiviewProperties {
VkStructureType sType; void* pNext;
uint32_t maxMultiviewViewCount;
uint32_t maxMultiviewInstanceIndex;
} VkPhysicalDeviceMultiviewProperties;
typedef struct VkPhysicalDevicePointClippingProperties {
VkStructureType sType; void* pNext;
VkPointClippingBehavior pointClippingBehavior;
} VkPhysicalDevicePointClippingProperties;
pointClippingBehavior:
VK_POINT_CLIPPING_BEHAVIOR_X where X is
ALL_CLIP_PLANES, USER_CLIP_PLANES_ONLY

typedef struct VkPhysicalDeviceProperties {
uint32_t apiVersion;
uint32_t driverVersion;
uint32_t vendorID;
uint32_t deviceID;
VkPhysicalDeviceType deviceType;
char deviceName[
VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
uint8_t pipelineCacheUUID[VK_UUID_SIZE];
VkPhysicalDeviceLimits limits; P.14
VkPhysicalDeviceSparseProperties sparseProperties; P.15
} VkPhysicalDeviceProperties;
deviceType:
VK_PHYSICAL_DEVICE_TYPE_X where X is
OTHER, INTEGRATED_GPU, DISCRETE_GPU,
VIRTUAL_GPU, CPU

Continued on next page >
www.khronos.org/vulkan

Vulkan 1.1 Quick Reference
Structures and Enumerations (continued)
typedef struct
VkPhysicalDeviceProtectedMemoryFeatures {
VkStructureType sType; void* pNext;
VkBool32 protectedMemory;
} VkPhysicalDeviceProtectedMemoryFeatures;
typedef struct
VkPhysicalDeviceProtectedMemoryProperties {
VkStructureType sType; void* pNext;
VkBool32 protectedNoFault;
} VkPhysicalDeviceProtectedMemoryProperties;
typedef struct
VkPhysicalDeviceSamplerYcbcrConversionFeatures {
VkStructureType sType; void* pNext;
VkBool32 samplerYcbcrConversion;
} VkPhysicalDeviceSamplerYcbcrConversionFeatures;
typedef struct
VkPhysicalDeviceShaderDrawParameterFeatures {
VkStructureType sType; void* pNext;
VkBool32 shaderDrawParameters;
} VkPhysicalDeviceShaderDrawParameterFeatures;
typedef struct VkPhysicalDeviceSparseProperties {
VkBool32 residencyStandard2DBlockShape;
VkBool32 residencyStandard2DMultisampleBlockShape;
VkBool32 residencyStandard3DBlockShape;
VkBool32 residencyAlignedMipSize;
VkBool32 residencyNonResidentStrict;
} VkPhysicalDeviceSparseProperties;
typedef struct VkPhysicalDeviceSubgroupProperties {
VkStructureType sType; void* pNext;
uint32_t subgroupSize;
VkShaderStageFlags supportedStages; P.15
VkSubgroupFeatureFlags supportedOperations;
VkBool32 quadOperationsInAllStages;
} VkPhysicalDeviceSubgroupProperties;
supportedOperations:
VK_SUBGROUP_FEATURE_X_BIT where X is
ARITHMETIC, BALLOT, BASIC, CLUSTERED, QUAD, SHUFFLE,
SHUFFLE_RELATIVE, VOTE

typedef struct VkPhysicalDeviceSurfaceInfo2KHR {
VkStructureType sType; const void* pNext;
VkSurfaceKHR surface;
} VkPhysicalDeviceSurfaceInfo2KHR;
typedef struct VkPhysicalDeviceVariablePointerFeatures {
VkStructureType sType; void* pNext;
VkBool32 variablePointersStorageBuffer;
VkBool32 variablePointers;
} VkPhysicalDeviceVariablePointerFeatures;
enum VkPipelineBindPoint:
VK_PIPELINE_BIND_POINT_COMPUTE,
VK_PIPELINE_BIND_POINT_GRAPHICS

enum VkPipelineCreateFlagBits:
VK_PIPELINE_CREATE_X where X is
DISABLE_OPTIMIZATION_BIT,
ALLOW_DERIVATIVES_BIT,
DERIVATIVE_BIT,
VIEW_INDEX_FROM_DEVICE_INDEX_BIT,
DISPATCH_BASE

typedef struct VkPipelineShaderStageCreateInfo {
VkStructureType sType; const void* pNext;
VkPipelineShaderStageCreateFlags flags; = 0
VkShaderStageFlagBits stage; P.15
VkShaderModule module;
const char* pName;
const VkSpecializationInfo* pSpecializationInfo; P.15
} VkPipelineShaderStageCreateInfo;
typedef struct VkSpecializationInfo {
uint32_t mapEntryCount;
const VkSpecializationMapEntry* pMapEntries; P.15
size_t dataSize; const void* pData;
} VkSpecializationInfo;
typedef struct VkSpecializationMapEntry {
uint32_t constantID;
uint32_t offset;
size_t size;
} VkSpecializationMapEntry;

Page 15
enum VkPipelineStageFlagBits:
VK_PIPELINE_STAGE_X_BIT where X is
TOP_OF_PIPE,
DRAW_INDIRECT,
VERTEX_[INPUT, SHADER],
TESSELLATION_[CONTROL,
EVALUATION]_SHADER,
[COMPUTE, GEOMETRY, FRAGMENT]_SHADER,
[EARLY, LATE]_FRAGMENT_TESTS,
COLOR_ATTACHMENT_OUTPUT,
TRANSFER, BOTTOM_OF_PIPE, HOST,
ALL_{GRAPHICS, COMMANDS}

typedef struct
VkPipelineTessellationDomainOriginStateCreateInfo{
VkStructureType sType; const void* pNext;
VkTessellationDomainOrigin domainOrigin;
} VkPipelineTessellationDomainOriginStateCreateInfo;
domainOrigin:
VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT
VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT

typedef struct VkProtectedSubmitInfo {
VkStructureType sType;
const void* pNext;
VkBool32 protectedSubmit;
} VkProtectedSubmitInfo;
enum VkQueryPipelineStatisticFlagBits:
VK_QUERY_PIPELINE_STATISTIC_X_BIT where X is
INPUT_ASSEMBLY_{VERTICES, PRIMITIVES},
VERTEX_SHADER_INVOCATIONS,
GEOMETRY_SHADER_{INVOCATIONS, PRIMITIVES},
CLIPPING_{INVOCATIONS, PRIMITIVES},
FRAGMENT_SHADER_INVOCATIONS,
TESSELLATION_CONTROL_SHADER_PATCHES,
TESSELLATION_EVALUATION_SHADER_INVOCATIONS,
COMPUTE_SHADER_INVOCATIONS

typedef struct VkRect2D {
VkOffset2D offset; P14
VkExtent2D extent; P.12
} VkRect2D;
typedef struct
VkRenderPassInputAttachmentAspectCreateInfo {
VkStructureType sType; const void* pNext;
uint32_t aspectReferenceCount;
const VkInputAttachmentAspectReference*
pAspectReferences; P.13
} VkRenderPassInputAttachmentAspectCreateInfo;
typedef struct VkRenderPassMultiviewCreateInfo {
VkStructureType sType; const void* pNext;
uint32_t subpassCount;
const uint32_t* pViewMasks;
uint32_t dependencyCount;
const int32_t* pViewOffsets;
uint32_t correlationMaskCount;
const uint32_t* pCorrelationMasks;
} VkRenderPassMultiviewCreateInfo;
enum VkSampleCountFlagBits:
VK_SAMPLE_COUNT_X_BIT where X is
1, 2, 4, 8, 16, 32, 64

typedef struct
VkSamplerYcbcrConversionImageFormatProperties {
VkStructureType sType; void* pNext;
uint32_t combinedImageSamplerDescriptorCount;
} VkSamplerYcbcrConversionImageFormatProperties;
typedef struct VkSamplerYcbcrConversionInfo {
VkStructureType sType; const void* pNext;
VkSamplerYcbcrConversion conversion;
} VkSamplerYcbcrConversionInfo

typedef struct VkSparseMemoryBind {
VkDeviceSize resourceOffset;
VkDeviceSize size;
VkDeviceMemory memory;
VkDeviceSize memoryOffset;
VkSparseMemoryBindFlags flags;
} VkSparseMemoryBind;
flags: VK_SPARSE_MEMORY_BIND_METADATA_BIT

typedef struct VkSurfaceCapabilitiesKHR {
uint32_t minImageCount;
uint32_t maxImageCount;
VkExtent2D currentExtent; P.12
VkExtent2D minImageExtent; P.12
VkExtent2D maxImageExtent; P.12
uint32_t maxImageArrayLayers;
VkSurfaceTransformFlagsKHR supportedTransforms; P.15
VkSurfaceTransformFlagBitsKHR currentTransform; P.15
VkCompositeAlphaFlagsKHR
supportedCompositeAlpha; P.12
VkImageUsageFlags supportedUsageFlags; P.13
} VkSurfaceCapabilitiesKHR;
enum VkCompositeAlphaFlagBitsKHR:
VK_COMPOSITE_ALPHA_X_BIT_KHR where X is
OPAQUE, PRE_MULTIPLIED, POST_MULTIPLIED, INHERIT

typedef struct VkSurfaceFormatKHR {
VkFormat format; P.13
VkColorSpaceKHR colorSpace;
} VkSurfaceFormatKHR;
colorSpace: VK_COLOR_SPACE_SRGB_NONLINEAR_KHR

enum VkSurfaceTransformFlagBitsKHR {
VK_SURFACE_TRANSFORM_X_BIT_KHR where X is
IDENTITY,
ROTATE_{90, 180, 270},
HORIZONTAL_MIRROR
HORIZONTAL_MIRROR_ROTATE_{90, 180, 270},
INHERIT

typedef struct VkViewport {
float x; float y;
float width; float height;
float minDepth; float maxDepth;
} VkViewport;

Learn more about Vulkan

Vulkan is maintained by the Khronos Group, a worldwide
consortium of organizations that work to create and maintain
key standards used across many industries. Visit Khronos
online for resources to help you use and master Vulkan:

Main Vulkan Resource Page:
khronos.org/vulkan/
Vulkan Registry:
khronos.org/registry/vulkan/
Forums:
forums.khronos.org
Reference Guides:
khronos.org/developers/reference-cards/
Courses:
khronos.org/developers/training/
Videos & Presentations:
khronos.org/developers/library/
Events:
khronos.org/news/events/
Khronos Blog:
khronos.org/blog/

enum VkShaderStageFlagBits:
VK_SHADER_STAGE_X where X is
{VERTEX, GEOMETRY, FRAGMENT, COMPUTE}_BIT,
TESSELLATION_CONTROL_BIT,
TESSELLATION_EVALUATION_BIT,
ALL_GRAPHICS, ALL

enum VkSharingMode:
VK_SHARING_MODE_EXCLUSIVE,
VK_SHARING_MODE_CONCURRENT

@thekhronosgroup
©2018 Khronos Group - Rev. 0318

khronos.org
www.khronos.org/vulkan

Vulkan 1.1 Quick Reference

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
Android Platform
Blending
Buffers
Cache Control
Clear Commands
Command Buffers
Command Funciton Pointers
Command Pools
Compute Pipelines
Copy Commands
Depth Bias
Depth Bounds
Descriptors, Resource
Devices
Dispatching Commands
Display Enumeration
Drawing Commands
Enumerations
Events
Extensions
Fences
Format Properties
Fragment Operations
Framebuffers
Graphics Pipelines

VkGr-VkP
9
8
5
2
7-8
1-2
1
1
3
8
8
8
6-7
1
8
9
8
12-15
2
10
2
11
8
3
3

I-R
Image Capabilities
Image Views
Images
Instances
Layers
Line Width
Memory Allocation
Pipeline Barriers
Pipeline Layouts
Pipelines
Queries
Queues
Rasterization
Render Pass
Resource Creation
Resource Descriptors
Return Codes

11
6
5
1
10
8
4
2
6
3-4
7
1
8
3
5-6
6-7
1

S-V
Samplers
Scissor Test
Semaphores
Shaders
Sparse Resources
Stencil Test
Structures
Synchronization
Timestamp Queries
Variables, Built-in
Vertex Input Description
Viewport

6
8
2
3
8-9
8
12-15
2
7
3
8
8

vkA - vkCl
vkAcquireNextImage*
VkAcquireNextImageInfoKHR
vkAllocateCommandBuffers
vkAllocateDescriptorSets
vkAllocateMemory
VkAndroidSurfaceCreateInfoKHR
VkApplicationInfo
VkAttachment*
vkBeginCommandBuffer
vkBind{Buffer, Image}Memory*
VkBindImageMemoryInfo
VkBindSparseInfo
VkBuffer[Image]Copy
VkBuffer[View]CreateInfo
VkBufferMemoryRequirementsInfo2
VkClear{Attachment, Rect}

10
10
2
7
4
9
1
3
2
6
6
9
8
5
6
7

vkCm
vkCmd{Set, Reset}Event
vkCmdBeginQuery
vkCmdBeginRenderPass
vkCmdBindDescriptorSets
vkCmdBindIndexBuffer

2
7
3
7
8

vkCmdBindPipeline
vkCmdBindVertexBuffers
vkCmdBlitImage
vkCmdClearAttachments
vkCmdClearColorImage
vkCmdClearDepthStencilImage
vkCmdCopyBuffer[ToImage]
vkCmdCopyImage[ToBuffer]
vkCmdCopyQueryPoolResults
vkCmdDispatch*
vkCmdDraw[Indirect]
vkCmdDrawIndexed[Indirect]
vkCmdEndQuery
vkCmdEndRenderPass
vkCmdExecuteCommands
vkCmdFillBuffer
vkCmdNextSubpass
vkCmdPipelineBarrier
vkCmdPushConstants
vkCmdResetQueryPool
vkCmdResolveImage
vkCmdSetBlendConstants
vkCmdSetDepthBias
vkCmdSetDepthBounds
vkCmdSetDeviceMask
vkCmdSetLineWidth
vkCmdSetScissor
vkCmdSetStencil{Compare, Write}Mask
vkCmdSetStencilReference
vkCmdSetViewport
vkCmdUpdateBuffer
vkCmdWaitEvents
vkCmdWriteTimestamp

4
8
8
7
7
7
8
8
7
8
8
8
7
3
2
8
3
2
7
7
8
8
8
8
2
8
8
8
8
8
8
2
7

VkCo - vkCr
VkCommandBuffer*
VkCommandPoolCreateInfo
VkComponentMapping
VkComputePipelineCreateInfo
VkCopyDescriptorSet
vkCreate{Event, Fence}
vkCreateAndroidSurfaceKHR
vkCreateBuffer[View]
vkCreateCommandPool
vkCreateComputePipelines
vkCreateDescriptorPool
vkCreateDescriptorSetLayout
vkCreateDescriptorUpdateTemplate
vkCreateDevice
vkCreateDisplayModeKHR
vkCreateDisplayPlaneSurfaceKHR
vkCreateFramebuffer
vkCreateGraphicsPipelines
vkCreateImage
vkCreateImageView
vkCreateInstance
vkCreatePipelineCache
vkCreatePipelineLayout
vkCreateQueryPool
vkCreateRenderPass
vkCreateSampler[YcbcrConversion]
vkCreateSemaphore
vkCreateShaderModule
vkCreateSharedSwapchainsKHR
vkCreateSwapchainKHR
vkCreateWaylandSurfaceKHR
vkCreateWin32SurfaceKHR
vkCreateXcbSurfaceKHR
vkCreateXlibSurfaceKHR

2
1
6
3
7
2
9
5
1
3
6
6
7
1
9
9
3
3
5
6
1
4
6
7
3
6
2
3
10
10
9
9
9
9

VkDesc - vkDest
VkDescriptor{Buffer, Image}Info
VkDescriptorPool*
VkDescriptorSetAllocateInfo
VkDescriptorSetLayoutSupport
VkDescriptorUpdateTemplate*
vkDestroy{Event, Fence}
vkDestroyBuffer[View]
vkDestroyCommandPool
vkDestroyDescriptorPool
vkDestroyDescriptorSetLayout
vkDestroyDescriptorUpdateTemplate

7
7
7
6
7
2
5
1
7
6
7

vkDestroyDevice
vkDestroyFramebuffer
vkDestroyImage[View]
vkDestroyInstance
vkDestroyPipeline[Cache]
vkDestroyPipelineLayout
vkDestroyQueryPool
vkDestroyRenderPass
vkDestroySampler[YcbcrConversion]
vkDestroySemaphore
vkDestroyShaderModule
vkDestroySurfaceKHR
vkDestroySwapchainKHR

1
3
6
1
4
6
7
3
6
2
3
9
10

VkDev - vkF
VkDevice[GroupDevice]CreateInfo
VkDeviceGroupPresentCapabilitiesKHR
VkDeviceGroupPresentInfoKHR
VkDeviceGroupSwapchainCreateInfoKHR
VkDeviceQueue[Create]Info*
vkDeviceWaitIdle
VkDispatchIndirectCommand
VkDisplayMode*
VkDisplayPlane*
VkDisplayPresentInfoKHR
VkDisplayPropertiesKHR
VkDisplaySurfaceCreateInfoKHR
VkDraw[Indexed]IndirectCommand
vkEndCommandBuffer
vkEnumerateDevice*
vkEnumerateInstance*
vkEnumerateInstanceVersion
vkEnumeratePhysicalDevice*
Vk{Event, Fence}CreateInfo
VkExtensionProperties
VkExternalBufferProperties
VkExternalFenceProperties
VkExternalSemaphoreProperties
vkFlushMappedMemoryRanges
VkFormatProperties*
VkFramebufferCreateInfo
vkFreeCommandBuffers
vkFreeDescriptorSets
vkFreeMemory

1
10
10
10
1
2
8
9
9
10
9
9
8
2
10
10
1
1
2
11
11
11
11
4
11
3
2
7
4

vkG
vkGet{Event, Fence}Status
2
vkGetBufferMemoryRequirements*
6
vkGetDescriptorSetLayoutSupport
6
vkGetDeviceGroupPeerMemoryFeatures
4
vkGetDeviceGroupPresentCapabilitiesKHR
10
vkGetDeviceGroupSurfacePresentModesKHR
10
vkGetDeviceMemoryCommitment
4
vkGetDeviceProcAddr
1
vkGetDeviceQueue*
1
vkGetDisplayModePropertiesKHR
9
vkGetDisplayPlaneCapabilitiesKHR
9
vkGetDisplayPlaneSupportedDisplaysKHR
9
vkGetImageMemoryRequirements*
6
vkGetImageSparseMemoryRequirements*
9
vkGetImageSubresourceLayout
5
vkGetInstanceProcAddr
1
vkGetPhysicalDeviceDisplay[Plane]PropertiesKHR 9
vkGetPhysicalDeviceExternalBufferProperties
11
vkGetPhysicalDeviceExternalFenceProperties
11
vkGetPhysicalDeviceExternalSemaphoreProperties 11
vkGetPhysicalDeviceFeatures*
11
vkGetPhysicalDeviceFormatProperties*
11
vkGetPhysicalDeviceImageFormatProperties*
11
vkGetPhysicalDeviceMemoryProperties*
4
vkGetPhysicalDevicePresentRectanglesKHR
10
vkGetPhysicalDeviceProperties*
1
vkGetPhysicalDeviceQueueFamilyProperties*
1
vkGetPhysicalDeviceSparseImageFormat*
8
vkGetPhysicalDeviceSurface*
10
vkGetPhysicalDeviceWaylandPresentationSupport* 10
vkGetPhysicalDeviceWin32PresentationSupport* 10
vkGetPhysicalDeviceXcbPresentationSupportKHR 10
vkGetPhysicalDeviceXlibPresentationSupportKHR 10
vkGetPipelineCacheData
4
vkGetQueryPoolResults
7
vkGetRenderAreaGranularity
3
vkGetSwapchain*
10

VkGraphicsPipelineCreateInfo
VkImageBlit
VkImageCopy
VkImageCreateInfo
VkImageFormatProperties*
VkImageMemoryRequirementsInfo2
VkImageResolve
VkImageSparseMemoryRequirementsInfo2
VkImageSubresource
VkImageSwapchainCreateInfoKHR
VkImageViewCreateInfo
VkInstanceCreateInfo
vkInvalidateMappedMemoryRanges
VkLayerProperties
vkMapMemory
VkMappedMemoryRange
VkMemoryAllocateInfo
vkMergePipelineCaches
VkPhysicalDeviceExternalBufferInfo
VkPhysicalDeviceExternalFenceInfo
VkPhysicalDeviceExternalSemaphoreInfo
VkPhysicalDevice[Group]Properties*
VkPhysicalDeviceImageFormatInfo2
VkPhysicalDeviceMemoryProperties2
VkPhysicalDeviceSparseImageFormatInfo2
VkPipelineCacheCreateInfo
VkPipelineColorBlend*
VkPipelineDepthStencilStateCreateInfo
VkPipelineDynamicStateCreateInfo
VkPipelineInputAssemblyStateCreateInfo
VkPipelineLayoutCreateInfo
VkPipelineMultisampleStateCreateInfo
VkPipelineRasterizationStateCreateInfo
VkPipelineTessellationStateCreateInfo
VkPipelineVertexInputStateCreateInfo
VkPipelineViewportStateCreateInfo

3
8
8
5
11
6
8
9
5
5
6
1
4
10
4
4
4
4
11
11
11
1
11
4
9
4
4
4
4
4
6
4
4
4
3
4

VkPr-VkSt
VkPresentInfoKHR
VkPresentRegion[s]KHR
VkPushConstantRange
VkQueryPoolCreateInfo
vkQueueBindSparse
VkQueueFamilyProperties*
vkQueuePresentKHR
vkQueueSubmit
vkQueueWaitIdle
VkRectLayerKHR
VkRenderPass{Begin, Create}Info
vkResetCommandBuffer
vkResetCommandPool
vkResetDescriptorPool
vkResetFences
VkSampler[YcbcrConversion]CreateInfo
VkSemaphoreCreateInfo
vk{Set, Reset}Event
VkShaderModuleCreateInfo
VkSharedPresentSurfaceCapabilitiesKHR
VkSparseBufferMemoryBindInfo
VkSparseImageFormatProperties*
VkSparseImage[Opaque]Memory*
VkStencilOpState

10
10
6
7
9
1
10
2
2
10
3
2
1
7
2
6
2
2
3
10
9
8
9
4

VkSu - W
VkSubmitInfo
VkSubpass*
VkSubresourceLayout
VkSurface*
VkSwapchainCreateInfoKHR
vkTrimCommandPool
vkUnmapMemory
vkUpdateDescriptorSet*
VkVertexInputAttributeDescription
VkVertexInputBindingDescription
vkWaitForFences
VkWaylandSurfaceCreateInfoKHR
VkWin32SurfaceCreateInfoKHR
VkWriteDescriptorSet
VkXcbSurfaceCreateInfoKHR
VkXlibSurfaceCreateInfoKHR
Wait Idle Operations
WSI (Window System Integration)

2
3
6
10
10
1
4
7
4
3
2
9
9
7
9
9
2
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. 0318

Reference guide production by Miller & Mattson www.millermattson.com

www.khronos.org/vulkan



---

Source Exif Data:

File Type                       : PDF
File Type Extension             : pdf
MIME Type                       : application/pdf
PDF Version                     : 1.5
Linearized                      : Yes
Language                        : en-US
Tagged PDF                      : Yes
XMP Toolkit                     : Adobe XMP Core 5.6-c143 79.161210, 2017/08/11-10:28:36
Create Date                     : 2018:03:05 12:46:32-08:00
Metadata Date                   : 2018:03:05 12:46:50-08:00
Modify Date                     : 2018:03:05 12:46:50-08:00
Creator Tool                    : Adobe InDesign CC 13.0 (Macintosh)
Instance ID                     : uuid:383ce6d9-d107-5a4b-8c3a-503823f627dc
Original Document ID            : xmp.did:3195D91657CDDD11841EF19E5A285EBE
Document ID                     : xmp.id:720c7adf-07ee-4530-8e03-f6cb13ec88f5
Rendition Class                 : proof:pdf
Derived From Instance ID        : xmp.iid:d50abfe0-ee42-475f-8453-64a73598abf0
Derived From Document ID        : xmp.did:8e3a7f5f-8d10-4040-a0a5-d662c28d9e96
Derived From Original Document ID: xmp.did:3195D91657CDDD11841EF19E5A285EBE
Derived From Rendition Class    : default
History Action                  : converted
History Parameters              : from application/x-indesign to application/pdf
History Software Agent          : Adobe InDesign CC 13.0 (Macintosh)
History Changed                 : /
History When                    : 2018:03:05 12:46:32-08:00
Format                          : application/pdf
Producer                        : Adobe PDF Library 15.0
Trapped                         : False
Page Layout                     : OneColumn
Page Count                      : 16
Creator                         : Adobe InDesign CC 13.0 (Macintosh)

EXIF Metadata provided by EXIF.tools