include/vulkan/vulkan_core.h

   1 #ifndef VULKAN_CORE_H_
   2 #define VULKAN_CORE_H_ 1
   3
   4 #ifdef __cplusplus
   5 extern "C" {
   6 #endif
   7
   8 /*
   9 ** Copyright (c) 2015-2019 The Khronos Group Inc.
  10 **
  11 ** Licensed under the Apache License, Version 2.0 (the "License");
  12 ** you may not use this file except in compliance with the License.
  13 ** You may obtain a copy of the License at
  14 **
  15 **     http://www.apache.org/licenses/LICENSE-2.0
  16 **
  17 ** Unless required by applicable law or agreed to in writing, software
  18 ** distributed under the License is distributed on an "AS IS" BASIS,
  19 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  20 ** See the License for the specific language governing permissions and
  21 ** limitations under the License.
  22 */
  23
  24 /*
  25 ** This header is generated from the Khronos Vulkan XML API Registry.
  26 **
  27 */
  28
  29
  30
  31 #define VK_VERSION_1_0 1
  32 #include "vk_platform.h"
  33 #define VK_MAKE_VERSION(major, minor, patch) \
  34     (((major) << 22) | ((minor) << 12) | (patch))
  35
  36 // 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.
  37 //#define VK_API_VERSION VK_MAKE_VERSION(1, 0, 0) // Patch version should always be set to 0
  38
  39 // Vulkan 1.0 version number
  40 #define VK_API_VERSION_1_0 VK_MAKE_VERSION(1, 0, 0)// Patch version should always be set to 0
  41
  42 #define VK_VERSION_MAJOR(version) ((uint32_t)(version) >> 22)
  43 #define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff)
  44 #define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff)
  45 // Version of this file
  46 #define VK_HEADER_VERSION 117
  47
  48
  49 #define VK_NULL_HANDLE 0
  50
  51
  52 #define VK_DEFINE_HANDLE(object) typedef struct object##_T* object;
  53
  54
  55 #if !defined(VK_DEFINE_NON_DISPATCHABLE_HANDLE)
  56 #if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
  57         #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object;
  58 #else
  59         #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object;
  60 #endif
  61 #endif
  62
  63 typedef uint32_t VkFlags;
  64 typedef uint32_t VkBool32;
  65 typedef uint64_t VkDeviceSize;
  66 typedef uint32_t VkSampleMask;
  67 VK_DEFINE_HANDLE(VkInstance)
  68 VK_DEFINE_HANDLE(VkPhysicalDevice)
  69 VK_DEFINE_HANDLE(VkDevice)
  70 VK_DEFINE_HANDLE(VkQueue)
  71 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore)
  72 VK_DEFINE_HANDLE(VkCommandBuffer)
  73 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence)
  74 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory)
  75 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer)
  76 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage)
  77 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent)
  78 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool)
  79 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView)
  80 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView)
  81 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule)
  82 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache)
  83 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout)
  84 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass)
  85 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline)
  86 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout)
  87 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler)
  88 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool)
  89 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet)
  90 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer)
  91 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool)
  92 #define VK_LOD_CLAMP_NONE                 1000.0f
  93 #define VK_REMAINING_MIP_LEVELS           (~0U)
  94 #define VK_REMAINING_ARRAY_LAYERS         (~0U)
  95 #define VK_WHOLE_SIZE                     (~0ULL)
  96 #define VK_ATTACHMENT_UNUSED              (~0U)
  97 #define VK_TRUE                           1
  98 #define VK_FALSE                          0
  99 #define VK_QUEUE_FAMILY_IGNORED           (~0U)
 100 #define VK_SUBPASS_EXTERNAL               (~0U)
 101 #define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE  256
 102 #define VK_UUID_SIZE                      16
 103 #define VK_MAX_MEMORY_TYPES               32
 104 #define VK_MAX_MEMORY_HEAPS               16
 105 #define VK_MAX_EXTENSION_NAME_SIZE        256
 106 #define VK_MAX_DESCRIPTION_SIZE           256
 107
 108 typedef enum VkPipelineCacheHeaderVersion {
 109     VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1,
 110     VK_PIPELINE_CACHE_HEADER_VERSION_BEGIN_RANGE = VK_PIPELINE_CACHE_HEADER_VERSION_ONE,
 111     VK_PIPELINE_CACHE_HEADER_VERSION_END_RANGE = VK_PIPELINE_CACHE_HEADER_VERSION_ONE,
 112     VK_PIPELINE_CACHE_HEADER_VERSION_RANGE_SIZE = (VK_PIPELINE_CACHE_HEADER_VERSION_ONE - VK_PIPELINE_CACHE_HEADER_VERSION_ONE + 1),
 113     VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF
 114 } VkPipelineCacheHeaderVersion;
 115
 116 typedef enum VkResult {
 117     VK_SUCCESS = 0,
 118     VK_NOT_READY = 1,
 119     VK_TIMEOUT = 2,
 120     VK_EVENT_SET = 3,
 121     VK_EVENT_RESET = 4,
 122     VK_INCOMPLETE = 5,
 123     VK_ERROR_OUT_OF_HOST_MEMORY = -1,
 124     VK_ERROR_OUT_OF_DEVICE_MEMORY = -2,
 125     VK_ERROR_INITIALIZATION_FAILED = -3,
 126     VK_ERROR_DEVICE_LOST = -4,
 127     VK_ERROR_MEMORY_MAP_FAILED = -5,
 128     VK_ERROR_LAYER_NOT_PRESENT = -6,
 129     VK_ERROR_EXTENSION_NOT_PRESENT = -7,
 130     VK_ERROR_FEATURE_NOT_PRESENT = -8,
 131     VK_ERROR_INCOMPATIBLE_DRIVER = -9,
 132     VK_ERROR_TOO_MANY_OBJECTS = -10,
 133     VK_ERROR_FORMAT_NOT_SUPPORTED = -11,
 134     VK_ERROR_FRAGMENTED_POOL = -12,
 135     VK_ERROR_OUT_OF_POOL_MEMORY = -1000069000,
 136     VK_ERROR_INVALID_EXTERNAL_HANDLE = -1000072003,
 137     VK_ERROR_SURFACE_LOST_KHR = -1000000000,
 138     VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001,
 139     VK_SUBOPTIMAL_KHR = 1000001003,
 140     VK_ERROR_OUT_OF_DATE_KHR = -1000001004,
 141     VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001,
 142     VK_ERROR_VALIDATION_FAILED_EXT = -1000011001,
 143     VK_ERROR_INVALID_SHADER_NV = -1000012000,
 144     VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT = -1000158000,
 145     VK_ERROR_FRAGMENTATION_EXT = -1000161000,
 146     VK_ERROR_NOT_PERMITTED_EXT = -1000174001,
 147     VK_ERROR_INVALID_DEVICE_ADDRESS_EXT = -1000244000,
 148     VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT = -1000255000,
 149     VK_ERROR_OUT_OF_POOL_MEMORY_KHR = VK_ERROR_OUT_OF_POOL_MEMORY,
 150     VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = VK_ERROR_INVALID_EXTERNAL_HANDLE,
 151     VK_RESULT_BEGIN_RANGE = VK_ERROR_FRAGMENTED_POOL,
 152     VK_RESULT_END_RANGE = VK_INCOMPLETE,
 153     VK_RESULT_RANGE_SIZE = (VK_INCOMPLETE - VK_ERROR_FRAGMENTED_POOL + 1),
 154     VK_RESULT_MAX_ENUM = 0x7FFFFFFF
 155 } VkResult;
 156
 157 typedef enum VkStructureType {
 158     VK_STRUCTURE_TYPE_APPLICATION_INFO = 0,
 159     VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1,
 160     VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2,
 161     VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3,
 162     VK_STRUCTURE_TYPE_SUBMIT_INFO = 4,
 163     VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5,
 164     VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6,
 165     VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7,
 166     VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8,
 167     VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9,
 168     VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10,
 169     VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11,
 170     VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12,
 171     VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13,
 172     VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14,
 173     VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15,
 174     VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16,
 175     VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17,
 176     VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18,
 177     VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19,
 178     VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20,
 179     VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21,
 180     VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22,
 181     VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23,
 182     VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24,
 183     VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25,
 184     VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26,
 185     VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27,
 186     VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28,
 187     VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29,
 188     VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30,
 189     VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31,
 190     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32,
 191     VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33,
 192     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34,
 193     VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35,
 194     VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36,
 195     VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37,
 196     VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38,
 197     VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39,
 198     VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40,
 199     VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41,
 200     VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42,
 201     VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43,
 202     VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44,
 203     VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45,
 204     VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46,
 205     VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47,
 206     VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48,
 207     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES = 1000094000,
 208     VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO = 1000157000,
 209     VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO = 1000157001,
 210     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES = 1000083000,
 211     VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS = 1000127000,
 212     VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO = 1000127001,
 213     VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO = 1000060000,
 214     VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO = 1000060003,
 215     VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO = 1000060004,
 216     VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO = 1000060005,
 217     VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO = 1000060006,
 218     VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO = 1000060013,
 219     VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO = 1000060014,
 220     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES = 1000070000,
 221     VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO = 1000070001,
 222     VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2 = 1000146000,
 223     VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2 = 1000146001,
 224     VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 = 1000146002,
 225     VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 = 1000146003,
 226     VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 = 1000146004,
 227     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 = 1000059000,
 228     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 = 1000059001,
 229     VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 = 1000059002,
 230     VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 = 1000059003,
 231     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 = 1000059004,
 232     VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 = 1000059005,
 233     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 = 1000059006,
 234     VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 = 1000059007,
 235     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 = 1000059008,
 236     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES = 1000117000,
 237     VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO = 1000117001,
 238     VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO = 1000117002,
 239     VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO = 1000117003,
 240     VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO = 1000053000,
 241     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES = 1000053001,
 242     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES = 1000053002,
 243     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES = 1000120000,
 244     VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO = 1000145000,
 245     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES = 1000145001,
 246     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES = 1000145002,
 247     VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 = 1000145003,
 248     VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO = 1000156000,
 249     VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO = 1000156001,
 250     VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO = 1000156002,
 251     VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO = 1000156003,
 252     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES = 1000156004,
 253     VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES = 1000156005,
 254     VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO = 1000085000,
 255     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO = 1000071000,
 256     VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES = 1000071001,
 257     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO = 1000071002,
 258     VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES = 1000071003,
 259     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES = 1000071004,
 260     VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO = 1000072000,
 261     VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO = 1000072001,
 262     VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO = 1000072002,
 263     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO = 1000112000,
 264     VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES = 1000112001,
 265     VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO = 1000113000,
 266     VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO = 1000077000,
 267     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO = 1000076000,
 268     VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES = 1000076001,
 269     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES = 1000168000,
 270     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT = 1000168001,
 271     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES = 1000063000,
 272     VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000,
 273     VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001,
 274     VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR = 1000060007,
 275     VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR = 1000060008,
 276     VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR = 1000060009,
 277     VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR = 1000060010,
 278     VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR = 1000060011,
 279     VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR = 1000060012,
 280     VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000,
 281     VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001,
 282     VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000,
 283     VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000,
 284     VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000,
 285     VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000,
 286     VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000,
 287     VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000,
 288     VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000,
 289     VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000,
 290     VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000,
 291     VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001,
 292     VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002,
 293     VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000,
 294     VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001,
 295     VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002,
 296     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT = 1000028000,
 297     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT = 1000028001,
 298     VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT = 1000028002,
 299     VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX = 1000030000,
 300     VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD = 1000041000,
 301     VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP = 1000049000,
 302     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV = 1000050000,
 303     VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000,
 304     VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001,
 305     VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000,
 306     VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057001,
 307     VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000,
 308     VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = 1000061000,
 309     VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN = 1000062000,
 310     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT = 1000066000,
 311     VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT = 1000067000,
 312     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT = 1000067001,
 313     VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073000,
 314     VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073001,
 315     VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR = 1000073002,
 316     VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR = 1000073003,
 317     VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR = 1000074000,
 318     VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR = 1000074001,
 319     VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR = 1000074002,
 320     VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR = 1000075000,
 321     VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078000,
 322     VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078001,
 323     VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR = 1000078002,
 324     VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR = 1000078003,
 325     VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR = 1000079000,
 326     VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR = 1000079001,
 327     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = 1000080000,
 328     VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT = 1000081000,
 329     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT = 1000081001,
 330     VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT = 1000081002,
 331     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR = 1000082000,
 332     VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000,
 333     VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX = 1000086000,
 334     VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX = 1000086001,
 335     VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX = 1000086002,
 336     VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX = 1000086003,
 337     VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX = 1000086004,
 338     VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX = 1000086005,
 339     VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV = 1000087000,
 340     VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT = 1000090000,
 341     VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT = 1000091000,
 342     VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT = 1000091001,
 343     VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT = 1000091002,
 344     VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT = 1000091003,
 345     VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE = 1000092000,
 346     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX = 1000097000,
 347     VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV = 1000098000,
 348     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT = 1000099000,
 349     VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT = 1000099001,
 350     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT = 1000101000,
 351     VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT = 1000101001,
 352     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT = 1000102000,
 353     VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT = 1000102001,
 354     VK_STRUCTURE_TYPE_HDR_METADATA_EXT = 1000105000,
 355     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR = 1000108000,
 356     VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR = 1000108001,
 357     VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR = 1000108002,
 358     VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR = 1000108003,
 359     VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR = 1000109000,
 360     VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR = 1000109001,
 361     VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR = 1000109002,
 362     VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2_KHR = 1000109003,
 363     VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR = 1000109004,
 364     VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO_KHR = 1000109005,
 365     VK_STRUCTURE_TYPE_SUBPASS_END_INFO_KHR = 1000109006,
 366     VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000,
 367     VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114000,
 368     VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114001,
 369     VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR = 1000114002,
 370     VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR = 1000115000,
 371     VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR = 1000115001,
 372     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000,
 373     VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001,
 374     VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002,
 375     VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR = 1000121000,
 376     VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR = 1000121001,
 377     VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR = 1000121002,
 378     VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR = 1000121003,
 379     VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR = 1000121004,
 380     VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK = 1000122000,
 381     VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = 1000123000,
 382     VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT = 1000128000,
 383     VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT = 1000128001,
 384     VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT = 1000128002,
 385     VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT = 1000128003,
 386     VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT = 1000128004,
 387     VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID = 1000129000,
 388     VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID = 1000129001,
 389     VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID = 1000129002,
 390     VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129003,
 391     VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129004,
 392     VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID = 1000129005,
 393     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT = 1000130000,
 394     VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT = 1000130001,
 395     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT = 1000138000,
 396     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT = 1000138001,
 397     VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT = 1000138002,
 398     VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT = 1000138003,
 399     VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT = 1000143000,
 400     VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT = 1000143001,
 401     VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT = 1000143002,
 402     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT = 1000143003,
 403     VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT = 1000143004,
 404     VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR = 1000147000,
 405     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT = 1000148000,
 406     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT = 1000148001,
 407     VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT = 1000148002,
 408     VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV = 1000149000,
 409     VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV = 1000152000,
 410     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV = 1000154000,
 411     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV = 1000154001,
 412     VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT = 1000158000,
 413     VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT = 1000158001,
 414     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT = 1000158002,
 415     VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT = 1000158003,
 416     VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT = 1000158004,
 417     VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT = 1000158005,
 418     VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160000,
 419     VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160001,
 420     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT = 1000161000,
 421     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT = 1000161001,
 422     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT = 1000161002,
 423     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT = 1000161003,
 424     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT = 1000161004,
 425     VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV = 1000164000,
 426     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV = 1000164001,
 427     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV = 1000164002,
 428     VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV = 1000164005,
 429     VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV = 1000165000,
 430     VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV = 1000165001,
 431     VK_STRUCTURE_TYPE_GEOMETRY_NV = 1000165003,
 432     VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV = 1000165004,
 433     VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV = 1000165005,
 434     VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV = 1000165006,
 435     VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV = 1000165007,
 436     VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV = 1000165008,
 437     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV = 1000165009,
 438     VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV = 1000165011,
 439     VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV = 1000165012,
 440     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV = 1000166000,
 441     VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV = 1000166001,
 442     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT = 1000170000,
 443     VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT = 1000170001,
 444     VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT = 1000174000,
 445     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR = 1000177000,
 446     VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT = 1000178000,
 447     VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT = 1000178001,
 448     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002,
 449     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR = 1000180000,
 450     VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT = 1000184000,
 451     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD = 1000185000,
 452     VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD = 1000189000,
 453     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT = 1000190000,
 454     VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT = 1000190001,
 455     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT = 1000190002,
 456     VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP = 1000191000,
 457     VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT = 1000192000,
 458     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR = 1000196000,
 459     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR = 1000197000,
 460     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR = 1000199000,
 461     VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR = 1000199001,
 462     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV = 1000201000,
 463     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV = 1000202000,
 464     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV = 1000202001,
 465     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV = 1000203000,
 466     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV = 1000204000,
 467     VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV = 1000205000,
 468     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV = 1000205002,
 469     VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV = 1000206000,
 470     VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV = 1000206001,
 471     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL = 1000209000,
 472     VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL = 1000210000,
 473     VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL = 1000210001,
 474     VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL = 1000210002,
 475     VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL = 1000210003,
 476     VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL = 1000210004,
 477     VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL = 1000210005,
 478     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR = 1000211000,
 479     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT = 1000212000,
 480     VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD = 1000213000,
 481     VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD = 1000213001,
 482     VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA = 1000214000,
 483     VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT = 1000217000,
 484     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT = 1000218000,
 485     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT = 1000218001,
 486     VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT = 1000218002,
 487     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT = 1000221000,
 488     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT = 1000225000,
 489     VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT = 1000225001,
 490     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT = 1000237000,
 491     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT = 1000238000,
 492     VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT = 1000238001,
 493     VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR = 1000239000,
 494     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV = 1000240000,
 495     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT = 1000244000,
 496     VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT = 1000244001,
 497     VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT = 1000244002,
 498     VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT = 1000246000,
 499     VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT = 1000247000,
 500     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV = 1000249000,
 501     VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV = 1000249001,
 502     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV = 1000249002,
 503     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV = 1000250000,
 504     VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV = 1000250001,
 505     VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV = 1000250002,
 506     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT = 1000251000,
 507     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT = 1000252000,
 508     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR = 1000253000,
 509     VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT = 1000255000,
 510     VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT = 1000255002,
 511     VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT = 1000255001,
 512     VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT = 1000256000,
 513     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT = 1000259000,
 514     VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT = 1000259001,
 515     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT = 1000259002,
 516     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT = 1000261000,
 517     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT = 1000265000,
 518     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT = 1000276000,
 519     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT = 1000281000,
 520     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT = 1000281001,
 521     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
 522     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES,
 523     VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
 524     VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO,
 525     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES,
 526     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES,
 527     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2,
 528     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2,
 529     VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2,
 530     VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2,
 531     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
 532     VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2,
 533     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2,
 534     VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2,
 535     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2,
 536     VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO,
 537     VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO,
 538     VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO,
 539     VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO,
 540     VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO,
 541     VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO,
 542     VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO,
 543     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES,
 544     VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO,
 545     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO,
 546     VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES,
 547     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO,
 548     VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES,
 549     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES,
 550     VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO,
 551     VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
 552     VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO,
 553     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO,
 554     VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES,
 555     VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO,
 556     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR,
 557     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES,
 558     VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO,
 559     VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT,
 560     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO,
 561     VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES,
 562     VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO,
 563     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES,
 564     VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO,
 565     VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO,
 566     VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO,
 567     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES,
 568     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES,
 569     VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS,
 570     VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
 571     VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2,
 572     VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2,
 573     VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2,
 574     VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2,
 575     VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2,
 576     VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO,
 577     VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO,
 578     VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO,
 579     VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO,
 580     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES,
 581     VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES,
 582     VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO,
 583     VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO,
 584     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES,
 585     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT,
 586     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT,
 587     VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO,
 588     VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO,
 589     VK_STRUCTURE_TYPE_RANGE_SIZE = (VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1),
 590     VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
 591 } VkStructureType;
 592
 593 typedef enum VkSystemAllocationScope {
 594     VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0,
 595     VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1,
 596     VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2,
 597     VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3,
 598     VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4,
 599     VK_SYSTEM_ALLOCATION_SCOPE_BEGIN_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_COMMAND,
 600     VK_SYSTEM_ALLOCATION_SCOPE_END_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE,
 601     VK_SYSTEM_ALLOCATION_SCOPE_RANGE_SIZE = (VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE - VK_SYSTEM_ALLOCATION_SCOPE_COMMAND + 1),
 602     VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF
 603 } VkSystemAllocationScope;
 604
 605 typedef enum VkInternalAllocationType {
 606     VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0,
 607     VK_INTERNAL_ALLOCATION_TYPE_BEGIN_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE,
 608     VK_INTERNAL_ALLOCATION_TYPE_END_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE,
 609     VK_INTERNAL_ALLOCATION_TYPE_RANGE_SIZE = (VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE - VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE + 1),
 610     VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF
 611 } VkInternalAllocationType;
 612
 613 typedef enum VkFormat {
 614     VK_FORMAT_UNDEFINED = 0,
 615     VK_FORMAT_R4G4_UNORM_PACK8 = 1,
 616     VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2,
 617     VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3,
 618     VK_FORMAT_R5G6B5_UNORM_PACK16 = 4,
 619     VK_FORMAT_B5G6R5_UNORM_PACK16 = 5,
 620     VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6,
 621     VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7,
 622     VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8,
 623     VK_FORMAT_R8_UNORM = 9,
 624     VK_FORMAT_R8_SNORM = 10,
 625     VK_FORMAT_R8_USCALED = 11,
 626     VK_FORMAT_R8_SSCALED = 12,
 627     VK_FORMAT_R8_UINT = 13,
 628     VK_FORMAT_R8_SINT = 14,
 629     VK_FORMAT_R8_SRGB = 15,
 630     VK_FORMAT_R8G8_UNORM = 16,
 631     VK_FORMAT_R8G8_SNORM = 17,
 632     VK_FORMAT_R8G8_USCALED = 18,
 633     VK_FORMAT_R8G8_SSCALED = 19,
 634     VK_FORMAT_R8G8_UINT = 20,
 635     VK_FORMAT_R8G8_SINT = 21,
 636     VK_FORMAT_R8G8_SRGB = 22,
 637     VK_FORMAT_R8G8B8_UNORM = 23,
 638     VK_FORMAT_R8G8B8_SNORM = 24,
 639     VK_FORMAT_R8G8B8_USCALED = 25,
 640     VK_FORMAT_R8G8B8_SSCALED = 26,
 641     VK_FORMAT_R8G8B8_UINT = 27,
 642     VK_FORMAT_R8G8B8_SINT = 28,
 643     VK_FORMAT_R8G8B8_SRGB = 29,
 644     VK_FORMAT_B8G8R8_UNORM = 30,
 645     VK_FORMAT_B8G8R8_SNORM = 31,
 646     VK_FORMAT_B8G8R8_USCALED = 32,
 647     VK_FORMAT_B8G8R8_SSCALED = 33,
 648     VK_FORMAT_B8G8R8_UINT = 34,
 649     VK_FORMAT_B8G8R8_SINT = 35,
 650     VK_FORMAT_B8G8R8_SRGB = 36,
 651     VK_FORMAT_R8G8B8A8_UNORM = 37,
 652     VK_FORMAT_R8G8B8A8_SNORM = 38,
 653     VK_FORMAT_R8G8B8A8_USCALED = 39,
 654     VK_FORMAT_R8G8B8A8_SSCALED = 40,
 655     VK_FORMAT_R8G8B8A8_UINT = 41,
 656     VK_FORMAT_R8G8B8A8_SINT = 42,
 657     VK_FORMAT_R8G8B8A8_SRGB = 43,
 658     VK_FORMAT_B8G8R8A8_UNORM = 44,
 659     VK_FORMAT_B8G8R8A8_SNORM = 45,
 660     VK_FORMAT_B8G8R8A8_USCALED = 46,
 661     VK_FORMAT_B8G8R8A8_SSCALED = 47,
 662     VK_FORMAT_B8G8R8A8_UINT = 48,
 663     VK_FORMAT_B8G8R8A8_SINT = 49,
 664     VK_FORMAT_B8G8R8A8_SRGB = 50,
 665     VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51,
 666     VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52,
 667     VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53,
 668     VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54,
 669     VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55,
 670     VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56,
 671     VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57,
 672     VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58,
 673     VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59,
 674     VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60,
 675     VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61,
 676     VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62,
 677     VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63,
 678     VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64,
 679     VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65,
 680     VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66,
 681     VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67,
 682     VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68,
 683     VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69,
 684     VK_FORMAT_R16_UNORM = 70,
 685     VK_FORMAT_R16_SNORM = 71,
 686     VK_FORMAT_R16_USCALED = 72,
 687     VK_FORMAT_R16_SSCALED = 73,
 688     VK_FORMAT_R16_UINT = 74,
 689     VK_FORMAT_R16_SINT = 75,
 690     VK_FORMAT_R16_SFLOAT = 76,
 691     VK_FORMAT_R16G16_UNORM = 77,
 692     VK_FORMAT_R16G16_SNORM = 78,
 693     VK_FORMAT_R16G16_USCALED = 79,
 694     VK_FORMAT_R16G16_SSCALED = 80,
 695     VK_FORMAT_R16G16_UINT = 81,
 696     VK_FORMAT_R16G16_SINT = 82,
 697     VK_FORMAT_R16G16_SFLOAT = 83,
 698     VK_FORMAT_R16G16B16_UNORM = 84,
 699     VK_FORMAT_R16G16B16_SNORM = 85,
 700     VK_FORMAT_R16G16B16_USCALED = 86,
 701     VK_FORMAT_R16G16B16_SSCALED = 87,
 702     VK_FORMAT_R16G16B16_UINT = 88,
 703     VK_FORMAT_R16G16B16_SINT = 89,
 704     VK_FORMAT_R16G16B16_SFLOAT = 90,
 705     VK_FORMAT_R16G16B16A16_UNORM = 91,
 706     VK_FORMAT_R16G16B16A16_SNORM = 92,
 707     VK_FORMAT_R16G16B16A16_USCALED = 93,
 708     VK_FORMAT_R16G16B16A16_SSCALED = 94,
 709     VK_FORMAT_R16G16B16A16_UINT = 95,
 710     VK_FORMAT_R16G16B16A16_SINT = 96,
 711     VK_FORMAT_R16G16B16A16_SFLOAT = 97,
 712     VK_FORMAT_R32_UINT = 98,
 713     VK_FORMAT_R32_SINT = 99,
 714     VK_FORMAT_R32_SFLOAT = 100,
 715     VK_FORMAT_R32G32_UINT = 101,
 716     VK_FORMAT_R32G32_SINT = 102,
 717     VK_FORMAT_R32G32_SFLOAT = 103,
 718     VK_FORMAT_R32G32B32_UINT = 104,
 719     VK_FORMAT_R32G32B32_SINT = 105,
 720     VK_FORMAT_R32G32B32_SFLOAT = 106,
 721     VK_FORMAT_R32G32B32A32_UINT = 107,
 722     VK_FORMAT_R32G32B32A32_SINT = 108,
 723     VK_FORMAT_R32G32B32A32_SFLOAT = 109,
 724     VK_FORMAT_R64_UINT = 110,
 725     VK_FORMAT_R64_SINT = 111,
 726     VK_FORMAT_R64_SFLOAT = 112,
 727     VK_FORMAT_R64G64_UINT = 113,
 728     VK_FORMAT_R64G64_SINT = 114,
 729     VK_FORMAT_R64G64_SFLOAT = 115,
 730     VK_FORMAT_R64G64B64_UINT = 116,
 731     VK_FORMAT_R64G64B64_SINT = 117,
 732     VK_FORMAT_R64G64B64_SFLOAT = 118,
 733     VK_FORMAT_R64G64B64A64_UINT = 119,
 734     VK_FORMAT_R64G64B64A64_SINT = 120,
 735     VK_FORMAT_R64G64B64A64_SFLOAT = 121,
 736     VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122,
 737     VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123,
 738     VK_FORMAT_D16_UNORM = 124,
 739     VK_FORMAT_X8_D24_UNORM_PACK32 = 125,
 740     VK_FORMAT_D32_SFLOAT = 126,
 741     VK_FORMAT_S8_UINT = 127,
 742     VK_FORMAT_D16_UNORM_S8_UINT = 128,
 743     VK_FORMAT_D24_UNORM_S8_UINT = 129,
 744     VK_FORMAT_D32_SFLOAT_S8_UINT = 130,
 745     VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131,
 746     VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132,
 747     VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133,
 748     VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134,
 749     VK_FORMAT_BC2_UNORM_BLOCK = 135,
 750     VK_FORMAT_BC2_SRGB_BLOCK = 136,
 751     VK_FORMAT_BC3_UNORM_BLOCK = 137,
 752     VK_FORMAT_BC3_SRGB_BLOCK = 138,
 753     VK_FORMAT_BC4_UNORM_BLOCK = 139,
 754     VK_FORMAT_BC4_SNORM_BLOCK = 140,
 755     VK_FORMAT_BC5_UNORM_BLOCK = 141,
 756     VK_FORMAT_BC5_SNORM_BLOCK = 142,
 757     VK_FORMAT_BC6H_UFLOAT_BLOCK = 143,
 758     VK_FORMAT_BC6H_SFLOAT_BLOCK = 144,
 759     VK_FORMAT_BC7_UNORM_BLOCK = 145,
 760     VK_FORMAT_BC7_SRGB_BLOCK = 146,
 761     VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147,
 762     VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148,
 763     VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149,
 764     VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150,
 765     VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151,
 766     VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152,
 767     VK_FORMAT_EAC_R11_UNORM_BLOCK = 153,
 768     VK_FORMAT_EAC_R11_SNORM_BLOCK = 154,
 769     VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155,
 770     VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156,
 771     VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157,
 772     VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158,
 773     VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159,
 774     VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160,
 775     VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161,
 776     VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162,
 777     VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163,
 778     VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164,
 779     VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165,
 780     VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166,
 781     VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167,
 782     VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168,
 783     VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169,
 784     VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170,
 785     VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171,
 786     VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172,
 787     VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173,
 788     VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174,
 789     VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175,
 790     VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176,
 791     VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177,
 792     VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178,
 793     VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179,
 794     VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180,
 795     VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181,
 796     VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182,
 797     VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183,
 798     VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184,
 799     VK_FORMAT_G8B8G8R8_422_UNORM = 1000156000,
 800     VK_FORMAT_B8G8R8G8_422_UNORM = 1000156001,
 801     VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM = 1000156002,
 802     VK_FORMAT_G8_B8R8_2PLANE_420_UNORM = 1000156003,
 803     VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM = 1000156004,
 804     VK_FORMAT_G8_B8R8_2PLANE_422_UNORM = 1000156005,
 805     VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM = 1000156006,
 806     VK_FORMAT_R10X6_UNORM_PACK16 = 1000156007,
 807     VK_FORMAT_R10X6G10X6_UNORM_2PACK16 = 1000156008,
 808     VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 = 1000156009,
 809     VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 = 1000156010,
 810     VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 = 1000156011,
 811     VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 = 1000156012,
 812     VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 = 1000156013,
 813     VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 = 1000156014,
 814     VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 = 1000156015,
 815     VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 = 1000156016,
 816     VK_FORMAT_R12X4_UNORM_PACK16 = 1000156017,
 817     VK_FORMAT_R12X4G12X4_UNORM_2PACK16 = 1000156018,
 818     VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 = 1000156019,
 819     VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 = 1000156020,
 820     VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 = 1000156021,
 821     VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 = 1000156022,
 822     VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 = 1000156023,
 823     VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 = 1000156024,
 824     VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 = 1000156025,
 825     VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 = 1000156026,
 826     VK_FORMAT_G16B16G16R16_422_UNORM = 1000156027,
 827     VK_FORMAT_B16G16R16G16_422_UNORM = 1000156028,
 828     VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM = 1000156029,
 829     VK_FORMAT_G16_B16R16_2PLANE_420_UNORM = 1000156030,
 830     VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM = 1000156031,
 831     VK_FORMAT_G16_B16R16_2PLANE_422_UNORM = 1000156032,
 832     VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM = 1000156033,
 833     VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000,
 834     VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001,
 835     VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002,
 836     VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003,
 837     VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004,
 838     VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005,
 839     VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006,
 840     VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007,
 841     VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT = 1000066000,
 842     VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT = 1000066001,
 843     VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT = 1000066002,
 844     VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT = 1000066003,
 845     VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT = 1000066004,
 846     VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT = 1000066005,
 847     VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT = 1000066006,
 848     VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT = 1000066007,
 849     VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT = 1000066008,
 850     VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT = 1000066009,
 851     VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT = 1000066010,
 852     VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT = 1000066011,
 853     VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT = 1000066012,
 854     VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT = 1000066013,
 855     VK_FORMAT_G8B8G8R8_422_UNORM_KHR = VK_FORMAT_G8B8G8R8_422_UNORM,
 856     VK_FORMAT_B8G8R8G8_422_UNORM_KHR = VK_FORMAT_B8G8R8G8_422_UNORM,
 857     VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM,
 858     VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM,
 859     VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM,
 860     VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM,
 861     VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM,
 862     VK_FORMAT_R10X6_UNORM_PACK16_KHR = VK_FORMAT_R10X6_UNORM_PACK16,
 863     VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR = VK_FORMAT_R10X6G10X6_UNORM_2PACK16,
 864     VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16,
 865     VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR = VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16,
 866     VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16,
 867     VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16,
 868     VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16,
 869     VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16,
 870     VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16,
 871     VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16,
 872     VK_FORMAT_R12X4_UNORM_PACK16_KHR = VK_FORMAT_R12X4_UNORM_PACK16,
 873     VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR = VK_FORMAT_R12X4G12X4_UNORM_2PACK16,
 874     VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR = VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16,
 875     VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR = VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16,
 876     VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR = VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16,
 877     VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16,
 878     VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16,
 879     VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16,
 880     VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16,
 881     VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16,
 882     VK_FORMAT_G16B16G16R16_422_UNORM_KHR = VK_FORMAT_G16B16G16R16_422_UNORM,
 883     VK_FORMAT_B16G16R16G16_422_UNORM_KHR = VK_FORMAT_B16G16R16G16_422_UNORM,
 884     VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM,
 885     VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM,
 886     VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM,
 887     VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM,
 888     VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM,
 889     VK_FORMAT_BEGIN_RANGE = VK_FORMAT_UNDEFINED,
 890     VK_FORMAT_END_RANGE = VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
 891     VK_FORMAT_RANGE_SIZE = (VK_FORMAT_ASTC_12x12_SRGB_BLOCK - VK_FORMAT_UNDEFINED + 1),
 892     VK_FORMAT_MAX_ENUM = 0x7FFFFFFF
 893 } VkFormat;
 894
 895 typedef enum VkImageType {
 896     VK_IMAGE_TYPE_1D = 0,
 897     VK_IMAGE_TYPE_2D = 1,
 898     VK_IMAGE_TYPE_3D = 2,
 899     VK_IMAGE_TYPE_BEGIN_RANGE = VK_IMAGE_TYPE_1D,
 900     VK_IMAGE_TYPE_END_RANGE = VK_IMAGE_TYPE_3D,
 901     VK_IMAGE_TYPE_RANGE_SIZE = (VK_IMAGE_TYPE_3D - VK_IMAGE_TYPE_1D + 1),
 902     VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF
 903 } VkImageType;
 904
 905 typedef enum VkImageTiling {
 906     VK_IMAGE_TILING_OPTIMAL = 0,
 907     VK_IMAGE_TILING_LINEAR = 1,
 908     VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT = 1000158000,
 909     VK_IMAGE_TILING_BEGIN_RANGE = VK_IMAGE_TILING_OPTIMAL,
 910     VK_IMAGE_TILING_END_RANGE = VK_IMAGE_TILING_LINEAR,
 911     VK_IMAGE_TILING_RANGE_SIZE = (VK_IMAGE_TILING_LINEAR - VK_IMAGE_TILING_OPTIMAL + 1),
 912     VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF
 913 } VkImageTiling;
 914
 915 typedef enum VkPhysicalDeviceType {
 916     VK_PHYSICAL_DEVICE_TYPE_OTHER = 0,
 917     VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1,
 918     VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2,
 919     VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3,
 920     VK_PHYSICAL_DEVICE_TYPE_CPU = 4,
 921     VK_PHYSICAL_DEVICE_TYPE_BEGIN_RANGE = VK_PHYSICAL_DEVICE_TYPE_OTHER,
 922     VK_PHYSICAL_DEVICE_TYPE_END_RANGE = VK_PHYSICAL_DEVICE_TYPE_CPU,
 923     VK_PHYSICAL_DEVICE_TYPE_RANGE_SIZE = (VK_PHYSICAL_DEVICE_TYPE_CPU - VK_PHYSICAL_DEVICE_TYPE_OTHER + 1),
 924     VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF
 925 } VkPhysicalDeviceType;
 926
 927 typedef enum VkQueryType {
 928     VK_QUERY_TYPE_OCCLUSION = 0,
 929     VK_QUERY_TYPE_PIPELINE_STATISTICS = 1,
 930     VK_QUERY_TYPE_TIMESTAMP = 2,
 931     VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT = 1000028004,
 932     VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV = 1000165000,
 933     VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL = 1000210000,
 934     VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION,
 935     VK_QUERY_TYPE_END_RANGE = VK_QUERY_TYPE_TIMESTAMP,
 936     VK_QUERY_TYPE_RANGE_SIZE = (VK_QUERY_TYPE_TIMESTAMP - VK_QUERY_TYPE_OCCLUSION + 1),
 937     VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF
 938 } VkQueryType;
 939
 940 typedef enum VkSharingMode {
 941     VK_SHARING_MODE_EXCLUSIVE = 0,
 942     VK_SHARING_MODE_CONCURRENT = 1,
 943     VK_SHARING_MODE_BEGIN_RANGE = VK_SHARING_MODE_EXCLUSIVE,
 944     VK_SHARING_MODE_END_RANGE = VK_SHARING_MODE_CONCURRENT,
 945     VK_SHARING_MODE_RANGE_SIZE = (VK_SHARING_MODE_CONCURRENT - VK_SHARING_MODE_EXCLUSIVE + 1),
 946     VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF
 947 } VkSharingMode;
 948
 949 typedef enum VkImageLayout {
 950     VK_IMAGE_LAYOUT_UNDEFINED = 0,
 951     VK_IMAGE_LAYOUT_GENERAL = 1,
 952     VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2,
 953     VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3,
 954     VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4,
 955     VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5,
 956     VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6,
 957     VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7,
 958     VK_IMAGE_LAYOUT_PREINITIALIZED = 8,
 959     VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL = 1000117000,
 960     VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL = 1000117001,
 961     VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002,
 962     VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000,
 963     VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV = 1000164003,
 964     VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT = 1000218000,
 965     VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL,
 966     VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL,
 967     VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED,
 968     VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_PREINITIALIZED,
 969     VK_IMAGE_LAYOUT_RANGE_SIZE = (VK_IMAGE_LAYOUT_PREINITIALIZED - VK_IMAGE_LAYOUT_UNDEFINED + 1),
 970     VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF
 971 } VkImageLayout;
 972
 973 typedef enum VkImageViewType {
 974     VK_IMAGE_VIEW_TYPE_1D = 0,
 975     VK_IMAGE_VIEW_TYPE_2D = 1,
 976     VK_IMAGE_VIEW_TYPE_3D = 2,
 977     VK_IMAGE_VIEW_TYPE_CUBE = 3,
 978     VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4,
 979     VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5,
 980     VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6,
 981     VK_IMAGE_VIEW_TYPE_BEGIN_RANGE = VK_IMAGE_VIEW_TYPE_1D,
 982     VK_IMAGE_VIEW_TYPE_END_RANGE = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY,
 983     VK_IMAGE_VIEW_TYPE_RANGE_SIZE = (VK_IMAGE_VIEW_TYPE_CUBE_ARRAY - VK_IMAGE_VIEW_TYPE_1D + 1),
 984     VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF
 985 } VkImageViewType;
 986
 987 typedef enum VkComponentSwizzle {
 988     VK_COMPONENT_SWIZZLE_IDENTITY = 0,
 989     VK_COMPONENT_SWIZZLE_ZERO = 1,
 990     VK_COMPONENT_SWIZZLE_ONE = 2,
 991     VK_COMPONENT_SWIZZLE_R = 3,
 992     VK_COMPONENT_SWIZZLE_G = 4,
 993     VK_COMPONENT_SWIZZLE_B = 5,
 994     VK_COMPONENT_SWIZZLE_A = 6,
 995     VK_COMPONENT_SWIZZLE_BEGIN_RANGE = VK_COMPONENT_SWIZZLE_IDENTITY,
 996     VK_COMPONENT_SWIZZLE_END_RANGE = VK_COMPONENT_SWIZZLE_A,
 997     VK_COMPONENT_SWIZZLE_RANGE_SIZE = (VK_COMPONENT_SWIZZLE_A - VK_COMPONENT_SWIZZLE_IDENTITY + 1),
 998     VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF
 999 } VkComponentSwizzle;
1000
1001 typedef enum VkVertexInputRate {
1002     VK_VERTEX_INPUT_RATE_VERTEX = 0,
1003     VK_VERTEX_INPUT_RATE_INSTANCE = 1,
1004     VK_VERTEX_INPUT_RATE_BEGIN_RANGE = VK_VERTEX_INPUT_RATE_VERTEX,
1005     VK_VERTEX_INPUT_RATE_END_RANGE = VK_VERTEX_INPUT_RATE_INSTANCE,
1006     VK_VERTEX_INPUT_RATE_RANGE_SIZE = (VK_VERTEX_INPUT_RATE_INSTANCE - VK_VERTEX_INPUT_RATE_VERTEX + 1),
1007     VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF
1008 } VkVertexInputRate;
1009
1010 typedef enum VkPrimitiveTopology {
1011     VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0,
1012     VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1,
1013     VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2,
1014     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3,
1015     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4,
1016     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5,
1017     VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6,
1018     VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7,
1019     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8,
1020     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9,
1021     VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10,
1022     VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = VK_PRIMITIVE_TOPOLOGY_POINT_LIST,
1023     VK_PRIMITIVE_TOPOLOGY_END_RANGE = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST,
1024     VK_PRIMITIVE_TOPOLOGY_RANGE_SIZE = (VK_PRIMITIVE_TOPOLOGY_PATCH_LIST - VK_PRIMITIVE_TOPOLOGY_POINT_LIST + 1),
1025     VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF
1026 } VkPrimitiveTopology;
1027
1028 typedef enum VkPolygonMode {
1029     VK_POLYGON_MODE_FILL = 0,
1030     VK_POLYGON_MODE_LINE = 1,
1031     VK_POLYGON_MODE_POINT = 2,
1032     VK_POLYGON_MODE_FILL_RECTANGLE_NV = 1000153000,
1033     VK_POLYGON_MODE_BEGIN_RANGE = VK_POLYGON_MODE_FILL,
1034     VK_POLYGON_MODE_END_RANGE = VK_POLYGON_MODE_POINT,
1035     VK_POLYGON_MODE_RANGE_SIZE = (VK_POLYGON_MODE_POINT - VK_POLYGON_MODE_FILL + 1),
1036     VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF
1037 } VkPolygonMode;
1038
1039 typedef enum VkFrontFace {
1040     VK_FRONT_FACE_COUNTER_CLOCKWISE = 0,
1041     VK_FRONT_FACE_CLOCKWISE = 1,
1042     VK_FRONT_FACE_BEGIN_RANGE = VK_FRONT_FACE_COUNTER_CLOCKWISE,
1043     VK_FRONT_FACE_END_RANGE = VK_FRONT_FACE_CLOCKWISE,
1044     VK_FRONT_FACE_RANGE_SIZE = (VK_FRONT_FACE_CLOCKWISE - VK_FRONT_FACE_COUNTER_CLOCKWISE + 1),
1045     VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF
1046 } VkFrontFace;
1047
1048 typedef enum VkCompareOp {
1049     VK_COMPARE_OP_NEVER = 0,
1050     VK_COMPARE_OP_LESS = 1,
1051     VK_COMPARE_OP_EQUAL = 2,
1052     VK_COMPARE_OP_LESS_OR_EQUAL = 3,
1053     VK_COMPARE_OP_GREATER = 4,
1054     VK_COMPARE_OP_NOT_EQUAL = 5,
1055     VK_COMPARE_OP_GREATER_OR_EQUAL = 6,
1056     VK_COMPARE_OP_ALWAYS = 7,
1057     VK_COMPARE_OP_BEGIN_RANGE = VK_COMPARE_OP_NEVER,
1058     VK_COMPARE_OP_END_RANGE = VK_COMPARE_OP_ALWAYS,
1059     VK_COMPARE_OP_RANGE_SIZE = (VK_COMPARE_OP_ALWAYS - VK_COMPARE_OP_NEVER + 1),
1060     VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF
1061 } VkCompareOp;
1062
1063 typedef enum VkStencilOp {
1064     VK_STENCIL_OP_KEEP = 0,
1065     VK_STENCIL_OP_ZERO = 1,
1066     VK_STENCIL_OP_REPLACE = 2,
1067     VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3,
1068     VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4,
1069     VK_STENCIL_OP_INVERT = 5,
1070     VK_STENCIL_OP_INCREMENT_AND_WRAP = 6,
1071     VK_STENCIL_OP_DECREMENT_AND_WRAP = 7,
1072     VK_STENCIL_OP_BEGIN_RANGE = VK_STENCIL_OP_KEEP,
1073     VK_STENCIL_OP_END_RANGE = VK_STENCIL_OP_DECREMENT_AND_WRAP,
1074     VK_STENCIL_OP_RANGE_SIZE = (VK_STENCIL_OP_DECREMENT_AND_WRAP - VK_STENCIL_OP_KEEP + 1),
1075     VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF
1076 } VkStencilOp;
1077
1078 typedef enum VkLogicOp {
1079     VK_LOGIC_OP_CLEAR = 0,
1080     VK_LOGIC_OP_AND = 1,
1081     VK_LOGIC_OP_AND_REVERSE = 2,
1082     VK_LOGIC_OP_COPY = 3,
1083     VK_LOGIC_OP_AND_INVERTED = 4,
1084     VK_LOGIC_OP_NO_OP = 5,
1085     VK_LOGIC_OP_XOR = 6,
1086     VK_LOGIC_OP_OR = 7,
1087     VK_LOGIC_OP_NOR = 8,
1088     VK_LOGIC_OP_EQUIVALENT = 9,
1089     VK_LOGIC_OP_INVERT = 10,
1090     VK_LOGIC_OP_OR_REVERSE = 11,
1091     VK_LOGIC_OP_COPY_INVERTED = 12,
1092     VK_LOGIC_OP_OR_INVERTED = 13,
1093     VK_LOGIC_OP_NAND = 14,
1094     VK_LOGIC_OP_SET = 15,
1095     VK_LOGIC_OP_BEGIN_RANGE = VK_LOGIC_OP_CLEAR,
1096     VK_LOGIC_OP_END_RANGE = VK_LOGIC_OP_SET,
1097     VK_LOGIC_OP_RANGE_SIZE = (VK_LOGIC_OP_SET - VK_LOGIC_OP_CLEAR + 1),
1098     VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF
1099 } VkLogicOp;
1100
1101 typedef enum VkBlendFactor {
1102     VK_BLEND_FACTOR_ZERO = 0,
1103     VK_BLEND_FACTOR_ONE = 1,
1104     VK_BLEND_FACTOR_SRC_COLOR = 2,
1105     VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3,
1106     VK_BLEND_FACTOR_DST_COLOR = 4,
1107     VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5,
1108     VK_BLEND_FACTOR_SRC_ALPHA = 6,
1109     VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7,
1110     VK_BLEND_FACTOR_DST_ALPHA = 8,
1111     VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9,
1112     VK_BLEND_FACTOR_CONSTANT_COLOR = 10,
1113     VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11,
1114     VK_BLEND_FACTOR_CONSTANT_ALPHA = 12,
1115     VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13,
1116     VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14,
1117     VK_BLEND_FACTOR_SRC1_COLOR = 15,
1118     VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16,
1119     VK_BLEND_FACTOR_SRC1_ALPHA = 17,
1120     VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18,
1121     VK_BLEND_FACTOR_BEGIN_RANGE = VK_BLEND_FACTOR_ZERO,
1122     VK_BLEND_FACTOR_END_RANGE = VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA,
1123     VK_BLEND_FACTOR_RANGE_SIZE = (VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA - VK_BLEND_FACTOR_ZERO + 1),
1124     VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF
1125 } VkBlendFactor;
1126
1127 typedef enum VkBlendOp {
1128     VK_BLEND_OP_ADD = 0,
1129     VK_BLEND_OP_SUBTRACT = 1,
1130     VK_BLEND_OP_REVERSE_SUBTRACT = 2,
1131     VK_BLEND_OP_MIN = 3,
1132     VK_BLEND_OP_MAX = 4,
1133     VK_BLEND_OP_ZERO_EXT = 1000148000,
1134     VK_BLEND_OP_SRC_EXT = 1000148001,
1135     VK_BLEND_OP_DST_EXT = 1000148002,
1136     VK_BLEND_OP_SRC_OVER_EXT = 1000148003,
1137     VK_BLEND_OP_DST_OVER_EXT = 1000148004,
1138     VK_BLEND_OP_SRC_IN_EXT = 1000148005,
1139     VK_BLEND_OP_DST_IN_EXT = 1000148006,
1140     VK_BLEND_OP_SRC_OUT_EXT = 1000148007,
1141     VK_BLEND_OP_DST_OUT_EXT = 1000148008,
1142     VK_BLEND_OP_SRC_ATOP_EXT = 1000148009,
1143     VK_BLEND_OP_DST_ATOP_EXT = 1000148010,
1144     VK_BLEND_OP_XOR_EXT = 1000148011,
1145     VK_BLEND_OP_MULTIPLY_EXT = 1000148012,
1146     VK_BLEND_OP_SCREEN_EXT = 1000148013,
1147     VK_BLEND_OP_OVERLAY_EXT = 1000148014,
1148     VK_BLEND_OP_DARKEN_EXT = 1000148015,
1149     VK_BLEND_OP_LIGHTEN_EXT = 1000148016,
1150     VK_BLEND_OP_COLORDODGE_EXT = 1000148017,
1151     VK_BLEND_OP_COLORBURN_EXT = 1000148018,
1152     VK_BLEND_OP_HARDLIGHT_EXT = 1000148019,
1153     VK_BLEND_OP_SOFTLIGHT_EXT = 1000148020,
1154     VK_BLEND_OP_DIFFERENCE_EXT = 1000148021,
1155     VK_BLEND_OP_EXCLUSION_EXT = 1000148022,
1156     VK_BLEND_OP_INVERT_EXT = 1000148023,
1157     VK_BLEND_OP_INVERT_RGB_EXT = 1000148024,
1158     VK_BLEND_OP_LINEARDODGE_EXT = 1000148025,
1159     VK_BLEND_OP_LINEARBURN_EXT = 1000148026,
1160     VK_BLEND_OP_VIVIDLIGHT_EXT = 1000148027,
1161     VK_BLEND_OP_LINEARLIGHT_EXT = 1000148028,
1162     VK_BLEND_OP_PINLIGHT_EXT = 1000148029,
1163     VK_BLEND_OP_HARDMIX_EXT = 1000148030,
1164     VK_BLEND_OP_HSL_HUE_EXT = 1000148031,
1165     VK_BLEND_OP_HSL_SATURATION_EXT = 1000148032,
1166     VK_BLEND_OP_HSL_COLOR_EXT = 1000148033,
1167     VK_BLEND_OP_HSL_LUMINOSITY_EXT = 1000148034,
1168     VK_BLEND_OP_PLUS_EXT = 1000148035,
1169     VK_BLEND_OP_PLUS_CLAMPED_EXT = 1000148036,
1170     VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT = 1000148037,
1171     VK_BLEND_OP_PLUS_DARKER_EXT = 1000148038,
1172     VK_BLEND_OP_MINUS_EXT = 1000148039,
1173     VK_BLEND_OP_MINUS_CLAMPED_EXT = 1000148040,
1174     VK_BLEND_OP_CONTRAST_EXT = 1000148041,
1175     VK_BLEND_OP_INVERT_OVG_EXT = 1000148042,
1176     VK_BLEND_OP_RED_EXT = 1000148043,
1177     VK_BLEND_OP_GREEN_EXT = 1000148044,
1178     VK_BLEND_OP_BLUE_EXT = 1000148045,
1179     VK_BLEND_OP_BEGIN_RANGE = VK_BLEND_OP_ADD,
1180     VK_BLEND_OP_END_RANGE = VK_BLEND_OP_MAX,
1181     VK_BLEND_OP_RANGE_SIZE = (VK_BLEND_OP_MAX - VK_BLEND_OP_ADD + 1),
1182     VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF
1183 } VkBlendOp;
1184
1185 typedef enum VkDynamicState {
1186     VK_DYNAMIC_STATE_VIEWPORT = 0,
1187     VK_DYNAMIC_STATE_SCISSOR = 1,
1188     VK_DYNAMIC_STATE_LINE_WIDTH = 2,
1189     VK_DYNAMIC_STATE_DEPTH_BIAS = 3,
1190     VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4,
1191     VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5,
1192     VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6,
1193     VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7,
1194     VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8,
1195     VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV = 1000087000,
1196     VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = 1000099000,
1197     VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT = 1000143000,
1198     VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV = 1000164004,
1199     VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV = 1000164006,
1200     VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV = 1000205001,
1201     VK_DYNAMIC_STATE_LINE_STIPPLE_EXT = 1000259000,
1202     VK_DYNAMIC_STATE_BEGIN_RANGE = VK_DYNAMIC_STATE_VIEWPORT,
1203     VK_DYNAMIC_STATE_END_RANGE = VK_DYNAMIC_STATE_STENCIL_REFERENCE,
1204     VK_DYNAMIC_STATE_RANGE_SIZE = (VK_DYNAMIC_STATE_STENCIL_REFERENCE - VK_DYNAMIC_STATE_VIEWPORT + 1),
1205     VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF
1206 } VkDynamicState;
1207
1208 typedef enum VkFilter {
1209     VK_FILTER_NEAREST = 0,
1210     VK_FILTER_LINEAR = 1,
1211     VK_FILTER_CUBIC_IMG = 1000015000,
1212     VK_FILTER_CUBIC_EXT = VK_FILTER_CUBIC_IMG,
1213     VK_FILTER_BEGIN_RANGE = VK_FILTER_NEAREST,
1214     VK_FILTER_END_RANGE = VK_FILTER_LINEAR,
1215     VK_FILTER_RANGE_SIZE = (VK_FILTER_LINEAR - VK_FILTER_NEAREST + 1),
1216     VK_FILTER_MAX_ENUM = 0x7FFFFFFF
1217 } VkFilter;
1218
1219 typedef enum VkSamplerMipmapMode {
1220     VK_SAMPLER_MIPMAP_MODE_NEAREST = 0,
1221     VK_SAMPLER_MIPMAP_MODE_LINEAR = 1,
1222     VK_SAMPLER_MIPMAP_MODE_BEGIN_RANGE = VK_SAMPLER_MIPMAP_MODE_NEAREST,
1223     VK_SAMPLER_MIPMAP_MODE_END_RANGE = VK_SAMPLER_MIPMAP_MODE_LINEAR,
1224     VK_SAMPLER_MIPMAP_MODE_RANGE_SIZE = (VK_SAMPLER_MIPMAP_MODE_LINEAR - VK_SAMPLER_MIPMAP_MODE_NEAREST + 1),
1225     VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF
1226 } VkSamplerMipmapMode;
1227
1228 typedef enum VkSamplerAddressMode {
1229     VK_SAMPLER_ADDRESS_MODE_REPEAT = 0,
1230     VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1,
1231     VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2,
1232     VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3,
1233     VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4,
1234     VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE = VK_SAMPLER_ADDRESS_MODE_REPEAT,
1235     VK_SAMPLER_ADDRESS_MODE_END_RANGE = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,
1236     VK_SAMPLER_ADDRESS_MODE_RANGE_SIZE = (VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER - VK_SAMPLER_ADDRESS_MODE_REPEAT + 1),
1237     VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF
1238 } VkSamplerAddressMode;
1239
1240 typedef enum VkBorderColor {
1241     VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0,
1242     VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1,
1243     VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2,
1244     VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3,
1245     VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4,
1246     VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5,
1247     VK_BORDER_COLOR_BEGIN_RANGE = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
1248     VK_BORDER_COLOR_END_RANGE = VK_BORDER_COLOR_INT_OPAQUE_WHITE,
1249     VK_BORDER_COLOR_RANGE_SIZE = (VK_BORDER_COLOR_INT_OPAQUE_WHITE - VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK + 1),
1250     VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF
1251 } VkBorderColor;
1252
1253 typedef enum VkDescriptorType {
1254     VK_DESCRIPTOR_TYPE_SAMPLER = 0,
1255     VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1,
1256     VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2,
1257     VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3,
1258     VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4,
1259     VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5,
1260     VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6,
1261     VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7,
1262     VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8,
1263     VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9,
1264     VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10,
1265     VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT = 1000138000,
1266     VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000,
1267     VK_DESCRIPTOR_TYPE_BEGIN_RANGE = VK_DESCRIPTOR_TYPE_SAMPLER,
1268     VK_DESCRIPTOR_TYPE_END_RANGE = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
1269     VK_DESCRIPTOR_TYPE_RANGE_SIZE = (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT - VK_DESCRIPTOR_TYPE_SAMPLER + 1),
1270     VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF
1271 } VkDescriptorType;
1272
1273 typedef enum VkAttachmentLoadOp {
1274     VK_ATTACHMENT_LOAD_OP_LOAD = 0,
1275     VK_ATTACHMENT_LOAD_OP_CLEAR = 1,
1276     VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2,
1277     VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE = VK_ATTACHMENT_LOAD_OP_LOAD,
1278     VK_ATTACHMENT_LOAD_OP_END_RANGE = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
1279     VK_ATTACHMENT_LOAD_OP_RANGE_SIZE = (VK_ATTACHMENT_LOAD_OP_DONT_CARE - VK_ATTACHMENT_LOAD_OP_LOAD + 1),
1280     VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF
1281 } VkAttachmentLoadOp;
1282
1283 typedef enum VkAttachmentStoreOp {
1284     VK_ATTACHMENT_STORE_OP_STORE = 0,
1285     VK_ATTACHMENT_STORE_OP_DONT_CARE = 1,
1286     VK_ATTACHMENT_STORE_OP_BEGIN_RANGE = VK_ATTACHMENT_STORE_OP_STORE,
1287     VK_ATTACHMENT_STORE_OP_END_RANGE = VK_ATTACHMENT_STORE_OP_DONT_CARE,
1288     VK_ATTACHMENT_STORE_OP_RANGE_SIZE = (VK_ATTACHMENT_STORE_OP_DONT_CARE - VK_ATTACHMENT_STORE_OP_STORE + 1),
1289     VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF
1290 } VkAttachmentStoreOp;
1291
1292 typedef enum VkPipelineBindPoint {
1293     VK_PIPELINE_BIND_POINT_GRAPHICS = 0,
1294     VK_PIPELINE_BIND_POINT_COMPUTE = 1,
1295     VK_PIPELINE_BIND_POINT_RAY_TRACING_NV = 1000165000,
1296     VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VK_PIPELINE_BIND_POINT_GRAPHICS,
1297     VK_PIPELINE_BIND_POINT_END_RANGE = VK_PIPELINE_BIND_POINT_COMPUTE,
1298     VK_PIPELINE_BIND_POINT_RANGE_SIZE = (VK_PIPELINE_BIND_POINT_COMPUTE - VK_PIPELINE_BIND_POINT_GRAPHICS + 1),
1299     VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF
1300 } VkPipelineBindPoint;
1301
1302 typedef enum VkCommandBufferLevel {
1303     VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0,
1304     VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1,
1305     VK_COMMAND_BUFFER_LEVEL_BEGIN_RANGE = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
1306     VK_COMMAND_BUFFER_LEVEL_END_RANGE = VK_COMMAND_BUFFER_LEVEL_SECONDARY,
1307     VK_COMMAND_BUFFER_LEVEL_RANGE_SIZE = (VK_COMMAND_BUFFER_LEVEL_SECONDARY - VK_COMMAND_BUFFER_LEVEL_PRIMARY + 1),
1308     VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF
1309 } VkCommandBufferLevel;
1310
1311 typedef enum VkIndexType {
1312     VK_INDEX_TYPE_UINT16 = 0,
1313     VK_INDEX_TYPE_UINT32 = 1,
1314     VK_INDEX_TYPE_NONE_NV = 1000165000,
1315     VK_INDEX_TYPE_UINT8_EXT = 1000265000,
1316     VK_INDEX_TYPE_BEGIN_RANGE = VK_INDEX_TYPE_UINT16,
1317     VK_INDEX_TYPE_END_RANGE = VK_INDEX_TYPE_UINT32,
1318     VK_INDEX_TYPE_RANGE_SIZE = (VK_INDEX_TYPE_UINT32 - VK_INDEX_TYPE_UINT16 + 1),
1319     VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF
1320 } VkIndexType;
1321
1322 typedef enum VkSubpassContents {
1323     VK_SUBPASS_CONTENTS_INLINE = 0,
1324     VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1,
1325     VK_SUBPASS_CONTENTS_BEGIN_RANGE = VK_SUBPASS_CONTENTS_INLINE,
1326     VK_SUBPASS_CONTENTS_END_RANGE = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS,
1327     VK_SUBPASS_CONTENTS_RANGE_SIZE = (VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS - VK_SUBPASS_CONTENTS_INLINE + 1),
1328     VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF
1329 } VkSubpassContents;
1330
1331 typedef enum VkObjectType {
1332     VK_OBJECT_TYPE_UNKNOWN = 0,
1333     VK_OBJECT_TYPE_INSTANCE = 1,
1334     VK_OBJECT_TYPE_PHYSICAL_DEVICE = 2,
1335     VK_OBJECT_TYPE_DEVICE = 3,
1336     VK_OBJECT_TYPE_QUEUE = 4,
1337     VK_OBJECT_TYPE_SEMAPHORE = 5,
1338     VK_OBJECT_TYPE_COMMAND_BUFFER = 6,
1339     VK_OBJECT_TYPE_FENCE = 7,
1340     VK_OBJECT_TYPE_DEVICE_MEMORY = 8,
1341     VK_OBJECT_TYPE_BUFFER = 9,
1342     VK_OBJECT_TYPE_IMAGE = 10,
1343     VK_OBJECT_TYPE_EVENT = 11,
1344     VK_OBJECT_TYPE_QUERY_POOL = 12,
1345     VK_OBJECT_TYPE_BUFFER_VIEW = 13,
1346     VK_OBJECT_TYPE_IMAGE_VIEW = 14,
1347     VK_OBJECT_TYPE_SHADER_MODULE = 15,
1348     VK_OBJECT_TYPE_PIPELINE_CACHE = 16,
1349     VK_OBJECT_TYPE_PIPELINE_LAYOUT = 17,
1350     VK_OBJECT_TYPE_RENDER_PASS = 18,
1351     VK_OBJECT_TYPE_PIPELINE = 19,
1352     VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 20,
1353     VK_OBJECT_TYPE_SAMPLER = 21,
1354     VK_OBJECT_TYPE_DESCRIPTOR_POOL = 22,
1355     VK_OBJECT_TYPE_DESCRIPTOR_SET = 23,
1356     VK_OBJECT_TYPE_FRAMEBUFFER = 24,
1357     VK_OBJECT_TYPE_COMMAND_POOL = 25,
1358     VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION = 1000156000,
1359     VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE = 1000085000,
1360     VK_OBJECT_TYPE_SURFACE_KHR = 1000000000,
1361     VK_OBJECT_TYPE_SWAPCHAIN_KHR = 1000001000,
1362     VK_OBJECT_TYPE_DISPLAY_KHR = 1000002000,
1363     VK_OBJECT_TYPE_DISPLAY_MODE_KHR = 1000002001,
1364     VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT = 1000011000,
1365     VK_OBJECT_TYPE_OBJECT_TABLE_NVX = 1000086000,
1366     VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX = 1000086001,
1367     VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT = 1000128000,
1368     VK_OBJECT_TYPE_VALIDATION_CACHE_EXT = 1000160000,
1369     VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000,
1370     VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL = 1000210000,
1371     VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE,
1372     VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION,
1373     VK_OBJECT_TYPE_BEGIN_RANGE = VK_OBJECT_TYPE_UNKNOWN,
1374     VK_OBJECT_TYPE_END_RANGE = VK_OBJECT_TYPE_COMMAND_POOL,
1375     VK_OBJECT_TYPE_RANGE_SIZE = (VK_OBJECT_TYPE_COMMAND_POOL - VK_OBJECT_TYPE_UNKNOWN + 1),
1376     VK_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF
1377 } VkObjectType;
1378
1379 typedef enum VkVendorId {
1380     VK_VENDOR_ID_VIV = 0x10001,
1381     VK_VENDOR_ID_VSI = 0x10002,
1382     VK_VENDOR_ID_KAZAN = 0x10003,
1383     VK_VENDOR_ID_BEGIN_RANGE = VK_VENDOR_ID_VIV,
1384     VK_VENDOR_ID_END_RANGE = VK_VENDOR_ID_KAZAN,
1385     VK_VENDOR_ID_RANGE_SIZE = (VK_VENDOR_ID_KAZAN - VK_VENDOR_ID_VIV + 1),
1386     VK_VENDOR_ID_MAX_ENUM = 0x7FFFFFFF
1387 } VkVendorId;
1388 typedef VkFlags VkInstanceCreateFlags;
1389
1390 typedef enum VkFormatFeatureFlagBits {
1391     VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001,
1392     VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002,
1393     VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004,
1394     VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008,
1395     VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010,
1396     VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020,
1397     VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040,
1398     VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080,
1399     VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100,
1400     VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200,
1401     VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400,
1402     VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800,
1403     VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000,
1404     VK_FORMAT_FEATURE_TRANSFER_SRC_BIT = 0x00004000,
1405     VK_FORMAT_FEATURE_TRANSFER_DST_BIT = 0x00008000,
1406     VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT = 0x00020000,
1407     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT = 0x00040000,
1408     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT = 0x00080000,
1409     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT = 0x00100000,
1410     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT = 0x00200000,
1411     VK_FORMAT_FEATURE_DISJOINT_BIT = 0x00400000,
1412     VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT = 0x00800000,
1413     VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = 0x00002000,
1414     VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT = 0x00010000,
1415     VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x01000000,
1416     VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT,
1417     VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_DST_BIT,
1418     VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT,
1419     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT,
1420     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT,
1421     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT,
1422     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT,
1423     VK_FORMAT_FEATURE_DISJOINT_BIT_KHR = VK_FORMAT_FEATURE_DISJOINT_BIT,
1424     VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT,
1425     VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG,
1426     VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1427 } VkFormatFeatureFlagBits;
1428 typedef VkFlags VkFormatFeatureFlags;
1429
1430 typedef enum VkImageUsageFlagBits {
1431     VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001,
1432     VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002,
1433     VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004,
1434     VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008,
1435     VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010,
1436     VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020,
1437     VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040,
1438     VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080,
1439     VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV = 0x00000100,
1440     VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x00000200,
1441     VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1442 } VkImageUsageFlagBits;
1443 typedef VkFlags VkImageUsageFlags;
1444
1445 typedef enum VkImageCreateFlagBits {
1446     VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001,
1447     VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,
1448     VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
1449     VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008,
1450     VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010,
1451     VK_IMAGE_CREATE_ALIAS_BIT = 0x00000400,
1452     VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT = 0x00000040,
1453     VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT = 0x00000020,
1454     VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT = 0x00000080,
1455     VK_IMAGE_CREATE_EXTENDED_USAGE_BIT = 0x00000100,
1456     VK_IMAGE_CREATE_PROTECTED_BIT = 0x00000800,
1457     VK_IMAGE_CREATE_DISJOINT_BIT = 0x00000200,
1458     VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV = 0x00002000,
1459     VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = 0x00001000,
1460     VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT = 0x00004000,
1461     VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT,
1462     VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT,
1463     VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT,
1464     VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT,
1465     VK_IMAGE_CREATE_DISJOINT_BIT_KHR = VK_IMAGE_CREATE_DISJOINT_BIT,
1466     VK_IMAGE_CREATE_ALIAS_BIT_KHR = VK_IMAGE_CREATE_ALIAS_BIT,
1467     VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1468 } VkImageCreateFlagBits;
1469 typedef VkFlags VkImageCreateFlags;
1470
1471 typedef enum VkSampleCountFlagBits {
1472     VK_SAMPLE_COUNT_1_BIT = 0x00000001,
1473     VK_SAMPLE_COUNT_2_BIT = 0x00000002,
1474     VK_SAMPLE_COUNT_4_BIT = 0x00000004,
1475     VK_SAMPLE_COUNT_8_BIT = 0x00000008,
1476     VK_SAMPLE_COUNT_16_BIT = 0x00000010,
1477     VK_SAMPLE_COUNT_32_BIT = 0x00000020,
1478     VK_SAMPLE_COUNT_64_BIT = 0x00000040,
1479     VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1480 } VkSampleCountFlagBits;
1481 typedef VkFlags VkSampleCountFlags;
1482
1483 typedef enum VkQueueFlagBits {
1484     VK_QUEUE_GRAPHICS_BIT = 0x00000001,
1485     VK_QUEUE_COMPUTE_BIT = 0x00000002,
1486     VK_QUEUE_TRANSFER_BIT = 0x00000004,
1487     VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008,
1488     VK_QUEUE_PROTECTED_BIT = 0x00000010,
1489     VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1490 } VkQueueFlagBits;
1491 typedef VkFlags VkQueueFlags;
1492
1493 typedef enum VkMemoryPropertyFlagBits {
1494     VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001,
1495     VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002,
1496     VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004,
1497     VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008,
1498     VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010,
1499     VK_MEMORY_PROPERTY_PROTECTED_BIT = 0x00000020,
1500     VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1501 } VkMemoryPropertyFlagBits;
1502 typedef VkFlags VkMemoryPropertyFlags;
1503
1504 typedef enum VkMemoryHeapFlagBits {
1505     VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001,
1506     VK_MEMORY_HEAP_MULTI_INSTANCE_BIT = 0x00000002,
1507     VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT,
1508     VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1509 } VkMemoryHeapFlagBits;
1510 typedef VkFlags VkMemoryHeapFlags;
1511 typedef VkFlags VkDeviceCreateFlags;
1512
1513 typedef enum VkDeviceQueueCreateFlagBits {
1514     VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT = 0x00000001,
1515     VK_DEVICE_QUEUE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1516 } VkDeviceQueueCreateFlagBits;
1517 typedef VkFlags VkDeviceQueueCreateFlags;
1518
1519 typedef enum VkPipelineStageFlagBits {
1520     VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001,
1521     VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002,
1522     VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004,
1523     VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008,
1524     VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010,
1525     VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020,
1526     VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040,
1527     VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080,
1528     VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100,
1529     VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200,
1530     VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400,
1531     VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800,
1532     VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000,
1533     VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000,
1534     VK_PIPELINE_STAGE_HOST_BIT = 0x00004000,
1535     VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000,
1536     VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000,
1537     VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT = 0x01000000,
1538     VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00040000,
1539     VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX = 0x00020000,
1540     VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV = 0x00400000,
1541     VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV = 0x00200000,
1542     VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV = 0x02000000,
1543     VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV = 0x00080000,
1544     VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV = 0x00100000,
1545     VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT = 0x00800000,
1546     VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1547 } VkPipelineStageFlagBits;
1548 typedef VkFlags VkPipelineStageFlags;
1549 typedef VkFlags VkMemoryMapFlags;
1550
1551 typedef enum VkImageAspectFlagBits {
1552     VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001,
1553     VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002,
1554     VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004,
1555     VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008,
1556     VK_IMAGE_ASPECT_PLANE_0_BIT = 0x00000010,
1557     VK_IMAGE_ASPECT_PLANE_1_BIT = 0x00000020,
1558     VK_IMAGE_ASPECT_PLANE_2_BIT = 0x00000040,
1559     VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT = 0x00000080,
1560     VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT = 0x00000100,
1561     VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT = 0x00000200,
1562     VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT = 0x00000400,
1563     VK_IMAGE_ASPECT_PLANE_0_BIT_KHR = VK_IMAGE_ASPECT_PLANE_0_BIT,
1564     VK_IMAGE_ASPECT_PLANE_1_BIT_KHR = VK_IMAGE_ASPECT_PLANE_1_BIT,
1565     VK_IMAGE_ASPECT_PLANE_2_BIT_KHR = VK_IMAGE_ASPECT_PLANE_2_BIT,
1566     VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1567 } VkImageAspectFlagBits;
1568 typedef VkFlags VkImageAspectFlags;
1569
1570 typedef enum VkSparseImageFormatFlagBits {
1571     VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001,
1572     VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002,
1573     VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004,
1574     VK_SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1575 } VkSparseImageFormatFlagBits;
1576 typedef VkFlags VkSparseImageFormatFlags;
1577
1578 typedef enum VkSparseMemoryBindFlagBits {
1579     VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0x00000001,
1580     VK_SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1581 } VkSparseMemoryBindFlagBits;
1582 typedef VkFlags VkSparseMemoryBindFlags;
1583
1584 typedef enum VkFenceCreateFlagBits {
1585     VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001,
1586     VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1587 } VkFenceCreateFlagBits;
1588 typedef VkFlags VkFenceCreateFlags;
1589 typedef VkFlags VkSemaphoreCreateFlags;
1590 typedef VkFlags VkEventCreateFlags;
1591 typedef VkFlags VkQueryPoolCreateFlags;
1592
1593 typedef enum VkQueryPipelineStatisticFlagBits {
1594     VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001,
1595     VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002,
1596     VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004,
1597     VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008,
1598     VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0x00000010,
1599     VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0x00000020,
1600     VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0x00000040,
1601     VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0x00000080,
1602     VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x00000100,
1603     VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0x00000200,
1604     VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400,
1605     VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1606 } VkQueryPipelineStatisticFlagBits;
1607 typedef VkFlags VkQueryPipelineStatisticFlags;
1608
1609 typedef enum VkQueryResultFlagBits {
1610     VK_QUERY_RESULT_64_BIT = 0x00000001,
1611     VK_QUERY_RESULT_WAIT_BIT = 0x00000002,
1612     VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004,
1613     VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008,
1614     VK_QUERY_RESULT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1615 } VkQueryResultFlagBits;
1616 typedef VkFlags VkQueryResultFlags;
1617
1618 typedef enum VkBufferCreateFlagBits {
1619     VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001,
1620     VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,
1621     VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
1622     VK_BUFFER_CREATE_PROTECTED_BIT = 0x00000008,
1623     VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT = 0x00000010,
1624     VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1625 } VkBufferCreateFlagBits;
1626 typedef VkFlags VkBufferCreateFlags;
1627
1628 typedef enum VkBufferUsageFlagBits {
1629     VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001,
1630     VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002,
1631     VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004,
1632     VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008,
1633     VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010,
1634     VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020,
1635     VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040,
1636     VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080,
1637     VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100,
1638     VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT = 0x00000800,
1639     VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT = 0x00001000,
1640     VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00000200,
1641     VK_BUFFER_USAGE_RAY_TRACING_BIT_NV = 0x00000400,
1642     VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT = 0x00020000,
1643     VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1644 } VkBufferUsageFlagBits;
1645 typedef VkFlags VkBufferUsageFlags;
1646 typedef VkFlags VkBufferViewCreateFlags;
1647
1648 typedef enum VkImageViewCreateFlagBits {
1649     VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT = 0x00000001,
1650     VK_IMAGE_VIEW_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1651 } VkImageViewCreateFlagBits;
1652 typedef VkFlags VkImageViewCreateFlags;
1653
1654 typedef enum VkShaderModuleCreateFlagBits {
1655     VK_SHADER_MODULE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1656 } VkShaderModuleCreateFlagBits;
1657 typedef VkFlags VkShaderModuleCreateFlags;
1658 typedef VkFlags VkPipelineCacheCreateFlags;
1659
1660 typedef enum VkPipelineCreateFlagBits {
1661     VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001,
1662     VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002,
1663     VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004,
1664     VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0x00000008,
1665     VK_PIPELINE_CREATE_DISPATCH_BASE = 0x00000010,
1666     VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV = 0x00000020,
1667     VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT,
1668     VK_PIPELINE_CREATE_DISPATCH_BASE_KHR = VK_PIPELINE_CREATE_DISPATCH_BASE,
1669     VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1670 } VkPipelineCreateFlagBits;
1671 typedef VkFlags VkPipelineCreateFlags;
1672
1673 typedef enum VkPipelineShaderStageCreateFlagBits {
1674     VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT = 0x00000001,
1675     VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT = 0x00000002,
1676     VK_PIPELINE_SHADER_STAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1677 } VkPipelineShaderStageCreateFlagBits;
1678 typedef VkFlags VkPipelineShaderStageCreateFlags;
1679
1680 typedef enum VkShaderStageFlagBits {
1681     VK_SHADER_STAGE_VERTEX_BIT = 0x00000001,
1682     VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002,
1683     VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004,
1684     VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008,
1685     VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010,
1686     VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020,
1687     VK_SHADER_STAGE_ALL_GRAPHICS = 0x0000001F,
1688     VK_SHADER_STAGE_ALL = 0x7FFFFFFF,
1689     VK_SHADER_STAGE_RAYGEN_BIT_NV = 0x00000100,
1690     VK_SHADER_STAGE_ANY_HIT_BIT_NV = 0x00000200,
1691     VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV = 0x00000400,
1692     VK_SHADER_STAGE_MISS_BIT_NV = 0x00000800,
1693     VK_SHADER_STAGE_INTERSECTION_BIT_NV = 0x00001000,
1694     VK_SHADER_STAGE_CALLABLE_BIT_NV = 0x00002000,
1695     VK_SHADER_STAGE_TASK_BIT_NV = 0x00000040,
1696     VK_SHADER_STAGE_MESH_BIT_NV = 0x00000080,
1697     VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1698 } VkShaderStageFlagBits;
1699 typedef VkFlags VkPipelineVertexInputStateCreateFlags;
1700 typedef VkFlags VkPipelineInputAssemblyStateCreateFlags;
1701 typedef VkFlags VkPipelineTessellationStateCreateFlags;
1702 typedef VkFlags VkPipelineViewportStateCreateFlags;
1703 typedef VkFlags VkPipelineRasterizationStateCreateFlags;
1704
1705 typedef enum VkCullModeFlagBits {
1706     VK_CULL_MODE_NONE = 0,
1707     VK_CULL_MODE_FRONT_BIT = 0x00000001,
1708     VK_CULL_MODE_BACK_BIT = 0x00000002,
1709     VK_CULL_MODE_FRONT_AND_BACK = 0x00000003,
1710     VK_CULL_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1711 } VkCullModeFlagBits;
1712 typedef VkFlags VkCullModeFlags;
1713 typedef VkFlags VkPipelineMultisampleStateCreateFlags;
1714 typedef VkFlags VkPipelineDepthStencilStateCreateFlags;
1715 typedef VkFlags VkPipelineColorBlendStateCreateFlags;
1716
1717 typedef enum VkColorComponentFlagBits {
1718     VK_COLOR_COMPONENT_R_BIT = 0x00000001,
1719     VK_COLOR_COMPONENT_G_BIT = 0x00000002,
1720     VK_COLOR_COMPONENT_B_BIT = 0x00000004,
1721     VK_COLOR_COMPONENT_A_BIT = 0x00000008,
1722     VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1723 } VkColorComponentFlagBits;
1724 typedef VkFlags VkColorComponentFlags;
1725 typedef VkFlags VkPipelineDynamicStateCreateFlags;
1726 typedef VkFlags VkPipelineLayoutCreateFlags;
1727 typedef VkFlags VkShaderStageFlags;
1728
1729 typedef enum VkSamplerCreateFlagBits {
1730     VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT = 0x00000001,
1731     VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT = 0x00000002,
1732     VK_SAMPLER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1733 } VkSamplerCreateFlagBits;
1734 typedef VkFlags VkSamplerCreateFlags;
1735
1736 typedef enum VkDescriptorSetLayoutCreateFlagBits {
1737     VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR = 0x00000001,
1738     VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT = 0x00000002,
1739     VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1740 } VkDescriptorSetLayoutCreateFlagBits;
1741 typedef VkFlags VkDescriptorSetLayoutCreateFlags;
1742
1743 typedef enum VkDescriptorPoolCreateFlagBits {
1744     VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001,
1745     VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT = 0x00000002,
1746     VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1747 } VkDescriptorPoolCreateFlagBits;
1748 typedef VkFlags VkDescriptorPoolCreateFlags;
1749 typedef VkFlags VkDescriptorPoolResetFlags;
1750
1751 typedef enum VkFramebufferCreateFlagBits {
1752     VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR = 0x00000001,
1753     VK_FRAMEBUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1754 } VkFramebufferCreateFlagBits;
1755 typedef VkFlags VkFramebufferCreateFlags;
1756
1757 typedef enum VkRenderPassCreateFlagBits {
1758     VK_RENDER_PASS_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1759 } VkRenderPassCreateFlagBits;
1760 typedef VkFlags VkRenderPassCreateFlags;
1761
1762 typedef enum VkAttachmentDescriptionFlagBits {
1763     VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001,
1764     VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1765 } VkAttachmentDescriptionFlagBits;
1766 typedef VkFlags VkAttachmentDescriptionFlags;
1767
1768 typedef enum VkSubpassDescriptionFlagBits {
1769     VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX = 0x00000001,
1770     VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX = 0x00000002,
1771     VK_SUBPASS_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1772 } VkSubpassDescriptionFlagBits;
1773 typedef VkFlags VkSubpassDescriptionFlags;
1774
1775 typedef enum VkAccessFlagBits {
1776     VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001,
1777     VK_ACCESS_INDEX_READ_BIT = 0x00000002,
1778     VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004,
1779     VK_ACCESS_UNIFORM_READ_BIT = 0x00000008,
1780     VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0x00000010,
1781     VK_ACCESS_SHADER_READ_BIT = 0x00000020,
1782     VK_ACCESS_SHADER_WRITE_BIT = 0x00000040,
1783     VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0x00000080,
1784     VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100,
1785     VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200,
1786     VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400,
1787     VK_ACCESS_TRANSFER_READ_BIT = 0x00000800,
1788     VK_ACCESS_TRANSFER_WRITE_BIT = 0x00001000,
1789     VK_ACCESS_HOST_READ_BIT = 0x00002000,
1790     VK_ACCESS_HOST_WRITE_BIT = 0x00004000,
1791     VK_ACCESS_MEMORY_READ_BIT = 0x00008000,
1792     VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000,
1793     VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT = 0x02000000,
1794     VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT = 0x04000000,
1795     VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT = 0x08000000,
1796     VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT = 0x00100000,
1797     VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX = 0x00020000,
1798     VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX = 0x00040000,
1799     VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000,
1800     VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV = 0x00800000,
1801     VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV = 0x00200000,
1802     VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV = 0x00400000,
1803     VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT = 0x01000000,
1804     VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1805 } VkAccessFlagBits;
1806 typedef VkFlags VkAccessFlags;
1807
1808 typedef enum VkDependencyFlagBits {
1809     VK_DEPENDENCY_BY_REGION_BIT = 0x00000001,
1810     VK_DEPENDENCY_DEVICE_GROUP_BIT = 0x00000004,
1811     VK_DEPENDENCY_VIEW_LOCAL_BIT = 0x00000002,
1812     VK_DEPENDENCY_VIEW_LOCAL_BIT_KHR = VK_DEPENDENCY_VIEW_LOCAL_BIT,
1813     VK_DEPENDENCY_DEVICE_GROUP_BIT_KHR = VK_DEPENDENCY_DEVICE_GROUP_BIT,
1814     VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1815 } VkDependencyFlagBits;
1816 typedef VkFlags VkDependencyFlags;
1817
1818 typedef enum VkCommandPoolCreateFlagBits {
1819     VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001,
1820     VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002,
1821     VK_COMMAND_POOL_CREATE_PROTECTED_BIT = 0x00000004,
1822     VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1823 } VkCommandPoolCreateFlagBits;
1824 typedef VkFlags VkCommandPoolCreateFlags;
1825
1826 typedef enum VkCommandPoolResetFlagBits {
1827     VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
1828     VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1829 } VkCommandPoolResetFlagBits;
1830 typedef VkFlags VkCommandPoolResetFlags;
1831
1832 typedef enum VkCommandBufferUsageFlagBits {
1833     VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001,
1834     VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002,
1835     VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004,
1836     VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1837 } VkCommandBufferUsageFlagBits;
1838 typedef VkFlags VkCommandBufferUsageFlags;
1839
1840 typedef enum VkQueryControlFlagBits {
1841     VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001,
1842     VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1843 } VkQueryControlFlagBits;
1844 typedef VkFlags VkQueryControlFlags;
1845
1846 typedef enum VkCommandBufferResetFlagBits {
1847     VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
1848     VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1849 } VkCommandBufferResetFlagBits;
1850 typedef VkFlags VkCommandBufferResetFlags;
1851
1852 typedef enum VkStencilFaceFlagBits {
1853     VK_STENCIL_FACE_FRONT_BIT = 0x00000001,
1854     VK_STENCIL_FACE_BACK_BIT = 0x00000002,
1855     VK_STENCIL_FACE_FRONT_AND_BACK = 0x00000003,
1856     VK_STENCIL_FRONT_AND_BACK = VK_STENCIL_FACE_FRONT_AND_BACK,
1857     VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1858 } VkStencilFaceFlagBits;
1859 typedef VkFlags VkStencilFaceFlags;
1860 typedef struct VkApplicationInfo {
1861     VkStructureType    sType;
1862     const void*        pNext;
1863     const char*        pApplicationName;
1864     uint32_t           applicationVersion;
1865     const char*        pEngineName;
1866     uint32_t           engineVersion;
1867     uint32_t           apiVersion;
1868 } VkApplicationInfo;
1869
1870 typedef struct VkInstanceCreateInfo {
1871     VkStructureType             sType;
1872     const void*                 pNext;
1873     VkInstanceCreateFlags       flags;
1874     const VkApplicationInfo*    pApplicationInfo;
1875     uint32_t                    enabledLayerCount;
1876     const char* const*          ppEnabledLayerNames;
1877     uint32_t                    enabledExtensionCount;
1878     const char* const*          ppEnabledExtensionNames;
1879 } VkInstanceCreateInfo;
1880
1881 typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)(
1882     void*                                       pUserData,
1883     size_t                                      size,
1884     size_t                                      alignment,
1885     VkSystemAllocationScope                     allocationScope);
1886
1887 typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)(
1888     void*                                       pUserData,
1889     void*                                       pOriginal,
1890     size_t                                      size,
1891     size_t                                      alignment,
1892     VkSystemAllocationScope                     allocationScope);
1893
1894 typedef void (VKAPI_PTR *PFN_vkFreeFunction)(
1895     void*                                       pUserData,
1896     void*                                       pMemory);
1897
1898 typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)(
1899     void*                                       pUserData,
1900     size_t                                      size,
1901     VkInternalAllocationType                    allocationType,
1902     VkSystemAllocationScope                     allocationScope);
1903
1904 typedef void (VKAPI_PTR *PFN_vkInternalFreeNotification)(
1905     void*                                       pUserData,
1906     size_t                                      size,
1907     VkInternalAllocationType                    allocationType,
1908     VkSystemAllocationScope                     allocationScope);
1909
1910 typedef struct VkAllocationCallbacks {
1911     void*                                   pUserData;
1912     PFN_vkAllocationFunction                pfnAllocation;
1913     PFN_vkReallocationFunction              pfnReallocation;
1914     PFN_vkFreeFunction                      pfnFree;
1915     PFN_vkInternalAllocationNotification    pfnInternalAllocation;
1916     PFN_vkInternalFreeNotification          pfnInternalFree;
1917 } VkAllocationCallbacks;
1918
1919 typedef struct VkPhysicalDeviceFeatures {
1920     VkBool32    robustBufferAccess;
1921     VkBool32    fullDrawIndexUint32;
1922     VkBool32    imageCubeArray;
1923     VkBool32    independentBlend;
1924     VkBool32    geometryShader;
1925     VkBool32    tessellationShader;
1926     VkBool32    sampleRateShading;
1927     VkBool32    dualSrcBlend;
1928     VkBool32    logicOp;
1929     VkBool32    multiDrawIndirect;
1930     VkBool32    drawIndirectFirstInstance;
1931     VkBool32    depthClamp;
1932     VkBool32    depthBiasClamp;
1933     VkBool32    fillModeNonSolid;
1934     VkBool32    depthBounds;
1935     VkBool32    wideLines;
1936     VkBool32    largePoints;
1937     VkBool32    alphaToOne;
1938     VkBool32    multiViewport;
1939     VkBool32    samplerAnisotropy;
1940     VkBool32    textureCompressionETC2;
1941     VkBool32    textureCompressionASTC_LDR;
1942     VkBool32    textureCompressionBC;
1943     VkBool32    occlusionQueryPrecise;
1944     VkBool32    pipelineStatisticsQuery;
1945     VkBool32    vertexPipelineStoresAndAtomics;
1946     VkBool32    fragmentStoresAndAtomics;
1947     VkBool32    shaderTessellationAndGeometryPointSize;
1948     VkBool32    shaderImageGatherExtended;
1949     VkBool32    shaderStorageImageExtendedFormats;
1950     VkBool32    shaderStorageImageMultisample;
1951     VkBool32    shaderStorageImageReadWithoutFormat;
1952     VkBool32    shaderStorageImageWriteWithoutFormat;
1953     VkBool32    shaderUniformBufferArrayDynamicIndexing;
1954     VkBool32    shaderSampledImageArrayDynamicIndexing;
1955     VkBool32    shaderStorageBufferArrayDynamicIndexing;
1956     VkBool32    shaderStorageImageArrayDynamicIndexing;
1957     VkBool32    shaderClipDistance;
1958     VkBool32    shaderCullDistance;
1959     VkBool32    shaderFloat64;
1960     VkBool32    shaderInt64;
1961     VkBool32    shaderInt16;
1962     VkBool32    shaderResourceResidency;
1963     VkBool32    shaderResourceMinLod;
1964     VkBool32    sparseBinding;
1965     VkBool32    sparseResidencyBuffer;
1966     VkBool32    sparseResidencyImage2D;
1967     VkBool32    sparseResidencyImage3D;
1968     VkBool32    sparseResidency2Samples;
1969     VkBool32    sparseResidency4Samples;
1970     VkBool32    sparseResidency8Samples;
1971     VkBool32    sparseResidency16Samples;
1972     VkBool32    sparseResidencyAliased;
1973     VkBool32    variableMultisampleRate;
1974     VkBool32    inheritedQueries;
1975 } VkPhysicalDeviceFeatures;
1976
1977 typedef struct VkFormatProperties {
1978     VkFormatFeatureFlags    linearTilingFeatures;
1979     VkFormatFeatureFlags    optimalTilingFeatures;
1980     VkFormatFeatureFlags    bufferFeatures;
1981 } VkFormatProperties;
1982
1983 typedef struct VkExtent3D {
1984     uint32_t    width;
1985     uint32_t    height;
1986     uint32_t    depth;
1987 } VkExtent3D;
1988
1989 typedef struct VkImageFormatProperties {
1990     VkExtent3D            maxExtent;
1991     uint32_t              maxMipLevels;
1992     uint32_t              maxArrayLayers;
1993     VkSampleCountFlags    sampleCounts;
1994     VkDeviceSize          maxResourceSize;
1995 } VkImageFormatProperties;
1996
1997 typedef struct VkPhysicalDeviceLimits {
1998     uint32_t              maxImageDimension1D;
1999     uint32_t              maxImageDimension2D;
2000     uint32_t              maxImageDimension3D;
2001     uint32_t              maxImageDimensionCube;
2002     uint32_t              maxImageArrayLayers;
2003     uint32_t              maxTexelBufferElements;
2004     uint32_t              maxUniformBufferRange;
2005     uint32_t              maxStorageBufferRange;
2006     uint32_t              maxPushConstantsSize;
2007     uint32_t              maxMemoryAllocationCount;
2008     uint32_t              maxSamplerAllocationCount;
2009     VkDeviceSize          bufferImageGranularity;
2010     VkDeviceSize          sparseAddressSpaceSize;
2011     uint32_t              maxBoundDescriptorSets;
2012     uint32_t              maxPerStageDescriptorSamplers;
2013     uint32_t              maxPerStageDescriptorUniformBuffers;
2014     uint32_t              maxPerStageDescriptorStorageBuffers;
2015     uint32_t              maxPerStageDescriptorSampledImages;
2016     uint32_t              maxPerStageDescriptorStorageImages;
2017     uint32_t              maxPerStageDescriptorInputAttachments;
2018     uint32_t              maxPerStageResources;
2019     uint32_t              maxDescriptorSetSamplers;
2020     uint32_t              maxDescriptorSetUniformBuffers;
2021     uint32_t              maxDescriptorSetUniformBuffersDynamic;
2022     uint32_t              maxDescriptorSetStorageBuffers;
2023     uint32_t              maxDescriptorSetStorageBuffersDynamic;
2024     uint32_t              maxDescriptorSetSampledImages;
2025     uint32_t              maxDescriptorSetStorageImages;
2026     uint32_t              maxDescriptorSetInputAttachments;
2027     uint32_t              maxVertexInputAttributes;
2028     uint32_t              maxVertexInputBindings;
2029     uint32_t              maxVertexInputAttributeOffset;
2030     uint32_t              maxVertexInputBindingStride;
2031     uint32_t              maxVertexOutputComponents;
2032     uint32_t              maxTessellationGenerationLevel;
2033     uint32_t              maxTessellationPatchSize;
2034     uint32_t              maxTessellationControlPerVertexInputComponents;
2035     uint32_t              maxTessellationControlPerVertexOutputComponents;
2036     uint32_t              maxTessellationControlPerPatchOutputComponents;
2037     uint32_t              maxTessellationControlTotalOutputComponents;
2038     uint32_t              maxTessellationEvaluationInputComponents;
2039     uint32_t              maxTessellationEvaluationOutputComponents;
2040     uint32_t              maxGeometryShaderInvocations;
2041     uint32_t              maxGeometryInputComponents;
2042     uint32_t              maxGeometryOutputComponents;
2043     uint32_t              maxGeometryOutputVertices;
2044     uint32_t              maxGeometryTotalOutputComponents;
2045     uint32_t              maxFragmentInputComponents;
2046     uint32_t              maxFragmentOutputAttachments;
2047     uint32_t              maxFragmentDualSrcAttachments;
2048     uint32_t              maxFragmentCombinedOutputResources;
2049     uint32_t              maxComputeSharedMemorySize;
2050     uint32_t              maxComputeWorkGroupCount[3];
2051     uint32_t              maxComputeWorkGroupInvocations;
2052     uint32_t              maxComputeWorkGroupSize[3];
2053     uint32_t              subPixelPrecisionBits;
2054     uint32_t              subTexelPrecisionBits;
2055     uint32_t              mipmapPrecisionBits;
2056     uint32_t              maxDrawIndexedIndexValue;
2057     uint32_t              maxDrawIndirectCount;
2058     float                 maxSamplerLodBias;
2059     float                 maxSamplerAnisotropy;
2060     uint32_t              maxViewports;
2061     uint32_t              maxViewportDimensions[2];
2062     float                 viewportBoundsRange[2];
2063     uint32_t              viewportSubPixelBits;
2064     size_t                minMemoryMapAlignment;
2065     VkDeviceSize          minTexelBufferOffsetAlignment;
2066     VkDeviceSize          minUniformBufferOffsetAlignment;
2067     VkDeviceSize          minStorageBufferOffsetAlignment;
2068     int32_t               minTexelOffset;
2069     uint32_t              maxTexelOffset;
2070     int32_t               minTexelGatherOffset;
2071     uint32_t              maxTexelGatherOffset;
2072     float                 minInterpolationOffset;
2073     float                 maxInterpolationOffset;
2074     uint32_t              subPixelInterpolationOffsetBits;
2075     uint32_t              maxFramebufferWidth;
2076     uint32_t              maxFramebufferHeight;
2077     uint32_t              maxFramebufferLayers;
2078     VkSampleCountFlags    framebufferColorSampleCounts;
2079     VkSampleCountFlags    framebufferDepthSampleCounts;
2080     VkSampleCountFlags    framebufferStencilSampleCounts;
2081     VkSampleCountFlags    framebufferNoAttachmentsSampleCounts;
2082     uint32_t              maxColorAttachments;
2083     VkSampleCountFlags    sampledImageColorSampleCounts;
2084     VkSampleCountFlags    sampledImageIntegerSampleCounts;
2085     VkSampleCountFlags    sampledImageDepthSampleCounts;
2086     VkSampleCountFlags    sampledImageStencilSampleCounts;
2087     VkSampleCountFlags    storageImageSampleCounts;
2088     uint32_t              maxSampleMaskWords;
2089     VkBool32              timestampComputeAndGraphics;
2090     float                 timestampPeriod;
2091     uint32_t              maxClipDistances;
2092     uint32_t              maxCullDistances;
2093     uint32_t              maxCombinedClipAndCullDistances;
2094     uint32_t              discreteQueuePriorities;
2095     float                 pointSizeRange[2];
2096     float                 lineWidthRange[2];
2097     float                 pointSizeGranularity;
2098     float                 lineWidthGranularity;
2099     VkBool32              strictLines;
2100     VkBool32              standardSampleLocations;
2101     VkDeviceSize          optimalBufferCopyOffsetAlignment;
2102     VkDeviceSize          optimalBufferCopyRowPitchAlignment;
2103     VkDeviceSize          nonCoherentAtomSize;
2104 } VkPhysicalDeviceLimits;
2105
2106 typedef struct VkPhysicalDeviceSparseProperties {
2107     VkBool32    residencyStandard2DBlockShape;
2108     VkBool32    residencyStandard2DMultisampleBlockShape;
2109     VkBool32    residencyStandard3DBlockShape;
2110     VkBool32    residencyAlignedMipSize;
2111     VkBool32    residencyNonResidentStrict;
2112 } VkPhysicalDeviceSparseProperties;
2113
2114 typedef struct VkPhysicalDeviceProperties {
2115     uint32_t                            apiVersion;
2116     uint32_t                            driverVersion;
2117     uint32_t                            vendorID;
2118     uint32_t                            deviceID;
2119     VkPhysicalDeviceType                deviceType;
2120     char                                deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
2121     uint8_t                             pipelineCacheUUID[VK_UUID_SIZE];
2122     VkPhysicalDeviceLimits              limits;
2123     VkPhysicalDeviceSparseProperties    sparseProperties;
2124 } VkPhysicalDeviceProperties;
2125
2126 typedef struct VkQueueFamilyProperties {
2127     VkQueueFlags    queueFlags;
2128     uint32_t        queueCount;
2129     uint32_t        timestampValidBits;
2130     VkExtent3D      minImageTransferGranularity;
2131 } VkQueueFamilyProperties;
2132
2133 typedef struct VkMemoryType {
2134     VkMemoryPropertyFlags    propertyFlags;
2135     uint32_t                 heapIndex;
2136 } VkMemoryType;
2137
2138 typedef struct VkMemoryHeap {
2139     VkDeviceSize         size;
2140     VkMemoryHeapFlags    flags;
2141 } VkMemoryHeap;
2142
2143 typedef struct VkPhysicalDeviceMemoryProperties {
2144     uint32_t        memoryTypeCount;
2145     VkMemoryType    memoryTypes[VK_MAX_MEMORY_TYPES];
2146     uint32_t        memoryHeapCount;
2147     VkMemoryHeap    memoryHeaps[VK_MAX_MEMORY_HEAPS];
2148 } VkPhysicalDeviceMemoryProperties;
2149
2150 typedef void (VKAPI_PTR *PFN_vkVoidFunction)(void);
2151 typedef struct VkDeviceQueueCreateInfo {
2152     VkStructureType             sType;
2153     const void*                 pNext;
2154     VkDeviceQueueCreateFlags    flags;
2155     uint32_t                    queueFamilyIndex;
2156     uint32_t                    queueCount;
2157     const float*                pQueuePriorities;
2158 } VkDeviceQueueCreateInfo;
2159
2160 typedef struct VkDeviceCreateInfo {
2161     VkStructureType                    sType;
2162     const void*                        pNext;
2163     VkDeviceCreateFlags                flags;
2164     uint32_t                           queueCreateInfoCount;
2165     const VkDeviceQueueCreateInfo*     pQueueCreateInfos;
2166     uint32_t                           enabledLayerCount;
2167     const char* const*                 ppEnabledLayerNames;
2168     uint32_t                           enabledExtensionCount;
2169     const char* const*                 ppEnabledExtensionNames;
2170     const VkPhysicalDeviceFeatures*    pEnabledFeatures;
2171 } VkDeviceCreateInfo;
2172
2173 typedef struct VkExtensionProperties {
2174     char        extensionName[VK_MAX_EXTENSION_NAME_SIZE];
2175     uint32_t    specVersion;
2176 } VkExtensionProperties;
2177
2178 typedef struct VkLayerProperties {
2179     char        layerName[VK_MAX_EXTENSION_NAME_SIZE];
2180     uint32_t    specVersion;
2181     uint32_t    implementationVersion;
2182     char        description[VK_MAX_DESCRIPTION_SIZE];
2183 } VkLayerProperties;
2184
2185 typedef struct VkSubmitInfo {
2186     VkStructureType                sType;
2187     const void*                    pNext;
2188     uint32_t                       waitSemaphoreCount;
2189     const VkSemaphore*             pWaitSemaphores;
2190     const VkPipelineStageFlags*    pWaitDstStageMask;
2191     uint32_t                       commandBufferCount;
2192     const VkCommandBuffer*         pCommandBuffers;
2193     uint32_t                       signalSemaphoreCount;
2194     const VkSemaphore*             pSignalSemaphores;
2195 } VkSubmitInfo;
2196
2197 typedef struct VkMemoryAllocateInfo {
2198     VkStructureType    sType;
2199     const void*        pNext;
2200     VkDeviceSize       allocationSize;
2201     uint32_t           memoryTypeIndex;
2202 } VkMemoryAllocateInfo;
2203
2204 typedef struct VkMappedMemoryRange {
2205     VkStructureType    sType;
2206     const void*        pNext;
2207     VkDeviceMemory     memory;
2208     VkDeviceSize       offset;
2209     VkDeviceSize       size;
2210 } VkMappedMemoryRange;
2211
2212 typedef struct VkMemoryRequirements {
2213     VkDeviceSize    size;
2214     VkDeviceSize    alignment;
2215     uint32_t        memoryTypeBits;
2216 } VkMemoryRequirements;
2217
2218 typedef struct VkSparseImageFormatProperties {
2219     VkImageAspectFlags          aspectMask;
2220     VkExtent3D                  imageGranularity;
2221     VkSparseImageFormatFlags    flags;
2222 } VkSparseImageFormatProperties;
2223
2224 typedef struct VkSparseImageMemoryRequirements {
2225     VkSparseImageFormatProperties    formatProperties;
2226     uint32_t                         imageMipTailFirstLod;
2227     VkDeviceSize                     imageMipTailSize;
2228     VkDeviceSize                     imageMipTailOffset;
2229     VkDeviceSize                     imageMipTailStride;
2230 } VkSparseImageMemoryRequirements;
2231
2232 typedef struct VkSparseMemoryBind {
2233     VkDeviceSize               resourceOffset;
2234     VkDeviceSize               size;
2235     VkDeviceMemory             memory;
2236     VkDeviceSize               memoryOffset;
2237     VkSparseMemoryBindFlags    flags;
2238 } VkSparseMemoryBind;
2239
2240 typedef struct VkSparseBufferMemoryBindInfo {
2241     VkBuffer                     buffer;
2242     uint32_t                     bindCount;
2243     const VkSparseMemoryBind*    pBinds;
2244 } VkSparseBufferMemoryBindInfo;
2245
2246 typedef struct VkSparseImageOpaqueMemoryBindInfo {
2247     VkImage                      image;
2248     uint32_t                     bindCount;
2249     const VkSparseMemoryBind*    pBinds;
2250 } VkSparseImageOpaqueMemoryBindInfo;
2251
2252 typedef struct VkImageSubresource {
2253     VkImageAspectFlags    aspectMask;
2254     uint32_t              mipLevel;
2255     uint32_t              arrayLayer;
2256 } VkImageSubresource;
2257
2258 typedef struct VkOffset3D {
2259     int32_t    x;
2260     int32_t    y;
2261     int32_t    z;
2262 } VkOffset3D;
2263
2264 typedef struct VkSparseImageMemoryBind {
2265     VkImageSubresource         subresource;
2266     VkOffset3D                 offset;
2267     VkExtent3D                 extent;
2268     VkDeviceMemory             memory;
2269     VkDeviceSize               memoryOffset;
2270     VkSparseMemoryBindFlags    flags;
2271 } VkSparseImageMemoryBind;
2272
2273 typedef struct VkSparseImageMemoryBindInfo {
2274     VkImage                           image;
2275     uint32_t                          bindCount;
2276     const VkSparseImageMemoryBind*    pBinds;
2277 } VkSparseImageMemoryBindInfo;
2278
2279 typedef struct VkBindSparseInfo {
2280     VkStructureType                             sType;
2281     const void*                                 pNext;
2282     uint32_t                                    waitSemaphoreCount;
2283     const VkSemaphore*                          pWaitSemaphores;
2284     uint32_t                                    bufferBindCount;
2285     const VkSparseBufferMemoryBindInfo*         pBufferBinds;
2286     uint32_t                                    imageOpaqueBindCount;
2287     const VkSparseImageOpaqueMemoryBindInfo*    pImageOpaqueBinds;
2288     uint32_t                                    imageBindCount;
2289     const VkSparseImageMemoryBindInfo*          pImageBinds;
2290     uint32_t                                    signalSemaphoreCount;
2291     const VkSemaphore*                          pSignalSemaphores;
2292 } VkBindSparseInfo;
2293
2294 typedef struct VkFenceCreateInfo {
2295     VkStructureType       sType;
2296     const void*           pNext;
2297     VkFenceCreateFlags    flags;
2298 } VkFenceCreateInfo;
2299
2300 typedef struct VkSemaphoreCreateInfo {
2301     VkStructureType           sType;
2302     const void*               pNext;
2303     VkSemaphoreCreateFlags    flags;
2304 } VkSemaphoreCreateInfo;
2305
2306 typedef struct VkEventCreateInfo {
2307     VkStructureType       sType;
2308     const void*           pNext;
2309     VkEventCreateFlags    flags;
2310 } VkEventCreateInfo;
2311
2312 typedef struct VkQueryPoolCreateInfo {
2313     VkStructureType                  sType;
2314     const void*                      pNext;
2315     VkQueryPoolCreateFlags           flags;
2316     VkQueryType                      queryType;
2317     uint32_t                         queryCount;
2318     VkQueryPipelineStatisticFlags    pipelineStatistics;
2319 } VkQueryPoolCreateInfo;
2320
2321 typedef struct VkBufferCreateInfo {
2322     VkStructureType        sType;
2323     const void*            pNext;
2324     VkBufferCreateFlags    flags;
2325     VkDeviceSize           size;
2326     VkBufferUsageFlags     usage;
2327     VkSharingMode          sharingMode;
2328     uint32_t               queueFamilyIndexCount;
2329     const uint32_t*        pQueueFamilyIndices;
2330 } VkBufferCreateInfo;
2331
2332 typedef struct VkBufferViewCreateInfo {
2333     VkStructureType            sType;
2334     const void*                pNext;
2335     VkBufferViewCreateFlags    flags;
2336     VkBuffer                   buffer;
2337     VkFormat                   format;
2338     VkDeviceSize               offset;
2339     VkDeviceSize               range;
2340 } VkBufferViewCreateInfo;
2341
2342 typedef struct VkImageCreateInfo {
2343     VkStructureType          sType;
2344     const void*              pNext;
2345     VkImageCreateFlags       flags;
2346     VkImageType              imageType;
2347     VkFormat                 format;
2348     VkExtent3D               extent;
2349     uint32_t                 mipLevels;
2350     uint32_t                 arrayLayers;
2351     VkSampleCountFlagBits    samples;
2352     VkImageTiling            tiling;
2353     VkImageUsageFlags        usage;
2354     VkSharingMode            sharingMode;
2355     uint32_t                 queueFamilyIndexCount;
2356     const uint32_t*          pQueueFamilyIndices;
2357     VkImageLayout            initialLayout;
2358 } VkImageCreateInfo;
2359
2360 typedef struct VkSubresourceLayout {
2361     VkDeviceSize    offset;
2362     VkDeviceSize    size;
2363     VkDeviceSize    rowPitch;
2364     VkDeviceSize    arrayPitch;
2365     VkDeviceSize    depthPitch;
2366 } VkSubresourceLayout;
2367
2368 typedef struct VkComponentMapping {
2369     VkComponentSwizzle    r;
2370     VkComponentSwizzle    g;
2371     VkComponentSwizzle    b;
2372     VkComponentSwizzle    a;
2373 } VkComponentMapping;
2374
2375 typedef struct VkImageSubresourceRange {
2376     VkImageAspectFlags    aspectMask;
2377     uint32_t              baseMipLevel;
2378     uint32_t              levelCount;
2379     uint32_t              baseArrayLayer;
2380     uint32_t              layerCount;
2381 } VkImageSubresourceRange;
2382
2383 typedef struct VkImageViewCreateInfo {
2384     VkStructureType            sType;
2385     const void*                pNext;
2386     VkImageViewCreateFlags     flags;
2387     VkImage                    image;
2388     VkImageViewType            viewType;
2389     VkFormat                   format;
2390     VkComponentMapping         components;
2391     VkImageSubresourceRange    subresourceRange;
2392 } VkImageViewCreateInfo;
2393
2394 typedef struct VkShaderModuleCreateInfo {
2395     VkStructureType              sType;
2396     const void*                  pNext;
2397     VkShaderModuleCreateFlags    flags;
2398     size_t                       codeSize;
2399     const uint32_t*              pCode;
2400 } VkShaderModuleCreateInfo;
2401
2402 typedef struct VkPipelineCacheCreateInfo {
2403     VkStructureType               sType;
2404     const void*                   pNext;
2405     VkPipelineCacheCreateFlags    flags;
2406     size_t                        initialDataSize;
2407     const void*                   pInitialData;
2408 } VkPipelineCacheCreateInfo;
2409
2410 typedef struct VkSpecializationMapEntry {
2411     uint32_t    constantID;
2412     uint32_t    offset;
2413     size_t      size;
2414 } VkSpecializationMapEntry;
2415
2416 typedef struct VkSpecializationInfo {
2417     uint32_t                           mapEntryCount;
2418     const VkSpecializationMapEntry*    pMapEntries;
2419     size_t                             dataSize;
2420     const void*                        pData;
2421 } VkSpecializationInfo;
2422
2423 typedef struct VkPipelineShaderStageCreateInfo {
2424     VkStructureType                     sType;
2425     const void*                         pNext;
2426     VkPipelineShaderStageCreateFlags    flags;
2427     VkShaderStageFlagBits               stage;
2428     VkShaderModule                      module;
2429     const char*                         pName;
2430     const VkSpecializationInfo*         pSpecializationInfo;
2431 } VkPipelineShaderStageCreateInfo;
2432
2433 typedef struct VkVertexInputBindingDescription {
2434     uint32_t             binding;
2435     uint32_t             stride;
2436     VkVertexInputRate    inputRate;
2437 } VkVertexInputBindingDescription;
2438
2439 typedef struct VkVertexInputAttributeDescription {
2440     uint32_t    location;
2441     uint32_t    binding;
2442     VkFormat    format;
2443     uint32_t    offset;
2444 } VkVertexInputAttributeDescription;
2445
2446 typedef struct VkPipelineVertexInputStateCreateInfo {
2447     VkStructureType                             sType;
2448     const void*                                 pNext;
2449     VkPipelineVertexInputStateCreateFlags       flags;
2450     uint32_t                                    vertexBindingDescriptionCount;
2451     const VkVertexInputBindingDescription*      pVertexBindingDescriptions;
2452     uint32_t                                    vertexAttributeDescriptionCount;
2453     const VkVertexInputAttributeDescription*    pVertexAttributeDescriptions;
2454 } VkPipelineVertexInputStateCreateInfo;
2455
2456 typedef struct VkPipelineInputAssemblyStateCreateInfo {
2457     VkStructureType                            sType;
2458     const void*                                pNext;
2459     VkPipelineInputAssemblyStateCreateFlags    flags;
2460     VkPrimitiveTopology                        topology;
2461     VkBool32                                   primitiveRestartEnable;
2462 } VkPipelineInputAssemblyStateCreateInfo;
2463
2464 typedef struct VkPipelineTessellationStateCreateInfo {
2465     VkStructureType                           sType;
2466     const void*                               pNext;
2467     VkPipelineTessellationStateCreateFlags    flags;
2468     uint32_t                                  patchControlPoints;
2469 } VkPipelineTessellationStateCreateInfo;
2470
2471 typedef struct VkViewport {
2472     float    x;
2473     float    y;
2474     float    width;
2475     float    height;
2476     float    minDepth;
2477     float    maxDepth;
2478 } VkViewport;
2479
2480 typedef struct VkOffset2D {
2481     int32_t    x;
2482     int32_t    y;
2483 } VkOffset2D;
2484
2485 typedef struct VkExtent2D {
2486     uint32_t    width;
2487     uint32_t    height;
2488 } VkExtent2D;
2489
2490 typedef struct VkRect2D {
2491     VkOffset2D    offset;
2492     VkExtent2D    extent;
2493 } VkRect2D;
2494
2495 typedef struct VkPipelineViewportStateCreateInfo {
2496     VkStructureType                       sType;
2497     const void*                           pNext;
2498     VkPipelineViewportStateCreateFlags    flags;
2499     uint32_t                              viewportCount;
2500     const VkViewport*                     pViewports;
2501     uint32_t                              scissorCount;
2502     const VkRect2D*                       pScissors;
2503 } VkPipelineViewportStateCreateInfo;
2504
2505 typedef struct VkPipelineRasterizationStateCreateInfo {
2506     VkStructureType                            sType;
2507     const void*                                pNext;
2508     VkPipelineRasterizationStateCreateFlags    flags;
2509     VkBool32                                   depthClampEnable;
2510     VkBool32                                   rasterizerDiscardEnable;
2511     VkPolygonMode                              polygonMode;
2512     VkCullModeFlags                            cullMode;
2513     VkFrontFace                                frontFace;
2514     VkBool32                                   depthBiasEnable;
2515     float                                      depthBiasConstantFactor;
2516     float                                      depthBiasClamp;
2517     float                                      depthBiasSlopeFactor;
2518     float                                      lineWidth;
2519 } VkPipelineRasterizationStateCreateInfo;
2520
2521 typedef struct VkPipelineMultisampleStateCreateInfo {
2522     VkStructureType                          sType;
2523     const void*                              pNext;
2524     VkPipelineMultisampleStateCreateFlags    flags;
2525     VkSampleCountFlagBits                    rasterizationSamples;
2526     VkBool32                                 sampleShadingEnable;
2527     float                                    minSampleShading;
2528     const VkSampleMask*                      pSampleMask;
2529     VkBool32                                 alphaToCoverageEnable;
2530     VkBool32                                 alphaToOneEnable;
2531 } VkPipelineMultisampleStateCreateInfo;
2532
2533 typedef struct VkStencilOpState {
2534     VkStencilOp    failOp;
2535     VkStencilOp    passOp;
2536     VkStencilOp    depthFailOp;
2537     VkCompareOp    compareOp;
2538     uint32_t       compareMask;
2539     uint32_t       writeMask;
2540     uint32_t       reference;
2541 } VkStencilOpState;
2542
2543 typedef struct VkPipelineDepthStencilStateCreateInfo {
2544     VkStructureType                           sType;
2545     const void*                               pNext;
2546     VkPipelineDepthStencilStateCreateFlags    flags;
2547     VkBool32                                  depthTestEnable;
2548     VkBool32                                  depthWriteEnable;
2549     VkCompareOp                               depthCompareOp;
2550     VkBool32                                  depthBoundsTestEnable;
2551     VkBool32                                  stencilTestEnable;
2552     VkStencilOpState                          front;
2553     VkStencilOpState                          back;
2554     float                                     minDepthBounds;
2555     float                                     maxDepthBounds;
2556 } VkPipelineDepthStencilStateCreateInfo;
2557
2558 typedef struct VkPipelineColorBlendAttachmentState {
2559     VkBool32                 blendEnable;
2560     VkBlendFactor            srcColorBlendFactor;
2561     VkBlendFactor            dstColorBlendFactor;
2562     VkBlendOp                colorBlendOp;
2563     VkBlendFactor            srcAlphaBlendFactor;
2564     VkBlendFactor            dstAlphaBlendFactor;
2565     VkBlendOp                alphaBlendOp;
2566     VkColorComponentFlags    colorWriteMask;
2567 } VkPipelineColorBlendAttachmentState;
2568
2569 typedef struct VkPipelineColorBlendStateCreateInfo {
2570     VkStructureType                               sType;
2571     const void*                                   pNext;
2572     VkPipelineColorBlendStateCreateFlags          flags;
2573     VkBool32                                      logicOpEnable;
2574     VkLogicOp                                     logicOp;
2575     uint32_t                                      attachmentCount;
2576     const VkPipelineColorBlendAttachmentState*    pAttachments;
2577     float                                         blendConstants[4];
2578 } VkPipelineColorBlendStateCreateInfo;
2579
2580 typedef struct VkPipelineDynamicStateCreateInfo {
2581     VkStructureType                      sType;
2582     const void*                          pNext;
2583     VkPipelineDynamicStateCreateFlags    flags;
2584     uint32_t                             dynamicStateCount;
2585     const VkDynamicState*                pDynamicStates;
2586 } VkPipelineDynamicStateCreateInfo;
2587
2588 typedef struct VkGraphicsPipelineCreateInfo {
2589     VkStructureType                                  sType;
2590     const void*                                      pNext;
2591     VkPipelineCreateFlags                            flags;
2592     uint32_t                                         stageCount;
2593     const VkPipelineShaderStageCreateInfo*           pStages;
2594     const VkPipelineVertexInputStateCreateInfo*      pVertexInputState;
2595     const VkPipelineInputAssemblyStateCreateInfo*    pInputAssemblyState;
2596     const VkPipelineTessellationStateCreateInfo*     pTessellationState;
2597     const VkPipelineViewportStateCreateInfo*         pViewportState;
2598     const VkPipelineRasterizationStateCreateInfo*    pRasterizationState;
2599     const VkPipelineMultisampleStateCreateInfo*      pMultisampleState;
2600     const VkPipelineDepthStencilStateCreateInfo*     pDepthStencilState;
2601     const VkPipelineColorBlendStateCreateInfo*       pColorBlendState;
2602     const VkPipelineDynamicStateCreateInfo*          pDynamicState;
2603     VkPipelineLayout                                 layout;
2604     VkRenderPass                                     renderPass;
2605     uint32_t                                         subpass;
2606     VkPipeline                                       basePipelineHandle;
2607     int32_t                                          basePipelineIndex;
2608 } VkGraphicsPipelineCreateInfo;
2609
2610 typedef struct VkComputePipelineCreateInfo {
2611     VkStructureType                    sType;
2612     const void*                        pNext;
2613     VkPipelineCreateFlags              flags;
2614     VkPipelineShaderStageCreateInfo    stage;
2615     VkPipelineLayout                   layout;
2616     VkPipeline                         basePipelineHandle;
2617     int32_t                            basePipelineIndex;
2618 } VkComputePipelineCreateInfo;
2619
2620 typedef struct VkPushConstantRange {
2621     VkShaderStageFlags    stageFlags;
2622     uint32_t              offset;
2623     uint32_t              size;
2624 } VkPushConstantRange;
2625
2626 typedef struct VkPipelineLayoutCreateInfo {
2627     VkStructureType                 sType;
2628     const void*                     pNext;
2629     VkPipelineLayoutCreateFlags     flags;
2630     uint32_t                        setLayoutCount;
2631     const VkDescriptorSetLayout*    pSetLayouts;
2632     uint32_t                        pushConstantRangeCount;
2633     const VkPushConstantRange*      pPushConstantRanges;
2634 } VkPipelineLayoutCreateInfo;
2635
2636 typedef struct VkSamplerCreateInfo {
2637     VkStructureType         sType;
2638     const void*             pNext;
2639     VkSamplerCreateFlags    flags;
2640     VkFilter                magFilter;
2641     VkFilter                minFilter;
2642     VkSamplerMipmapMode     mipmapMode;
2643     VkSamplerAddressMode    addressModeU;
2644     VkSamplerAddressMode    addressModeV;
2645     VkSamplerAddressMode    addressModeW;
2646     float                   mipLodBias;
2647     VkBool32                anisotropyEnable;
2648     float                   maxAnisotropy;
2649     VkBool32                compareEnable;
2650     VkCompareOp             compareOp;
2651     float                   minLod;
2652     float                   maxLod;
2653     VkBorderColor           borderColor;
2654     VkBool32                unnormalizedCoordinates;
2655 } VkSamplerCreateInfo;
2656
2657 typedef struct VkDescriptorSetLayoutBinding {
2658     uint32_t              binding;
2659     VkDescriptorType      descriptorType;
2660     uint32_t              descriptorCount;
2661     VkShaderStageFlags    stageFlags;
2662     const VkSampler*      pImmutableSamplers;
2663 } VkDescriptorSetLayoutBinding;
2664
2665 typedef struct VkDescriptorSetLayoutCreateInfo {
2666     VkStructureType                        sType;
2667     const void*                            pNext;
2668     VkDescriptorSetLayoutCreateFlags       flags;
2669     uint32_t                               bindingCount;
2670     const VkDescriptorSetLayoutBinding*    pBindings;
2671 } VkDescriptorSetLayoutCreateInfo;
2672
2673 typedef struct VkDescriptorPoolSize {
2674     VkDescriptorType    type;
2675     uint32_t            descriptorCount;
2676 } VkDescriptorPoolSize;
2677
2678 typedef struct VkDescriptorPoolCreateInfo {
2679     VkStructureType                sType;
2680     const void*                    pNext;
2681     VkDescriptorPoolCreateFlags    flags;
2682     uint32_t                       maxSets;
2683     uint32_t                       poolSizeCount;
2684     const VkDescriptorPoolSize*    pPoolSizes;
2685 } VkDescriptorPoolCreateInfo;
2686
2687 typedef struct VkDescriptorSetAllocateInfo {
2688     VkStructureType                 sType;
2689     const void*                     pNext;
2690     VkDescriptorPool                descriptorPool;
2691     uint32_t                        descriptorSetCount;
2692     const VkDescriptorSetLayout*    pSetLayouts;
2693 } VkDescriptorSetAllocateInfo;
2694
2695 typedef struct VkDescriptorImageInfo {
2696     VkSampler        sampler;
2697     VkImageView      imageView;
2698     VkImageLayout    imageLayout;
2699 } VkDescriptorImageInfo;
2700
2701 typedef struct VkDescriptorBufferInfo {
2702     VkBuffer        buffer;
2703     VkDeviceSize    offset;
2704     VkDeviceSize    range;
2705 } VkDescriptorBufferInfo;
2706
2707 typedef struct VkWriteDescriptorSet {
2708     VkStructureType                  sType;
2709     const void*                      pNext;
2710     VkDescriptorSet                  dstSet;
2711     uint32_t                         dstBinding;
2712     uint32_t                         dstArrayElement;
2713     uint32_t                         descriptorCount;
2714     VkDescriptorType                 descriptorType;
2715     const VkDescriptorImageInfo*     pImageInfo;
2716     const VkDescriptorBufferInfo*    pBufferInfo;
2717     const VkBufferView*              pTexelBufferView;
2718 } VkWriteDescriptorSet;
2719
2720 typedef struct VkCopyDescriptorSet {
2721     VkStructureType    sType;
2722     const void*        pNext;
2723     VkDescriptorSet    srcSet;
2724     uint32_t           srcBinding;
2725     uint32_t           srcArrayElement;
2726     VkDescriptorSet    dstSet;
2727     uint32_t           dstBinding;
2728     uint32_t           dstArrayElement;
2729     uint32_t           descriptorCount;
2730 } VkCopyDescriptorSet;
2731
2732 typedef struct VkFramebufferCreateInfo {
2733     VkStructureType             sType;
2734     const void*                 pNext;
2735     VkFramebufferCreateFlags    flags;
2736     VkRenderPass                renderPass;
2737     uint32_t                    attachmentCount;
2738     const VkImageView*          pAttachments;
2739     uint32_t                    width;
2740     uint32_t                    height;
2741     uint32_t                    layers;
2742 } VkFramebufferCreateInfo;
2743
2744 typedef struct VkAttachmentDescription {
2745     VkAttachmentDescriptionFlags    flags;
2746     VkFormat                        format;
2747     VkSampleCountFlagBits           samples;
2748     VkAttachmentLoadOp              loadOp;
2749     VkAttachmentStoreOp             storeOp;
2750     VkAttachmentLoadOp              stencilLoadOp;
2751     VkAttachmentStoreOp             stencilStoreOp;
2752     VkImageLayout                   initialLayout;
2753     VkImageLayout                   finalLayout;
2754 } VkAttachmentDescription;
2755
2756 typedef struct VkAttachmentReference {
2757     uint32_t         attachment;
2758     VkImageLayout    layout;
2759 } VkAttachmentReference;
2760
2761 typedef struct VkSubpassDescription {
2762     VkSubpassDescriptionFlags       flags;
2763     VkPipelineBindPoint             pipelineBindPoint;
2764     uint32_t                        inputAttachmentCount;
2765     const VkAttachmentReference*    pInputAttachments;
2766     uint32_t                        colorAttachmentCount;
2767     const VkAttachmentReference*    pColorAttachments;
2768     const VkAttachmentReference*    pResolveAttachments;
2769     const VkAttachmentReference*    pDepthStencilAttachment;
2770     uint32_t                        preserveAttachmentCount;
2771     const uint32_t*                 pPreserveAttachments;
2772 } VkSubpassDescription;
2773
2774 typedef struct VkSubpassDependency {
2775     uint32_t                srcSubpass;
2776     uint32_t                dstSubpass;
2777     VkPipelineStageFlags    srcStageMask;
2778     VkPipelineStageFlags    dstStageMask;
2779     VkAccessFlags           srcAccessMask;
2780     VkAccessFlags           dstAccessMask;
2781     VkDependencyFlags       dependencyFlags;
2782 } VkSubpassDependency;
2783
2784 typedef struct VkRenderPassCreateInfo {
2785     VkStructureType                   sType;
2786     const void*                       pNext;
2787     VkRenderPassCreateFlags           flags;
2788     uint32_t                          attachmentCount;
2789     const VkAttachmentDescription*    pAttachments;
2790     uint32_t                          subpassCount;
2791     const VkSubpassDescription*       pSubpasses;
2792     uint32_t                          dependencyCount;
2793     const VkSubpassDependency*        pDependencies;
2794 } VkRenderPassCreateInfo;
2795
2796 typedef struct VkCommandPoolCreateInfo {
2797     VkStructureType             sType;
2798     const void*                 pNext;
2799     VkCommandPoolCreateFlags    flags;
2800     uint32_t                    queueFamilyIndex;
2801 } VkCommandPoolCreateInfo;
2802
2803 typedef struct VkCommandBufferAllocateInfo {
2804     VkStructureType         sType;
2805     const void*             pNext;
2806     VkCommandPool           commandPool;
2807     VkCommandBufferLevel    level;
2808     uint32_t                commandBufferCount;
2809 } VkCommandBufferAllocateInfo;
2810
2811 typedef struct VkCommandBufferInheritanceInfo {
2812     VkStructureType                  sType;
2813     const void*                      pNext;
2814     VkRenderPass                     renderPass;
2815     uint32_t                         subpass;
2816     VkFramebuffer                    framebuffer;
2817     VkBool32                         occlusionQueryEnable;
2818     VkQueryControlFlags              queryFlags;
2819     VkQueryPipelineStatisticFlags    pipelineStatistics;
2820 } VkCommandBufferInheritanceInfo;
2821
2822 typedef struct VkCommandBufferBeginInfo {
2823     VkStructureType                          sType;
2824     const void*                              pNext;
2825     VkCommandBufferUsageFlags                flags;
2826     const VkCommandBufferInheritanceInfo*    pInheritanceInfo;
2827 } VkCommandBufferBeginInfo;
2828
2829 typedef struct VkBufferCopy {
2830     VkDeviceSize    srcOffset;
2831     VkDeviceSize    dstOffset;
2832     VkDeviceSize    size;
2833 } VkBufferCopy;
2834
2835 typedef struct VkImageSubresourceLayers {
2836     VkImageAspectFlags    aspectMask;
2837     uint32_t              mipLevel;
2838     uint32_t              baseArrayLayer;
2839     uint32_t              layerCount;
2840 } VkImageSubresourceLayers;
2841
2842 typedef struct VkImageCopy {
2843     VkImageSubresourceLayers    srcSubresource;
2844     VkOffset3D                  srcOffset;
2845     VkImageSubresourceLayers    dstSubresource;
2846     VkOffset3D                  dstOffset;
2847     VkExtent3D                  extent;
2848 } VkImageCopy;
2849
2850 typedef struct VkImageBlit {
2851     VkImageSubresourceLayers    srcSubresource;
2852     VkOffset3D                  srcOffsets[2];
2853     VkImageSubresourceLayers    dstSubresource;
2854     VkOffset3D                  dstOffsets[2];
2855 } VkImageBlit;
2856
2857 typedef struct VkBufferImageCopy {
2858     VkDeviceSize                bufferOffset;
2859     uint32_t                    bufferRowLength;
2860     uint32_t                    bufferImageHeight;
2861     VkImageSubresourceLayers    imageSubresource;
2862     VkOffset3D                  imageOffset;
2863     VkExtent3D                  imageExtent;
2864 } VkBufferImageCopy;
2865
2866 typedef union VkClearColorValue {
2867     float       float32[4];
2868     int32_t     int32[4];
2869     uint32_t    uint32[4];
2870 } VkClearColorValue;
2871
2872 typedef struct VkClearDepthStencilValue {
2873     float       depth;
2874     uint32_t    stencil;
2875 } VkClearDepthStencilValue;
2876
2877 typedef union VkClearValue {
2878     VkClearColorValue           color;
2879     VkClearDepthStencilValue    depthStencil;
2880 } VkClearValue;
2881
2882 typedef struct VkClearAttachment {
2883     VkImageAspectFlags    aspectMask;
2884     uint32_t              colorAttachment;
2885     VkClearValue          clearValue;
2886 } VkClearAttachment;
2887
2888 typedef struct VkClearRect {
2889     VkRect2D    rect;
2890     uint32_t    baseArrayLayer;
2891     uint32_t    layerCount;
2892 } VkClearRect;
2893
2894 typedef struct VkImageResolve {
2895     VkImageSubresourceLayers    srcSubresource;
2896     VkOffset3D                  srcOffset;
2897     VkImageSubresourceLayers    dstSubresource;
2898     VkOffset3D                  dstOffset;
2899     VkExtent3D                  extent;
2900 } VkImageResolve;
2901
2902 typedef struct VkMemoryBarrier {
2903     VkStructureType    sType;
2904     const void*        pNext;
2905     VkAccessFlags      srcAccessMask;
2906     VkAccessFlags      dstAccessMask;
2907 } VkMemoryBarrier;
2908
2909 typedef struct VkBufferMemoryBarrier {
2910     VkStructureType    sType;
2911     const void*        pNext;
2912     VkAccessFlags      srcAccessMask;
2913     VkAccessFlags      dstAccessMask;
2914     uint32_t           srcQueueFamilyIndex;
2915     uint32_t           dstQueueFamilyIndex;
2916     VkBuffer           buffer;
2917     VkDeviceSize       offset;
2918     VkDeviceSize       size;
2919 } VkBufferMemoryBarrier;
2920
2921 typedef struct VkImageMemoryBarrier {
2922     VkStructureType            sType;
2923     const void*                pNext;
2924     VkAccessFlags              srcAccessMask;
2925     VkAccessFlags              dstAccessMask;
2926     VkImageLayout              oldLayout;
2927     VkImageLayout              newLayout;
2928     uint32_t                   srcQueueFamilyIndex;
2929     uint32_t                   dstQueueFamilyIndex;
2930     VkImage                    image;
2931     VkImageSubresourceRange    subresourceRange;
2932 } VkImageMemoryBarrier;
2933
2934 typedef struct VkRenderPassBeginInfo {
2935     VkStructureType        sType;
2936     const void*            pNext;
2937     VkRenderPass           renderPass;
2938     VkFramebuffer          framebuffer;
2939     VkRect2D               renderArea;
2940     uint32_t               clearValueCount;
2941     const VkClearValue*    pClearValues;
2942 } VkRenderPassBeginInfo;
2943
2944 typedef struct VkDispatchIndirectCommand {
2945     uint32_t    x;
2946     uint32_t    y;
2947     uint32_t    z;
2948 } VkDispatchIndirectCommand;
2949
2950 typedef struct VkDrawIndexedIndirectCommand {
2951     uint32_t    indexCount;
2952     uint32_t    instanceCount;
2953     uint32_t    firstIndex;
2954     int32_t     vertexOffset;
2955     uint32_t    firstInstance;
2956 } VkDrawIndexedIndirectCommand;
2957
2958 typedef struct VkDrawIndirectCommand {
2959     uint32_t    vertexCount;
2960     uint32_t    instanceCount;
2961     uint32_t    firstVertex;
2962     uint32_t    firstInstance;
2963 } VkDrawIndirectCommand;
2964
2965 typedef struct VkBaseOutStructure {
2966     VkStructureType               sType;
2967     struct VkBaseOutStructure*    pNext;
2968 } VkBaseOutStructure;
2969
2970 typedef struct VkBaseInStructure {
2971     VkStructureType                    sType;
2972     const struct VkBaseInStructure*    pNext;
2973 } VkBaseInStructure;
2974
2975 typedef VkResult (VKAPI_PTR *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance);
2976 typedef void (VKAPI_PTR *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks* pAllocator);
2977 typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
2978 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
2979 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
2980 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
2981 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
2982 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties);
2983 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
2984 typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName);
2985 typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName);
2986 typedef VkResult (VKAPI_PTR *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice);
2987 typedef void (VKAPI_PTR *PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks* pAllocator);
2988 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
2989 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
2990 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties);
2991 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties);
2992 typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
2993 typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence);
2994 typedef VkResult (VKAPI_PTR *PFN_vkQueueWaitIdle)(VkQueue queue);
2995 typedef VkResult (VKAPI_PTR *PFN_vkDeviceWaitIdle)(VkDevice device);
2996 typedef VkResult (VKAPI_PTR *PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory);
2997 typedef void (VKAPI_PTR *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator);
2998 typedef VkResult (VKAPI_PTR *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);
2999 typedef void (VKAPI_PTR *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory);
3000 typedef VkResult (VKAPI_PTR *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
3001 typedef VkResult (VKAPI_PTR *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
3002 typedef void (VKAPI_PTR *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);
3003 typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset);
3004 typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset);
3005 typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
3006 typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
3007 typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
3008 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties);
3009 typedef VkResult (VKAPI_PTR *PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence);
3010 typedef VkResult (VKAPI_PTR *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
3011 typedef void (VKAPI_PTR *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator);
3012 typedef VkResult (VKAPI_PTR *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences);
3013 typedef VkResult (VKAPI_PTR *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence);
3014 typedef VkResult (VKAPI_PTR *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout);
3015 typedef VkResult (VKAPI_PTR *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore);
3016 typedef void (VKAPI_PTR *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator);
3017 typedef VkResult (VKAPI_PTR *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent);
3018 typedef void (VKAPI_PTR *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator);
3019 typedef VkResult (VKAPI_PTR *PFN_vkGetEventStatus)(VkDevice device, VkEvent event);
3020 typedef VkResult (VKAPI_PTR *PFN_vkSetEvent)(VkDevice device, VkEvent event);
3021 typedef VkResult (VKAPI_PTR *PFN_vkResetEvent)(VkDevice device, VkEvent event);
3022 typedef VkResult (VKAPI_PTR *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool);
3023 typedef void (VKAPI_PTR *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator);
3024 typedef VkResult (VKAPI_PTR *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags);
3025 typedef VkResult (VKAPI_PTR *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer);
3026 typedef void (VKAPI_PTR *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator);
3027 typedef VkResult (VKAPI_PTR *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView);
3028 typedef void (VKAPI_PTR *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator);
3029 typedef VkResult (VKAPI_PTR *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage);
3030 typedef void (VKAPI_PTR *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator);
3031 typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
3032 typedef VkResult (VKAPI_PTR *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView);
3033 typedef void (VKAPI_PTR *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator);
3034 typedef VkResult (VKAPI_PTR *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule);
3035 typedef void (VKAPI_PTR *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator);
3036 typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache);
3037 typedef void (VKAPI_PTR *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator);
3038 typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData);
3039 typedef VkResult (VKAPI_PTR *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
3040 typedef VkResult (VKAPI_PTR *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
3041 typedef VkResult (VKAPI_PTR *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
3042 typedef void (VKAPI_PTR *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator);
3043 typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout);
3044 typedef void (VKAPI_PTR *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator);
3045 typedef VkResult (VKAPI_PTR *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler);
3046 typedef void (VKAPI_PTR *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator);
3047 typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout);
3048 typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator);
3049 typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool);
3050 typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator);
3051 typedef VkResult (VKAPI_PTR *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);
3052 typedef VkResult (VKAPI_PTR *PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets);
3053 typedef VkResult (VKAPI_PTR *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets);
3054 typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies);
3055 typedef VkResult (VKAPI_PTR *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer);
3056 typedef void (VKAPI_PTR *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator);
3057 typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);
3058 typedef void (VKAPI_PTR *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator);
3059 typedef void (VKAPI_PTR *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
3060 typedef VkResult (VKAPI_PTR *PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool);
3061 typedef void (VKAPI_PTR *PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator);
3062 typedef VkResult (VKAPI_PTR *PFN_vkResetCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags);
3063 typedef VkResult (VKAPI_PTR *PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers);
3064 typedef void (VKAPI_PTR *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
3065 typedef VkResult (VKAPI_PTR *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo);
3066 typedef VkResult (VKAPI_PTR *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer);
3067 typedef VkResult (VKAPI_PTR *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags);
3068 typedef void (VKAPI_PTR *PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
3069 typedef void (VKAPI_PTR *PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports);
3070 typedef void (VKAPI_PTR *PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors);
3071 typedef void (VKAPI_PTR *PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth);
3072 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor);
3073 typedef void (VKAPI_PTR *PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4]);
3074 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds);
3075 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask);
3076 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask);
3077 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference);
3078 typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorSets)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets);
3079 typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
3080 typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
3081 typedef void (VKAPI_PTR *PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
3082 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
3083 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
3084 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
3085 typedef void (VKAPI_PTR *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);
3086 typedef void (VKAPI_PTR *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset);
3087 typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions);
3088 typedef void (VKAPI_PTR *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions);
3089 typedef void (VKAPI_PTR *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter);
3090 typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);
3091 typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);
3092 typedef void (VKAPI_PTR *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData);
3093 typedef void (VKAPI_PTR *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data);
3094 typedef void (VKAPI_PTR *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
3095 typedef void (VKAPI_PTR *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
3096 typedef void (VKAPI_PTR *PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects);
3097 typedef void (VKAPI_PTR *PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
3098 typedef void (VKAPI_PTR *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
3099 typedef void (VKAPI_PTR *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
3100 typedef void (VKAPI_PTR *PFN_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);
3101 typedef void (VKAPI_PTR *PFN_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);
3102 typedef void (VKAPI_PTR *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags);
3103 typedef void (VKAPI_PTR *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query);
3104 typedef void (VKAPI_PTR *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);
3105 typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query);
3106 typedef void (VKAPI_PTR *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags);
3107 typedef void (VKAPI_PTR *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues);
3108 typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents);
3109 typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkSubpassContents contents);
3110 typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer);
3111 typedef void (VKAPI_PTR *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
3112
3113 #ifndef VK_NO_PROTOTYPES
3114 VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(
3115     const VkInstanceCreateInfo*                 pCreateInfo,
3116     const VkAllocationCallbacks*                pAllocator,
3117     VkInstance*                                 pInstance);
3118
3119 VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(
3120     VkInstance                                  instance,
3121     const VkAllocationCallbacks*                pAllocator);
3122
3123 VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices(
3124     VkInstance                                  instance,
3125     uint32_t*                                   pPhysicalDeviceCount,
3126     VkPhysicalDevice*                           pPhysicalDevices);
3127
3128 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures(
3129     VkPhysicalDevice                            physicalDevice,
3130     VkPhysicalDeviceFeatures*                   pFeatures);
3131
3132 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties(
3133     VkPhysicalDevice                            physicalDevice,
3134     VkFormat                                    format,
3135     VkFormatProperties*                         pFormatProperties);
3136
3137 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties(
3138     VkPhysicalDevice                            physicalDevice,
3139     VkFormat                                    format,
3140     VkImageType                                 type,
3141     VkImageTiling                               tiling,
3142     VkImageUsageFlags                           usage,
3143     VkImageCreateFlags                          flags,
3144     VkImageFormatProperties*                    pImageFormatProperties);
3145
3146 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties(
3147     VkPhysicalDevice                            physicalDevice,
3148     VkPhysicalDeviceProperties*                 pProperties);
3149
3150 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties(
3151     VkPhysicalDevice                            physicalDevice,
3152     uint32_t*                                   pQueueFamilyPropertyCount,
3153     VkQueueFamilyProperties*                    pQueueFamilyProperties);
3154
3155 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties(
3156     VkPhysicalDevice                            physicalDevice,
3157     VkPhysicalDeviceMemoryProperties*           pMemoryProperties);
3158
3159 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(
3160     VkInstance                                  instance,
3161     const char*                                 pName);
3162
3163 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(
3164     VkDevice                                    device,
3165     const char*                                 pName);
3166
3167 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(
3168     VkPhysicalDevice                            physicalDevice,
3169     const VkDeviceCreateInfo*                   pCreateInfo,
3170     const VkAllocationCallbacks*                pAllocator,
3171     VkDevice*                                   pDevice);
3172
3173 VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(
3174     VkDevice                                    device,
3175     const VkAllocationCallbacks*                pAllocator);
3176
3177 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(
3178     const char*                                 pLayerName,
3179     uint32_t*                                   pPropertyCount,
3180     VkExtensionProperties*                      pProperties);
3181
3182 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(
3183     VkPhysicalDevice                            physicalDevice,
3184     const char*                                 pLayerName,
3185     uint32_t*                                   pPropertyCount,
3186     VkExtensionProperties*                      pProperties);
3187
3188 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(
3189     uint32_t*                                   pPropertyCount,
3190     VkLayerProperties*                          pProperties);
3191
3192 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(
3193     VkPhysicalDevice                            physicalDevice,
3194     uint32_t*                                   pPropertyCount,
3195     VkLayerProperties*                          pProperties);
3196
3197 VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue(
3198     VkDevice                                    device,
3199     uint32_t                                    queueFamilyIndex,
3200     uint32_t                                    queueIndex,
3201     VkQueue*                                    pQueue);
3202
3203 VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit(
3204     VkQueue                                     queue,
3205     uint32_t                                    submitCount,
3206     const VkSubmitInfo*                         pSubmits,
3207     VkFence                                     fence);
3208
3209 VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle(
3210     VkQueue                                     queue);
3211
3212 VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle(
3213     VkDevice                                    device);
3214
3215 VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory(
3216     VkDevice                                    device,
3217     const VkMemoryAllocateInfo*                 pAllocateInfo,
3218     const VkAllocationCallbacks*                pAllocator,
3219     VkDeviceMemory*                             pMemory);
3220
3221 VKAPI_ATTR void VKAPI_CALL vkFreeMemory(
3222     VkDevice                                    device,
3223     VkDeviceMemory                              memory,
3224     const VkAllocationCallbacks*                pAllocator);
3225
3226 VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory(
3227     VkDevice                                    device,
3228     VkDeviceMemory                              memory,
3229     VkDeviceSize                                offset,
3230     VkDeviceSize                                size,
3231     VkMemoryMapFlags                            flags,
3232     void**                                      ppData);
3233
3234 VKAPI_ATTR void VKAPI_CALL vkUnmapMemory(
3235     VkDevice                                    device,
3236     VkDeviceMemory                              memory);
3237
3238 VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges(
3239     VkDevice                                    device,
3240     uint32_t                                    memoryRangeCount,
3241     const VkMappedMemoryRange*                  pMemoryRanges);
3242
3243 VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges(
3244     VkDevice                                    device,
3245     uint32_t                                    memoryRangeCount,
3246     const VkMappedMemoryRange*                  pMemoryRanges);
3247
3248 VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment(
3249     VkDevice                                    device,
3250     VkDeviceMemory                              memory,
3251     VkDeviceSize*                               pCommittedMemoryInBytes);
3252
3253 VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory(
3254     VkDevice                                    device,
3255     VkBuffer                                    buffer,
3256     VkDeviceMemory                              memory,
3257     VkDeviceSize                                memoryOffset);
3258
3259 VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory(
3260     VkDevice                                    device,
3261     VkImage                                     image,
3262     VkDeviceMemory                              memory,
3263     VkDeviceSize                                memoryOffset);
3264
3265 VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements(
3266     VkDevice                                    device,
3267     VkBuffer                                    buffer,
3268     VkMemoryRequirements*                       pMemoryRequirements);
3269
3270 VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements(
3271     VkDevice                                    device,
3272     VkImage                                     image,
3273     VkMemoryRequirements*                       pMemoryRequirements);
3274
3275 VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements(
3276     VkDevice                                    device,
3277     VkImage                                     image,
3278     uint32_t*                                   pSparseMemoryRequirementCount,
3279     VkSparseImageMemoryRequirements*            pSparseMemoryRequirements);
3280
3281 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties(
3282     VkPhysicalDevice                            physicalDevice,
3283     VkFormat                                    format,
3284     VkImageType                                 type,
3285     VkSampleCountFlagBits                       samples,
3286     VkImageUsageFlags                           usage,
3287     VkImageTiling                               tiling,
3288     uint32_t*                                   pPropertyCount,
3289     VkSparseImageFormatProperties*              pProperties);
3290
3291 VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse(
3292     VkQueue                                     queue,
3293     uint32_t                                    bindInfoCount,
3294     const VkBindSparseInfo*                     pBindInfo,
3295     VkFence                                     fence);
3296
3297 VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence(
3298     VkDevice                                    device,
3299     const VkFenceCreateInfo*                    pCreateInfo,
3300     const VkAllocationCallbacks*                pAllocator,
3301     VkFence*                                    pFence);
3302
3303 VKAPI_ATTR void VKAPI_CALL vkDestroyFence(
3304     VkDevice                                    device,
3305     VkFence                                     fence,
3306     const VkAllocationCallbacks*                pAllocator);
3307
3308 VKAPI_ATTR VkResult VKAPI_CALL vkResetFences(
3309     VkDevice                                    device,
3310     uint32_t                                    fenceCount,
3311     const VkFence*                              pFences);
3312
3313 VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus(
3314     VkDevice                                    device,
3315     VkFence                                     fence);
3316
3317 VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences(
3318     VkDevice                                    device,
3319     uint32_t                                    fenceCount,
3320     const VkFence*                              pFences,
3321     VkBool32                                    waitAll,
3322     uint64_t                                    timeout);
3323
3324 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore(
3325     VkDevice                                    device,
3326     const VkSemaphoreCreateInfo*                pCreateInfo,
3327     const VkAllocationCallbacks*                pAllocator,
3328     VkSemaphore*                                pSemaphore);
3329
3330 VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore(
3331     VkDevice                                    device,
3332     VkSemaphore                                 semaphore,
3333     const VkAllocationCallbacks*                pAllocator);
3334
3335 VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent(
3336     VkDevice                                    device,
3337     const VkEventCreateInfo*                    pCreateInfo,
3338     const VkAllocationCallbacks*                pAllocator,
3339     VkEvent*                                    pEvent);
3340
3341 VKAPI_ATTR void VKAPI_CALL vkDestroyEvent(
3342     VkDevice                                    device,
3343     VkEvent                                     event,
3344     const VkAllocationCallbacks*                pAllocator);
3345
3346 VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus(
3347     VkDevice                                    device,
3348     VkEvent                                     event);
3349
3350 VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent(
3351     VkDevice                                    device,
3352     VkEvent                                     event);
3353
3354 VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent(
3355     VkDevice                                    device,
3356     VkEvent                                     event);
3357
3358 VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool(
3359     VkDevice                                    device,
3360     const VkQueryPoolCreateInfo*                pCreateInfo,
3361     const VkAllocationCallbacks*                pAllocator,
3362     VkQueryPool*                                pQueryPool);
3363
3364 VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool(
3365     VkDevice                                    device,
3366     VkQueryPool                                 queryPool,
3367     const VkAllocationCallbacks*                pAllocator);
3368
3369 VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults(
3370     VkDevice                                    device,
3371     VkQueryPool                                 queryPool,
3372     uint32_t                                    firstQuery,
3373     uint32_t                                    queryCount,
3374     size_t                                      dataSize,
3375     void*                                       pData,
3376     VkDeviceSize                                stride,
3377     VkQueryResultFlags                          flags);
3378
3379 VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer(
3380     VkDevice                                    device,
3381     const VkBufferCreateInfo*                   pCreateInfo,
3382     const VkAllocationCallbacks*                pAllocator,
3383     VkBuffer*                                   pBuffer);
3384
3385 VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer(
3386     VkDevice                                    device,
3387     VkBuffer                                    buffer,
3388     const VkAllocationCallbacks*                pAllocator);
3389
3390 VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView(
3391     VkDevice                                    device,
3392     const VkBufferViewCreateInfo*               pCreateInfo,
3393     const VkAllocationCallbacks*                pAllocator,
3394     VkBufferView*                               pView);
3395
3396 VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView(
3397     VkDevice                                    device,
3398     VkBufferView                                bufferView,
3399     const VkAllocationCallbacks*                pAllocator);
3400
3401 VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(
3402     VkDevice                                    device,
3403     const VkImageCreateInfo*                    pCreateInfo,
3404     const VkAllocationCallbacks*                pAllocator,
3405     VkImage*                                    pImage);
3406
3407 VKAPI_ATTR void VKAPI_CALL vkDestroyImage(
3408     VkDevice                                    device,
3409     VkImage                                     image,
3410     const VkAllocationCallbacks*                pAllocator);
3411
3412 VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout(
3413     VkDevice                                    device,
3414     VkImage                                     image,
3415     const VkImageSubresource*                   pSubresource,
3416     VkSubresourceLayout*                        pLayout);
3417
3418 VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView(
3419     VkDevice                                    device,
3420     const VkImageViewCreateInfo*                pCreateInfo,
3421     const VkAllocationCallbacks*                pAllocator,
3422     VkImageView*                                pView);
3423
3424 VKAPI_ATTR void VKAPI_CALL vkDestroyImageView(
3425     VkDevice                                    device,
3426     VkImageView                                 imageView,
3427     const VkAllocationCallbacks*                pAllocator);
3428
3429 VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule(
3430     VkDevice                                    device,
3431     const VkShaderModuleCreateInfo*             pCreateInfo,
3432     const VkAllocationCallbacks*                pAllocator,
3433     VkShaderModule*                             pShaderModule);
3434
3435 VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule(
3436     VkDevice                                    device,
3437     VkShaderModule                              shaderModule,
3438     const VkAllocationCallbacks*                pAllocator);
3439
3440 VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache(
3441     VkDevice                                    device,
3442     const VkPipelineCacheCreateInfo*            pCreateInfo,
3443     const VkAllocationCallbacks*                pAllocator,
3444     VkPipelineCache*                            pPipelineCache);
3445
3446 VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache(
3447     VkDevice                                    device,
3448     VkPipelineCache                             pipelineCache,
3449     const VkAllocationCallbacks*                pAllocator);
3450
3451 VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData(
3452     VkDevice                                    device,
3453     VkPipelineCache                             pipelineCache,
3454     size_t*                                     pDataSize,
3455     void*                                       pData);
3456
3457 VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches(
3458     VkDevice                                    device,
3459     VkPipelineCache                             dstCache,
3460     uint32_t                                    srcCacheCount,
3461     const VkPipelineCache*                      pSrcCaches);
3462
3463 VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines(
3464     VkDevice                                    device,
3465     VkPipelineCache                             pipelineCache,
3466     uint32_t                                    createInfoCount,
3467     const VkGraphicsPipelineCreateInfo*         pCreateInfos,
3468     const VkAllocationCallbacks*                pAllocator,
3469     VkPipeline*                                 pPipelines);
3470
3471 VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines(
3472     VkDevice                                    device,
3473     VkPipelineCache                             pipelineCache,
3474     uint32_t                                    createInfoCount,
3475     const VkComputePipelineCreateInfo*          pCreateInfos,
3476     const VkAllocationCallbacks*                pAllocator,
3477     VkPipeline*                                 pPipelines);
3478
3479 VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline(
3480     VkDevice                                    device,
3481     VkPipeline                                  pipeline,
3482     const VkAllocationCallbacks*                pAllocator);
3483
3484 VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout(
3485     VkDevice                                    device,
3486     const VkPipelineLayoutCreateInfo*           pCreateInfo,
3487     const VkAllocationCallbacks*                pAllocator,
3488     VkPipelineLayout*                           pPipelineLayout);
3489
3490 VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout(
3491     VkDevice                                    device,
3492     VkPipelineLayout                            pipelineLayout,
3493     const VkAllocationCallbacks*                pAllocator);
3494
3495 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler(
3496     VkDevice                                    device,
3497     const VkSamplerCreateInfo*                  pCreateInfo,
3498     const VkAllocationCallbacks*                pAllocator,
3499     VkSampler*                                  pSampler);
3500
3501 VKAPI_ATTR void VKAPI_CALL vkDestroySampler(
3502     VkDevice                                    device,
3503     VkSampler                                   sampler,
3504     const VkAllocationCallbacks*                pAllocator);
3505
3506 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout(
3507     VkDevice                                    device,
3508     const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
3509     const VkAllocationCallbacks*                pAllocator,
3510     VkDescriptorSetLayout*                      pSetLayout);
3511
3512 VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout(
3513     VkDevice                                    device,
3514     VkDescriptorSetLayout                       descriptorSetLayout,
3515     const VkAllocationCallbacks*                pAllocator);
3516
3517 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool(
3518     VkDevice                                    device,
3519     const VkDescriptorPoolCreateInfo*           pCreateInfo,
3520     const VkAllocationCallbacks*                pAllocator,
3521     VkDescriptorPool*                           pDescriptorPool);
3522
3523 VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool(
3524     VkDevice                                    device,
3525     VkDescriptorPool                            descriptorPool,
3526     const VkAllocationCallbacks*                pAllocator);
3527
3528 VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool(
3529     VkDevice                                    device,
3530     VkDescriptorPool                            descriptorPool,
3531     VkDescriptorPoolResetFlags                  flags);
3532
3533 VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets(
3534     VkDevice                                    device,
3535     const VkDescriptorSetAllocateInfo*          pAllocateInfo,
3536     VkDescriptorSet*                            pDescriptorSets);
3537
3538 VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets(
3539     VkDevice                                    device,
3540     VkDescriptorPool                            descriptorPool,
3541     uint32_t                                    descriptorSetCount,
3542     const VkDescriptorSet*                      pDescriptorSets);
3543
3544 VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets(
3545     VkDevice                                    device,
3546     uint32_t                                    descriptorWriteCount,
3547     const VkWriteDescriptorSet*                 pDescriptorWrites,
3548     uint32_t                                    descriptorCopyCount,
3549     const VkCopyDescriptorSet*                  pDescriptorCopies);
3550
3551 VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer(
3552     VkDevice                                    device,
3553     const VkFramebufferCreateInfo*              pCreateInfo,
3554     const VkAllocationCallbacks*                pAllocator,
3555     VkFramebuffer*                              pFramebuffer);
3556
3557 VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer(
3558     VkDevice                                    device,
3559     VkFramebuffer                               framebuffer,
3560     const VkAllocationCallbacks*                pAllocator);
3561
3562 VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass(
3563     VkDevice                                    device,
3564     const VkRenderPassCreateInfo*               pCreateInfo,
3565     const VkAllocationCallbacks*                pAllocator,
3566     VkRenderPass*                               pRenderPass);
3567
3568 VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass(
3569     VkDevice                                    device,
3570     VkRenderPass                                renderPass,
3571     const VkAllocationCallbacks*                pAllocator);
3572
3573 VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity(
3574     VkDevice                                    device,
3575     VkRenderPass                                renderPass,
3576     VkExtent2D*                                 pGranularity);
3577
3578 VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool(
3579     VkDevice                                    device,
3580     const VkCommandPoolCreateInfo*              pCreateInfo,
3581     const VkAllocationCallbacks*                pAllocator,
3582     VkCommandPool*                              pCommandPool);
3583
3584 VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool(
3585     VkDevice                                    device,
3586     VkCommandPool                               commandPool,
3587     const VkAllocationCallbacks*                pAllocator);
3588
3589 VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool(
3590     VkDevice                                    device,
3591     VkCommandPool                               commandPool,
3592     VkCommandPoolResetFlags                     flags);
3593
3594 VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers(
3595     VkDevice                                    device,
3596     const VkCommandBufferAllocateInfo*          pAllocateInfo,
3597     VkCommandBuffer*                            pCommandBuffers);
3598
3599 VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers(
3600     VkDevice                                    device,
3601     VkCommandPool                               commandPool,
3602     uint32_t                                    commandBufferCount,
3603     const VkCommandBuffer*                      pCommandBuffers);
3604
3605 VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer(
3606     VkCommandBuffer                             commandBuffer,
3607     const VkCommandBufferBeginInfo*             pBeginInfo);
3608
3609 VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer(
3610     VkCommandBuffer                             commandBuffer);
3611
3612 VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer(
3613     VkCommandBuffer                             commandBuffer,
3614     VkCommandBufferResetFlags                   flags);
3615
3616 VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline(
3617     VkCommandBuffer                             commandBuffer,
3618     VkPipelineBindPoint                         pipelineBindPoint,
3619     VkPipeline                                  pipeline);
3620
3621 VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport(
3622     VkCommandBuffer                             commandBuffer,
3623     uint32_t                                    firstViewport,
3624     uint32_t                                    viewportCount,
3625     const VkViewport*                           pViewports);
3626
3627 VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor(
3628     VkCommandBuffer                             commandBuffer,
3629     uint32_t                                    firstScissor,
3630     uint32_t                                    scissorCount,
3631     const VkRect2D*                             pScissors);
3632
3633 VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth(
3634     VkCommandBuffer                             commandBuffer,
3635     float                                       lineWidth);
3636
3637 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias(
3638     VkCommandBuffer                             commandBuffer,
3639     float                                       depthBiasConstantFactor,
3640     float                                       depthBiasClamp,
3641     float                                       depthBiasSlopeFactor);
3642
3643 VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants(
3644     VkCommandBuffer                             commandBuffer,
3645     const float                                 blendConstants[4]);
3646
3647 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds(
3648     VkCommandBuffer                             commandBuffer,
3649     float                                       minDepthBounds,
3650     float                                       maxDepthBounds);
3651
3652 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask(
3653     VkCommandBuffer                             commandBuffer,
3654     VkStencilFaceFlags                          faceMask,
3655     uint32_t                                    compareMask);
3656
3657 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask(
3658     VkCommandBuffer                             commandBuffer,
3659     VkStencilFaceFlags                          faceMask,
3660     uint32_t                                    writeMask);
3661
3662 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference(
3663     VkCommandBuffer                             commandBuffer,
3664     VkStencilFaceFlags                          faceMask,
3665     uint32_t                                    reference);
3666
3667 VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets(
3668     VkCommandBuffer                             commandBuffer,
3669     VkPipelineBindPoint                         pipelineBindPoint,
3670     VkPipelineLayout                            layout,
3671     uint32_t                                    firstSet,
3672     uint32_t                                    descriptorSetCount,
3673     const VkDescriptorSet*                      pDescriptorSets,
3674     uint32_t                                    dynamicOffsetCount,
3675     const uint32_t*                             pDynamicOffsets);
3676
3677 VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer(
3678     VkCommandBuffer                             commandBuffer,
3679     VkBuffer                                    buffer,
3680     VkDeviceSize                                offset,
3681     VkIndexType                                 indexType);
3682
3683 VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers(
3684     VkCommandBuffer                             commandBuffer,
3685     uint32_t                                    firstBinding,
3686     uint32_t                                    bindingCount,
3687     const VkBuffer*                             pBuffers,
3688     const VkDeviceSize*                         pOffsets);
3689
3690 VKAPI_ATTR void VKAPI_CALL vkCmdDraw(
3691     VkCommandBuffer                             commandBuffer,
3692     uint32_t                                    vertexCount,
3693     uint32_t                                    instanceCount,
3694     uint32_t                                    firstVertex,
3695     uint32_t                                    firstInstance);
3696
3697 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed(
3698     VkCommandBuffer                             commandBuffer,
3699     uint32_t                                    indexCount,
3700     uint32_t                                    instanceCount,
3701     uint32_t                                    firstIndex,
3702     int32_t                                     vertexOffset,
3703     uint32_t                                    firstInstance);
3704
3705 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect(
3706     VkCommandBuffer                             commandBuffer,
3707     VkBuffer                                    buffer,
3708     VkDeviceSize                                offset,
3709     uint32_t                                    drawCount,
3710     uint32_t                                    stride);
3711
3712 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect(
3713     VkCommandBuffer                             commandBuffer,
3714     VkBuffer                                    buffer,
3715     VkDeviceSize                                offset,
3716     uint32_t                                    drawCount,
3717     uint32_t                                    stride);
3718
3719 VKAPI_ATTR void VKAPI_CALL vkCmdDispatch(
3720     VkCommandBuffer                             commandBuffer,
3721     uint32_t                                    groupCountX,
3722     uint32_t                                    groupCountY,
3723     uint32_t                                    groupCountZ);
3724
3725 VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect(
3726     VkCommandBuffer                             commandBuffer,
3727     VkBuffer                                    buffer,
3728     VkDeviceSize                                offset);
3729
3730 VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer(
3731     VkCommandBuffer                             commandBuffer,
3732     VkBuffer                                    srcBuffer,
3733     VkBuffer                                    dstBuffer,
3734     uint32_t                                    regionCount,
3735     const VkBufferCopy*                         pRegions);
3736
3737 VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage(
3738     VkCommandBuffer                             commandBuffer,
3739     VkImage                                     srcImage,
3740     VkImageLayout                               srcImageLayout,
3741     VkImage                                     dstImage,
3742     VkImageLayout                               dstImageLayout,
3743     uint32_t                                    regionCount,
3744     const VkImageCopy*                          pRegions);
3745
3746 VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage(
3747     VkCommandBuffer                             commandBuffer,
3748     VkImage                                     srcImage,
3749     VkImageLayout                               srcImageLayout,
3750     VkImage                                     dstImage,
3751     VkImageLayout                               dstImageLayout,
3752     uint32_t                                    regionCount,
3753     const VkImageBlit*                          pRegions,
3754     VkFilter                                    filter);
3755
3756 VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage(
3757     VkCommandBuffer                             commandBuffer,
3758     VkBuffer                                    srcBuffer,
3759     VkImage                                     dstImage,
3760     VkImageLayout                               dstImageLayout,
3761     uint32_t                                    regionCount,
3762     const VkBufferImageCopy*                    pRegions);
3763
3764 VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer(
3765     VkCommandBuffer                             commandBuffer,
3766     VkImage                                     srcImage,
3767     VkImageLayout                               srcImageLayout,
3768     VkBuffer                                    dstBuffer,
3769     uint32_t                                    regionCount,
3770     const VkBufferImageCopy*                    pRegions);
3771
3772 VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer(
3773     VkCommandBuffer                             commandBuffer,
3774     VkBuffer                                    dstBuffer,
3775     VkDeviceSize                                dstOffset,
3776     VkDeviceSize                                dataSize,
3777     const void*                                 pData);
3778
3779 VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer(
3780     VkCommandBuffer                             commandBuffer,
3781     VkBuffer                                    dstBuffer,
3782     VkDeviceSize                                dstOffset,
3783     VkDeviceSize                                size,
3784     uint32_t                                    data);
3785
3786 VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage(
3787     VkCommandBuffer                             commandBuffer,
3788     VkImage                                     image,
3789     VkImageLayout                               imageLayout,
3790     const VkClearColorValue*                    pColor,
3791     uint32_t                                    rangeCount,
3792     const VkImageSubresourceRange*              pRanges);
3793
3794 VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage(
3795     VkCommandBuffer                             commandBuffer,
3796     VkImage                                     image,
3797     VkImageLayout                               imageLayout,
3798     const VkClearDepthStencilValue*             pDepthStencil,
3799     uint32_t                                    rangeCount,
3800     const VkImageSubresourceRange*              pRanges);
3801
3802 VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments(
3803     VkCommandBuffer                             commandBuffer,
3804     uint32_t                                    attachmentCount,
3805     const VkClearAttachment*                    pAttachments,
3806     uint32_t                                    rectCount,
3807     const VkClearRect*                          pRects);
3808
3809 VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage(
3810     VkCommandBuffer                             commandBuffer,
3811     VkImage                                     srcImage,
3812     VkImageLayout                               srcImageLayout,
3813     VkImage                                     dstImage,
3814     VkImageLayout                               dstImageLayout,
3815     uint32_t                                    regionCount,
3816     const VkImageResolve*                       pRegions);
3817
3818 VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent(
3819     VkCommandBuffer                             commandBuffer,
3820     VkEvent                                     event,
3821     VkPipelineStageFlags                        stageMask);
3822
3823 VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent(
3824     VkCommandBuffer                             commandBuffer,
3825     VkEvent                                     event,
3826     VkPipelineStageFlags                        stageMask);
3827
3828 VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents(
3829     VkCommandBuffer                             commandBuffer,
3830     uint32_t                                    eventCount,
3831     const VkEvent*                              pEvents,
3832     VkPipelineStageFlags                        srcStageMask,
3833     VkPipelineStageFlags                        dstStageMask,
3834     uint32_t                                    memoryBarrierCount,
3835     const VkMemoryBarrier*                      pMemoryBarriers,
3836     uint32_t                                    bufferMemoryBarrierCount,
3837     const VkBufferMemoryBarrier*                pBufferMemoryBarriers,
3838     uint32_t                                    imageMemoryBarrierCount,
3839     const VkImageMemoryBarrier*                 pImageMemoryBarriers);
3840
3841 VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier(
3842     VkCommandBuffer                             commandBuffer,
3843     VkPipelineStageFlags                        srcStageMask,
3844     VkPipelineStageFlags                        dstStageMask,
3845     VkDependencyFlags                           dependencyFlags,
3846     uint32_t                                    memoryBarrierCount,
3847     const VkMemoryBarrier*                      pMemoryBarriers,
3848     uint32_t                                    bufferMemoryBarrierCount,
3849     const VkBufferMemoryBarrier*                pBufferMemoryBarriers,
3850     uint32_t                                    imageMemoryBarrierCount,
3851     const VkImageMemoryBarrier*                 pImageMemoryBarriers);
3852
3853 VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery(
3854     VkCommandBuffer                             commandBuffer,
3855     VkQueryPool                                 queryPool,
3856     uint32_t                                    query,
3857     VkQueryControlFlags                         flags);
3858
3859 VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery(
3860     VkCommandBuffer                             commandBuffer,
3861     VkQueryPool                                 queryPool,
3862     uint32_t                                    query);
3863
3864 VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool(
3865     VkCommandBuffer                             commandBuffer,
3866     VkQueryPool                                 queryPool,
3867     uint32_t                                    firstQuery,
3868     uint32_t                                    queryCount);
3869
3870 VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp(
3871     VkCommandBuffer                             commandBuffer,
3872     VkPipelineStageFlagBits                     pipelineStage,
3873     VkQueryPool                                 queryPool,
3874     uint32_t                                    query);
3875
3876 VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults(
3877     VkCommandBuffer                             commandBuffer,
3878     VkQueryPool                                 queryPool,
3879     uint32_t                                    firstQuery,
3880     uint32_t                                    queryCount,
3881     VkBuffer                                    dstBuffer,
3882     VkDeviceSize                                dstOffset,
3883     VkDeviceSize                                stride,
3884     VkQueryResultFlags                          flags);
3885
3886 VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants(
3887     VkCommandBuffer                             commandBuffer,
3888     VkPipelineLayout                            layout,
3889     VkShaderStageFlags                          stageFlags,
3890     uint32_t                                    offset,
3891     uint32_t                                    size,
3892     const void*                                 pValues);
3893
3894 VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass(
3895     VkCommandBuffer                             commandBuffer,
3896     const VkRenderPassBeginInfo*                pRenderPassBegin,
3897     VkSubpassContents                           contents);
3898
3899 VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass(
3900     VkCommandBuffer                             commandBuffer,
3901     VkSubpassContents                           contents);
3902
3903 VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass(
3904     VkCommandBuffer                             commandBuffer);
3905
3906 VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands(
3907     VkCommandBuffer                             commandBuffer,
3908     uint32_t                                    commandBufferCount,
3909     const VkCommandBuffer*                      pCommandBuffers);
3910 #endif
3911
3912
3913 #define VK_VERSION_1_1 1
3914 // Vulkan 1.1 version number
3915 #define VK_API_VERSION_1_1 VK_MAKE_VERSION(1, 1, 0)// Patch version should always be set to 0
3916
3917 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSamplerYcbcrConversion)
3918 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorUpdateTemplate)
3919 #define VK_MAX_DEVICE_GROUP_SIZE          32
3920 #define VK_LUID_SIZE                      8
3921 #define VK_QUEUE_FAMILY_EXTERNAL          (~0U-1)
3922
3923 typedef enum VkPointClippingBehavior {
3924     VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES = 0,
3925     VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY = 1,
3926     VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES,
3927     VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY,
3928     VK_POINT_CLIPPING_BEHAVIOR_BEGIN_RANGE = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES,
3929     VK_POINT_CLIPPING_BEHAVIOR_END_RANGE = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY,
3930     VK_POINT_CLIPPING_BEHAVIOR_RANGE_SIZE = (VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY - VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES + 1),
3931     VK_POINT_CLIPPING_BEHAVIOR_MAX_ENUM = 0x7FFFFFFF
3932 } VkPointClippingBehavior;
3933
3934 typedef enum VkTessellationDomainOrigin {
3935     VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT = 0,
3936     VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT = 1,
3937     VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT,
3938     VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT,
3939     VK_TESSELLATION_DOMAIN_ORIGIN_BEGIN_RANGE = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT,
3940     VK_TESSELLATION_DOMAIN_ORIGIN_END_RANGE = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT,
3941     VK_TESSELLATION_DOMAIN_ORIGIN_RANGE_SIZE = (VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT - VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT + 1),
3942     VK_TESSELLATION_DOMAIN_ORIGIN_MAX_ENUM = 0x7FFFFFFF
3943 } VkTessellationDomainOrigin;
3944
3945 typedef enum VkSamplerYcbcrModelConversion {
3946     VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY = 0,
3947     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY = 1,
3948     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709 = 2,
3949     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601 = 3,
3950     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 = 4,
3951     VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY,
3952     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY,
3953     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709,
3954     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601,
3955     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020,
3956     VK_SAMPLER_YCBCR_MODEL_CONVERSION_BEGIN_RANGE = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY,
3957     VK_SAMPLER_YCBCR_MODEL_CONVERSION_END_RANGE = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020,
3958     VK_SAMPLER_YCBCR_MODEL_CONVERSION_RANGE_SIZE = (VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 - VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY + 1),
3959     VK_SAMPLER_YCBCR_MODEL_CONVERSION_MAX_ENUM = 0x7FFFFFFF
3960 } VkSamplerYcbcrModelConversion;
3961
3962 typedef enum VkSamplerYcbcrRange {
3963     VK_SAMPLER_YCBCR_RANGE_ITU_FULL = 0,
3964     VK_SAMPLER_YCBCR_RANGE_ITU_NARROW = 1,
3965     VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_FULL,
3966     VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW,
3967     VK_SAMPLER_YCBCR_RANGE_BEGIN_RANGE = VK_SAMPLER_YCBCR_RANGE_ITU_FULL,
3968     VK_SAMPLER_YCBCR_RANGE_END_RANGE = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW,
3969     VK_SAMPLER_YCBCR_RANGE_RANGE_SIZE = (VK_SAMPLER_YCBCR_RANGE_ITU_NARROW - VK_SAMPLER_YCBCR_RANGE_ITU_FULL + 1),
3970     VK_SAMPLER_YCBCR_RANGE_MAX_ENUM = 0x7FFFFFFF
3971 } VkSamplerYcbcrRange;
3972
3973 typedef enum VkChromaLocation {
3974     VK_CHROMA_LOCATION_COSITED_EVEN = 0,
3975     VK_CHROMA_LOCATION_MIDPOINT = 1,
3976     VK_CHROMA_LOCATION_COSITED_EVEN_KHR = VK_CHROMA_LOCATION_COSITED_EVEN,
3977     VK_CHROMA_LOCATION_MIDPOINT_KHR = VK_CHROMA_LOCATION_MIDPOINT,
3978     VK_CHROMA_LOCATION_BEGIN_RANGE = VK_CHROMA_LOCATION_COSITED_EVEN,
3979     VK_CHROMA_LOCATION_END_RANGE = VK_CHROMA_LOCATION_MIDPOINT,
3980     VK_CHROMA_LOCATION_RANGE_SIZE = (VK_CHROMA_LOCATION_MIDPOINT - VK_CHROMA_LOCATION_COSITED_EVEN + 1),
3981     VK_CHROMA_LOCATION_MAX_ENUM = 0x7FFFFFFF
3982 } VkChromaLocation;
3983
3984 typedef enum VkDescriptorUpdateTemplateType {
3985     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET = 0,
3986     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = 1,
3987     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET,
3988     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_BEGIN_RANGE = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET,
3989     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_END_RANGE = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET,
3990     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_RANGE_SIZE = (VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET - VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET + 1),
3991     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM = 0x7FFFFFFF
3992 } VkDescriptorUpdateTemplateType;
3993
3994 typedef enum VkSubgroupFeatureFlagBits {
3995     VK_SUBGROUP_FEATURE_BASIC_BIT = 0x00000001,
3996     VK_SUBGROUP_FEATURE_VOTE_BIT = 0x00000002,
3997     VK_SUBGROUP_FEATURE_ARITHMETIC_BIT = 0x00000004,
3998     VK_SUBGROUP_FEATURE_BALLOT_BIT = 0x00000008,
3999     VK_SUBGROUP_FEATURE_SHUFFLE_BIT = 0x00000010,
4000     VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT = 0x00000020,
4001     VK_SUBGROUP_FEATURE_CLUSTERED_BIT = 0x00000040,
4002     VK_SUBGROUP_FEATURE_QUAD_BIT = 0x00000080,
4003     VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV = 0x00000100,
4004     VK_SUBGROUP_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
4005 } VkSubgroupFeatureFlagBits;
4006 typedef VkFlags VkSubgroupFeatureFlags;
4007
4008 typedef enum VkPeerMemoryFeatureFlagBits {
4009     VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT = 0x00000001,
4010     VK_PEER_MEMORY_FEATURE_COPY_DST_BIT = 0x00000002,
4011     VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT = 0x00000004,
4012     VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT = 0x00000008,
4013     VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHR = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT,
4014     VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHR = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT,
4015     VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHR = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT,
4016     VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHR = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT,
4017     VK_PEER_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
4018 } VkPeerMemoryFeatureFlagBits;
4019 typedef VkFlags VkPeerMemoryFeatureFlags;
4020
4021 typedef enum VkMemoryAllocateFlagBits {
4022     VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT = 0x00000001,
4023     VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT,
4024     VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
4025 } VkMemoryAllocateFlagBits;
4026 typedef VkFlags VkMemoryAllocateFlags;
4027 typedef VkFlags VkCommandPoolTrimFlags;
4028 typedef VkFlags VkDescriptorUpdateTemplateCreateFlags;
4029
4030 typedef enum VkExternalMemoryHandleTypeFlagBits {
4031     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001,
4032     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002,
4033     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004,
4034     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT = 0x00000008,
4035     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT = 0x00000010,
4036     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT = 0x00000020,
4037     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT = 0x00000040,
4038     VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT = 0x00000200,
4039     VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID = 0x00000400,
4040     VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT = 0x00000080,
4041     VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT = 0x00000100,
4042     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT,
4043     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT,
4044     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
4045     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT,
4046     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT,
4047     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT,
4048     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT,
4049     VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
4050 } VkExternalMemoryHandleTypeFlagBits;
4051 typedef VkFlags VkExternalMemoryHandleTypeFlags;
4052
4053 typedef enum VkExternalMemoryFeatureFlagBits {
4054     VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT = 0x00000001,
4055     VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT = 0x00000002,
4056     VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT = 0x00000004,
4057     VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT,
4058     VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT,
4059     VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT,
4060     VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
4061 } VkExternalMemoryFeatureFlagBits;
4062 typedef VkFlags VkExternalMemoryFeatureFlags;
4063
4064 typedef enum VkExternalFenceHandleTypeFlagBits {
4065     VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001,
4066     VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002,
4067     VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004,
4068     VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000008,
4069     VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT,
4070     VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT,
4071     VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
4072     VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT,
4073     VK_EXTERNAL_FENCE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
4074 } VkExternalFenceHandleTypeFlagBits;
4075 typedef VkFlags VkExternalFenceHandleTypeFlags;
4076
4077 typedef enum VkExternalFenceFeatureFlagBits {
4078     VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT = 0x00000001,
4079     VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT = 0x00000002,
4080     VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT,
4081     VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT,
4082     VK_EXTERNAL_FENCE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
4083 } VkExternalFenceFeatureFlagBits;
4084 typedef VkFlags VkExternalFenceFeatureFlags;
4085
4086 typedef enum VkFenceImportFlagBits {
4087     VK_FENCE_IMPORT_TEMPORARY_BIT = 0x00000001,
4088     VK_FENCE_IMPORT_TEMPORARY_BIT_KHR = VK_FENCE_IMPORT_TEMPORARY_BIT,
4089     VK_FENCE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
4090 } VkFenceImportFlagBits;
4091 typedef VkFlags VkFenceImportFlags;
4092
4093 typedef enum VkSemaphoreImportFlagBits {
4094     VK_SEMAPHORE_IMPORT_TEMPORARY_BIT = 0x00000001,
4095     VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT,
4096     VK_SEMAPHORE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
4097 } VkSemaphoreImportFlagBits;
4098 typedef VkFlags VkSemaphoreImportFlags;
4099
4100 typedef enum VkExternalSemaphoreHandleTypeFlagBits {
4101     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001,
4102     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002,
4103     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004,
4104     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT = 0x00000008,
4105     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000010,
4106     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT,
4107     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT,
4108     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
4109     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT,
4110     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT,
4111     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
4112 } VkExternalSemaphoreHandleTypeFlagBits;
4113 typedef VkFlags VkExternalSemaphoreHandleTypeFlags;
4114
4115 typedef enum VkExternalSemaphoreFeatureFlagBits {
4116     VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT = 0x00000001,
4117     VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT = 0x00000002,
4118     VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT,
4119     VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT,
4120     VK_EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
4121 } VkExternalSemaphoreFeatureFlagBits;
4122 typedef VkFlags VkExternalSemaphoreFeatureFlags;
4123 typedef struct VkPhysicalDeviceSubgroupProperties {
4124     VkStructureType           sType;
4125     void*                     pNext;
4126     uint32_t                  subgroupSize;
4127     VkShaderStageFlags        supportedStages;
4128     VkSubgroupFeatureFlags    supportedOperations;
4129     VkBool32                  quadOperationsInAllStages;
4130 } VkPhysicalDeviceSubgroupProperties;
4131
4132 typedef struct VkBindBufferMemoryInfo {
4133     VkStructureType    sType;
4134     const void*        pNext;
4135     VkBuffer           buffer;
4136     VkDeviceMemory     memory;
4137     VkDeviceSize       memoryOffset;
4138 } VkBindBufferMemoryInfo;
4139
4140 typedef struct VkBindImageMemoryInfo {
4141     VkStructureType    sType;
4142     const void*        pNext;
4143     VkImage            image;
4144     VkDeviceMemory     memory;
4145     VkDeviceSize       memoryOffset;
4146 } VkBindImageMemoryInfo;
4147
4148 typedef struct VkPhysicalDevice16BitStorageFeatures {
4149     VkStructureType    sType;
4150     void*              pNext;
4151     VkBool32           storageBuffer16BitAccess;
4152     VkBool32           uniformAndStorageBuffer16BitAccess;
4153     VkBool32           storagePushConstant16;
4154     VkBool32           storageInputOutput16;
4155 } VkPhysicalDevice16BitStorageFeatures;
4156
4157 typedef struct VkMemoryDedicatedRequirements {
4158     VkStructureType    sType;
4159     void*              pNext;
4160     VkBool32           prefersDedicatedAllocation;
4161     VkBool32           requiresDedicatedAllocation;
4162 } VkMemoryDedicatedRequirements;
4163
4164 typedef struct VkMemoryDedicatedAllocateInfo {
4165     VkStructureType    sType;
4166     const void*        pNext;
4167     VkImage            image;
4168     VkBuffer           buffer;
4169 } VkMemoryDedicatedAllocateInfo;
4170
4171 typedef struct VkMemoryAllocateFlagsInfo {
4172     VkStructureType          sType;
4173     const void*              pNext;
4174     VkMemoryAllocateFlags    flags;
4175     uint32_t                 deviceMask;
4176 } VkMemoryAllocateFlagsInfo;
4177
4178 typedef struct VkDeviceGroupRenderPassBeginInfo {
4179     VkStructureType    sType;
4180     const void*        pNext;
4181     uint32_t           deviceMask;
4182     uint32_t           deviceRenderAreaCount;
4183     const VkRect2D*    pDeviceRenderAreas;
4184 } VkDeviceGroupRenderPassBeginInfo;
4185
4186 typedef struct VkDeviceGroupCommandBufferBeginInfo {
4187     VkStructureType    sType;
4188     const void*        pNext;
4189     uint32_t           deviceMask;
4190 } VkDeviceGroupCommandBufferBeginInfo;
4191
4192 typedef struct VkDeviceGroupSubmitInfo {
4193     VkStructureType    sType;
4194     const void*        pNext;
4195     uint32_t           waitSemaphoreCount;
4196     const uint32_t*    pWaitSemaphoreDeviceIndices;
4197     uint32_t           commandBufferCount;
4198     const uint32_t*    pCommandBufferDeviceMasks;
4199     uint32_t           signalSemaphoreCount;
4200     const uint32_t*    pSignalSemaphoreDeviceIndices;
4201 } VkDeviceGroupSubmitInfo;
4202
4203 typedef struct VkDeviceGroupBindSparseInfo {
4204     VkStructureType    sType;
4205     const void*        pNext;
4206     uint32_t           resourceDeviceIndex;
4207     uint32_t           memoryDeviceIndex;
4208 } VkDeviceGroupBindSparseInfo;
4209
4210 typedef struct VkBindBufferMemoryDeviceGroupInfo {
4211     VkStructureType    sType;
4212     const void*        pNext;
4213     uint32_t           deviceIndexCount;
4214     const uint32_t*    pDeviceIndices;
4215 } VkBindBufferMemoryDeviceGroupInfo;
4216
4217 typedef struct VkBindImageMemoryDeviceGroupInfo {
4218     VkStructureType    sType;
4219     const void*        pNext;
4220     uint32_t           deviceIndexCount;
4221     const uint32_t*    pDeviceIndices;
4222     uint32_t           splitInstanceBindRegionCount;
4223     const VkRect2D*    pSplitInstanceBindRegions;
4224 } VkBindImageMemoryDeviceGroupInfo;
4225
4226 typedef struct VkPhysicalDeviceGroupProperties {
4227     VkStructureType     sType;
4228     void*               pNext;
4229     uint32_t            physicalDeviceCount;
4230     VkPhysicalDevice    physicalDevices[VK_MAX_DEVICE_GROUP_SIZE];
4231     VkBool32            subsetAllocation;
4232 } VkPhysicalDeviceGroupProperties;
4233
4234 typedef struct VkDeviceGroupDeviceCreateInfo {
4235     VkStructureType            sType;
4236     const void*                pNext;
4237     uint32_t                   physicalDeviceCount;
4238     const VkPhysicalDevice*    pPhysicalDevices;
4239 } VkDeviceGroupDeviceCreateInfo;
4240
4241 typedef struct VkBufferMemoryRequirementsInfo2 {
4242     VkStructureType    sType;
4243     const void*        pNext;
4244     VkBuffer           buffer;
4245 } VkBufferMemoryRequirementsInfo2;
4246
4247 typedef struct VkImageMemoryRequirementsInfo2 {
4248     VkStructureType    sType;
4249     const void*        pNext;
4250     VkImage            image;
4251 } VkImageMemoryRequirementsInfo2;
4252
4253 typedef struct VkImageSparseMemoryRequirementsInfo2 {
4254     VkStructureType    sType;
4255     const void*        pNext;
4256     VkImage            image;
4257 } VkImageSparseMemoryRequirementsInfo2;
4258
4259 typedef struct VkMemoryRequirements2 {
4260     VkStructureType         sType;
4261     void*                   pNext;
4262     VkMemoryRequirements    memoryRequirements;
4263 } VkMemoryRequirements2;
4264
4265 typedef VkMemoryRequirements2 VkMemoryRequirements2KHR;
4266
4267 typedef struct VkSparseImageMemoryRequirements2 {
4268     VkStructureType                    sType;
4269     void*                              pNext;
4270     VkSparseImageMemoryRequirements    memoryRequirements;
4271 } VkSparseImageMemoryRequirements2;
4272
4273 typedef struct VkPhysicalDeviceFeatures2 {
4274     VkStructureType             sType;
4275     void*                       pNext;
4276     VkPhysicalDeviceFeatures    features;
4277 } VkPhysicalDeviceFeatures2;
4278
4279 typedef struct VkPhysicalDeviceProperties2 {
4280     VkStructureType               sType;
4281     void*                         pNext;
4282     VkPhysicalDeviceProperties    properties;
4283 } VkPhysicalDeviceProperties2;
4284
4285 typedef struct VkFormatProperties2 {
4286     VkStructureType       sType;
4287     void*                 pNext;
4288     VkFormatProperties    formatProperties;
4289 } VkFormatProperties2;
4290
4291 typedef struct VkImageFormatProperties2 {
4292     VkStructureType            sType;
4293     void*                      pNext;
4294     VkImageFormatProperties    imageFormatProperties;
4295 } VkImageFormatProperties2;
4296
4297 typedef struct VkPhysicalDeviceImageFormatInfo2 {
4298     VkStructureType       sType;
4299     const void*           pNext;
4300     VkFormat              format;
4301     VkImageType           type;
4302     VkImageTiling         tiling;
4303     VkImageUsageFlags     usage;
4304     VkImageCreateFlags    flags;
4305 } VkPhysicalDeviceImageFormatInfo2;
4306
4307 typedef struct VkQueueFamilyProperties2 {
4308     VkStructureType            sType;
4309     void*                      pNext;
4310     VkQueueFamilyProperties    queueFamilyProperties;
4311 } VkQueueFamilyProperties2;
4312
4313 typedef struct VkPhysicalDeviceMemoryProperties2 {
4314     VkStructureType                     sType;
4315     void*                               pNext;
4316     VkPhysicalDeviceMemoryProperties    memoryProperties;
4317 } VkPhysicalDeviceMemoryProperties2;
4318
4319 typedef struct VkSparseImageFormatProperties2 {
4320     VkStructureType                  sType;
4321     void*                            pNext;
4322     VkSparseImageFormatProperties    properties;
4323 } VkSparseImageFormatProperties2;
4324
4325 typedef struct VkPhysicalDeviceSparseImageFormatInfo2 {
4326     VkStructureType          sType;
4327     const void*              pNext;
4328     VkFormat                 format;
4329     VkImageType              type;
4330     VkSampleCountFlagBits    samples;
4331     VkImageUsageFlags        usage;
4332     VkImageTiling            tiling;
4333 } VkPhysicalDeviceSparseImageFormatInfo2;
4334
4335 typedef struct VkPhysicalDevicePointClippingProperties {
4336     VkStructureType            sType;
4337     void*                      pNext;
4338     VkPointClippingBehavior    pointClippingBehavior;
4339 } VkPhysicalDevicePointClippingProperties;
4340
4341 typedef struct VkInputAttachmentAspectReference {
4342     uint32_t              subpass;
4343     uint32_t              inputAttachmentIndex;
4344     VkImageAspectFlags    aspectMask;
4345 } VkInputAttachmentAspectReference;
4346
4347 typedef struct VkRenderPassInputAttachmentAspectCreateInfo {
4348     VkStructureType                            sType;
4349     const void*                                pNext;
4350     uint32_t                                   aspectReferenceCount;
4351     const VkInputAttachmentAspectReference*    pAspectReferences;
4352 } VkRenderPassInputAttachmentAspectCreateInfo;
4353
4354 typedef struct VkImageViewUsageCreateInfo {
4355     VkStructureType      sType;
4356     const void*          pNext;
4357     VkImageUsageFlags    usage;
4358 } VkImageViewUsageCreateInfo;
4359
4360 typedef struct VkPipelineTessellationDomainOriginStateCreateInfo {
4361     VkStructureType               sType;
4362     const void*                   pNext;
4363     VkTessellationDomainOrigin    domainOrigin;
4364 } VkPipelineTessellationDomainOriginStateCreateInfo;
4365
4366 typedef struct VkRenderPassMultiviewCreateInfo {
4367     VkStructureType    sType;
4368     const void*        pNext;
4369     uint32_t           subpassCount;
4370     const uint32_t*    pViewMasks;
4371     uint32_t           dependencyCount;
4372     const int32_t*     pViewOffsets;
4373     uint32_t           correlationMaskCount;
4374     const uint32_t*    pCorrelationMasks;
4375 } VkRenderPassMultiviewCreateInfo;
4376
4377 typedef struct VkPhysicalDeviceMultiviewFeatures {
4378     VkStructureType    sType;
4379     void*              pNext;
4380     VkBool32           multiview;
4381     VkBool32           multiviewGeometryShader;
4382     VkBool32           multiviewTessellationShader;
4383 } VkPhysicalDeviceMultiviewFeatures;
4384
4385 typedef struct VkPhysicalDeviceMultiviewProperties {
4386     VkStructureType    sType;
4387     void*              pNext;
4388     uint32_t           maxMultiviewViewCount;
4389     uint32_t           maxMultiviewInstanceIndex;
4390 } VkPhysicalDeviceMultiviewProperties;
4391
4392 typedef struct VkPhysicalDeviceVariablePointersFeatures {
4393     VkStructureType    sType;
4394     void*              pNext;
4395     VkBool32           variablePointersStorageBuffer;
4396     VkBool32           variablePointers;
4397 } VkPhysicalDeviceVariablePointersFeatures;
4398
4399 typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointerFeatures;
4400
4401 typedef struct VkPhysicalDeviceProtectedMemoryFeatures {
4402     VkStructureType    sType;
4403     void*              pNext;
4404     VkBool32           protectedMemory;
4405 } VkPhysicalDeviceProtectedMemoryFeatures;
4406
4407 typedef struct VkPhysicalDeviceProtectedMemoryProperties {
4408     VkStructureType    sType;
4409     void*              pNext;
4410     VkBool32           protectedNoFault;
4411 } VkPhysicalDeviceProtectedMemoryProperties;
4412
4413 typedef struct VkDeviceQueueInfo2 {
4414     VkStructureType             sType;
4415     const void*                 pNext;
4416     VkDeviceQueueCreateFlags    flags;
4417     uint32_t                    queueFamilyIndex;
4418     uint32_t                    queueIndex;
4419 } VkDeviceQueueInfo2;
4420
4421 typedef struct VkProtectedSubmitInfo {
4422     VkStructureType    sType;
4423     const void*        pNext;
4424     VkBool32           protectedSubmit;
4425 } VkProtectedSubmitInfo;
4426
4427 typedef struct VkSamplerYcbcrConversionCreateInfo {
4428     VkStructureType                  sType;
4429     const void*                      pNext;
4430     VkFormat                         format;
4431     VkSamplerYcbcrModelConversion    ycbcrModel;
4432     VkSamplerYcbcrRange              ycbcrRange;
4433     VkComponentMapping               components;
4434     VkChromaLocation                 xChromaOffset;
4435     VkChromaLocation                 yChromaOffset;
4436     VkFilter                         chromaFilter;
4437     VkBool32                         forceExplicitReconstruction;
4438 } VkSamplerYcbcrConversionCreateInfo;
4439
4440 typedef struct VkSamplerYcbcrConversionInfo {
4441     VkStructureType             sType;
4442     const void*                 pNext;
4443     VkSamplerYcbcrConversion    conversion;
4444 } VkSamplerYcbcrConversionInfo;
4445
4446 typedef struct VkBindImagePlaneMemoryInfo {
4447     VkStructureType          sType;
4448     const void*              pNext;
4449     VkImageAspectFlagBits    planeAspect;
4450 } VkBindImagePlaneMemoryInfo;
4451
4452 typedef struct VkImagePlaneMemoryRequirementsInfo {
4453     VkStructureType          sType;
4454     const void*              pNext;
4455     VkImageAspectFlagBits    planeAspect;
4456 } VkImagePlaneMemoryRequirementsInfo;
4457
4458 typedef struct VkPhysicalDeviceSamplerYcbcrConversionFeatures {
4459     VkStructureType    sType;
4460     void*              pNext;
4461     VkBool32           samplerYcbcrConversion;
4462 } VkPhysicalDeviceSamplerYcbcrConversionFeatures;
4463
4464 typedef struct VkSamplerYcbcrConversionImageFormatProperties {
4465     VkStructureType    sType;
4466     void*              pNext;
4467     uint32_t           combinedImageSamplerDescriptorCount;
4468 } VkSamplerYcbcrConversionImageFormatProperties;
4469
4470 typedef struct VkDescriptorUpdateTemplateEntry {
4471     uint32_t            dstBinding;
4472     uint32_t            dstArrayElement;
4473     uint32_t            descriptorCount;
4474     VkDescriptorType    descriptorType;
4475     size_t              offset;
4476     size_t              stride;
4477 } VkDescriptorUpdateTemplateEntry;
4478
4479 typedef struct VkDescriptorUpdateTemplateCreateInfo {
4480     VkStructureType                           sType;
4481     const void*                               pNext;
4482     VkDescriptorUpdateTemplateCreateFlags     flags;
4483     uint32_t                                  descriptorUpdateEntryCount;
4484     const VkDescriptorUpdateTemplateEntry*    pDescriptorUpdateEntries;
4485     VkDescriptorUpdateTemplateType            templateType;
4486     VkDescriptorSetLayout                     descriptorSetLayout;
4487     VkPipelineBindPoint                       pipelineBindPoint;
4488     VkPipelineLayout                          pipelineLayout;
4489     uint32_t                                  set;
4490 } VkDescriptorUpdateTemplateCreateInfo;
4491
4492 typedef struct VkExternalMemoryProperties {
4493     VkExternalMemoryFeatureFlags       externalMemoryFeatures;
4494     VkExternalMemoryHandleTypeFlags    exportFromImportedHandleTypes;
4495     VkExternalMemoryHandleTypeFlags    compatibleHandleTypes;
4496 } VkExternalMemoryProperties;
4497
4498 typedef struct VkPhysicalDeviceExternalImageFormatInfo {
4499     VkStructureType                       sType;
4500     const void*                           pNext;
4501     VkExternalMemoryHandleTypeFlagBits    handleType;
4502 } VkPhysicalDeviceExternalImageFormatInfo;
4503
4504 typedef struct VkExternalImageFormatProperties {
4505     VkStructureType               sType;
4506     void*                         pNext;
4507     VkExternalMemoryProperties    externalMemoryProperties;
4508 } VkExternalImageFormatProperties;
4509
4510 typedef struct VkPhysicalDeviceExternalBufferInfo {
4511     VkStructureType                       sType;
4512     const void*                           pNext;
4513     VkBufferCreateFlags                   flags;
4514     VkBufferUsageFlags                    usage;
4515     VkExternalMemoryHandleTypeFlagBits    handleType;
4516 } VkPhysicalDeviceExternalBufferInfo;
4517
4518 typedef struct VkExternalBufferProperties {
4519     VkStructureType               sType;
4520     void*                         pNext;
4521     VkExternalMemoryProperties    externalMemoryProperties;
4522 } VkExternalBufferProperties;
4523
4524 typedef struct VkPhysicalDeviceIDProperties {
4525     VkStructureType    sType;
4526     void*              pNext;
4527     uint8_t            deviceUUID[VK_UUID_SIZE];
4528     uint8_t            driverUUID[VK_UUID_SIZE];
4529     uint8_t            deviceLUID[VK_LUID_SIZE];
4530     uint32_t           deviceNodeMask;
4531     VkBool32           deviceLUIDValid;
4532 } VkPhysicalDeviceIDProperties;
4533
4534 typedef struct VkExternalMemoryImageCreateInfo {
4535     VkStructureType                    sType;
4536     const void*                        pNext;
4537     VkExternalMemoryHandleTypeFlags    handleTypes;
4538 } VkExternalMemoryImageCreateInfo;
4539
4540 typedef struct VkExternalMemoryBufferCreateInfo {
4541     VkStructureType                    sType;
4542     const void*                        pNext;
4543     VkExternalMemoryHandleTypeFlags    handleTypes;
4544 } VkExternalMemoryBufferCreateInfo;
4545
4546 typedef struct VkExportMemoryAllocateInfo {
4547     VkStructureType                    sType;
4548     const void*                        pNext;
4549     VkExternalMemoryHandleTypeFlags    handleTypes;
4550 } VkExportMemoryAllocateInfo;
4551
4552 typedef struct VkPhysicalDeviceExternalFenceInfo {
4553     VkStructureType                      sType;
4554     const void*                          pNext;
4555     VkExternalFenceHandleTypeFlagBits    handleType;
4556 } VkPhysicalDeviceExternalFenceInfo;
4557
4558 typedef struct VkExternalFenceProperties {
4559     VkStructureType                   sType;
4560     void*                             pNext;
4561     VkExternalFenceHandleTypeFlags    exportFromImportedHandleTypes;
4562     VkExternalFenceHandleTypeFlags    compatibleHandleTypes;
4563     VkExternalFenceFeatureFlags       externalFenceFeatures;
4564 } VkExternalFenceProperties;
4565
4566 typedef struct VkExportFenceCreateInfo {
4567     VkStructureType                   sType;
4568     const void*                       pNext;
4569     VkExternalFenceHandleTypeFlags    handleTypes;
4570 } VkExportFenceCreateInfo;
4571
4572 typedef struct VkExportSemaphoreCreateInfo {
4573     VkStructureType                       sType;
4574     const void*                           pNext;
4575     VkExternalSemaphoreHandleTypeFlags    handleTypes;
4576 } VkExportSemaphoreCreateInfo;
4577
4578 typedef struct VkPhysicalDeviceExternalSemaphoreInfo {
4579     VkStructureType                          sType;
4580     const void*                              pNext;
4581     VkExternalSemaphoreHandleTypeFlagBits    handleType;
4582 } VkPhysicalDeviceExternalSemaphoreInfo;
4583
4584 typedef struct VkExternalSemaphoreProperties {
4585     VkStructureType                       sType;
4586     void*                                 pNext;
4587     VkExternalSemaphoreHandleTypeFlags    exportFromImportedHandleTypes;
4588     VkExternalSemaphoreHandleTypeFlags    compatibleHandleTypes;
4589     VkExternalSemaphoreFeatureFlags       externalSemaphoreFeatures;
4590 } VkExternalSemaphoreProperties;
4591
4592 typedef struct VkPhysicalDeviceMaintenance3Properties {
4593     VkStructureType    sType;
4594     void*              pNext;
4595     uint32_t           maxPerSetDescriptors;
4596     VkDeviceSize       maxMemoryAllocationSize;
4597 } VkPhysicalDeviceMaintenance3Properties;
4598
4599 typedef struct VkDescriptorSetLayoutSupport {
4600     VkStructureType    sType;
4601     void*              pNext;
4602     VkBool32           supported;
4603 } VkDescriptorSetLayoutSupport;
4604
4605 typedef struct VkPhysicalDeviceShaderDrawParametersFeatures {
4606     VkStructureType    sType;
4607     void*              pNext;
4608     VkBool32           shaderDrawParameters;
4609 } VkPhysicalDeviceShaderDrawParametersFeatures;
4610
4611 typedef VkPhysicalDeviceShaderDrawParametersFeatures VkPhysicalDeviceShaderDrawParameterFeatures;
4612
4613 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceVersion)(uint32_t* pApiVersion);
4614 typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos);
4615 typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos);
4616 typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeatures)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);
4617 typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMask)(VkCommandBuffer commandBuffer, uint32_t deviceMask);
4618 typedef void (VKAPI_PTR *PFN_vkCmdDispatchBase)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);
4619 typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroups)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);
4620 typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2)(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements);
4621 typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2)(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements);
4622 typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements2)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
4623 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures);
4624 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties);
4625 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties);
4626 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties);
4627 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties);
4628 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties);
4629 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties);
4630 typedef void (VKAPI_PTR *PFN_vkTrimCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags);
4631 typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue2)(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue);
4632 typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversion)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion);
4633 typedef void (VKAPI_PTR *PFN_vkDestroySamplerYcbcrConversion)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator);
4634 typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplate)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);
4635 typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplate)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator);
4636 typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplate)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData);
4637 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties);
4638 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFenceProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties);
4639 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphoreProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties);
4640 typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutSupport)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport);
4641
4642 #ifndef VK_NO_PROTOTYPES
4643 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceVersion(
4644     uint32_t*                                   pApiVersion);
4645
4646 VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2(
4647     VkDevice                                    device,
4648     uint32_t                                    bindInfoCount,
4649     const VkBindBufferMemoryInfo*               pBindInfos);
4650
4651 VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2(
4652     VkDevice                                    device,
4653     uint32_t                                    bindInfoCount,
4654     const VkBindImageMemoryInfo*                pBindInfos);
4655
4656 VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeatures(
4657     VkDevice                                    device,
4658     uint32_t                                    heapIndex,
4659     uint32_t                                    localDeviceIndex,
4660     uint32_t                                    remoteDeviceIndex,
4661     VkPeerMemoryFeatureFlags*                   pPeerMemoryFeatures);
4662
4663 VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMask(
4664     VkCommandBuffer                             commandBuffer,
4665     uint32_t                                    deviceMask);
4666
4667 VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBase(
4668     VkCommandBuffer                             commandBuffer,
4669     uint32_t                                    baseGroupX,
4670     uint32_t                                    baseGroupY,
4671     uint32_t                                    baseGroupZ,
4672     uint32_t                                    groupCountX,
4673     uint32_t                                    groupCountY,
4674     uint32_t                                    groupCountZ);
4675
4676 VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroups(
4677     VkInstance                                  instance,
4678     uint32_t*                                   pPhysicalDeviceGroupCount,
4679     VkPhysicalDeviceGroupProperties*            pPhysicalDeviceGroupProperties);
4680
4681 VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2(
4682     VkDevice                                    device,
4683     const VkImageMemoryRequirementsInfo2*       pInfo,
4684     VkMemoryRequirements2*                      pMemoryRequirements);
4685
4686 VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2(
4687     VkDevice                                    device,
4688     const VkBufferMemoryRequirementsInfo2*      pInfo,
4689     VkMemoryRequirements2*                      pMemoryRequirements);
4690
4691 VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2(
4692     VkDevice                                    device,
4693     const VkImageSparseMemoryRequirementsInfo2* pInfo,
4694     uint32_t*                                   pSparseMemoryRequirementCount,
4695     VkSparseImageMemoryRequirements2*           pSparseMemoryRequirements);
4696
4697 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2(
4698     VkPhysicalDevice                            physicalDevice,
4699     VkPhysicalDeviceFeatures2*                  pFeatures);
4700
4701 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2(
4702     VkPhysicalDevice                            physicalDevice,
4703     VkPhysicalDeviceProperties2*                pProperties);
4704
4705 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2(
4706     VkPhysicalDevice                            physicalDevice,
4707     VkFormat                                    format,
4708     VkFormatProperties2*                        pFormatProperties);
4709
4710 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2(
4711     VkPhysicalDevice                            physicalDevice,
4712     const VkPhysicalDeviceImageFormatInfo2*     pImageFormatInfo,
4713     VkImageFormatProperties2*                   pImageFormatProperties);
4714
4715 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2(
4716     VkPhysicalDevice                            physicalDevice,
4717     uint32_t*                                   pQueueFamilyPropertyCount,
4718     VkQueueFamilyProperties2*                   pQueueFamilyProperties);
4719
4720 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2(
4721     VkPhysicalDevice                            physicalDevice,
4722     VkPhysicalDeviceMemoryProperties2*          pMemoryProperties);
4723
4724 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2(
4725     VkPhysicalDevice                            physicalDevice,
4726     const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
4727     uint32_t*                                   pPropertyCount,
4728     VkSparseImageFormatProperties2*             pProperties);
4729
4730 VKAPI_ATTR void VKAPI_CALL vkTrimCommandPool(
4731     VkDevice                                    device,
4732     VkCommandPool                               commandPool,
4733     VkCommandPoolTrimFlags                      flags);
4734
4735 VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue2(
4736     VkDevice                                    device,
4737     const VkDeviceQueueInfo2*                   pQueueInfo,
4738     VkQueue*                                    pQueue);
4739
4740 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversion(
4741     VkDevice                                    device,
4742     const VkSamplerYcbcrConversionCreateInfo*   pCreateInfo,
4743     const VkAllocationCallbacks*                pAllocator,
4744     VkSamplerYcbcrConversion*                   pYcbcrConversion);
4745
4746 VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversion(
4747     VkDevice                                    device,
4748     VkSamplerYcbcrConversion                    ycbcrConversion,
4749     const VkAllocationCallbacks*                pAllocator);
4750
4751 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplate(
4752     VkDevice                                    device,
4753     const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
4754     const VkAllocationCallbacks*                pAllocator,
4755     VkDescriptorUpdateTemplate*                 pDescriptorUpdateTemplate);
4756
4757 VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplate(
4758     VkDevice                                    device,
4759     VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
4760     const VkAllocationCallbacks*                pAllocator);
4761
4762 VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplate(
4763     VkDevice                                    device,
4764     VkDescriptorSet                             descriptorSet,
4765     VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
4766     const void*                                 pData);
4767
4768 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferProperties(
4769     VkPhysicalDevice                            physicalDevice,
4770     const VkPhysicalDeviceExternalBufferInfo*   pExternalBufferInfo,
4771     VkExternalBufferProperties*                 pExternalBufferProperties);
4772
4773 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFenceProperties(
4774     VkPhysicalDevice                            physicalDevice,
4775     const VkPhysicalDeviceExternalFenceInfo*    pExternalFenceInfo,
4776     VkExternalFenceProperties*                  pExternalFenceProperties);
4777
4778 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphoreProperties(
4779     VkPhysicalDevice                            physicalDevice,
4780     const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
4781     VkExternalSemaphoreProperties*              pExternalSemaphoreProperties);
4782
4783 VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupport(
4784     VkDevice                                    device,
4785     const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
4786     VkDescriptorSetLayoutSupport*               pSupport);
4787 #endif
4788
4789
4790 #define VK_KHR_surface 1
4791 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR)
4792 #define VK_KHR_SURFACE_SPEC_VERSION       25
4793 #define VK_KHR_SURFACE_EXTENSION_NAME     "VK_KHR_surface"
4794
4795 typedef enum VkColorSpaceKHR {
4796     VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0,
4797     VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT = 1000104001,
4798     VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT = 1000104002,
4799     VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT = 1000104003,
4800     VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT = 1000104004,
4801     VK_COLOR_SPACE_BT709_LINEAR_EXT = 1000104005,
4802     VK_COLOR_SPACE_BT709_NONLINEAR_EXT = 1000104006,
4803     VK_COLOR_SPACE_BT2020_LINEAR_EXT = 1000104007,
4804     VK_COLOR_SPACE_HDR10_ST2084_EXT = 1000104008,
4805     VK_COLOR_SPACE_DOLBYVISION_EXT = 1000104009,
4806     VK_COLOR_SPACE_HDR10_HLG_EXT = 1000104010,
4807     VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT = 1000104011,
4808     VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT = 1000104012,
4809     VK_COLOR_SPACE_PASS_THROUGH_EXT = 1000104013,
4810     VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT = 1000104014,
4811     VK_COLOR_SPACE_DISPLAY_NATIVE_AMD = 1000213000,
4812     VK_COLORSPACE_SRGB_NONLINEAR_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
4813     VK_COLOR_SPACE_DCI_P3_LINEAR_EXT = VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT,
4814     VK_COLOR_SPACE_BEGIN_RANGE_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
4815     VK_COLOR_SPACE_END_RANGE_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
4816     VK_COLOR_SPACE_RANGE_SIZE_KHR = (VK_COLOR_SPACE_SRGB_NONLINEAR_KHR - VK_COLOR_SPACE_SRGB_NONLINEAR_KHR + 1),
4817     VK_COLOR_SPACE_MAX_ENUM_KHR = 0x7FFFFFFF
4818 } VkColorSpaceKHR;
4819
4820 typedef enum VkPresentModeKHR {
4821     VK_PRESENT_MODE_IMMEDIATE_KHR = 0,
4822     VK_PRESENT_MODE_MAILBOX_KHR = 1,
4823     VK_PRESENT_MODE_FIFO_KHR = 2,
4824     VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3,
4825     VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR = 1000111000,
4826     VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR = 1000111001,
4827     VK_PRESENT_MODE_BEGIN_RANGE_KHR = VK_PRESENT_MODE_IMMEDIATE_KHR,
4828     VK_PRESENT_MODE_END_RANGE_KHR = VK_PRESENT_MODE_FIFO_RELAXED_KHR,
4829     VK_PRESENT_MODE_RANGE_SIZE_KHR = (VK_PRESENT_MODE_FIFO_RELAXED_KHR - VK_PRESENT_MODE_IMMEDIATE_KHR + 1),
4830     VK_PRESENT_MODE_MAX_ENUM_KHR = 0x7FFFFFFF
4831 } VkPresentModeKHR;
4832
4833 typedef enum VkSurfaceTransformFlagBitsKHR {
4834     VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 0x00000001,
4835     VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 0x00000002,
4836     VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 0x00000004,
4837     VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 0x00000008,
4838     VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 0x00000010,
4839     VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 0x00000020,
4840     VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 0x00000040,
4841     VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 0x00000080,
4842     VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100,
4843     VK_SURFACE_TRANSFORM_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
4844 } VkSurfaceTransformFlagBitsKHR;
4845 typedef VkFlags VkSurfaceTransformFlagsKHR;
4846
4847 typedef enum VkCompositeAlphaFlagBitsKHR {
4848     VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001,
4849     VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002,
4850     VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004,
4851     VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008,
4852     VK_COMPOSITE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
4853 } VkCompositeAlphaFlagBitsKHR;
4854 typedef VkFlags VkCompositeAlphaFlagsKHR;
4855 typedef struct VkSurfaceCapabilitiesKHR {
4856     uint32_t                         minImageCount;
4857     uint32_t                         maxImageCount;
4858     VkExtent2D                       currentExtent;
4859     VkExtent2D                       minImageExtent;
4860     VkExtent2D                       maxImageExtent;
4861     uint32_t                         maxImageArrayLayers;
4862     VkSurfaceTransformFlagsKHR       supportedTransforms;
4863     VkSurfaceTransformFlagBitsKHR    currentTransform;
4864     VkCompositeAlphaFlagsKHR         supportedCompositeAlpha;
4865     VkImageUsageFlags                supportedUsageFlags;
4866 } VkSurfaceCapabilitiesKHR;
4867
4868 typedef struct VkSurfaceFormatKHR {
4869     VkFormat           format;
4870     VkColorSpaceKHR    colorSpace;
4871 } VkSurfaceFormatKHR;
4872
4873 typedef void (VKAPI_PTR *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator);
4874 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported);
4875 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);
4876 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats);
4877 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes);
4878
4879 #ifndef VK_NO_PROTOTYPES
4880 VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR(
4881     VkInstance                                  instance,
4882     VkSurfaceKHR                                surface,
4883     const VkAllocationCallbacks*                pAllocator);
4884
4885 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR(
4886     VkPhysicalDevice                            physicalDevice,
4887     uint32_t                                    queueFamilyIndex,
4888     VkSurfaceKHR                                surface,
4889     VkBool32*                                   pSupported);
4890
4891 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
4892     VkPhysicalDevice                            physicalDevice,
4893     VkSurfaceKHR                                surface,
4894     VkSurfaceCapabilitiesKHR*                   pSurfaceCapabilities);
4895
4896 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR(
4897     VkPhysicalDevice                            physicalDevice,
4898     VkSurfaceKHR                                surface,
4899     uint32_t*                                   pSurfaceFormatCount,
4900     VkSurfaceFormatKHR*                         pSurfaceFormats);
4901
4902 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR(
4903     VkPhysicalDevice                            physicalDevice,
4904     VkSurfaceKHR                                surface,
4905     uint32_t*                                   pPresentModeCount,
4906     VkPresentModeKHR*                           pPresentModes);
4907 #endif
4908
4909
4910 #define VK_KHR_swapchain 1
4911 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR)
4912 #define VK_KHR_SWAPCHAIN_SPEC_VERSION     70
4913 #define VK_KHR_SWAPCHAIN_EXTENSION_NAME   "VK_KHR_swapchain"
4914
4915 typedef enum VkSwapchainCreateFlagBitsKHR {
4916     VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = 0x00000001,
4917     VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR = 0x00000002,
4918     VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR = 0x00000004,
4919     VK_SWAPCHAIN_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
4920 } VkSwapchainCreateFlagBitsKHR;
4921 typedef VkFlags VkSwapchainCreateFlagsKHR;
4922
4923 typedef enum VkDeviceGroupPresentModeFlagBitsKHR {
4924     VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR = 0x00000001,
4925     VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR = 0x00000002,
4926     VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR = 0x00000004,
4927     VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR = 0x00000008,
4928     VK_DEVICE_GROUP_PRESENT_MODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
4929 } VkDeviceGroupPresentModeFlagBitsKHR;
4930 typedef VkFlags VkDeviceGroupPresentModeFlagsKHR;
4931 typedef struct VkSwapchainCreateInfoKHR {
4932     VkStructureType                  sType;
4933     const void*                      pNext;
4934     VkSwapchainCreateFlagsKHR        flags;
4935     VkSurfaceKHR                     surface;
4936     uint32_t                         minImageCount;
4937     VkFormat                         imageFormat;
4938     VkColorSpaceKHR                  imageColorSpace;
4939     VkExtent2D                       imageExtent;
4940     uint32_t                         imageArrayLayers;
4941     VkImageUsageFlags                imageUsage;
4942     VkSharingMode                    imageSharingMode;
4943     uint32_t                         queueFamilyIndexCount;
4944     const uint32_t*                  pQueueFamilyIndices;
4945     VkSurfaceTransformFlagBitsKHR    preTransform;
4946     VkCompositeAlphaFlagBitsKHR      compositeAlpha;
4947     VkPresentModeKHR                 presentMode;
4948     VkBool32                         clipped;
4949     VkSwapchainKHR                   oldSwapchain;
4950 } VkSwapchainCreateInfoKHR;
4951
4952 typedef struct VkPresentInfoKHR {
4953     VkStructureType          sType;
4954     const void*              pNext;
4955     uint32_t                 waitSemaphoreCount;
4956     const VkSemaphore*       pWaitSemaphores;
4957     uint32_t                 swapchainCount;
4958     const VkSwapchainKHR*    pSwapchains;
4959     const uint32_t*          pImageIndices;
4960     VkResult*                pResults;
4961 } VkPresentInfoKHR;
4962
4963 typedef struct VkImageSwapchainCreateInfoKHR {
4964     VkStructureType    sType;
4965     const void*        pNext;
4966     VkSwapchainKHR     swapchain;
4967 } VkImageSwapchainCreateInfoKHR;
4968
4969 typedef struct VkBindImageMemorySwapchainInfoKHR {
4970     VkStructureType    sType;
4971     const void*        pNext;
4972     VkSwapchainKHR     swapchain;
4973     uint32_t           imageIndex;
4974 } VkBindImageMemorySwapchainInfoKHR;
4975
4976 typedef struct VkAcquireNextImageInfoKHR {
4977     VkStructureType    sType;
4978     const void*        pNext;
4979     VkSwapchainKHR     swapchain;
4980     uint64_t           timeout;
4981     VkSemaphore        semaphore;
4982     VkFence            fence;
4983     uint32_t           deviceMask;
4984 } VkAcquireNextImageInfoKHR;
4985
4986 typedef struct VkDeviceGroupPresentCapabilitiesKHR {
4987     VkStructureType                     sType;
4988     const void*                         pNext;
4989     uint32_t                            presentMask[VK_MAX_DEVICE_GROUP_SIZE];
4990     VkDeviceGroupPresentModeFlagsKHR    modes;
4991 } VkDeviceGroupPresentCapabilitiesKHR;
4992
4993 typedef struct VkDeviceGroupPresentInfoKHR {
4994     VkStructureType                        sType;
4995     const void*                            pNext;
4996     uint32_t                               swapchainCount;
4997     const uint32_t*                        pDeviceMasks;
4998     VkDeviceGroupPresentModeFlagBitsKHR    mode;
4999 } VkDeviceGroupPresentInfoKHR;
5000
5001 typedef struct VkDeviceGroupSwapchainCreateInfoKHR {
5002     VkStructureType                     sType;
5003     const void*                         pNext;
5004     VkDeviceGroupPresentModeFlagsKHR    modes;
5005 } VkDeviceGroupSwapchainCreateInfoKHR;
5006
5007 typedef VkResult (VKAPI_PTR *PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain);
5008 typedef void (VKAPI_PTR *PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator);
5009 typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages);
5010 typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex);
5011 typedef VkResult (VKAPI_PTR *PFN_vkQueuePresentKHR)(VkQueue queue, const VkPresentInfoKHR* pPresentInfo);
5012 typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupPresentCapabilitiesKHR)(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities);
5013 typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupSurfacePresentModesKHR)(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes);
5014 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDevicePresentRectanglesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects);
5015 typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImage2KHR)(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex);
5016
5017 #ifndef VK_NO_PROTOTYPES
5018 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR(
5019     VkDevice                                    device,
5020     const VkSwapchainCreateInfoKHR*             pCreateInfo,
5021     const VkAllocationCallbacks*                pAllocator,
5022     VkSwapchainKHR*                             pSwapchain);
5023
5024 VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR(
5025     VkDevice                                    device,
5026     VkSwapchainKHR                              swapchain,
5027     const VkAllocationCallbacks*                pAllocator);
5028
5029 VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR(
5030     VkDevice                                    device,
5031     VkSwapchainKHR                              swapchain,
5032     uint32_t*                                   pSwapchainImageCount,
5033     VkImage*                                    pSwapchainImages);
5034
5035 VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(
5036     VkDevice                                    device,
5037     VkSwapchainKHR                              swapchain,
5038     uint64_t                                    timeout,
5039     VkSemaphore                                 semaphore,
5040     VkFence                                     fence,
5041     uint32_t*                                   pImageIndex);
5042
5043 VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(
5044     VkQueue                                     queue,
5045     const VkPresentInfoKHR*                     pPresentInfo);
5046
5047 VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupPresentCapabilitiesKHR(
5048     VkDevice                                    device,
5049     VkDeviceGroupPresentCapabilitiesKHR*        pDeviceGroupPresentCapabilities);
5050
5051 VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModesKHR(
5052     VkDevice                                    device,
5053     VkSurfaceKHR                                surface,
5054     VkDeviceGroupPresentModeFlagsKHR*           pModes);
5055
5056 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDevicePresentRectanglesKHR(
5057     VkPhysicalDevice                            physicalDevice,
5058     VkSurfaceKHR                                surface,
5059     uint32_t*                                   pRectCount,
5060     VkRect2D*                                   pRects);
5061
5062 VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImage2KHR(
5063     VkDevice                                    device,
5064     const VkAcquireNextImageInfoKHR*            pAcquireInfo,
5065     uint32_t*                                   pImageIndex);
5066 #endif
5067
5068
5069 #define VK_KHR_display 1
5070 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR)
5071 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR)
5072 #define VK_KHR_DISPLAY_SPEC_VERSION       21
5073 #define VK_KHR_DISPLAY_EXTENSION_NAME     "VK_KHR_display"
5074
5075 typedef enum VkDisplayPlaneAlphaFlagBitsKHR {
5076     VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0x00000001,
5077     VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000002,
5078     VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000004,
5079     VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000008,
5080     VK_DISPLAY_PLANE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
5081 } VkDisplayPlaneAlphaFlagBitsKHR;
5082 typedef VkFlags VkDisplayPlaneAlphaFlagsKHR;
5083 typedef VkFlags VkDisplayModeCreateFlagsKHR;
5084 typedef VkFlags VkDisplaySurfaceCreateFlagsKHR;
5085 typedef struct VkDisplayPropertiesKHR {
5086     VkDisplayKHR                  display;
5087     const char*                   displayName;
5088     VkExtent2D                    physicalDimensions;
5089     VkExtent2D                    physicalResolution;
5090     VkSurfaceTransformFlagsKHR    supportedTransforms;
5091     VkBool32                      planeReorderPossible;
5092     VkBool32                      persistentContent;
5093 } VkDisplayPropertiesKHR;
5094
5095 typedef struct VkDisplayModeParametersKHR {
5096     VkExtent2D    visibleRegion;
5097     uint32_t      refreshRate;
5098 } VkDisplayModeParametersKHR;
5099
5100 typedef struct VkDisplayModePropertiesKHR {
5101     VkDisplayModeKHR              displayMode;
5102     VkDisplayModeParametersKHR    parameters;
5103 } VkDisplayModePropertiesKHR;
5104
5105 typedef struct VkDisplayModeCreateInfoKHR {
5106     VkStructureType                sType;
5107     const void*                    pNext;
5108     VkDisplayModeCreateFlagsKHR    flags;
5109     VkDisplayModeParametersKHR     parameters;
5110 } VkDisplayModeCreateInfoKHR;
5111
5112 typedef struct VkDisplayPlaneCapabilitiesKHR {
5113     VkDisplayPlaneAlphaFlagsKHR    supportedAlpha;
5114     VkOffset2D                     minSrcPosition;
5115     VkOffset2D                     maxSrcPosition;
5116     VkExtent2D                     minSrcExtent;
5117     VkExtent2D                     maxSrcExtent;
5118     VkOffset2D                     minDstPosition;
5119     VkOffset2D                     maxDstPosition;
5120     VkExtent2D                     minDstExtent;
5121     VkExtent2D                     maxDstExtent;
5122 } VkDisplayPlaneCapabilitiesKHR;
5123
5124 typedef struct VkDisplayPlanePropertiesKHR {
5125     VkDisplayKHR    currentDisplay;
5126     uint32_t        currentStackIndex;
5127 } VkDisplayPlanePropertiesKHR;
5128
5129 typedef struct VkDisplaySurfaceCreateInfoKHR {
5130     VkStructureType                   sType;
5131     const void*                       pNext;
5132     VkDisplaySurfaceCreateFlagsKHR    flags;
5133     VkDisplayModeKHR                  displayMode;
5134     uint32_t                          planeIndex;
5135     uint32_t                          planeStackIndex;
5136     VkSurfaceTransformFlagBitsKHR     transform;
5137     float                             globalAlpha;
5138     VkDisplayPlaneAlphaFlagBitsKHR    alphaMode;
5139     VkExtent2D                        imageExtent;
5140 } VkDisplaySurfaceCreateInfoKHR;
5141
5142 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties);
5143 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties);
5144 typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays);
5145 typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties);
5146 typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode);
5147 typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities);
5148 typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
5149
5150 #ifndef VK_NO_PROTOTYPES
5151 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR(
5152     VkPhysicalDevice                            physicalDevice,
5153     uint32_t*                                   pPropertyCount,
5154     VkDisplayPropertiesKHR*                     pProperties);
5155
5156 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
5157     VkPhysicalDevice                            physicalDevice,
5158     uint32_t*                                   pPropertyCount,
5159     VkDisplayPlanePropertiesKHR*                pProperties);
5160
5161 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR(
5162     VkPhysicalDevice                            physicalDevice,
5163     uint32_t                                    planeIndex,
5164     uint32_t*                                   pDisplayCount,
5165     VkDisplayKHR*                               pDisplays);
5166
5167 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR(
5168     VkPhysicalDevice                            physicalDevice,
5169     VkDisplayKHR                                display,
5170     uint32_t*                                   pPropertyCount,
5171     VkDisplayModePropertiesKHR*                 pProperties);
5172
5173 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR(
5174     VkPhysicalDevice                            physicalDevice,
5175     VkDisplayKHR                                display,
5176     const VkDisplayModeCreateInfoKHR*           pCreateInfo,
5177     const VkAllocationCallbacks*                pAllocator,
5178     VkDisplayModeKHR*                           pMode);
5179
5180 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR(
5181     VkPhysicalDevice                            physicalDevice,
5182     VkDisplayModeKHR                            mode,
5183     uint32_t                                    planeIndex,
5184     VkDisplayPlaneCapabilitiesKHR*              pCapabilities);
5185
5186 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR(
5187     VkInstance                                  instance,
5188     const VkDisplaySurfaceCreateInfoKHR*        pCreateInfo,
5189     const VkAllocationCallbacks*                pAllocator,
5190     VkSurfaceKHR*                               pSurface);
5191 #endif
5192
5193
5194 #define VK_KHR_display_swapchain 1
5195 #define VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION 9
5196 #define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain"
5197 typedef struct VkDisplayPresentInfoKHR {
5198     VkStructureType    sType;
5199     const void*        pNext;
5200     VkRect2D           srcRect;
5201     VkRect2D           dstRect;
5202     VkBool32           persistent;
5203 } VkDisplayPresentInfoKHR;
5204
5205 typedef VkResult (VKAPI_PTR *PFN_vkCreateSharedSwapchainsKHR)(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains);
5206
5207 #ifndef VK_NO_PROTOTYPES
5208 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR(
5209     VkDevice                                    device,
5210     uint32_t                                    swapchainCount,
5211     const VkSwapchainCreateInfoKHR*             pCreateInfos,
5212     const VkAllocationCallbacks*                pAllocator,
5213     VkSwapchainKHR*                             pSwapchains);
5214 #endif
5215
5216
5217 #define VK_KHR_sampler_mirror_clamp_to_edge 1
5218 #define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION 1
5219 #define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME "VK_KHR_sampler_mirror_clamp_to_edge"
5220
5221
5222 #define VK_KHR_multiview 1
5223 #define VK_KHR_MULTIVIEW_SPEC_VERSION     1
5224 #define VK_KHR_MULTIVIEW_EXTENSION_NAME   "VK_KHR_multiview"
5225 typedef VkRenderPassMultiviewCreateInfo VkRenderPassMultiviewCreateInfoKHR;
5226
5227 typedef VkPhysicalDeviceMultiviewFeatures VkPhysicalDeviceMultiviewFeaturesKHR;
5228
5229 typedef VkPhysicalDeviceMultiviewProperties VkPhysicalDeviceMultiviewPropertiesKHR;
5230
5231
5232
5233 #define VK_KHR_get_physical_device_properties2 1
5234 #define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION 1
5235 #define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_physical_device_properties2"
5236 typedef VkPhysicalDeviceFeatures2 VkPhysicalDeviceFeatures2KHR;
5237
5238 typedef VkPhysicalDeviceProperties2 VkPhysicalDeviceProperties2KHR;
5239
5240 typedef VkFormatProperties2 VkFormatProperties2KHR;
5241
5242 typedef VkImageFormatProperties2 VkImageFormatProperties2KHR;
5243
5244 typedef VkPhysicalDeviceImageFormatInfo2 VkPhysicalDeviceImageFormatInfo2KHR;
5245
5246 typedef VkQueueFamilyProperties2 VkQueueFamilyProperties2KHR;
5247
5248 typedef VkPhysicalDeviceMemoryProperties2 VkPhysicalDeviceMemoryProperties2KHR;
5249
5250 typedef VkSparseImageFormatProperties2 VkSparseImageFormatProperties2KHR;
5251
5252 typedef VkPhysicalDeviceSparseImageFormatInfo2 VkPhysicalDeviceSparseImageFormatInfo2KHR;
5253
5254 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures);
5255 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties);
5256 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2KHR)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties);
5257 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties);
5258 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties);
5259 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties);
5260 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties);
5261
5262 #ifndef VK_NO_PROTOTYPES
5263 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2KHR(
5264     VkPhysicalDevice                            physicalDevice,
5265     VkPhysicalDeviceFeatures2*                  pFeatures);
5266
5267 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2KHR(
5268     VkPhysicalDevice                            physicalDevice,
5269     VkPhysicalDeviceProperties2*                pProperties);
5270
5271 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2KHR(
5272     VkPhysicalDevice                            physicalDevice,
5273     VkFormat                                    format,
5274     VkFormatProperties2*                        pFormatProperties);
5275
5276 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2KHR(
5277     VkPhysicalDevice                            physicalDevice,
5278     const VkPhysicalDeviceImageFormatInfo2*     pImageFormatInfo,
5279     VkImageFormatProperties2*                   pImageFormatProperties);
5280
5281 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2KHR(
5282     VkPhysicalDevice                            physicalDevice,
5283     uint32_t*                                   pQueueFamilyPropertyCount,
5284     VkQueueFamilyProperties2*                   pQueueFamilyProperties);
5285
5286 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2KHR(
5287     VkPhysicalDevice                            physicalDevice,
5288     VkPhysicalDeviceMemoryProperties2*          pMemoryProperties);
5289
5290 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
5291     VkPhysicalDevice                            physicalDevice,
5292     const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
5293     uint32_t*                                   pPropertyCount,
5294     VkSparseImageFormatProperties2*             pProperties);
5295 #endif
5296
5297
5298 #define VK_KHR_device_group 1
5299 #define VK_KHR_DEVICE_GROUP_SPEC_VERSION  3
5300 #define VK_KHR_DEVICE_GROUP_EXTENSION_NAME "VK_KHR_device_group"
5301 typedef VkPeerMemoryFeatureFlags VkPeerMemoryFeatureFlagsKHR;
5302
5303 typedef VkPeerMemoryFeatureFlagBits VkPeerMemoryFeatureFlagBitsKHR;
5304
5305 typedef VkMemoryAllocateFlags VkMemoryAllocateFlagsKHR;
5306
5307 typedef VkMemoryAllocateFlagBits VkMemoryAllocateFlagBitsKHR;
5308
5309 typedef VkMemoryAllocateFlagsInfo VkMemoryAllocateFlagsInfoKHR;
5310
5311 typedef VkDeviceGroupRenderPassBeginInfo VkDeviceGroupRenderPassBeginInfoKHR;
5312
5313 typedef VkDeviceGroupCommandBufferBeginInfo VkDeviceGroupCommandBufferBeginInfoKHR;
5314
5315 typedef VkDeviceGroupSubmitInfo VkDeviceGroupSubmitInfoKHR;
5316
5317 typedef VkDeviceGroupBindSparseInfo VkDeviceGroupBindSparseInfoKHR;
5318
5319 typedef VkBindBufferMemoryDeviceGroupInfo VkBindBufferMemoryDeviceGroupInfoKHR;
5320
5321 typedef VkBindImageMemoryDeviceGroupInfo VkBindImageMemoryDeviceGroupInfoKHR;
5322
5323 typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);
5324 typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMaskKHR)(VkCommandBuffer commandBuffer, uint32_t deviceMask);
5325 typedef void (VKAPI_PTR *PFN_vkCmdDispatchBaseKHR)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);
5326
5327 #ifndef VK_NO_PROTOTYPES
5328 VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeaturesKHR(
5329     VkDevice                                    device,
5330     uint32_t                                    heapIndex,
5331     uint32_t                                    localDeviceIndex,
5332     uint32_t                                    remoteDeviceIndex,
5333     VkPeerMemoryFeatureFlags*                   pPeerMemoryFeatures);
5334
5335 VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMaskKHR(
5336     VkCommandBuffer                             commandBuffer,
5337     uint32_t                                    deviceMask);
5338
5339 VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBaseKHR(
5340     VkCommandBuffer                             commandBuffer,
5341     uint32_t                                    baseGroupX,
5342     uint32_t                                    baseGroupY,
5343     uint32_t                                    baseGroupZ,
5344     uint32_t                                    groupCountX,
5345     uint32_t                                    groupCountY,
5346     uint32_t                                    groupCountZ);
5347 #endif
5348
5349
5350 #define VK_KHR_shader_draw_parameters 1
5351 #define VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION 1
5352 #define VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME "VK_KHR_shader_draw_parameters"
5353
5354
5355 #define VK_KHR_maintenance1 1
5356 #define VK_KHR_MAINTENANCE1_SPEC_VERSION  2
5357 #define VK_KHR_MAINTENANCE1_EXTENSION_NAME "VK_KHR_maintenance1"
5358 typedef VkCommandPoolTrimFlags VkCommandPoolTrimFlagsKHR;
5359
5360 typedef void (VKAPI_PTR *PFN_vkTrimCommandPoolKHR)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags);
5361
5362 #ifndef VK_NO_PROTOTYPES
5363 VKAPI_ATTR void VKAPI_CALL vkTrimCommandPoolKHR(
5364     VkDevice                                    device,
5365     VkCommandPool                               commandPool,
5366     VkCommandPoolTrimFlags                      flags);
5367 #endif
5368
5369
5370 #define VK_KHR_device_group_creation 1
5371 #define VK_KHR_DEVICE_GROUP_CREATION_SPEC_VERSION 1
5372 #define VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME "VK_KHR_device_group_creation"
5373 #define VK_MAX_DEVICE_GROUP_SIZE_KHR      VK_MAX_DEVICE_GROUP_SIZE
5374 typedef VkPhysicalDeviceGroupProperties VkPhysicalDeviceGroupPropertiesKHR;
5375
5376 typedef VkDeviceGroupDeviceCreateInfo VkDeviceGroupDeviceCreateInfoKHR;
5377
5378 typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroupsKHR)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);
5379
5380 #ifndef VK_NO_PROTOTYPES
5381 VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroupsKHR(
5382     VkInstance                                  instance,
5383     uint32_t*                                   pPhysicalDeviceGroupCount,
5384     VkPhysicalDeviceGroupProperties*            pPhysicalDeviceGroupProperties);
5385 #endif
5386
5387
5388 #define VK_KHR_external_memory_capabilities 1
5389 #define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1
5390 #define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_memory_capabilities"
5391 #define VK_LUID_SIZE_KHR                  VK_LUID_SIZE
5392 typedef VkExternalMemoryHandleTypeFlags VkExternalMemoryHandleTypeFlagsKHR;
5393
5394 typedef VkExternalMemoryHandleTypeFlagBits VkExternalMemoryHandleTypeFlagBitsKHR;
5395
5396 typedef VkExternalMemoryFeatureFlags VkExternalMemoryFeatureFlagsKHR;
5397
5398 typedef VkExternalMemoryFeatureFlagBits VkExternalMemoryFeatureFlagBitsKHR;
5399
5400 typedef VkExternalMemoryProperties VkExternalMemoryPropertiesKHR;
5401
5402 typedef VkPhysicalDeviceExternalImageFormatInfo VkPhysicalDeviceExternalImageFormatInfoKHR;
5403
5404 typedef VkExternalImageFormatProperties VkExternalImageFormatPropertiesKHR;
5405
5406 typedef VkPhysicalDeviceExternalBufferInfo VkPhysicalDeviceExternalBufferInfoKHR;
5407
5408 typedef VkExternalBufferProperties VkExternalBufferPropertiesKHR;
5409
5410 typedef VkPhysicalDeviceIDProperties VkPhysicalDeviceIDPropertiesKHR;
5411
5412 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties);
5413
5414 #ifndef VK_NO_PROTOTYPES
5415 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferPropertiesKHR(
5416     VkPhysicalDevice                            physicalDevice,
5417     const VkPhysicalDeviceExternalBufferInfo*   pExternalBufferInfo,
5418     VkExternalBufferProperties*                 pExternalBufferProperties);
5419 #endif
5420
5421
5422 #define VK_KHR_external_memory 1
5423 #define VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION 1
5424 #define VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME "VK_KHR_external_memory"
5425 #define VK_QUEUE_FAMILY_EXTERNAL_KHR      VK_QUEUE_FAMILY_EXTERNAL
5426 typedef VkExternalMemoryImageCreateInfo VkExternalMemoryImageCreateInfoKHR;
5427
5428 typedef VkExternalMemoryBufferCreateInfo VkExternalMemoryBufferCreateInfoKHR;
5429
5430 typedef VkExportMemoryAllocateInfo VkExportMemoryAllocateInfoKHR;
5431
5432
5433
5434 #define VK_KHR_external_memory_fd 1
5435 #define VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION 1
5436 #define VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME "VK_KHR_external_memory_fd"
5437 typedef struct VkImportMemoryFdInfoKHR {
5438     VkStructureType                       sType;
5439     const void*                           pNext;
5440     VkExternalMemoryHandleTypeFlagBits    handleType;
5441     int                                   fd;
5442 } VkImportMemoryFdInfoKHR;
5443
5444 typedef struct VkMemoryFdPropertiesKHR {
5445     VkStructureType    sType;
5446     void*              pNext;
5447     uint32_t           memoryTypeBits;
5448 } VkMemoryFdPropertiesKHR;
5449
5450 typedef struct VkMemoryGetFdInfoKHR {
5451     VkStructureType                       sType;
5452     const void*                           pNext;
5453     VkDeviceMemory                        memory;
5454     VkExternalMemoryHandleTypeFlagBits    handleType;
5455 } VkMemoryGetFdInfoKHR;
5456
5457 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdKHR)(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd);
5458 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdPropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties);
5459
5460 #ifndef VK_NO_PROTOTYPES
5461 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdKHR(
5462     VkDevice                                    device,
5463     const VkMemoryGetFdInfoKHR*                 pGetFdInfo,
5464     int*                                        pFd);
5465
5466 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdPropertiesKHR(
5467     VkDevice                                    device,
5468     VkExternalMemoryHandleTypeFlagBits          handleType,
5469     int                                         fd,
5470     VkMemoryFdPropertiesKHR*                    pMemoryFdProperties);
5471 #endif
5472
5473
5474 #define VK_KHR_external_semaphore_capabilities 1
5475 #define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION 1
5476 #define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_semaphore_capabilities"
5477 typedef VkExternalSemaphoreHandleTypeFlags VkExternalSemaphoreHandleTypeFlagsKHR;
5478
5479 typedef VkExternalSemaphoreHandleTypeFlagBits VkExternalSemaphoreHandleTypeFlagBitsKHR;
5480
5481 typedef VkExternalSemaphoreFeatureFlags VkExternalSemaphoreFeatureFlagsKHR;
5482
5483 typedef VkExternalSemaphoreFeatureFlagBits VkExternalSemaphoreFeatureFlagBitsKHR;
5484
5485 typedef VkPhysicalDeviceExternalSemaphoreInfo VkPhysicalDeviceExternalSemaphoreInfoKHR;
5486
5487 typedef VkExternalSemaphoreProperties VkExternalSemaphorePropertiesKHR;
5488
5489 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties);
5490
5491 #ifndef VK_NO_PROTOTYPES
5492 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
5493     VkPhysicalDevice                            physicalDevice,
5494     const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
5495     VkExternalSemaphoreProperties*              pExternalSemaphoreProperties);
5496 #endif
5497
5498
5499 #define VK_KHR_external_semaphore 1
5500 #define VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION 1
5501 #define VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME "VK_KHR_external_semaphore"
5502 typedef VkSemaphoreImportFlags VkSemaphoreImportFlagsKHR;
5503
5504 typedef VkSemaphoreImportFlagBits VkSemaphoreImportFlagBitsKHR;
5505
5506 typedef VkExportSemaphoreCreateInfo VkExportSemaphoreCreateInfoKHR;
5507
5508
5509
5510 #define VK_KHR_external_semaphore_fd 1
5511 #define VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION 1
5512 #define VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME "VK_KHR_external_semaphore_fd"
5513 typedef struct VkImportSemaphoreFdInfoKHR {
5514     VkStructureType                          sType;
5515     const void*                              pNext;
5516     VkSemaphore                              semaphore;
5517     VkSemaphoreImportFlags                   flags;
5518     VkExternalSemaphoreHandleTypeFlagBits    handleType;
5519     int                                      fd;
5520 } VkImportSemaphoreFdInfoKHR;
5521
5522 typedef struct VkSemaphoreGetFdInfoKHR {
5523     VkStructureType                          sType;
5524     const void*                              pNext;
5525     VkSemaphore                              semaphore;
5526     VkExternalSemaphoreHandleTypeFlagBits    handleType;
5527 } VkSemaphoreGetFdInfoKHR;
5528
5529 typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreFdKHR)(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo);
5530 typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreFdKHR)(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd);
5531
5532 #ifndef VK_NO_PROTOTYPES
5533 VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreFdKHR(
5534     VkDevice                                    device,
5535     const VkImportSemaphoreFdInfoKHR*           pImportSemaphoreFdInfo);
5536
5537 VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreFdKHR(
5538     VkDevice                                    device,
5539     const VkSemaphoreGetFdInfoKHR*              pGetFdInfo,
5540     int*                                        pFd);
5541 #endif
5542
5543
5544 #define VK_KHR_push_descriptor 1
5545 #define VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION 2
5546 #define VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME "VK_KHR_push_descriptor"
5547 typedef struct VkPhysicalDevicePushDescriptorPropertiesKHR {
5548     VkStructureType    sType;
5549     void*              pNext;
5550     uint32_t           maxPushDescriptors;
5551 } VkPhysicalDevicePushDescriptorPropertiesKHR;
5552
5553 typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetKHR)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites);
5554 typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetWithTemplateKHR)(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData);
5555
5556 #ifndef VK_NO_PROTOTYPES
5557 VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetKHR(
5558     VkCommandBuffer                             commandBuffer,
5559     VkPipelineBindPoint                         pipelineBindPoint,
5560     VkPipelineLayout                            layout,
5561     uint32_t                                    set,
5562     uint32_t                                    descriptorWriteCount,
5563     const VkWriteDescriptorSet*                 pDescriptorWrites);
5564
5565 VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplateKHR(
5566     VkCommandBuffer                             commandBuffer,
5567     VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
5568     VkPipelineLayout                            layout,
5569     uint32_t                                    set,
5570     const void*                                 pData);
5571 #endif
5572
5573
5574 #define VK_KHR_shader_float16_int8 1
5575 #define VK_KHR_SHADER_FLOAT16_INT8_SPEC_VERSION 1
5576 #define VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME "VK_KHR_shader_float16_int8"
5577 typedef struct VkPhysicalDeviceShaderFloat16Int8FeaturesKHR {
5578     VkStructureType    sType;
5579     void*              pNext;
5580     VkBool32           shaderFloat16;
5581     VkBool32           shaderInt8;
5582 } VkPhysicalDeviceShaderFloat16Int8FeaturesKHR;
5583
5584 typedef VkPhysicalDeviceShaderFloat16Int8FeaturesKHR VkPhysicalDeviceFloat16Int8FeaturesKHR;
5585
5586
5587
5588 #define VK_KHR_16bit_storage 1
5589 #define VK_KHR_16BIT_STORAGE_SPEC_VERSION 1
5590 #define VK_KHR_16BIT_STORAGE_EXTENSION_NAME "VK_KHR_16bit_storage"
5591 typedef VkPhysicalDevice16BitStorageFeatures VkPhysicalDevice16BitStorageFeaturesKHR;
5592
5593
5594
5595 #define VK_KHR_incremental_present 1
5596 #define VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION 1
5597 #define VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME "VK_KHR_incremental_present"
5598 typedef struct VkRectLayerKHR {
5599     VkOffset2D    offset;
5600     VkExtent2D    extent;
5601     uint32_t      layer;
5602 } VkRectLayerKHR;
5603
5604 typedef struct VkPresentRegionKHR {
5605     uint32_t                 rectangleCount;
5606     const VkRectLayerKHR*    pRectangles;
5607 } VkPresentRegionKHR;
5608
5609 typedef struct VkPresentRegionsKHR {
5610     VkStructureType              sType;
5611     const void*                  pNext;
5612     uint32_t                     swapchainCount;
5613     const VkPresentRegionKHR*    pRegions;
5614 } VkPresentRegionsKHR;
5615
5616
5617
5618 #define VK_KHR_descriptor_update_template 1
5619 typedef VkDescriptorUpdateTemplate VkDescriptorUpdateTemplateKHR;
5620
5621 #define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION 1
5622 #define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME "VK_KHR_descriptor_update_template"
5623 typedef VkDescriptorUpdateTemplateType VkDescriptorUpdateTemplateTypeKHR;
5624
5625 typedef VkDescriptorUpdateTemplateCreateFlags VkDescriptorUpdateTemplateCreateFlagsKHR;
5626
5627 typedef VkDescriptorUpdateTemplateEntry VkDescriptorUpdateTemplateEntryKHR;
5628
5629 typedef VkDescriptorUpdateTemplateCreateInfo VkDescriptorUpdateTemplateCreateInfoKHR;
5630
5631 typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplateKHR)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);
5632 typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplateKHR)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator);
5633 typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplateKHR)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData);
5634
5635 #ifndef VK_NO_PROTOTYPES
5636 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplateKHR(
5637     VkDevice                                    device,
5638     const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
5639     const VkAllocationCallbacks*                pAllocator,
5640     VkDescriptorUpdateTemplate*                 pDescriptorUpdateTemplate);
5641
5642 VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplateKHR(
5643     VkDevice                                    device,
5644     VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
5645     const VkAllocationCallbacks*                pAllocator);
5646
5647 VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplateKHR(
5648     VkDevice                                    device,
5649     VkDescriptorSet                             descriptorSet,
5650     VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
5651     const void*                                 pData);
5652 #endif
5653
5654
5655 #define VK_KHR_imageless_framebuffer 1
5656 #define VK_KHR_IMAGELESS_FRAMEBUFFER_SPEC_VERSION 1
5657 #define VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME "VK_KHR_imageless_framebuffer"
5658 typedef struct VkPhysicalDeviceImagelessFramebufferFeaturesKHR {
5659     VkStructureType    sType;
5660     void*              pNext;
5661     VkBool32           imagelessFramebuffer;
5662 } VkPhysicalDeviceImagelessFramebufferFeaturesKHR;
5663
5664 typedef struct VkFramebufferAttachmentImageInfoKHR {
5665     VkStructureType       sType;
5666     const void*           pNext;
5667     VkImageCreateFlags    flags;
5668     VkImageUsageFlags     usage;
5669     uint32_t              width;
5670     uint32_t              height;
5671     uint32_t              layerCount;
5672     uint32_t              viewFormatCount;
5673     const VkFormat*       pViewFormats;
5674 } VkFramebufferAttachmentImageInfoKHR;
5675
5676 typedef struct VkFramebufferAttachmentsCreateInfoKHR {
5677     VkStructureType                               sType;
5678     const void*                                   pNext;
5679     uint32_t                                      attachmentImageInfoCount;
5680     const VkFramebufferAttachmentImageInfoKHR*    pAttachmentImageInfos;
5681 } VkFramebufferAttachmentsCreateInfoKHR;
5682
5683 typedef struct VkRenderPassAttachmentBeginInfoKHR {
5684     VkStructureType       sType;
5685     const void*           pNext;
5686     uint32_t              attachmentCount;
5687     const VkImageView*    pAttachments;
5688 } VkRenderPassAttachmentBeginInfoKHR;
5689
5690
5691
5692 #define VK_KHR_create_renderpass2 1
5693 #define VK_KHR_CREATE_RENDERPASS_2_SPEC_VERSION 1
5694 #define VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME "VK_KHR_create_renderpass2"
5695 typedef struct VkAttachmentDescription2KHR {
5696     VkStructureType                 sType;
5697     const void*                     pNext;
5698     VkAttachmentDescriptionFlags    flags;
5699     VkFormat                        format;
5700     VkSampleCountFlagBits           samples;
5701     VkAttachmentLoadOp              loadOp;
5702     VkAttachmentStoreOp             storeOp;
5703     VkAttachmentLoadOp              stencilLoadOp;
5704     VkAttachmentStoreOp             stencilStoreOp;
5705     VkImageLayout                   initialLayout;
5706     VkImageLayout                   finalLayout;
5707 } VkAttachmentDescription2KHR;
5708
5709 typedef struct VkAttachmentReference2KHR {
5710     VkStructureType       sType;
5711     const void*           pNext;
5712     uint32_t              attachment;
5713     VkImageLayout         layout;
5714     VkImageAspectFlags    aspectMask;
5715 } VkAttachmentReference2KHR;
5716
5717 typedef struct VkSubpassDescription2KHR {
5718     VkStructureType                     sType;
5719     const void*                         pNext;
5720     VkSubpassDescriptionFlags           flags;
5721     VkPipelineBindPoint                 pipelineBindPoint;
5722     uint32_t                            viewMask;
5723     uint32_t                            inputAttachmentCount;
5724     const VkAttachmentReference2KHR*    pInputAttachments;
5725     uint32_t                            colorAttachmentCount;
5726     const VkAttachmentReference2KHR*    pColorAttachments;
5727     const VkAttachmentReference2KHR*    pResolveAttachments;
5728     const VkAttachmentReference2KHR*    pDepthStencilAttachment;
5729     uint32_t                            preserveAttachmentCount;
5730     const uint32_t*                     pPreserveAttachments;
5731 } VkSubpassDescription2KHR;
5732
5733 typedef struct VkSubpassDependency2KHR {
5734     VkStructureType         sType;
5735     const void*             pNext;
5736     uint32_t                srcSubpass;
5737     uint32_t                dstSubpass;
5738     VkPipelineStageFlags    srcStageMask;
5739     VkPipelineStageFlags    dstStageMask;
5740     VkAccessFlags           srcAccessMask;
5741     VkAccessFlags           dstAccessMask;
5742     VkDependencyFlags       dependencyFlags;
5743     int32_t                 viewOffset;
5744 } VkSubpassDependency2KHR;
5745
5746 typedef struct VkRenderPassCreateInfo2KHR {
5747     VkStructureType                       sType;
5748     const void*                           pNext;
5749     VkRenderPassCreateFlags               flags;
5750     uint32_t                              attachmentCount;
5751     const VkAttachmentDescription2KHR*    pAttachments;
5752     uint32_t                              subpassCount;
5753     const VkSubpassDescription2KHR*       pSubpasses;
5754     uint32_t                              dependencyCount;
5755     const VkSubpassDependency2KHR*        pDependencies;
5756     uint32_t                              correlatedViewMaskCount;
5757     const uint32_t*                       pCorrelatedViewMasks;
5758 } VkRenderPassCreateInfo2KHR;
5759
5760 typedef struct VkSubpassBeginInfoKHR {
5761     VkStructureType      sType;
5762     const void*          pNext;
5763     VkSubpassContents    contents;
5764 } VkSubpassBeginInfoKHR;
5765
5766 typedef struct VkSubpassEndInfoKHR {
5767     VkStructureType    sType;
5768     const void*        pNext;
5769 } VkSubpassEndInfoKHR;
5770
5771 typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass2KHR)(VkDevice device, const VkRenderPassCreateInfo2KHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);
5772 typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass2KHR)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo*      pRenderPassBegin, const VkSubpassBeginInfoKHR*      pSubpassBeginInfo);
5773 typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass2KHR)(VkCommandBuffer commandBuffer, const VkSubpassBeginInfoKHR*      pSubpassBeginInfo, const VkSubpassEndInfoKHR*        pSubpassEndInfo);
5774 typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass2KHR)(VkCommandBuffer commandBuffer, const VkSubpassEndInfoKHR*        pSubpassEndInfo);
5775
5776 #ifndef VK_NO_PROTOTYPES
5777 VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass2KHR(
5778     VkDevice                                    device,
5779     const VkRenderPassCreateInfo2KHR*           pCreateInfo,
5780     const VkAllocationCallbacks*                pAllocator,
5781     VkRenderPass*                               pRenderPass);
5782
5783 VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass2KHR(
5784     VkCommandBuffer                             commandBuffer,
5785     const VkRenderPassBeginInfo*                pRenderPassBegin,
5786     const VkSubpassBeginInfoKHR*                pSubpassBeginInfo);
5787
5788 VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass2KHR(
5789     VkCommandBuffer                             commandBuffer,
5790     const VkSubpassBeginInfoKHR*                pSubpassBeginInfo,
5791     const VkSubpassEndInfoKHR*                  pSubpassEndInfo);
5792
5793 VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass2KHR(
5794     VkCommandBuffer                             commandBuffer,
5795     const VkSubpassEndInfoKHR*                  pSubpassEndInfo);
5796 #endif
5797
5798
5799 #define VK_KHR_shared_presentable_image 1
5800 #define VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION 1
5801 #define VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME "VK_KHR_shared_presentable_image"
5802 typedef struct VkSharedPresentSurfaceCapabilitiesKHR {
5803     VkStructureType      sType;
5804     void*                pNext;
5805     VkImageUsageFlags    sharedPresentSupportedUsageFlags;
5806 } VkSharedPresentSurfaceCapabilitiesKHR;
5807
5808 typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainStatusKHR)(VkDevice device, VkSwapchainKHR swapchain);
5809
5810 #ifndef VK_NO_PROTOTYPES
5811 VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainStatusKHR(
5812     VkDevice                                    device,
5813     VkSwapchainKHR                              swapchain);
5814 #endif
5815
5816
5817 #define VK_KHR_external_fence_capabilities 1
5818 #define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION 1
5819 #define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_fence_capabilities"
5820 typedef VkExternalFenceHandleTypeFlags VkExternalFenceHandleTypeFlagsKHR;
5821
5822 typedef VkExternalFenceHandleTypeFlagBits VkExternalFenceHandleTypeFlagBitsKHR;
5823
5824 typedef VkExternalFenceFeatureFlags VkExternalFenceFeatureFlagsKHR;
5825
5826 typedef VkExternalFenceFeatureFlagBits VkExternalFenceFeatureFlagBitsKHR;
5827
5828 typedef VkPhysicalDeviceExternalFenceInfo VkPhysicalDeviceExternalFenceInfoKHR;
5829
5830 typedef VkExternalFenceProperties VkExternalFencePropertiesKHR;
5831
5832 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties);
5833
5834 #ifndef VK_NO_PROTOTYPES
5835 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFencePropertiesKHR(
5836     VkPhysicalDevice                            physicalDevice,
5837     const VkPhysicalDeviceExternalFenceInfo*    pExternalFenceInfo,
5838     VkExternalFenceProperties*                  pExternalFenceProperties);
5839 #endif
5840
5841
5842 #define VK_KHR_external_fence 1
5843 #define VK_KHR_EXTERNAL_FENCE_SPEC_VERSION 1
5844 #define VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME "VK_KHR_external_fence"
5845 typedef VkFenceImportFlags VkFenceImportFlagsKHR;
5846
5847 typedef VkFenceImportFlagBits VkFenceImportFlagBitsKHR;
5848
5849 typedef VkExportFenceCreateInfo VkExportFenceCreateInfoKHR;
5850
5851
5852
5853 #define VK_KHR_external_fence_fd 1
5854 #define VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION 1
5855 #define VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME "VK_KHR_external_fence_fd"
5856 typedef struct VkImportFenceFdInfoKHR {
5857     VkStructureType                      sType;
5858     const void*                          pNext;
5859     VkFence                              fence;
5860     VkFenceImportFlags                   flags;
5861     VkExternalFenceHandleTypeFlagBits    handleType;
5862     int                                  fd;
5863 } VkImportFenceFdInfoKHR;
5864
5865 typedef struct VkFenceGetFdInfoKHR {
5866     VkStructureType                      sType;
5867     const void*                          pNext;
5868     VkFence                              fence;
5869     VkExternalFenceHandleTypeFlagBits    handleType;
5870 } VkFenceGetFdInfoKHR;
5871
5872 typedef VkResult (VKAPI_PTR *PFN_vkImportFenceFdKHR)(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo);
5873 typedef VkResult (VKAPI_PTR *PFN_vkGetFenceFdKHR)(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd);
5874
5875 #ifndef VK_NO_PROTOTYPES
5876 VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceFdKHR(
5877     VkDevice                                    device,
5878     const VkImportFenceFdInfoKHR*               pImportFenceFdInfo);
5879
5880 VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceFdKHR(
5881     VkDevice                                    device,
5882     const VkFenceGetFdInfoKHR*                  pGetFdInfo,
5883     int*                                        pFd);
5884 #endif
5885
5886
5887 #define VK_KHR_maintenance2 1
5888 #define VK_KHR_MAINTENANCE2_SPEC_VERSION  1
5889 #define VK_KHR_MAINTENANCE2_EXTENSION_NAME "VK_KHR_maintenance2"
5890 typedef VkPointClippingBehavior VkPointClippingBehaviorKHR;
5891
5892 typedef VkTessellationDomainOrigin VkTessellationDomainOriginKHR;
5893
5894 typedef VkPhysicalDevicePointClippingProperties VkPhysicalDevicePointClippingPropertiesKHR;
5895
5896 typedef VkRenderPassInputAttachmentAspectCreateInfo VkRenderPassInputAttachmentAspectCreateInfoKHR;
5897
5898 typedef VkInputAttachmentAspectReference VkInputAttachmentAspectReferenceKHR;
5899
5900 typedef VkImageViewUsageCreateInfo VkImageViewUsageCreateInfoKHR;
5901
5902 typedef VkPipelineTessellationDomainOriginStateCreateInfo VkPipelineTessellationDomainOriginStateCreateInfoKHR;
5903
5904
5905
5906 #define VK_KHR_get_surface_capabilities2 1
5907 #define VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION 1
5908 #define VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME "VK_KHR_get_surface_capabilities2"
5909 typedef struct VkPhysicalDeviceSurfaceInfo2KHR {
5910     VkStructureType    sType;
5911     const void*        pNext;
5912     VkSurfaceKHR       surface;
5913 } VkPhysicalDeviceSurfaceInfo2KHR;
5914
5915 typedef struct VkSurfaceCapabilities2KHR {
5916     VkStructureType             sType;
5917     void*                       pNext;
5918     VkSurfaceCapabilitiesKHR    surfaceCapabilities;
5919 } VkSurfaceCapabilities2KHR;
5920
5921 typedef struct VkSurfaceFormat2KHR {
5922     VkStructureType       sType;
5923     void*                 pNext;
5924     VkSurfaceFormatKHR    surfaceFormat;
5925 } VkSurfaceFormat2KHR;
5926
5927 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities);
5928 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormats2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats);
5929
5930 #ifndef VK_NO_PROTOTYPES
5931 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2KHR(
5932     VkPhysicalDevice                            physicalDevice,
5933     const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
5934     VkSurfaceCapabilities2KHR*                  pSurfaceCapabilities);
5935
5936 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormats2KHR(
5937     VkPhysicalDevice                            physicalDevice,
5938     const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
5939     uint32_t*                                   pSurfaceFormatCount,
5940     VkSurfaceFormat2KHR*                        pSurfaceFormats);
5941 #endif
5942
5943
5944 #define VK_KHR_variable_pointers 1
5945 #define VK_KHR_VARIABLE_POINTERS_SPEC_VERSION 1
5946 #define VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME "VK_KHR_variable_pointers"
5947 typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointerFeaturesKHR;
5948
5949 typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointersFeaturesKHR;
5950
5951
5952
5953 #define VK_KHR_get_display_properties2 1
5954 #define VK_KHR_GET_DISPLAY_PROPERTIES_2_SPEC_VERSION 1
5955 #define VK_KHR_GET_DISPLAY_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_display_properties2"
5956 typedef struct VkDisplayProperties2KHR {
5957     VkStructureType           sType;
5958     void*                     pNext;
5959     VkDisplayPropertiesKHR    displayProperties;
5960 } VkDisplayProperties2KHR;
5961
5962 typedef struct VkDisplayPlaneProperties2KHR {
5963     VkStructureType                sType;
5964     void*                          pNext;
5965     VkDisplayPlanePropertiesKHR    displayPlaneProperties;
5966 } VkDisplayPlaneProperties2KHR;
5967
5968 typedef struct VkDisplayModeProperties2KHR {
5969     VkStructureType               sType;
5970     void*                         pNext;
5971     VkDisplayModePropertiesKHR    displayModeProperties;
5972 } VkDisplayModeProperties2KHR;
5973
5974 typedef struct VkDisplayPlaneInfo2KHR {
5975     VkStructureType     sType;
5976     const void*         pNext;
5977     VkDisplayModeKHR    mode;
5978     uint32_t            planeIndex;
5979 } VkDisplayPlaneInfo2KHR;
5980
5981 typedef struct VkDisplayPlaneCapabilities2KHR {
5982     VkStructureType                  sType;
5983     void*                            pNext;
5984     VkDisplayPlaneCapabilitiesKHR    capabilities;
5985 } VkDisplayPlaneCapabilities2KHR;
5986
5987 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties);
5988 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties);
5989 typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModeProperties2KHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties);
5990 typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities);
5991
5992 #ifndef VK_NO_PROTOTYPES
5993 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayProperties2KHR(
5994     VkPhysicalDevice                            physicalDevice,
5995     uint32_t*                                   pPropertyCount,
5996     VkDisplayProperties2KHR*                    pProperties);
5997
5998 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
5999     VkPhysicalDevice                            physicalDevice,
6000     uint32_t*                                   pPropertyCount,
6001     VkDisplayPlaneProperties2KHR*               pProperties);
6002
6003 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModeProperties2KHR(
6004     VkPhysicalDevice                            physicalDevice,
6005     VkDisplayKHR                                display,
6006     uint32_t*                                   pPropertyCount,
6007     VkDisplayModeProperties2KHR*                pProperties);
6008
6009 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilities2KHR(
6010     VkPhysicalDevice                            physicalDevice,
6011     const VkDisplayPlaneInfo2KHR*               pDisplayPlaneInfo,
6012     VkDisplayPlaneCapabilities2KHR*             pCapabilities);
6013 #endif
6014
6015
6016 #define VK_KHR_dedicated_allocation 1
6017 #define VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION 3
6018 #define VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_KHR_dedicated_allocation"
6019 typedef VkMemoryDedicatedRequirements VkMemoryDedicatedRequirementsKHR;
6020
6021 typedef VkMemoryDedicatedAllocateInfo VkMemoryDedicatedAllocateInfoKHR;
6022
6023
6024
6025 #define VK_KHR_storage_buffer_storage_class 1
6026 #define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION 1
6027 #define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME "VK_KHR_storage_buffer_storage_class"
6028
6029
6030 #define VK_KHR_relaxed_block_layout 1
6031 #define VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION 1
6032 #define VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME "VK_KHR_relaxed_block_layout"
6033
6034
6035 #define VK_KHR_get_memory_requirements2 1
6036 #define VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION 1
6037 #define VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME "VK_KHR_get_memory_requirements2"
6038 typedef VkBufferMemoryRequirementsInfo2 VkBufferMemoryRequirementsInfo2KHR;
6039
6040 typedef VkImageMemoryRequirementsInfo2 VkImageMemoryRequirementsInfo2KHR;
6041
6042 typedef VkImageSparseMemoryRequirementsInfo2 VkImageSparseMemoryRequirementsInfo2KHR;
6043
6044 typedef VkSparseImageMemoryRequirements2 VkSparseImageMemoryRequirements2KHR;
6045
6046 typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2KHR)(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements);
6047 typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2KHR)(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements);
6048 typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements2KHR)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
6049
6050 #ifndef VK_NO_PROTOTYPES
6051 VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2KHR(
6052     VkDevice                                    device,
6053     const VkImageMemoryRequirementsInfo2*       pInfo,
6054     VkMemoryRequirements2*                      pMemoryRequirements);
6055
6056 VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2KHR(
6057     VkDevice                                    device,
6058     const VkBufferMemoryRequirementsInfo2*      pInfo,
6059     VkMemoryRequirements2*                      pMemoryRequirements);
6060
6061 VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2KHR(
6062     VkDevice                                    device,
6063     const VkImageSparseMemoryRequirementsInfo2* pInfo,
6064     uint32_t*                                   pSparseMemoryRequirementCount,
6065     VkSparseImageMemoryRequirements2*           pSparseMemoryRequirements);
6066 #endif
6067
6068
6069 #define VK_KHR_image_format_list 1
6070 #define VK_KHR_IMAGE_FORMAT_LIST_SPEC_VERSION 1
6071 #define VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME "VK_KHR_image_format_list"
6072 typedef struct VkImageFormatListCreateInfoKHR {
6073     VkStructureType    sType;
6074     const void*        pNext;
6075     uint32_t           viewFormatCount;
6076     const VkFormat*    pViewFormats;
6077 } VkImageFormatListCreateInfoKHR;
6078
6079
6080
6081 #define VK_KHR_sampler_ycbcr_conversion 1
6082 typedef VkSamplerYcbcrConversion VkSamplerYcbcrConversionKHR;
6083
6084 #define VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION 1
6085 #define VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME "VK_KHR_sampler_ycbcr_conversion"
6086 typedef VkSamplerYcbcrModelConversion VkSamplerYcbcrModelConversionKHR;
6087
6088 typedef VkSamplerYcbcrRange VkSamplerYcbcrRangeKHR;
6089
6090 typedef VkChromaLocation VkChromaLocationKHR;
6091
6092 typedef VkSamplerYcbcrConversionCreateInfo VkSamplerYcbcrConversionCreateInfoKHR;
6093
6094 typedef VkSamplerYcbcrConversionInfo VkSamplerYcbcrConversionInfoKHR;
6095
6096 typedef VkBindImagePlaneMemoryInfo VkBindImagePlaneMemoryInfoKHR;
6097
6098 typedef VkImagePlaneMemoryRequirementsInfo VkImagePlaneMemoryRequirementsInfoKHR;
6099
6100 typedef VkPhysicalDeviceSamplerYcbcrConversionFeatures VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR;
6101
6102 typedef VkSamplerYcbcrConversionImageFormatProperties VkSamplerYcbcrConversionImageFormatPropertiesKHR;
6103
6104 typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversionKHR)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion);
6105 typedef void (VKAPI_PTR *PFN_vkDestroySamplerYcbcrConversionKHR)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator);
6106
6107 #ifndef VK_NO_PROTOTYPES
6108 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversionKHR(
6109     VkDevice                                    device,
6110     const VkSamplerYcbcrConversionCreateInfo*   pCreateInfo,
6111     const VkAllocationCallbacks*                pAllocator,
6112     VkSamplerYcbcrConversion*                   pYcbcrConversion);
6113
6114 VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversionKHR(
6115     VkDevice                                    device,
6116     VkSamplerYcbcrConversion                    ycbcrConversion,
6117     const VkAllocationCallbacks*                pAllocator);
6118 #endif
6119
6120
6121 #define VK_KHR_bind_memory2 1
6122 #define VK_KHR_BIND_MEMORY_2_SPEC_VERSION 1
6123 #define VK_KHR_BIND_MEMORY_2_EXTENSION_NAME "VK_KHR_bind_memory2"
6124 typedef VkBindBufferMemoryInfo VkBindBufferMemoryInfoKHR;
6125
6126 typedef VkBindImageMemoryInfo VkBindImageMemoryInfoKHR;
6127
6128 typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos);
6129 typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos);
6130
6131 #ifndef VK_NO_PROTOTYPES
6132 VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2KHR(
6133     VkDevice                                    device,
6134     uint32_t                                    bindInfoCount,
6135     const VkBindBufferMemoryInfo*               pBindInfos);
6136
6137 VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2KHR(
6138     VkDevice                                    device,
6139     uint32_t                                    bindInfoCount,
6140     const VkBindImageMemoryInfo*                pBindInfos);
6141 #endif
6142
6143
6144 #define VK_KHR_maintenance3 1
6145 #define VK_KHR_MAINTENANCE3_SPEC_VERSION  1
6146 #define VK_KHR_MAINTENANCE3_EXTENSION_NAME "VK_KHR_maintenance3"
6147 typedef VkPhysicalDeviceMaintenance3Properties VkPhysicalDeviceMaintenance3PropertiesKHR;
6148
6149 typedef VkDescriptorSetLayoutSupport VkDescriptorSetLayoutSupportKHR;
6150
6151 typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutSupportKHR)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport);
6152
6153 #ifndef VK_NO_PROTOTYPES
6154 VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupportKHR(
6155     VkDevice                                    device,
6156     const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
6157     VkDescriptorSetLayoutSupport*               pSupport);
6158 #endif
6159
6160
6161 #define VK_KHR_draw_indirect_count 1
6162 #define VK_KHR_DRAW_INDIRECT_COUNT_SPEC_VERSION 1
6163 #define VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_KHR_draw_indirect_count"
6164 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountKHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
6165 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCountKHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
6166
6167 #ifndef VK_NO_PROTOTYPES
6168 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountKHR(
6169     VkCommandBuffer                             commandBuffer,
6170     VkBuffer                                    buffer,
6171     VkDeviceSize                                offset,
6172     VkBuffer                                    countBuffer,
6173     VkDeviceSize                                countBufferOffset,
6174     uint32_t                                    maxDrawCount,
6175     uint32_t                                    stride);
6176
6177 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountKHR(
6178     VkCommandBuffer                             commandBuffer,
6179     VkBuffer                                    buffer,
6180     VkDeviceSize                                offset,
6181     VkBuffer                                    countBuffer,
6182     VkDeviceSize                                countBufferOffset,
6183     uint32_t                                    maxDrawCount,
6184     uint32_t                                    stride);
6185 #endif
6186
6187
6188 #define VK_KHR_8bit_storage 1
6189 #define VK_KHR_8BIT_STORAGE_SPEC_VERSION  1
6190 #define VK_KHR_8BIT_STORAGE_EXTENSION_NAME "VK_KHR_8bit_storage"
6191 typedef struct VkPhysicalDevice8BitStorageFeaturesKHR {
6192     VkStructureType    sType;
6193     void*              pNext;
6194     VkBool32           storageBuffer8BitAccess;
6195     VkBool32           uniformAndStorageBuffer8BitAccess;
6196     VkBool32           storagePushConstant8;
6197 } VkPhysicalDevice8BitStorageFeaturesKHR;
6198
6199
6200
6201 #define VK_KHR_shader_atomic_int64 1
6202 #define VK_KHR_SHADER_ATOMIC_INT64_SPEC_VERSION 1
6203 #define VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME "VK_KHR_shader_atomic_int64"
6204 typedef struct VkPhysicalDeviceShaderAtomicInt64FeaturesKHR {
6205     VkStructureType    sType;
6206     void*              pNext;
6207     VkBool32           shaderBufferInt64Atomics;
6208     VkBool32           shaderSharedInt64Atomics;
6209 } VkPhysicalDeviceShaderAtomicInt64FeaturesKHR;
6210
6211
6212
6213 #define VK_KHR_driver_properties 1
6214 #define VK_MAX_DRIVER_NAME_SIZE_KHR       256
6215 #define VK_MAX_DRIVER_INFO_SIZE_KHR       256
6216 #define VK_KHR_DRIVER_PROPERTIES_SPEC_VERSION 1
6217 #define VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME "VK_KHR_driver_properties"
6218
6219 typedef enum VkDriverIdKHR {
6220     VK_DRIVER_ID_AMD_PROPRIETARY_KHR = 1,
6221     VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR = 2,
6222     VK_DRIVER_ID_MESA_RADV_KHR = 3,
6223     VK_DRIVER_ID_NVIDIA_PROPRIETARY_KHR = 4,
6224     VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS_KHR = 5,
6225     VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA_KHR = 6,
6226     VK_DRIVER_ID_IMAGINATION_PROPRIETARY_KHR = 7,
6227     VK_DRIVER_ID_QUALCOMM_PROPRIETARY_KHR = 8,
6228     VK_DRIVER_ID_ARM_PROPRIETARY_KHR = 9,
6229     VK_DRIVER_ID_GOOGLE_SWIFTSHADER_KHR = 10,
6230     VK_DRIVER_ID_GGP_PROPRIETARY_KHR = 11,
6231     VK_DRIVER_ID_BROADCOM_PROPRIETARY_KHR = 12,
6232     VK_DRIVER_ID_BEGIN_RANGE_KHR = VK_DRIVER_ID_AMD_PROPRIETARY_KHR,
6233     VK_DRIVER_ID_END_RANGE_KHR = VK_DRIVER_ID_BROADCOM_PROPRIETARY_KHR,
6234     VK_DRIVER_ID_RANGE_SIZE_KHR = (VK_DRIVER_ID_BROADCOM_PROPRIETARY_KHR - VK_DRIVER_ID_AMD_PROPRIETARY_KHR + 1),
6235     VK_DRIVER_ID_MAX_ENUM_KHR = 0x7FFFFFFF
6236 } VkDriverIdKHR;
6237 typedef struct VkConformanceVersionKHR {
6238     uint8_t    major;
6239     uint8_t    minor;
6240     uint8_t    subminor;
6241     uint8_t    patch;
6242 } VkConformanceVersionKHR;
6243
6244 typedef struct VkPhysicalDeviceDriverPropertiesKHR {
6245     VkStructureType            sType;
6246     void*                      pNext;
6247     VkDriverIdKHR              driverID;
6248     char                       driverName[VK_MAX_DRIVER_NAME_SIZE_KHR];
6249     char                       driverInfo[VK_MAX_DRIVER_INFO_SIZE_KHR];
6250     VkConformanceVersionKHR    conformanceVersion;
6251 } VkPhysicalDeviceDriverPropertiesKHR;
6252
6253
6254
6255 #define VK_KHR_shader_float_controls 1
6256 #define VK_KHR_SHADER_FLOAT_CONTROLS_SPEC_VERSION 4
6257 #define VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME "VK_KHR_shader_float_controls"
6258
6259 typedef enum VkShaderFloatControlsIndependenceKHR {
6260     VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR = 0,
6261     VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL_KHR = 1,
6262     VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR = 2,
6263     VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_BEGIN_RANGE_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR,
6264     VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_END_RANGE_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR,
6265     VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_RANGE_SIZE_KHR = (VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR - VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR + 1),
6266     VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_MAX_ENUM_KHR = 0x7FFFFFFF
6267 } VkShaderFloatControlsIndependenceKHR;
6268 typedef struct VkPhysicalDeviceFloatControlsPropertiesKHR {
6269     VkStructureType                         sType;
6270     void*                                   pNext;
6271     VkShaderFloatControlsIndependenceKHR    denormBehaviorIndependence;
6272     VkShaderFloatControlsIndependenceKHR    roundingModeIndependence;
6273     VkBool32                                shaderSignedZeroInfNanPreserveFloat16;
6274     VkBool32                                shaderSignedZeroInfNanPreserveFloat32;
6275     VkBool32                                shaderSignedZeroInfNanPreserveFloat64;
6276     VkBool32                                shaderDenormPreserveFloat16;
6277     VkBool32                                shaderDenormPreserveFloat32;
6278     VkBool32                                shaderDenormPreserveFloat64;
6279     VkBool32                                shaderDenormFlushToZeroFloat16;
6280     VkBool32                                shaderDenormFlushToZeroFloat32;
6281     VkBool32                                shaderDenormFlushToZeroFloat64;
6282     VkBool32                                shaderRoundingModeRTEFloat16;
6283     VkBool32                                shaderRoundingModeRTEFloat32;
6284     VkBool32                                shaderRoundingModeRTEFloat64;
6285     VkBool32                                shaderRoundingModeRTZFloat16;
6286     VkBool32                                shaderRoundingModeRTZFloat32;
6287     VkBool32                                shaderRoundingModeRTZFloat64;
6288 } VkPhysicalDeviceFloatControlsPropertiesKHR;
6289
6290
6291
6292 #define VK_KHR_depth_stencil_resolve 1
6293 #define VK_KHR_DEPTH_STENCIL_RESOLVE_SPEC_VERSION 1
6294 #define VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME "VK_KHR_depth_stencil_resolve"
6295
6296 typedef enum VkResolveModeFlagBitsKHR {
6297     VK_RESOLVE_MODE_NONE_KHR = 0,
6298     VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR = 0x00000001,
6299     VK_RESOLVE_MODE_AVERAGE_BIT_KHR = 0x00000002,
6300     VK_RESOLVE_MODE_MIN_BIT_KHR = 0x00000004,
6301     VK_RESOLVE_MODE_MAX_BIT_KHR = 0x00000008,
6302     VK_RESOLVE_MODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
6303 } VkResolveModeFlagBitsKHR;
6304 typedef VkFlags VkResolveModeFlagsKHR;
6305 typedef struct VkSubpassDescriptionDepthStencilResolveKHR {
6306     VkStructureType                     sType;
6307     const void*                         pNext;
6308     VkResolveModeFlagBitsKHR            depthResolveMode;
6309     VkResolveModeFlagBitsKHR            stencilResolveMode;
6310     const VkAttachmentReference2KHR*    pDepthStencilResolveAttachment;
6311 } VkSubpassDescriptionDepthStencilResolveKHR;
6312
6313 typedef struct VkPhysicalDeviceDepthStencilResolvePropertiesKHR {
6314     VkStructureType          sType;
6315     void*                    pNext;
6316     VkResolveModeFlagsKHR    supportedDepthResolveModes;
6317     VkResolveModeFlagsKHR    supportedStencilResolveModes;
6318     VkBool32                 independentResolveNone;
6319     VkBool32                 independentResolve;
6320 } VkPhysicalDeviceDepthStencilResolvePropertiesKHR;
6321
6322
6323
6324 #define VK_KHR_swapchain_mutable_format 1
6325 #define VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_SPEC_VERSION 1
6326 #define VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME "VK_KHR_swapchain_mutable_format"
6327
6328
6329 #define VK_KHR_vulkan_memory_model 1
6330 #define VK_KHR_VULKAN_MEMORY_MODEL_SPEC_VERSION 3
6331 #define VK_KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME "VK_KHR_vulkan_memory_model"
6332 typedef struct VkPhysicalDeviceVulkanMemoryModelFeaturesKHR {
6333     VkStructureType    sType;
6334     void*              pNext;
6335     VkBool32           vulkanMemoryModel;
6336     VkBool32           vulkanMemoryModelDeviceScope;
6337     VkBool32           vulkanMemoryModelAvailabilityVisibilityChains;
6338 } VkPhysicalDeviceVulkanMemoryModelFeaturesKHR;
6339
6340
6341
6342 #define VK_KHR_surface_protected_capabilities 1
6343 #define VK_KHR_SURFACE_PROTECTED_CAPABILITIES_SPEC_VERSION 1
6344 #define VK_KHR_SURFACE_PROTECTED_CAPABILITIES_EXTENSION_NAME "VK_KHR_surface_protected_capabilities"
6345 typedef struct VkSurfaceProtectedCapabilitiesKHR {
6346     VkStructureType    sType;
6347     const void*        pNext;
6348     VkBool32           supportsProtected;
6349 } VkSurfaceProtectedCapabilitiesKHR;
6350
6351
6352
6353 #define VK_KHR_uniform_buffer_standard_layout 1
6354 #define VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_SPEC_VERSION 1
6355 #define VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME "VK_KHR_uniform_buffer_standard_layout"
6356 typedef struct VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR {
6357     VkStructureType    sType;
6358     void*              pNext;
6359     VkBool32           uniformBufferStandardLayout;
6360 } VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR;
6361
6362
6363
6364 #define VK_EXT_debug_report 1
6365 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT)
6366 #define VK_EXT_DEBUG_REPORT_SPEC_VERSION  9
6367 #define VK_EXT_DEBUG_REPORT_EXTENSION_NAME "VK_EXT_debug_report"
6368
6369 typedef enum VkDebugReportObjectTypeEXT {
6370     VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0,
6371     VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1,
6372     VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2,
6373     VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3,
6374     VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4,
6375     VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5,
6376     VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6,
6377     VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7,
6378     VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8,
6379     VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9,
6380     VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10,
6381     VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11,
6382     VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12,
6383     VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13,
6384     VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14,
6385     VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15,
6386     VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16,
6387     VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17,
6388     VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18,
6389     VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19,
6390     VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20,
6391     VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21,
6392     VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22,
6393     VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23,
6394     VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24,
6395     VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25,
6396     VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26,
6397     VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27,
6398     VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT = 28,
6399     VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT = 29,
6400     VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT = 30,
6401     VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT = 31,
6402     VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT = 32,
6403     VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT = 33,
6404     VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT = 1000156000,
6405     VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT = 1000085000,
6406     VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT = 1000165000,
6407     VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT,
6408     VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT,
6409     VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT,
6410     VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT,
6411     VK_DEBUG_REPORT_OBJECT_TYPE_BEGIN_RANGE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT,
6412     VK_DEBUG_REPORT_OBJECT_TYPE_END_RANGE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT,
6413     VK_DEBUG_REPORT_OBJECT_TYPE_RANGE_SIZE_EXT = (VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT - VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT + 1),
6414     VK_DEBUG_REPORT_OBJECT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
6415 } VkDebugReportObjectTypeEXT;
6416
6417 typedef enum VkDebugReportFlagBitsEXT {
6418     VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 0x00000001,
6419     VK_DEBUG_REPORT_WARNING_BIT_EXT = 0x00000002,
6420     VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 0x00000004,
6421     VK_DEBUG_REPORT_ERROR_BIT_EXT = 0x00000008,
6422     VK_DEBUG_REPORT_DEBUG_BIT_EXT = 0x00000010,
6423     VK_DEBUG_REPORT_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
6424 } VkDebugReportFlagBitsEXT;
6425 typedef VkFlags VkDebugReportFlagsEXT;
6426 typedef VkBool32 (VKAPI_PTR *PFN_vkDebugReportCallbackEXT)(
6427     VkDebugReportFlagsEXT                       flags,
6428     VkDebugReportObjectTypeEXT                  objectType,
6429     uint64_t                                    object,
6430     size_t                                      location,
6431     int32_t                                     messageCode,
6432     const char*                                 pLayerPrefix,
6433     const char*                                 pMessage,
6434     void*                                       pUserData);
6435
6436 typedef struct VkDebugReportCallbackCreateInfoEXT {
6437     VkStructureType                 sType;
6438     const void*                     pNext;
6439     VkDebugReportFlagsEXT           flags;
6440     PFN_vkDebugReportCallbackEXT    pfnCallback;
6441     void*                           pUserData;
6442 } VkDebugReportCallbackCreateInfoEXT;
6443
6444 typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugReportCallbackEXT)(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback);
6445 typedef void (VKAPI_PTR *PFN_vkDestroyDebugReportCallbackEXT)(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator);
6446 typedef void (VKAPI_PTR *PFN_vkDebugReportMessageEXT)(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage);
6447
6448 #ifndef VK_NO_PROTOTYPES
6449 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT(
6450     VkInstance                                  instance,
6451     const VkDebugReportCallbackCreateInfoEXT*   pCreateInfo,
6452     const VkAllocationCallbacks*                pAllocator,
6453     VkDebugReportCallbackEXT*                   pCallback);
6454
6455 VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT(
6456     VkInstance                                  instance,
6457     VkDebugReportCallbackEXT                    callback,
6458     const VkAllocationCallbacks*                pAllocator);
6459
6460 VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT(
6461     VkInstance                                  instance,
6462     VkDebugReportFlagsEXT                       flags,
6463     VkDebugReportObjectTypeEXT                  objectType,
6464     uint64_t                                    object,
6465     size_t                                      location,
6466     int32_t                                     messageCode,
6467     const char*                                 pLayerPrefix,
6468     const char*                                 pMessage);
6469 #endif
6470
6471
6472 #define VK_NV_glsl_shader 1
6473 #define VK_NV_GLSL_SHADER_SPEC_VERSION    1
6474 #define VK_NV_GLSL_SHADER_EXTENSION_NAME  "VK_NV_glsl_shader"
6475
6476
6477 #define VK_EXT_depth_range_unrestricted 1
6478 #define VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION 1
6479 #define VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME "VK_EXT_depth_range_unrestricted"
6480
6481
6482 #define VK_IMG_filter_cubic 1
6483 #define VK_IMG_FILTER_CUBIC_SPEC_VERSION  1
6484 #define VK_IMG_FILTER_CUBIC_EXTENSION_NAME "VK_IMG_filter_cubic"
6485
6486
6487 #define VK_AMD_rasterization_order 1
6488 #define VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION 1
6489 #define VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME "VK_AMD_rasterization_order"
6490
6491 typedef enum VkRasterizationOrderAMD {
6492     VK_RASTERIZATION_ORDER_STRICT_AMD = 0,
6493     VK_RASTERIZATION_ORDER_RELAXED_AMD = 1,
6494     VK_RASTERIZATION_ORDER_BEGIN_RANGE_AMD = VK_RASTERIZATION_ORDER_STRICT_AMD,
6495     VK_RASTERIZATION_ORDER_END_RANGE_AMD = VK_RASTERIZATION_ORDER_RELAXED_AMD,
6496     VK_RASTERIZATION_ORDER_RANGE_SIZE_AMD = (VK_RASTERIZATION_ORDER_RELAXED_AMD - VK_RASTERIZATION_ORDER_STRICT_AMD + 1),
6497     VK_RASTERIZATION_ORDER_MAX_ENUM_AMD = 0x7FFFFFFF
6498 } VkRasterizationOrderAMD;
6499 typedef struct VkPipelineRasterizationStateRasterizationOrderAMD {
6500     VkStructureType            sType;
6501     const void*                pNext;
6502     VkRasterizationOrderAMD    rasterizationOrder;
6503 } VkPipelineRasterizationStateRasterizationOrderAMD;
6504
6505
6506
6507 #define VK_AMD_shader_trinary_minmax 1
6508 #define VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION 1
6509 #define VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME "VK_AMD_shader_trinary_minmax"
6510
6511
6512 #define VK_AMD_shader_explicit_vertex_parameter 1
6513 #define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION 1
6514 #define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME "VK_AMD_shader_explicit_vertex_parameter"
6515
6516
6517 #define VK_EXT_debug_marker 1
6518 #define VK_EXT_DEBUG_MARKER_SPEC_VERSION  4
6519 #define VK_EXT_DEBUG_MARKER_EXTENSION_NAME "VK_EXT_debug_marker"
6520 typedef struct VkDebugMarkerObjectNameInfoEXT {
6521     VkStructureType               sType;
6522     const void*                   pNext;
6523     VkDebugReportObjectTypeEXT    objectType;
6524     uint64_t                      object;
6525     const char*                   pObjectName;
6526 } VkDebugMarkerObjectNameInfoEXT;
6527
6528 typedef struct VkDebugMarkerObjectTagInfoEXT {
6529     VkStructureType               sType;
6530     const void*                   pNext;
6531     VkDebugReportObjectTypeEXT    objectType;
6532     uint64_t                      object;
6533     uint64_t                      tagName;
6534     size_t                        tagSize;
6535     const void*                   pTag;
6536 } VkDebugMarkerObjectTagInfoEXT;
6537
6538 typedef struct VkDebugMarkerMarkerInfoEXT {
6539     VkStructureType    sType;
6540     const void*        pNext;
6541     const char*        pMarkerName;
6542     float              color[4];
6543 } VkDebugMarkerMarkerInfoEXT;
6544
6545 typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectTagEXT)(VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo);
6546 typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectNameEXT)(VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo);
6547 typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerBeginEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
6548 typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerEndEXT)(VkCommandBuffer commandBuffer);
6549 typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerInsertEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
6550
6551 #ifndef VK_NO_PROTOTYPES
6552 VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectTagEXT(
6553     VkDevice                                    device,
6554     const VkDebugMarkerObjectTagInfoEXT*        pTagInfo);
6555
6556 VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectNameEXT(
6557     VkDevice                                    device,
6558     const VkDebugMarkerObjectNameInfoEXT*       pNameInfo);
6559
6560 VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerBeginEXT(
6561     VkCommandBuffer                             commandBuffer,
6562     const VkDebugMarkerMarkerInfoEXT*           pMarkerInfo);
6563
6564 VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerEndEXT(
6565     VkCommandBuffer                             commandBuffer);
6566
6567 VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerInsertEXT(
6568     VkCommandBuffer                             commandBuffer,
6569     const VkDebugMarkerMarkerInfoEXT*           pMarkerInfo);
6570 #endif
6571
6572
6573 #define VK_AMD_gcn_shader 1
6574 #define VK_AMD_GCN_SHADER_SPEC_VERSION    1
6575 #define VK_AMD_GCN_SHADER_EXTENSION_NAME  "VK_AMD_gcn_shader"
6576
6577
6578 #define VK_NV_dedicated_allocation 1
6579 #define VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION 1
6580 #define VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_NV_dedicated_allocation"
6581 typedef struct VkDedicatedAllocationImageCreateInfoNV {
6582     VkStructureType    sType;
6583     const void*        pNext;
6584     VkBool32           dedicatedAllocation;
6585 } VkDedicatedAllocationImageCreateInfoNV;
6586
6587 typedef struct VkDedicatedAllocationBufferCreateInfoNV {
6588     VkStructureType    sType;
6589     const void*        pNext;
6590     VkBool32           dedicatedAllocation;
6591 } VkDedicatedAllocationBufferCreateInfoNV;
6592
6593 typedef struct VkDedicatedAllocationMemoryAllocateInfoNV {
6594     VkStructureType    sType;
6595     const void*        pNext;
6596     VkImage            image;
6597     VkBuffer           buffer;
6598 } VkDedicatedAllocationMemoryAllocateInfoNV;
6599
6600
6601
6602 #define VK_EXT_transform_feedback 1
6603 #define VK_EXT_TRANSFORM_FEEDBACK_SPEC_VERSION 1
6604 #define VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME "VK_EXT_transform_feedback"
6605 typedef VkFlags VkPipelineRasterizationStateStreamCreateFlagsEXT;
6606 typedef struct VkPhysicalDeviceTransformFeedbackFeaturesEXT {
6607     VkStructureType    sType;
6608     void*              pNext;
6609     VkBool32           transformFeedback;
6610     VkBool32           geometryStreams;
6611 } VkPhysicalDeviceTransformFeedbackFeaturesEXT;
6612
6613 typedef struct VkPhysicalDeviceTransformFeedbackPropertiesEXT {
6614     VkStructureType    sType;
6615     void*              pNext;
6616     uint32_t           maxTransformFeedbackStreams;
6617     uint32_t           maxTransformFeedbackBuffers;
6618     VkDeviceSize       maxTransformFeedbackBufferSize;
6619     uint32_t           maxTransformFeedbackStreamDataSize;
6620     uint32_t           maxTransformFeedbackBufferDataSize;
6621     uint32_t           maxTransformFeedbackBufferDataStride;
6622     VkBool32           transformFeedbackQueries;
6623     VkBool32           transformFeedbackStreamsLinesTriangles;
6624     VkBool32           transformFeedbackRasterizationStreamSelect;
6625     VkBool32           transformFeedbackDraw;
6626 } VkPhysicalDeviceTransformFeedbackPropertiesEXT;
6627
6628 typedef struct VkPipelineRasterizationStateStreamCreateInfoEXT {
6629     VkStructureType                                     sType;
6630     const void*                                         pNext;
6631     VkPipelineRasterizationStateStreamCreateFlagsEXT    flags;
6632     uint32_t                                            rasterizationStream;
6633 } VkPipelineRasterizationStateStreamCreateInfoEXT;
6634
6635 typedef void (VKAPI_PTR *PFN_vkCmdBindTransformFeedbackBuffersEXT)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes);
6636 typedef void (VKAPI_PTR *PFN_vkCmdBeginTransformFeedbackEXT)(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets);
6637 typedef void (VKAPI_PTR *PFN_vkCmdEndTransformFeedbackEXT)(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets);
6638 typedef void (VKAPI_PTR *PFN_vkCmdBeginQueryIndexedEXT)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index);
6639 typedef void (VKAPI_PTR *PFN_vkCmdEndQueryIndexedEXT)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index);
6640 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectByteCountEXT)(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride);
6641
6642 #ifndef VK_NO_PROTOTYPES
6643 VKAPI_ATTR void VKAPI_CALL vkCmdBindTransformFeedbackBuffersEXT(
6644     VkCommandBuffer                             commandBuffer,
6645     uint32_t                                    firstBinding,
6646     uint32_t                                    bindingCount,
6647     const VkBuffer*                             pBuffers,
6648     const VkDeviceSize*                         pOffsets,
6649     const VkDeviceSize*                         pSizes);
6650
6651 VKAPI_ATTR void VKAPI_CALL vkCmdBeginTransformFeedbackEXT(
6652     VkCommandBuffer                             commandBuffer,
6653     uint32_t                                    firstCounterBuffer,
6654     uint32_t                                    counterBufferCount,
6655     const VkBuffer*                             pCounterBuffers,
6656     const VkDeviceSize*                         pCounterBufferOffsets);
6657
6658 VKAPI_ATTR void VKAPI_CALL vkCmdEndTransformFeedbackEXT(
6659     VkCommandBuffer                             commandBuffer,
6660     uint32_t                                    firstCounterBuffer,
6661     uint32_t                                    counterBufferCount,
6662     const VkBuffer*                             pCounterBuffers,
6663     const VkDeviceSize*                         pCounterBufferOffsets);
6664
6665 VKAPI_ATTR void VKAPI_CALL vkCmdBeginQueryIndexedEXT(
6666     VkCommandBuffer                             commandBuffer,
6667     VkQueryPool                                 queryPool,
6668     uint32_t                                    query,
6669     VkQueryControlFlags                         flags,
6670     uint32_t                                    index);
6671
6672 VKAPI_ATTR void VKAPI_CALL vkCmdEndQueryIndexedEXT(
6673     VkCommandBuffer                             commandBuffer,
6674     VkQueryPool                                 queryPool,
6675     uint32_t                                    query,
6676     uint32_t                                    index);
6677
6678 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectByteCountEXT(
6679     VkCommandBuffer                             commandBuffer,
6680     uint32_t                                    instanceCount,
6681     uint32_t                                    firstInstance,
6682     VkBuffer                                    counterBuffer,
6683     VkDeviceSize                                counterBufferOffset,
6684     uint32_t                                    counterOffset,
6685     uint32_t                                    vertexStride);
6686 #endif
6687
6688
6689 #define VK_NVX_image_view_handle 1
6690 #define VK_NVX_IMAGE_VIEW_HANDLE_SPEC_VERSION 1
6691 #define VK_NVX_IMAGE_VIEW_HANDLE_EXTENSION_NAME "VK_NVX_image_view_handle"
6692 typedef struct VkImageViewHandleInfoNVX {
6693     VkStructureType     sType;
6694     const void*         pNext;
6695     VkImageView         imageView;
6696     VkDescriptorType    descriptorType;
6697     VkSampler           sampler;
6698 } VkImageViewHandleInfoNVX;
6699
6700 typedef uint32_t (VKAPI_PTR *PFN_vkGetImageViewHandleNVX)(VkDevice device, const VkImageViewHandleInfoNVX* pInfo);
6701
6702 #ifndef VK_NO_PROTOTYPES
6703 VKAPI_ATTR uint32_t VKAPI_CALL vkGetImageViewHandleNVX(
6704     VkDevice                                    device,
6705     const VkImageViewHandleInfoNVX*             pInfo);
6706 #endif
6707
6708
6709 #define VK_AMD_draw_indirect_count 1
6710 #define VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION 1
6711 #define VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_AMD_draw_indirect_count"
6712 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
6713 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
6714
6715 #ifndef VK_NO_PROTOTYPES
6716 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountAMD(
6717     VkCommandBuffer                             commandBuffer,
6718     VkBuffer                                    buffer,
6719     VkDeviceSize                                offset,
6720     VkBuffer                                    countBuffer,
6721     VkDeviceSize                                countBufferOffset,
6722     uint32_t                                    maxDrawCount,
6723     uint32_t                                    stride);
6724
6725 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountAMD(
6726     VkCommandBuffer                             commandBuffer,
6727     VkBuffer                                    buffer,
6728     VkDeviceSize                                offset,
6729     VkBuffer                                    countBuffer,
6730     VkDeviceSize                                countBufferOffset,
6731     uint32_t                                    maxDrawCount,
6732     uint32_t                                    stride);
6733 #endif
6734
6735
6736 #define VK_AMD_negative_viewport_height 1
6737 #define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION 1
6738 #define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME "VK_AMD_negative_viewport_height"
6739
6740
6741 #define VK_AMD_gpu_shader_half_float 1
6742 #define VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION 2
6743 #define VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME "VK_AMD_gpu_shader_half_float"
6744
6745
6746 #define VK_AMD_shader_ballot 1
6747 #define VK_AMD_SHADER_BALLOT_SPEC_VERSION 1
6748 #define VK_AMD_SHADER_BALLOT_EXTENSION_NAME "VK_AMD_shader_ballot"
6749
6750
6751 #define VK_AMD_texture_gather_bias_lod 1
6752 #define VK_AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION 1
6753 #define VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME "VK_AMD_texture_gather_bias_lod"
6754 typedef struct VkTextureLODGatherFormatPropertiesAMD {
6755     VkStructureType    sType;
6756     void*              pNext;
6757     VkBool32           supportsTextureGatherLODBiasAMD;
6758 } VkTextureLODGatherFormatPropertiesAMD;
6759
6760
6761
6762 #define VK_AMD_shader_info 1
6763 #define VK_AMD_SHADER_INFO_SPEC_VERSION   1
6764 #define VK_AMD_SHADER_INFO_EXTENSION_NAME "VK_AMD_shader_info"
6765
6766 typedef enum VkShaderInfoTypeAMD {
6767     VK_SHADER_INFO_TYPE_STATISTICS_AMD = 0,
6768     VK_SHADER_INFO_TYPE_BINARY_AMD = 1,
6769     VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD = 2,
6770     VK_SHADER_INFO_TYPE_BEGIN_RANGE_AMD = VK_SHADER_INFO_TYPE_STATISTICS_AMD,
6771     VK_SHADER_INFO_TYPE_END_RANGE_AMD = VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD,
6772     VK_SHADER_INFO_TYPE_RANGE_SIZE_AMD = (VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD - VK_SHADER_INFO_TYPE_STATISTICS_AMD + 1),
6773     VK_SHADER_INFO_TYPE_MAX_ENUM_AMD = 0x7FFFFFFF
6774 } VkShaderInfoTypeAMD;
6775 typedef struct VkShaderResourceUsageAMD {
6776     uint32_t    numUsedVgprs;
6777     uint32_t    numUsedSgprs;
6778     uint32_t    ldsSizePerLocalWorkGroup;
6779     size_t      ldsUsageSizeInBytes;
6780     size_t      scratchMemUsageInBytes;
6781 } VkShaderResourceUsageAMD;
6782
6783 typedef struct VkShaderStatisticsInfoAMD {
6784     VkShaderStageFlags          shaderStageMask;
6785     VkShaderResourceUsageAMD    resourceUsage;
6786     uint32_t                    numPhysicalVgprs;
6787     uint32_t                    numPhysicalSgprs;
6788     uint32_t                    numAvailableVgprs;
6789     uint32_t                    numAvailableSgprs;
6790     uint32_t                    computeWorkGroupSize[3];
6791 } VkShaderStatisticsInfoAMD;
6792
6793 typedef VkResult (VKAPI_PTR *PFN_vkGetShaderInfoAMD)(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo);
6794
6795 #ifndef VK_NO_PROTOTYPES
6796 VKAPI_ATTR VkResult VKAPI_CALL vkGetShaderInfoAMD(
6797     VkDevice                                    device,
6798     VkPipeline                                  pipeline,
6799     VkShaderStageFlagBits                       shaderStage,
6800     VkShaderInfoTypeAMD                         infoType,
6801     size_t*                                     pInfoSize,
6802     void*                                       pInfo);
6803 #endif
6804
6805
6806 #define VK_AMD_shader_image_load_store_lod 1
6807 #define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION 1
6808 #define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME "VK_AMD_shader_image_load_store_lod"
6809
6810
6811 #define VK_NV_corner_sampled_image 1
6812 #define VK_NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION 2
6813 #define VK_NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME "VK_NV_corner_sampled_image"
6814 typedef struct VkPhysicalDeviceCornerSampledImageFeaturesNV {
6815     VkStructureType    sType;
6816     void*              pNext;
6817     VkBool32           cornerSampledImage;
6818 } VkPhysicalDeviceCornerSampledImageFeaturesNV;
6819
6820
6821
6822 #define VK_IMG_format_pvrtc 1
6823 #define VK_IMG_FORMAT_PVRTC_SPEC_VERSION  1
6824 #define VK_IMG_FORMAT_PVRTC_EXTENSION_NAME "VK_IMG_format_pvrtc"
6825
6826
6827 #define VK_NV_external_memory_capabilities 1
6828 #define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1
6829 #define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_NV_external_memory_capabilities"
6830
6831 typedef enum VkExternalMemoryHandleTypeFlagBitsNV {
6832     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = 0x00000001,
6833     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = 0x00000002,
6834     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = 0x00000004,
6835     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = 0x00000008,
6836     VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
6837 } VkExternalMemoryHandleTypeFlagBitsNV;
6838 typedef VkFlags VkExternalMemoryHandleTypeFlagsNV;
6839
6840 typedef enum VkExternalMemoryFeatureFlagBitsNV {
6841     VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = 0x00000001,
6842     VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = 0x00000002,
6843     VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = 0x00000004,
6844     VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
6845 } VkExternalMemoryFeatureFlagBitsNV;
6846 typedef VkFlags VkExternalMemoryFeatureFlagsNV;
6847 typedef struct VkExternalImageFormatPropertiesNV {
6848     VkImageFormatProperties              imageFormatProperties;
6849     VkExternalMemoryFeatureFlagsNV       externalMemoryFeatures;
6850     VkExternalMemoryHandleTypeFlagsNV    exportFromImportedHandleTypes;
6851     VkExternalMemoryHandleTypeFlagsNV    compatibleHandleTypes;
6852 } VkExternalImageFormatPropertiesNV;
6853
6854 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties);
6855
6856 #ifndef VK_NO_PROTOTYPES
6857 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
6858     VkPhysicalDevice                            physicalDevice,
6859     VkFormat                                    format,
6860     VkImageType                                 type,
6861     VkImageTiling                               tiling,
6862     VkImageUsageFlags                           usage,
6863     VkImageCreateFlags                          flags,
6864     VkExternalMemoryHandleTypeFlagsNV           externalHandleType,
6865     VkExternalImageFormatPropertiesNV*          pExternalImageFormatProperties);
6866 #endif
6867
6868
6869 #define VK_NV_external_memory 1
6870 #define VK_NV_EXTERNAL_MEMORY_SPEC_VERSION 1
6871 #define VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME "VK_NV_external_memory"
6872 typedef struct VkExternalMemoryImageCreateInfoNV {
6873     VkStructureType                      sType;
6874     const void*                          pNext;
6875     VkExternalMemoryHandleTypeFlagsNV    handleTypes;
6876 } VkExternalMemoryImageCreateInfoNV;
6877
6878 typedef struct VkExportMemoryAllocateInfoNV {
6879     VkStructureType                      sType;
6880     const void*                          pNext;
6881     VkExternalMemoryHandleTypeFlagsNV    handleTypes;
6882 } VkExportMemoryAllocateInfoNV;
6883
6884
6885
6886 #define VK_EXT_validation_flags 1
6887 #define VK_EXT_VALIDATION_FLAGS_SPEC_VERSION 1
6888 #define VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME "VK_EXT_validation_flags"
6889
6890 typedef enum VkValidationCheckEXT {
6891     VK_VALIDATION_CHECK_ALL_EXT = 0,
6892     VK_VALIDATION_CHECK_SHADERS_EXT = 1,
6893     VK_VALIDATION_CHECK_BEGIN_RANGE_EXT = VK_VALIDATION_CHECK_ALL_EXT,
6894     VK_VALIDATION_CHECK_END_RANGE_EXT = VK_VALIDATION_CHECK_SHADERS_EXT,
6895     VK_VALIDATION_CHECK_RANGE_SIZE_EXT = (VK_VALIDATION_CHECK_SHADERS_EXT - VK_VALIDATION_CHECK_ALL_EXT + 1),
6896     VK_VALIDATION_CHECK_MAX_ENUM_EXT = 0x7FFFFFFF
6897 } VkValidationCheckEXT;
6898 typedef struct VkValidationFlagsEXT {
6899     VkStructureType                sType;
6900     const void*                    pNext;
6901     uint32_t                       disabledValidationCheckCount;
6902     const VkValidationCheckEXT*    pDisabledValidationChecks;
6903 } VkValidationFlagsEXT;
6904
6905
6906
6907 #define VK_EXT_shader_subgroup_ballot 1
6908 #define VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION 1
6909 #define VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME "VK_EXT_shader_subgroup_ballot"
6910
6911
6912 #define VK_EXT_shader_subgroup_vote 1
6913 #define VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION 1
6914 #define VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME "VK_EXT_shader_subgroup_vote"
6915
6916
6917 #define VK_EXT_texture_compression_astc_hdr 1
6918 #define VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_SPEC_VERSION 1
6919 #define VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME "VK_EXT_texture_compression_astc_hdr"
6920 typedef struct VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT {
6921     VkStructureType    sType;
6922     const void*        pNext;
6923     VkBool32           textureCompressionASTC_HDR;
6924 } VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT;
6925
6926
6927
6928 #define VK_EXT_astc_decode_mode 1
6929 #define VK_EXT_ASTC_DECODE_MODE_SPEC_VERSION 1
6930 #define VK_EXT_ASTC_DECODE_MODE_EXTENSION_NAME "VK_EXT_astc_decode_mode"
6931 typedef struct VkImageViewASTCDecodeModeEXT {
6932     VkStructureType    sType;
6933     const void*        pNext;
6934     VkFormat           decodeMode;
6935 } VkImageViewASTCDecodeModeEXT;
6936
6937 typedef struct VkPhysicalDeviceASTCDecodeFeaturesEXT {
6938     VkStructureType    sType;
6939     void*              pNext;
6940     VkBool32           decodeModeSharedExponent;
6941 } VkPhysicalDeviceASTCDecodeFeaturesEXT;
6942
6943
6944
6945 #define VK_EXT_conditional_rendering 1
6946 #define VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION 1
6947 #define VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME "VK_EXT_conditional_rendering"
6948
6949 typedef enum VkConditionalRenderingFlagBitsEXT {
6950     VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT = 0x00000001,
6951     VK_CONDITIONAL_RENDERING_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
6952 } VkConditionalRenderingFlagBitsEXT;
6953 typedef VkFlags VkConditionalRenderingFlagsEXT;
6954 typedef struct VkConditionalRenderingBeginInfoEXT {
6955     VkStructureType                   sType;
6956     const void*                       pNext;
6957     VkBuffer                          buffer;
6958     VkDeviceSize                      offset;
6959     VkConditionalRenderingFlagsEXT    flags;
6960 } VkConditionalRenderingBeginInfoEXT;
6961
6962 typedef struct VkPhysicalDeviceConditionalRenderingFeaturesEXT {
6963     VkStructureType    sType;
6964     void*              pNext;
6965     VkBool32           conditionalRendering;
6966     VkBool32           inheritedConditionalRendering;
6967 } VkPhysicalDeviceConditionalRenderingFeaturesEXT;
6968
6969 typedef struct VkCommandBufferInheritanceConditionalRenderingInfoEXT {
6970     VkStructureType    sType;
6971     const void*        pNext;
6972     VkBool32           conditionalRenderingEnable;
6973 } VkCommandBufferInheritanceConditionalRenderingInfoEXT;
6974
6975 typedef void (VKAPI_PTR *PFN_vkCmdBeginConditionalRenderingEXT)(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin);
6976 typedef void (VKAPI_PTR *PFN_vkCmdEndConditionalRenderingEXT)(VkCommandBuffer commandBuffer);
6977
6978 #ifndef VK_NO_PROTOTYPES
6979 VKAPI_ATTR void VKAPI_CALL vkCmdBeginConditionalRenderingEXT(
6980     VkCommandBuffer                             commandBuffer,
6981     const VkConditionalRenderingBeginInfoEXT*   pConditionalRenderingBegin);
6982
6983 VKAPI_ATTR void VKAPI_CALL vkCmdEndConditionalRenderingEXT(
6984     VkCommandBuffer                             commandBuffer);
6985 #endif
6986
6987
6988 #define VK_NVX_device_generated_commands 1
6989 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkObjectTableNVX)
6990 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutNVX)
6991 #define VK_NVX_DEVICE_GENERATED_COMMANDS_SPEC_VERSION 3
6992 #define VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME "VK_NVX_device_generated_commands"
6993
6994 typedef enum VkIndirectCommandsTokenTypeNVX {
6995     VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX = 0,
6996     VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX = 1,
6997     VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX = 2,
6998     VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX = 3,
6999     VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX = 4,
7000     VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX = 5,
7001     VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX = 6,
7002     VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX = 7,
7003     VK_INDIRECT_COMMANDS_TOKEN_TYPE_BEGIN_RANGE_NVX = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX,
7004     VK_INDIRECT_COMMANDS_TOKEN_TYPE_END_RANGE_NVX = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX,
7005     VK_INDIRECT_COMMANDS_TOKEN_TYPE_RANGE_SIZE_NVX = (VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX - VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX + 1),
7006     VK_INDIRECT_COMMANDS_TOKEN_TYPE_MAX_ENUM_NVX = 0x7FFFFFFF
7007 } VkIndirectCommandsTokenTypeNVX;
7008
7009 typedef enum VkObjectEntryTypeNVX {
7010     VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX = 0,
7011     VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX = 1,
7012     VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX = 2,
7013     VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX = 3,
7014     VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX = 4,
7015     VK_OBJECT_ENTRY_TYPE_BEGIN_RANGE_NVX = VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX,
7016     VK_OBJECT_ENTRY_TYPE_END_RANGE_NVX = VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX,
7017     VK_OBJECT_ENTRY_TYPE_RANGE_SIZE_NVX = (VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX - VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX + 1),
7018     VK_OBJECT_ENTRY_TYPE_MAX_ENUM_NVX = 0x7FFFFFFF
7019 } VkObjectEntryTypeNVX;
7020
7021 typedef enum VkIndirectCommandsLayoutUsageFlagBitsNVX {
7022     VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX = 0x00000001,
7023     VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX = 0x00000002,
7024     VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX = 0x00000004,
7025     VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX = 0x00000008,
7026     VK_INDIRECT_COMMANDS_LAYOUT_USAGE_FLAG_BITS_MAX_ENUM_NVX = 0x7FFFFFFF
7027 } VkIndirectCommandsLayoutUsageFlagBitsNVX;
7028 typedef VkFlags VkIndirectCommandsLayoutUsageFlagsNVX;
7029
7030 typedef enum VkObjectEntryUsageFlagBitsNVX {
7031     VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX = 0x00000001,
7032     VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX = 0x00000002,
7033     VK_OBJECT_ENTRY_USAGE_FLAG_BITS_MAX_ENUM_NVX = 0x7FFFFFFF
7034 } VkObjectEntryUsageFlagBitsNVX;
7035 typedef VkFlags VkObjectEntryUsageFlagsNVX;
7036 typedef struct VkDeviceGeneratedCommandsFeaturesNVX {
7037     VkStructureType    sType;
7038     const void*        pNext;
7039     VkBool32           computeBindingPointSupport;
7040 } VkDeviceGeneratedCommandsFeaturesNVX;
7041
7042 typedef struct VkDeviceGeneratedCommandsLimitsNVX {
7043     VkStructureType    sType;
7044     const void*        pNext;
7045     uint32_t           maxIndirectCommandsLayoutTokenCount;
7046     uint32_t           maxObjectEntryCounts;
7047     uint32_t           minSequenceCountBufferOffsetAlignment;
7048     uint32_t           minSequenceIndexBufferOffsetAlignment;
7049     uint32_t           minCommandsTokenBufferOffsetAlignment;
7050 } VkDeviceGeneratedCommandsLimitsNVX;
7051
7052 typedef struct VkIndirectCommandsTokenNVX {
7053     VkIndirectCommandsTokenTypeNVX    tokenType;
7054     VkBuffer                          buffer;
7055     VkDeviceSize                      offset;
7056 } VkIndirectCommandsTokenNVX;
7057
7058 typedef struct VkIndirectCommandsLayoutTokenNVX {
7059     VkIndirectCommandsTokenTypeNVX    tokenType;
7060     uint32_t                          bindingUnit;
7061     uint32_t                          dynamicCount;
7062     uint32_t                          divisor;
7063 } VkIndirectCommandsLayoutTokenNVX;
7064
7065 typedef struct VkIndirectCommandsLayoutCreateInfoNVX {
7066     VkStructureType                            sType;
7067     const void*                                pNext;
7068     VkPipelineBindPoint                        pipelineBindPoint;
7069     VkIndirectCommandsLayoutUsageFlagsNVX      flags;
7070     uint32_t                                   tokenCount;
7071     const VkIndirectCommandsLayoutTokenNVX*    pTokens;
7072 } VkIndirectCommandsLayoutCreateInfoNVX;
7073
7074 typedef struct VkCmdProcessCommandsInfoNVX {
7075     VkStructureType                      sType;
7076     const void*                          pNext;
7077     VkObjectTableNVX                     objectTable;
7078     VkIndirectCommandsLayoutNVX          indirectCommandsLayout;
7079     uint32_t                             indirectCommandsTokenCount;
7080     const VkIndirectCommandsTokenNVX*    pIndirectCommandsTokens;
7081     uint32_t                             maxSequencesCount;
7082     VkCommandBuffer                      targetCommandBuffer;
7083     VkBuffer                             sequencesCountBuffer;
7084     VkDeviceSize                         sequencesCountOffset;
7085     VkBuffer                             sequencesIndexBuffer;
7086     VkDeviceSize                         sequencesIndexOffset;
7087 } VkCmdProcessCommandsInfoNVX;
7088
7089 typedef struct VkCmdReserveSpaceForCommandsInfoNVX {
7090     VkStructureType                sType;
7091     const void*                    pNext;
7092     VkObjectTableNVX               objectTable;
7093     VkIndirectCommandsLayoutNVX    indirectCommandsLayout;
7094     uint32_t                       maxSequencesCount;
7095 } VkCmdReserveSpaceForCommandsInfoNVX;
7096
7097 typedef struct VkObjectTableCreateInfoNVX {
7098     VkStructureType                      sType;
7099     const void*                          pNext;
7100     uint32_t                             objectCount;
7101     const VkObjectEntryTypeNVX*          pObjectEntryTypes;
7102     const uint32_t*                      pObjectEntryCounts;
7103     const VkObjectEntryUsageFlagsNVX*    pObjectEntryUsageFlags;
7104     uint32_t                             maxUniformBuffersPerDescriptor;
7105     uint32_t                             maxStorageBuffersPerDescriptor;
7106     uint32_t                             maxStorageImagesPerDescriptor;
7107     uint32_t                             maxSampledImagesPerDescriptor;
7108     uint32_t                             maxPipelineLayouts;
7109 } VkObjectTableCreateInfoNVX;
7110
7111 typedef struct VkObjectTableEntryNVX {
7112     VkObjectEntryTypeNVX          type;
7113     VkObjectEntryUsageFlagsNVX    flags;
7114 } VkObjectTableEntryNVX;
7115
7116 typedef struct VkObjectTablePipelineEntryNVX {
7117     VkObjectEntryTypeNVX          type;
7118     VkObjectEntryUsageFlagsNVX    flags;
7119     VkPipeline                    pipeline;
7120 } VkObjectTablePipelineEntryNVX;
7121
7122 typedef struct VkObjectTableDescriptorSetEntryNVX {
7123     VkObjectEntryTypeNVX          type;
7124     VkObjectEntryUsageFlagsNVX    flags;
7125     VkPipelineLayout              pipelineLayout;
7126     VkDescriptorSet               descriptorSet;
7127 } VkObjectTableDescriptorSetEntryNVX;
7128
7129 typedef struct VkObjectTableVertexBufferEntryNVX {
7130     VkObjectEntryTypeNVX          type;
7131     VkObjectEntryUsageFlagsNVX    flags;
7132     VkBuffer                      buffer;
7133 } VkObjectTableVertexBufferEntryNVX;
7134
7135 typedef struct VkObjectTableIndexBufferEntryNVX {
7136     VkObjectEntryTypeNVX          type;
7137     VkObjectEntryUsageFlagsNVX    flags;
7138     VkBuffer                      buffer;
7139     VkIndexType                   indexType;
7140 } VkObjectTableIndexBufferEntryNVX;
7141
7142 typedef struct VkObjectTablePushConstantEntryNVX {
7143     VkObjectEntryTypeNVX          type;
7144     VkObjectEntryUsageFlagsNVX    flags;
7145     VkPipelineLayout              pipelineLayout;
7146     VkShaderStageFlags            stageFlags;
7147 } VkObjectTablePushConstantEntryNVX;
7148
7149 typedef void (VKAPI_PTR *PFN_vkCmdProcessCommandsNVX)(VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo);
7150 typedef void (VKAPI_PTR *PFN_vkCmdReserveSpaceForCommandsNVX)(VkCommandBuffer commandBuffer, const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo);
7151 typedef VkResult (VKAPI_PTR *PFN_vkCreateIndirectCommandsLayoutNVX)(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout);
7152 typedef void (VKAPI_PTR *PFN_vkDestroyIndirectCommandsLayoutNVX)(VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout, const VkAllocationCallbacks* pAllocator);
7153 typedef VkResult (VKAPI_PTR *PFN_vkCreateObjectTableNVX)(VkDevice device, const VkObjectTableCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkObjectTableNVX* pObjectTable);
7154 typedef void (VKAPI_PTR *PFN_vkDestroyObjectTableNVX)(VkDevice device, VkObjectTableNVX objectTable, const VkAllocationCallbacks* pAllocator);
7155 typedef VkResult (VKAPI_PTR *PFN_vkRegisterObjectsNVX)(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectTableEntryNVX* const*    ppObjectTableEntries, const uint32_t* pObjectIndices);
7156 typedef VkResult (VKAPI_PTR *PFN_vkUnregisterObjectsNVX)(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices);
7157 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX)(VkPhysicalDevice physicalDevice, VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, VkDeviceGeneratedCommandsLimitsNVX* pLimits);
7158
7159 #ifndef VK_NO_PROTOTYPES
7160 VKAPI_ATTR void VKAPI_CALL vkCmdProcessCommandsNVX(
7161     VkCommandBuffer                             commandBuffer,
7162     const VkCmdProcessCommandsInfoNVX*          pProcessCommandsInfo);
7163
7164 VKAPI_ATTR void VKAPI_CALL vkCmdReserveSpaceForCommandsNVX(
7165     VkCommandBuffer                             commandBuffer,
7166     const VkCmdReserveSpaceForCommandsInfoNVX*  pReserveSpaceInfo);
7167
7168 VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutNVX(
7169     VkDevice                                    device,
7170     const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
7171     const VkAllocationCallbacks*                pAllocator,
7172     VkIndirectCommandsLayoutNVX*                pIndirectCommandsLayout);
7173
7174 VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectCommandsLayoutNVX(
7175     VkDevice                                    device,
7176     VkIndirectCommandsLayoutNVX                 indirectCommandsLayout,
7177     const VkAllocationCallbacks*                pAllocator);
7178
7179 VKAPI_ATTR VkResult VKAPI_CALL vkCreateObjectTableNVX(
7180     VkDevice                                    device,
7181     const VkObjectTableCreateInfoNVX*           pCreateInfo,
7182     const VkAllocationCallbacks*                pAllocator,
7183     VkObjectTableNVX*                           pObjectTable);
7184
7185 VKAPI_ATTR void VKAPI_CALL vkDestroyObjectTableNVX(
7186     VkDevice                                    device,
7187     VkObjectTableNVX                            objectTable,
7188     const VkAllocationCallbacks*                pAllocator);
7189
7190 VKAPI_ATTR VkResult VKAPI_CALL vkRegisterObjectsNVX(
7191     VkDevice                                    device,
7192     VkObjectTableNVX                            objectTable,
7193     uint32_t                                    objectCount,
7194     const VkObjectTableEntryNVX* const*         ppObjectTableEntries,
7195     const uint32_t*                             pObjectIndices);
7196
7197 VKAPI_ATTR VkResult VKAPI_CALL vkUnregisterObjectsNVX(
7198     VkDevice                                    device,
7199     VkObjectTableNVX                            objectTable,
7200     uint32_t                                    objectCount,
7201     const VkObjectEntryTypeNVX*                 pObjectEntryTypes,
7202     const uint32_t*                             pObjectIndices);
7203
7204 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
7205     VkPhysicalDevice                            physicalDevice,
7206     VkDeviceGeneratedCommandsFeaturesNVX*       pFeatures,
7207     VkDeviceGeneratedCommandsLimitsNVX*         pLimits);
7208 #endif
7209
7210
7211 #define VK_NV_clip_space_w_scaling 1
7212 #define VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION 1
7213 #define VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME "VK_NV_clip_space_w_scaling"
7214 typedef struct VkViewportWScalingNV {
7215     float    xcoeff;
7216     float    ycoeff;
7217 } VkViewportWScalingNV;
7218
7219 typedef struct VkPipelineViewportWScalingStateCreateInfoNV {
7220     VkStructureType                sType;
7221     const void*                    pNext;
7222     VkBool32                       viewportWScalingEnable;
7223     uint32_t                       viewportCount;
7224     const VkViewportWScalingNV*    pViewportWScalings;
7225 } VkPipelineViewportWScalingStateCreateInfoNV;
7226
7227 typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWScalingNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings);
7228
7229 #ifndef VK_NO_PROTOTYPES
7230 VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingNV(
7231     VkCommandBuffer                             commandBuffer,
7232     uint32_t                                    firstViewport,
7233     uint32_t                                    viewportCount,
7234     const VkViewportWScalingNV*                 pViewportWScalings);
7235 #endif
7236
7237
7238 #define VK_EXT_direct_mode_display 1
7239 #define VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION 1
7240 #define VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME "VK_EXT_direct_mode_display"
7241 typedef VkResult (VKAPI_PTR *PFN_vkReleaseDisplayEXT)(VkPhysicalDevice physicalDevice, VkDisplayKHR display);
7242
7243 #ifndef VK_NO_PROTOTYPES
7244 VKAPI_ATTR VkResult VKAPI_CALL vkReleaseDisplayEXT(
7245     VkPhysicalDevice                            physicalDevice,
7246     VkDisplayKHR                                display);
7247 #endif
7248
7249
7250 #define VK_EXT_display_surface_counter 1
7251 #define VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION 1
7252 #define VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME "VK_EXT_display_surface_counter"
7253
7254 typedef enum VkSurfaceCounterFlagBitsEXT {
7255     VK_SURFACE_COUNTER_VBLANK_EXT = 0x00000001,
7256     VK_SURFACE_COUNTER_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
7257 } VkSurfaceCounterFlagBitsEXT;
7258 typedef VkFlags VkSurfaceCounterFlagsEXT;
7259 typedef struct VkSurfaceCapabilities2EXT {
7260     VkStructureType                  sType;
7261     void*                            pNext;
7262     uint32_t                         minImageCount;
7263     uint32_t                         maxImageCount;
7264     VkExtent2D                       currentExtent;
7265     VkExtent2D                       minImageExtent;
7266     VkExtent2D                       maxImageExtent;
7267     uint32_t                         maxImageArrayLayers;
7268     VkSurfaceTransformFlagsKHR       supportedTransforms;
7269     VkSurfaceTransformFlagBitsKHR    currentTransform;
7270     VkCompositeAlphaFlagsKHR         supportedCompositeAlpha;
7271     VkImageUsageFlags                supportedUsageFlags;
7272     VkSurfaceCounterFlagsEXT         supportedSurfaceCounters;
7273 } VkSurfaceCapabilities2EXT;
7274
7275 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities);
7276
7277 #ifndef VK_NO_PROTOTYPES
7278 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2EXT(
7279     VkPhysicalDevice                            physicalDevice,
7280     VkSurfaceKHR                                surface,
7281     VkSurfaceCapabilities2EXT*                  pSurfaceCapabilities);
7282 #endif
7283
7284
7285 #define VK_EXT_display_control 1
7286 #define VK_EXT_DISPLAY_CONTROL_SPEC_VERSION 1
7287 #define VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME "VK_EXT_display_control"
7288
7289 typedef enum VkDisplayPowerStateEXT {
7290     VK_DISPLAY_POWER_STATE_OFF_EXT = 0,
7291     VK_DISPLAY_POWER_STATE_SUSPEND_EXT = 1,
7292     VK_DISPLAY_POWER_STATE_ON_EXT = 2,
7293     VK_DISPLAY_POWER_STATE_BEGIN_RANGE_EXT = VK_DISPLAY_POWER_STATE_OFF_EXT,
7294     VK_DISPLAY_POWER_STATE_END_RANGE_EXT = VK_DISPLAY_POWER_STATE_ON_EXT,
7295     VK_DISPLAY_POWER_STATE_RANGE_SIZE_EXT = (VK_DISPLAY_POWER_STATE_ON_EXT - VK_DISPLAY_POWER_STATE_OFF_EXT + 1),
7296     VK_DISPLAY_POWER_STATE_MAX_ENUM_EXT = 0x7FFFFFFF
7297 } VkDisplayPowerStateEXT;
7298
7299 typedef enum VkDeviceEventTypeEXT {
7300     VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT = 0,
7301     VK_DEVICE_EVENT_TYPE_BEGIN_RANGE_EXT = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT,
7302     VK_DEVICE_EVENT_TYPE_END_RANGE_EXT = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT,
7303     VK_DEVICE_EVENT_TYPE_RANGE_SIZE_EXT = (VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT - VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT + 1),
7304     VK_DEVICE_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
7305 } VkDeviceEventTypeEXT;
7306
7307 typedef enum VkDisplayEventTypeEXT {
7308     VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT = 0,
7309     VK_DISPLAY_EVENT_TYPE_BEGIN_RANGE_EXT = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT,
7310     VK_DISPLAY_EVENT_TYPE_END_RANGE_EXT = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT,
7311     VK_DISPLAY_EVENT_TYPE_RANGE_SIZE_EXT = (VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT - VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT + 1),
7312     VK_DISPLAY_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
7313 } VkDisplayEventTypeEXT;
7314 typedef struct VkDisplayPowerInfoEXT {
7315     VkStructureType           sType;
7316     const void*               pNext;
7317     VkDisplayPowerStateEXT    powerState;
7318 } VkDisplayPowerInfoEXT;
7319
7320 typedef struct VkDeviceEventInfoEXT {
7321     VkStructureType         sType;
7322     const void*             pNext;
7323     VkDeviceEventTypeEXT    deviceEvent;
7324 } VkDeviceEventInfoEXT;
7325
7326 typedef struct VkDisplayEventInfoEXT {
7327     VkStructureType          sType;
7328     const void*              pNext;
7329     VkDisplayEventTypeEXT    displayEvent;
7330 } VkDisplayEventInfoEXT;
7331
7332 typedef struct VkSwapchainCounterCreateInfoEXT {
7333     VkStructureType             sType;
7334     const void*                 pNext;
7335     VkSurfaceCounterFlagsEXT    surfaceCounters;
7336 } VkSwapchainCounterCreateInfoEXT;
7337
7338 typedef VkResult (VKAPI_PTR *PFN_vkDisplayPowerControlEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo);
7339 typedef VkResult (VKAPI_PTR *PFN_vkRegisterDeviceEventEXT)(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
7340 typedef VkResult (VKAPI_PTR *PFN_vkRegisterDisplayEventEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
7341 typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainCounterEXT)(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue);
7342
7343 #ifndef VK_NO_PROTOTYPES
7344 VKAPI_ATTR VkResult VKAPI_CALL vkDisplayPowerControlEXT(
7345     VkDevice                                    device,
7346     VkDisplayKHR                                display,
7347     const VkDisplayPowerInfoEXT*                pDisplayPowerInfo);
7348
7349 VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDeviceEventEXT(
7350     VkDevice                                    device,
7351     const VkDeviceEventInfoEXT*                 pDeviceEventInfo,
7352     const VkAllocationCallbacks*                pAllocator,
7353     VkFence*                                    pFence);
7354
7355 VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDisplayEventEXT(
7356     VkDevice                                    device,
7357     VkDisplayKHR                                display,
7358     const VkDisplayEventInfoEXT*                pDisplayEventInfo,
7359     const VkAllocationCallbacks*                pAllocator,
7360     VkFence*                                    pFence);
7361
7362 VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainCounterEXT(
7363     VkDevice                                    device,
7364     VkSwapchainKHR                              swapchain,
7365     VkSurfaceCounterFlagBitsEXT                 counter,
7366     uint64_t*                                   pCounterValue);
7367 #endif
7368
7369
7370 #define VK_GOOGLE_display_timing 1
7371 #define VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION 1
7372 #define VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME "VK_GOOGLE_display_timing"
7373 typedef struct VkRefreshCycleDurationGOOGLE {
7374     uint64_t    refreshDuration;
7375 } VkRefreshCycleDurationGOOGLE;
7376
7377 typedef struct VkPastPresentationTimingGOOGLE {
7378     uint32_t    presentID;
7379     uint64_t    desiredPresentTime;
7380     uint64_t    actualPresentTime;
7381     uint64_t    earliestPresentTime;
7382     uint64_t    presentMargin;
7383 } VkPastPresentationTimingGOOGLE;
7384
7385 typedef struct VkPresentTimeGOOGLE {
7386     uint32_t    presentID;
7387     uint64_t    desiredPresentTime;
7388 } VkPresentTimeGOOGLE;
7389
7390 typedef struct VkPresentTimesInfoGOOGLE {
7391     VkStructureType               sType;
7392     const void*                   pNext;
7393     uint32_t                      swapchainCount;
7394     const VkPresentTimeGOOGLE*    pTimes;
7395 } VkPresentTimesInfoGOOGLE;
7396
7397 typedef VkResult (VKAPI_PTR *PFN_vkGetRefreshCycleDurationGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties);
7398 typedef VkResult (VKAPI_PTR *PFN_vkGetPastPresentationTimingGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings);
7399
7400 #ifndef VK_NO_PROTOTYPES
7401 VKAPI_ATTR VkResult VKAPI_CALL vkGetRefreshCycleDurationGOOGLE(
7402     VkDevice                                    device,
7403     VkSwapchainKHR                              swapchain,
7404     VkRefreshCycleDurationGOOGLE*               pDisplayTimingProperties);
7405
7406 VKAPI_ATTR VkResult VKAPI_CALL vkGetPastPresentationTimingGOOGLE(
7407     VkDevice                                    device,
7408     VkSwapchainKHR                              swapchain,
7409     uint32_t*                                   pPresentationTimingCount,
7410     VkPastPresentationTimingGOOGLE*             pPresentationTimings);
7411 #endif
7412
7413
7414 #define VK_NV_sample_mask_override_coverage 1
7415 #define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION 1
7416 #define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME "VK_NV_sample_mask_override_coverage"
7417
7418
7419 #define VK_NV_geometry_shader_passthrough 1
7420 #define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION 1
7421 #define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME "VK_NV_geometry_shader_passthrough"
7422
7423
7424 #define VK_NV_viewport_array2 1
7425 #define VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION 1
7426 #define VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME "VK_NV_viewport_array2"
7427
7428
7429 #define VK_NVX_multiview_per_view_attributes 1
7430 #define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION 1
7431 #define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME "VK_NVX_multiview_per_view_attributes"
7432 typedef struct VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
7433     VkStructureType    sType;
7434     void*              pNext;
7435     VkBool32           perViewPositionAllComponents;
7436 } VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
7437
7438
7439
7440 #define VK_NV_viewport_swizzle 1
7441 #define VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION 1
7442 #define VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME "VK_NV_viewport_swizzle"
7443
7444 typedef enum VkViewportCoordinateSwizzleNV {
7445     VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV = 0,
7446     VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV = 1,
7447     VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV = 2,
7448     VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV = 3,
7449     VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV = 4,
7450     VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV = 5,
7451     VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV = 6,
7452     VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV = 7,
7453     VK_VIEWPORT_COORDINATE_SWIZZLE_BEGIN_RANGE_NV = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV,
7454     VK_VIEWPORT_COORDINATE_SWIZZLE_END_RANGE_NV = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV,
7455     VK_VIEWPORT_COORDINATE_SWIZZLE_RANGE_SIZE_NV = (VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV - VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV + 1),
7456     VK_VIEWPORT_COORDINATE_SWIZZLE_MAX_ENUM_NV = 0x7FFFFFFF
7457 } VkViewportCoordinateSwizzleNV;
7458 typedef VkFlags VkPipelineViewportSwizzleStateCreateFlagsNV;
7459 typedef struct VkViewportSwizzleNV {
7460     VkViewportCoordinateSwizzleNV    x;
7461     VkViewportCoordinateSwizzleNV    y;
7462     VkViewportCoordinateSwizzleNV    z;
7463     VkViewportCoordinateSwizzleNV    w;
7464 } VkViewportSwizzleNV;
7465
7466 typedef struct VkPipelineViewportSwizzleStateCreateInfoNV {
7467     VkStructureType                                sType;
7468     const void*                                    pNext;
7469     VkPipelineViewportSwizzleStateCreateFlagsNV    flags;
7470     uint32_t                                       viewportCount;
7471     const VkViewportSwizzleNV*                     pViewportSwizzles;
7472 } VkPipelineViewportSwizzleStateCreateInfoNV;
7473
7474
7475
7476 #define VK_EXT_discard_rectangles 1
7477 #define VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION 1
7478 #define VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME "VK_EXT_discard_rectangles"
7479
7480 typedef enum VkDiscardRectangleModeEXT {
7481     VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = 0,
7482     VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = 1,
7483     VK_DISCARD_RECTANGLE_MODE_BEGIN_RANGE_EXT = VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT,
7484     VK_DISCARD_RECTANGLE_MODE_END_RANGE_EXT = VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT,
7485     VK_DISCARD_RECTANGLE_MODE_RANGE_SIZE_EXT = (VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT - VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT + 1),
7486     VK_DISCARD_RECTANGLE_MODE_MAX_ENUM_EXT = 0x7FFFFFFF
7487 } VkDiscardRectangleModeEXT;
7488 typedef VkFlags VkPipelineDiscardRectangleStateCreateFlagsEXT;
7489 typedef struct VkPhysicalDeviceDiscardRectanglePropertiesEXT {
7490     VkStructureType    sType;
7491     void*              pNext;
7492     uint32_t           maxDiscardRectangles;
7493 } VkPhysicalDeviceDiscardRectanglePropertiesEXT;
7494
7495 typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT {
7496     VkStructureType                                  sType;
7497     const void*                                      pNext;
7498     VkPipelineDiscardRectangleStateCreateFlagsEXT    flags;
7499     VkDiscardRectangleModeEXT                        discardRectangleMode;
7500     uint32_t                                         discardRectangleCount;
7501     const VkRect2D*                                  pDiscardRectangles;
7502 } VkPipelineDiscardRectangleStateCreateInfoEXT;
7503
7504 typedef void (VKAPI_PTR *PFN_vkCmdSetDiscardRectangleEXT)(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles);
7505
7506 #ifndef VK_NO_PROTOTYPES
7507 VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEXT(
7508     VkCommandBuffer                             commandBuffer,
7509     uint32_t                                    firstDiscardRectangle,
7510     uint32_t                                    discardRectangleCount,
7511     const VkRect2D*                             pDiscardRectangles);
7512 #endif
7513
7514
7515 #define VK_EXT_conservative_rasterization 1
7516 #define VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION 1
7517 #define VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME "VK_EXT_conservative_rasterization"
7518
7519 typedef enum VkConservativeRasterizationModeEXT {
7520     VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT = 0,
7521     VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT = 1,
7522     VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT = 2,
7523     VK_CONSERVATIVE_RASTERIZATION_MODE_BEGIN_RANGE_EXT = VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT,
7524     VK_CONSERVATIVE_RASTERIZATION_MODE_END_RANGE_EXT = VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT,
7525     VK_CONSERVATIVE_RASTERIZATION_MODE_RANGE_SIZE_EXT = (VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT - VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT + 1),
7526     VK_CONSERVATIVE_RASTERIZATION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF
7527 } VkConservativeRasterizationModeEXT;
7528 typedef VkFlags VkPipelineRasterizationConservativeStateCreateFlagsEXT;
7529 typedef struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT {
7530     VkStructureType    sType;
7531     void*              pNext;
7532     float              primitiveOverestimationSize;
7533     float              maxExtraPrimitiveOverestimationSize;
7534     float              extraPrimitiveOverestimationSizeGranularity;
7535     VkBool32           primitiveUnderestimation;
7536     VkBool32           conservativePointAndLineRasterization;
7537     VkBool32           degenerateTrianglesRasterized;
7538     VkBool32           degenerateLinesRasterized;
7539     VkBool32           fullyCoveredFragmentShaderInputVariable;
7540     VkBool32           conservativeRasterizationPostDepthCoverage;
7541 } VkPhysicalDeviceConservativeRasterizationPropertiesEXT;
7542
7543 typedef struct VkPipelineRasterizationConservativeStateCreateInfoEXT {
7544     VkStructureType                                           sType;
7545     const void*                                               pNext;
7546     VkPipelineRasterizationConservativeStateCreateFlagsEXT    flags;
7547     VkConservativeRasterizationModeEXT                        conservativeRasterizationMode;
7548     float                                                     extraPrimitiveOverestimationSize;
7549 } VkPipelineRasterizationConservativeStateCreateInfoEXT;
7550
7551
7552
7553 #define VK_EXT_depth_clip_enable 1
7554 #define VK_EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION 1
7555 #define VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME "VK_EXT_depth_clip_enable"
7556 typedef VkFlags VkPipelineRasterizationDepthClipStateCreateFlagsEXT;
7557 typedef struct VkPhysicalDeviceDepthClipEnableFeaturesEXT {
7558     VkStructureType    sType;
7559     void*              pNext;
7560     VkBool32           depthClipEnable;
7561 } VkPhysicalDeviceDepthClipEnableFeaturesEXT;
7562
7563 typedef struct VkPipelineRasterizationDepthClipStateCreateInfoEXT {
7564     VkStructureType                                        sType;
7565     const void*                                            pNext;
7566     VkPipelineRasterizationDepthClipStateCreateFlagsEXT    flags;
7567     VkBool32                                               depthClipEnable;
7568 } VkPipelineRasterizationDepthClipStateCreateInfoEXT;
7569
7570
7571
7572 #define VK_EXT_swapchain_colorspace 1
7573 #define VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION 4
7574 #define VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME "VK_EXT_swapchain_colorspace"
7575
7576
7577 #define VK_EXT_hdr_metadata 1
7578 #define VK_EXT_HDR_METADATA_SPEC_VERSION  1
7579 #define VK_EXT_HDR_METADATA_EXTENSION_NAME "VK_EXT_hdr_metadata"
7580 typedef struct VkXYColorEXT {
7581     float    x;
7582     float    y;
7583 } VkXYColorEXT;
7584
7585 typedef struct VkHdrMetadataEXT {
7586     VkStructureType    sType;
7587     const void*        pNext;
7588     VkXYColorEXT       displayPrimaryRed;
7589     VkXYColorEXT       displayPrimaryGreen;
7590     VkXYColorEXT       displayPrimaryBlue;
7591     VkXYColorEXT       whitePoint;
7592     float              maxLuminance;
7593     float              minLuminance;
7594     float              maxContentLightLevel;
7595     float              maxFrameAverageLightLevel;
7596 } VkHdrMetadataEXT;
7597
7598 typedef void (VKAPI_PTR *PFN_vkSetHdrMetadataEXT)(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata);
7599
7600 #ifndef VK_NO_PROTOTYPES
7601 VKAPI_ATTR void VKAPI_CALL vkSetHdrMetadataEXT(
7602     VkDevice                                    device,
7603     uint32_t                                    swapchainCount,
7604     const VkSwapchainKHR*                       pSwapchains,
7605     const VkHdrMetadataEXT*                     pMetadata);
7606 #endif
7607
7608
7609 #define VK_EXT_external_memory_dma_buf 1
7610 #define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION 1
7611 #define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME "VK_EXT_external_memory_dma_buf"
7612
7613
7614 #define VK_EXT_queue_family_foreign 1
7615 #define VK_EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION 1
7616 #define VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME "VK_EXT_queue_family_foreign"
7617 #define VK_QUEUE_FAMILY_FOREIGN_EXT       (~0U-2)
7618
7619
7620 #define VK_EXT_debug_utils 1
7621 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugUtilsMessengerEXT)
7622 #define VK_EXT_DEBUG_UTILS_SPEC_VERSION   1
7623 #define VK_EXT_DEBUG_UTILS_EXTENSION_NAME "VK_EXT_debug_utils"
7624 typedef VkFlags VkDebugUtilsMessengerCallbackDataFlagsEXT;
7625 typedef VkFlags VkDebugUtilsMessengerCreateFlagsEXT;
7626
7627 typedef enum VkDebugUtilsMessageSeverityFlagBitsEXT {
7628     VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT = 0x00000001,
7629     VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT = 0x00000010,
7630     VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT = 0x00000100,
7631     VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT = 0x00001000,
7632     VK_DEBUG_UTILS_MESSAGE_SEVERITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
7633 } VkDebugUtilsMessageSeverityFlagBitsEXT;
7634 typedef VkFlags VkDebugUtilsMessageSeverityFlagsEXT;
7635
7636 typedef enum VkDebugUtilsMessageTypeFlagBitsEXT {
7637     VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT = 0x00000001,
7638     VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT = 0x00000002,
7639     VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT = 0x00000004,
7640     VK_DEBUG_UTILS_MESSAGE_TYPE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
7641 } VkDebugUtilsMessageTypeFlagBitsEXT;
7642 typedef VkFlags VkDebugUtilsMessageTypeFlagsEXT;
7643 typedef struct VkDebugUtilsObjectNameInfoEXT {
7644     VkStructureType    sType;
7645     const void*        pNext;
7646     VkObjectType       objectType;
7647     uint64_t           objectHandle;
7648     const char*        pObjectName;
7649 } VkDebugUtilsObjectNameInfoEXT;
7650
7651 typedef struct VkDebugUtilsObjectTagInfoEXT {
7652     VkStructureType    sType;
7653     const void*        pNext;
7654     VkObjectType       objectType;
7655     uint64_t           objectHandle;
7656     uint64_t           tagName;
7657     size_t             tagSize;
7658     const void*        pTag;
7659 } VkDebugUtilsObjectTagInfoEXT;
7660
7661 typedef struct VkDebugUtilsLabelEXT {
7662     VkStructureType    sType;
7663     const void*        pNext;
7664     const char*        pLabelName;
7665     float              color[4];
7666 } VkDebugUtilsLabelEXT;
7667
7668 typedef struct VkDebugUtilsMessengerCallbackDataEXT {
7669     VkStructureType                              sType;
7670     const void*                                  pNext;
7671     VkDebugUtilsMessengerCallbackDataFlagsEXT    flags;
7672     const char*                                  pMessageIdName;
7673     int32_t                                      messageIdNumber;
7674     const char*                                  pMessage;
7675     uint32_t                                     queueLabelCount;
7676     const VkDebugUtilsLabelEXT*                  pQueueLabels;
7677     uint32_t                                     cmdBufLabelCount;
7678     const VkDebugUtilsLabelEXT*                  pCmdBufLabels;
7679     uint32_t                                     objectCount;
7680     const VkDebugUtilsObjectNameInfoEXT*         pObjects;
7681 } VkDebugUtilsMessengerCallbackDataEXT;
7682
7683 typedef VkBool32 (VKAPI_PTR *PFN_vkDebugUtilsMessengerCallbackEXT)(
7684     VkDebugUtilsMessageSeverityFlagBitsEXT           messageSeverity,
7685     VkDebugUtilsMessageTypeFlagsEXT                  messageTypes,
7686     const VkDebugUtilsMessengerCallbackDataEXT*      pCallbackData,
7687     void*                                            pUserData);
7688
7689 typedef struct VkDebugUtilsMessengerCreateInfoEXT {
7690     VkStructureType                         sType;
7691     const void*                             pNext;
7692     VkDebugUtilsMessengerCreateFlagsEXT     flags;
7693     VkDebugUtilsMessageSeverityFlagsEXT     messageSeverity;
7694     VkDebugUtilsMessageTypeFlagsEXT         messageType;
7695     PFN_vkDebugUtilsMessengerCallbackEXT    pfnUserCallback;
7696     void*                                   pUserData;
7697 } VkDebugUtilsMessengerCreateInfoEXT;
7698
7699 typedef VkResult (VKAPI_PTR *PFN_vkSetDebugUtilsObjectNameEXT)(VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo);
7700 typedef VkResult (VKAPI_PTR *PFN_vkSetDebugUtilsObjectTagEXT)(VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo);
7701 typedef void (VKAPI_PTR *PFN_vkQueueBeginDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo);
7702 typedef void (VKAPI_PTR *PFN_vkQueueEndDebugUtilsLabelEXT)(VkQueue queue);
7703 typedef void (VKAPI_PTR *PFN_vkQueueInsertDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo);
7704 typedef void (VKAPI_PTR *PFN_vkCmdBeginDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo);
7705 typedef void (VKAPI_PTR *PFN_vkCmdEndDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer);
7706 typedef void (VKAPI_PTR *PFN_vkCmdInsertDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo);
7707 typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugUtilsMessengerEXT)(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger);
7708 typedef void (VKAPI_PTR *PFN_vkDestroyDebugUtilsMessengerEXT)(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator);
7709 typedef void (VKAPI_PTR *PFN_vkSubmitDebugUtilsMessageEXT)(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData);
7710
7711 #ifndef VK_NO_PROTOTYPES
7712 VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectNameEXT(
7713     VkDevice                                    device,
7714     const VkDebugUtilsObjectNameInfoEXT*        pNameInfo);
7715
7716 VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectTagEXT(
7717     VkDevice                                    device,
7718     const VkDebugUtilsObjectTagInfoEXT*         pTagInfo);
7719
7720 VKAPI_ATTR void VKAPI_CALL vkQueueBeginDebugUtilsLabelEXT(
7721     VkQueue                                     queue,
7722     const VkDebugUtilsLabelEXT*                 pLabelInfo);
7723
7724 VKAPI_ATTR void VKAPI_CALL vkQueueEndDebugUtilsLabelEXT(
7725     VkQueue                                     queue);
7726
7727 VKAPI_ATTR void VKAPI_CALL vkQueueInsertDebugUtilsLabelEXT(
7728     VkQueue                                     queue,
7729     const VkDebugUtilsLabelEXT*                 pLabelInfo);
7730
7731 VKAPI_ATTR void VKAPI_CALL vkCmdBeginDebugUtilsLabelEXT(
7732     VkCommandBuffer                             commandBuffer,
7733     const VkDebugUtilsLabelEXT*                 pLabelInfo);
7734
7735 VKAPI_ATTR void VKAPI_CALL vkCmdEndDebugUtilsLabelEXT(
7736     VkCommandBuffer                             commandBuffer);
7737
7738 VKAPI_ATTR void VKAPI_CALL vkCmdInsertDebugUtilsLabelEXT(
7739     VkCommandBuffer                             commandBuffer,
7740     const VkDebugUtilsLabelEXT*                 pLabelInfo);
7741
7742 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugUtilsMessengerEXT(
7743     VkInstance                                  instance,
7744     const VkDebugUtilsMessengerCreateInfoEXT*   pCreateInfo,
7745     const VkAllocationCallbacks*                pAllocator,
7746     VkDebugUtilsMessengerEXT*                   pMessenger);
7747
7748 VKAPI_ATTR void VKAPI_CALL vkDestroyDebugUtilsMessengerEXT(
7749     VkInstance                                  instance,
7750     VkDebugUtilsMessengerEXT                    messenger,
7751     const VkAllocationCallbacks*                pAllocator);
7752
7753 VKAPI_ATTR void VKAPI_CALL vkSubmitDebugUtilsMessageEXT(
7754     VkInstance                                  instance,
7755     VkDebugUtilsMessageSeverityFlagBitsEXT      messageSeverity,
7756     VkDebugUtilsMessageTypeFlagsEXT             messageTypes,
7757     const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData);
7758 #endif
7759
7760
7761 #define VK_EXT_sampler_filter_minmax 1
7762 #define VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION 1
7763 #define VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME "VK_EXT_sampler_filter_minmax"
7764
7765 typedef enum VkSamplerReductionModeEXT {
7766     VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT = 0,
7767     VK_SAMPLER_REDUCTION_MODE_MIN_EXT = 1,
7768     VK_SAMPLER_REDUCTION_MODE_MAX_EXT = 2,
7769     VK_SAMPLER_REDUCTION_MODE_BEGIN_RANGE_EXT = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT,
7770     VK_SAMPLER_REDUCTION_MODE_END_RANGE_EXT = VK_SAMPLER_REDUCTION_MODE_MAX_EXT,
7771     VK_SAMPLER_REDUCTION_MODE_RANGE_SIZE_EXT = (VK_SAMPLER_REDUCTION_MODE_MAX_EXT - VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT + 1),
7772     VK_SAMPLER_REDUCTION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF
7773 } VkSamplerReductionModeEXT;
7774 typedef struct VkSamplerReductionModeCreateInfoEXT {
7775     VkStructureType              sType;
7776     const void*                  pNext;
7777     VkSamplerReductionModeEXT    reductionMode;
7778 } VkSamplerReductionModeCreateInfoEXT;
7779
7780 typedef struct VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT {
7781     VkStructureType    sType;
7782     void*              pNext;
7783     VkBool32           filterMinmaxSingleComponentFormats;
7784     VkBool32           filterMinmaxImageComponentMapping;
7785 } VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT;
7786
7787
7788
7789 #define VK_AMD_gpu_shader_int16 1
7790 #define VK_AMD_GPU_SHADER_INT16_SPEC_VERSION 2
7791 #define VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME "VK_AMD_gpu_shader_int16"
7792
7793
7794 #define VK_AMD_mixed_attachment_samples 1
7795 #define VK_AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION 1
7796 #define VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME "VK_AMD_mixed_attachment_samples"
7797
7798
7799 #define VK_AMD_shader_fragment_mask 1
7800 #define VK_AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION 1
7801 #define VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME "VK_AMD_shader_fragment_mask"
7802
7803
7804 #define VK_EXT_inline_uniform_block 1
7805 #define VK_EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION 1
7806 #define VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME "VK_EXT_inline_uniform_block"
7807 typedef struct VkPhysicalDeviceInlineUniformBlockFeaturesEXT {
7808     VkStructureType    sType;
7809     void*              pNext;
7810     VkBool32           inlineUniformBlock;
7811     VkBool32           descriptorBindingInlineUniformBlockUpdateAfterBind;
7812 } VkPhysicalDeviceInlineUniformBlockFeaturesEXT;
7813
7814 typedef struct VkPhysicalDeviceInlineUniformBlockPropertiesEXT {
7815     VkStructureType    sType;
7816     void*              pNext;
7817     uint32_t           maxInlineUniformBlockSize;
7818     uint32_t           maxPerStageDescriptorInlineUniformBlocks;
7819     uint32_t           maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
7820     uint32_t           maxDescriptorSetInlineUniformBlocks;
7821     uint32_t           maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
7822 } VkPhysicalDeviceInlineUniformBlockPropertiesEXT;
7823
7824 typedef struct VkWriteDescriptorSetInlineUniformBlockEXT {
7825     VkStructureType    sType;
7826     const void*        pNext;
7827     uint32_t           dataSize;
7828     const void*        pData;
7829 } VkWriteDescriptorSetInlineUniformBlockEXT;
7830
7831 typedef struct VkDescriptorPoolInlineUniformBlockCreateInfoEXT {
7832     VkStructureType    sType;
7833     const void*        pNext;
7834     uint32_t           maxInlineUniformBlockBindings;
7835 } VkDescriptorPoolInlineUniformBlockCreateInfoEXT;
7836
7837
7838
7839 #define VK_EXT_shader_stencil_export 1
7840 #define VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION 1
7841 #define VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME "VK_EXT_shader_stencil_export"
7842
7843
7844 #define VK_EXT_sample_locations 1
7845 #define VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION 1
7846 #define VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME "VK_EXT_sample_locations"
7847 typedef struct VkSampleLocationEXT {
7848     float    x;
7849     float    y;
7850 } VkSampleLocationEXT;
7851
7852 typedef struct VkSampleLocationsInfoEXT {
7853     VkStructureType               sType;
7854     const void*                   pNext;
7855     VkSampleCountFlagBits         sampleLocationsPerPixel;
7856     VkExtent2D                    sampleLocationGridSize;
7857     uint32_t                      sampleLocationsCount;
7858     const VkSampleLocationEXT*    pSampleLocations;
7859 } VkSampleLocationsInfoEXT;
7860
7861 typedef struct VkAttachmentSampleLocationsEXT {
7862     uint32_t                    attachmentIndex;
7863     VkSampleLocationsInfoEXT    sampleLocationsInfo;
7864 } VkAttachmentSampleLocationsEXT;
7865
7866 typedef struct VkSubpassSampleLocationsEXT {
7867     uint32_t                    subpassIndex;
7868     VkSampleLocationsInfoEXT    sampleLocationsInfo;
7869 } VkSubpassSampleLocationsEXT;
7870
7871 typedef struct VkRenderPassSampleLocationsBeginInfoEXT {
7872     VkStructureType                          sType;
7873     const void*                              pNext;
7874     uint32_t                                 attachmentInitialSampleLocationsCount;
7875     const VkAttachmentSampleLocationsEXT*    pAttachmentInitialSampleLocations;
7876     uint32_t                                 postSubpassSampleLocationsCount;
7877     const VkSubpassSampleLocationsEXT*       pPostSubpassSampleLocations;
7878 } VkRenderPassSampleLocationsBeginInfoEXT;
7879
7880 typedef struct VkPipelineSampleLocationsStateCreateInfoEXT {
7881     VkStructureType             sType;
7882     const void*                 pNext;
7883     VkBool32                    sampleLocationsEnable;
7884     VkSampleLocationsInfoEXT    sampleLocationsInfo;
7885 } VkPipelineSampleLocationsStateCreateInfoEXT;
7886
7887 typedef struct VkPhysicalDeviceSampleLocationsPropertiesEXT {
7888     VkStructureType       sType;
7889     void*                 pNext;
7890     VkSampleCountFlags    sampleLocationSampleCounts;
7891     VkExtent2D            maxSampleLocationGridSize;
7892     float                 sampleLocationCoordinateRange[2];
7893     uint32_t              sampleLocationSubPixelBits;
7894     VkBool32              variableSampleLocations;
7895 } VkPhysicalDeviceSampleLocationsPropertiesEXT;
7896
7897 typedef struct VkMultisamplePropertiesEXT {
7898     VkStructureType    sType;
7899     void*              pNext;
7900     VkExtent2D         maxSampleLocationGridSize;
7901 } VkMultisamplePropertiesEXT;
7902
7903 typedef void (VKAPI_PTR *PFN_vkCmdSetSampleLocationsEXT)(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo);
7904 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT)(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties);
7905
7906 #ifndef VK_NO_PROTOTYPES
7907 VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleLocationsEXT(
7908     VkCommandBuffer                             commandBuffer,
7909     const VkSampleLocationsInfoEXT*             pSampleLocationsInfo);
7910
7911 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMultisamplePropertiesEXT(
7912     VkPhysicalDevice                            physicalDevice,
7913     VkSampleCountFlagBits                       samples,
7914     VkMultisamplePropertiesEXT*                 pMultisampleProperties);
7915 #endif
7916
7917
7918 #define VK_EXT_blend_operation_advanced 1
7919 #define VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION 2
7920 #define VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME "VK_EXT_blend_operation_advanced"
7921
7922 typedef enum VkBlendOverlapEXT {
7923     VK_BLEND_OVERLAP_UNCORRELATED_EXT = 0,
7924     VK_BLEND_OVERLAP_DISJOINT_EXT = 1,
7925     VK_BLEND_OVERLAP_CONJOINT_EXT = 2,
7926     VK_BLEND_OVERLAP_BEGIN_RANGE_EXT = VK_BLEND_OVERLAP_UNCORRELATED_EXT,
7927     VK_BLEND_OVERLAP_END_RANGE_EXT = VK_BLEND_OVERLAP_CONJOINT_EXT,
7928     VK_BLEND_OVERLAP_RANGE_SIZE_EXT = (VK_BLEND_OVERLAP_CONJOINT_EXT - VK_BLEND_OVERLAP_UNCORRELATED_EXT + 1),
7929     VK_BLEND_OVERLAP_MAX_ENUM_EXT = 0x7FFFFFFF
7930 } VkBlendOverlapEXT;
7931 typedef struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT {
7932     VkStructureType    sType;
7933     void*              pNext;
7934     VkBool32           advancedBlendCoherentOperations;
7935 } VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT;
7936
7937 typedef struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT {
7938     VkStructureType    sType;
7939     void*              pNext;
7940     uint32_t           advancedBlendMaxColorAttachments;
7941     VkBool32           advancedBlendIndependentBlend;
7942     VkBool32           advancedBlendNonPremultipliedSrcColor;
7943     VkBool32           advancedBlendNonPremultipliedDstColor;
7944     VkBool32           advancedBlendCorrelatedOverlap;
7945     VkBool32           advancedBlendAllOperations;
7946 } VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT;
7947
7948 typedef struct VkPipelineColorBlendAdvancedStateCreateInfoEXT {
7949     VkStructureType      sType;
7950     const void*          pNext;
7951     VkBool32             srcPremultiplied;
7952     VkBool32             dstPremultiplied;
7953     VkBlendOverlapEXT    blendOverlap;
7954 } VkPipelineColorBlendAdvancedStateCreateInfoEXT;
7955
7956
7957
7958 #define VK_NV_fragment_coverage_to_color 1
7959 #define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION 1
7960 #define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME "VK_NV_fragment_coverage_to_color"
7961 typedef VkFlags VkPipelineCoverageToColorStateCreateFlagsNV;
7962 typedef struct VkPipelineCoverageToColorStateCreateInfoNV {
7963     VkStructureType                                sType;
7964     const void*                                    pNext;
7965     VkPipelineCoverageToColorStateCreateFlagsNV    flags;
7966     VkBool32                                       coverageToColorEnable;
7967     uint32_t                                       coverageToColorLocation;
7968 } VkPipelineCoverageToColorStateCreateInfoNV;
7969
7970
7971
7972 #define VK_NV_framebuffer_mixed_samples 1
7973 #define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION 1
7974 #define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME "VK_NV_framebuffer_mixed_samples"
7975
7976 typedef enum VkCoverageModulationModeNV {
7977     VK_COVERAGE_MODULATION_MODE_NONE_NV = 0,
7978     VK_COVERAGE_MODULATION_MODE_RGB_NV = 1,
7979     VK_COVERAGE_MODULATION_MODE_ALPHA_NV = 2,
7980     VK_COVERAGE_MODULATION_MODE_RGBA_NV = 3,
7981     VK_COVERAGE_MODULATION_MODE_BEGIN_RANGE_NV = VK_COVERAGE_MODULATION_MODE_NONE_NV,
7982     VK_COVERAGE_MODULATION_MODE_END_RANGE_NV = VK_COVERAGE_MODULATION_MODE_RGBA_NV,
7983     VK_COVERAGE_MODULATION_MODE_RANGE_SIZE_NV = (VK_COVERAGE_MODULATION_MODE_RGBA_NV - VK_COVERAGE_MODULATION_MODE_NONE_NV + 1),
7984     VK_COVERAGE_MODULATION_MODE_MAX_ENUM_NV = 0x7FFFFFFF
7985 } VkCoverageModulationModeNV;
7986 typedef VkFlags VkPipelineCoverageModulationStateCreateFlagsNV;
7987 typedef struct VkPipelineCoverageModulationStateCreateInfoNV {
7988     VkStructureType                                   sType;
7989     const void*                                       pNext;
7990     VkPipelineCoverageModulationStateCreateFlagsNV    flags;
7991     VkCoverageModulationModeNV                        coverageModulationMode;
7992     VkBool32                                          coverageModulationTableEnable;
7993     uint32_t                                          coverageModulationTableCount;
7994     const float*                                      pCoverageModulationTable;
7995 } VkPipelineCoverageModulationStateCreateInfoNV;
7996
7997
7998
7999 #define VK_NV_fill_rectangle 1
8000 #define VK_NV_FILL_RECTANGLE_SPEC_VERSION 1
8001 #define VK_NV_FILL_RECTANGLE_EXTENSION_NAME "VK_NV_fill_rectangle"
8002
8003
8004 #define VK_NV_shader_sm_builtins 1
8005 #define VK_NV_SHADER_SM_BUILTINS_SPEC_VERSION 1
8006 #define VK_NV_SHADER_SM_BUILTINS_EXTENSION_NAME "VK_NV_shader_sm_builtins"
8007 typedef struct VkPhysicalDeviceShaderSMBuiltinsPropertiesNV {
8008     VkStructureType    sType;
8009     void*              pNext;
8010     uint32_t           shaderSMCount;
8011     uint32_t           shaderWarpsPerSM;
8012 } VkPhysicalDeviceShaderSMBuiltinsPropertiesNV;
8013
8014 typedef struct VkPhysicalDeviceShaderSMBuiltinsFeaturesNV {
8015     VkStructureType    sType;
8016     void*              pNext;
8017     VkBool32           shaderSMBuiltins;
8018 } VkPhysicalDeviceShaderSMBuiltinsFeaturesNV;
8019
8020
8021
8022 #define VK_EXT_post_depth_coverage 1
8023 #define VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION 1
8024 #define VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME "VK_EXT_post_depth_coverage"
8025
8026
8027 #define VK_EXT_image_drm_format_modifier 1
8028 #define VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION 1
8029 #define VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME "VK_EXT_image_drm_format_modifier"
8030 typedef struct VkDrmFormatModifierPropertiesEXT {
8031     uint64_t                drmFormatModifier;
8032     uint32_t                drmFormatModifierPlaneCount;
8033     VkFormatFeatureFlags    drmFormatModifierTilingFeatures;
8034 } VkDrmFormatModifierPropertiesEXT;
8035
8036 typedef struct VkDrmFormatModifierPropertiesListEXT {
8037     VkStructureType                      sType;
8038     void*                                pNext;
8039     uint32_t                             drmFormatModifierCount;
8040     VkDrmFormatModifierPropertiesEXT*    pDrmFormatModifierProperties;
8041 } VkDrmFormatModifierPropertiesListEXT;
8042
8043 typedef struct VkPhysicalDeviceImageDrmFormatModifierInfoEXT {
8044     VkStructureType    sType;
8045     const void*        pNext;
8046     uint64_t           drmFormatModifier;
8047     VkSharingMode      sharingMode;
8048     uint32_t           queueFamilyIndexCount;
8049     const uint32_t*    pQueueFamilyIndices;
8050 } VkPhysicalDeviceImageDrmFormatModifierInfoEXT;
8051
8052 typedef struct VkImageDrmFormatModifierListCreateInfoEXT {
8053     VkStructureType    sType;
8054     const void*        pNext;
8055     uint32_t           drmFormatModifierCount;
8056     const uint64_t*    pDrmFormatModifiers;
8057 } VkImageDrmFormatModifierListCreateInfoEXT;
8058
8059 typedef struct VkImageDrmFormatModifierExplicitCreateInfoEXT {
8060     VkStructureType               sType;
8061     const void*                   pNext;
8062     uint64_t                      drmFormatModifier;
8063     uint32_t                      drmFormatModifierPlaneCount;
8064     const VkSubresourceLayout*    pPlaneLayouts;
8065 } VkImageDrmFormatModifierExplicitCreateInfoEXT;
8066
8067 typedef struct VkImageDrmFormatModifierPropertiesEXT {
8068     VkStructureType    sType;
8069     void*              pNext;
8070     uint64_t           drmFormatModifier;
8071 } VkImageDrmFormatModifierPropertiesEXT;
8072
8073 typedef VkResult (VKAPI_PTR *PFN_vkGetImageDrmFormatModifierPropertiesEXT)(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties);
8074
8075 #ifndef VK_NO_PROTOTYPES
8076 VKAPI_ATTR VkResult VKAPI_CALL vkGetImageDrmFormatModifierPropertiesEXT(
8077     VkDevice                                    device,
8078     VkImage                                     image,
8079     VkImageDrmFormatModifierPropertiesEXT*      pProperties);
8080 #endif
8081
8082
8083 #define VK_EXT_validation_cache 1
8084 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkValidationCacheEXT)
8085 #define VK_EXT_VALIDATION_CACHE_SPEC_VERSION 1
8086 #define VK_EXT_VALIDATION_CACHE_EXTENSION_NAME "VK_EXT_validation_cache"
8087
8088 typedef enum VkValidationCacheHeaderVersionEXT {
8089     VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT = 1,
8090     VK_VALIDATION_CACHE_HEADER_VERSION_BEGIN_RANGE_EXT = VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT,
8091     VK_VALIDATION_CACHE_HEADER_VERSION_END_RANGE_EXT = VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT,
8092     VK_VALIDATION_CACHE_HEADER_VERSION_RANGE_SIZE_EXT = (VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT - VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT + 1),
8093     VK_VALIDATION_CACHE_HEADER_VERSION_MAX_ENUM_EXT = 0x7FFFFFFF
8094 } VkValidationCacheHeaderVersionEXT;
8095 typedef VkFlags VkValidationCacheCreateFlagsEXT;
8096 typedef struct VkValidationCacheCreateInfoEXT {
8097     VkStructureType                    sType;
8098     const void*                        pNext;
8099     VkValidationCacheCreateFlagsEXT    flags;
8100     size_t                             initialDataSize;
8101     const void*                        pInitialData;
8102 } VkValidationCacheCreateInfoEXT;
8103
8104 typedef struct VkShaderModuleValidationCacheCreateInfoEXT {
8105     VkStructureType         sType;
8106     const void*             pNext;
8107     VkValidationCacheEXT    validationCache;
8108 } VkShaderModuleValidationCacheCreateInfoEXT;
8109
8110 typedef VkResult (VKAPI_PTR *PFN_vkCreateValidationCacheEXT)(VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache);
8111 typedef void (VKAPI_PTR *PFN_vkDestroyValidationCacheEXT)(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator);
8112 typedef VkResult (VKAPI_PTR *PFN_vkMergeValidationCachesEXT)(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches);
8113 typedef VkResult (VKAPI_PTR *PFN_vkGetValidationCacheDataEXT)(VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData);
8114
8115 #ifndef VK_NO_PROTOTYPES
8116 VKAPI_ATTR VkResult VKAPI_CALL vkCreateValidationCacheEXT(
8117     VkDevice                                    device,
8118     const VkValidationCacheCreateInfoEXT*       pCreateInfo,
8119     const VkAllocationCallbacks*                pAllocator,
8120     VkValidationCacheEXT*                       pValidationCache);
8121
8122 VKAPI_ATTR void VKAPI_CALL vkDestroyValidationCacheEXT(
8123     VkDevice                                    device,
8124     VkValidationCacheEXT                        validationCache,
8125     const VkAllocationCallbacks*                pAllocator);
8126
8127 VKAPI_ATTR VkResult VKAPI_CALL vkMergeValidationCachesEXT(
8128     VkDevice                                    device,
8129     VkValidationCacheEXT                        dstCache,
8130     uint32_t                                    srcCacheCount,
8131     const VkValidationCacheEXT*                 pSrcCaches);
8132
8133 VKAPI_ATTR VkResult VKAPI_CALL vkGetValidationCacheDataEXT(
8134     VkDevice                                    device,
8135     VkValidationCacheEXT                        validationCache,
8136     size_t*                                     pDataSize,
8137     void*                                       pData);
8138 #endif
8139
8140
8141 #define VK_EXT_descriptor_indexing 1
8142 #define VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION 2
8143 #define VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME "VK_EXT_descriptor_indexing"
8144
8145 typedef enum VkDescriptorBindingFlagBitsEXT {
8146     VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT = 0x00000001,
8147     VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT = 0x00000002,
8148     VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT = 0x00000004,
8149     VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT = 0x00000008,
8150     VK_DESCRIPTOR_BINDING_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
8151 } VkDescriptorBindingFlagBitsEXT;
8152 typedef VkFlags VkDescriptorBindingFlagsEXT;
8153 typedef struct VkDescriptorSetLayoutBindingFlagsCreateInfoEXT {
8154     VkStructureType                       sType;
8155     const void*                           pNext;
8156     uint32_t                              bindingCount;
8157     const VkDescriptorBindingFlagsEXT*    pBindingFlags;
8158 } VkDescriptorSetLayoutBindingFlagsCreateInfoEXT;
8159
8160 typedef struct VkPhysicalDeviceDescriptorIndexingFeaturesEXT {
8161     VkStructureType    sType;
8162     void*              pNext;
8163     VkBool32           shaderInputAttachmentArrayDynamicIndexing;
8164     VkBool32           shaderUniformTexelBufferArrayDynamicIndexing;
8165     VkBool32           shaderStorageTexelBufferArrayDynamicIndexing;
8166     VkBool32           shaderUniformBufferArrayNonUniformIndexing;
8167     VkBool32           shaderSampledImageArrayNonUniformIndexing;
8168     VkBool32           shaderStorageBufferArrayNonUniformIndexing;
8169     VkBool32           shaderStorageImageArrayNonUniformIndexing;
8170     VkBool32           shaderInputAttachmentArrayNonUniformIndexing;
8171     VkBool32           shaderUniformTexelBufferArrayNonUniformIndexing;
8172     VkBool32           shaderStorageTexelBufferArrayNonUniformIndexing;
8173     VkBool32           descriptorBindingUniformBufferUpdateAfterBind;
8174     VkBool32           descriptorBindingSampledImageUpdateAfterBind;
8175     VkBool32           descriptorBindingStorageImageUpdateAfterBind;
8176     VkBool32           descriptorBindingStorageBufferUpdateAfterBind;
8177     VkBool32           descriptorBindingUniformTexelBufferUpdateAfterBind;
8178     VkBool32           descriptorBindingStorageTexelBufferUpdateAfterBind;
8179     VkBool32           descriptorBindingUpdateUnusedWhilePending;
8180     VkBool32           descriptorBindingPartiallyBound;
8181     VkBool32           descriptorBindingVariableDescriptorCount;
8182     VkBool32           runtimeDescriptorArray;
8183 } VkPhysicalDeviceDescriptorIndexingFeaturesEXT;
8184
8185 typedef struct VkPhysicalDeviceDescriptorIndexingPropertiesEXT {
8186     VkStructureType    sType;
8187     void*              pNext;
8188     uint32_t           maxUpdateAfterBindDescriptorsInAllPools;
8189     VkBool32           shaderUniformBufferArrayNonUniformIndexingNative;
8190     VkBool32           shaderSampledImageArrayNonUniformIndexingNative;
8191     VkBool32           shaderStorageBufferArrayNonUniformIndexingNative;
8192     VkBool32           shaderStorageImageArrayNonUniformIndexingNative;
8193     VkBool32           shaderInputAttachmentArrayNonUniformIndexingNative;
8194     VkBool32           robustBufferAccessUpdateAfterBind;
8195     VkBool32           quadDivergentImplicitLod;
8196     uint32_t           maxPerStageDescriptorUpdateAfterBindSamplers;
8197     uint32_t           maxPerStageDescriptorUpdateAfterBindUniformBuffers;
8198     uint32_t           maxPerStageDescriptorUpdateAfterBindStorageBuffers;
8199     uint32_t           maxPerStageDescriptorUpdateAfterBindSampledImages;
8200     uint32_t           maxPerStageDescriptorUpdateAfterBindStorageImages;
8201     uint32_t           maxPerStageDescriptorUpdateAfterBindInputAttachments;
8202     uint32_t           maxPerStageUpdateAfterBindResources;
8203     uint32_t           maxDescriptorSetUpdateAfterBindSamplers;
8204     uint32_t           maxDescriptorSetUpdateAfterBindUniformBuffers;
8205     uint32_t           maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
8206     uint32_t           maxDescriptorSetUpdateAfterBindStorageBuffers;
8207     uint32_t           maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
8208     uint32_t           maxDescriptorSetUpdateAfterBindSampledImages;
8209     uint32_t           maxDescriptorSetUpdateAfterBindStorageImages;
8210     uint32_t           maxDescriptorSetUpdateAfterBindInputAttachments;
8211 } VkPhysicalDeviceDescriptorIndexingPropertiesEXT;
8212
8213 typedef struct VkDescriptorSetVariableDescriptorCountAllocateInfoEXT {
8214     VkStructureType    sType;
8215     const void*        pNext;
8216     uint32_t           descriptorSetCount;
8217     const uint32_t*    pDescriptorCounts;
8218 } VkDescriptorSetVariableDescriptorCountAllocateInfoEXT;
8219
8220 typedef struct VkDescriptorSetVariableDescriptorCountLayoutSupportEXT {
8221     VkStructureType    sType;
8222     void*              pNext;
8223     uint32_t           maxVariableDescriptorCount;
8224 } VkDescriptorSetVariableDescriptorCountLayoutSupportEXT;
8225
8226
8227
8228 #define VK_EXT_shader_viewport_index_layer 1
8229 #define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION 1
8230 #define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME "VK_EXT_shader_viewport_index_layer"
8231
8232
8233 #define VK_NV_shading_rate_image 1
8234 #define VK_NV_SHADING_RATE_IMAGE_SPEC_VERSION 3
8235 #define VK_NV_SHADING_RATE_IMAGE_EXTENSION_NAME "VK_NV_shading_rate_image"
8236
8237 typedef enum VkShadingRatePaletteEntryNV {
8238     VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV = 0,
8239     VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV = 1,
8240     VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV = 2,
8241     VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV = 3,
8242     VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV = 4,
8243     VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV = 5,
8244     VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV = 6,
8245     VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV = 7,
8246     VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV = 8,
8247     VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV = 9,
8248     VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV = 10,
8249     VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV = 11,
8250     VK_SHADING_RATE_PALETTE_ENTRY_BEGIN_RANGE_NV = VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV,
8251     VK_SHADING_RATE_PALETTE_ENTRY_END_RANGE_NV = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV,
8252     VK_SHADING_RATE_PALETTE_ENTRY_RANGE_SIZE_NV = (VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV - VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV + 1),
8253     VK_SHADING_RATE_PALETTE_ENTRY_MAX_ENUM_NV = 0x7FFFFFFF
8254 } VkShadingRatePaletteEntryNV;
8255
8256 typedef enum VkCoarseSampleOrderTypeNV {
8257     VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV = 0,
8258     VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV = 1,
8259     VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV = 2,
8260     VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV = 3,
8261     VK_COARSE_SAMPLE_ORDER_TYPE_BEGIN_RANGE_NV = VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV,
8262     VK_COARSE_SAMPLE_ORDER_TYPE_END_RANGE_NV = VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV,
8263     VK_COARSE_SAMPLE_ORDER_TYPE_RANGE_SIZE_NV = (VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV - VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV + 1),
8264     VK_COARSE_SAMPLE_ORDER_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
8265 } VkCoarseSampleOrderTypeNV;
8266 typedef struct VkShadingRatePaletteNV {
8267     uint32_t                              shadingRatePaletteEntryCount;
8268     const VkShadingRatePaletteEntryNV*    pShadingRatePaletteEntries;
8269 } VkShadingRatePaletteNV;
8270
8271 typedef struct VkPipelineViewportShadingRateImageStateCreateInfoNV {
8272     VkStructureType                  sType;
8273     const void*                      pNext;
8274     VkBool32                         shadingRateImageEnable;
8275     uint32_t                         viewportCount;
8276     const VkShadingRatePaletteNV*    pShadingRatePalettes;
8277 } VkPipelineViewportShadingRateImageStateCreateInfoNV;
8278
8279 typedef struct VkPhysicalDeviceShadingRateImageFeaturesNV {
8280     VkStructureType    sType;
8281     void*              pNext;
8282     VkBool32           shadingRateImage;
8283     VkBool32           shadingRateCoarseSampleOrder;
8284 } VkPhysicalDeviceShadingRateImageFeaturesNV;
8285
8286 typedef struct VkPhysicalDeviceShadingRateImagePropertiesNV {
8287     VkStructureType    sType;
8288     void*              pNext;
8289     VkExtent2D         shadingRateTexelSize;
8290     uint32_t           shadingRatePaletteSize;
8291     uint32_t           shadingRateMaxCoarseSamples;
8292 } VkPhysicalDeviceShadingRateImagePropertiesNV;
8293
8294 typedef struct VkCoarseSampleLocationNV {
8295     uint32_t    pixelX;
8296     uint32_t    pixelY;
8297     uint32_t    sample;
8298 } VkCoarseSampleLocationNV;
8299
8300 typedef struct VkCoarseSampleOrderCustomNV {
8301     VkShadingRatePaletteEntryNV        shadingRate;
8302     uint32_t                           sampleCount;
8303     uint32_t                           sampleLocationCount;
8304     const VkCoarseSampleLocationNV*    pSampleLocations;
8305 } VkCoarseSampleOrderCustomNV;
8306
8307 typedef struct VkPipelineViewportCoarseSampleOrderStateCreateInfoNV {
8308     VkStructureType                       sType;
8309     const void*                           pNext;
8310     VkCoarseSampleOrderTypeNV             sampleOrderType;
8311     uint32_t                              customSampleOrderCount;
8312     const VkCoarseSampleOrderCustomNV*    pCustomSampleOrders;
8313 } VkPipelineViewportCoarseSampleOrderStateCreateInfoNV;
8314
8315 typedef void (VKAPI_PTR *PFN_vkCmdBindShadingRateImageNV)(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout);
8316 typedef void (VKAPI_PTR *PFN_vkCmdSetViewportShadingRatePaletteNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes);
8317 typedef void (VKAPI_PTR *PFN_vkCmdSetCoarseSampleOrderNV)(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders);
8318
8319 #ifndef VK_NO_PROTOTYPES
8320 VKAPI_ATTR void VKAPI_CALL vkCmdBindShadingRateImageNV(
8321     VkCommandBuffer                             commandBuffer,
8322     VkImageView                                 imageView,
8323     VkImageLayout                               imageLayout);
8324
8325 VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportShadingRatePaletteNV(
8326     VkCommandBuffer                             commandBuffer,
8327     uint32_t                                    firstViewport,
8328     uint32_t                                    viewportCount,
8329     const VkShadingRatePaletteNV*               pShadingRatePalettes);
8330
8331 VKAPI_ATTR void VKAPI_CALL vkCmdSetCoarseSampleOrderNV(
8332     VkCommandBuffer                             commandBuffer,
8333     VkCoarseSampleOrderTypeNV                   sampleOrderType,
8334     uint32_t                                    customSampleOrderCount,
8335     const VkCoarseSampleOrderCustomNV*          pCustomSampleOrders);
8336 #endif
8337
8338
8339 #define VK_NV_ray_tracing 1
8340 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureNV)
8341 #define VK_NV_RAY_TRACING_SPEC_VERSION    3
8342 #define VK_NV_RAY_TRACING_EXTENSION_NAME  "VK_NV_ray_tracing"
8343 #define VK_SHADER_UNUSED_NV               (~0U)
8344
8345 typedef enum VkRayTracingShaderGroupTypeNV {
8346     VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV = 0,
8347     VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV = 1,
8348     VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV = 2,
8349     VK_RAY_TRACING_SHADER_GROUP_TYPE_BEGIN_RANGE_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV,
8350     VK_RAY_TRACING_SHADER_GROUP_TYPE_END_RANGE_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV,
8351     VK_RAY_TRACING_SHADER_GROUP_TYPE_RANGE_SIZE_NV = (VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV - VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV + 1),
8352     VK_RAY_TRACING_SHADER_GROUP_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
8353 } VkRayTracingShaderGroupTypeNV;
8354
8355 typedef enum VkGeometryTypeNV {
8356     VK_GEOMETRY_TYPE_TRIANGLES_NV = 0,
8357     VK_GEOMETRY_TYPE_AABBS_NV = 1,
8358     VK_GEOMETRY_TYPE_BEGIN_RANGE_NV = VK_GEOMETRY_TYPE_TRIANGLES_NV,
8359     VK_GEOMETRY_TYPE_END_RANGE_NV = VK_GEOMETRY_TYPE_AABBS_NV,
8360     VK_GEOMETRY_TYPE_RANGE_SIZE_NV = (VK_GEOMETRY_TYPE_AABBS_NV - VK_GEOMETRY_TYPE_TRIANGLES_NV + 1),
8361     VK_GEOMETRY_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
8362 } VkGeometryTypeNV;
8363
8364 typedef enum VkAccelerationStructureTypeNV {
8365     VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV = 0,
8366     VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV = 1,
8367     VK_ACCELERATION_STRUCTURE_TYPE_BEGIN_RANGE_NV = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV,
8368     VK_ACCELERATION_STRUCTURE_TYPE_END_RANGE_NV = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV,
8369     VK_ACCELERATION_STRUCTURE_TYPE_RANGE_SIZE_NV = (VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV - VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV + 1),
8370     VK_ACCELERATION_STRUCTURE_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
8371 } VkAccelerationStructureTypeNV;
8372
8373 typedef enum VkCopyAccelerationStructureModeNV {
8374     VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV = 0,
8375     VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV = 1,
8376     VK_COPY_ACCELERATION_STRUCTURE_MODE_BEGIN_RANGE_NV = VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV,
8377     VK_COPY_ACCELERATION_STRUCTURE_MODE_END_RANGE_NV = VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV,
8378     VK_COPY_ACCELERATION_STRUCTURE_MODE_RANGE_SIZE_NV = (VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV - VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV + 1),
8379     VK_COPY_ACCELERATION_STRUCTURE_MODE_MAX_ENUM_NV = 0x7FFFFFFF
8380 } VkCopyAccelerationStructureModeNV;
8381
8382 typedef enum VkAccelerationStructureMemoryRequirementsTypeNV {
8383     VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV = 0,
8384     VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV = 1,
8385     VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV = 2,
8386     VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BEGIN_RANGE_NV = VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV,
8387     VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_END_RANGE_NV = VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV,
8388     VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_RANGE_SIZE_NV = (VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV - VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV + 1),
8389     VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
8390 } VkAccelerationStructureMemoryRequirementsTypeNV;
8391
8392 typedef enum VkGeometryFlagBitsNV {
8393     VK_GEOMETRY_OPAQUE_BIT_NV = 0x00000001,
8394     VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_NV = 0x00000002,
8395     VK_GEOMETRY_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
8396 } VkGeometryFlagBitsNV;
8397 typedef VkFlags VkGeometryFlagsNV;
8398
8399 typedef enum VkGeometryInstanceFlagBitsNV {
8400     VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV = 0x00000001,
8401     VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_NV = 0x00000002,
8402     VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NV = 0x00000004,
8403     VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NV = 0x00000008,
8404     VK_GEOMETRY_INSTANCE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
8405 } VkGeometryInstanceFlagBitsNV;
8406 typedef VkFlags VkGeometryInstanceFlagsNV;
8407
8408 typedef enum VkBuildAccelerationStructureFlagBitsNV {
8409     VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV = 0x00000001,
8410     VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV = 0x00000002,
8411     VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV = 0x00000004,
8412     VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV = 0x00000008,
8413     VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NV = 0x00000010,
8414     VK_BUILD_ACCELERATION_STRUCTURE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
8415 } VkBuildAccelerationStructureFlagBitsNV;
8416 typedef VkFlags VkBuildAccelerationStructureFlagsNV;
8417 typedef struct VkRayTracingShaderGroupCreateInfoNV {
8418     VkStructureType                  sType;
8419     const void*                      pNext;
8420     VkRayTracingShaderGroupTypeNV    type;
8421     uint32_t                         generalShader;
8422     uint32_t                         closestHitShader;
8423     uint32_t                         anyHitShader;
8424     uint32_t                         intersectionShader;
8425 } VkRayTracingShaderGroupCreateInfoNV;
8426
8427 typedef struct VkRayTracingPipelineCreateInfoNV {
8428     VkStructureType                               sType;
8429     const void*                                   pNext;
8430     VkPipelineCreateFlags                         flags;
8431     uint32_t                                      stageCount;
8432     const VkPipelineShaderStageCreateInfo*        pStages;
8433     uint32_t                                      groupCount;
8434     const VkRayTracingShaderGroupCreateInfoNV*    pGroups;
8435     uint32_t                                      maxRecursionDepth;
8436     VkPipelineLayout                              layout;
8437     VkPipeline                                    basePipelineHandle;
8438     int32_t                                       basePipelineIndex;
8439 } VkRayTracingPipelineCreateInfoNV;
8440
8441 typedef struct VkGeometryTrianglesNV {
8442     VkStructureType    sType;
8443     const void*        pNext;
8444     VkBuffer           vertexData;
8445     VkDeviceSize       vertexOffset;
8446     uint32_t           vertexCount;
8447     VkDeviceSize       vertexStride;
8448     VkFormat           vertexFormat;
8449     VkBuffer           indexData;
8450     VkDeviceSize       indexOffset;
8451     uint32_t           indexCount;
8452     VkIndexType        indexType;
8453     VkBuffer           transformData;
8454     VkDeviceSize       transformOffset;
8455 } VkGeometryTrianglesNV;
8456
8457 typedef struct VkGeometryAABBNV {
8458     VkStructureType    sType;
8459     const void*        pNext;
8460     VkBuffer           aabbData;
8461     uint32_t           numAABBs;
8462     uint32_t           stride;
8463     VkDeviceSize       offset;
8464 } VkGeometryAABBNV;
8465
8466 typedef struct VkGeometryDataNV {
8467     VkGeometryTrianglesNV    triangles;
8468     VkGeometryAABBNV         aabbs;
8469 } VkGeometryDataNV;
8470
8471 typedef struct VkGeometryNV {
8472     VkStructureType      sType;
8473     const void*          pNext;
8474     VkGeometryTypeNV     geometryType;
8475     VkGeometryDataNV     geometry;
8476     VkGeometryFlagsNV    flags;
8477 } VkGeometryNV;
8478
8479 typedef struct VkAccelerationStructureInfoNV {
8480     VkStructureType                        sType;
8481     const void*                            pNext;
8482     VkAccelerationStructureTypeNV          type;
8483     VkBuildAccelerationStructureFlagsNV    flags;
8484     uint32_t                               instanceCount;
8485     uint32_t                               geometryCount;
8486     const VkGeometryNV*                    pGeometries;
8487 } VkAccelerationStructureInfoNV;
8488
8489 typedef struct VkAccelerationStructureCreateInfoNV {
8490     VkStructureType                  sType;
8491     const void*                      pNext;
8492     VkDeviceSize                     compactedSize;
8493     VkAccelerationStructureInfoNV    info;
8494 } VkAccelerationStructureCreateInfoNV;
8495
8496 typedef struct VkBindAccelerationStructureMemoryInfoNV {
8497     VkStructureType              sType;
8498     const void*                  pNext;
8499     VkAccelerationStructureNV    accelerationStructure;
8500     VkDeviceMemory               memory;
8501     VkDeviceSize                 memoryOffset;
8502     uint32_t                     deviceIndexCount;
8503     const uint32_t*              pDeviceIndices;
8504 } VkBindAccelerationStructureMemoryInfoNV;
8505
8506 typedef struct VkWriteDescriptorSetAccelerationStructureNV {
8507     VkStructureType                     sType;
8508     const void*                         pNext;
8509     uint32_t                            accelerationStructureCount;
8510     const VkAccelerationStructureNV*    pAccelerationStructures;
8511 } VkWriteDescriptorSetAccelerationStructureNV;
8512
8513 typedef struct VkAccelerationStructureMemoryRequirementsInfoNV {
8514     VkStructureType                                    sType;
8515     const void*                                        pNext;
8516     VkAccelerationStructureMemoryRequirementsTypeNV    type;
8517     VkAccelerationStructureNV                          accelerationStructure;
8518 } VkAccelerationStructureMemoryRequirementsInfoNV;
8519
8520 typedef struct VkPhysicalDeviceRayTracingPropertiesNV {
8521     VkStructureType    sType;
8522     void*              pNext;
8523     uint32_t           shaderGroupHandleSize;
8524     uint32_t           maxRecursionDepth;
8525     uint32_t           maxShaderGroupStride;
8526     uint32_t           shaderGroupBaseAlignment;
8527     uint64_t           maxGeometryCount;
8528     uint64_t           maxInstanceCount;
8529     uint64_t           maxTriangleCount;
8530     uint32_t           maxDescriptorSetAccelerationStructures;
8531 } VkPhysicalDeviceRayTracingPropertiesNV;
8532
8533 typedef VkResult (VKAPI_PTR *PFN_vkCreateAccelerationStructureNV)(VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure);
8534 typedef void (VKAPI_PTR *PFN_vkDestroyAccelerationStructureNV)(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator);
8535 typedef void (VKAPI_PTR *PFN_vkGetAccelerationStructureMemoryRequirementsNV)(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements);
8536 typedef VkResult (VKAPI_PTR *PFN_vkBindAccelerationStructureMemoryNV)(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos);
8537 typedef void (VKAPI_PTR *PFN_vkCmdBuildAccelerationStructureNV)(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset);
8538 typedef void (VKAPI_PTR *PFN_vkCmdCopyAccelerationStructureNV)(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeNV mode);
8539 typedef void (VKAPI_PTR *PFN_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);
8540 typedef VkResult (VKAPI_PTR *PFN_vkCreateRayTracingPipelinesNV)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
8541 typedef VkResult (VKAPI_PTR *PFN_vkGetRayTracingShaderGroupHandlesNV)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData);
8542 typedef VkResult (VKAPI_PTR *PFN_vkGetAccelerationStructureHandleNV)(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData);
8543 typedef void (VKAPI_PTR *PFN_vkCmdWriteAccelerationStructuresPropertiesNV)(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery);
8544 typedef VkResult (VKAPI_PTR *PFN_vkCompileDeferredNV)(VkDevice device, VkPipeline pipeline, uint32_t shader);
8545
8546 #ifndef VK_NO_PROTOTYPES
8547 VKAPI_ATTR VkResult VKAPI_CALL vkCreateAccelerationStructureNV(
8548     VkDevice                                    device,
8549     const VkAccelerationStructureCreateInfoNV*  pCreateInfo,
8550     const VkAllocationCallbacks*                pAllocator,
8551     VkAccelerationStructureNV*                  pAccelerationStructure);
8552
8553 VKAPI_ATTR void VKAPI_CALL vkDestroyAccelerationStructureNV(
8554     VkDevice                                    device,
8555     VkAccelerationStructureNV                   accelerationStructure,
8556     const VkAllocationCallbacks*                pAllocator);
8557
8558 VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureMemoryRequirementsNV(
8559     VkDevice                                    device,
8560     const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo,
8561     VkMemoryRequirements2KHR*                   pMemoryRequirements);
8562
8563 VKAPI_ATTR VkResult VKAPI_CALL vkBindAccelerationStructureMemoryNV(
8564     VkDevice                                    device,
8565     uint32_t                                    bindInfoCount,
8566     const VkBindAccelerationStructureMemoryInfoNV* pBindInfos);
8567
8568 VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructureNV(
8569     VkCommandBuffer                             commandBuffer,
8570     const VkAccelerationStructureInfoNV*        pInfo,
8571     VkBuffer                                    instanceData,
8572     VkDeviceSize                                instanceOffset,
8573     VkBool32                                    update,
8574     VkAccelerationStructureNV                   dst,
8575     VkAccelerationStructureNV                   src,
8576     VkBuffer                                    scratch,
8577     VkDeviceSize                                scratchOffset);
8578
8579 VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureNV(
8580     VkCommandBuffer                             commandBuffer,
8581     VkAccelerationStructureNV                   dst,
8582     VkAccelerationStructureNV                   src,
8583     VkCopyAccelerationStructureModeNV           mode);
8584
8585 VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysNV(
8586     VkCommandBuffer                             commandBuffer,
8587     VkBuffer                                    raygenShaderBindingTableBuffer,
8588     VkDeviceSize                                raygenShaderBindingOffset,
8589     VkBuffer                                    missShaderBindingTableBuffer,
8590     VkDeviceSize                                missShaderBindingOffset,
8591     VkDeviceSize                                missShaderBindingStride,
8592     VkBuffer                                    hitShaderBindingTableBuffer,
8593     VkDeviceSize                                hitShaderBindingOffset,
8594     VkDeviceSize                                hitShaderBindingStride,
8595     VkBuffer                                    callableShaderBindingTableBuffer,
8596     VkDeviceSize                                callableShaderBindingOffset,
8597     VkDeviceSize                                callableShaderBindingStride,
8598     uint32_t                                    width,
8599     uint32_t                                    height,
8600     uint32_t                                    depth);
8601
8602 VKAPI_ATTR VkResult VKAPI_CALL vkCreateRayTracingPipelinesNV(
8603     VkDevice                                    device,
8604     VkPipelineCache                             pipelineCache,
8605     uint32_t                                    createInfoCount,
8606     const VkRayTracingPipelineCreateInfoNV*     pCreateInfos,
8607     const VkAllocationCallbacks*                pAllocator,
8608     VkPipeline*                                 pPipelines);
8609
8610 VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingShaderGroupHandlesNV(
8611     VkDevice                                    device,
8612     VkPipeline                                  pipeline,
8613     uint32_t                                    firstGroup,
8614     uint32_t                                    groupCount,
8615     size_t                                      dataSize,
8616     void*                                       pData);
8617
8618 VKAPI_ATTR VkResult VKAPI_CALL vkGetAccelerationStructureHandleNV(
8619     VkDevice                                    device,
8620     VkAccelerationStructureNV                   accelerationStructure,
8621     size_t                                      dataSize,
8622     void*                                       pData);
8623
8624 VKAPI_ATTR void VKAPI_CALL vkCmdWriteAccelerationStructuresPropertiesNV(
8625     VkCommandBuffer                             commandBuffer,
8626     uint32_t                                    accelerationStructureCount,
8627     const VkAccelerationStructureNV*            pAccelerationStructures,
8628     VkQueryType                                 queryType,
8629     VkQueryPool                                 queryPool,
8630     uint32_t                                    firstQuery);
8631
8632 VKAPI_ATTR VkResult VKAPI_CALL vkCompileDeferredNV(
8633     VkDevice                                    device,
8634     VkPipeline                                  pipeline,
8635     uint32_t                                    shader);
8636 #endif
8637
8638
8639 #define VK_NV_representative_fragment_test 1
8640 #define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION 1
8641 #define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME "VK_NV_representative_fragment_test"
8642 typedef struct VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV {
8643     VkStructureType    sType;
8644     void*              pNext;
8645     VkBool32           representativeFragmentTest;
8646 } VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV;
8647
8648 typedef struct VkPipelineRepresentativeFragmentTestStateCreateInfoNV {
8649     VkStructureType    sType;
8650     const void*        pNext;
8651     VkBool32           representativeFragmentTestEnable;
8652 } VkPipelineRepresentativeFragmentTestStateCreateInfoNV;
8653
8654
8655
8656 #define VK_EXT_filter_cubic 1
8657 #define VK_EXT_FILTER_CUBIC_SPEC_VERSION  2
8658 #define VK_EXT_FILTER_CUBIC_EXTENSION_NAME "VK_EXT_filter_cubic"
8659 typedef struct VkPhysicalDeviceImageViewImageFormatInfoEXT {
8660     VkStructureType    sType;
8661     void*              pNext;
8662     VkImageViewType    imageViewType;
8663 } VkPhysicalDeviceImageViewImageFormatInfoEXT;
8664
8665 typedef struct VkFilterCubicImageViewImageFormatPropertiesEXT {
8666     VkStructureType    sType;
8667     void*              pNext;
8668     VkBool32           filterCubic;
8669     VkBool32           filterCubicMinmax ;
8670 } VkFilterCubicImageViewImageFormatPropertiesEXT;
8671
8672
8673
8674 #define VK_EXT_global_priority 1
8675 #define VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION 2
8676 #define VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME "VK_EXT_global_priority"
8677
8678 typedef enum VkQueueGlobalPriorityEXT {
8679     VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT = 128,
8680     VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT = 256,
8681     VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT = 512,
8682     VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT = 1024,
8683     VK_QUEUE_GLOBAL_PRIORITY_BEGIN_RANGE_EXT = VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT,
8684     VK_QUEUE_GLOBAL_PRIORITY_END_RANGE_EXT = VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT,
8685     VK_QUEUE_GLOBAL_PRIORITY_RANGE_SIZE_EXT = (VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT - VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT + 1),
8686     VK_QUEUE_GLOBAL_PRIORITY_MAX_ENUM_EXT = 0x7FFFFFFF
8687 } VkQueueGlobalPriorityEXT;
8688 typedef struct VkDeviceQueueGlobalPriorityCreateInfoEXT {
8689     VkStructureType             sType;
8690     const void*                 pNext;
8691     VkQueueGlobalPriorityEXT    globalPriority;
8692 } VkDeviceQueueGlobalPriorityCreateInfoEXT;
8693
8694
8695
8696 #define VK_EXT_external_memory_host 1
8697 #define VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION 1
8698 #define VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME "VK_EXT_external_memory_host"
8699 typedef struct VkImportMemoryHostPointerInfoEXT {
8700     VkStructureType                       sType;
8701     const void*                           pNext;
8702     VkExternalMemoryHandleTypeFlagBits    handleType;
8703     void*                                 pHostPointer;
8704 } VkImportMemoryHostPointerInfoEXT;
8705
8706 typedef struct VkMemoryHostPointerPropertiesEXT {
8707     VkStructureType    sType;
8708     void*              pNext;
8709     uint32_t           memoryTypeBits;
8710 } VkMemoryHostPointerPropertiesEXT;
8711
8712 typedef struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT {
8713     VkStructureType    sType;
8714     void*              pNext;
8715     VkDeviceSize       minImportedHostPointerAlignment;
8716 } VkPhysicalDeviceExternalMemoryHostPropertiesEXT;
8717
8718 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryHostPointerPropertiesEXT)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties);
8719
8720 #ifndef VK_NO_PROTOTYPES
8721 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryHostPointerPropertiesEXT(
8722     VkDevice                                    device,
8723     VkExternalMemoryHandleTypeFlagBits          handleType,
8724     const void*                                 pHostPointer,
8725     VkMemoryHostPointerPropertiesEXT*           pMemoryHostPointerProperties);
8726 #endif
8727
8728
8729 #define VK_AMD_buffer_marker 1
8730 #define VK_AMD_BUFFER_MARKER_SPEC_VERSION 1
8731 #define VK_AMD_BUFFER_MARKER_EXTENSION_NAME "VK_AMD_buffer_marker"
8732 typedef void (VKAPI_PTR *PFN_vkCmdWriteBufferMarkerAMD)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker);
8733
8734 #ifndef VK_NO_PROTOTYPES
8735 VKAPI_ATTR void VKAPI_CALL vkCmdWriteBufferMarkerAMD(
8736     VkCommandBuffer                             commandBuffer,
8737     VkPipelineStageFlagBits                     pipelineStage,
8738     VkBuffer                                    dstBuffer,
8739     VkDeviceSize                                dstOffset,
8740     uint32_t                                    marker);
8741 #endif
8742
8743
8744 #define VK_EXT_calibrated_timestamps 1
8745 #define VK_EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION 1
8746 #define VK_EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME "VK_EXT_calibrated_timestamps"
8747
8748 typedef enum VkTimeDomainEXT {
8749     VK_TIME_DOMAIN_DEVICE_EXT = 0,
8750     VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT = 1,
8751     VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT = 2,
8752     VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT = 3,
8753     VK_TIME_DOMAIN_BEGIN_RANGE_EXT = VK_TIME_DOMAIN_DEVICE_EXT,
8754     VK_TIME_DOMAIN_END_RANGE_EXT = VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT,
8755     VK_TIME_DOMAIN_RANGE_SIZE_EXT = (VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT - VK_TIME_DOMAIN_DEVICE_EXT + 1),
8756     VK_TIME_DOMAIN_MAX_ENUM_EXT = 0x7FFFFFFF
8757 } VkTimeDomainEXT;
8758 typedef struct VkCalibratedTimestampInfoEXT {
8759     VkStructureType    sType;
8760     const void*        pNext;
8761     VkTimeDomainEXT    timeDomain;
8762 } VkCalibratedTimestampInfoEXT;
8763
8764 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains);
8765 typedef VkResult (VKAPI_PTR *PFN_vkGetCalibratedTimestampsEXT)(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation);
8766
8767 #ifndef VK_NO_PROTOTYPES
8768 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(
8769     VkPhysicalDevice                            physicalDevice,
8770     uint32_t*                                   pTimeDomainCount,
8771     VkTimeDomainEXT*                            pTimeDomains);
8772
8773 VKAPI_ATTR VkResult VKAPI_CALL vkGetCalibratedTimestampsEXT(
8774     VkDevice                                    device,
8775     uint32_t                                    timestampCount,
8776     const VkCalibratedTimestampInfoEXT*         pTimestampInfos,
8777     uint64_t*                                   pTimestamps,
8778     uint64_t*                                   pMaxDeviation);
8779 #endif
8780
8781
8782 #define VK_AMD_shader_core_properties 1
8783 #define VK_AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION 1
8784 #define VK_AMD_SHADER_CORE_PROPERTIES_EXTENSION_NAME "VK_AMD_shader_core_properties"
8785 typedef struct VkPhysicalDeviceShaderCorePropertiesAMD {
8786     VkStructureType    sType;
8787     void*              pNext;
8788     uint32_t           shaderEngineCount;
8789     uint32_t           shaderArraysPerEngineCount;
8790     uint32_t           computeUnitsPerShaderArray;
8791     uint32_t           simdPerComputeUnit;
8792     uint32_t           wavefrontsPerSimd;
8793     uint32_t           wavefrontSize;
8794     uint32_t           sgprsPerSimd;
8795     uint32_t           minSgprAllocation;
8796     uint32_t           maxSgprAllocation;
8797     uint32_t           sgprAllocationGranularity;
8798     uint32_t           vgprsPerSimd;
8799     uint32_t           minVgprAllocation;
8800     uint32_t           maxVgprAllocation;
8801     uint32_t           vgprAllocationGranularity;
8802 } VkPhysicalDeviceShaderCorePropertiesAMD;
8803
8804
8805
8806 #define VK_AMD_memory_overallocation_behavior 1
8807 #define VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_SPEC_VERSION 1
8808 #define VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_EXTENSION_NAME "VK_AMD_memory_overallocation_behavior"
8809
8810 typedef enum VkMemoryOverallocationBehaviorAMD {
8811     VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD = 0,
8812     VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD = 1,
8813     VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD = 2,
8814     VK_MEMORY_OVERALLOCATION_BEHAVIOR_BEGIN_RANGE_AMD = VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD,
8815     VK_MEMORY_OVERALLOCATION_BEHAVIOR_END_RANGE_AMD = VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD,
8816     VK_MEMORY_OVERALLOCATION_BEHAVIOR_RANGE_SIZE_AMD = (VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD - VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD + 1),
8817     VK_MEMORY_OVERALLOCATION_BEHAVIOR_MAX_ENUM_AMD = 0x7FFFFFFF
8818 } VkMemoryOverallocationBehaviorAMD;
8819 typedef struct VkDeviceMemoryOverallocationCreateInfoAMD {
8820     VkStructureType                      sType;
8821     const void*                          pNext;
8822     VkMemoryOverallocationBehaviorAMD    overallocationBehavior;
8823 } VkDeviceMemoryOverallocationCreateInfoAMD;
8824
8825
8826
8827 #define VK_EXT_vertex_attribute_divisor 1
8828 #define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION 3
8829 #define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME "VK_EXT_vertex_attribute_divisor"
8830 typedef struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT {
8831     VkStructureType    sType;
8832     void*              pNext;
8833     uint32_t           maxVertexAttribDivisor;
8834 } VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT;
8835
8836 typedef struct VkVertexInputBindingDivisorDescriptionEXT {
8837     uint32_t    binding;
8838     uint32_t    divisor;
8839 } VkVertexInputBindingDivisorDescriptionEXT;
8840
8841 typedef struct VkPipelineVertexInputDivisorStateCreateInfoEXT {
8842     VkStructureType                                     sType;
8843     const void*                                         pNext;
8844     uint32_t                                            vertexBindingDivisorCount;
8845     const VkVertexInputBindingDivisorDescriptionEXT*    pVertexBindingDivisors;
8846 } VkPipelineVertexInputDivisorStateCreateInfoEXT;
8847
8848 typedef struct VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT {
8849     VkStructureType    sType;
8850     void*              pNext;
8851     VkBool32           vertexAttributeInstanceRateDivisor;
8852     VkBool32           vertexAttributeInstanceRateZeroDivisor;
8853 } VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT;
8854
8855
8856
8857 #define VK_EXT_pipeline_creation_feedback 1
8858 #define VK_EXT_PIPELINE_CREATION_FEEDBACK_SPEC_VERSION 1
8859 #define VK_EXT_PIPELINE_CREATION_FEEDBACK_EXTENSION_NAME "VK_EXT_pipeline_creation_feedback"
8860
8861 typedef enum VkPipelineCreationFeedbackFlagBitsEXT {
8862     VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT = 0x00000001,
8863     VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT = 0x00000002,
8864     VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT_EXT = 0x00000004,
8865     VK_PIPELINE_CREATION_FEEDBACK_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
8866 } VkPipelineCreationFeedbackFlagBitsEXT;
8867 typedef VkFlags VkPipelineCreationFeedbackFlagsEXT;
8868 typedef struct VkPipelineCreationFeedbackEXT {
8869     VkPipelineCreationFeedbackFlagsEXT    flags;
8870     uint64_t                              duration;
8871 } VkPipelineCreationFeedbackEXT;
8872
8873 typedef struct VkPipelineCreationFeedbackCreateInfoEXT {
8874     VkStructureType                   sType;
8875     const void*                       pNext;
8876     VkPipelineCreationFeedbackEXT*    pPipelineCreationFeedback;
8877     uint32_t                          pipelineStageCreationFeedbackCount;
8878     VkPipelineCreationFeedbackEXT*    pPipelineStageCreationFeedbacks;
8879 } VkPipelineCreationFeedbackCreateInfoEXT;
8880
8881
8882
8883 #define VK_NV_shader_subgroup_partitioned 1
8884 #define VK_NV_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION 1
8885 #define VK_NV_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME "VK_NV_shader_subgroup_partitioned"
8886
8887
8888 #define VK_NV_compute_shader_derivatives 1
8889 #define VK_NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION 1
8890 #define VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME "VK_NV_compute_shader_derivatives"
8891 typedef struct VkPhysicalDeviceComputeShaderDerivativesFeaturesNV {
8892     VkStructureType    sType;
8893     void*              pNext;
8894     VkBool32           computeDerivativeGroupQuads;
8895     VkBool32           computeDerivativeGroupLinear;
8896 } VkPhysicalDeviceComputeShaderDerivativesFeaturesNV;
8897
8898
8899
8900 #define VK_NV_mesh_shader 1
8901 #define VK_NV_MESH_SHADER_SPEC_VERSION    1
8902 #define VK_NV_MESH_SHADER_EXTENSION_NAME  "VK_NV_mesh_shader"
8903 typedef struct VkPhysicalDeviceMeshShaderFeaturesNV {
8904     VkStructureType    sType;
8905     void*              pNext;
8906     VkBool32           taskShader;
8907     VkBool32           meshShader;
8908 } VkPhysicalDeviceMeshShaderFeaturesNV;
8909
8910 typedef struct VkPhysicalDeviceMeshShaderPropertiesNV {
8911     VkStructureType    sType;
8912     void*              pNext;
8913     uint32_t           maxDrawMeshTasksCount;
8914     uint32_t           maxTaskWorkGroupInvocations;
8915     uint32_t           maxTaskWorkGroupSize[3];
8916     uint32_t           maxTaskTotalMemorySize;
8917     uint32_t           maxTaskOutputCount;
8918     uint32_t           maxMeshWorkGroupInvocations;
8919     uint32_t           maxMeshWorkGroupSize[3];
8920     uint32_t           maxMeshTotalMemorySize;
8921     uint32_t           maxMeshOutputVertices;
8922     uint32_t           maxMeshOutputPrimitives;
8923     uint32_t           maxMeshMultiviewViewCount;
8924     uint32_t           meshOutputPerVertexGranularity;
8925     uint32_t           meshOutputPerPrimitiveGranularity;
8926 } VkPhysicalDeviceMeshShaderPropertiesNV;
8927
8928 typedef struct VkDrawMeshTasksIndirectCommandNV {
8929     uint32_t    taskCount;
8930     uint32_t    firstTask;
8931 } VkDrawMeshTasksIndirectCommandNV;
8932
8933 typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksNV)(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask);
8934 typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirectNV)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
8935 typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirectCountNV)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
8936
8937 #ifndef VK_NO_PROTOTYPES
8938 VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksNV(
8939     VkCommandBuffer                             commandBuffer,
8940     uint32_t                                    taskCount,
8941     uint32_t                                    firstTask);
8942
8943 VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectNV(
8944     VkCommandBuffer                             commandBuffer,
8945     VkBuffer                                    buffer,
8946     VkDeviceSize                                offset,
8947     uint32_t                                    drawCount,
8948     uint32_t                                    stride);
8949
8950 VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectCountNV(
8951     VkCommandBuffer                             commandBuffer,
8952     VkBuffer                                    buffer,
8953     VkDeviceSize                                offset,
8954     VkBuffer                                    countBuffer,
8955     VkDeviceSize                                countBufferOffset,
8956     uint32_t                                    maxDrawCount,
8957     uint32_t                                    stride);
8958 #endif
8959
8960
8961 #define VK_NV_fragment_shader_barycentric 1
8962 #define VK_NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION 1
8963 #define VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME "VK_NV_fragment_shader_barycentric"
8964 typedef struct VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV {
8965     VkStructureType    sType;
8966     void*              pNext;
8967     VkBool32           fragmentShaderBarycentric;
8968 } VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV;
8969
8970
8971
8972 #define VK_NV_shader_image_footprint 1
8973 #define VK_NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION 1
8974 #define VK_NV_SHADER_IMAGE_FOOTPRINT_EXTENSION_NAME "VK_NV_shader_image_footprint"
8975 typedef struct VkPhysicalDeviceShaderImageFootprintFeaturesNV {
8976     VkStructureType    sType;
8977     void*              pNext;
8978     VkBool32           imageFootprint;
8979 } VkPhysicalDeviceShaderImageFootprintFeaturesNV;
8980
8981
8982
8983 #define VK_NV_scissor_exclusive 1
8984 #define VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION 1
8985 #define VK_NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME "VK_NV_scissor_exclusive"
8986 typedef struct VkPipelineViewportExclusiveScissorStateCreateInfoNV {
8987     VkStructureType    sType;
8988     const void*        pNext;
8989     uint32_t           exclusiveScissorCount;
8990     const VkRect2D*    pExclusiveScissors;
8991 } VkPipelineViewportExclusiveScissorStateCreateInfoNV;
8992
8993 typedef struct VkPhysicalDeviceExclusiveScissorFeaturesNV {
8994     VkStructureType    sType;
8995     void*              pNext;
8996     VkBool32           exclusiveScissor;
8997 } VkPhysicalDeviceExclusiveScissorFeaturesNV;
8998
8999 typedef void (VKAPI_PTR *PFN_vkCmdSetExclusiveScissorNV)(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors);
9000
9001 #ifndef VK_NO_PROTOTYPES
9002 VKAPI_ATTR void VKAPI_CALL vkCmdSetExclusiveScissorNV(
9003     VkCommandBuffer                             commandBuffer,
9004     uint32_t                                    firstExclusiveScissor,
9005     uint32_t                                    exclusiveScissorCount,
9006     const VkRect2D*                             pExclusiveScissors);
9007 #endif
9008
9009
9010 #define VK_NV_device_diagnostic_checkpoints 1
9011 #define VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_SPEC_VERSION 2
9012 #define VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_EXTENSION_NAME "VK_NV_device_diagnostic_checkpoints"
9013 typedef struct VkQueueFamilyCheckpointPropertiesNV {
9014     VkStructureType         sType;
9015     void*                   pNext;
9016     VkPipelineStageFlags    checkpointExecutionStageMask;
9017 } VkQueueFamilyCheckpointPropertiesNV;
9018
9019 typedef struct VkCheckpointDataNV {
9020     VkStructureType            sType;
9021     void*                      pNext;
9022     VkPipelineStageFlagBits    stage;
9023     void*                      pCheckpointMarker;
9024 } VkCheckpointDataNV;
9025
9026 typedef void (VKAPI_PTR *PFN_vkCmdSetCheckpointNV)(VkCommandBuffer commandBuffer, const void* pCheckpointMarker);
9027 typedef void (VKAPI_PTR *PFN_vkGetQueueCheckpointDataNV)(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData);
9028
9029 #ifndef VK_NO_PROTOTYPES
9030 VKAPI_ATTR void VKAPI_CALL vkCmdSetCheckpointNV(
9031     VkCommandBuffer                             commandBuffer,
9032     const void*                                 pCheckpointMarker);
9033
9034 VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointDataNV(
9035     VkQueue                                     queue,
9036     uint32_t*                                   pCheckpointDataCount,
9037     VkCheckpointDataNV*                         pCheckpointData);
9038 #endif
9039
9040
9041 #define VK_INTEL_shader_integer_functions2 1
9042 #define VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_SPEC_VERSION 1
9043 #define VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_EXTENSION_NAME "VK_INTEL_shader_integer_functions2"
9044 typedef struct VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
9045     VkStructureType    sType;
9046     void*              pNext;
9047     VkBool32           shaderIntegerFunctions2;
9048 } VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
9049
9050
9051
9052 #define VK_INTEL_performance_query 1
9053 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPerformanceConfigurationINTEL)
9054 #define VK_INTEL_PERFORMANCE_QUERY_SPEC_VERSION 1
9055 #define VK_INTEL_PERFORMANCE_QUERY_EXTENSION_NAME "VK_INTEL_performance_query"
9056
9057 typedef enum VkPerformanceConfigurationTypeINTEL {
9058     VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL = 0,
9059     VK_PERFORMANCE_CONFIGURATION_TYPE_BEGIN_RANGE_INTEL = VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL,
9060     VK_PERFORMANCE_CONFIGURATION_TYPE_END_RANGE_INTEL = VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL,
9061     VK_PERFORMANCE_CONFIGURATION_TYPE_RANGE_SIZE_INTEL = (VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL - VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL + 1),
9062     VK_PERFORMANCE_CONFIGURATION_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF
9063 } VkPerformanceConfigurationTypeINTEL;
9064
9065 typedef enum VkQueryPoolSamplingModeINTEL {
9066     VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL = 0,
9067     VK_QUERY_POOL_SAMPLING_MODE_BEGIN_RANGE_INTEL = VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL,
9068     VK_QUERY_POOL_SAMPLING_MODE_END_RANGE_INTEL = VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL,
9069     VK_QUERY_POOL_SAMPLING_MODE_RANGE_SIZE_INTEL = (VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL - VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL + 1),
9070     VK_QUERY_POOL_SAMPLING_MODE_MAX_ENUM_INTEL = 0x7FFFFFFF
9071 } VkQueryPoolSamplingModeINTEL;
9072
9073 typedef enum VkPerformanceOverrideTypeINTEL {
9074     VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL = 0,
9075     VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL = 1,
9076     VK_PERFORMANCE_OVERRIDE_TYPE_BEGIN_RANGE_INTEL = VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL,
9077     VK_PERFORMANCE_OVERRIDE_TYPE_END_RANGE_INTEL = VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL,
9078     VK_PERFORMANCE_OVERRIDE_TYPE_RANGE_SIZE_INTEL = (VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL - VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL + 1),
9079     VK_PERFORMANCE_OVERRIDE_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF
9080 } VkPerformanceOverrideTypeINTEL;
9081
9082 typedef enum VkPerformanceParameterTypeINTEL {
9083     VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL = 0,
9084     VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL = 1,
9085     VK_PERFORMANCE_PARAMETER_TYPE_BEGIN_RANGE_INTEL = VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL,
9086     VK_PERFORMANCE_PARAMETER_TYPE_END_RANGE_INTEL = VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL,
9087     VK_PERFORMANCE_PARAMETER_TYPE_RANGE_SIZE_INTEL = (VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL - VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL + 1),
9088     VK_PERFORMANCE_PARAMETER_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF
9089 } VkPerformanceParameterTypeINTEL;
9090
9091 typedef enum VkPerformanceValueTypeINTEL {
9092     VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL = 0,
9093     VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL = 1,
9094     VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL = 2,
9095     VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL = 3,
9096     VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL = 4,
9097     VK_PERFORMANCE_VALUE_TYPE_BEGIN_RANGE_INTEL = VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL,
9098     VK_PERFORMANCE_VALUE_TYPE_END_RANGE_INTEL = VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL,
9099     VK_PERFORMANCE_VALUE_TYPE_RANGE_SIZE_INTEL = (VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL - VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL + 1),
9100     VK_PERFORMANCE_VALUE_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF
9101 } VkPerformanceValueTypeINTEL;
9102 typedef union VkPerformanceValueDataINTEL {
9103     uint32_t       value32;
9104     uint64_t       value64;
9105     float          valueFloat;
9106     VkBool32       valueBool;
9107     const char*    valueString;
9108 } VkPerformanceValueDataINTEL;
9109
9110 typedef struct VkPerformanceValueINTEL {
9111     VkPerformanceValueTypeINTEL    type;
9112     VkPerformanceValueDataINTEL    data;
9113 } VkPerformanceValueINTEL;
9114
9115 typedef struct VkInitializePerformanceApiInfoINTEL {
9116     VkStructureType    sType;
9117     const void*        pNext;
9118     void*              pUserData;
9119 } VkInitializePerformanceApiInfoINTEL;
9120
9121 typedef struct VkQueryPoolCreateInfoINTEL {
9122     VkStructureType                 sType;
9123     const void*                     pNext;
9124     VkQueryPoolSamplingModeINTEL    performanceCountersSampling;
9125 } VkQueryPoolCreateInfoINTEL;
9126
9127 typedef struct VkPerformanceMarkerInfoINTEL {
9128     VkStructureType    sType;
9129     const void*        pNext;
9130     uint64_t           marker;
9131 } VkPerformanceMarkerInfoINTEL;
9132
9133 typedef struct VkPerformanceStreamMarkerInfoINTEL {
9134     VkStructureType    sType;
9135     const void*        pNext;
9136     uint32_t           marker;
9137 } VkPerformanceStreamMarkerInfoINTEL;
9138
9139 typedef struct VkPerformanceOverrideInfoINTEL {
9140     VkStructureType                   sType;
9141     const void*                       pNext;
9142     VkPerformanceOverrideTypeINTEL    type;
9143     VkBool32                          enable;
9144     uint64_t                          parameter;
9145 } VkPerformanceOverrideInfoINTEL;
9146
9147 typedef struct VkPerformanceConfigurationAcquireInfoINTEL {
9148     VkStructureType                        sType;
9149     const void*                            pNext;
9150     VkPerformanceConfigurationTypeINTEL    type;
9151 } VkPerformanceConfigurationAcquireInfoINTEL;
9152
9153 typedef VkResult (VKAPI_PTR *PFN_vkInitializePerformanceApiINTEL)(VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo);
9154 typedef void (VKAPI_PTR *PFN_vkUninitializePerformanceApiINTEL)(VkDevice device);
9155 typedef VkResult (VKAPI_PTR *PFN_vkCmdSetPerformanceMarkerINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo);
9156 typedef VkResult (VKAPI_PTR *PFN_vkCmdSetPerformanceStreamMarkerINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo);
9157 typedef VkResult (VKAPI_PTR *PFN_vkCmdSetPerformanceOverrideINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo);
9158 typedef VkResult (VKAPI_PTR *PFN_vkAcquirePerformanceConfigurationINTEL)(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration);
9159 typedef VkResult (VKAPI_PTR *PFN_vkReleasePerformanceConfigurationINTEL)(VkDevice device, VkPerformanceConfigurationINTEL configuration);
9160 typedef VkResult (VKAPI_PTR *PFN_vkQueueSetPerformanceConfigurationINTEL)(VkQueue queue, VkPerformanceConfigurationINTEL configuration);
9161 typedef VkResult (VKAPI_PTR *PFN_vkGetPerformanceParameterINTEL)(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue);
9162
9163 #ifndef VK_NO_PROTOTYPES
9164 VKAPI_ATTR VkResult VKAPI_CALL vkInitializePerformanceApiINTEL(
9165     VkDevice                                    device,
9166     const VkInitializePerformanceApiInfoINTEL*  pInitializeInfo);
9167
9168 VKAPI_ATTR void VKAPI_CALL vkUninitializePerformanceApiINTEL(
9169     VkDevice                                    device);
9170
9171 VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceMarkerINTEL(
9172     VkCommandBuffer                             commandBuffer,
9173     const VkPerformanceMarkerInfoINTEL*         pMarkerInfo);
9174
9175 VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceStreamMarkerINTEL(
9176     VkCommandBuffer                             commandBuffer,
9177     const VkPerformanceStreamMarkerInfoINTEL*   pMarkerInfo);
9178
9179 VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceOverrideINTEL(
9180     VkCommandBuffer                             commandBuffer,
9181     const VkPerformanceOverrideInfoINTEL*       pOverrideInfo);
9182
9183 VKAPI_ATTR VkResult VKAPI_CALL vkAcquirePerformanceConfigurationINTEL(
9184     VkDevice                                    device,
9185     const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo,
9186     VkPerformanceConfigurationINTEL*            pConfiguration);
9187
9188 VKAPI_ATTR VkResult VKAPI_CALL vkReleasePerformanceConfigurationINTEL(
9189     VkDevice                                    device,
9190     VkPerformanceConfigurationINTEL             configuration);
9191
9192 VKAPI_ATTR VkResult VKAPI_CALL vkQueueSetPerformanceConfigurationINTEL(
9193     VkQueue                                     queue,
9194     VkPerformanceConfigurationINTEL             configuration);
9195
9196 VKAPI_ATTR VkResult VKAPI_CALL vkGetPerformanceParameterINTEL(
9197     VkDevice                                    device,
9198     VkPerformanceParameterTypeINTEL             parameter,
9199     VkPerformanceValueINTEL*                    pValue);
9200 #endif
9201
9202
9203 #define VK_EXT_pci_bus_info 1
9204 #define VK_EXT_PCI_BUS_INFO_SPEC_VERSION  2
9205 #define VK_EXT_PCI_BUS_INFO_EXTENSION_NAME "VK_EXT_pci_bus_info"
9206 typedef struct VkPhysicalDevicePCIBusInfoPropertiesEXT {
9207     VkStructureType    sType;
9208     void*              pNext;
9209     uint32_t           pciDomain;
9210     uint32_t           pciBus;
9211     uint32_t           pciDevice;
9212     uint32_t           pciFunction;
9213 } VkPhysicalDevicePCIBusInfoPropertiesEXT;
9214
9215
9216
9217 #define VK_AMD_display_native_hdr 1
9218 #define VK_AMD_DISPLAY_NATIVE_HDR_SPEC_VERSION 1
9219 #define VK_AMD_DISPLAY_NATIVE_HDR_EXTENSION_NAME "VK_AMD_display_native_hdr"
9220 typedef struct VkDisplayNativeHdrSurfaceCapabilitiesAMD {
9221     VkStructureType    sType;
9222     void*              pNext;
9223     VkBool32           localDimmingSupport;
9224 } VkDisplayNativeHdrSurfaceCapabilitiesAMD;
9225
9226 typedef struct VkSwapchainDisplayNativeHdrCreateInfoAMD {
9227     VkStructureType    sType;
9228     const void*        pNext;
9229     VkBool32           localDimmingEnable;
9230 } VkSwapchainDisplayNativeHdrCreateInfoAMD;
9231
9232 typedef void (VKAPI_PTR *PFN_vkSetLocalDimmingAMD)(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable);
9233
9234 #ifndef VK_NO_PROTOTYPES
9235 VKAPI_ATTR void VKAPI_CALL vkSetLocalDimmingAMD(
9236     VkDevice                                    device,
9237     VkSwapchainKHR                              swapChain,
9238     VkBool32                                    localDimmingEnable);
9239 #endif
9240
9241
9242 #define VK_EXT_fragment_density_map 1
9243 #define VK_EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION 1
9244 #define VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME "VK_EXT_fragment_density_map"
9245 typedef struct VkPhysicalDeviceFragmentDensityMapFeaturesEXT {
9246     VkStructureType    sType;
9247     void*              pNext;
9248     VkBool32           fragmentDensityMap;
9249     VkBool32           fragmentDensityMapDynamic;
9250     VkBool32           fragmentDensityMapNonSubsampledImages;
9251 } VkPhysicalDeviceFragmentDensityMapFeaturesEXT;
9252
9253 typedef struct VkPhysicalDeviceFragmentDensityMapPropertiesEXT {
9254     VkStructureType    sType;
9255     void*              pNext;
9256     VkExtent2D         minFragmentDensityTexelSize;
9257     VkExtent2D         maxFragmentDensityTexelSize;
9258     VkBool32           fragmentDensityInvocations;
9259 } VkPhysicalDeviceFragmentDensityMapPropertiesEXT;
9260
9261 typedef struct VkRenderPassFragmentDensityMapCreateInfoEXT {
9262     VkStructureType          sType;
9263     const void*              pNext;
9264     VkAttachmentReference    fragmentDensityMapAttachment;
9265 } VkRenderPassFragmentDensityMapCreateInfoEXT;
9266
9267
9268
9269 #define VK_EXT_scalar_block_layout 1
9270 #define VK_EXT_SCALAR_BLOCK_LAYOUT_SPEC_VERSION 1
9271 #define VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME "VK_EXT_scalar_block_layout"
9272 typedef struct VkPhysicalDeviceScalarBlockLayoutFeaturesEXT {
9273     VkStructureType    sType;
9274     void*              pNext;
9275     VkBool32           scalarBlockLayout;
9276 } VkPhysicalDeviceScalarBlockLayoutFeaturesEXT;
9277
9278
9279
9280 #define VK_GOOGLE_hlsl_functionality1 1
9281 #define VK_GOOGLE_HLSL_FUNCTIONALITY1_SPEC_VERSION 1
9282 #define VK_GOOGLE_HLSL_FUNCTIONALITY1_EXTENSION_NAME "VK_GOOGLE_hlsl_functionality1"
9283
9284
9285 #define VK_GOOGLE_decorate_string 1
9286 #define VK_GOOGLE_DECORATE_STRING_SPEC_VERSION 1
9287 #define VK_GOOGLE_DECORATE_STRING_EXTENSION_NAME "VK_GOOGLE_decorate_string"
9288
9289
9290 #define VK_EXT_subgroup_size_control 1
9291 #define VK_EXT_SUBGROUP_SIZE_CONTROL_SPEC_VERSION 1
9292 #define VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME "VK_EXT_subgroup_size_control"
9293 typedef struct VkPhysicalDeviceSubgroupSizeControlPropertiesEXT {
9294     VkStructureType       sType;
9295     void*                 pNext;
9296     uint32_t              minSubgroupSize;
9297     uint32_t              maxSubgroupSize;
9298     uint32_t              maxComputeWorkgroupSubgroups;
9299     VkShaderStageFlags    requiredSubgroupSizeStages;
9300 } VkPhysicalDeviceSubgroupSizeControlPropertiesEXT;
9301
9302 typedef struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT {
9303     VkStructureType    sType;
9304     void*              pNext;
9305     uint32_t           requiredSubgroupSize;
9306 } VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT;
9307
9308
9309
9310 #define VK_EXT_memory_budget 1
9311 #define VK_EXT_MEMORY_BUDGET_SPEC_VERSION 1
9312 #define VK_EXT_MEMORY_BUDGET_EXTENSION_NAME "VK_EXT_memory_budget"
9313 typedef struct VkPhysicalDeviceMemoryBudgetPropertiesEXT {
9314     VkStructureType    sType;
9315     void*              pNext;
9316     VkDeviceSize       heapBudget[VK_MAX_MEMORY_HEAPS];
9317     VkDeviceSize       heapUsage[VK_MAX_MEMORY_HEAPS];
9318 } VkPhysicalDeviceMemoryBudgetPropertiesEXT;
9319
9320
9321
9322 #define VK_EXT_memory_priority 1
9323 #define VK_EXT_MEMORY_PRIORITY_SPEC_VERSION 1
9324 #define VK_EXT_MEMORY_PRIORITY_EXTENSION_NAME "VK_EXT_memory_priority"
9325 typedef struct VkPhysicalDeviceMemoryPriorityFeaturesEXT {
9326     VkStructureType    sType;
9327     void*              pNext;
9328     VkBool32           memoryPriority;
9329 } VkPhysicalDeviceMemoryPriorityFeaturesEXT;
9330
9331 typedef struct VkMemoryPriorityAllocateInfoEXT {
9332     VkStructureType    sType;
9333     const void*        pNext;
9334     float              priority;
9335 } VkMemoryPriorityAllocateInfoEXT;
9336
9337
9338
9339 #define VK_NV_dedicated_allocation_image_aliasing 1
9340 #define VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_SPEC_VERSION 1
9341 #define VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_EXTENSION_NAME "VK_NV_dedicated_allocation_image_aliasing"
9342 typedef struct VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
9343     VkStructureType    sType;
9344     void*              pNext;
9345     VkBool32           dedicatedAllocationImageAliasing;
9346 } VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;
9347
9348
9349
9350 #define VK_EXT_buffer_device_address 1
9351 typedef uint64_t VkDeviceAddress;
9352 #define VK_EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION 2
9353 #define VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME "VK_EXT_buffer_device_address"
9354 typedef struct VkPhysicalDeviceBufferDeviceAddressFeaturesEXT {
9355     VkStructureType    sType;
9356     void*              pNext;
9357     VkBool32           bufferDeviceAddress;
9358     VkBool32           bufferDeviceAddressCaptureReplay;
9359     VkBool32           bufferDeviceAddressMultiDevice;
9360 } VkPhysicalDeviceBufferDeviceAddressFeaturesEXT;
9361
9362 typedef VkPhysicalDeviceBufferDeviceAddressFeaturesEXT VkPhysicalDeviceBufferAddressFeaturesEXT;
9363
9364 typedef struct VkBufferDeviceAddressInfoEXT {
9365     VkStructureType    sType;
9366     const void*        pNext;
9367     VkBuffer           buffer;
9368 } VkBufferDeviceAddressInfoEXT;
9369
9370 typedef struct VkBufferDeviceAddressCreateInfoEXT {
9371     VkStructureType    sType;
9372     const void*        pNext;
9373     VkDeviceAddress    deviceAddress;
9374 } VkBufferDeviceAddressCreateInfoEXT;
9375
9376 typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddressEXT)(VkDevice device, const VkBufferDeviceAddressInfoEXT* pInfo);
9377
9378 #ifndef VK_NO_PROTOTYPES
9379 VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressEXT(
9380     VkDevice                                    device,
9381     const VkBufferDeviceAddressInfoEXT*         pInfo);
9382 #endif
9383
9384
9385 #define VK_EXT_separate_stencil_usage 1
9386 #define VK_EXT_SEPARATE_STENCIL_USAGE_SPEC_VERSION 1
9387 #define VK_EXT_SEPARATE_STENCIL_USAGE_EXTENSION_NAME "VK_EXT_separate_stencil_usage"
9388 typedef struct VkImageStencilUsageCreateInfoEXT {
9389     VkStructureType      sType;
9390     const void*          pNext;
9391     VkImageUsageFlags    stencilUsage;
9392 } VkImageStencilUsageCreateInfoEXT;
9393
9394
9395
9396 #define VK_EXT_validation_features 1
9397 #define VK_EXT_VALIDATION_FEATURES_SPEC_VERSION 1
9398 #define VK_EXT_VALIDATION_FEATURES_EXTENSION_NAME "VK_EXT_validation_features"
9399
9400 typedef enum VkValidationFeatureEnableEXT {
9401     VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT = 0,
9402     VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT = 1,
9403     VK_VALIDATION_FEATURE_ENABLE_BEGIN_RANGE_EXT = VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT,
9404     VK_VALIDATION_FEATURE_ENABLE_END_RANGE_EXT = VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT,
9405     VK_VALIDATION_FEATURE_ENABLE_RANGE_SIZE_EXT = (VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT - VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT + 1),
9406     VK_VALIDATION_FEATURE_ENABLE_MAX_ENUM_EXT = 0x7FFFFFFF
9407 } VkValidationFeatureEnableEXT;
9408
9409 typedef enum VkValidationFeatureDisableEXT {
9410     VK_VALIDATION_FEATURE_DISABLE_ALL_EXT = 0,
9411     VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT = 1,
9412     VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT = 2,
9413     VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT = 3,
9414     VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT = 4,
9415     VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT = 5,
9416     VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT = 6,
9417     VK_VALIDATION_FEATURE_DISABLE_BEGIN_RANGE_EXT = VK_VALIDATION_FEATURE_DISABLE_ALL_EXT,
9418     VK_VALIDATION_FEATURE_DISABLE_END_RANGE_EXT = VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT,
9419     VK_VALIDATION_FEATURE_DISABLE_RANGE_SIZE_EXT = (VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT - VK_VALIDATION_FEATURE_DISABLE_ALL_EXT + 1),
9420     VK_VALIDATION_FEATURE_DISABLE_MAX_ENUM_EXT = 0x7FFFFFFF
9421 } VkValidationFeatureDisableEXT;
9422 typedef struct VkValidationFeaturesEXT {
9423     VkStructureType                         sType;
9424     const void*                             pNext;
9425     uint32_t                                enabledValidationFeatureCount;
9426     const VkValidationFeatureEnableEXT*     pEnabledValidationFeatures;
9427     uint32_t                                disabledValidationFeatureCount;
9428     const VkValidationFeatureDisableEXT*    pDisabledValidationFeatures;
9429 } VkValidationFeaturesEXT;
9430
9431
9432
9433 #define VK_NV_cooperative_matrix 1
9434 #define VK_NV_COOPERATIVE_MATRIX_SPEC_VERSION 1
9435 #define VK_NV_COOPERATIVE_MATRIX_EXTENSION_NAME "VK_NV_cooperative_matrix"
9436
9437 typedef enum VkComponentTypeNV {
9438     VK_COMPONENT_TYPE_FLOAT16_NV = 0,
9439     VK_COMPONENT_TYPE_FLOAT32_NV = 1,
9440     VK_COMPONENT_TYPE_FLOAT64_NV = 2,
9441     VK_COMPONENT_TYPE_SINT8_NV = 3,
9442     VK_COMPONENT_TYPE_SINT16_NV = 4,
9443     VK_COMPONENT_TYPE_SINT32_NV = 5,
9444     VK_COMPONENT_TYPE_SINT64_NV = 6,
9445     VK_COMPONENT_TYPE_UINT8_NV = 7,
9446     VK_COMPONENT_TYPE_UINT16_NV = 8,
9447     VK_COMPONENT_TYPE_UINT32_NV = 9,
9448     VK_COMPONENT_TYPE_UINT64_NV = 10,
9449     VK_COMPONENT_TYPE_BEGIN_RANGE_NV = VK_COMPONENT_TYPE_FLOAT16_NV,
9450     VK_COMPONENT_TYPE_END_RANGE_NV = VK_COMPONENT_TYPE_UINT64_NV,
9451     VK_COMPONENT_TYPE_RANGE_SIZE_NV = (VK_COMPONENT_TYPE_UINT64_NV - VK_COMPONENT_TYPE_FLOAT16_NV + 1),
9452     VK_COMPONENT_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
9453 } VkComponentTypeNV;
9454
9455 typedef enum VkScopeNV {
9456     VK_SCOPE_DEVICE_NV = 1,
9457     VK_SCOPE_WORKGROUP_NV = 2,
9458     VK_SCOPE_SUBGROUP_NV = 3,
9459     VK_SCOPE_QUEUE_FAMILY_NV = 5,
9460     VK_SCOPE_BEGIN_RANGE_NV = VK_SCOPE_DEVICE_NV,
9461     VK_SCOPE_END_RANGE_NV = VK_SCOPE_QUEUE_FAMILY_NV,
9462     VK_SCOPE_RANGE_SIZE_NV = (VK_SCOPE_QUEUE_FAMILY_NV - VK_SCOPE_DEVICE_NV + 1),
9463     VK_SCOPE_MAX_ENUM_NV = 0x7FFFFFFF
9464 } VkScopeNV;
9465 typedef struct VkCooperativeMatrixPropertiesNV {
9466     VkStructureType      sType;
9467     void*                pNext;
9468     uint32_t             MSize;
9469     uint32_t             NSize;
9470     uint32_t             KSize;
9471     VkComponentTypeNV    AType;
9472     VkComponentTypeNV    BType;
9473     VkComponentTypeNV    CType;
9474     VkComponentTypeNV    DType;
9475     VkScopeNV            scope;
9476 } VkCooperativeMatrixPropertiesNV;
9477
9478 typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesNV {
9479     VkStructureType    sType;
9480     void*              pNext;
9481     VkBool32           cooperativeMatrix;
9482     VkBool32           cooperativeMatrixRobustBufferAccess;
9483 } VkPhysicalDeviceCooperativeMatrixFeaturesNV;
9484
9485 typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesNV {
9486     VkStructureType       sType;
9487     void*                 pNext;
9488     VkShaderStageFlags    cooperativeMatrixSupportedStages;
9489 } VkPhysicalDeviceCooperativeMatrixPropertiesNV;
9490
9491 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties);
9492
9493 #ifndef VK_NO_PROTOTYPES
9494 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(
9495     VkPhysicalDevice                            physicalDevice,
9496     uint32_t*                                   pPropertyCount,
9497     VkCooperativeMatrixPropertiesNV*            pProperties);
9498 #endif
9499
9500
9501 #define VK_NV_coverage_reduction_mode 1
9502 #define VK_NV_COVERAGE_REDUCTION_MODE_SPEC_VERSION 1
9503 #define VK_NV_COVERAGE_REDUCTION_MODE_EXTENSION_NAME "VK_NV_coverage_reduction_mode"
9504
9505 typedef enum VkCoverageReductionModeNV {
9506     VK_COVERAGE_REDUCTION_MODE_MERGE_NV = 0,
9507     VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV = 1,
9508     VK_COVERAGE_REDUCTION_MODE_BEGIN_RANGE_NV = VK_COVERAGE_REDUCTION_MODE_MERGE_NV,
9509     VK_COVERAGE_REDUCTION_MODE_END_RANGE_NV = VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV,
9510     VK_COVERAGE_REDUCTION_MODE_RANGE_SIZE_NV = (VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV - VK_COVERAGE_REDUCTION_MODE_MERGE_NV + 1),
9511     VK_COVERAGE_REDUCTION_MODE_MAX_ENUM_NV = 0x7FFFFFFF
9512 } VkCoverageReductionModeNV;
9513 typedef VkFlags VkPipelineCoverageReductionStateCreateFlagsNV;
9514 typedef struct VkPhysicalDeviceCoverageReductionModeFeaturesNV {
9515     VkStructureType    sType;
9516     void*              pNext;
9517     VkBool32           coverageReductionMode;
9518 } VkPhysicalDeviceCoverageReductionModeFeaturesNV;
9519
9520 typedef struct VkPipelineCoverageReductionStateCreateInfoNV {
9521     VkStructureType                                  sType;
9522     const void*                                      pNext;
9523     VkPipelineCoverageReductionStateCreateFlagsNV    flags;
9524     VkCoverageReductionModeNV                        coverageReductionMode;
9525 } VkPipelineCoverageReductionStateCreateInfoNV;
9526
9527 typedef struct VkFramebufferMixedSamplesCombinationNV {
9528     VkStructureType              sType;
9529     void*                        pNext;
9530     VkCoverageReductionModeNV    coverageReductionMode;
9531     VkSampleCountFlagBits        rasterizationSamples;
9532     VkSampleCountFlags           depthStencilSamples;
9533     VkSampleCountFlags           colorSamples;
9534 } VkFramebufferMixedSamplesCombinationNV;
9535
9536 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV)(VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations);
9537
9538 #ifndef VK_NO_PROTOTYPES
9539 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
9540     VkPhysicalDevice                            physicalDevice,
9541     uint32_t*                                   pCombinationCount,
9542     VkFramebufferMixedSamplesCombinationNV*     pCombinations);
9543 #endif
9544
9545
9546 #define VK_EXT_fragment_shader_interlock 1
9547 #define VK_EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION 1
9548 #define VK_EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME "VK_EXT_fragment_shader_interlock"
9549 typedef struct VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT {
9550     VkStructureType    sType;
9551     void*              pNext;
9552     VkBool32           fragmentShaderSampleInterlock;
9553     VkBool32           fragmentShaderPixelInterlock;
9554     VkBool32           fragmentShaderShadingRateInterlock;
9555 } VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT;
9556
9557
9558
9559 #define VK_EXT_ycbcr_image_arrays 1
9560 #define VK_EXT_YCBCR_IMAGE_ARRAYS_SPEC_VERSION 1
9561 #define VK_EXT_YCBCR_IMAGE_ARRAYS_EXTENSION_NAME "VK_EXT_ycbcr_image_arrays"
9562 typedef struct VkPhysicalDeviceYcbcrImageArraysFeaturesEXT {
9563     VkStructureType    sType;
9564     void*              pNext;
9565     VkBool32           ycbcrImageArrays;
9566 } VkPhysicalDeviceYcbcrImageArraysFeaturesEXT;
9567
9568
9569
9570 #define VK_EXT_headless_surface 1
9571 #define VK_EXT_HEADLESS_SURFACE_SPEC_VERSION 0
9572 #define VK_EXT_HEADLESS_SURFACE_EXTENSION_NAME "VK_EXT_headless_surface"
9573 typedef VkFlags VkHeadlessSurfaceCreateFlagsEXT;
9574 typedef struct VkHeadlessSurfaceCreateInfoEXT {
9575     VkStructureType                    sType;
9576     const void*                        pNext;
9577     VkHeadlessSurfaceCreateFlagsEXT    flags;
9578 } VkHeadlessSurfaceCreateInfoEXT;
9579
9580 typedef VkResult (VKAPI_PTR *PFN_vkCreateHeadlessSurfaceEXT)(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
9581
9582 #ifndef VK_NO_PROTOTYPES
9583 VKAPI_ATTR VkResult VKAPI_CALL vkCreateHeadlessSurfaceEXT(
9584     VkInstance                                  instance,
9585     const VkHeadlessSurfaceCreateInfoEXT*       pCreateInfo,
9586     const VkAllocationCallbacks*                pAllocator,
9587     VkSurfaceKHR*                               pSurface);
9588 #endif
9589
9590
9591 #define VK_EXT_line_rasterization 1
9592 #define VK_EXT_LINE_RASTERIZATION_SPEC_VERSION 1
9593 #define VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME "VK_EXT_line_rasterization"
9594
9595 typedef enum VkLineRasterizationModeEXT {
9596     VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT = 0,
9597     VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT = 1,
9598     VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT = 2,
9599     VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT = 3,
9600     VK_LINE_RASTERIZATION_MODE_BEGIN_RANGE_EXT = VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT,
9601     VK_LINE_RASTERIZATION_MODE_END_RANGE_EXT = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT,
9602     VK_LINE_RASTERIZATION_MODE_RANGE_SIZE_EXT = (VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT - VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT + 1),
9603     VK_LINE_RASTERIZATION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF
9604 } VkLineRasterizationModeEXT;
9605 typedef struct VkPhysicalDeviceLineRasterizationFeaturesEXT {
9606     VkStructureType    sType;
9607     void*              pNext;
9608     VkBool32           rectangularLines;
9609     VkBool32           bresenhamLines;
9610     VkBool32           smoothLines;
9611     VkBool32           stippledRectangularLines;
9612     VkBool32           stippledBresenhamLines;
9613     VkBool32           stippledSmoothLines;
9614 } VkPhysicalDeviceLineRasterizationFeaturesEXT;
9615
9616 typedef struct VkPhysicalDeviceLineRasterizationPropertiesEXT {
9617     VkStructureType    sType;
9618     void*              pNext;
9619     uint32_t           lineSubPixelPrecisionBits;
9620 } VkPhysicalDeviceLineRasterizationPropertiesEXT;
9621
9622 typedef struct VkPipelineRasterizationLineStateCreateInfoEXT {
9623     VkStructureType               sType;
9624     const void*                   pNext;
9625     VkLineRasterizationModeEXT    lineRasterizationMode;
9626     VkBool32                      stippledLineEnable;
9627     uint32_t                      lineStippleFactor;
9628     uint16_t                      lineStipplePattern;
9629 } VkPipelineRasterizationLineStateCreateInfoEXT;
9630
9631 typedef void (VKAPI_PTR *PFN_vkCmdSetLineStippleEXT)(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern);
9632
9633 #ifndef VK_NO_PROTOTYPES
9634 VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleEXT(
9635     VkCommandBuffer                             commandBuffer,
9636     uint32_t                                    lineStippleFactor,
9637     uint16_t                                    lineStipplePattern);
9638 #endif
9639
9640
9641 #define VK_EXT_host_query_reset 1
9642 #define VK_EXT_HOST_QUERY_RESET_SPEC_VERSION 1
9643 #define VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME "VK_EXT_host_query_reset"
9644 typedef struct VkPhysicalDeviceHostQueryResetFeaturesEXT {
9645     VkStructureType    sType;
9646     void*              pNext;
9647     VkBool32           hostQueryReset;
9648 } VkPhysicalDeviceHostQueryResetFeaturesEXT;
9649
9650 typedef void (VKAPI_PTR *PFN_vkResetQueryPoolEXT)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);
9651
9652 #ifndef VK_NO_PROTOTYPES
9653 VKAPI_ATTR void VKAPI_CALL vkResetQueryPoolEXT(
9654     VkDevice                                    device,
9655     VkQueryPool                                 queryPool,
9656     uint32_t                                    firstQuery,
9657     uint32_t                                    queryCount);
9658 #endif
9659
9660
9661 #define VK_EXT_index_type_uint8 1
9662 #define VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION 1
9663 #define VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME "VK_EXT_index_type_uint8"
9664 typedef struct VkPhysicalDeviceIndexTypeUint8FeaturesEXT {
9665     VkStructureType    sType;
9666     void*              pNext;
9667     VkBool32           indexTypeUint8;
9668 } VkPhysicalDeviceIndexTypeUint8FeaturesEXT;
9669
9670
9671
9672 #define VK_EXT_shader_demote_to_helper_invocation 1
9673 #define VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_SPEC_VERSION 1
9674 #define VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME "VK_EXT_shader_demote_to_helper_invocation"
9675 typedef struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT {
9676     VkStructureType    sType;
9677     void*              pNext;
9678     VkBool32           shaderDemoteToHelperInvocation;
9679 } VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT;
9680
9681
9682
9683 #define VK_EXT_texel_buffer_alignment 1
9684 #define VK_EXT_TEXEL_BUFFER_ALIGNMENT_SPEC_VERSION 1
9685 #define VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME "VK_EXT_texel_buffer_alignment"
9686 typedef struct VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT {
9687     VkStructureType    sType;
9688     void*              pNext;
9689     VkBool32           texelBufferAlignment;
9690 } VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT;
9691
9692 typedef struct VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT {
9693     VkStructureType    sType;
9694     void*              pNext;
9695     VkDeviceSize       storageTexelBufferOffsetAlignmentBytes;
9696     VkBool32           storageTexelBufferOffsetSingleTexelAlignment;
9697     VkDeviceSize       uniformTexelBufferOffsetAlignmentBytes;
9698     VkBool32           uniformTexelBufferOffsetSingleTexelAlignment;
9699 } VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT;
9700
9701
9702 #ifdef __cplusplus
9703 }
9704 #endif
9705
9706 #endif