Copyright (c) 2015-2019 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.
---- Exceptions to the Apache 2.0 License: ----
As an exception, if you use this Software to generate code and portions of
this Software are embedded into the generated code as a result, you may
redistribute such product without providing attribution as would otherwise
be required by Sections 4(a), 4(b) and 4(d) of the License.
In addition, if you combine or link code generated by this Software with
software that is licensed under the GPLv2 or the LGPL v2.0 or 2.1
("`Combined Software`") and if a court of competent jurisdiction determines
that the patent provision (Section 3), the indemnity provision (Section 9)
or other Section of the License conflicts with the conditions of the
applicable GPL or LGPL license, you may retroactively and prospectively
choose to deem waived or otherwise exclude such Section(s) of the License,
but only in their entirety and only with respect to the Combined Software.
    
    
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 master branch of the member gitlab
server.
    
    
        
        
        
        
        
        
        
        
        
        
        
        
    
    
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
    
    
        #include "vk_platform.h"
            WSI extensions
        
        
        
        
        
        
        
            
                In the current header structure, each platform's interfaces
                are confined to a platform-specific header (vulkan_xlib.h,
                vulkan_win32.h, etc.). These headers are not self-contained,
                and should not include native headers (X11/Xlib.h,
                windows.h, etc.). Code should either include vulkan.h after
                defining the appropriate VK_USE_PLATFORM_platform
                macros, or include the required native headers prior to
                explicitly including the corresponding platform header.
                To accomplish this, the dependencies of native types require
                native headers, but the XML defines the content for those
                native headers as empty. The actual native header includes
                can be restored by modifying the native header tags above
                to #include the header file in the 'name' attribute.
            
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        #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
        // Vulkan 1.1 version number
#define VK_API_VERSION_1_1 VK_MAKE_VERSION(1, 1, 0)// Patch version should always be set to 0
        // Version of this file
#define VK_HEADER_VERSION 127
        
#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
        struct ANativeWindow;
        struct AHardwareBuffer;
        
