Copyright (c) 2015-2017 The Khronos Group Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
------------------------------------------------------------------------
This file, vk.xml, is the Vulkan API Registry. It is a critically important
and normative part of the Vulkan Specification, including a canonical
machine-readable definition of the API, parameter and member validation
language incorporated into the Specification and reference pages, and other
material which is registered by Khronos, such as tags used by extension and
layer authors. The authoritative public version of vk.xml is maintained in
the master branch of the Khronos Vulkan GitHub project. The authoritative
private version is maintained in the 1.0 branch of the member gitlab server.
#include "vk_platform.h"
WSI extensions
#include "vulkan.h"
#include <X11/Xlib.h>
#include <X11/extensions/Xrandr.h>
#include <android/native_window.h>
#include <mir_toolkit/client_types.h>
#include <wayland-client.h>
#include <windows.h>
#include <xcb/xcb.h>
#define VK_MAKE_VERSION(major, minor, patch) \
(((major) << 22) | ((minor) << 12) | (patch))
#define VK_VERSION_MAJOR(version) ((uint32_t)(version) >> 22)
#define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff)
#define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff)
// DEPRECATED: This define has been removed. Specific version defines (e.g. VK_API_VERSION_1_0), or the VK_MAKE_VERSION macro, should be used instead.
//#define VK_API_VERSION VK_MAKE_VERSION(1, 0, 0) // Patch version should always be set to 0
// Vulkan 1.0 version number
#define VK_API_VERSION_1_0 VK_MAKE_VERSION(1, 0, 0)// Patch version should always be set to 0
// Version of this file
#define VK_HEADER_VERSION 60
#define VK_DEFINE_HANDLE(object) typedef struct object##_T* object;
#if !defined(VK_DEFINE_NON_DISPATCHABLE_HANDLE)
#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
#define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object;
#else
#define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object;
#endif
#endif
#define VK_NULL_HANDLE 0
typedef uint32_t VkSampleMask;
typedef uint32_t VkBool32;
typedef uint32_t VkFlags;
typedef uint64_t VkDeviceSize;
Basic C types, pulled in via vk_platform.h
Bitmask types
typedef VkFlags VkFramebufferCreateFlags;
typedef VkFlags VkQueryPoolCreateFlags;
typedef VkFlags VkRenderPassCreateFlags;
typedef VkFlags VkSamplerCreateFlags;
typedef VkFlags VkPipelineLayoutCreateFlags;
typedef VkFlags VkPipelineCacheCreateFlags;
typedef VkFlags VkPipelineDepthStencilStateCreateFlags;
typedef VkFlags VkPipelineDynamicStateCreateFlags;
typedef VkFlags VkPipelineColorBlendStateCreateFlags;
typedef VkFlags VkPipelineMultisampleStateCreateFlags;
typedef VkFlags VkPipelineRasterizationStateCreateFlags;
typedef VkFlags VkPipelineViewportStateCreateFlags;
typedef VkFlags VkPipelineTessellationStateCreateFlags;
typedef VkFlags VkPipelineInputAssemblyStateCreateFlags;
typedef VkFlags VkPipelineVertexInputStateCreateFlags;
typedef VkFlags VkPipelineShaderStageCreateFlags;
typedef VkFlags VkDescriptorSetLayoutCreateFlags;
typedef VkFlags VkBufferViewCreateFlags;
typedef VkFlags VkInstanceCreateFlags;
typedef VkFlags VkDeviceCreateFlags;
typedef VkFlags VkDeviceQueueCreateFlags;
typedef VkFlags VkQueueFlags;
typedef VkFlags VkMemoryPropertyFlags;
typedef VkFlags VkMemoryHeapFlags;
typedef VkFlags VkAccessFlags;
typedef VkFlags VkBufferUsageFlags;
typedef VkFlags VkBufferCreateFlags;
typedef VkFlags VkShaderStageFlags;
typedef VkFlags VkImageUsageFlags;
typedef VkFlags VkImageCreateFlags;
typedef VkFlags VkImageViewCreateFlags;
typedef VkFlags VkPipelineCreateFlags;
typedef VkFlags VkColorComponentFlags;
typedef VkFlags VkFenceCreateFlags;
typedef VkFlags VkSemaphoreCreateFlags;
typedef VkFlags VkFormatFeatureFlags;
typedef VkFlags VkQueryControlFlags;
typedef VkFlags VkQueryResultFlags;
typedef VkFlags VkShaderModuleCreateFlags;
typedef VkFlags VkEventCreateFlags;
typedef VkFlags VkCommandPoolCreateFlags;
typedef VkFlags VkCommandPoolResetFlags;
typedef VkFlags VkCommandBufferResetFlags;
typedef VkFlags VkCommandBufferUsageFlags;
typedef VkFlags VkQueryPipelineStatisticFlags;
typedef VkFlags VkMemoryMapFlags;
typedef VkFlags VkImageAspectFlags;
typedef VkFlags VkSparseMemoryBindFlags;
typedef VkFlags VkSparseImageFormatFlags;
typedef VkFlags VkSubpassDescriptionFlags;
typedef VkFlags VkPipelineStageFlags;
typedef VkFlags VkSampleCountFlags;
typedef VkFlags VkAttachmentDescriptionFlags;
typedef VkFlags VkStencilFaceFlags;
typedef VkFlags VkCullModeFlags;
typedef VkFlags VkDescriptorPoolCreateFlags;
typedef VkFlags VkDescriptorPoolResetFlags;
typedef VkFlags VkDependencyFlags;
typedef VkFlags VkIndirectCommandsLayoutUsageFlagsNVX;
typedef VkFlags VkObjectEntryUsageFlagsNVX;
typedef VkFlags VkDescriptorUpdateTemplateCreateFlagsKHR;
WSI extensions
typedef VkFlags VkCompositeAlphaFlagsKHR;
typedef VkFlags VkDisplayPlaneAlphaFlagsKHR;
typedef VkFlags VkSurfaceTransformFlagsKHR;
typedef VkFlags VkSwapchainCreateFlagsKHR;
typedef VkFlags VkDisplayModeCreateFlagsKHR;
typedef VkFlags VkDisplaySurfaceCreateFlagsKHR;
typedef VkFlags VkAndroidSurfaceCreateFlagsKHR;
typedef VkFlags VkMirSurfaceCreateFlagsKHR;
typedef VkFlags VkViSurfaceCreateFlagsNN;
typedef VkFlags VkWaylandSurfaceCreateFlagsKHR;
typedef VkFlags VkWin32SurfaceCreateFlagsKHR;
typedef VkFlags VkXlibSurfaceCreateFlagsKHR;
typedef VkFlags VkXcbSurfaceCreateFlagsKHR;
typedef VkFlags VkIOSSurfaceCreateFlagsMVK;
typedef VkFlags VkMacOSSurfaceCreateFlagsMVK;
typedef VkFlags VkPeerMemoryFeatureFlagsKHX;
typedef VkFlags VkMemoryAllocateFlagsKHX;
typedef VkFlags VkDeviceGroupPresentModeFlagsKHX;
typedef VkFlags VkDebugReportFlagsEXT;
typedef VkFlags VkCommandPoolTrimFlagsKHR;
typedef VkFlags VkExternalMemoryHandleTypeFlagsNV;
typedef VkFlags VkExternalMemoryFeatureFlagsNV;
typedef VkFlags VkExternalMemoryHandleTypeFlagsKHR;
typedef VkFlags VkExternalMemoryFeatureFlagsKHR;
typedef VkFlags VkExternalSemaphoreHandleTypeFlagsKHR;
typedef VkFlags VkExternalSemaphoreFeatureFlagsKHR;
typedef VkFlags VkSemaphoreImportFlagsKHR;
typedef VkFlags VkExternalFenceHandleTypeFlagsKHR;
typedef VkFlags VkExternalFenceFeatureFlagsKHR;
typedef VkFlags VkFenceImportFlagsKHR;
typedef VkFlags VkSurfaceCounterFlagsEXT;
typedef VkFlags VkPipelineViewportSwizzleStateCreateFlagsNV;
typedef VkFlags VkPipelineDiscardRectangleStateCreateFlagsEXT;
typedef VkFlags VkPipelineCoverageToColorStateCreateFlagsNV;
typedef VkFlags VkPipelineCoverageModulationStateCreateFlagsNV;
typedef VkFlags VkValidationCacheCreateFlagsEXT;
Types which can be void pointers or class pointers, selected at compile time
VK_DEFINE_HANDLE(VkInstance)
VK_DEFINE_HANDLE(VkPhysicalDevice)
VK_DEFINE_HANDLE(VkDevice)
VK_DEFINE_HANDLE(VkQueue)
VK_DEFINE_HANDLE(VkCommandBuffer)
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory)
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool)
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer)
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView)
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage)
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView)
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule)
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline)
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout)
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler)
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet)
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout)
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool)
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence)
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore)
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent)
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool)
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer)
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass)
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache)
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkObjectTableNVX)
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutNVX)
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorUpdateTemplateKHR)
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkValidationCacheEXT)
WSI extensions
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR)
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR)
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR)
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR)
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT)
Types generated from corresponding enums tags below
Extensions
WSI extensions
The PFN_vk*Function types are used by VkAllocationCallbacks below
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);
typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)(
void* pUserData,
void* pOriginal,
size_t size,
size_t alignment,
VkSystemAllocationScope allocationScope);
typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)(
void* pUserData,
size_t size,
size_t alignment,
VkSystemAllocationScope allocationScope);
typedef void (VKAPI_PTR *PFN_vkFreeFunction)(
void* pUserData,
void* pMemory);
The PFN_vkVoidFunction type are used by VkGet*ProcAddr below
typedef void (VKAPI_PTR *PFN_vkVoidFunction)(void);
The PFN_vkDebugReportCallbackEXT type are used by the DEBUG_REPORT extension
typedef VkBool32 (VKAPI_PTR *PFN_vkDebugReportCallbackEXT)(
VkDebugReportFlagsEXT flags,
VkDebugReportObjectTypeEXT objectType,
uint64_t object,
size_t location,
int32_t messageCode,
const char* pLayerPrefix,
const char* pMessage,
void* pUserData);
Struct types
int32_t x
int32_t y
int32_t x
int32_t y
int32_t z
uint32_t width
uint32_t height
uint32_t width
uint32_t height
uint32_t depth
float x
float y
float width
float height
float minDepth
float maxDepth
VkOffset2D offset
VkExtent2D extent
VkOffset3D offset
VkExtent3D extent
VkRect2D rect
uint32_t baseArrayLayer
uint32_t layerCount
VkComponentSwizzle r
VkComponentSwizzle g
VkComponentSwizzle b
VkComponentSwizzle a
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
VkPhysicalDeviceSparseProperties sparseProperties
char extensionName[VK_MAX_EXTENSION_NAME_SIZE]extension name
uint32_t specVersionversion of the extension specification implemented
char layerName[VK_MAX_EXTENSION_NAME_SIZE]layer name
uint32_t specVersionversion of the layer specification implemented
uint32_t implementationVersionbuild or release version of the layer's library
char description[VK_MAX_DESCRIPTION_SIZE]Free-form description of the layer
VkStructureType sType
const void* pNext
const char* pApplicationName
uint32_t applicationVersion
const char* pEngineName
uint32_t engineVersion
uint32_t apiVersion
void* pUserData
PFN_vkAllocationFunction pfnAllocation
PFN_vkReallocationFunction pfnReallocation
PFN_vkFreeFunction pfnFree
PFN_vkInternalAllocationNotification pfnInternalAllocation
PFN_vkInternalFreeNotification pfnInternalFree
VkStructureType sType
const void* pNext
VkDeviceQueueCreateFlags flags
uint32_t queueFamilyIndex
uint32_t queueCount
const float* pQueuePriorities
VkStructureType sType
const void* pNext
VkDeviceCreateFlags flags
uint32_t queueCreateInfoCount
const VkDeviceQueueCreateInfo* pQueueCreateInfos
uint32_t enabledLayerCount
const char* const* ppEnabledLayerNamesOrdered list of layer names to be enabled
uint32_t enabledExtensionCount
const char* const* ppEnabledExtensionNames
const VkPhysicalDeviceFeatures* pEnabledFeatures
VkStructureType sType
const void* pNext
VkInstanceCreateFlags flags
const VkApplicationInfo* pApplicationInfo
uint32_t enabledLayerCount
const char* const* ppEnabledLayerNamesOrdered list of layer names to be enabled
uint32_t enabledExtensionCount
const char* const* ppEnabledExtensionNamesExtension names to be enabled
VkQueueFlags queueFlagsQueue flags
uint32_t queueCount
uint32_t timestampValidBits
VkExtent3D minImageTransferGranularityMinimum alignment requirement for image transfers
uint32_t memoryTypeCount
VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES]
uint32_t memoryHeapCount
VkMemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS]
VkStructureType sType
const void* pNext
VkDeviceSize allocationSizeSize of memory allocation
uint32_t memoryTypeIndexIndex of the of the memory type to allocate from
VkDeviceSize sizeSpecified in bytes
VkDeviceSize alignmentSpecified in bytes
uint32_t memoryTypeBitsBitmask of the allowed memory type indices into memoryTypes[] for this object
VkImageAspectFlags aspectMask
VkExtent3D imageGranularity
VkSparseImageFormatFlags flags
VkSparseImageFormatProperties formatProperties
uint32_t imageMipTailFirstLod
VkDeviceSize imageMipTailSizeSpecified in bytes, must be a multiple of sparse block size in bytes / alignment
VkDeviceSize imageMipTailOffsetSpecified in bytes, must be a multiple of sparse block size in bytes / alignment
VkDeviceSize imageMipTailStrideSpecified in bytes, must be a multiple of sparse block size in bytes / alignment
VkMemoryPropertyFlags propertyFlagsMemory properties of this memory type
uint32_t heapIndexIndex of the memory heap allocations of this memory type are taken from
VkDeviceSize sizeAvailable memory in the heap
VkMemoryHeapFlags flagsFlags for the heap
VkStructureType sType
const void* pNext
VkDeviceMemory memoryMapped memory object
VkDeviceSize offsetOffset within the memory object where the range starts
VkDeviceSize sizeSize of the range within the memory object
VkFormatFeatureFlags linearTilingFeaturesFormat features in case of linear tiling
VkFormatFeatureFlags optimalTilingFeaturesFormat features in case of optimal tiling
VkFormatFeatureFlags bufferFeaturesFormat features supported by buffers
VkExtent3D maxExtentmax image dimensions for this resource type
uint32_t maxMipLevelsmax number of mipmap levels for this resource type
uint32_t maxArrayLayersmax array size for this resource type
VkSampleCountFlags sampleCountssupported sample counts for this resource type
VkDeviceSize maxResourceSizemax size (in bytes) of this resource type
VkBuffer bufferBuffer used for this descriptor slot when the descriptor is UNIFORM_BUFFER[_DYNAMIC] or STORAGE_BUFFER[_DYNAMIC]. VK_NULL_HANDLE otherwise.
VkDeviceSize offsetBase offset from buffer start in bytes to update in the descriptor set.
VkDeviceSize rangeSize in bytes of the buffer resource for this descriptor update.
VkSampler samplerSampler to write to the descriptor in case it is a SAMPLER or COMBINED_IMAGE_SAMPLER descriptor. Ignored otherwise.
VkImageView imageViewImage view to write to the descriptor in case it is a SAMPLED_IMAGE, STORAGE_IMAGE, COMBINED_IMAGE_SAMPLER, or INPUT_ATTACHMENT descriptor. Ignored otherwise.
VkImageLayout imageLayoutLayout the image is expected to be in when accessed using this descriptor (only used if imageView is not VK_NULL_HANDLE).
VkStructureType sType
const void* pNext
VkDescriptorSet dstSetDestination descriptor set
uint32_t dstBindingBinding within the destination descriptor set to write
uint32_t dstArrayElementArray element within the destination binding to write
uint32_t descriptorCountNumber of descriptors to write (determines the size of the array pointed by pDescriptors)
VkDescriptorType descriptorTypeDescriptor type to write (determines which members of the array pointed by pDescriptors are going to be used)
const VkDescriptorImageInfo* pImageInfoSampler, image view, and layout for SAMPLER, COMBINED_IMAGE_SAMPLER, {SAMPLED,STORAGE}_IMAGE, and INPUT_ATTACHMENT descriptor types.
const VkDescriptorBufferInfo* pBufferInfoRaw buffer, size, and offset for {UNIFORM,STORAGE}_BUFFER[_DYNAMIC] descriptor types.
const VkBufferView* pTexelBufferViewBuffer view to write to the descriptor for {UNIFORM,STORAGE}_TEXEL_BUFFER descriptor types.
VkStructureType sType
const void* pNext
VkDescriptorSet srcSetSource descriptor set
uint32_t srcBindingBinding within the source descriptor set to copy from
uint32_t srcArrayElementArray element within the source binding to copy from
VkDescriptorSet dstSetDestination descriptor set
uint32_t dstBindingBinding within the destination descriptor set to copy to
uint32_t dstArrayElementArray element within the destination binding to copy to
uint32_t descriptorCountNumber of descriptors to write (determines the size of the array pointed by pDescriptors)
VkStructureType sType
const void* pNext
VkBufferCreateFlags flagsBuffer creation flags
VkDeviceSize sizeSpecified in bytes
VkBufferUsageFlags usageBuffer usage flags
VkSharingMode sharingMode
uint32_t queueFamilyIndexCount
const uint32_t* pQueueFamilyIndices
VkStructureType sType
const void* pNext
VkBufferViewCreateFlagsflags
VkBuffer buffer
VkFormat formatOptionally specifies format of elements
VkDeviceSize offsetSpecified in bytes
VkDeviceSize rangeView size specified in bytes
VkImageAspectFlags aspectMask
uint32_t mipLevel
uint32_t arrayLayer
VkImageAspectFlags aspectMask
uint32_t mipLevel
uint32_t baseArrayLayer
uint32_t layerCount
VkImageAspectFlags aspectMask
uint32_t baseMipLevel
uint32_t levelCount
uint32_t baseArrayLayer
uint32_t layerCount
VkStructureType sType
const void* pNext
VkAccessFlags srcAccessMaskMemory accesses from the source of the dependency to synchronize
VkAccessFlags dstAccessMaskMemory accesses from the destination of the dependency to synchronize
VkStructureType sType
const void* pNext
VkAccessFlags srcAccessMaskMemory accesses from the source of the dependency to synchronize
VkAccessFlags dstAccessMaskMemory accesses from the destination of the dependency to synchronize
uint32_t srcQueueFamilyIndexQueue family to transition ownership from
uint32_t dstQueueFamilyIndexQueue family to transition ownership to
VkBuffer bufferBuffer to sync
VkDeviceSize offsetOffset within the buffer to sync
VkDeviceSize sizeAmount of bytes to sync
VkStructureType sType
const void* pNext
VkAccessFlags srcAccessMaskMemory accesses from the source of the dependency to synchronize
VkAccessFlags dstAccessMaskMemory accesses from the destination of the dependency to synchronize
VkImageLayout oldLayoutCurrent layout of the image
VkImageLayout newLayoutNew layout to transition the image to
uint32_t srcQueueFamilyIndexQueue family to transition ownership from
uint32_t dstQueueFamilyIndexQueue family to transition ownership to
VkImage imageImage to sync
VkImageSubresourceRange subresourceRangeSubresource range to sync
VkStructureType sType
const void* pNext
VkImageCreateFlags flagsImage creation flags
VkImageType imageType
VkFormat format
VkExtent3D extent
uint32_t mipLevels
uint32_t arrayLayers
VkSampleCountFlagBits samples
VkImageTiling tiling
VkImageUsageFlags usageImage usage flags
VkSharingMode sharingModeCross-queue-family sharing mode
uint32_t queueFamilyIndexCountNumber of queue families to share across
const uint32_t* pQueueFamilyIndicesArray of queue family indices to share across
VkImageLayout initialLayoutInitial image layout for all subresources
VkDeviceSize offsetSpecified in bytes
VkDeviceSize sizeSpecified in bytes
VkDeviceSize rowPitchSpecified in bytes
VkDeviceSize arrayPitchSpecified in bytes
VkDeviceSize depthPitchSpecified in bytes
VkStructureType sType
const void* pNext
VkImageViewCreateFlags flags
VkImage image
VkImageViewType viewType
VkFormat format
VkComponentMapping components
VkImageSubresourceRange subresourceRange
VkDeviceSize srcOffsetSpecified in bytes
VkDeviceSize dstOffsetSpecified in bytes
VkDeviceSize sizeSpecified in bytes
VkDeviceSize resourceOffsetSpecified in bytes
VkDeviceSize sizeSpecified in bytes
VkDeviceMemory memory
VkDeviceSize memoryOffsetSpecified in bytes
VkSparseMemoryBindFlagsflags
VkImageSubresource subresource
VkOffset3D offset
VkExtent3D extent
VkDeviceMemory memory
VkDeviceSize memoryOffsetSpecified in bytes
VkSparseMemoryBindFlagsflags
VkBuffer buffer
uint32_t bindCount
const VkSparseMemoryBind* pBinds
VkImage image
uint32_t bindCount
const VkSparseMemoryBind* pBinds
VkImage image
uint32_t bindCount
const VkSparseImageMemoryBind* pBinds
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
VkImageSubresourceLayers srcSubresource
VkOffset3D srcOffsetSpecified in pixels for both compressed and uncompressed images
VkImageSubresourceLayers dstSubresource
VkOffset3D dstOffsetSpecified in pixels for both compressed and uncompressed images
VkExtent3D extentSpecified in pixels for both compressed and uncompressed images
VkImageSubresourceLayers srcSubresource
VkOffset3D srcOffsets[2]Specified in pixels for both compressed and uncompressed images
VkImageSubresourceLayers dstSubresource
VkOffset3D dstOffsets[2]Specified in pixels for both compressed and uncompressed images
VkDeviceSize bufferOffsetSpecified in bytes
uint32_t bufferRowLengthSpecified in texels
uint32_t bufferImageHeight
VkImageSubresourceLayers imageSubresource
VkOffset3D imageOffsetSpecified in pixels for both compressed and uncompressed images
VkExtent3D imageExtentSpecified in pixels for both compressed and uncompressed images
VkImageSubresourceLayers srcSubresource
VkOffset3D srcOffset
VkImageSubresourceLayers dstSubresource
VkOffset3D dstOffset
VkExtent3D extent
VkStructureType sType
const void* pNext
VkShaderModuleCreateFlags flags
size_t codeSizeSpecified in bytes
const uint32_t* pCodeBinary code of size codeSize
uint32_t bindingBinding number for this entry
VkDescriptorType descriptorTypeType of the descriptors in this binding
uint32_t descriptorCountNumber of descriptors in this binding
VkShaderStageFlags stageFlagsShader stages this binding is visible to
const VkSampler* pImmutableSamplersImmutable samplers (used if descriptor type is SAMPLER or COMBINED_IMAGE_SAMPLER, is either NULL or contains count number of elements)
VkStructureType sType
const void* pNext
VkDescriptorSetLayoutCreateFlags flags
uint32_t bindingCountNumber of bindings in the descriptor set layout
const VkDescriptorSetLayoutBinding* pBindingsArray of descriptor set layout bindings
VkDescriptorType type
uint32_t descriptorCount
VkStructureType sType
const void* pNext
VkDescriptorPoolCreateFlags flags
uint32_t maxSets
uint32_t poolSizeCount
const VkDescriptorPoolSize* pPoolSizes
VkStructureType sType
const void* pNext
VkDescriptorPool descriptorPool
uint32_t descriptorSetCount
const VkDescriptorSetLayout* pSetLayouts
uint32_t constantIDThe SpecConstant ID specified in the BIL
uint32_t offsetOffset of the value in the data block
size_t sizeSize in bytes of the SpecConstant
uint32_t mapEntryCountNumber of entries in the map
const VkSpecializationMapEntry* pMapEntriesArray of map entries
size_t dataSizeSize in bytes of pData
const void* pDataPointer to SpecConstant data
VkStructureType sType
const void* pNext
VkPipelineShaderStageCreateFlags flags
VkShaderStageFlagBits stageShader stage
VkShaderModule moduleModule containing entry point
const char* pNameNull-terminated entry point name
const VkSpecializationInfo* pSpecializationInfo
VkStructureType sType
const void* pNext
VkPipelineCreateFlags flagsPipeline creation flags
VkPipelineShaderStageCreateInfo stage
VkPipelineLayout layoutInterface layout of the pipeline
VkPipeline basePipelineHandleIf VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of
int32_t basePipelineIndexIf VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of
uint32_t bindingVertex buffer binding id
uint32_t strideDistance between vertices in bytes (0 = no advancement)
VkVertexInputRate inputRateThe rate at which the vertex data is consumed
uint32_t locationlocation of the shader vertex attrib
uint32_t bindingVertex buffer binding id
VkFormat formatformat of source data
uint32_t offsetOffset of first element in bytes from base of vertex
VkStructureType sType
const void* pNext
VkPipelineVertexInputStateCreateFlags flags
uint32_t vertexBindingDescriptionCountnumber of bindings
const VkVertexInputBindingDescription* pVertexBindingDescriptions
uint32_t vertexAttributeDescriptionCountnumber of attributes
const VkVertexInputAttributeDescription* pVertexAttributeDescriptions
VkStructureType sType
const void* pNext
VkPipelineInputAssemblyStateCreateFlags flags
VkPrimitiveTopology topology
VkBool32 primitiveRestartEnable
VkStructureType sType
const void* pNext
VkPipelineTessellationStateCreateFlags flags
uint32_t patchControlPoints
VkStructureType sType
const void* pNext
VkPipelineViewportStateCreateFlags flags
uint32_t viewportCount
const VkViewport* pViewports
uint32_t scissorCount
const VkRect2D* pScissors
VkStructureType sType
const void* pNext
VkPipelineRasterizationStateCreateFlags flags
VkBool32 depthClampEnable
VkBool32 rasterizerDiscardEnable
VkPolygonMode polygonModeoptional (GL45)
VkCullModeFlags cullMode
VkFrontFace frontFace
VkBool32 depthBiasEnable
float depthBiasConstantFactor
float depthBiasClamp
float depthBiasSlopeFactor
float lineWidth
VkStructureType sType
const void* pNext
VkPipelineMultisampleStateCreateFlags flags
VkSampleCountFlagBits rasterizationSamplesNumber of samples used for rasterization
VkBool32 sampleShadingEnableoptional (GL45)
float minSampleShadingoptional (GL45)
const VkSampleMask* pSampleMaskArray of sampleMask words
VkBool32 alphaToCoverageEnable
VkBool32 alphaToOneEnable
VkBool32 blendEnable
VkBlendFactor srcColorBlendFactor
VkBlendFactor dstColorBlendFactor
VkBlendOp colorBlendOp
VkBlendFactor srcAlphaBlendFactor
VkBlendFactor dstAlphaBlendFactor
VkBlendOp alphaBlendOp
VkColorComponentFlags colorWriteMask
VkStructureType sType
const void* pNext
VkPipelineColorBlendStateCreateFlags flags
VkBool32 logicOpEnable
VkLogicOp logicOp
uint32_t attachmentCount# of pAttachments
const VkPipelineColorBlendAttachmentState* pAttachments
float blendConstants[4]
VkStructureType sType
const void* pNext
VkPipelineDynamicStateCreateFlags flags
uint32_t dynamicStateCount
const VkDynamicState* pDynamicStates
VkStencilOp failOp
VkStencilOp passOp
VkStencilOp depthFailOp
VkCompareOp compareOp
uint32_t compareMask
uint32_t writeMask
uint32_t reference
VkStructureType sType
const void* pNext
VkPipelineDepthStencilStateCreateFlags flags
VkBool32 depthTestEnable
VkBool32 depthWriteEnable
VkCompareOp depthCompareOp
VkBool32 depthBoundsTestEnableoptional (depth_bounds_test)
VkBool32 stencilTestEnable
VkStencilOpState front
VkStencilOpState back
float minDepthBounds
float maxDepthBounds
VkStructureType sType
const void* pNext
VkPipelineCreateFlags flagsPipeline creation flags
uint32_t stageCount
const VkPipelineShaderStageCreateInfo* pStagesOne entry for each active shader stage
const VkPipelineVertexInputStateCreateInfo* pVertexInputState
const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState
const VkPipelineTessellationStateCreateInfo* pTessellationState
const VkPipelineViewportStateCreateInfo* pViewportState
const VkPipelineRasterizationStateCreateInfo* pRasterizationState
const VkPipelineMultisampleStateCreateInfo* pMultisampleState
const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState
const VkPipelineColorBlendStateCreateInfo* pColorBlendState
const VkPipelineDynamicStateCreateInfo* pDynamicState
VkPipelineLayout layoutInterface layout of the pipeline
VkRenderPass renderPass
uint32_t subpass
VkPipeline basePipelineHandleIf VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of
int32_t basePipelineIndexIf VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of
VkStructureType sType
const void* pNext
VkPipelineCacheCreateFlags flags
size_t initialDataSizeSize of initial data to populate cache, in bytes
const void* pInitialDataInitial data to populate cache
VkShaderStageFlags stageFlagsWhich stages use the range
uint32_t offsetStart of the range, in bytes
uint32_t sizeSize of the range, in bytes
VkStructureType sType
const void* pNext
VkPipelineLayoutCreateFlags flags
uint32_t setLayoutCountNumber of descriptor sets interfaced by the pipeline
const VkDescriptorSetLayout* pSetLayoutsArray of setCount number of descriptor set layout objects defining the layout of the
uint32_t pushConstantRangeCountNumber of push-constant ranges used by the pipeline
const VkPushConstantRange* pPushConstantRangesArray of pushConstantRangeCount number of ranges used by various shader stages
VkStructureType sType
const void* pNext
VkSamplerCreateFlags flags
VkFilter magFilterFilter mode for magnification
VkFilter minFilterFilter mode for minifiation
VkSamplerMipmapMode mipmapModeMipmap selection mode
VkSamplerAddressMode addressModeU
VkSamplerAddressMode addressModeV
VkSamplerAddressMode addressModeW
float mipLodBias
VkBool32 anisotropyEnable
float maxAnisotropy
VkBool32 compareEnable
VkCompareOp compareOp
float minLod
float maxLod
VkBorderColor borderColor
VkBool32 unnormalizedCoordinates
VkStructureType sType
const void* pNext
VkCommandPoolCreateFlags flagsCommand pool creation flags
uint32_t queueFamilyIndex
VkStructureType sType
const void* pNext
VkCommandPool commandPool
VkCommandBufferLevel level
uint32_t commandBufferCount
VkStructureType sType
const void* pNext
VkRenderPass renderPassRender pass for secondary command buffers
uint32_t subpass
VkFramebuffer framebufferFramebuffer for secondary command buffers
VkBool32 occlusionQueryEnableWhether this secondary command buffer may be executed during an occlusion query
VkQueryControlFlags queryFlagsQuery flags used by this secondary command buffer, if executed during an occlusion query
VkQueryPipelineStatisticFlags pipelineStatisticsPipeline statistics that may be counted for this secondary command buffer
VkStructureType sType
const void* pNext
VkCommandBufferUsageFlags flagsCommand buffer usage flags
const VkCommandBufferInheritanceInfo* pInheritanceInfoPointer to inheritance info for secondary command buffers
VkStructureType sType
const void* pNext
VkRenderPass renderPass
VkFramebuffer framebuffer
VkRect2D renderArea
uint32_t clearValueCount
const VkClearValue* pClearValues
float float32[4]
int32_t int32[4]
uint32_t uint32[4]
float depth
uint32_t stencil
VkClearColorValue color
VkClearDepthStencilValue depthStencil
VkImageAspectFlags aspectMask
uint32_t colorAttachment
VkClearValue clearValue
VkAttachmentDescriptionFlags flags
VkFormat format
VkSampleCountFlagBits samples
VkAttachmentLoadOp loadOpLoad operation for color or depth data
VkAttachmentStoreOp storeOpStore operation for color or depth data
VkAttachmentLoadOp stencilLoadOpLoad operation for stencil data
VkAttachmentStoreOp stencilStoreOpStore operation for stencil data
VkImageLayout initialLayout
VkImageLayout finalLayout
uint32_t attachment
VkImageLayout layout
VkSubpassDescriptionFlags flags
VkPipelineBindPoint pipelineBindPointMust be VK_PIPELINE_BIND_POINT_GRAPHICS for now
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
uint32_t srcSubpass
uint32_t dstSubpass
VkPipelineStageFlags srcStageMask
VkPipelineStageFlags dstStageMask
VkAccessFlags srcAccessMaskMemory accesses from the source of the dependency to synchronize
VkAccessFlags dstAccessMaskMemory accesses from the destination of the dependency to synchronize
VkDependencyFlags dependencyFlags
VkStructureType sType
const void* pNext
VkRenderPassCreateFlags flags
uint32_t attachmentCount
const VkAttachmentDescription* pAttachments
uint32_t subpassCount
const VkSubpassDescription* pSubpasses
uint32_t dependencyCount
const VkSubpassDependency* pDependencies
VkStructureType sType
const void* pNext
VkEventCreateFlags flagsEvent creation flags
VkStructureType sType
const void* pNext
VkFenceCreateFlags flagsFence creation flags
VkBool32 robustBufferAccessout of bounds buffer accesses are well defined
VkBool32 fullDrawIndexUint32full 32-bit range of indices for indexed draw calls
VkBool32 imageCubeArrayimage views which are arrays of cube maps
VkBool32 independentBlendblending operations are controlled per-attachment
VkBool32 geometryShadergeometry stage
VkBool32 tessellationShadertessellation control and evaluation stage
VkBool32 sampleRateShadingper-sample shading and interpolation
VkBool32 dualSrcBlendblend operations which take two sources
VkBool32 logicOplogic operations
VkBool32 multiDrawIndirectmulti draw indirect
VkBool32 drawIndirectFirstInstanceindirect draws can use non-zero firstInstance
VkBool32 depthClampdepth clamping
VkBool32 depthBiasClampdepth bias clamping
VkBool32 fillModeNonSolidpoint and wireframe fill modes
VkBool32 depthBoundsdepth bounds test
VkBool32 wideLineslines with width greater than 1
VkBool32 largePointspoints with size greater than 1
VkBool32 alphaToOnethe fragment alpha component can be forced to maximum representable alpha value
VkBool32 multiViewportviewport arrays
VkBool32 samplerAnisotropyanisotropic sampler filtering
VkBool32 textureCompressionETC2ETC texture compression formats
VkBool32 textureCompressionASTC_LDRASTC LDR texture compression formats
VkBool32 textureCompressionBCBC1-7 texture compressed formats
VkBool32 occlusionQueryPreciseprecise occlusion queries returning actual sample counts
VkBool32 pipelineStatisticsQuerypipeline statistics query
VkBool32 vertexPipelineStoresAndAtomicsstores and atomic ops on storage buffers and images are supported in vertex, tessellation, and geometry stages
VkBool32 fragmentStoresAndAtomicsstores and atomic ops on storage buffers and images are supported in the fragment stage
VkBool32 shaderTessellationAndGeometryPointSizetessellation and geometry stages can export point size
VkBool32 shaderImageGatherExtendedimage gather with run-time values and independent offsets
VkBool32 shaderStorageImageExtendedFormatsthe extended set of formats can be used for storage images
VkBool32 shaderStorageImageMultisamplemultisample images can be used for storage images
VkBool32 shaderStorageImageReadWithoutFormatread from storage image does not require format qualifier
VkBool32 shaderStorageImageWriteWithoutFormatwrite to storage image does not require format qualifier
VkBool32 shaderUniformBufferArrayDynamicIndexingarrays of uniform buffers can be accessed with dynamically uniform indices
VkBool32 shaderSampledImageArrayDynamicIndexingarrays of sampled images can be accessed with dynamically uniform indices
VkBool32 shaderStorageBufferArrayDynamicIndexingarrays of storage buffers can be accessed with dynamically uniform indices
VkBool32 shaderStorageImageArrayDynamicIndexingarrays of storage images can be accessed with dynamically uniform indices
VkBool32 shaderClipDistanceclip distance in shaders
VkBool32 shaderCullDistancecull distance in shaders
VkBool32 shaderFloat6464-bit floats (doubles) in shaders
VkBool32 shaderInt6464-bit integers in shaders
VkBool32 shaderInt1616-bit integers in shaders
VkBool32 shaderResourceResidencyshader can use texture operations that return resource residency information (requires sparseNonResident support)
VkBool32 shaderResourceMinLodshader can use texture operations that specify minimum resource level of detail
VkBool32 sparseBindingSparse resources support: Resource memory can be managed at opaque page level rather than object level
VkBool32 sparseResidencyBufferSparse resources support: GPU can access partially resident buffers
VkBool32 sparseResidencyImage2DSparse resources support: GPU can access partially resident 2D (non-MSAA non-depth/stencil) images
VkBool32 sparseResidencyImage3DSparse resources support: GPU can access partially resident 3D images
VkBool32 sparseResidency2SamplesSparse resources support: GPU can access partially resident MSAA 2D images with 2 samples
VkBool32 sparseResidency4SamplesSparse resources support: GPU can access partially resident MSAA 2D images with 4 samples
VkBool32 sparseResidency8SamplesSparse resources support: GPU can access partially resident MSAA 2D images with 8 samples
VkBool32 sparseResidency16SamplesSparse resources support: GPU can access partially resident MSAA 2D images with 16 samples
VkBool32 sparseResidencyAliasedSparse resources support: GPU can correctly access data aliased into multiple locations (opt-in)
VkBool32 variableMultisampleRatemultisample rate must be the same for all pipelines in a subpass
VkBool32 inheritedQueriesQueries may be inherited from primary to secondary command buffers
VkBool32 residencyStandard2DBlockShapeSparse resources support: GPU will access all 2D (single sample) sparse resources using the standard sparse image block shapes (based on pixel format)
VkBool32 residencyStandard2DMultisampleBlockShapeSparse resources support: GPU will access all 2D (multisample) sparse resources using the standard sparse image block shapes (based on pixel format)
VkBool32 residencyStandard3DBlockShapeSparse resources support: GPU will access all 3D sparse resources using the standard sparse image block shapes (based on pixel format)
VkBool32 residencyAlignedMipSizeSparse resources support: Images with mip level dimensions that are NOT a multiple of the sparse image block dimensions will be placed in the mip tail
VkBool32 residencyNonResidentStrictSparse resources support: GPU can consistently access non-resident regions of a resource, all reads return as if data is 0, writes are discarded
resource maximum sizes
uint32_t maxImageDimension1Dmax 1D image dimension
uint32_t maxImageDimension2Dmax 2D image dimension
uint32_t maxImageDimension3Dmax 3D image dimension
uint32_t maxImageDimensionCubemax cubemap image dimension
uint32_t maxImageArrayLayersmax layers for image arrays
uint32_t maxTexelBufferElementsmax texel buffer size (fstexels)
uint32_t maxUniformBufferRangemax uniform buffer range (bytes)
uint32_t maxStorageBufferRangemax storage buffer range (bytes)
uint32_t maxPushConstantsSizemax size of the push constants pool (bytes)
memory limits
uint32_t maxMemoryAllocationCountmax number of device memory allocations supported
uint32_t maxSamplerAllocationCountmax number of samplers that can be allocated on a device
VkDeviceSize bufferImageGranularityGranularity (in bytes) at which buffers and images can be bound to adjacent memory for simultaneous usage
VkDeviceSize sparseAddressSpaceSizeTotal address space available for sparse allocations (bytes)
descriptor set limits
uint32_t maxBoundDescriptorSetsmax number of descriptors sets that can be bound to a pipeline
uint32_t maxPerStageDescriptorSamplersmax number of samplers allowed per-stage in a descriptor set
uint32_t maxPerStageDescriptorUniformBuffersmax number of uniform buffers allowed per-stage in a descriptor set
uint32_t maxPerStageDescriptorStorageBuffersmax number of storage buffers allowed per-stage in a descriptor set
uint32_t maxPerStageDescriptorSampledImagesmax number of sampled images allowed per-stage in a descriptor set
uint32_t maxPerStageDescriptorStorageImagesmax number of storage images allowed per-stage in a descriptor set
uint32_t maxPerStageDescriptorInputAttachmentsmax number of input attachments allowed per-stage in a descriptor set
uint32_t maxPerStageResourcesmax number of resources allowed by a single stage
uint32_t maxDescriptorSetSamplersmax number of samplers allowed in all stages in a descriptor set
uint32_t maxDescriptorSetUniformBuffersmax number of uniform buffers allowed in all stages in a descriptor set
uint32_t maxDescriptorSetUniformBuffersDynamicmax number of dynamic uniform buffers allowed in all stages in a descriptor set
uint32_t maxDescriptorSetStorageBuffersmax number of storage buffers allowed in all stages in a descriptor set
uint32_t maxDescriptorSetStorageBuffersDynamicmax number of dynamic storage buffers allowed in all stages in a descriptor set
uint32_t maxDescriptorSetSampledImagesmax number of sampled images allowed in all stages in a descriptor set
uint32_t maxDescriptorSetStorageImagesmax number of storage images allowed in all stages in a descriptor set
uint32_t maxDescriptorSetInputAttachmentsmax number of input attachments allowed in all stages in a descriptor set
vertex stage limits
uint32_t maxVertexInputAttributesmax number of vertex input attribute slots
uint32_t maxVertexInputBindingsmax number of vertex input binding slots
uint32_t maxVertexInputAttributeOffsetmax vertex input attribute offset added to vertex buffer offset
uint32_t maxVertexInputBindingStridemax vertex input binding stride
uint32_t maxVertexOutputComponentsmax number of output components written by vertex shader
tessellation control stage limits
uint32_t maxTessellationGenerationLevelmax level supported by tessellation primitive generator
uint32_t maxTessellationPatchSizemax patch size (vertices)
uint32_t maxTessellationControlPerVertexInputComponentsmax number of input components per-vertex in TCS
uint32_t maxTessellationControlPerVertexOutputComponentsmax number of output components per-vertex in TCS
uint32_t maxTessellationControlPerPatchOutputComponentsmax number of output components per-patch in TCS
uint32_t maxTessellationControlTotalOutputComponentsmax total number of per-vertex and per-patch output components in TCS
tessellation evaluation stage limits
uint32_t maxTessellationEvaluationInputComponentsmax number of input components per vertex in TES
uint32_t maxTessellationEvaluationOutputComponentsmax number of output components per vertex in TES
geometry stage limits
uint32_t maxGeometryShaderInvocationsmax invocation count supported in geometry shader
uint32_t maxGeometryInputComponentsmax number of input components read in geometry stage
uint32_t maxGeometryOutputComponentsmax number of output components written in geometry stage
uint32_t maxGeometryOutputVerticesmax number of vertices that can be emitted in geometry stage
uint32_t maxGeometryTotalOutputComponentsmax total number of components (all vertices) written in geometry stage
fragment stage limits
uint32_t maxFragmentInputComponentsmax number of input compontents read in fragment stage
uint32_t maxFragmentOutputAttachmentsmax number of output attachments written in fragment stage
uint32_t maxFragmentDualSrcAttachmentsmax number of output attachments written when using dual source blending
uint32_t maxFragmentCombinedOutputResourcesmax total number of storage buffers, storage images and output buffers
compute stage limits
uint32_t maxComputeSharedMemorySizemax total storage size of work group local storage (bytes)
uint32_t maxComputeWorkGroupCount[3]max num of compute work groups that may be dispatched by a single command (x,y,z)
uint32_t maxComputeWorkGroupInvocationsmax total compute invocations in a single local work group
uint32_t maxComputeWorkGroupSize[3]max local size of a compute work group (x,y,z)
uint32_t subPixelPrecisionBitsnumber bits of subpixel precision in screen x and y
uint32_t subTexelPrecisionBitsnumber bits of precision for selecting texel weights
uint32_t mipmapPrecisionBitsnumber bits of precision for selecting mipmap weights
uint32_t maxDrawIndexedIndexValuemax index value for indexed draw calls (for 32-bit indices)
uint32_t maxDrawIndirectCountmax draw count for indirect draw calls
float maxSamplerLodBiasmax absolute sampler level of detail bias
float maxSamplerAnisotropymax degree of sampler anisotropy
uint32_t maxViewportsmax number of active viewports
uint32_t maxViewportDimensions[2]max viewport dimensions (x,y)
float viewportBoundsRange[2]viewport bounds range (min,max)
uint32_t viewportSubPixelBitsnumber bits of subpixel precision for viewport
size_t minMemoryMapAlignmentmin required alignment of pointers returned by MapMemory (bytes)
VkDeviceSize minTexelBufferOffsetAlignmentmin required alignment for texel buffer offsets (bytes)
VkDeviceSize minUniformBufferOffsetAlignmentmin required alignment for uniform buffer sizes and offsets (bytes)
VkDeviceSize minStorageBufferOffsetAlignmentmin required alignment for storage buffer offsets (bytes)
int32_t minTexelOffsetmin texel offset for OpTextureSampleOffset
uint32_t maxTexelOffsetmax texel offset for OpTextureSampleOffset
int32_t minTexelGatherOffsetmin texel offset for OpTextureGatherOffset
uint32_t maxTexelGatherOffsetmax texel offset for OpTextureGatherOffset
float minInterpolationOffsetfurthest negative offset for interpolateAtOffset
float maxInterpolationOffsetfurthest positive offset for interpolateAtOffset
uint32_t subPixelInterpolationOffsetBitsnumber of subpixel bits for interpolateAtOffset
uint32_t maxFramebufferWidthmax width for a framebuffer
uint32_t maxFramebufferHeightmax height for a framebuffer
uint32_t maxFramebufferLayersmax layer count for a layered framebuffer
VkSampleCountFlags framebufferColorSampleCountssupported color sample counts for a framebuffer
VkSampleCountFlags framebufferDepthSampleCountssupported depth sample counts for a framebuffer
VkSampleCountFlags framebufferStencilSampleCountssupported stencil sample counts for a framebuffer
VkSampleCountFlags framebufferNoAttachmentsSampleCountssupported sample counts for a framebuffer with no attachments
uint32_t maxColorAttachmentsmax number of color attachments per subpass
VkSampleCountFlags sampledImageColorSampleCountssupported color sample counts for a non-integer sampled image
VkSampleCountFlags sampledImageIntegerSampleCountssupported sample counts for an integer image
VkSampleCountFlags sampledImageDepthSampleCountssupported depth sample counts for a sampled image
VkSampleCountFlags sampledImageStencilSampleCountssupported stencil sample counts for a sampled image
VkSampleCountFlags storageImageSampleCountssupported sample counts for a storage image
uint32_t maxSampleMaskWordsmax number of sample mask words
VkBool32 timestampComputeAndGraphicstimestamps on graphics and compute queues
float timestampPeriodnumber of nanoseconds it takes for timestamp query value to increment by 1
uint32_t maxClipDistancesmax number of clip distances
uint32_t maxCullDistancesmax number of cull distances
uint32_t maxCombinedClipAndCullDistancesmax combined number of user clipping
uint32_t discreteQueuePrioritiesdistinct queue priorities available
float pointSizeRange[2]range (min,max) of supported point sizes
float lineWidthRange[2]range (min,max) of supported line widths
float pointSizeGranularitygranularity of supported point sizes
float lineWidthGranularitygranularity of supported line widths
VkBool32 strictLinesline rasterization follows preferred rules
VkBool32 standardSampleLocationssupports standard sample locations for all supported sample counts
VkDeviceSize optimalBufferCopyOffsetAlignmentoptimal offset of buffer copies
VkDeviceSize optimalBufferCopyRowPitchAlignmentoptimal pitch of buffer copies
VkDeviceSize nonCoherentAtomSizeminimum size and alignment for non-coherent host-mapped device memory access
VkStructureType sType
const void* pNext
VkSemaphoreCreateFlags flagsSemaphore creation flags
VkStructureType sType
const void* pNext
VkQueryPoolCreateFlags flags
VkQueryType queryType
uint32_t queryCount
VkQueryPipelineStatisticFlags pipelineStatisticsOptional
VkStructureType sType
const void* pNext
VkFramebufferCreateFlags flags
VkRenderPass renderPass
uint32_t attachmentCount
const VkImageView* pAttachments
uint32_t width
uint32_t height
uint32_t layers
uint32_t vertexCount
uint32_t instanceCount
uint32_t firstVertex
uint32_t firstInstance
uint32_t indexCount
uint32_t instanceCount
uint32_t firstIndex
int32_t vertexOffset
uint32_t firstInstance
uint32_t x
uint32_t y
uint32_t z
VkStructureType sType
const void* pNext
uint32_t waitSemaphoreCount
const VkSemaphore* pWaitSemaphores
const VkPipelineStageFlags* pWaitDstStageMask
uint32_t commandBufferCount
const VkCommandBuffer* pCommandBuffers
uint32_t signalSemaphoreCount
const VkSemaphore* pSignalSemaphores
WSI extensions
VkDisplayKHR displayHandle of the display object
const char* displayNameName of the display
VkExtent2D physicalDimensionsIn millimeters?
VkExtent2D physicalResolutionMax resolution for CRT?
VkSurfaceTransformFlagsKHR supportedTransformsone or more bits from VkSurfaceTransformFlagsKHR
VkBool32 planeReorderPossibleVK_TRUE if the overlay plane's z-order can be changed on this display.
VkBool32 persistentContentVK_TRUE if this is a "smart" display that supports self-refresh/internal buffering.
VkDisplayKHR currentDisplayDisplay the plane is currently associated with. Will be VK_NULL_HANDLE if the plane is not in use.
uint32_t currentStackIndexCurrent z-order of the plane.
VkExtent2D visibleRegionVisible scanout region.
uint32_t refreshRateNumber of times per second the display is updated.
VkDisplayModeKHR displayModeHandle of this display mode.
VkDisplayModeParametersKHR parametersThe parameters this mode uses.
VkStructureType sType
const void* pNext
VkDisplayModeCreateFlagsKHR flags
VkDisplayModeParametersKHR parametersThe parameters this mode uses.
VkDisplayPlaneAlphaFlagsKHR supportedAlphaTypes of alpha blending supported, if any.
VkOffset2D minSrcPositionDoes the plane have any position and extent restrictions?
VkOffset2D maxSrcPosition
VkExtent2D minSrcExtent
VkExtent2D maxSrcExtent
VkOffset2D minDstPosition
VkOffset2D maxDstPosition
VkExtent2D minDstExtent
VkExtent2D maxDstExtent
VkStructureType sType
const void* pNext
VkDisplaySurfaceCreateFlagsKHR flags
VkDisplayModeKHR displayModeThe mode to use when displaying this surface
uint32_t planeIndexThe plane on which this surface appears. Must be between 0 and the value returned by vkGetPhysicalDeviceDisplayPlanePropertiesKHR() in pPropertyCount.
uint32_t planeStackIndexThe z-order of the plane.
VkSurfaceTransformFlagBitsKHR transformTransform to apply to the images as part of the scanout operation
float globalAlphaGlobal alpha value. Must be between 0 and 1, inclusive. Ignored if alphaMode is not VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR
VkDisplayPlaneAlphaFlagBitsKHR alphaModeWhat type of alpha blending to use. Must be a bit from vkGetDisplayPlanePropertiesKHR::supportedAlpha.
VkExtent2D imageExtentsize of the images to use with this surface
VkStructureType sType
const void* pNext
VkRect2D srcRectRectangle within the presentable image to read pixel data from when presenting to the display.
VkRect2D dstRectRectangle within the current display mode's visible region to display srcRectangle in.
VkBool32 persistentFor smart displays, use buffered mode. If the display properties member "persistentMode" is VK_FALSE, this member must always be VK_FALSE.
uint32_t minImageCountSupported minimum number of images for the surface
uint32_t maxImageCountSupported maximum number of images for the surface, 0 for unlimited
VkExtent2D currentExtentCurrent image width and height for the surface, (0, 0) if undefined
VkExtent2D minImageExtentSupported minimum image width and height for the surface
VkExtent2D maxImageExtentSupported maximum image width and height for the surface
uint32_t maxImageArrayLayersSupported maximum number of image layers for the surface
VkSurfaceTransformFlagsKHR supportedTransforms1 or more bits representing the transforms supported
VkSurfaceTransformFlagBitsKHR currentTransformThe surface's current transform relative to the device's natural orientation
VkCompositeAlphaFlagsKHR supportedCompositeAlpha1 or more bits representing the alpha compositing modes supported
VkImageUsageFlags supportedUsageFlagsSupported image usage flags for the surface
VkStructureType sType
const void* pNext
VkAndroidSurfaceCreateFlagsKHR flags
ANativeWindow* window
VkStructureType sType
const void* pNext
VkMirSurfaceCreateFlagsKHR flags
MirConnection* connection
MirSurface* mirSurface
VkStructureType sType
const void* pNext
VkViSurfaceCreateFlagsNN flags
void* window
VkStructureType sType
const void* pNext
VkWaylandSurfaceCreateFlagsKHR flags
struct wl_display* display
struct wl_surface* surface
VkStructureType sType
const void* pNext
VkWin32SurfaceCreateFlagsKHR flags
HINSTANCE hinstance
HWND hwnd
VkStructureType sType
const void* pNext
VkXlibSurfaceCreateFlagsKHR flags
Display* dpy
Window window
VkStructureType sType
const void* pNext
VkXcbSurfaceCreateFlagsKHR flags
xcb_connection_t* connection
xcb_window_t window
VkFormat formatSupported pair of rendering format
VkColorSpaceKHR colorSpaceand color space for the surface
VkStructureType sType
const void* pNext
VkSwapchainCreateFlagsKHR flags
VkSurfaceKHR surfaceThe swapchain's target surface
uint32_t minImageCountMinimum number of presentation images the application needs
VkFormat imageFormatFormat of the presentation images
VkColorSpaceKHR imageColorSpaceColorspace of the presentation images
VkExtent2D imageExtentDimensions of the presentation images
uint32_t imageArrayLayersDetermines the number of views for multiview/stereo presentation
VkImageUsageFlags imageUsageBits indicating how the presentation images will be used
VkSharingMode imageSharingModeSharing mode used for the presentation images
uint32_t queueFamilyIndexCountNumber of queue families having access to the images in case of concurrent sharing mode
const uint32_t* pQueueFamilyIndicesArray of queue family indices having access to the images in case of concurrent sharing mode
VkSurfaceTransformFlagBitsKHR preTransformThe transform, relative to the device's natural orientation, applied to the image content prior to presentation
VkCompositeAlphaFlagBitsKHR compositeAlphaThe alpha blending mode used when compositing this surface with other surfaces in the window system
VkPresentModeKHR presentModeWhich presentation mode to use for presents on this swap chain
VkBool32 clippedSpecifies whether presentable images may be affected by window clip regions
VkSwapchainKHR oldSwapchainExisting swap chain to replace, if any
VkStructureType sType
const void* pNext
uint32_t waitSemaphoreCountNumber of semaphores to wait for before presenting
const VkSemaphore* pWaitSemaphoresSemaphores to wait for before presenting
uint32_t swapchainCountNumber of swapchains to present in this call
const VkSwapchainKHR* pSwapchainsSwapchains to present an image from
const uint32_t* pImageIndicesIndices of which presentable images to present
VkResult* pResultsOptional (i.e. if non-NULL) VkResult for each swapchain
VkStructureType sType
const void* pNext
VkDebugReportFlagsEXT flagsIndicates which events call this callback
PFN_vkDebugReportCallbackEXT pfnCallbackFunction pointer of a callback function
void* pUserDataUser data provided to callback function
VkStructureType sTypeMust be VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT
const void* pNext
uint32_t disabledValidationCheckCountNumber of validation checks to disable
VkValidationCheckEXT* pDisabledValidationChecksValidation checks to disable
VkStructureType sType
const void* pNext
VkRasterizationOrderAMD rasterizationOrderRasterization order to use for the pipeline
VkStructureType sType
const void* pNext
VkDebugReportObjectTypeEXT objectTypeThe type of the object
uint64_t objectThe handle of the object, cast to uint64_t
const char* pObjectNameName to apply to the object
VkStructureType sType
const void* pNext
VkDebugReportObjectTypeEXT objectTypeThe type of the object
uint64_t objectThe handle of the object, cast to uint64_t
uint64_t tagNameThe name of the tag to set on the object
size_t tagSizeThe length in bytes of the tag data
const void* pTagTag data to attach to the object
VkStructureType sType
const void* pNext
const char* pMarkerNameName of the debug marker
float color[4]Optional color for debug marker
VkStructureType sType
const void* pNext
VkBool32 dedicatedAllocationWhether this image uses a dedicated allocation
VkStructureType sType
const void* pNext
VkBool32 dedicatedAllocationWhether this buffer uses a dedicated allocation
VkStructureType sType
const void* pNext
VkImage imageImage that this allocation will be bound to
VkBuffer bufferBuffer that this allocation will be bound to
VkImageFormatProperties imageFormatProperties
VkExternalMemoryFeatureFlagsNV externalMemoryFeatures
VkExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes
VkExternalMemoryHandleTypeFlagsNV compatibleHandleTypes
VkStructureType sType
const void* pNext
VkExternalMemoryHandleTypeFlagsNV handleTypes
VkStructureType sType
const void* pNext
VkExternalMemoryHandleTypeFlagsNV handleTypes
VkStructureType sType
const void* pNext
VkExternalMemoryHandleTypeFlagsNV handleType
HANDLE handle
VkStructureType sType
const void* pNext
const SECURITY_ATTRIBUTES* pAttributes
DWORD dwAccess
VkStructureType sType
const void* pNext
uint32_t acquireCount
const VkDeviceMemory* pAcquireSyncs
const uint64_t* pAcquireKeys
const uint32_t* pAcquireTimeoutMilliseconds
uint32_t releaseCount
const VkDeviceMemory* pReleaseSyncs
const uint64_t* pReleaseKeys
VkStructureType sType
const void* pNext
VkBool32 computeBindingPointSupport
VkStructureType sType
const void* pNext
uint32_t maxIndirectCommandsLayoutTokenCount
uint32_t maxObjectEntryCounts
uint32_t minSequenceCountBufferOffsetAlignment
uint32_t minSequenceIndexBufferOffsetAlignment
uint32_t minCommandsTokenBufferOffsetAlignment
VkIndirectCommandsTokenTypeNVX tokenType
VkBuffer bufferbuffer containing tableEntries and additional data for indirectCommands
VkDeviceSize offsetoffset from the base address of the buffer
VkIndirectCommandsTokenTypeNVX tokenType
uint32_t bindingUnitBinding unit for vertex attribute / descriptor set, offset for pushconstants
uint32_t dynamicCountNumber of variable dynamic values for descriptor set / push constants
uint32_t divisorRate the which the array is advanced per element (must be power of 2, minimum 1)
VkStructureType sType
const void* pNext
VkPipelineBindPoint pipelineBindPoint
VkIndirectCommandsLayoutUsageFlagsNVX flags
uint32_t tokenCount
const VkIndirectCommandsLayoutTokenNVX* pTokens
VkStructureType sType
const void* pNext
VkObjectTableNVX objectTable
VkIndirectCommandsLayoutNVX indirectCommandsLayout
uint32_t indirectCommandsTokenCount
const VkIndirectCommandsTokenNVX* pIndirectCommandsTokens
uint32_t maxSequencesCount
VkCommandBuffer targetCommandBuffer
VkBuffer sequencesCountBuffer
VkDeviceSize sequencesCountOffset
VkBuffer sequencesIndexBuffer
VkDeviceSize sequencesIndexOffset
VkStructureType sType
const void* pNext
VkObjectTableNVX objectTable
VkIndirectCommandsLayoutNVX indirectCommandsLayout
uint32_t maxSequencesCount
VkStructureType sType
const void* pNext
uint32_t objectCount
const VkObjectEntryTypeNVX* pObjectEntryTypes
const uint32_t* pObjectEntryCounts
const VkObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags
uint32_t maxUniformBuffersPerDescriptor
uint32_t maxStorageBuffersPerDescriptor
uint32_t maxStorageImagesPerDescriptor
uint32_t maxSampledImagesPerDescriptor
uint32_t maxPipelineLayouts
VkObjectEntryTypeNVX type
VkObjectEntryUsageFlagsNVX flags
VkObjectEntryTypeNVX type
VkObjectEntryUsageFlagsNVX flags
VkPipeline pipeline
VkObjectEntryTypeNVX type
VkObjectEntryUsageFlagsNVX flags
VkPipelineLayout pipelineLayout
VkDescriptorSet descriptorSet
VkObjectEntryTypeNVX type
VkObjectEntryUsageFlagsNVX flags
VkBuffer buffer
VkObjectEntryTypeNVX type
VkObjectEntryUsageFlagsNVX flags
VkBuffer buffer
VkIndexType indexType
VkObjectEntryTypeNVX type
VkObjectEntryUsageFlagsNVX flags
VkPipelineLayout pipelineLayout
VkShaderStageFlags stageFlags
VkStructureType sType
void* pNext
VkPhysicalDeviceFeatures features
VkStructureType sType
void* pNext
VkPhysicalDeviceProperties properties
VkStructureType sType
void* pNext
VkFormatProperties formatProperties
VkStructureType sType
void* pNext
VkImageFormatProperties imageFormatProperties
VkStructureType sType
const void* pNext
VkFormat format
VkImageType type
VkImageTiling tiling
VkImageUsageFlags usage
VkImageCreateFlags flags
VkStructureType sType
void* pNext
VkQueueFamilyProperties queueFamilyProperties
VkStructureType sType
void* pNext
VkPhysicalDeviceMemoryProperties memoryProperties
VkStructureType sType
void* pNext
VkSparseImageFormatProperties properties
VkStructureType sType
const void* pNext
VkFormat format
VkImageType type
VkSampleCountFlagBits samples
VkImageUsageFlags usage
VkImageTiling tiling
VkStructureType sType
void* pNext
uint32_t maxPushDescriptors
VkStructureType sType
const void* pNext
uint32_t swapchainCountCopy of VkPresentInfoKHR::swapchainCount
const VkPresentRegionKHR* pRegionsThe regions that have changed
uint32_t rectangleCountNumber of rectangles in pRectangles
const VkRectLayerKHR* pRectanglesArray of rectangles that have changed in a swapchain's image(s)
VkOffset2D offsetupper-left corner of a rectangle that has not changed, in pixels of a presentation images
VkExtent2D extentDimensions of a rectangle that has not changed, in pixels of a presentation images
uint32_t layerLayer of a swapchain's image(s), for stereoscopic-3D images
VkStructureType sType
void* pNext
VkBool32 variablePointersStorageBuffer
VkBool32 variablePointers
VkExternalMemoryFeatureFlagsKHR externalMemoryFeatures
VkExternalMemoryHandleTypeFlagsKHR exportFromImportedHandleTypes
VkExternalMemoryHandleTypeFlagsKHR compatibleHandleTypes
VkStructureType sType
const void* pNext
VkExternalMemoryHandleTypeFlagBitsKHR handleType
VkStructureType sType
void* pNext
VkExternalMemoryPropertiesKHR externalMemoryProperties
VkStructureType sType
const void* pNext
VkBufferCreateFlags flags
VkBufferUsageFlags usage
VkExternalMemoryHandleTypeFlagBitsKHR handleType
VkStructureType sType
void* pNext
VkExternalMemoryPropertiesKHR externalMemoryProperties
VkStructureType sType
void* pNext
uint8_t deviceUUID[VK_UUID_SIZE]
uint8_t driverUUID[VK_UUID_SIZE]
uint8_t deviceLUID[VK_LUID_SIZE_KHR]
uint32_t deviceNodeMask
VkBool32 deviceLUIDValid
VkStructureType sType
const void* pNext
VkExternalMemoryHandleTypeFlagsKHR handleTypes
VkStructureType sType
const void* pNext
VkExternalMemoryHandleTypeFlagsKHR handleTypes
VkStructureType sType
const void* pNext
VkExternalMemoryHandleTypeFlagsKHR handleTypes
VkStructureType sType
const void* pNext
VkExternalMemoryHandleTypeFlagBitsKHR handleType
HANDLE handle
LPCWSTR name
VkStructureType sType
const void* pNext
const SECURITY_ATTRIBUTES* pAttributes
DWORD dwAccess
LPCWSTR name
VkStructureType sType
void* pNext
uint32_t memoryTypeBits
VkStructureType sType
const void* pNext
VkDeviceMemory memory
VkExternalMemoryHandleTypeFlagBitsKHR handleType
VkStructureType sType
const void* pNext
VkExternalMemoryHandleTypeFlagBitsKHR handleType
int fd
VkStructureType sType
void* pNext
uint32_t memoryTypeBits
VkStructureType sType
const void* pNext
VkDeviceMemory memory
VkExternalMemoryHandleTypeFlagBitsKHR handleType
VkStructureType sType
const void* pNext
uint32_t acquireCount
const VkDeviceMemory* pAcquireSyncs
const uint64_t* pAcquireKeys
const uint32_t* pAcquireTimeouts
uint32_t releaseCount
const VkDeviceMemory* pReleaseSyncs
const uint64_t* pReleaseKeys
VkStructureType sType
const void* pNext
VkExternalSemaphoreHandleTypeFlagBitsKHR handleType
VkStructureType sType
void* pNext
VkExternalSemaphoreHandleTypeFlagsKHR exportFromImportedHandleTypes
VkExternalSemaphoreHandleTypeFlagsKHR compatibleHandleTypes
VkExternalSemaphoreFeatureFlagsKHR externalSemaphoreFeatures
VkStructureType sType
const void* pNext
VkExternalSemaphoreHandleTypeFlagsKHR handleTypes
VkStructureType sType
const void* pNext
VkSemaphore semaphore
VkSemaphoreImportFlagsKHR flags
VkExternalSemaphoreHandleTypeFlagBitsKHR handleType
HANDLE handle
LPCWSTR name
VkStructureType sType
const void* pNext
const SECURITY_ATTRIBUTES* pAttributes
DWORD dwAccess
LPCWSTR name
VkStructureType sType
const void* pNext
uint32_t waitSemaphoreValuesCount
const uint64_t* pWaitSemaphoreValues
uint32_t signalSemaphoreValuesCount
const uint64_t* pSignalSemaphoreValues
VkStructureType sType
const void* pNext
VkSemaphore semaphore
VkExternalSemaphoreHandleTypeFlagBitsKHR handleType
VkStructureType sType
const void* pNext
VkSemaphore semaphore
VkSemaphoreImportFlagsKHR flags
VkExternalSemaphoreHandleTypeFlagBitsKHR handleType
int fd
VkStructureType sType
const void* pNext
VkSemaphore semaphore
VkExternalSemaphoreHandleTypeFlagBitsKHR handleType
VkStructureType sType
const void* pNext
VkExternalFenceHandleTypeFlagBitsKHR handleType
VkStructureType sType
void* pNext
VkExternalFenceHandleTypeFlagsKHR exportFromImportedHandleTypes
VkExternalFenceHandleTypeFlagsKHR compatibleHandleTypes
VkExternalFenceFeatureFlagsKHR externalFenceFeatures
VkStructureType sType
const void* pNext
VkExternalFenceHandleTypeFlagsKHR handleTypes
VkStructureType sType
const void* pNext
VkFence fence
VkFenceImportFlagsKHR flags
VkExternalFenceHandleTypeFlagBitsKHR handleType
HANDLE handle
LPCWSTR name
VkStructureType sType
const void* pNext
const SECURITY_ATTRIBUTES* pAttributes
DWORD dwAccess
LPCWSTR name
VkStructureType sType
const void* pNext
VkFence fence
VkExternalFenceHandleTypeFlagBitsKHR handleType
VkStructureType sType
const void* pNext
VkFence fence
VkFenceImportFlagsKHR flags
VkExternalFenceHandleTypeFlagBitsKHR handleType
int fd
VkStructureType sType
const void* pNext
VkFence fence
VkExternalFenceHandleTypeFlagBitsKHR handleType
VkStructureType sType
void* pNext
VkBool32 multiviewMultiple views in a renderpass
VkBool32 multiviewGeometryShaderMultiple views in a renderpass w/ geometry shader
VkBool32 multiviewTessellationShaderMultiple views in a renderpass w/ tessellation shader
VkStructureType sType
void* pNext
uint32_t maxMultiviewViewCountmax number of views in a subpass
uint32_t maxMultiviewInstanceIndexmax instance index for a draw in a multiview subpass
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
VkStructureType sType
void* pNext
uint32_t minImageCountSupported minimum number of images for the surface
uint32_t maxImageCountSupported maximum number of images for the surface, 0 for unlimited
VkExtent2D currentExtentCurrent image width and height for the surface, (0, 0) if undefined
VkExtent2D minImageExtentSupported minimum image width and height for the surface
VkExtent2D maxImageExtentSupported maximum image width and height for the surface
uint32_t maxImageArrayLayersSupported maximum number of image layers for the surface
VkSurfaceTransformFlagsKHR supportedTransforms1 or more bits representing the transforms supported
VkSurfaceTransformFlagBitsKHR currentTransformThe surface's current transform relative to the device's natural orientation
VkCompositeAlphaFlagsKHR supportedCompositeAlpha1 or more bits representing the alpha compositing modes supported
VkImageUsageFlags supportedUsageFlagsSupported image usage flags for the surface
VkSurfaceCounterFlagsEXT supportedSurfaceCounters
VkStructureType sType
const void* pNext
VkDisplayPowerStateEXT powerState
VkStructureType sType
const void* pNext
VkDeviceEventTypeEXT deviceEvent
VkStructureType sType
const void* pNext
VkDisplayEventTypeEXT displayEvent
VkStructureType sType
const void* pNext
VkSurfaceCounterFlagsEXT surfaceCounters
VkStructureType sType
void* pNext
uint32_t physicalDeviceCount
VkPhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE_KHX]
VkBool32 subsetAllocation
VkStructureType sType
const void* pNext
VkMemoryAllocateFlagsKHX flags
uint32_t deviceMask
VkStructureType sType
const void* pNext
VkBuffer buffer
VkDeviceMemory memory
VkDeviceSize memoryOffset
uint32_t deviceIndexCount
const uint32_t* pDeviceIndices
VkStructureType sType
const void* pNext
VkImage image
VkDeviceMemory memory
VkDeviceSize memoryOffset
uint32_t deviceIndexCount
const uint32_t* pDeviceIndices
uint32_t SFRRectCount
const VkRect2D* pSFRRects
VkStructureType sType
const void* pNext
uint32_t deviceMask
uint32_t deviceRenderAreaCount
const VkRect2D* pDeviceRenderAreas
VkStructureType sType
const void* pNext
uint32_t deviceMask
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
VkStructureType sType
const void* pNext
uint32_t resourceDeviceIndex
uint32_t memoryDeviceIndex
VkStructureType sType
const void* pNext
uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE_KHX]
VkDeviceGroupPresentModeFlagsKHX modes
VkStructureType sType
const void* pNext
VkSwapchainKHR swapchain
VkStructureType sType
const void* pNext
VkSwapchainKHR swapchain
uint32_t imageIndex
VkStructureType sType
const void* pNext
VkSwapchainKHR swapchain
uint64_t timeout
VkSemaphore semaphore
VkFence fence
uint32_t deviceMask
VkStructureType sType
const void* pNext
uint32_t swapchainCount
const uint32_t* pDeviceMasks
VkDeviceGroupPresentModeFlagBitsKHX mode
VkStructureType sType
const void* pNext
uint32_t physicalDeviceCount
const VkPhysicalDevice* pPhysicalDevices
VkStructureType sType
const void* pNext
VkDeviceGroupPresentModeFlagsKHX modes
uint32_t dstBindingBinding within the destination descriptor set to write
uint32_t dstArrayElementArray element within the destination binding to write
uint32_t descriptorCountNumber of descriptors to write
VkDescriptorType descriptorTypeDescriptor type to write
size_t offsetOffset into pData where the descriptors to update are stored
size_t strideStride between two descriptors in pData when writing more than one descriptor
VkStructureType sType
void* pNext
VkDescriptorUpdateTemplateCreateFlagsKHR flags
uint32_t descriptorUpdateEntryCountNumber of descriptor update entries to use for the update template
const VkDescriptorUpdateTemplateEntryKHR* pDescriptorUpdateEntriesDescriptor update entries for the template
VkDescriptorUpdateTemplateTypeKHR templateType
VkDescriptorSetLayout descriptorSetLayout
VkPipelineBindPoint pipelineBindPoint
VkPipelineLayoutpipelineLayoutIf used for push descriptors, this is the only allowed layout
uint32_t set
float x
float y
Display primary in chromaticity coordinates
VkStructureType sType
const void* pNext
From SMPTE 2086
VkXYColorEXT displayPrimaryRedDisplay primary's Red
VkXYColorEXT displayPrimaryGreenDisplay primary's Green
VkXYColorEXT displayPrimaryBlueDisplay primary's Blue
VkXYColorEXT whitePointDisplay primary's Blue
float maxLuminanceDisplay maximum luminance
float minLuminanceDisplay minimum luminance
From CTA 861.3
float maxContentLightLevelContent maximum luminance
float maxFrameAverageLightLevel
uint64_t refreshDurationNumber of nanoseconds from the start of one refresh cycle to the next
uint32_t presentIDApplication-provided identifier, previously given to vkQueuePresentKHR
uint64_t desiredPresentTimeEarliest time an image should have been presented, previously given to vkQueuePresentKHR
uint64_t actualPresentTimeTime the image was actually displayed
uint64_t earliestPresentTimeEarliest time the image could have been displayed
uint64_t presentMarginHow early vkQueuePresentKHR was processed vs. how soon it needed to be and make earliestPresentTime
VkStructureType sType
const void* pNext
uint32_t swapchainCountCopy of VkPresentInfoKHR::swapchainCount
const VkPresentTimeGOOGLE* pTimesThe earliest times to present images
uint32_t presentIDApplication-provided identifier
uint64_t desiredPresentTimeEarliest time an image should be presented
VkStructureType sType
const void* pNext
VkIOSSurfaceCreateFlagsMVK flags
const void* pView
VkStructureType sType
const void* pNext
VkMacOSSurfaceCreateFlagsMVK flags
const void* pView
float xcoeff
float ycoeff
VkStructureType sType
const void* pNext
VkBool32 viewportWScalingEnable
uint32_t viewportCount
const VkViewportWScalingNV* pViewportWScalings
VkViewportCoordinateSwizzleNV x
VkViewportCoordinateSwizzleNV y
VkViewportCoordinateSwizzleNV z
VkViewportCoordinateSwizzleNV w
VkStructureType sType
const void* pNext
VkPipelineViewportSwizzleStateCreateFlagsNV flags
uint32_t viewportCount
const VkViewportSwizzleNV* pViewportSwizzles
VkStructureType sType
void* pNext
uint32_t maxDiscardRectanglesmax number of active discard rectangles
VkStructureType sType
const void* pNext
VkPipelineDiscardRectangleStateCreateFlagsEXT flags
VkDiscardRectangleModeEXT discardRectangleMode
uint32_t discardRectangleCount
const VkRect2D* pDiscardRectangles
VkStructureType sType
void* pNext
VkBool32 perViewPositionAllComponents
VkStructureType sType
const void* pNext
VkSurfaceKHR surface
VkStructureType sType
void* pNext
VkSurfaceCapabilitiesKHR surfaceCapabilities
VkStructureType sType
void* pNext
VkSurfaceFormatKHR surfaceFormat
VkStructureType sType
void* pNext
VkImageUsageFlags sharedPresentSupportedUsageFlagsSupported image usage flags if swapchain created using a shared present mode
VkStructureType sType
void* pNext
VkBool32 storageBuffer16BitAccess16-bit integer/floating-point variables supported in BufferBlock
VkBool32 uniformAndStorageBuffer16BitAccess16-bit integer/floating-point variables supported in BufferBlock and Block
VkBool32 storagePushConstant1616-bit integer/floating-point variables supported in PushConstant
VkBool32 storageInputOutput1616-bit integer/floating-point variables supported in shader inputs and outputs
VkStructureType sType
const void* pNext
VkBuffer buffer
VkStructureType sType
const void* pNext
VkImage image
VkStructureType sType
const void* pNext
VkImage image
VkStructureType sType
void* pNext
VkMemoryRequirements memoryRequirements
VkStructureType sType
void* pNext
VkSparseImageMemoryRequirements memoryRequirements
VkStructureType sType
void* pNext
VkBool32 prefersDedicatedAllocation
VkBool32 requiresDedicatedAllocation
VkStructureType sType
const void* pNext
VkImage imageImage that this allocation will be bound to
VkBuffer bufferBuffer that this allocation will be bound to
VkStructureType sType
void* pNext
VkBool32 supportsTextureGatherLODBiasAMD
VkStructureType sType
const void* pNext
VkPipelineCoverageToColorStateCreateFlagsNV flags
VkBool32 coverageToColorEnable
uint32_t coverageToColorLocation
VkStructureType sType
void* pNext
VkBool32 filterMinmaxSingleComponentFormats
VkBool32 filterMinmaxImageComponentMapping
float x
float y
VkStructureType sType
const void* pNext
VkSampleCountFlagBits sampleLocationsPerPixel
VkExtent2D sampleLocationGridSize
uint32_t sampleLocationsCount
const VkSampleLocationEXT* pSampleLocations
uint32_t attachmentIndex
VkSampleLocationsInfoEXT sampleLocationsInfo
uint32_t subpassIndex
VkSampleLocationsInfoEXT sampleLocationsInfo
VkStructureType sType
const void* pNext
uint32_t attachmentInitialSampleLocationsCount
const VkAttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations
uint32_t postSubpassSampleLocationsCount
const VkSubpassSampleLocationsEXT* pSubpassSampleLocations
VkStructureType sType
const void* pNext
VkBool32 sampleLocationsEnable
VkSampleLocationsInfoEXT sampleLocationsInfo
VkStructureType sType
void* pNext
VkSampleCountFlags sampleLocationSampleCounts
VkExtent2D maxSampleLocationGridSize
float sampleLocationCoordinateRange[2]
uint32_t sampleLocationSubPixelBits
VkBool32 variableSampleLocations
VkStructureType sType
void* pNext
VkExtent2D maxSampleLocationGridSize
VkStructureType sType
const void* pNext
VkSamplerReductionModeEXT reductionMode
VkStructureType sType
void* pNext
VkBool32 advancedBlendCoherentOperations
VkStructureType sType
void* pNext
uint32_t advancedBlendMaxColorAttachments
VkBool32 advancedBlendIndependentBlend
VkBool32 advancedBlendNonPremultipliedSrcColor
VkBool32 advancedBlendNonPremultipliedDstColor
VkBool32 advancedBlendCorrelatedOverlap
VkBool32 advancedBlendAllOperations
VkStructureType sType
const void* pNext
VkBool32 srcPremultiplied
VkBool32 dstPremultiplied
VkBlendOverlapEXT blendOverlap
VkStructureType sType
const void* pNext
VkPipelineCoverageModulationStateCreateFlagsNV flags
VkCoverageModulationModeNV coverageModulationMode
VkBool32 coverageModulationTableEnable
uint32_t coverageModulationTableCount
const float* pCoverageModulationTable
VkStructureType sType
const void* pNext
VkValidationCacheCreateFlagsEXT flags
size_t initialDataSize
const void* pInitialData
VkStructureType sType
const void* pNext
VkValidationCacheEXT validationCache
Vulkan enumerant (token) definitions
Unlike OpenGL, most tokens in Vulkan are actual typed enumerants in
their own numeric namespaces. The "name" attribute is the C enum
type name, and is pulled in from a type tag definition above
(slightly clunky, but retains the type / enum distinction). "type"
attributes of "enum" or "bitmask" indicate that these values should
be generated inside an appropriate definition.
value="4" reserved for VK_KHR_sampler_mirror_clamp_to_edge
enum VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE; do not
alias!
Return codes (positive values)
Error codes (negative values)
Flags
WSI Extensions
Placeholder for validation enums to be defined for VK_EXT_Validation_flags extension
VkResult vkCreateInstance
const VkInstanceCreateInfo* pCreateInfo
const VkAllocationCallbacks* pAllocator
VkInstance* pInstance
void vkDestroyInstance
VkInstance instance
const VkAllocationCallbacks* pAllocator
VkResult vkEnumeratePhysicalDevices
VkInstance instance
uint32_t* pPhysicalDeviceCount
VkPhysicalDevice* pPhysicalDevices
PFN_vkVoidFunction vkGetDeviceProcAddr
VkDevice device
const char* pName
PFN_vkVoidFunction vkGetInstanceProcAddr
VkInstance instance
const char* pName
void vkGetPhysicalDeviceProperties
VkPhysicalDevice physicalDevice
VkPhysicalDeviceProperties* pProperties
void vkGetPhysicalDeviceQueueFamilyProperties
VkPhysicalDevice physicalDevice
uint32_t* pQueueFamilyPropertyCount
VkQueueFamilyProperties* pQueueFamilyProperties
void vkGetPhysicalDeviceMemoryProperties
VkPhysicalDevice physicalDevice
VkPhysicalDeviceMemoryProperties* pMemoryProperties
void vkGetPhysicalDeviceFeatures
VkPhysicalDevice physicalDevice
VkPhysicalDeviceFeatures* pFeatures
void vkGetPhysicalDeviceFormatProperties
VkPhysicalDevice physicalDevice
VkFormat format
VkFormatProperties* pFormatProperties
VkResult vkGetPhysicalDeviceImageFormatProperties
VkPhysicalDevice physicalDevice
VkFormat format
VkImageType type
VkImageTiling tiling
VkImageUsageFlags usage
VkImageCreateFlags flags
VkImageFormatProperties* pImageFormatProperties
VkResult vkCreateDevice
VkPhysicalDevice physicalDevice
const VkDeviceCreateInfo* pCreateInfo
const VkAllocationCallbacks* pAllocator
VkDevice* pDevice
void vkDestroyDevice
VkDevice device
const VkAllocationCallbacks* pAllocator
VkResult vkEnumerateInstanceLayerProperties
uint32_t* pPropertyCount
VkLayerProperties* pProperties
VkResult vkEnumerateInstanceExtensionProperties
const char* pLayerName
uint32_t* pPropertyCount
VkExtensionProperties* pProperties
VkResult vkEnumerateDeviceLayerProperties
VkPhysicalDevice physicalDevice
uint32_t* pPropertyCount
VkLayerProperties* pProperties
VkResult vkEnumerateDeviceExtensionProperties
VkPhysicalDevice physicalDevice
const char* pLayerName
uint32_t* pPropertyCount
VkExtensionProperties* pProperties
void vkGetDeviceQueue
VkDevice device
uint32_t queueFamilyIndex
uint32_t queueIndex
VkQueue* pQueue
VkResult vkQueueSubmit
VkQueue queue
uint32_t submitCount
const VkSubmitInfo* pSubmits
VkFence fence
VkResult vkQueueWaitIdle
VkQueue queue
VkResult vkDeviceWaitIdle
VkDevice device
all sname:VkQueue objects created from pname:device
VkResult vkAllocateMemory
VkDevice device
const VkMemoryAllocateInfo* pAllocateInfo
const VkAllocationCallbacks* pAllocator
VkDeviceMemory* pMemory
void vkFreeMemory
VkDevice device
VkDeviceMemory memory
const VkAllocationCallbacks* pAllocator
VkResult vkMapMemory
VkDevice device
VkDeviceMemory memory
VkDeviceSize offset
VkDeviceSize size
VkMemoryMapFlags flags
void** ppData
void vkUnmapMemory
VkDevice device
VkDeviceMemory memory
VkResult vkFlushMappedMemoryRanges
VkDevice device
uint32_t memoryRangeCount
const VkMappedMemoryRange* pMemoryRanges
VkResult vkInvalidateMappedMemoryRanges
VkDevice device
uint32_t memoryRangeCount
const VkMappedMemoryRange* pMemoryRanges
void vkGetDeviceMemoryCommitment
VkDevice device
VkDeviceMemory memory
VkDeviceSize* pCommittedMemoryInBytes
void vkGetBufferMemoryRequirements
VkDevice device
VkBuffer buffer
VkMemoryRequirements* pMemoryRequirements
VkResult vkBindBufferMemory
VkDevice device
VkBuffer buffer
VkDeviceMemory memory
VkDeviceSize memoryOffset
void vkGetImageMemoryRequirements
VkDevice device
VkImage image
VkMemoryRequirements* pMemoryRequirements
VkResult vkBindImageMemory
VkDevice device
VkImage image
VkDeviceMemory memory
VkDeviceSize memoryOffset
void vkGetImageSparseMemoryRequirements
VkDevice device
VkImage image
uint32_t* pSparseMemoryRequirementCount
VkSparseImageMemoryRequirements* pSparseMemoryRequirements
void vkGetPhysicalDeviceSparseImageFormatProperties
VkPhysicalDevice physicalDevice
VkFormat format
VkImageType type
VkSampleCountFlagBits samples
VkImageUsageFlags usage
VkImageTiling tiling
uint32_t* pPropertyCount
VkSparseImageFormatProperties* pProperties
VkResult vkQueueBindSparse
VkQueue queue
uint32_t bindInfoCount
const VkBindSparseInfo* pBindInfo
VkFence fence
VkResult vkCreateFence
VkDevice device
const VkFenceCreateInfo* pCreateInfo
const VkAllocationCallbacks* pAllocator
VkFence* pFence
void vkDestroyFence
VkDevice device
VkFence fence
const VkAllocationCallbacks* pAllocator
VkResult vkResetFences
VkDevice device
uint32_t fenceCount
const VkFence* pFences
VkResult vkGetFenceStatus
VkDevice device
VkFence fence
VkResult vkWaitForFences
VkDevice device
uint32_t fenceCount
const VkFence* pFences
VkBool32 waitAll
uint64_t timeout
VkResult vkCreateSemaphore
VkDevice device
const VkSemaphoreCreateInfo* pCreateInfo
const VkAllocationCallbacks* pAllocator
VkSemaphore* pSemaphore
void vkDestroySemaphore
VkDevice device
VkSemaphore semaphore
const VkAllocationCallbacks* pAllocator
VkResult vkCreateEvent
VkDevice device
const VkEventCreateInfo* pCreateInfo
const VkAllocationCallbacks* pAllocator
VkEvent* pEvent
void vkDestroyEvent
VkDevice device
VkEvent event
const VkAllocationCallbacks* pAllocator
VkResult vkGetEventStatus
VkDevice device
VkEvent event
VkResult vkSetEvent
VkDevice device
VkEvent event
VkResult vkResetEvent
VkDevice device
VkEvent event
VkResult vkCreateQueryPool
VkDevice device
const VkQueryPoolCreateInfo* pCreateInfo
const VkAllocationCallbacks* pAllocator
VkQueryPool* pQueryPool
void vkDestroyQueryPool
VkDevice device
VkQueryPool queryPool
const VkAllocationCallbacks* pAllocator
VkResult vkGetQueryPoolResults
VkDevice device
VkQueryPool queryPool
uint32_t firstQuery
uint32_t queryCount
size_t dataSize
void* pData
VkDeviceSize stride
VkQueryResultFlags flags
VkResult vkCreateBuffer
VkDevice device
const VkBufferCreateInfo* pCreateInfo
const VkAllocationCallbacks* pAllocator
VkBuffer* pBuffer
void vkDestroyBuffer
VkDevice device
VkBuffer buffer
const VkAllocationCallbacks* pAllocator
VkResult vkCreateBufferView
VkDevice device
const VkBufferViewCreateInfo* pCreateInfo
const VkAllocationCallbacks* pAllocator
VkBufferView* pView
void vkDestroyBufferView
VkDevice device
VkBufferView bufferView
const VkAllocationCallbacks* pAllocator
VkResult vkCreateImage
VkDevice device
const VkImageCreateInfo* pCreateInfo
const VkAllocationCallbacks* pAllocator
VkImage* pImage
void vkDestroyImage
VkDevice device
VkImage image
const VkAllocationCallbacks* pAllocator
void vkGetImageSubresourceLayout
VkDevice device
VkImage image
const VkImageSubresource* pSubresource
VkSubresourceLayout* pLayout
VkResult vkCreateImageView
VkDevice device
const VkImageViewCreateInfo* pCreateInfo
const VkAllocationCallbacks* pAllocator
VkImageView* pView
void vkDestroyImageView
VkDevice device
VkImageView imageView
const VkAllocationCallbacks* pAllocator
VkResult vkCreateShaderModule
VkDevice device
const VkShaderModuleCreateInfo* pCreateInfo
const VkAllocationCallbacks* pAllocator
VkShaderModule* pShaderModule
void vkDestroyShaderModule
VkDevice device
VkShaderModule shaderModule
const VkAllocationCallbacks* pAllocator
VkResult vkCreatePipelineCache
VkDevice device
const VkPipelineCacheCreateInfo* pCreateInfo
const VkAllocationCallbacks* pAllocator
VkPipelineCache* pPipelineCache
void vkDestroyPipelineCache
VkDevice device
VkPipelineCache pipelineCache
const VkAllocationCallbacks* pAllocator
VkResult vkGetPipelineCacheData
VkDevice device
VkPipelineCache pipelineCache
size_t* pDataSize
void* pData
VkResult vkMergePipelineCaches
VkDevice device
VkPipelineCache dstCache
uint32_t srcCacheCount
const VkPipelineCache* pSrcCaches
VkResult vkCreateGraphicsPipelines
VkDevice device
VkPipelineCache pipelineCache
uint32_t createInfoCount
const VkGraphicsPipelineCreateInfo* pCreateInfos
const VkAllocationCallbacks* pAllocator
VkPipeline* pPipelines
VkResult vkCreateComputePipelines
VkDevice device
VkPipelineCache pipelineCache
uint32_t createInfoCount
const VkComputePipelineCreateInfo* pCreateInfos
const VkAllocationCallbacks* pAllocator
VkPipeline* pPipelines
void vkDestroyPipeline
VkDevice device
VkPipeline pipeline
const VkAllocationCallbacks* pAllocator
VkResult vkCreatePipelineLayout
VkDevice device
const VkPipelineLayoutCreateInfo* pCreateInfo
const VkAllocationCallbacks* pAllocator
VkPipelineLayout* pPipelineLayout
void vkDestroyPipelineLayout
VkDevice device
VkPipelineLayout pipelineLayout
const VkAllocationCallbacks* pAllocator
VkResult vkCreateSampler
VkDevice device
const VkSamplerCreateInfo* pCreateInfo
const VkAllocationCallbacks* pAllocator
VkSampler* pSampler
void vkDestroySampler
VkDevice device
VkSampler sampler
const VkAllocationCallbacks* pAllocator
VkResult vkCreateDescriptorSetLayout
VkDevice device
const VkDescriptorSetLayoutCreateInfo* pCreateInfo
const VkAllocationCallbacks* pAllocator
VkDescriptorSetLayout* pSetLayout
void vkDestroyDescriptorSetLayout
VkDevice device
VkDescriptorSetLayout descriptorSetLayout
const VkAllocationCallbacks* pAllocator
VkResult vkCreateDescriptorPool
VkDevice device
const VkDescriptorPoolCreateInfo* pCreateInfo
const VkAllocationCallbacks* pAllocator
VkDescriptorPool* pDescriptorPool
void vkDestroyDescriptorPool
VkDevice device
VkDescriptorPool descriptorPool
const VkAllocationCallbacks* pAllocator
VkResult vkResetDescriptorPool
VkDevice device
VkDescriptorPool descriptorPool
VkDescriptorPoolResetFlags flags
any sname:VkDescriptorSet objects allocated from pname:descriptorPool
VkResult vkAllocateDescriptorSets
VkDevice device
const VkDescriptorSetAllocateInfo* pAllocateInfo
VkDescriptorSet* pDescriptorSets
VkResult vkFreeDescriptorSets
VkDevice device
VkDescriptorPool descriptorPool
uint32_t descriptorSetCount
const VkDescriptorSet* pDescriptorSets
void vkUpdateDescriptorSets
VkDevice device
uint32_t descriptorWriteCount
const VkWriteDescriptorSet* pDescriptorWrites
uint32_t descriptorCopyCount
const VkCopyDescriptorSet* pDescriptorCopies
VkResult vkCreateFramebuffer
VkDevice device
const VkFramebufferCreateInfo* pCreateInfo
const VkAllocationCallbacks* pAllocator
VkFramebuffer* pFramebuffer
void vkDestroyFramebuffer
VkDevice device
VkFramebuffer framebuffer
const VkAllocationCallbacks* pAllocator
VkResult vkCreateRenderPass
VkDevice device
const VkRenderPassCreateInfo* pCreateInfo
const VkAllocationCallbacks* pAllocator
VkRenderPass* pRenderPass
void vkDestroyRenderPass
VkDevice device
VkRenderPass renderPass
const VkAllocationCallbacks* pAllocator
void vkGetRenderAreaGranularity
VkDevice device
VkRenderPass renderPass
VkExtent2D* pGranularity
VkResult vkCreateCommandPool
VkDevice device
const VkCommandPoolCreateInfo* pCreateInfo
const VkAllocationCallbacks* pAllocator
VkCommandPool* pCommandPool
void vkDestroyCommandPool
VkDevice device
VkCommandPool commandPool
const VkAllocationCallbacks* pAllocator
VkResult vkResetCommandPool
VkDevice device
VkCommandPool commandPool
VkCommandPoolResetFlags flags
VkResult vkAllocateCommandBuffers
VkDevice device
const VkCommandBufferAllocateInfo* pAllocateInfo
VkCommandBuffer* pCommandBuffers
void vkFreeCommandBuffers
VkDevice device
VkCommandPool commandPool
uint32_t commandBufferCount
const VkCommandBuffer* pCommandBuffers
VkResult vkBeginCommandBuffer
VkCommandBuffer commandBuffer
const VkCommandBufferBeginInfo* pBeginInfo
the sname:VkCommandPool that pname:commandBuffer was allocated from
VkResult vkEndCommandBuffer
VkCommandBuffer commandBuffer
the sname:VkCommandPool that pname:commandBuffer was allocated from
VkResult vkResetCommandBuffer
VkCommandBuffer commandBuffer
VkCommandBufferResetFlags flags
void vkCmdBindPipeline
VkCommandBuffer commandBuffer
VkPipelineBindPoint pipelineBindPoint
VkPipeline pipeline
void vkCmdSetViewport
VkCommandBuffer commandBuffer
uint32_t firstViewport
uint32_t viewportCount
const VkViewport* pViewports
void vkCmdSetScissor
VkCommandBuffer commandBuffer
uint32_t firstScissor
uint32_t scissorCount
const VkRect2D* pScissors
void vkCmdSetLineWidth
VkCommandBuffer commandBuffer
float lineWidth
void vkCmdSetDepthBias
VkCommandBuffer commandBuffer
float depthBiasConstantFactor
float depthBiasClamp
float depthBiasSlopeFactor
void vkCmdSetBlendConstants
VkCommandBuffer commandBuffer
const float blendConstants[4]
void vkCmdSetDepthBounds
VkCommandBuffer commandBuffer
float minDepthBounds
float maxDepthBounds
void vkCmdSetStencilCompareMask
VkCommandBuffer commandBuffer
VkStencilFaceFlags faceMask
uint32_t compareMask
void vkCmdSetStencilWriteMask
VkCommandBuffer commandBuffer
VkStencilFaceFlags faceMask
uint32_t writeMask
void vkCmdSetStencilReference
VkCommandBuffer commandBuffer
VkStencilFaceFlags faceMask
uint32_t reference
void vkCmdBindDescriptorSets
VkCommandBuffer commandBuffer
VkPipelineBindPoint pipelineBindPoint
VkPipelineLayout layout
uint32_t firstSet
uint32_t descriptorSetCount
const VkDescriptorSet* pDescriptorSets
uint32_t dynamicOffsetCount
const uint32_t* pDynamicOffsets
void vkCmdBindIndexBuffer
VkCommandBuffer commandBuffer
VkBuffer buffer
VkDeviceSize offset
VkIndexType indexType
void vkCmdBindVertexBuffers
VkCommandBuffer commandBuffer
uint32_t firstBinding
uint32_t bindingCount
const VkBuffer* pBuffers
const VkDeviceSize* pOffsets
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
void vkCmdDrawIndexedIndirect
VkCommandBuffer commandBuffer
VkBuffer buffer
VkDeviceSize offset
uint32_t drawCount
uint32_t stride
void vkCmdDispatch
VkCommandBuffer commandBuffer
uint32_t groupCountX
uint32_t groupCountY
uint32_t groupCountZ
void vkCmdDispatchIndirect
VkCommandBuffer commandBuffer
VkBuffer buffer
VkDeviceSize offset
void vkCmdCopyBuffer
VkCommandBuffer commandBuffer
VkBuffer srcBuffer
VkBuffer dstBuffer
uint32_t regionCount
const VkBufferCopy* pRegions
void vkCmdCopyImage
VkCommandBuffer commandBuffer
VkImage srcImage
VkImageLayout srcImageLayout
VkImage dstImage
VkImageLayout dstImageLayout
uint32_t regionCount
const VkImageCopy* pRegions
void vkCmdBlitImage
VkCommandBuffer commandBuffer
VkImage srcImage
VkImageLayout srcImageLayout
VkImage dstImage
VkImageLayout dstImageLayout
uint32_t regionCount
const VkImageBlit* pRegions
VkFilter filter
void vkCmdCopyBufferToImage
VkCommandBuffer commandBuffer
VkBuffer srcBuffer
VkImage dstImage
VkImageLayout dstImageLayout
uint32_t regionCount
const VkBufferImageCopy* pRegions
void vkCmdCopyImageToBuffer
VkCommandBuffer commandBuffer
VkImage srcImage
VkImageLayout srcImageLayout
VkBuffer dstBuffer
uint32_t regionCount
const VkBufferImageCopy* pRegions
void vkCmdUpdateBuffer
VkCommandBuffer commandBuffer
VkBuffer dstBuffer
VkDeviceSize dstOffset
VkDeviceSize dataSize
const void* pData
void vkCmdFillBuffer
VkCommandBuffer commandBuffer
VkBuffer dstBuffer
VkDeviceSize dstOffset
VkDeviceSize size
uint32_t data
void vkCmdClearColorImage
VkCommandBuffer commandBuffer
VkImage image
VkImageLayout imageLayout
const VkClearColorValue* pColor
uint32_t rangeCount
const VkImageSubresourceRange* pRanges
void vkCmdClearDepthStencilImage
VkCommandBuffer commandBuffer
VkImage image
VkImageLayout imageLayout
const VkClearDepthStencilValue* pDepthStencil
uint32_t rangeCount
const VkImageSubresourceRange* pRanges
void vkCmdClearAttachments
VkCommandBuffer commandBuffer
uint32_t attachmentCount
const VkClearAttachment* pAttachments
uint32_t rectCount
const VkClearRect* pRects
void vkCmdResolveImage
VkCommandBuffer commandBuffer
VkImage srcImage
VkImageLayout srcImageLayout
VkImage dstImage
VkImageLayout dstImageLayout
uint32_t regionCount
const VkImageResolve* pRegions
void vkCmdSetEvent
VkCommandBuffer commandBuffer
VkEvent event
VkPipelineStageFlags stageMask
void vkCmdResetEvent
VkCommandBuffer commandBuffer
VkEvent event
VkPipelineStageFlags stageMask
void vkCmdWaitEvents
VkCommandBuffer commandBuffer
uint32_t eventCount
const VkEvent* pEvents
VkPipelineStageFlags srcStageMask
VkPipelineStageFlags dstStageMask
uint32_t memoryBarrierCount
const VkMemoryBarrier* pMemoryBarriers
uint32_t bufferMemoryBarrierCount
const VkBufferMemoryBarrier* pBufferMemoryBarriers
uint32_t imageMemoryBarrierCount
const VkImageMemoryBarrier* pImageMemoryBarriers
void vkCmdPipelineBarrier
VkCommandBuffer commandBuffer
VkPipelineStageFlags srcStageMask
VkPipelineStageFlags dstStageMask
VkDependencyFlags dependencyFlags
uint32_t memoryBarrierCount
const VkMemoryBarrier* pMemoryBarriers
uint32_t bufferMemoryBarrierCount
const VkBufferMemoryBarrier* pBufferMemoryBarriers
uint32_t imageMemoryBarrierCount
const VkImageMemoryBarrier* pImageMemoryBarriers
void vkCmdBeginQuery
VkCommandBuffer commandBuffer
VkQueryPool queryPool
uint32_t query
VkQueryControlFlags flags
void vkCmdEndQuery
VkCommandBuffer commandBuffer
VkQueryPool queryPool
uint32_t query
void vkCmdResetQueryPool
VkCommandBuffer commandBuffer
VkQueryPool queryPool
uint32_t firstQuery
uint32_t queryCount
void vkCmdWriteTimestamp
VkCommandBuffer commandBuffer
VkPipelineStageFlagBits pipelineStage
VkQueryPool queryPool
uint32_t query
void vkCmdCopyQueryPoolResults
VkCommandBuffer commandBuffer
VkQueryPool queryPool
uint32_t firstQuery
uint32_t queryCount
VkBuffer dstBuffer
VkDeviceSize dstOffset
VkDeviceSize stride
VkQueryResultFlags flags
void vkCmdPushConstants
VkCommandBuffer commandBuffer
VkPipelineLayout layout
VkShaderStageFlags stageFlags
uint32_t offset
uint32_t size
const void* pValues
void vkCmdBeginRenderPass
VkCommandBuffer commandBuffer
const VkRenderPassBeginInfo* pRenderPassBegin
VkSubpassContents contents
void vkCmdNextSubpass
VkCommandBuffer commandBuffer
VkSubpassContents contents
void vkCmdEndRenderPass
VkCommandBuffer commandBuffer
void vkCmdExecuteCommands
VkCommandBuffer commandBuffer
uint32_t commandBufferCount
const VkCommandBuffer* pCommandBuffers
VkResult vkCreateAndroidSurfaceKHR
VkInstance instance
const VkAndroidSurfaceCreateInfoKHR* pCreateInfo
const VkAllocationCallbacks* pAllocator
VkSurfaceKHR* pSurface
VkResult vkGetPhysicalDeviceDisplayPropertiesKHR
VkPhysicalDevice physicalDevice
uint32_t* pPropertyCount
VkDisplayPropertiesKHR* pProperties
VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR
VkPhysicalDevice physicalDevice
uint32_t* pPropertyCount
VkDisplayPlanePropertiesKHR* pProperties
VkResult vkGetDisplayPlaneSupportedDisplaysKHR
VkPhysicalDevice physicalDevice
uint32_t planeIndex
uint32_t* pDisplayCount
VkDisplayKHR* pDisplays
VkResult vkGetDisplayModePropertiesKHR
VkPhysicalDevice physicalDevice
VkDisplayKHR display
uint32_t* pPropertyCount
VkDisplayModePropertiesKHR* pProperties
VkResult vkCreateDisplayModeKHR
VkPhysicalDevice physicalDevice
VkDisplayKHR display
const VkDisplayModeCreateInfoKHR* pCreateInfo
const VkAllocationCallbacks* pAllocator
VkDisplayModeKHR* pMode
VkResult vkGetDisplayPlaneCapabilitiesKHR
VkPhysicalDevice physicalDevice
VkDisplayModeKHR mode
uint32_t planeIndex
VkDisplayPlaneCapabilitiesKHR* pCapabilities
VkResult vkCreateDisplayPlaneSurfaceKHR
VkInstance instance
const VkDisplaySurfaceCreateInfoKHR* pCreateInfo
const VkAllocationCallbacks* pAllocator
VkSurfaceKHR* pSurface
VkResult vkCreateSharedSwapchainsKHR
VkDevice device
uint32_t swapchainCount
const VkSwapchainCreateInfoKHR* pCreateInfos
const VkAllocationCallbacks* pAllocator
VkSwapchainKHR* pSwapchains
VkResult vkCreateMirSurfaceKHR
VkInstance instance
const VkMirSurfaceCreateInfoKHR* pCreateInfo
const VkAllocationCallbacks* pAllocator
VkSurfaceKHR* pSurface
VkBool32 vkGetPhysicalDeviceMirPresentationSupportKHR
VkPhysicalDevice physicalDevice
uint32_t queueFamilyIndex
MirConnection* connection
void vkDestroySurfaceKHR
VkInstance instance
VkSurfaceKHR surface
const VkAllocationCallbacks* pAllocator
VkResult vkGetPhysicalDeviceSurfaceSupportKHR
VkPhysicalDevice physicalDevice
uint32_t queueFamilyIndex
VkSurfaceKHR surface
VkBool32* pSupported
VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR
VkPhysicalDevice physicalDevice
VkSurfaceKHR surface
VkSurfaceCapabilitiesKHR* pSurfaceCapabilities
VkResult vkGetPhysicalDeviceSurfaceFormatsKHR
VkPhysicalDevice physicalDevice
VkSurfaceKHR surface
uint32_t* pSurfaceFormatCount
VkSurfaceFormatKHR* pSurfaceFormats
VkResult vkGetPhysicalDeviceSurfacePresentModesKHR
VkPhysicalDevice physicalDevice
VkSurfaceKHR surface
uint32_t* pPresentModeCount
VkPresentModeKHR* pPresentModes
VkResult vkCreateSwapchainKHR
VkDevice device
const VkSwapchainCreateInfoKHR* pCreateInfo
const VkAllocationCallbacks* pAllocator
VkSwapchainKHR* pSwapchain
void vkDestroySwapchainKHR
VkDevice device
VkSwapchainKHR swapchain
const VkAllocationCallbacks* pAllocator
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 vkQueuePresentKHR
VkQueue queue
const VkPresentInfoKHR* pPresentInfo
VkResult vkCreateViSurfaceNN
VkInstance instance
const VkViSurfaceCreateInfoNN* pCreateInfo
const VkAllocationCallbacks* pAllocator
VkSurfaceKHR* pSurface
VkResult vkCreateWaylandSurfaceKHR
VkInstance instance
const VkWaylandSurfaceCreateInfoKHR* pCreateInfo
const VkAllocationCallbacks* pAllocator
VkSurfaceKHR* pSurface
VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR
VkPhysicalDevice physicalDevice
uint32_t queueFamilyIndex
struct wl_display* display
VkResult vkCreateWin32SurfaceKHR
VkInstance instance
const VkWin32SurfaceCreateInfoKHR* pCreateInfo
const VkAllocationCallbacks* pAllocator
VkSurfaceKHR* pSurface
VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR
VkPhysicalDevice physicalDevice
uint32_t queueFamilyIndex
VkResult vkCreateXlibSurfaceKHR
VkInstance instance
const VkXlibSurfaceCreateInfoKHR* pCreateInfo
const VkAllocationCallbacks* pAllocator
VkSurfaceKHR* pSurface
VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR
VkPhysicalDevice physicalDevice
uint32_t queueFamilyIndex
Display* dpy
VisualID visualID
VkResult vkCreateXcbSurfaceKHR
VkInstance instance
const VkXcbSurfaceCreateInfoKHR* pCreateInfo
const VkAllocationCallbacks* pAllocator
VkSurfaceKHR* pSurface
VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR
VkPhysicalDevice physicalDevice
uint32_t queueFamilyIndex
xcb_connection_t* connection
xcb_visualid_t visual_id
VkResult vkCreateDebugReportCallbackEXT
VkInstance instance
const VkDebugReportCallbackCreateInfoEXT* pCreateInfo
const VkAllocationCallbacks* pAllocator
VkDebugReportCallbackEXT* pCallback
void vkDestroyDebugReportCallbackEXT
VkInstance instance
VkDebugReportCallbackEXT callback
const VkAllocationCallbacks* pAllocator
void vkDebugReportMessageEXT
VkInstance instance
VkDebugReportFlagsEXT flags
VkDebugReportObjectTypeEXT objectType
uint64_t object
size_t location
int32_t messageCode
const char* pLayerPrefix
const char* pMessage
VkResult vkDebugMarkerSetObjectNameEXT
VkDevice device
const VkDebugMarkerObjectNameInfoEXT* pNameInfo
VkResult vkDebugMarkerSetObjectTagEXT
VkDevice device
const VkDebugMarkerObjectTagInfoEXT* pTagInfo
void vkCmdDebugMarkerBeginEXT
VkCommandBuffer commandBuffer
const VkDebugMarkerMarkerInfoEXT* pMarkerInfo
void vkCmdDebugMarkerEndEXT
VkCommandBuffer commandBuffer
void vkCmdDebugMarkerInsertEXT
VkCommandBuffer commandBuffer
const VkDebugMarkerMarkerInfoEXT* pMarkerInfo
VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV
VkPhysicalDevice physicalDevice
VkFormat format
VkImageType type
VkImageTiling tiling
VkImageUsageFlags usage
VkImageCreateFlags flags
VkExternalMemoryHandleTypeFlagsNV externalHandleType
VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties
VkResult vkGetMemoryWin32HandleNV
VkDevice device
VkDeviceMemory memory
VkExternalMemoryHandleTypeFlagsNV handleType
HANDLE* pHandle
void vkCmdDrawIndirectCountAMD
VkCommandBuffer commandBuffer
VkBuffer buffer
VkDeviceSize offset
VkBuffer countBuffer
VkDeviceSize countBufferOffset
uint32_t maxDrawCount
uint32_t stride
void vkCmdDrawIndexedIndirectCountAMD
VkCommandBuffer commandBuffer
VkBuffer buffer
VkDeviceSize offset
VkBuffer countBuffer
VkDeviceSize countBufferOffset
uint32_t maxDrawCount
uint32_t stride
void vkCmdProcessCommandsNVX
VkCommandBuffer commandBuffer
const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo
void vkCmdReserveSpaceForCommandsNVX
VkCommandBuffer commandBuffer
const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo
VkResult vkCreateIndirectCommandsLayoutNVX
VkDevice device
const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo
const VkAllocationCallbacks* pAllocator
VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout
void vkDestroyIndirectCommandsLayoutNVX
VkDevice device
VkIndirectCommandsLayoutNVX indirectCommandsLayout
const VkAllocationCallbacks* pAllocator
VkResult vkCreateObjectTableNVX
VkDevice device
const VkObjectTableCreateInfoNVX* pCreateInfo
const VkAllocationCallbacks* pAllocator
VkObjectTableNVX* pObjectTable
void vkDestroyObjectTableNVX
VkDevice device
VkObjectTableNVX objectTable
const VkAllocationCallbacks* pAllocator
VkResult vkRegisterObjectsNVX
VkDevice device
VkObjectTableNVX objectTable
uint32_t objectCount
const VkObjectTableEntryNVX* const* ppObjectTableEntries
const uint32_t* pObjectIndices
VkResult vkUnregisterObjectsNVX
VkDevice device
VkObjectTableNVX objectTable
uint32_t objectCount
const VkObjectEntryTypeNVX* pObjectEntryTypes
const uint32_t* pObjectIndices
void vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX
VkPhysicalDevice physicalDevice
VkDeviceGeneratedCommandsFeaturesNVX* pFeatures
VkDeviceGeneratedCommandsLimitsNVX* pLimits
void vkGetPhysicalDeviceFeatures2KHR
VkPhysicalDevice physicalDevice
VkPhysicalDeviceFeatures2KHR* pFeatures
void vkGetPhysicalDeviceProperties2KHR
VkPhysicalDevice physicalDevice
VkPhysicalDeviceProperties2KHR* pProperties
void vkGetPhysicalDeviceFormatProperties2KHR
VkPhysicalDevice physicalDevice
VkFormat format
VkFormatProperties2KHR* pFormatProperties
VkResult vkGetPhysicalDeviceImageFormatProperties2KHR
VkPhysicalDevice physicalDevice
const VkPhysicalDeviceImageFormatInfo2KHR* pImageFormatInfo
VkImageFormatProperties2KHR* pImageFormatProperties
void vkGetPhysicalDeviceQueueFamilyProperties2KHR
VkPhysicalDevice physicalDevice
uint32_t* pQueueFamilyPropertyCount
VkQueueFamilyProperties2KHR* pQueueFamilyProperties
void vkGetPhysicalDeviceMemoryProperties2KHR
VkPhysicalDevice physicalDevice
VkPhysicalDeviceMemoryProperties2KHR* pMemoryProperties
void vkGetPhysicalDeviceSparseImageFormatProperties2KHR
VkPhysicalDevice physicalDevice
const VkPhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo
uint32_t* pPropertyCount
VkSparseImageFormatProperties2KHR* pProperties
void vkCmdPushDescriptorSetKHR
VkCommandBuffer commandBuffer
VkPipelineBindPoint pipelineBindPoint
VkPipelineLayout layout
uint32_t set
uint32_t descriptorWriteCount
const VkWriteDescriptorSet* pDescriptorWrites
void vkTrimCommandPoolKHR
VkDevice device
VkCommandPool commandPool
VkCommandPoolTrimFlagsKHR flags
void vkGetPhysicalDeviceExternalBufferPropertiesKHR
VkPhysicalDevice physicalDevice
const VkPhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo
VkExternalBufferPropertiesKHR* pExternalBufferProperties
VkResult vkGetMemoryWin32HandleKHR
VkDevice device
const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo
HANDLE* pHandle
VkResult vkGetMemoryWin32HandlePropertiesKHR
VkDevice device
VkExternalMemoryHandleTypeFlagBitsKHR handleType
HANDLE handle
VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties
VkResult vkGetMemoryFdKHR
VkDevice device
const VkMemoryGetFdInfoKHR* pGetFdInfo
int* pFd
VkResult vkGetMemoryFdPropertiesKHR
VkDevice device
VkExternalMemoryHandleTypeFlagBitsKHR handleType
int fd
VkMemoryFdPropertiesKHR* pMemoryFdProperties
void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR
VkPhysicalDevice physicalDevice
const VkPhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo
VkExternalSemaphorePropertiesKHR* pExternalSemaphoreProperties
VkResult vkGetSemaphoreWin32HandleKHR
VkDevice device
const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo
HANDLE* pHandle
VkResult vkImportSemaphoreWin32HandleKHR
VkDevice device
const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo
VkResult vkGetSemaphoreFdKHR
VkDevice device
const VkSemaphoreGetFdInfoKHR* pGetFdInfo
int* pFd
VkResult vkImportSemaphoreFdKHR
VkDevice device
const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo
void vkGetPhysicalDeviceExternalFencePropertiesKHR
VkPhysicalDevice physicalDevice
const VkPhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo
VkExternalFencePropertiesKHR* pExternalFenceProperties
VkResult vkGetFenceWin32HandleKHR
VkDevice device
const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo
HANDLE* pHandle
VkResult vkImportFenceWin32HandleKHR
VkDevice device
const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo
VkResult vkGetFenceFdKHR
VkDevice device
const VkFenceGetFdInfoKHR* pGetFdInfo
int* pFd
VkResult vkImportFenceFdKHR
VkDevice device
const VkImportFenceFdInfoKHR* pImportFenceFdInfo
VkResult vkReleaseDisplayEXT
VkPhysicalDevice physicalDevice
VkDisplayKHR display
VkResult vkAcquireXlibDisplayEXT
VkPhysicalDevice physicalDevice
Display* dpy
VkDisplayKHR display
VkResult vkGetRandROutputDisplayEXT
VkPhysicalDevice physicalDevice
Display* dpy
RROutput rrOutput
VkDisplayKHR* pDisplay
VkResult vkDisplayPowerControlEXT
VkDevice device
VkDisplayKHR display
const VkDisplayPowerInfoEXT* pDisplayPowerInfo
VkResult vkRegisterDeviceEventEXT
VkDevice device
const VkDeviceEventInfoEXT* pDeviceEventInfo
const VkAllocationCallbacks* pAllocator
VkFence* pFence
VkResult vkRegisterDisplayEventEXT
VkDevice device
VkDisplayKHR display
const VkDisplayEventInfoEXT* pDisplayEventInfo
const VkAllocationCallbacks* pAllocator
VkFence* pFence
VkResult vkGetSwapchainCounterEXT
VkDevice device
VkSwapchainKHR swapchain
VkSurfaceCounterFlagBitsEXT counter
uint64_t* pCounterValue
VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT
VkPhysicalDevice physicalDevice
VkSurfaceKHR surface
VkSurfaceCapabilities2EXT* pSurfaceCapabilities
VkResult vkEnumeratePhysicalDeviceGroupsKHX
VkInstance instance
uint32_t* pPhysicalDeviceGroupCount
VkPhysicalDeviceGroupPropertiesKHX* pPhysicalDeviceGroupProperties
void vkGetDeviceGroupPeerMemoryFeaturesKHX
VkDevice device
uint32_t heapIndex
uint32_t localDeviceIndex
uint32_t remoteDeviceIndex
VkPeerMemoryFeatureFlagsKHX* pPeerMemoryFeatures
VkResult vkBindBufferMemory2KHX
VkDevice device
uint32_t bindInfoCount
const VkBindBufferMemoryInfoKHX* pBindInfos
VkResult vkBindImageMemory2KHX
VkDevice device
uint32_t bindInfoCount
const VkBindImageMemoryInfoKHX* pBindInfos
void vkCmdSetDeviceMaskKHX
VkCommandBuffer commandBuffer
uint32_t deviceMask
VkResult vkGetDeviceGroupPresentCapabilitiesKHX
VkDevice device
VkDeviceGroupPresentCapabilitiesKHX* pDeviceGroupPresentCapabilities
VkResult vkGetDeviceGroupSurfacePresentModesKHX
VkDevice device
VkSurfaceKHR surface
VkDeviceGroupPresentModeFlagsKHX* pModes
VkResult vkAcquireNextImage2KHX
VkDevice device
const VkAcquireNextImageInfoKHX* pAcquireInfo
uint32_t* pImageIndex
void vkCmdDispatchBaseKHX
VkCommandBuffer commandBuffer
uint32_t baseGroupX
uint32_t baseGroupY
uint32_t baseGroupZ
uint32_t groupCountX
uint32_t groupCountY
uint32_t groupCountZ
VkResult vkGetPhysicalDevicePresentRectanglesKHX
VkPhysicalDevice physicalDevice
VkSurfaceKHR surface
uint32_t* pRectCount
VkRect2D* pRects
VkResult vkCreateDescriptorUpdateTemplateKHR
VkDevice device
const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo
const VkAllocationCallbacks* pAllocator
VkDescriptorUpdateTemplateKHR* pDescriptorUpdateTemplate
void vkDestroyDescriptorUpdateTemplateKHR
VkDevice device
VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate
const VkAllocationCallbacks* pAllocator
void vkUpdateDescriptorSetWithTemplateKHR
VkDevice device
VkDescriptorSet descriptorSet
VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate
const void* pData
void vkCmdPushDescriptorSetWithTemplateKHR
VkCommandBuffer commandBuffer
VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate
VkPipelineLayout layout
uint32_t set
const void* pData
void vkSetHdrMetadataEXT
VkDevice device
uint32_t swapchainCount
const VkSwapchainKHR* pSwapchains
const VkHdrMetadataEXT* pMetadata
VkResult vkGetSwapchainStatusKHR
VkDevice device
VkSwapchainKHR swapchain
VkResult vkGetRefreshCycleDurationGOOGLE
VkDevice device
VkSwapchainKHR swapchain
VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties
VkResult vkGetPastPresentationTimingGOOGLE
VkDevice device
VkSwapchainKHR swapchain
uint32_t* pPresentationTimingCount
VkPastPresentationTimingGOOGLE* pPresentationTimings
VkResult vkCreateIOSSurfaceMVK
VkInstance instance
const VkIOSSurfaceCreateInfoMVK* pCreateInfo
const VkAllocationCallbacks* pAllocator
VkSurfaceKHR* pSurface
VkResult vkCreateMacOSSurfaceMVK
VkInstance instance
const VkMacOSSurfaceCreateInfoMVK* pCreateInfo
const VkAllocationCallbacks* pAllocator
VkSurfaceKHR* pSurface
void vkCmdSetViewportWScalingNV
VkCommandBuffer commandBuffer
uint32_t firstViewport
uint32_t viewportCount
const VkViewportWScalingNV* pViewportWScalings
void vkCmdSetDiscardRectangleEXT
VkCommandBuffer commandBuffer
uint32_t firstDiscardRectangle
uint32_t discardRectangleCount
const VkRect2D* pDiscardRectangles
void vkCmdSetSampleLocationsEXT
VkCommandBuffer commandBuffer
const VkSampleLocationsInfoEXT* pSampleLocationsInfo
void vkGetPhysicalDeviceMultisamplePropertiesEXT
VkPhysicalDevice physicalDevice
VkSampleCountFlagBits samples
VkMultisamplePropertiesEXT* pMultisampleProperties
VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR
VkPhysicalDevice physicalDevice
const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo
VkSurfaceCapabilities2KHR* pSurfaceCapabilities
VkResult vkGetPhysicalDeviceSurfaceFormats2KHR
VkPhysicalDevice physicalDevice
const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo
uint32_t* pSurfaceFormatCount
VkSurfaceFormat2KHR* pSurfaceFormats
void vkGetBufferMemoryRequirements2KHR
VkDevice device
const VkBufferMemoryRequirementsInfo2KHR* pInfo
VkMemoryRequirements2KHR* pMemoryRequirements
void vkGetImageMemoryRequirements2KHR
VkDevice device
const VkImageMemoryRequirementsInfo2KHR* pInfo
VkMemoryRequirements2KHR* pMemoryRequirements
void vkGetImageSparseMemoryRequirements2KHR
VkDevice device
const VkImageSparseMemoryRequirementsInfo2KHR* pInfo
uint32_t* pSparseMemoryRequirementCount
VkSparseImageMemoryRequirements2KHR* pSparseMemoryRequirements
VkResult vkCreateValidationCacheEXT
VkDevice device
const VkValidationCacheCreateInfoEXT* pCreateInfo
const VkAllocationCallbacks* pAllocator
VkValidationCacheEXT* pValidationCache
void vkDestroyValidationCacheEXT
VkDevice device
VkValidationCacheEXT validationCache
const VkAllocationCallbacks* pAllocator
VkResult vkGetValidationCacheDataEXT
VkDevice device
VkValidationCacheEXT validationCache
size_t* pDataSize
void* pData
VkResult vkMergeValidationCachesEXT
VkDevice device
VkValidationCacheEXT dstCache
uint32_t srcCacheCount
const VkValidationCacheEXT* pSrcCaches