#ifdef __OBJC__
@class CAMetalLayer;
#else
typedef void CAMetalLayer;
#endif
        typedef uint32_t VkSampleMask;
        typedef uint32_t VkBool32;
        typedef uint32_t VkFlags;
        typedef uint64_t VkDeviceSize;
        typedef uint64_t VkDeviceAddress;
            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 VkSubgroupFeatureFlags;
        typedef VkFlags VkIndirectCommandsLayoutUsageFlagsNVX;
        typedef VkFlags VkObjectEntryUsageFlagsNVX;
        typedef VkFlags VkGeometryFlagsNV;
        typedef VkFlags VkGeometryInstanceFlagsNV;
        typedef VkFlags VkBuildAccelerationStructureFlagsNV;
        typedef VkFlags VkDescriptorUpdateTemplateCreateFlags;
        
        typedef VkFlags VkPipelineCreationFeedbackFlagsEXT;
        typedef VkFlags VkPipelineCompilerControlFlagsAMD;
        typedef VkFlags VkShaderCorePropertiesFlagsAMD;
        typedef VkFlags VkSemaphoreWaitFlagsKHR;
            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 VkViSurfaceCreateFlagsNN;
        typedef VkFlags VkWaylandSurfaceCreateFlagsKHR;
        typedef VkFlags VkWin32SurfaceCreateFlagsKHR;
        typedef VkFlags VkXlibSurfaceCreateFlagsKHR;
        typedef VkFlags VkXcbSurfaceCreateFlagsKHR;
        typedef VkFlags VkIOSSurfaceCreateFlagsMVK;
        typedef VkFlags VkMacOSSurfaceCreateFlagsMVK;
        typedef VkFlags VkMetalSurfaceCreateFlagsEXT;
        typedef VkFlags VkImagePipeSurfaceCreateFlagsFUCHSIA;
        typedef VkFlags VkStreamDescriptorSurfaceCreateFlagsGGP;
        typedef VkFlags VkHeadlessSurfaceCreateFlagsEXT;
        typedef VkFlags VkPeerMemoryFeatureFlags;
        
        typedef VkFlags VkMemoryAllocateFlags;
        
        typedef VkFlags VkDeviceGroupPresentModeFlagsKHR;
        typedef VkFlags VkDebugReportFlagsEXT;
        typedef VkFlags VkCommandPoolTrimFlags;
        
        typedef VkFlags VkExternalMemoryHandleTypeFlagsNV;
        typedef VkFlags VkExternalMemoryFeatureFlagsNV;
        typedef VkFlags VkExternalMemoryHandleTypeFlags;
        
        typedef VkFlags VkExternalMemoryFeatureFlags;
        
        typedef VkFlags VkExternalSemaphoreHandleTypeFlags;
        
        typedef VkFlags VkExternalSemaphoreFeatureFlags;
        
        typedef VkFlags VkSemaphoreImportFlags;
        
        typedef VkFlags VkExternalFenceHandleTypeFlags;
        
        typedef VkFlags VkExternalFenceFeatureFlags;
        
        typedef VkFlags VkFenceImportFlags;
        
        typedef VkFlags VkSurfaceCounterFlagsEXT;
        typedef VkFlags VkPipelineViewportSwizzleStateCreateFlagsNV;
        typedef VkFlags VkPipelineDiscardRectangleStateCreateFlagsEXT;
        typedef VkFlags VkPipelineCoverageToColorStateCreateFlagsNV;
        typedef VkFlags VkPipelineCoverageModulationStateCreateFlagsNV;
        typedef VkFlags VkPipelineCoverageReductionStateCreateFlagsNV;
        typedef VkFlags VkValidationCacheCreateFlagsEXT;
        typedef VkFlags VkDebugUtilsMessageSeverityFlagsEXT;
        typedef VkFlags VkDebugUtilsMessageTypeFlagsEXT;
        typedef VkFlags VkDebugUtilsMessengerCreateFlagsEXT;
        typedef VkFlags VkDebugUtilsMessengerCallbackDataFlagsEXT;
        typedef VkFlags VkPipelineRasterizationConservativeStateCreateFlagsEXT;
        typedef VkFlags VkDescriptorBindingFlagsEXT;
        typedef VkFlags VkConditionalRenderingFlagsEXT;
        typedef VkFlags VkResolveModeFlagsKHR;
        typedef VkFlags VkPipelineRasterizationStateStreamCreateFlagsEXT;
        typedef VkFlags VkPipelineRasterizationDepthClipStateCreateFlagsEXT;
        typedef VkFlags VkSwapchainImageUsageFlagsANDROID;
            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(VkDescriptorUpdateTemplate)
        
        VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSamplerYcbcrConversion)
        
        VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkValidationCacheEXT)
        VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureNV)
        VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPerformanceConfigurationINTEL)
            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)
        VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugUtilsMessengerEXT)
            Types generated from corresponding enums tags below
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        Extensions
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
            WSI extensions
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
            Enumerated types in the header, but not used by the API
        
        
        
        
        
        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);
            The PFN_vkDebugUtilsMessengerCallbackEXT type are used by the VK_EXT_debug_utils extension
        typedef VkBool32 (VKAPI_PTR *PFN_vkDebugUtilsMessengerCallbackEXT)(
    VkDebugUtilsMessageSeverityFlagBitsEXT           messageSeverity,
    VkDebugUtilsMessageTypeFlagsEXT                  messageTypes,
    const VkDebugUtilsMessengerCallbackDataEXT*      pCallbackData,
    void*                                            pUserData);
            Struct types
        
            VkStructureType sType
            struct VkBaseOutStructure* pNext
        
        
            VkStructureType sType
            const struct VkBaseInStructure* pNext
        
        
            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
        
        
            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.
            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 LOD
            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 components 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 LOD 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
            struct ANativeWindow*    window
        
        
            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
        
        
            VkStructureType sType
            const void*                      pNext
            VkImagePipeSurfaceCreateFlagsFUCHSIA   flags
            zx_handle_t                      imagePipeHandle
        
        
            VkStructureType sType
            const void*                      pNext
            VkStreamDescriptorSurfaceCreateFlagsGGP flags
            GgpStreamDescriptor              streamDescriptor
        
        
            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
            const VkValidationCheckEXT* pDisabledValidationChecksValidation checks to disable
        
        
            VkStructureType  sTypeMust be VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT
            const void*                      pNext
            uint32_t                         enabledValidationFeatureCountNumber of validation features to enable
            const VkValidationFeatureEnableEXT* pEnabledValidationFeaturesValidation features to enable
            uint32_t                         disabledValidationFeatureCountNumber of validation features to disable
            const VkValidationFeatureDisableEXT* pDisabledValidationFeaturesValidation features 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
        
        
            uint8_t                          major
            uint8_t                          minor
            uint8_t                          subminor
            uint8_t                          patch
        
        
            VkStructureType sType
            void*                            pNext
            VkDriverIdKHR                    driverID
            char                             driverName[VK_MAX_DRIVER_NAME_SIZE_KHR]
            char                             driverInfo[VK_MAX_DRIVER_INFO_SIZE_KHR]
            VkConformanceVersionKHR          conformanceVersion
        
        
            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
        
        
        
        
        
            VkExternalMemoryFeatureFlags  externalMemoryFeatures
            VkExternalMemoryHandleTypeFlags exportFromImportedHandleTypes
            VkExternalMemoryHandleTypeFlags compatibleHandleTypes
        
        
        
            VkStructureType sType
            const void*                      pNext
            VkExternalMemoryHandleTypeFlagBits handleType
        
        
        
            VkStructureType sType
            void*                            pNext
            VkExternalMemoryProperties externalMemoryProperties
        
        
        
            VkStructureType sType
            const void*                      pNext
            VkBufferCreateFlags flags
            VkBufferUsageFlags               usage
            VkExternalMemoryHandleTypeFlagBits handleType
        
        
        
            VkStructureType sType
            void*                            pNext
            VkExternalMemoryProperties    externalMemoryProperties
        
        
        
            VkStructureType sType
            void*                            pNext
            uint8_t                          deviceUUID[VK_UUID_SIZE]
            uint8_t                          driverUUID[VK_UUID_SIZE]
            uint8_t                          deviceLUID[VK_LUID_SIZE]
            uint32_t                         deviceNodeMask
            VkBool32                         deviceLUIDValid
        
        
        
            VkStructureType sType
            const void*                      pNext
            VkExternalMemoryHandleTypeFlags handleTypes
        
        
        
            VkStructureType sType
            const void*                      pNext
            VkExternalMemoryHandleTypeFlags handleTypes
        
        
        
            VkStructureType sType
            const void*                      pNext
            VkExternalMemoryHandleTypeFlags handleTypes
        
        
        
            VkStructureType sType
            const void*                      pNext
            VkExternalMemoryHandleTypeFlagBits 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
            VkExternalMemoryHandleTypeFlagBits handleType
        
        
            VkStructureType sType
            const void*                      pNext
            VkExternalMemoryHandleTypeFlagBits handleType
            int                              fd
        
        
            VkStructureType sType
            void*                            pNext
            uint32_t                         memoryTypeBits
        
        
            VkStructureType sType
            const void*                      pNext
            VkDeviceMemory                   memory
            VkExternalMemoryHandleTypeFlagBits 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
            VkExternalSemaphoreHandleTypeFlagBits handleType
        
        
        
            VkStructureType sType
            void*                            pNext
            VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes
            VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes
            VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures
        
        
        
            VkStructureType sType
            const void*                      pNext
            VkExternalSemaphoreHandleTypeFlags handleTypes
        
        
        
            VkStructureType sType
            const void*                      pNext
            VkSemaphore    semaphore
            VkSemaphoreImportFlags flags
            VkExternalSemaphoreHandleTypeFlagBits 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
            VkExternalSemaphoreHandleTypeFlagBits handleType
        
        
            VkStructureType sType
            const void*                      pNext
            VkSemaphore    semaphore
            VkSemaphoreImportFlags flags
            VkExternalSemaphoreHandleTypeFlagBits handleType
            int                              fd
        
        
            VkStructureType sType
            const void*                      pNext
            VkSemaphore                      semaphore
            VkExternalSemaphoreHandleTypeFlagBits handleType
        
        
            VkStructureType sType
            const void*                      pNext
            VkExternalFenceHandleTypeFlagBits handleType
        
        
        
            VkStructureType sType
            void*                            pNext
            VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes
            VkExternalFenceHandleTypeFlags compatibleHandleTypes
            VkExternalFenceFeatureFlags externalFenceFeatures
        
        
        
            VkStructureType sType
            const void*                      pNext
            VkExternalFenceHandleTypeFlags handleTypes
        
        
        
            VkStructureType sType
            const void*                                        pNext
            VkFence                          fence
            VkFenceImportFlags              flags
            VkExternalFenceHandleTypeFlagBits  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
            VkExternalFenceHandleTypeFlagBits   handleType
        
        
            VkStructureType sType
            const void*                            pNext
            VkFence              fence
            VkFenceImportFlags  flags
            VkExternalFenceHandleTypeFlagBits   handleType
            int                                    fd
        
        
            VkStructureType sType
            const void*                            pNext
            VkFence                                fence
            VkExternalFenceHandleTypeFlagBits   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]
            VkBool32                         subsetAllocation
        
        
        
            VkStructureType sType
            const void*                      pNext
            VkMemoryAllocateFlags flags
            uint32_t                         deviceMask
        
        
        
            VkStructureType sType
            const void*                      pNext
            VkBuffer                         buffer
            VkDeviceMemory                   memory
            VkDeviceSize                     memoryOffset
        
        
        
            VkStructureType sType
            const void*                      pNext
            uint32_t         deviceIndexCount
            const uint32_t*  pDeviceIndices
        
        
        
            VkStructureType sType
            const void*                      pNext
            VkImage                          image
            VkDeviceMemory                   memory
            VkDeviceSize                     memoryOffset
        
        
        
            VkStructureType sType
            const void*                      pNext
            uint32_t         deviceIndexCount
            const uint32_t*  pDeviceIndices
            uint32_t         splitInstanceBindRegionCount
            const VkRect2D*  pSplitInstanceBindRegions
        
        
        
            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]
            VkDeviceGroupPresentModeFlagsKHR 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
            VkDeviceGroupPresentModeFlagBitsKHR mode
        
        
            VkStructureType sType
            const void*                      pNext
            uint32_t                         physicalDeviceCount
            const VkPhysicalDevice*  pPhysicalDevices
        
        
        
            VkStructureType sType
            const void*                      pNext
            VkDeviceGroupPresentModeFlagsKHR                         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
            const void*                               pNext
            VkDescriptorUpdateTemplateCreateFlags    flags
            uint32_t                 descriptorUpdateEntryCountNumber of descriptor update entries to use for the update template
            const VkDescriptorUpdateTemplateEntry* pDescriptorUpdateEntriesDescriptor update entries for the template
            VkDescriptorUpdateTemplateType 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
        
        
            VkStructureType sType
            void*          pNext
            VkBool32       localDimmingSupport
        
        
            VkStructureType sType
            const void*    pNext
            VkBool32       localDimmingEnable
        
        
            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
        
        
            VkStructureType sType
            const void*                                    pNext
            VkMetalSurfaceCreateFlagsEXT   flags
            const CAMetalLayer*      pLayer
        
        
            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
        
        
            uint32_t                        subpass
            uint32_t                        inputAttachmentIndex
            VkImageAspectFlags              aspectMask
        
        
        
            VkStructureType sType
            const void*                     pNext
            uint32_t                        aspectReferenceCount
            const VkInputAttachmentAspectReference* pAspectReferences
        
        
        
            VkStructureType sType
            const void* pNext
            VkSurfaceKHR surface
        
        
            VkStructureType sType
            void*   pNext
            VkSurfaceCapabilitiesKHR surfaceCapabilities
        
        
            VkStructureType sType
            void* pNext
            VkSurfaceFormatKHR surfaceFormat
        
        
            VkStructureType sType
            void* pNext
            VkDisplayPropertiesKHR displayProperties
        
        
            VkStructureType sType
            void* pNext
            VkDisplayPlanePropertiesKHR displayPlaneProperties
        
        
            VkStructureType sType
            void* pNext
            VkDisplayModePropertiesKHR displayModeProperties
        
        
            VkStructureType sType
            const void* pNext
            VkDisplayModeKHR mode
            uint32_t planeIndex
        
        
            VkStructureType sType
            void* pNext
            VkDisplayPlaneCapabilitiesKHR capabilities
        
        
            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
            void*                   pNext
            uint32_t                      subgroupSizeThe size of a subgroup for this queue.
            VkShaderStageFlags            supportedStagesBitfield of what shader stages support subgroup operations
            VkSubgroupFeatureFlags        supportedOperationsBitfield of what subgroup operations are supported.
            VkBool32 quadOperationsInAllStagesFlag to specify whether quad operations are available in all stages.
        
        
             VkStructureType sType
             void*                          pNext
             VkBool32 shaderSubgroupExtendedTypesFlag to specify whether subgroup operations with extended types are supported
        
        
            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
            VkPointClippingBehavior      pointClippingBehavior
        
        
        
            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
            const void* pNext
            VkImageUsageFlags usage
        
        
        
            VkStructureType sType
            const void*                      pNext
            VkTessellationDomainOrigin    domainOrigin
        
        
        
            VkStructureType sType
            const void*                      pNext
            VkSamplerYcbcrConversion      conversion
        
        
        
            VkStructureType sType
            const void*                      pNext
            VkFormat                         format
            VkSamplerYcbcrModelConversion ycbcrModel
            VkSamplerYcbcrRange           ycbcrRange
            VkComponentMapping               components
            VkChromaLocation              xChromaOffset
            VkChromaLocation              yChromaOffset
            VkFilter                         chromaFilter
            VkBool32                         forceExplicitReconstruction
        
        
        
            VkStructureType sType
            const void*                      pNext
            VkImageAspectFlagBits            planeAspect
        
        
        
            VkStructureType sType
            const void*                      pNext
            VkImageAspectFlagBits            planeAspect
        
        
        
            VkStructureType sType
            void*      pNext
            VkBool32                         samplerYcbcrConversionSampler color conversion supported
        
        
        
            VkStructureType sType
            void*      pNext
            uint32_t                         combinedImageSamplerDescriptorCount
        
        
        
            VkStructureType sType
            void*                            pNext
            VkBool32                         supportsTextureGatherLODBiasAMD
        
        
            VkStructureType sType
            const void*                      pNext
            VkBuffer                         buffer
            VkDeviceSize                     offset
            VkConditionalRenderingFlagsEXT    flags
        
        
            VkStructureType sType
            const void*                     pNext
            VkBool32                        protectedSubmitSubmit protected command buffers
        
        
            VkStructureType sType
            void*                               pNext
            VkBool32                            protectedMemory
        
        
            VkStructureType sType
            void*                               pNext
            VkBool32                            protectedNoFault
        
        
            VkStructureType sType
            const void*                         pNext
            VkDeviceQueueCreateFlags            flags
            uint32_t                            queueFamilyIndex
            uint32_t                            queueIndex
        
        
            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* pPostSubpassSampleLocations
        
        
            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
            void*                  pNext
            VkBool32               inlineUniformBlock
            VkBool32               descriptorBindingInlineUniformBlockUpdateAfterBind
        
        
            VkStructureType sType
            void*                  pNext
            uint32_t               maxInlineUniformBlockSize
            uint32_t               maxPerStageDescriptorInlineUniformBlocks
            uint32_t               maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks
            uint32_t               maxDescriptorSetInlineUniformBlocks
            uint32_t               maxDescriptorSetUpdateAfterBindInlineUniformBlocks
        
        
            VkStructureType sType
            const void*            pNext
            uint32_t               dataSize
            const void* pData
        
        
            VkStructureType sType
            const void*            pNext
            uint32_t               maxInlineUniformBlockBindings
        
        
            VkStructureType sType
            const void*                                                                      pNext
            VkPipelineCoverageModulationStateCreateFlagsNV                   flags
            VkCoverageModulationModeNV                                                       coverageModulationMode
            VkBool32                                                                         coverageModulationTableEnable
            uint32_t                                                         coverageModulationTableCount
            const float* pCoverageModulationTable
        
        
            VkStructureType sType
            const void*            pNext
            uint32_t               viewFormatCount
            const VkFormat*      pViewFormats
        
        
            VkStructureType sType
            const void*            pNext
            VkValidationCacheCreateFlagsEXT    flags
            size_t                 initialDataSize
            const void*            pInitialData
        
        
            VkStructureType sType
            const void*            pNext
            VkValidationCacheEXT    validationCache
        
        
            VkStructureType sType
            void*                            pNext
            uint32_t                         maxPerSetDescriptors
            VkDeviceSize                     maxMemoryAllocationSize
        
        
        
            VkStructureType sType
            void*            pNext
            VkBool32         supported
        
        
        
            VkStructureType sType
            void*                            pNext
            VkBool32                         shaderDrawParameters
        
        
        
            VkStructureType sType
            void*      pNext                            
            VkBool32                         shaderFloat16                 
            VkBool32                         shaderInt8                    
        
        
        
            VkStructureType sType
            void*                            pNext
            VkShaderFloatControlsIndependenceKHR denormBehaviorIndependence
            VkShaderFloatControlsIndependenceKHR roundingModeIndependence
            VkBool32                         shaderSignedZeroInfNanPreserveFloat16  
            VkBool32                         shaderSignedZeroInfNanPreserveFloat32  
            VkBool32                         shaderSignedZeroInfNanPreserveFloat64  
            VkBool32                         shaderDenormPreserveFloat16            
            VkBool32                         shaderDenormPreserveFloat32            
            VkBool32                         shaderDenormPreserveFloat64            
            VkBool32                         shaderDenormFlushToZeroFloat16         
            VkBool32                         shaderDenormFlushToZeroFloat32         
            VkBool32                         shaderDenormFlushToZeroFloat64         
            VkBool32                         shaderRoundingModeRTEFloat16           
            VkBool32                         shaderRoundingModeRTEFloat32           
            VkBool32                         shaderRoundingModeRTEFloat64           
            VkBool32                         shaderRoundingModeRTZFloat16           
            VkBool32                         shaderRoundingModeRTZFloat32           
            VkBool32                         shaderRoundingModeRTZFloat64           
        
        
            VkStructureType sType
            void*        pNext
            VkBool32                           hostQueryReset
        
        
            uint64_t consumer
            uint64_t producer
        
        
            VkStructureType sType
            const void* pNext
            const void* handle
            int stride
            int format
            int usage
            VkNativeBufferUsage2ANDROID usage2
        
        
            VkStructureType sType
            const void* pNext
            VkSwapchainImageUsageFlagsANDROID usage
        
        
            VkStructureType sType
            const void* pNext
            VkBool32 sharedImage
        
        
            uint32_t numUsedVgprs
            uint32_t numUsedSgprs
            uint32_t ldsSizePerLocalWorkGroup
            size_t ldsUsageSizeInBytes
            size_t scratchMemUsageInBytes
        
        
            VkShaderStageFlags shaderStageMask
            VkShaderResourceUsageAMD resourceUsage
            uint32_t numPhysicalVgprs
            uint32_t numPhysicalSgprs
            uint32_t numAvailableVgprs
            uint32_t numAvailableSgprs
            uint32_t computeWorkGroupSize[3]
        
        
            VkStructureType sType
            const void*                    pNext
            VkQueueGlobalPriorityEXT       globalPriority
        
        
            VkStructureType sType
            const void*                                            pNext
            VkObjectType                                           objectType
            uint64_t                                               objectHandle
            const char*      pObjectName
        
        
            VkStructureType sType
            const void*                            pNext
            VkObjectType                           objectType
            uint64_t                               objectHandle
            uint64_t                               tagName
            size_t                                 tagSize
            const void*              pTag
        
        
            VkStructureType sType
            const void*                            pNext
            const char*      pLabelName
            float                  color[4]
        
        
            VkStructureType sType
            const void*                                          pNext
            VkDebugUtilsMessengerCreateFlagsEXT  flags
            VkDebugUtilsMessageSeverityFlagsEXT                  messageSeverity
            VkDebugUtilsMessageTypeFlagsEXT                      messageType
            PFN_vkDebugUtilsMessengerCallbackEXT                 pfnUserCallback
            void*                                pUserData
        
        
            VkStructureType sType
            const void*                                                        pNext
            VkDebugUtilsMessengerCallbackDataFlagsEXT                          flags
            const char*                                  pMessageIdName
            int32_t                                                            messageIdNumber
            const char*                                                  pMessage
            uint32_t                                                           queueLabelCount
            const VkDebugUtilsLabelEXT*                  pQueueLabels
            uint32_t                                                           cmdBufLabelCount
            const VkDebugUtilsLabelEXT*                 pCmdBufLabels
            uint32_t                                                           objectCount
            const VkDebugUtilsObjectNameInfoEXT*             pObjects
        
        
            VkStructureType sType
            const void* pNext
            VkExternalMemoryHandleTypeFlagBits handleType
            void* pHostPointer
        
        
            VkStructureType sType
            void* pNext
            uint32_t memoryTypeBits
        
        
            VkStructureType sType
            void* pNext
            VkDeviceSize minImportedHostPointerAlignment
        
        
            VkStructureType sType
            void*                  pNextPointer to next structure
            float                  primitiveOverestimationSizeThe size in pixels the primitive is enlarged at each edge during conservative rasterization
            float                  maxExtraPrimitiveOverestimationSizeThe maximum additional overestimation the client can specify in the pipeline state
            float                  extraPrimitiveOverestimationSizeGranularityThe granularity of extra overestimation sizes the implementations supports between 0 and maxExtraOverestimationSize
            VkBool32               primitiveUnderestimationtrue if the implementation supports conservative rasterization underestimation mode
            VkBool32               conservativePointAndLineRasterizationtrue if conservative rasterization also applies to points and lines
            VkBool32               degenerateTrianglesRasterizedtrue if degenerate triangles (those with zero area after snap) are rasterized
            VkBool32               degenerateLinesRasterizedtrue if degenerate lines (those with zero length after snap) are rasterized
            VkBool32               fullyCoveredFragmentShaderInputVariabletrue if the implementation supports the FullyCoveredEXT SPIR-V builtin fragment shader input variable
            VkBool32               conservativeRasterizationPostDepthCoveragetrue if the implementation supports both conservative rasterization and post depth coverage sample coverage mask
        
        
            VkStructureType sType
            const void*            pNext
            VkTimeDomainEXT        timeDomain
        
        
            VkStructureType sType
            void*    pNextPointer to next structure
            uint32_t shaderEngineCountnumber of shader engines
            uint32_t shaderArraysPerEngineCountnumber of shader arrays
            uint32_t computeUnitsPerShaderArraynumber of physical CUs per shader array
            uint32_t simdPerComputeUnitnumber of SIMDs per compute unit
            uint32_t wavefrontsPerSimdnumber of wavefront slots in each SIMD
            uint32_t wavefrontSizemaximum number of threads per wavefront
            uint32_t sgprsPerSimdnumber of physical SGPRs per SIMD
            uint32_t minSgprAllocationminimum number of SGPRs that can be allocated by a wave
            uint32_t maxSgprAllocationnumber of available SGPRs
            uint32_t sgprAllocationGranularitySGPRs are allocated in groups of this size
            uint32_t vgprsPerSimdnumber of physical VGPRs per SIMD
            uint32_t minVgprAllocationminimum number of VGPRs that can be allocated by a wave
            uint32_t maxVgprAllocationnumber of available VGPRs
            uint32_t vgprAllocationGranularityVGPRs are allocated in groups of this size
        
        
            VkStructureType sType
            void*    pNextPointer to next structure
            VkShaderCorePropertiesFlagsAMD shaderCoreFeaturesfeatures supported by the shader core
            uint32_t activeComputeUnitCountnumber of active compute units across all shader engines/arrays
        
        
            VkStructureType sType
            const void*                                                                      pNext                 
            VkPipelineRasterizationConservativeStateCreateFlagsEXT           flags                 
            VkConservativeRasterizationModeEXT                                               conservativeRasterizationMode      
            float                                                                            extraPrimitiveOverestimationSize   
        
        
            VkStructureType sType
            void*                            pNext
            VkBool32               shaderInputAttachmentArrayDynamicIndexing
            VkBool32               shaderUniformTexelBufferArrayDynamicIndexing
            VkBool32               shaderStorageTexelBufferArrayDynamicIndexing
            VkBool32               shaderUniformBufferArrayNonUniformIndexing
            VkBool32               shaderSampledImageArrayNonUniformIndexing
            VkBool32               shaderStorageBufferArrayNonUniformIndexing
            VkBool32               shaderStorageImageArrayNonUniformIndexing
            VkBool32               shaderInputAttachmentArrayNonUniformIndexing
            VkBool32               shaderUniformTexelBufferArrayNonUniformIndexing
            VkBool32               shaderStorageTexelBufferArrayNonUniformIndexing
            VkBool32               descriptorBindingUniformBufferUpdateAfterBind
            VkBool32               descriptorBindingSampledImageUpdateAfterBind
            VkBool32               descriptorBindingStorageImageUpdateAfterBind
            VkBool32               descriptorBindingStorageBufferUpdateAfterBind
            VkBool32               descriptorBindingUniformTexelBufferUpdateAfterBind
            VkBool32               descriptorBindingStorageTexelBufferUpdateAfterBind
            VkBool32               descriptorBindingUpdateUnusedWhilePending
            VkBool32               descriptorBindingPartiallyBound
            VkBool32               descriptorBindingVariableDescriptorCount
            VkBool32               runtimeDescriptorArray
        
        
            VkStructureType sType
            void*                            pNext
            uint32_t               maxUpdateAfterBindDescriptorsInAllPools
            VkBool32               shaderUniformBufferArrayNonUniformIndexingNative
            VkBool32               shaderSampledImageArrayNonUniformIndexingNative
            VkBool32               shaderStorageBufferArrayNonUniformIndexingNative
            VkBool32               shaderStorageImageArrayNonUniformIndexingNative
            VkBool32               shaderInputAttachmentArrayNonUniformIndexingNative
            VkBool32               robustBufferAccessUpdateAfterBind
            VkBool32               quadDivergentImplicitLod
            uint32_t               maxPerStageDescriptorUpdateAfterBindSamplers
            uint32_t               maxPerStageDescriptorUpdateAfterBindUniformBuffers
            uint32_t               maxPerStageDescriptorUpdateAfterBindStorageBuffers
            uint32_t               maxPerStageDescriptorUpdateAfterBindSampledImages
            uint32_t               maxPerStageDescriptorUpdateAfterBindStorageImages
            uint32_t               maxPerStageDescriptorUpdateAfterBindInputAttachments
            uint32_t               maxPerStageUpdateAfterBindResources
            uint32_t               maxDescriptorSetUpdateAfterBindSamplers
            uint32_t               maxDescriptorSetUpdateAfterBindUniformBuffers
            uint32_t               maxDescriptorSetUpdateAfterBindUniformBuffersDynamic
            uint32_t               maxDescriptorSetUpdateAfterBindStorageBuffers
            uint32_t               maxDescriptorSetUpdateAfterBindStorageBuffersDynamic
            uint32_t               maxDescriptorSetUpdateAfterBindSampledImages
            uint32_t               maxDescriptorSetUpdateAfterBindStorageImages
            uint32_t               maxDescriptorSetUpdateAfterBindInputAttachments
        
        
            VkStructureType sType
            const void*            pNext
            uint32_t               bindingCount
            const VkDescriptorBindingFlagsEXT* pBindingFlags
        
        
            VkStructureType sType
            const void*            pNext
            uint32_t               descriptorSetCount
            const uint32_t* pDescriptorCounts
        
        
            VkStructureType sType
            void*            pNext
            uint32_t         maxVariableDescriptorCount
        
        
            VkStructureType sType
            const void*            pNext
            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
        
        
            VkStructureType sType
            const void* pNext
            uint32_t                          attachment
            VkImageLayout                     layout
            VkImageAspectFlags aspectMask
        
        
            VkStructureType sType
            const void*                           pNext
            VkSubpassDescriptionFlags                   flags
            VkPipelineBindPoint                                         pipelineBindPoint
            uint32_t                                                    viewMask
            uint32_t                                    inputAttachmentCount
            const VkAttachmentReference2KHR* pInputAttachments
            uint32_t                                    colorAttachmentCount
            const VkAttachmentReference2KHR* pColorAttachments
            const VkAttachmentReference2KHR* pResolveAttachments
            const VkAttachmentReference2KHR*            pDepthStencilAttachment
            uint32_t                                    preserveAttachmentCount
            const uint32_t*               pPreserveAttachments
        
        
            VkStructureType sType
            const void* pNext
            uint32_t                          srcSubpass
            uint32_t                          dstSubpass
            VkPipelineStageFlags              srcStageMask
            VkPipelineStageFlags              dstStageMask
            VkAccessFlags     srcAccessMask
            VkAccessFlags     dstAccessMask
            VkDependencyFlags dependencyFlags
            int32_t           viewOffset
        
        
            VkStructureType sType
            const void*                                              pNext
            VkRenderPassCreateFlags flags
            uint32_t                                 attachmentCount
            const VkAttachmentDescription2KHR* pAttachments
            uint32_t                                                 subpassCount
            const VkSubpassDescription2KHR*       pSubpasses
            uint32_t                                 dependencyCount
            const VkSubpassDependency2KHR*     pDependencies
            uint32_t                                 correlatedViewMaskCount
            const uint32_t*            pCorrelatedViewMasks
        
        
            VkStructureType sType
            const void*            pNext
            VkSubpassContents      contents
        
        
            VkStructureType sType
            const void*            pNext
        
        
            VkStructureType sType
            void*                  pNext
            VkBool32               timelineSemaphore
        
        
            VkStructureType sType
            void*                  pNext
            uint64_t               maxTimelineSemaphoreValueDifference
        
        
            VkStructureType sType
            const void*            pNext
            VkSemaphoreTypeKHR     semaphoreType
            uint64_t               initialValue
        
        
            VkStructureType sType
            const void*                      pNext
            uint32_t         waitSemaphoreValueCount
            const uint64_t* pWaitSemaphoreValues
            uint32_t         signalSemaphoreValueCount
            const uint64_t* pSignalSemaphoreValues
        
        
            VkStructureType sType
            const void*            pNext
            VkSemaphoreWaitFlagsKHR flags
            uint32_t               semaphoreCount
            const VkSemaphore* pSemaphores
            const uint64_t*    pValues
        
        
            VkStructureType sType
            const void*            pNext
            VkSemaphore            semaphore
            uint64_t               value
        
        
            uint32_t          binding
            uint32_t          divisor
        
        
            VkStructureType sType
            const void*                         pNext
            uint32_t                            vertexBindingDivisorCount
            const VkVertexInputBindingDivisorDescriptionEXT*      pVertexBindingDivisors
        
        
            VkStructureType sType
            void*                  pNext
            uint32_t               maxVertexAttribDivisormax value of vertex attribute divisor
        
        
            VkStructureType sType
            void*                  pNext
            uint32_t               pciDomain
            uint32_t               pciBus
            uint32_t               pciDevice
            uint32_t               pciFunction
        
        
            VkStructureType sType
            const void*                        pNext
            struct AHardwareBuffer*            buffer
        
        
            VkStructureType sType
            void*                              pNext
            uint64_t                           androidHardwareBufferUsage
        
        
            VkStructureType sType
            void*                              pNext
            VkDeviceSize                       allocationSize
            uint32_t                           memoryTypeBits
        
        
            VkStructureType sType
            const void*                        pNext
            VkDeviceMemory                     memory
        
        
            VkStructureType sType
            void*                              pNext
            VkFormat                           format
            uint64_t                           externalFormat
            VkFormatFeatureFlags               formatFeatures
            VkComponentMapping                 samplerYcbcrConversionComponents
            VkSamplerYcbcrModelConversion      suggestedYcbcrModel
            VkSamplerYcbcrRange                suggestedYcbcrRange
            VkChromaLocation                   suggestedXChromaOffset
            VkChromaLocation                   suggestedYChromaOffset
        
        
            VkStructureType sType
            const void*                         pNext
            VkBool32                            conditionalRenderingEnableWhether this secondary command buffer may be executed during an active conditional rendering
        
        
            VkStructureType sType
            void*                              pNext
            uint64_t                           externalFormat
        
        
            VkStructureType sType
            void*      pNext
            VkBool32                         storageBuffer8BitAccess8-bit integer variables supported in StorageBuffer
            VkBool32                         uniformAndStorageBuffer8BitAccess8-bit integer variables supported in StorageBuffer and Uniform
            VkBool32                         storagePushConstant88-bit integer variables supported in PushConstant
        
        
            VkStructureType sType
            void*        pNext
            VkBool32                           conditionalRendering
            VkBool32                           inheritedConditionalRendering
        
        
            VkStructureType sType
            void*      pNext
            VkBool32                         vulkanMemoryModel
            VkBool32                         vulkanMemoryModelDeviceScope
            VkBool32                         vulkanMemoryModelAvailabilityVisibilityChains
        
        
            VkStructureType sType
            void*                               pNext
            VkBool32                            shaderBufferInt64Atomics
            VkBool32                            shaderSharedInt64Atomics
        
        
            VkStructureType sType
            void*        pNext
            VkBool32                           vertexAttributeInstanceRateDivisor
            VkBool32                           vertexAttributeInstanceRateZeroDivisor
        
        
            VkStructureType sType
            void*           pNext
            VkPipelineStageFlags checkpointExecutionStageMask
        
        
            VkStructureType sType
            void*                  pNext
            VkPipelineStageFlagBits   stage
            void* pCheckpointMarker
        
        
            VkStructureType sType
            void*                                pNext
            VkResolveModeFlagsKHR                supportedDepthResolveModessupported depth resolve modes
            VkResolveModeFlagsKHR                supportedStencilResolveModessupported stencil resolve modes
            VkBool32                             independentResolveNonedepth and stencil resolve modes can be set independently if one of them is none
            VkBool32                             independentResolvedepth and stencil resolve modes can be set independently
        
        
            VkStructureType sType
            const void*                                              pNext
            VkResolveModeFlagBitsKHR                                 depthResolveModedepth resolve mode
            VkResolveModeFlagBitsKHR                                 stencilResolveModestencil resolve mode
            const VkAttachmentReference2KHR*         pDepthStencilResolveAttachmentdepth/stencil resolve attachment
        
        
            VkStructureType sType
            const void*                      pNext
            VkFormat                         decodeMode
        
        
            VkStructureType sType
            void*      pNext
            VkBool32                         decodeModeSharedExponent
        
        
            VkStructureType sType
            void*                  pNext
            VkBool32               transformFeedback
            VkBool32               geometryStreams
        
        
            VkStructureType sType
            void*                  pNext
            uint32_t               maxTransformFeedbackStreams
            uint32_t               maxTransformFeedbackBuffers
            VkDeviceSize           maxTransformFeedbackBufferSize
            uint32_t               maxTransformFeedbackStreamDataSize
            uint32_t               maxTransformFeedbackBufferDataSize
            uint32_t               maxTransformFeedbackBufferDataStride
            VkBool32               transformFeedbackQueries
            VkBool32               transformFeedbackStreamsLinesTriangles
            VkBool32               transformFeedbackRasterizationStreamSelect
            VkBool32               transformFeedbackDraw
        
        
            VkStructureType sType
            const void*                                                                      pNext
            VkPipelineRasterizationStateStreamCreateFlagsEXT                 flags
            uint32_t                                                                         rasterizationStream
        
        
            VkStructureTypesType
            void*    pNext
            VkBool32                       representativeFragmentTest
        
        
            VkStructureType sType
            const void*    pNext
            VkBool32       representativeFragmentTestEnable
        
        
            VkStructureType sType
            void*                            pNext
            VkBool32                         exclusiveScissor
        
        
            VkStructureType sType
            const void*                                                    pNext
            uint32_t                                       exclusiveScissorCount
            const VkRect2D*    pExclusiveScissors
        
        
            VkStructureType sType
            void*                              pNext
            VkBool32                           cornerSampledImage
        
        
            VkStructureType sType
            void*                            pNext
            VkBool32                         computeDerivativeGroupQuads
            VkBool32                         computeDerivativeGroupLinear
        
        
            VkStructureType sType
            void*                            pNext
            VkBool32                         fragmentShaderBarycentric
        
        
            VkStructureType sType
            void*                              pNext
            VkBool32                           imageFootprint
        
        
            VkStructureType sType
            void*                            pNext
            VkBool32                         dedicatedAllocationImageAliasing
        
        
            uint32_t                                                               shadingRatePaletteEntryCount
            const VkShadingRatePaletteEntryNV*  pShadingRatePaletteEntries
        
        
            VkStructureType sType
            const void*                                                            pNext
            VkBool32                                                               shadingRateImageEnable
            uint32_t                                                               viewportCount
            const VkShadingRatePaletteNV*      pShadingRatePalettes
        
        
            VkStructureType sType
            void*                               pNext
            VkBool32                            shadingRateImage
            VkBool32                            shadingRateCoarseSampleOrder
        
        
            VkStructureType sType
            void*                               pNext
            VkExtent2D                          shadingRateTexelSize
            uint32_t                            shadingRatePaletteSize
            uint32_t                            shadingRateMaxCoarseSamples
        
        
            uint32_t                            pixelX
            uint32_t                            pixelY
            uint32_t                            sample
        
        
            VkShadingRatePaletteEntryNV         shadingRate
            uint32_t                            sampleCount
            uint32_t                            sampleLocationCount
            const VkCoarseSampleLocationNV* pSampleLocations
        
        
            VkStructureType sType
            const void*                                                            pNext
            VkCoarseSampleOrderTypeNV                                              sampleOrderType
            uint32_t                                               customSampleOrderCount
            const VkCoarseSampleOrderCustomNV*        pCustomSampleOrders
        
        
            VkStructureType sType
            void*                               pNext
            VkBool32                            taskShader
            VkBool32                            meshShader
        
        
            VkStructureType sType
            void*                               pNext
            uint32_t                            maxDrawMeshTasksCount
            uint32_t                            maxTaskWorkGroupInvocations
            uint32_t                            maxTaskWorkGroupSize[3]
            uint32_t                            maxTaskTotalMemorySize
            uint32_t                            maxTaskOutputCount
            uint32_t                            maxMeshWorkGroupInvocations
            uint32_t                            maxMeshWorkGroupSize[3]
            uint32_t                            maxMeshTotalMemorySize
            uint32_t                            maxMeshOutputVertices
            uint32_t                            maxMeshOutputPrimitives
            uint32_t                            maxMeshMultiviewViewCount
            uint32_t                            meshOutputPerVertexGranularity
            uint32_t                            meshOutputPerPrimitiveGranularity
        
        
            uint32_t               taskCount
            uint32_t               firstTask
        
        
            VkStructureType sType
            const void*            pNext
            VkRayTracingShaderGroupTypeNV type
            uint32_t               generalShader
            uint32_t               closestHitShader
            uint32_t               anyHitShader
            uint32_t               intersectionShader
        
        
            VkStructureType sType
            const void*            pNext
            VkPipelineCreateFlags  flagsPipeline creation flags
            uint32_t               stageCount
            const VkPipelineShaderStageCreateInfo* pStagesOne entry for each active shader stage
            uint32_t               groupCount
            const VkRayTracingShaderGroupCreateInfoNV* pGroups
            uint32_t               maxRecursionDepth
            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
        
        
            VkStructureType sType
            const void*                pNext
            VkBuffer   vertexData
            VkDeviceSize               vertexOffset
            uint32_t                   vertexCount
            VkDeviceSize               vertexStride
            VkFormat                   vertexFormat
            VkBuffer   indexData
            VkDeviceSize               indexOffset
            uint32_t                   indexCount
            VkIndexType                indexType
            VkBuffer   transformDataOptional reference to array of floats representing a 3x4 row major affine transformation matrix.
            VkDeviceSize               transformOffset
        
        
            VkStructureType sType
            const void*                pNext
            VkBuffer   aabbData
            uint32_t                   numAABBs
            uint32_t                   strideStride in bytes between AABBs
            VkDeviceSize               offsetOffset in bytes of the first AABB in aabbData
        
        
            VkGeometryTrianglesNV                  triangles
            VkGeometryAABBNV                       aabbs
        
        
            VkStructureType sType
            const void*                        pNext
            VkGeometryTypeNV                  geometryType
            VkGeometryDataNV                  geometry
            VkGeometryFlagsNV flags
        
        
            VkStructureType sType
            const void*                            pNext
            VkAccelerationStructureTypeNV         type
            VkBuildAccelerationStructureFlagsNVflags
            uint32_t               instanceCount
            uint32_t               geometryCount
            const VkGeometryNV* pGeometries
        
        
            VkStructureType sType
            const void*                            pNext
            VkDeviceSize                           compactedSize
            VkAccelerationStructureInfoNV          info
        
        
            VkStructureType sType
            const void*                      pNext
            VkAccelerationStructureNV        accelerationStructure
            VkDeviceMemory                   memory
            VkDeviceSize                     memoryOffset
            uint32_t         deviceIndexCount
            const uint32_t*  pDeviceIndices
        
        
            VkStructureType sType
            const void*                      pNext
            uint32_t                         accelerationStructureCount
            const VkAccelerationStructureNV* pAccelerationStructures
        
        
            VkStructureType sType
            const void*                                                          pNext
            VkAccelerationStructureMemoryRequirementsTypeNV                      type
            VkAccelerationStructureNV                                            accelerationStructure
        
        
            VkStructureType sType
            void*                            pNext
            uint32_t                         shaderGroupHandleSize
            uint32_t                         maxRecursionDepth
            uint32_t                         maxShaderGroupStride
            uint32_t                         shaderGroupBaseAlignment
            uint64_t                         maxGeometryCount
            uint64_t                         maxInstanceCount
            uint64_t                         maxTriangleCount
            uint32_t                         maxDescriptorSetAccelerationStructures
        
        
            VkStructureType sType
            void* pNext
            uint32_t drmFormatModifierCount
            VkDrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties
        
        
            uint64_t drmFormatModifier
            uint32_t drmFormatModifierPlaneCount
            VkFormatFeatureFlags drmFormatModifierTilingFeatures
        
        
            VkStructureType sType
            const void* pNext
            uint64_t drmFormatModifier
            VkSharingMode sharingMode
            uint32_t queueFamilyIndexCount
            const uint32_t* pQueueFamilyIndices
        
        
            VkStructureType sType
            const void* pNext
            uint32_t drmFormatModifierCount
            const uint64_t* pDrmFormatModifiers
        
        
            VkStructureType sType
            const void* pNext
            uint64_t drmFormatModifier
            uint32_t drmFormatModifierPlaneCount
            const VkSubresourceLayout* pPlaneLayouts
        
        
            VkStructureType sType
            void* pNext
            uint64_t drmFormatModifier
        
        
            VkStructureType sType
            const void* pNext
            VkImageUsageFlags stencilUsage
        
        
            VkStructureType sType
            const void*                      pNext
            VkMemoryOverallocationBehaviorAMD overallocationBehavior
        
        
            VkStructureType sType
            void*                            pNext
            VkBool32                         fragmentDensityMap
            VkBool32                         fragmentDensityMapDynamic
            VkBool32                         fragmentDensityMapNonSubsampledImages
        
        
            VkStructureType sType
            void*                            pNext
            VkExtent2D                       minFragmentDensityTexelSize
            VkExtent2D                       maxFragmentDensityTexelSize
            VkBool32                         fragmentDensityInvocations
        
        
            VkStructureType sType
            const void*                      pNext
            VkAttachmentReference            fragmentDensityMapAttachment
        
        
            VkStructureType sType
            void*                               pNext
            VkBool32                            scalarBlockLayout
        
        
            VkStructureType sType
            const void* pNext
            VkBool32 supportsProtectedRepresents if surface can be protected
        
        
            VkStructureType sType
            void*                               pNext
            VkBool32                            uniformBufferStandardLayout
        
        
            VkStructureType sType
            void*                  pNextPointer to next structure
            VkBool32               depthClipEnable
        
        
            VkStructureType sType
            const void*                                                                 pNext                 
            VkPipelineRasterizationDepthClipStateCreateFlagsEXT         flags                 
            VkBool32                                                                    depthClipEnable
        
        
            VkStructureType sType
            void*        pNext
            VkDeviceSize                       heapBudget[VK_MAX_MEMORY_HEAPS]
            VkDeviceSize                       heapUsage[VK_MAX_MEMORY_HEAPS]
        
        
            VkStructureType sType
            void*        pNext
            VkBool32                           memoryPriority
        
        
            VkStructureType sType
            const void*                        pNext
            float                              priority
        
        
            VkStructureType sType
            void*        pNext
            VkBool32                           bufferDeviceAddress
            VkBool32                           bufferDeviceAddressCaptureReplay
            VkBool32                           bufferDeviceAddressMultiDevice
        
        
        
            VkStructureType sType
            const void*                                            pNext
            VkBuffer                                               buffer
        
        
            VkStructureType sType
            const void*                      pNext
            VkDeviceAddress                  deviceAddress
        
        
            VkStructureType sType
            void*                            pNext
            VkImageViewType                  imageViewType
        
        
            VkStructureType sType
            void*                            pNext
            VkBool32                         filterCubic 
            VkBool32                         filterCubicMinmax  
        
        
            VkStructureType sType
            void*                                    pNext
            VkBool32                                 imagelessFramebuffer
        
        
            VkStructureType sType
            const void*                              pNext
            uint32_t                 attachmentImageInfoCount
            const VkFramebufferAttachmentImageInfoKHR* pAttachmentImageInfos
        
        
            VkStructureType sType
            const void*                              pNext
            VkImageCreateFlags       flagsImage creation flags
            VkImageUsageFlags                        usageImage usage flags
            uint32_t                                 width
            uint32_t                                 height
            uint32_t                                 layerCount
            uint32_t                 viewFormatCount
            const VkFormat*    pViewFormats
        
        
            VkStructureType sType
            const void*                              pNext             
            uint32_t                 attachmentCount
            const VkImageView* pAttachments
        
        
            VkStructureType sType
            const void*            pNext                             
            VkBool32               textureCompressionASTC_HDR        
        
        
            VkStructureType sType
            void*                               pNext
            VkBool32                            cooperativeMatrix
            VkBool32                            cooperativeMatrixRobustBufferAccess
        
        
            VkStructureType sType
            void*                               pNext
            VkShaderStageFlags                  cooperativeMatrixSupportedStages
        
        
            VkStructureType sType
            void*                               pNext
            uint32_t                            MSize
            uint32_t                            NSize
            uint32_t                            KSize
            VkComponentTypeNV                   AType
            VkComponentTypeNV                   BType
            VkComponentTypeNV                   CType
            VkComponentTypeNV                   DType
            VkScopeNV                           scope
        
        
            VkStructureType sType
            void*        pNext
            VkBool32                           ycbcrImageArrays
        
        
            VkStructureType sType
            const void*            pNext
            VkImageView                         imageView
            VkDescriptorType                    descriptorType
            VkSampler           sampler
        
        
            VkStructureType sType
            const void*                      pNext
            GgpFrameToken                    frameToken
        
        
            VkPipelineCreationFeedbackFlagsEXT  flags
            uint64_t                            duration
        
        
            VkStructureType sType
            const void*                         pNext
            VkPipelineCreationFeedbackEXT*      pPipelineCreationFeedbackOutput pipeline creation feedback.
            uint32_t                            pipelineStageCreationFeedbackCount
            VkPipelineCreationFeedbackEXT* pPipelineStageCreationFeedbacksOne entry for each shader stage specified in the parent Vk*PipelineCreateInfo struct
        
        
            VkStructureType sType
            void*                            pNext
            VkFullScreenExclusiveEXT         fullScreenExclusive
        
        
            VkStructureType sType
            const void*      pNext
            HMONITOR         hmonitor
        
        
            VkStructureType sType
            void*            pNext
            VkBool32         fullScreenExclusiveSupported
        
        
            VkStructureType sType
            const void*            pNext
            VkHeadlessSurfaceCreateFlagsEXT   flags
        
        
            VkStructureTypesType
            void*    pNext
            VkBool32                       coverageReductionMode
        
        
            VkStructureType sType
            const void*                                                        pNext
            VkPipelineCoverageReductionStateCreateFlagsNV      flags
            VkCoverageReductionModeNV                                          coverageReductionMode
        
        
            VkStructureType sType
            void*                      pNext
            VkCoverageReductionModeNV  coverageReductionMode
            VkSampleCountFlagBits      rasterizationSamples
            VkSampleCountFlags         depthStencilSamples
            VkSampleCountFlags         colorSamples
        
        
            VkStructureType sType
            void*                            pNext
            VkBool32                         shaderIntegerFunctions2
        
        
            uint32_t                           value32
            uint64_t                           value64
            float                              valueFloat
            VkBool32                           valueBool
            const char*                        valueString
        
        
            VkPerformanceValueTypeINTEL        type
            VkPerformanceValueDataINTEL        data
        
        
            VkStructureType sType
            const void*                         pNext
            void*             pUserData
        
        
            VkStructureType sType
            const void*                         pNext
            VkQueryPoolSamplingModeINTEL        performanceCountersSampling
        
        
            VkStructureType sType
            const void*                         pNext
            uint64_t                            marker
        
        
            VkStructureType sType
            const void*                         pNext
            uint32_t                            marker
        
        
            VkStructureType sType
            const void*                         pNext
            VkPerformanceOverrideTypeINTEL      type
            VkBool32                            enable
            uint64_t                            parameter
        
        
            VkStructureType sType
            const void*                         pNext
            VkPerformanceConfigurationTypeINTEL type
        
        
            VkStructureType sType
            void*                               pNext
            VkBool32                            shaderSubgroupClock
            VkBool32                            shaderDeviceClock
        
        
            VkStructureType sType
            void*        pNext
            VkBool32                           indexTypeUint8
        
        
            VkStructureType sType
            void*                          pNext
            uint32_t                       shaderSMCount
            uint32_t                       shaderWarpsPerSM
        
        
            VkStructureTypesType
            void*    pNext
            VkBool32                       shaderSMBuiltins
        
        
            VkStructureType sType
            void*                  pNextPointer to next structure
            VkBool32               fragmentShaderSampleInterlock
            VkBool32               fragmentShaderPixelInterlock
            VkBool32               fragmentShaderShadingRateInterlock
        
        
            VkStructureTypesType
            void*    pNext
            VkBool32                       separateDepthStencilLayouts
        
        
            VkStructureTypesType
            void*    pNext
            VkImageLayout                  stencilLayout
        
        
            VkStructureTypesType
            void*    pNext
            VkImageLayout                  stencilInitialLayout
            VkImageLayout                  stencilFinalLayout
        
        
            VkStructureType sType
            void*              pNext
            VkBool32           pipelineExecutableInfo
        
        
            VkStructureType sType
            const void*        pNext
            VkPipeline         pipeline
        
        
            VkStructureType sType
            void*              pNext
            VkShaderStageFlags stages
            char               name[VK_MAX_DESCRIPTION_SIZE]
            char               description[VK_MAX_DESCRIPTION_SIZE]
            uint32_t           subgroupSize
        
        
            VkStructureType sType
            const void*        pNext
            VkPipeline         pipeline
            uint32_t           executableIndex
        
        
            VkBool32           b32
            int64_t            i64
            uint64_t           u64
            double             f64
        
        
            VkStructureType sType
            void*              pNext
            char               name[VK_MAX_DESCRIPTION_SIZE]
            char               description[VK_MAX_DESCRIPTION_SIZE]
            VkPipelineExecutableStatisticFormatKHR format
            VkPipelineExecutableStatisticValueKHR  value
        
        
            VkStructureType sType
            void*              pNext
            char               name[VK_MAX_DESCRIPTION_SIZE]
            char               description[VK_MAX_DESCRIPTION_SIZE]
            VkBool32           isText
            size_t               dataSize
            void* pData
        
        
            VkStructureType sType
            void*        pNext
            VkBool32                           shaderDemoteToHelperInvocation
        
        
            VkStructureType sType
            void*        pNext
            VkBool32                           texelBufferAlignment
        
        
            VkStructureType sType
            void*        pNext
            VkDeviceSize                       storageTexelBufferOffsetAlignmentBytes
            VkBool32                           storageTexelBufferOffsetSingleTexelAlignment
            VkDeviceSize                       uniformTexelBufferOffsetAlignmentBytes
            VkBool32                           uniformTexelBufferOffsetSingleTexelAlignment
        
        
             VkStructureType sType
             void*                          pNext
             VkBool32 subgroupSizeControl
             VkBool32 computeFullSubgroups
        
        
             VkStructureType sType
             void*                          pNext
             uint32_t minSubgroupSizeThe minimum subgroup size supported by this device
             uint32_t maxSubgroupSizeThe maximum subgroup size supported by this device
             uint32_t maxComputeWorkgroupSubgroupsThe maximum number of subgroups supported in a workgroup
             VkShaderStageFlags             requiredSubgroupSizeStagesThe shader stages that support specifying a subgroup size
        
        
            VkStructureType sType
            void*                  pNext
            uint32_t               requiredSubgroupSize
        
        
            VkStructureType sType
            void*        pNext
            VkBool32                           rectangularLines
            VkBool32                           bresenhamLines
            VkBool32                           smoothLines
            VkBool32                           stippledRectangularLines
            VkBool32                           stippledBresenhamLines
            VkBool32                           stippledSmoothLines
        
        
            VkStructureType sType
            void*                               pNext
            uint32_t                            lineSubPixelPrecisionBits
        
        
            VkStructureType sType
            const void*                                                      pNext
            VkLineRasterizationModeEXT                                       lineRasterizationMode
            VkBool32                                                         stippledLineEnable
            uint32_t                                         lineStippleFactor
            uint16_t                                         lineStipplePattern
        
        
            VkStructureType   sType
            const void*                                                                            pNext
            VkPipelineCompilerControlFlagsAMD                                      compilerControlFlags
        
        
            VkStructureType sType
            void*        pNext
            VkBool32                           deviceCoherentMemory
        
    
    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
    
        
        
        
        
    
    
        
        
    
    
        
        
        
        
    
    
        
        
        
        
    
    
        
        
        
        
        
        
        
        
        
    
    
      
    
    
        
        
        
        
    
    
        
        
        
        
        
    
    
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
    
    
        
        
    
    
        
        
        
        
    
    
        
        
        
    
    
        
        
    
    
        
        
        
    
    
        
        
        
        
        
        
        
    
    
        
        
        
        
        
        
        
        
    
    
        
        
        
        
    
    
        
        
    
    
        
        
        
        
        
        
        
        
    
    
        
        
        
        
        
    
    
    
    
        
        
        
        
        
        
        
    
    
        
        
        
    
    
        
        
        
        
        
    
    
        
        
    
    
        
    
    
        
        
        
        
    
    
        
        
    
    
        
    
    
        
    
    
        
        
        
    
    
        
    
    
        
    
    
        
        
        
        
    
    
        
    
    
        
        
        
        
    
    
    
    
        
        
        
        
        
        
        
        
    
    
        
        
    
    
    
    
        
        
    
    
        
        
        
    
    
        
        
    
    
        
        
        
        
        
    
    
        
        
    
    
        
        
    
    
        
        
        
    
    
        
        
        
        
    
    
        
        
    
    
        
    
    
        
        
        
    
    
        
        
        
        
    
    
        
        
        
        
    
    
        
        
        
    
    
        
        
        
    
    
        
        
        
        
    
    
        Vendor IDs are now represented as enums instead of the old
                 <vendorids> tag, allowing them to be included in the
                 API headers.
        
        
        
            
    
    
        Driver IDs are now represented as enums instead of the old
                 <driverids> tag, allowing them to be included in the
                 API headers.
        
        
        
        
        
        
        
        
        
        
        
        
    
    
        
    
    
        
        
        
        
        
    
    
        
        
        
        
        
        
        
        
        
        
        
        
    
    
        
        
        
        
    
    
        
        
        
        
    
    
        
        
    
    
        
        
        
        
        
    
    
        
        
    
    
        
        
    
    
        
        
    
    
        
        
        
    
    
        
        
        
    
    
        
        
        
    
    
    
    
        
        
        
        
    
    
        
        
        
        
        
        
        
        
        
        
        
    
    
        
        
        
    
    
        
        
        
        
    
    
    
    
        
    
    
        
    
    
        
        
    
    
        
        
    
    
        
        
        
        
        
    
    
        
        
        
        
    
    
        
        
        
    
    
        
        
        
        
    
    
    
    
    
    
        
            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 vkEnumerateInstanceVersion
            uint32_t* pApiVersion
        
        
            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
        
        
            void vkResetQueryPoolEXT
            VkDevice device
            VkQueryPool queryPool
            uint32_t firstQuery
            uint32_t queryCount
        
        
            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 vkCmdBeginConditionalRenderingEXT
            VkCommandBuffer commandBuffer
            const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin
        
        
            void vkCmdEndConditionalRenderingEXT
            VkCommandBuffer commandBuffer
        
        
            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
        
        
            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 vkCreateImagePipeSurfaceFUCHSIA
            VkInstance instance
            const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo
            const VkAllocationCallbacks* pAllocator
            VkSurfaceKHR* pSurface
        
        
            VkResult vkCreateStreamDescriptorSurfaceGGP
            VkInstance instance
            const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo
            const VkAllocationCallbacks* pAllocator
            VkSurfaceKHR* pSurface
        
        
            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 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 vkGetPhysicalDeviceFeatures2
            VkPhysicalDevice physicalDevice
            VkPhysicalDeviceFeatures2* pFeatures
        
        
        
            void vkGetPhysicalDeviceProperties2
            VkPhysicalDevice physicalDevice
            VkPhysicalDeviceProperties2* pProperties
        
        
        
            void vkGetPhysicalDeviceFormatProperties2
            VkPhysicalDevice physicalDevice
            VkFormat format
            VkFormatProperties2* pFormatProperties
        
        
        
            VkResult vkGetPhysicalDeviceImageFormatProperties2
            VkPhysicalDevice physicalDevice
            const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo
            VkImageFormatProperties2* pImageFormatProperties
        
        
        
            void vkGetPhysicalDeviceQueueFamilyProperties2
            VkPhysicalDevice physicalDevice
            uint32_t* pQueueFamilyPropertyCount
            VkQueueFamilyProperties2* pQueueFamilyProperties
        
        
        
            void vkGetPhysicalDeviceMemoryProperties2
            VkPhysicalDevice physicalDevice
            VkPhysicalDeviceMemoryProperties2* pMemoryProperties
        
        
        
            void vkGetPhysicalDeviceSparseImageFormatProperties2
            VkPhysicalDevice physicalDevice
            const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo
            uint32_t* pPropertyCount
            VkSparseImageFormatProperties2* pProperties
        
        
        
            void vkCmdPushDescriptorSetKHR
            VkCommandBuffer commandBuffer
            VkPipelineBindPoint pipelineBindPoint
            VkPipelineLayout layout
            uint32_t set
            uint32_t descriptorWriteCount
            const VkWriteDescriptorSet* pDescriptorWrites
        
        
            void vkTrimCommandPool
            VkDevice device
            VkCommandPool commandPool
            VkCommandPoolTrimFlags flags
        
        
        
            void vkGetPhysicalDeviceExternalBufferProperties
            VkPhysicalDevice physicalDevice
            const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo
            VkExternalBufferProperties* pExternalBufferProperties
        
        
        
            VkResult vkGetMemoryWin32HandleKHR
            VkDevice device
            const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo
            HANDLE* pHandle
        
        
            VkResult vkGetMemoryWin32HandlePropertiesKHR
            VkDevice device
            VkExternalMemoryHandleTypeFlagBits handleType
            HANDLE handle
            VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties
        
        
            VkResult vkGetMemoryFdKHR
            VkDevice device
            const VkMemoryGetFdInfoKHR* pGetFdInfo
            int* pFd
        
        
            VkResult vkGetMemoryFdPropertiesKHR
            VkDevice device
            VkExternalMemoryHandleTypeFlagBits handleType
            int fd
            VkMemoryFdPropertiesKHR* pMemoryFdProperties
        
        
            void vkGetPhysicalDeviceExternalSemaphoreProperties
            VkPhysicalDevice physicalDevice
            const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo
            VkExternalSemaphoreProperties* 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 vkGetPhysicalDeviceExternalFenceProperties
            VkPhysicalDevice physicalDevice
            const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo
            VkExternalFenceProperties* 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 vkEnumeratePhysicalDeviceGroups
            VkInstance instance
            uint32_t* pPhysicalDeviceGroupCount
            VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties
        
        
        
            void vkGetDeviceGroupPeerMemoryFeatures
            VkDevice device
            uint32_t heapIndex
            uint32_t localDeviceIndex
            uint32_t remoteDeviceIndex
            VkPeerMemoryFeatureFlags* pPeerMemoryFeatures
        
        
        
            VkResult vkBindBufferMemory2
            VkDevice device
            uint32_t bindInfoCount
            const VkBindBufferMemoryInfo* pBindInfos
        
        
        
            VkResult vkBindImageMemory2
            VkDevice device
            uint32_t bindInfoCount
            const VkBindImageMemoryInfo* pBindInfos
        
        
        
            void vkCmdSetDeviceMask
            VkCommandBuffer commandBuffer
            uint32_t deviceMask
        
        
        
            VkResult vkGetDeviceGroupPresentCapabilitiesKHR
            VkDevice device
            VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities
        
        
            VkResult vkGetDeviceGroupSurfacePresentModesKHR
            VkDevice device
            VkSurfaceKHR surface
            VkDeviceGroupPresentModeFlagsKHR* pModes
        
        
            VkResult vkAcquireNextImage2KHR
            VkDevice device
            const VkAcquireNextImageInfoKHR* pAcquireInfo
            uint32_t* pImageIndex
        
        
            void vkCmdDispatchBase
            VkCommandBuffer commandBuffer
            uint32_t baseGroupX
            uint32_t baseGroupY
            uint32_t baseGroupZ
            uint32_t groupCountX
            uint32_t groupCountY
            uint32_t groupCountZ
        
        
        
            VkResult vkGetPhysicalDevicePresentRectanglesKHR
            VkPhysicalDevice physicalDevice
            VkSurfaceKHR surface
            uint32_t* pRectCount
            VkRect2D* pRects
        
        
            VkResult vkCreateDescriptorUpdateTemplate
            VkDevice device
            const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo
            const VkAllocationCallbacks* pAllocator
            VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate
        
        
        
            void vkDestroyDescriptorUpdateTemplate
            VkDevice device
            VkDescriptorUpdateTemplate descriptorUpdateTemplate
            const VkAllocationCallbacks* pAllocator
        
        
        
            void vkUpdateDescriptorSetWithTemplate
            VkDevice device
            VkDescriptorSet descriptorSet
            VkDescriptorUpdateTemplate descriptorUpdateTemplate
            const void* pData
        
        
        
            void vkCmdPushDescriptorSetWithTemplateKHR
            VkCommandBuffer commandBuffer
            VkDescriptorUpdateTemplate 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
        
        
            VkResult vkCreateMetalSurfaceEXT
            VkInstance instance
            const VkMetalSurfaceCreateInfoEXT* 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
        
        
            VkResult vkGetPhysicalDeviceDisplayProperties2KHR
            VkPhysicalDevice physicalDevice
            uint32_t* pPropertyCount
            VkDisplayProperties2KHR* pProperties
        
        
            VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR
            VkPhysicalDevice physicalDevice
            uint32_t* pPropertyCount
            VkDisplayPlaneProperties2KHR* pProperties
        
        
            VkResult vkGetDisplayModeProperties2KHR
            VkPhysicalDevice physicalDevice
            VkDisplayKHR display
            uint32_t* pPropertyCount
            VkDisplayModeProperties2KHR* pProperties
        
        
            VkResult vkGetDisplayPlaneCapabilities2KHR
            VkPhysicalDevice physicalDevice
            const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo
            VkDisplayPlaneCapabilities2KHR* pCapabilities
        
        
            void vkGetBufferMemoryRequirements2
            VkDevice device
            const VkBufferMemoryRequirementsInfo2* pInfo
            VkMemoryRequirements2* pMemoryRequirements
        
        
        
            void vkGetImageMemoryRequirements2
            VkDevice device
            const VkImageMemoryRequirementsInfo2* pInfo
            VkMemoryRequirements2* pMemoryRequirements
        
        
        
            void vkGetImageSparseMemoryRequirements2
            VkDevice device
            const VkImageSparseMemoryRequirementsInfo2* pInfo
            uint32_t* pSparseMemoryRequirementCount
            VkSparseImageMemoryRequirements2* pSparseMemoryRequirements
        
        
        
            VkResult vkCreateSamplerYcbcrConversion
            VkDevice device
            const VkSamplerYcbcrConversionCreateInfo* pCreateInfo
            const VkAllocationCallbacks* pAllocator
            VkSamplerYcbcrConversion* pYcbcrConversion
        
        
        
            void vkDestroySamplerYcbcrConversion
            VkDevice device
            VkSamplerYcbcrConversion ycbcrConversion
            const VkAllocationCallbacks* pAllocator
        
        
        
            void vkGetDeviceQueue2
            VkDevice device
            const VkDeviceQueueInfo2* pQueueInfo
            VkQueue* pQueue
        
        
            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
        
        
            void vkGetDescriptorSetLayoutSupport
            VkDevice device
            const VkDescriptorSetLayoutCreateInfo* pCreateInfo
            VkDescriptorSetLayoutSupport* pSupport
        
        
        
            VkResult vkGetSwapchainGrallocUsageANDROID
            VkDevice device
            VkFormat format
            VkImageUsageFlags imageUsage
            int* grallocUsage
        
        
            VkResult vkGetSwapchainGrallocUsage2ANDROID
            VkDevice device
            VkFormat format
            VkImageUsageFlags imageUsage
            VkSwapchainImageUsageFlagsANDROID swapchainImageUsage
            uint64_t* grallocConsumerUsage
            uint64_t* grallocProducerUsage
        
        
            VkResult vkAcquireImageANDROID
            VkDevice device
            VkImage image
            int nativeFenceFd
            VkSemaphore semaphore
            VkFence fence
        
        
            VkResult vkQueueSignalReleaseImageANDROID
            VkQueue queue
            uint32_t waitSemaphoreCount
            const VkSemaphore* pWaitSemaphores
            VkImage image
            int* pNativeFenceFd
        
        
            VkResult vkGetShaderInfoAMD
            VkDevice device
            VkPipeline pipeline
            VkShaderStageFlagBits shaderStage
            VkShaderInfoTypeAMD infoType
            size_t* pInfoSize
            void* pInfo
        
        
            void vkSetLocalDimmingAMD
            VkDevice device
            VkSwapchainKHR swapChain
            VkBool32 localDimmingEnable
        
        
            VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsEXT
            VkPhysicalDevice physicalDevice
            uint32_t* pTimeDomainCount
            VkTimeDomainEXT* pTimeDomains
        
        
            VkResult vkGetCalibratedTimestampsEXT
            VkDevice device
            uint32_t timestampCount
            const VkCalibratedTimestampInfoEXT* pTimestampInfos
            uint64_t* pTimestamps
            uint64_t* pMaxDeviation
        
        
            VkResult vkSetDebugUtilsObjectNameEXT
            VkDevice device
            const VkDebugUtilsObjectNameInfoEXT* pNameInfo
        
        
            VkResult vkSetDebugUtilsObjectTagEXT
            VkDevice device
            const VkDebugUtilsObjectTagInfoEXT* pTagInfo
        
        
            void vkQueueBeginDebugUtilsLabelEXT
            VkQueue queue
            const VkDebugUtilsLabelEXT* pLabelInfo
        
        
            void vkQueueEndDebugUtilsLabelEXT
            VkQueue queue
        
        
            void vkQueueInsertDebugUtilsLabelEXT
            VkQueue queue
            const VkDebugUtilsLabelEXT* pLabelInfo
        
        
            void vkCmdBeginDebugUtilsLabelEXT
            VkCommandBuffer commandBuffer
            const VkDebugUtilsLabelEXT* pLabelInfo
        
        
            void vkCmdEndDebugUtilsLabelEXT
            VkCommandBuffer commandBuffer
        
        
            void vkCmdInsertDebugUtilsLabelEXT
            VkCommandBuffer commandBuffer
            const VkDebugUtilsLabelEXT* pLabelInfo
        
        
            VkResult vkCreateDebugUtilsMessengerEXT
            VkInstance instance
            const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo
            const VkAllocationCallbacks* pAllocator
            VkDebugUtilsMessengerEXT* pMessenger
        
        
            void vkDestroyDebugUtilsMessengerEXT
            VkInstance instance
            VkDebugUtilsMessengerEXT messenger
            const VkAllocationCallbacks* pAllocator
        
        
            void vkSubmitDebugUtilsMessageEXT
            VkInstance instance
            VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity
            VkDebugUtilsMessageTypeFlagsEXT messageTypes
            const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData
        
        
            VkResult vkGetMemoryHostPointerPropertiesEXT
            VkDevice device
            VkExternalMemoryHandleTypeFlagBits handleType
            const void* pHostPointer
            VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties
        
        
            void vkCmdWriteBufferMarkerAMD
            VkCommandBuffer commandBuffer
            VkPipelineStageFlagBits pipelineStage
            VkBuffer dstBuffer
            VkDeviceSize dstOffset
            uint32_t marker
        
        
            VkResult vkCreateRenderPass2KHR
            VkDevice device
            const VkRenderPassCreateInfo2KHR* pCreateInfo
            const VkAllocationCallbacks* pAllocator
            VkRenderPass* pRenderPass
        
        
            void vkCmdBeginRenderPass2KHR
            VkCommandBuffer commandBuffer
            const VkRenderPassBeginInfo*      pRenderPassBegin
            const VkSubpassBeginInfoKHR*      pSubpassBeginInfo
        
        
            void vkCmdNextSubpass2KHR
            VkCommandBuffer commandBuffer
            const VkSubpassBeginInfoKHR*      pSubpassBeginInfo
            const VkSubpassEndInfoKHR*        pSubpassEndInfo
        
        
            void vkCmdEndRenderPass2KHR
            VkCommandBuffer commandBuffer
            const VkSubpassEndInfoKHR*        pSubpassEndInfo
        
        
            VkResult vkGetSemaphoreCounterValueKHR
            VkDevice device
            VkSemaphore semaphore
            uint64_t* pValue
        
        
            VkResult vkWaitSemaphoresKHR
            VkDevice device
            const VkSemaphoreWaitInfoKHR* pWaitInfo
            uint64_t timeout
        
        
            VkResult vkSignalSemaphoreKHR
            VkDevice device
            const VkSemaphoreSignalInfoKHR* pSignalInfo
        
        
            VkResult vkGetAndroidHardwareBufferPropertiesANDROID
            VkDevice device
            const struct AHardwareBuffer* buffer
            VkAndroidHardwareBufferPropertiesANDROID* pProperties
        
        
            VkResult vkGetMemoryAndroidHardwareBufferANDROID
            VkDevice device
            const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo
            struct AHardwareBuffer** pBuffer
        
        
            void vkCmdDrawIndirectCountKHR
            VkCommandBuffer commandBuffer
            VkBuffer buffer
            VkDeviceSize offset
            VkBuffer countBuffer
            VkDeviceSize countBufferOffset
            uint32_t maxDrawCount
            uint32_t stride
        
        
        
            void vkCmdDrawIndexedIndirectCountKHR
            VkCommandBuffer commandBuffer
            VkBuffer buffer
            VkDeviceSize offset
            VkBuffer countBuffer
            VkDeviceSize countBufferOffset
            uint32_t maxDrawCount
            uint32_t stride
        
        
        
            void vkCmdSetCheckpointNV
            VkCommandBuffer commandBuffer
            const void* pCheckpointMarker
        
        
            void vkGetQueueCheckpointDataNV
            VkQueue queue
            uint32_t* pCheckpointDataCount
            VkCheckpointDataNV* pCheckpointData
        
        
            void vkCmdBindTransformFeedbackBuffersEXT
            VkCommandBuffer commandBuffer
            uint32_t firstBinding
            uint32_t bindingCount
            const VkBuffer* pBuffers
            const VkDeviceSize* pOffsets
            const VkDeviceSize* pSizes
        
        
            void vkCmdBeginTransformFeedbackEXT
            VkCommandBuffer commandBuffer
            uint32_t firstCounterBuffer
            uint32_t counterBufferCount
            const VkBuffer* pCounterBuffers
            const VkDeviceSize* pCounterBufferOffsets
        
        
            void vkCmdEndTransformFeedbackEXT
            VkCommandBuffer commandBuffer
            uint32_t firstCounterBuffer
            uint32_t counterBufferCount
            const VkBuffer* pCounterBuffers
            const VkDeviceSize* pCounterBufferOffsets
        
        
            void vkCmdBeginQueryIndexedEXT
            VkCommandBuffer commandBuffer
            VkQueryPool queryPool
            uint32_t query
            VkQueryControlFlags flags
            uint32_t index
        
        
            void vkCmdEndQueryIndexedEXT
            VkCommandBuffer commandBuffer
            VkQueryPool queryPool
            uint32_t query
            uint32_t index
        
        
            void vkCmdDrawIndirectByteCountEXT
            VkCommandBuffer commandBuffer
            uint32_t instanceCount
            uint32_t firstInstance
            VkBuffer counterBuffer
            VkDeviceSize counterBufferOffset
            uint32_t counterOffset
            uint32_t vertexStride
        
        
            void vkCmdSetExclusiveScissorNV
            VkCommandBuffer commandBuffer
            uint32_t firstExclusiveScissor
            uint32_t exclusiveScissorCount
            const VkRect2D* pExclusiveScissors
        
        
            void vkCmdBindShadingRateImageNV
            VkCommandBuffer commandBuffer
            VkImageView imageView
            VkImageLayout imageLayout
        
        
            void vkCmdSetViewportShadingRatePaletteNV
            VkCommandBuffer commandBuffer
            uint32_t firstViewport
            uint32_t viewportCount
            const VkShadingRatePaletteNV* pShadingRatePalettes
        
        
            void vkCmdSetCoarseSampleOrderNV
            VkCommandBuffer commandBuffer
            VkCoarseSampleOrderTypeNV sampleOrderType
            uint32_t customSampleOrderCount
            const VkCoarseSampleOrderCustomNV* pCustomSampleOrders
        
        
            void vkCmdDrawMeshTasksNV
            VkCommandBuffer commandBuffer
            uint32_t taskCount
            uint32_t firstTask
        
        
            void vkCmdDrawMeshTasksIndirectNV
            VkCommandBuffer commandBuffer
            VkBuffer buffer
            VkDeviceSize offset
            uint32_t drawCount
            uint32_t stride
        
        
            void vkCmdDrawMeshTasksIndirectCountNV
            VkCommandBuffer commandBuffer
            VkBuffer buffer
            VkDeviceSize offset
            VkBuffer countBuffer
            VkDeviceSize countBufferOffset
            uint32_t maxDrawCount
            uint32_t stride
        
        
            VkResult vkCompileDeferredNV
            VkDevice device
            VkPipeline pipeline
            uint32_t shader
        
        
            VkResult vkCreateAccelerationStructureNV
            VkDevice device
            const VkAccelerationStructureCreateInfoNV* pCreateInfo
            const VkAllocationCallbacks* pAllocator
            VkAccelerationStructureNV* pAccelerationStructure
        
        
            void vkDestroyAccelerationStructureNV
            VkDevice device
            VkAccelerationStructureNV accelerationStructure
            const VkAllocationCallbacks* pAllocator
        
        
            void vkGetAccelerationStructureMemoryRequirementsNV
            VkDevice device
            const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo
            VkMemoryRequirements2KHR* pMemoryRequirements
        
        
            VkResult vkBindAccelerationStructureMemoryNV
            VkDevice device
            uint32_t bindInfoCount
            const VkBindAccelerationStructureMemoryInfoNV* pBindInfos
        
        
            void vkCmdCopyAccelerationStructureNV
            VkCommandBuffer commandBuffer
            VkAccelerationStructureNV dst
            VkAccelerationStructureNV src
            VkCopyAccelerationStructureModeNV mode
        
        
            void vkCmdWriteAccelerationStructuresPropertiesNV
            VkCommandBuffer commandBuffer
            uint32_t accelerationStructureCount
            const VkAccelerationStructureNV* pAccelerationStructures
            VkQueryType queryType
            VkQueryPool queryPool
            uint32_t firstQuery
        
        
            void vkCmdBuildAccelerationStructureNV
            VkCommandBuffer commandBuffer
            const VkAccelerationStructureInfoNV* pInfo
            VkBuffer instanceData
            VkDeviceSize instanceOffset
            VkBool32 update
            VkAccelerationStructureNV dst
            VkAccelerationStructureNV src
            VkBuffer scratch
            VkDeviceSize scratchOffset
        
        
            void vkCmdTraceRaysNV
            VkCommandBuffer commandBuffer
            VkBuffer raygenShaderBindingTableBuffer
            VkDeviceSize raygenShaderBindingOffset
            VkBuffer missShaderBindingTableBuffer
            VkDeviceSize missShaderBindingOffset
            VkDeviceSize missShaderBindingStride
            VkBuffer hitShaderBindingTableBuffer
            VkDeviceSize hitShaderBindingOffset
            VkDeviceSize hitShaderBindingStride
            VkBuffer callableShaderBindingTableBuffer
            VkDeviceSize callableShaderBindingOffset
            VkDeviceSize callableShaderBindingStride
            uint32_t width
            uint32_t height
            uint32_t depth
        
        
            VkResult vkGetRayTracingShaderGroupHandlesNV
            VkDevice device
            VkPipeline pipeline
            uint32_t firstGroup
            uint32_t groupCount
            size_t dataSize
            void* pData
        
        
            VkResult vkGetAccelerationStructureHandleNV
            VkDevice device
            VkAccelerationStructureNV accelerationStructure
            size_t dataSize
            void* pData
        
        
            VkResult vkCreateRayTracingPipelinesNV
            VkDevice device
            VkPipelineCache pipelineCache
            uint32_t createInfoCount
            const VkRayTracingPipelineCreateInfoNV* pCreateInfos
            const VkAllocationCallbacks* pAllocator
            VkPipeline* pPipelines
        
        
            VkResult vkGetImageDrmFormatModifierPropertiesEXT
            VkDevice device
            VkImage image
            VkImageDrmFormatModifierPropertiesEXT* pProperties
        
        
            VkDeviceAddress vkGetBufferDeviceAddressEXT
            VkDevice device
            const VkBufferDeviceAddressInfoEXT* pInfo
        
        
            VkResult vkGetPhysicalDeviceCooperativeMatrixPropertiesNV
            VkPhysicalDevice physicalDevice
            uint32_t* pPropertyCount
            VkCooperativeMatrixPropertiesNV* pProperties
        
        
            uint32_t vkGetImageViewHandleNVX
            VkDevice device
            const VkImageViewHandleInfoNVX* pInfo
        
        
            VkResult vkGetPhysicalDeviceSurfacePresentModes2EXT
            VkPhysicalDevice physicalDevice
            const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo
            uint32_t* pPresentModeCount
            VkPresentModeKHR* pPresentModes
        
        
            VkResult vkGetDeviceGroupSurfacePresentModes2EXT
            VkDevice device
            const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo
            VkDeviceGroupPresentModeFlagsKHR* pModes
        
        
            VkResult vkAcquireFullScreenExclusiveModeEXT
            VkDevice device
            VkSwapchainKHR swapchain
        
        
            VkResult vkReleaseFullScreenExclusiveModeEXT
            VkDevice device
            VkSwapchainKHR swapchain
        
        
            VkResult vkCreateHeadlessSurfaceEXT
            VkInstance instance
            const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo
            const VkAllocationCallbacks* pAllocator
            VkSurfaceKHR* pSurface
        
        
            VkResult vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV
            VkPhysicalDevice physicalDevice
            uint32_t* pCombinationCount
            VkFramebufferMixedSamplesCombinationNV* pCombinations
        
        
            VkResult vkInitializePerformanceApiINTEL
            VkDevice device
            const VkInitializePerformanceApiInfoINTEL* pInitializeInfo
        
        
            void vkUninitializePerformanceApiINTEL
            VkDevice device
        
        
            VkResult vkCmdSetPerformanceMarkerINTEL
            VkCommandBuffer commandBuffer
            const VkPerformanceMarkerInfoINTEL* pMarkerInfo
        
        
            VkResult vkCmdSetPerformanceStreamMarkerINTEL
            VkCommandBuffer commandBuffer
            const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo
        
        
            VkResult vkCmdSetPerformanceOverrideINTEL
            VkCommandBuffer commandBuffer
            const VkPerformanceOverrideInfoINTEL* pOverrideInfo
        
        
            VkResult vkAcquirePerformanceConfigurationINTEL
            VkDevice device
            const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo
            VkPerformanceConfigurationINTEL* pConfiguration
        
        
            VkResult vkReleasePerformanceConfigurationINTEL
            VkDevice device
            VkPerformanceConfigurationINTEL configuration
        
        
            VkResult vkQueueSetPerformanceConfigurationINTEL
            VkQueue queue
            VkPerformanceConfigurationINTEL configuration
        
        
            VkResult vkGetPerformanceParameterINTEL
            VkDevice device
            VkPerformanceParameterTypeINTEL parameter
            VkPerformanceValueINTEL* pValue
        
        
            VkResult vkGetPipelineExecutablePropertiesKHR
            VkDevice                        device
            const VkPipelineInfoKHR*        pPipelineInfo
            uint32_t* pExecutableCount
            VkPipelineExecutablePropertiesKHR* pProperties
        
        
            VkResult vkGetPipelineExecutableStatisticsKHR
            VkDevice                        device
            const VkPipelineExecutableInfoKHR*  pExecutableInfo
            uint32_t* pStatisticCount
            VkPipelineExecutableStatisticKHR* pStatistics
        
        
            VkResult vkGetPipelineExecutableInternalRepresentationsKHR
            VkDevice                        device
            const VkPipelineExecutableInfoKHR*  pExecutableInfo
            uint32_t* pInternalRepresentationCount
            VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations
        
        
            void vkCmdSetLineStippleEXT
            VkCommandBuffer commandBuffer
            uint32_t lineStippleFactor
            uint16_t lineStipplePattern
        
    
    
        
            
        
        
            
            
            
            
            
            
        
        
            
            
            
            
            
            
            
            
            
            
            
        
        
            
            
            
            
            
            
            
            
            
            
            
        
        
            
            
        
        
            
            
        
        
            
            
        
        
            
            
            
            
        
        
            
            
            
            
            
            
            
        
        
            
            
            
            
        
        
            
            
            
        
        
            
            
            
            
            
        
        
            
            
        
        
            
            
            
            
            
        
        
            
            
            
        
        
            
            
        
        
            
            
        
        
            
            
            
        
        
            
            
        
        
            
            
        
        
            
            
            
            
        
        
            
            
            
        
        
            
            
        
        
            
            
        
        
            
            
            
            
            
            
            
            
        
        
            
            
            
            
            
        
        
            
            
            
        
        
            
            
            
            
            
        
        
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
        
        
            
            
            
            
            
            
            
            
            
            
        
    
    
        
            
        
        
            
        
        
        
        
            
            
            
            
        
        
            
            
            
            
            
            
            
        
        
            
            
        
        
            
            
            
            
        
        
            
            offset 1 reserved for the old VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHX enum
            offset 2 reserved for the old VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHX enum
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
        
        
            
            
            
            
            
        
        
            
            
            
            
            
            
            
        
        
            
            
            
            
            
            
            
            
            
            
            
            
            
            
        
        
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
        
        
            
            
            
            
            
            Additional dependent types / tokens extending enumerants, not explicitly mentioned
            
        
        
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
        
        
            
            
            
            
            
            
            
        
        
            
            
            
            
        
        
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
        
        
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            Additional dependent types / tokens extending enumerants, not explicitly mentioned
            
            
            
            
        
        
            
            
            
            
            
            
            
            
            
            
        
        
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
        
        
            
            
            
            
            
            
            
            
        
        
            
            
            
            
            
            
            
            
            
        
        
            
            
            
            
        
        
            
            
            
            
        
        
            
            
            
            
            
            
            
            
            
        
        
            
            
            
            
            
        
        
            
            
            
            
        
    
    
        
            
                
                
                
                
                
                
                
                
                
                
            
        
        
            
                
                
                
                
                
                
                
                
                
                
                
                
                
            
            
                This duplicates definitions in VK_KHR_device_group below
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
            
        
        
            
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
            
        
        
            
                
                
                
                
                
                
            
        
        
            
                
                
                
                
                
                
                
            
        
        
            
                
                
                
                
                
                
                
            
        
        
            
                
                
                
                
                
                
                
            
        
        
        
            
                
                
            
        
        
            
                
                
                
                
                
                
                
            
        
        
            
                
                
                
                
                
                
                
            
        
        
            
                VK_ANDROID_native_buffer is used between the Android Vulkan loader and drivers to implement the WSI extensions. It isn't exposed to applications and uses types that aren't part of Android's stable public API, so it is left disabled to keep it out of the standard Vulkan headers.
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
            
        
        
            
                
                
                
                
                
                
                
                
                
                
                
            
            
                This duplicates definitions in other extensions, below
                
                
            
        
        
            
                
                
                
            
        
        
            
                
                
            
        
        
            
                
                
                
                
            
        
        
            
                
                
                
                
            
        
        
            
                
                
            
        
        
            
                
                
            
        
        
            
                
                
                
                
                
            
        
        
            
                
                
            
        
        
            
                
                
            
        
        
            
                
                
            
        
        
            
                
                
                
                
                
                
                
                
                
                
                
                
                
                
            
        
        
            
                
                
                
                
                
                
                
                
                
                
                
                
                
                
            
        
        
            
                
                
                
                
                
                
                
                
                
                
                
                
                
                
            
        
        
            
                
                
            
        
        
            
                
                
                
                
                
                
                
                
            
        
        
            
                
                
            
        
        
            
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
            
        
        
            
                
                
            
        
        
            
                
                
                
                
                
            
        
        
            
                
                
            
        
        
            
                
                
            
        
        
            
                
                
                
                
            
        
        
            
                
                
            
        
        
            
                
                
            
        
        
            
                
                
            
        
        
            
                
                
            
        
        
            
                
                
            
        
        
            
                
                
            
        
        
            
                
                
            
        
        
            
                
                
                
                
            
        
        
            
                
                
                
                
                
                
            
        
        
            
                
                
            
        
        
            
                
                
            
        
        
            
                
                
            
        
        
            
                
                
            
        
        
            
                
                
            
        
        
            
                
                
            
        
        
            
                
                
                
                
                
                
            
        
        
            
                
                
                
                
                
            
        
        
            
                
                
                
                
            
        
        
            
                
                
            
        
        
            
                
                
                
                
                
                
                
                
                
            
        
        
            
                
                
                
                
                
                
                
                
                
                
            
        
        
            
                
                
                
                
                
                
                
                
            
        
        
            
                
                
                
                
                
                
            
        
        
            
                
                
                
                
                
                
                
            
        
        
            
                
                
                
                
            
        
        
            
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
            
        
        
            
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
            
            
                
                
                
                
                
            
            
                
                
                
                
                
                
                
            
            
                
                
                
                
                
                
                
                
                
                
                
                
            
        
        
            
                
                
                
                
            
        
        
            
                
                
                
                
                
                
            
        
        
            
                
                
            
        
        
            
                
                
            
        
        
            
                
                
            
        
        
            
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
            
        
        
            
                
                
                
                
                
                
            
        
        
            
                
                
            
        
        
            
                
                
                
                
                
                
                
                
            
        
        
            
                
                
                
                
                
                
                
                
                
            
        
        
            
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
            
        
        
            
                
                
                
                
                
                
                
                
                
                
            
        
        
            
                
                
                
                
                
                
                
                
                
                
                
                
            
        
        
            
                
                
                
                
                
                
                
                
                
                
            
        
        
            
                
                
                
                
            
        
        
            
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
            
        
        
            
                
                
                
                
                
                
                
            
        
        
            
                
                
                
                
                
                
                
                
                
                
                
                
            
        
        
            
                
                
                
                
                
                
                
                
            
        
        
            
                
                
                
                
                
                
            
            
                
                
            
        
        
            
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
            
        
        
            
                
                
                
                
                
                
            
        
        
            
                
                
                
                
            
        
        
            
                
                
                
                
                
                
            
        
        
            
                
                
                
                
                
                
                
                
                
                
                
                
                
            
            
                
                
            
            
                
            
        
        
            
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
            
        
        
            
                
                
                
                
                
                
                
            
        
        
            
                
                
                
            
        
        
            
                
                
                
                
            
        
        
            
                
                
                
                
                
                
                
                
            
        
        
            
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
            
        
        
            
                
                
                
                
                
                
                
                
                
            
        
        
        
        
            
                
                
                
                    enum offset=0 was mistakenly used for the 1.1 core enum
                    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES
                    (value=1000094000). Fortunately, no conflict resulted.