external/vulkancts/scripts/src/vulkan_core.h

   1 #ifndef VULKAN_CORE_H_
   2 #define VULKAN_CORE_H_ 1
   3
   4 /*
   5 ** Copyright 2015-2021 The Khronos Group Inc.
   6 **
   7 ** SPDX-License-Identifier: Apache-2.0
   8 */
   9
  10 /*
  11 ** This header is generated from the Khronos Vulkan XML API Registry.
  12 **
  13 */
  14
  15
  16 #ifdef __cplusplus
  17 extern "C" {
  18 #endif
  19
  20
  21
  22 #define VK_VERSION_1_0 1
  23 #include "vulkan/vk_platform.h"
  24
  25 #define VK_DEFINE_HANDLE(object) typedef struct object##_T* object;
  26
  27
  28 #ifndef VK_USE_64_BIT_PTR_DEFINES
  29     #if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
  30         #define VK_USE_64_BIT_PTR_DEFINES 1
  31     #else
  32         #define VK_USE_64_BIT_PTR_DEFINES 0
  33     #endif
  34 #endif
  35
  36
  37 #ifndef VK_DEFINE_NON_DISPATCHABLE_HANDLE
  38     #if (VK_USE_64_BIT_PTR_DEFINES==1)
  39         #if (defined(__cplusplus) && (__cplusplus >= 201103L)) || (defined(_MSVC_LANG) && (_MSVC_LANG >= 201103L))
  40             #define VK_NULL_HANDLE nullptr
  41         #else
  42             #define VK_NULL_HANDLE ((void*)0)
  43         #endif
  44     #else
  45         #define VK_NULL_HANDLE 0ULL
  46     #endif
  47 #endif
  48 #ifndef VK_NULL_HANDLE
  49     #define VK_NULL_HANDLE 0
  50 #endif
  51
  52
  53 #ifndef VK_DEFINE_NON_DISPATCHABLE_HANDLE
  54     #if (VK_USE_64_BIT_PTR_DEFINES==1)
  55         #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object;
  56     #else
  57         #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object;
  58     #endif
  59 #endif
  60
  61 // DEPRECATED: This define is deprecated. VK_MAKE_API_VERSION should be used instead.
  62 #define VK_MAKE_VERSION(major, minor, patch) \
  63     ((((uint32_t)(major)) << 22) | (((uint32_t)(minor)) << 12) | ((uint32_t)(patch)))
  64
  65 // 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.
  66 //#define VK_API_VERSION VK_MAKE_VERSION(1, 0, 0) // Patch version should always be set to 0
  67
  68 #define VK_MAKE_API_VERSION(variant, major, minor, patch) \
  69     ((((uint32_t)(variant)) << 29) | (((uint32_t)(major)) << 22) | (((uint32_t)(minor)) << 12) | ((uint32_t)(patch)))
  70
  71 // Vulkan 1.0 version number
  72 #define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0
  73
  74 // Version of this file
  75 #define VK_HEADER_VERSION 186
  76
  77 // Complete version of this file
  78 #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 2, VK_HEADER_VERSION)
  79
  80 // DEPRECATED: This define is deprecated. VK_API_VERSION_MAJOR should be used instead.
  81 #define VK_VERSION_MAJOR(version) ((uint32_t)(version) >> 22)
  82
  83 // DEPRECATED: This define is deprecated. VK_API_VERSION_MINOR should be used instead.
  84 #define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3FFU)
  85
  86 // DEPRECATED: This define is deprecated. VK_API_VERSION_PATCH should be used instead.
  87 #define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xFFFU)
  88
  89 #define VK_API_VERSION_VARIANT(version) ((uint32_t)(version) >> 29)
  90 #define VK_API_VERSION_MAJOR(version) (((uint32_t)(version) >> 22) & 0x7FU)
  91 #define VK_API_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3FFU)
  92 #define VK_API_VERSION_PATCH(version) ((uint32_t)(version) & 0xFFFU)
  93 typedef uint32_t VkBool32;
  94 typedef uint64_t VkDeviceAddress;
  95 typedef uint64_t VkDeviceSize;
  96 typedef uint32_t VkFlags;
  97 typedef uint32_t VkSampleMask;
  98 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer)
  99 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage)
 100 VK_DEFINE_HANDLE(VkInstance)
 101 VK_DEFINE_HANDLE(VkPhysicalDevice)
 102 VK_DEFINE_HANDLE(VkDevice)
 103 VK_DEFINE_HANDLE(VkQueue)
 104 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore)
 105 VK_DEFINE_HANDLE(VkCommandBuffer)
 106 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence)
 107 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory)
 108 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent)
 109 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool)
 110 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView)
 111 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView)
 112 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule)
 113 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache)
 114 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout)
 115 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline)
 116 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass)
 117 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout)
 118 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler)
 119 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet)
 120 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool)
 121 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer)
 122 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool)
 123 #define VK_UUID_SIZE                      16U
 124 #define VK_ATTACHMENT_UNUSED              (~0U)
 125 #define VK_FALSE                          0U
 126 #define VK_LOD_CLAMP_NONE                 1000.0F
 127 #define VK_QUEUE_FAMILY_IGNORED           (~0U)
 128 #define VK_REMAINING_ARRAY_LAYERS         (~0U)
 129 #define VK_REMAINING_MIP_LEVELS           (~0U)
 130 #define VK_SUBPASS_EXTERNAL               (~0U)
 131 #define VK_TRUE                           1U
 132 #define VK_WHOLE_SIZE                     (~0ULL)
 133 #define VK_MAX_MEMORY_TYPES               32U
 134 #define VK_MAX_MEMORY_HEAPS               16U
 135 #define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE  256U
 136 #define VK_MAX_EXTENSION_NAME_SIZE        256U
 137 #define VK_MAX_DESCRIPTION_SIZE           256U
 138
 139 typedef enum VkResult {
 140     VK_SUCCESS = 0,
 141     VK_NOT_READY = 1,
 142     VK_TIMEOUT = 2,
 143     VK_EVENT_SET = 3,
 144     VK_EVENT_RESET = 4,
 145     VK_INCOMPLETE = 5,
 146     VK_ERROR_OUT_OF_HOST_MEMORY = -1,
 147     VK_ERROR_OUT_OF_DEVICE_MEMORY = -2,
 148     VK_ERROR_INITIALIZATION_FAILED = -3,
 149     VK_ERROR_DEVICE_LOST = -4,
 150     VK_ERROR_MEMORY_MAP_FAILED = -5,
 151     VK_ERROR_LAYER_NOT_PRESENT = -6,
 152     VK_ERROR_EXTENSION_NOT_PRESENT = -7,
 153     VK_ERROR_FEATURE_NOT_PRESENT = -8,
 154     VK_ERROR_INCOMPATIBLE_DRIVER = -9,
 155     VK_ERROR_TOO_MANY_OBJECTS = -10,
 156     VK_ERROR_FORMAT_NOT_SUPPORTED = -11,
 157     VK_ERROR_FRAGMENTED_POOL = -12,
 158     VK_ERROR_UNKNOWN = -13,
 159     VK_ERROR_OUT_OF_POOL_MEMORY = -1000069000,
 160     VK_ERROR_INVALID_EXTERNAL_HANDLE = -1000072003,
 161     VK_ERROR_FRAGMENTATION = -1000161000,
 162     VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS = -1000257000,
 163     VK_ERROR_SURFACE_LOST_KHR = -1000000000,
 164     VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001,
 165     VK_SUBOPTIMAL_KHR = 1000001003,
 166     VK_ERROR_OUT_OF_DATE_KHR = -1000001004,
 167     VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001,
 168     VK_ERROR_VALIDATION_FAILED_EXT = -1000011001,
 169     VK_ERROR_INVALID_SHADER_NV = -1000012000,
 170     VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT = -1000158000,
 171     VK_ERROR_NOT_PERMITTED_EXT = -1000174001,
 172     VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT = -1000255000,
 173     VK_THREAD_IDLE_KHR = 1000268000,
 174     VK_THREAD_DONE_KHR = 1000268001,
 175     VK_OPERATION_DEFERRED_KHR = 1000268002,
 176     VK_OPERATION_NOT_DEFERRED_KHR = 1000268003,
 177     VK_PIPELINE_COMPILE_REQUIRED_EXT = 1000297000,
 178     VK_ERROR_OUT_OF_POOL_MEMORY_KHR = VK_ERROR_OUT_OF_POOL_MEMORY,
 179     VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = VK_ERROR_INVALID_EXTERNAL_HANDLE,
 180     VK_ERROR_FRAGMENTATION_EXT = VK_ERROR_FRAGMENTATION,
 181     VK_ERROR_INVALID_DEVICE_ADDRESS_EXT = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS,
 182     VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS,
 183     VK_ERROR_PIPELINE_COMPILE_REQUIRED_EXT = VK_PIPELINE_COMPILE_REQUIRED_EXT,
 184     VK_RESULT_MAX_ENUM = 0x7FFFFFFF
 185 } VkResult;
 186
 187 typedef enum VkStructureType {
 188     VK_STRUCTURE_TYPE_APPLICATION_INFO = 0,
 189     VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1,
 190     VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2,
 191     VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3,
 192     VK_STRUCTURE_TYPE_SUBMIT_INFO = 4,
 193     VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5,
 194     VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6,
 195     VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7,
 196     VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8,
 197     VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9,
 198     VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10,
 199     VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11,
 200     VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12,
 201     VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13,
 202     VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14,
 203     VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15,
 204     VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16,
 205     VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17,
 206     VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18,
 207     VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19,
 208     VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20,
 209     VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21,
 210     VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22,
 211     VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23,
 212     VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24,
 213     VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25,
 214     VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26,
 215     VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27,
 216     VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28,
 217     VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29,
 218     VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30,
 219     VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31,
 220     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32,
 221     VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33,
 222     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34,
 223     VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35,
 224     VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36,
 225     VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37,
 226     VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38,
 227     VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39,
 228     VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40,
 229     VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41,
 230     VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42,
 231     VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43,
 232     VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44,
 233     VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45,
 234     VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46,
 235     VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47,
 236     VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48,
 237     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES = 1000094000,
 238     VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO = 1000157000,
 239     VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO = 1000157001,
 240     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES = 1000083000,
 241     VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS = 1000127000,
 242     VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO = 1000127001,
 243     VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO = 1000060000,
 244     VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO = 1000060003,
 245     VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO = 1000060004,
 246     VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO = 1000060005,
 247     VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO = 1000060006,
 248     VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO = 1000060013,
 249     VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO = 1000060014,
 250     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES = 1000070000,
 251     VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO = 1000070001,
 252     VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2 = 1000146000,
 253     VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2 = 1000146001,
 254     VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 = 1000146002,
 255     VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 = 1000146003,
 256     VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 = 1000146004,
 257     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 = 1000059000,
 258     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 = 1000059001,
 259     VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 = 1000059002,
 260     VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 = 1000059003,
 261     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 = 1000059004,
 262     VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 = 1000059005,
 263     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 = 1000059006,
 264     VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 = 1000059007,
 265     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 = 1000059008,
 266     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES = 1000117000,
 267     VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO = 1000117001,
 268     VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO = 1000117002,
 269     VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO = 1000117003,
 270     VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO = 1000053000,
 271     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES = 1000053001,
 272     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES = 1000053002,
 273     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES = 1000120000,
 274     VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO = 1000145000,
 275     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES = 1000145001,
 276     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES = 1000145002,
 277     VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 = 1000145003,
 278     VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO = 1000156000,
 279     VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO = 1000156001,
 280     VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO = 1000156002,
 281     VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO = 1000156003,
 282     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES = 1000156004,
 283     VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES = 1000156005,
 284     VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO = 1000085000,
 285     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO = 1000071000,
 286     VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES = 1000071001,
 287     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO = 1000071002,
 288     VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES = 1000071003,
 289     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES = 1000071004,
 290     VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO = 1000072000,
 291     VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO = 1000072001,
 292     VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO = 1000072002,
 293     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO = 1000112000,
 294     VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES = 1000112001,
 295     VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO = 1000113000,
 296     VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO = 1000077000,
 297     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO = 1000076000,
 298     VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES = 1000076001,
 299     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES = 1000168000,
 300     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT = 1000168001,
 301     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES = 1000063000,
 302     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES = 49,
 303     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES = 50,
 304     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES = 51,
 305     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES = 52,
 306     VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO = 1000147000,
 307     VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2 = 1000109000,
 308     VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2 = 1000109001,
 309     VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2 = 1000109002,
 310     VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2 = 1000109003,
 311     VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2 = 1000109004,
 312     VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO = 1000109005,
 313     VK_STRUCTURE_TYPE_SUBPASS_END_INFO = 1000109006,
 314     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES = 1000177000,
 315     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES = 1000196000,
 316     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES = 1000180000,
 317     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES = 1000082000,
 318     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES = 1000197000,
 319     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO = 1000161000,
 320     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES = 1000161001,
 321     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES = 1000161002,
 322     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO = 1000161003,
 323     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT = 1000161004,
 324     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES = 1000199000,
 325     VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE = 1000199001,
 326     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES = 1000221000,
 327     VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO = 1000246000,
 328     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES = 1000130000,
 329     VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO = 1000130001,
 330     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES = 1000211000,
 331     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES = 1000108000,
 332     VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO = 1000108001,
 333     VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO = 1000108002,
 334     VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO = 1000108003,
 335     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES = 1000253000,
 336     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES = 1000175000,
 337     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES = 1000241000,
 338     VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT = 1000241001,
 339     VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT = 1000241002,
 340     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES = 1000261000,
 341     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES = 1000207000,
 342     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES = 1000207001,
 343     VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO = 1000207002,
 344     VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO = 1000207003,
 345     VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO = 1000207004,
 346     VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO = 1000207005,
 347     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES = 1000257000,
 348     VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO = 1000244001,
 349     VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO = 1000257002,
 350     VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO = 1000257003,
 351     VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO = 1000257004,
 352     VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000,
 353     VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001,
 354     VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR = 1000060007,
 355     VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR = 1000060008,
 356     VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR = 1000060009,
 357     VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR = 1000060010,
 358     VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR = 1000060011,
 359     VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR = 1000060012,
 360     VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000,
 361     VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001,
 362     VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000,
 363     VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000,
 364     VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000,
 365     VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000,
 366     VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000,
 367     VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000,
 368     VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000,
 369     VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000,
 370     VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000,
 371     VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001,
 372     VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002,
 373 #ifdef VK_ENABLE_BETA_EXTENSIONS
 374     VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR = 1000023000,
 375 #endif
 376 #ifdef VK_ENABLE_BETA_EXTENSIONS
 377     VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR = 1000023001,
 378 #endif
 379 #ifdef VK_ENABLE_BETA_EXTENSIONS
 380     VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_KHR = 1000023002,
 381 #endif
 382 #ifdef VK_ENABLE_BETA_EXTENSIONS
 383     VK_STRUCTURE_TYPE_VIDEO_GET_MEMORY_PROPERTIES_KHR = 1000023003,
 384 #endif
 385 #ifdef VK_ENABLE_BETA_EXTENSIONS
 386     VK_STRUCTURE_TYPE_VIDEO_BIND_MEMORY_KHR = 1000023004,
 387 #endif
 388 #ifdef VK_ENABLE_BETA_EXTENSIONS
 389     VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR = 1000023005,
 390 #endif
 391 #ifdef VK_ENABLE_BETA_EXTENSIONS
 392     VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000023006,
 393 #endif
 394 #ifdef VK_ENABLE_BETA_EXTENSIONS
 395     VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR = 1000023007,
 396 #endif
 397 #ifdef VK_ENABLE_BETA_EXTENSIONS
 398     VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR = 1000023008,
 399 #endif
 400 #ifdef VK_ENABLE_BETA_EXTENSIONS
 401     VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR = 1000023009,
 402 #endif
 403 #ifdef VK_ENABLE_BETA_EXTENSIONS
 404     VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR = 1000023010,
 405 #endif
 406 #ifdef VK_ENABLE_BETA_EXTENSIONS
 407     VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_KHR = 1000023011,
 408 #endif
 409 #ifdef VK_ENABLE_BETA_EXTENSIONS
 410     VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR = 1000023012,
 411 #endif
 412 #ifdef VK_ENABLE_BETA_EXTENSIONS
 413     VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR = 1000023013,
 414 #endif
 415 #ifdef VK_ENABLE_BETA_EXTENSIONS
 416     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR = 1000023014,
 417 #endif
 418 #ifdef VK_ENABLE_BETA_EXTENSIONS
 419     VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR = 1000023015,
 420 #endif
 421 #ifdef VK_ENABLE_BETA_EXTENSIONS
 422     VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR = 1000024000,
 423 #endif
 424     VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000,
 425     VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001,
 426     VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002,
 427     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT = 1000028000,
 428     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT = 1000028001,
 429     VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT = 1000028002,
 430     VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX = 1000029000,
 431     VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX = 1000029001,
 432     VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX = 1000029002,
 433     VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX = 1000030000,
 434     VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX = 1000030001,
 435 #ifdef VK_ENABLE_BETA_EXTENSIONS
 436     VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT = 1000038000,
 437 #endif
 438 #ifdef VK_ENABLE_BETA_EXTENSIONS
 439     VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT = 1000038001,
 440 #endif
 441 #ifdef VK_ENABLE_BETA_EXTENSIONS
 442     VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT = 1000038002,
 443 #endif
 444 #ifdef VK_ENABLE_BETA_EXTENSIONS
 445     VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT = 1000038003,
 446 #endif
 447 #ifdef VK_ENABLE_BETA_EXTENSIONS
 448     VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT = 1000038004,
 449 #endif
 450 #ifdef VK_ENABLE_BETA_EXTENSIONS
 451     VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT = 1000038005,
 452 #endif
 453 #ifdef VK_ENABLE_BETA_EXTENSIONS
 454     VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_EXT = 1000038006,
 455 #endif
 456 #ifdef VK_ENABLE_BETA_EXTENSIONS
 457     VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT = 1000038007,
 458 #endif
 459 #ifdef VK_ENABLE_BETA_EXTENSIONS
 460     VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT = 1000038008,
 461 #endif
 462 #ifdef VK_ENABLE_BETA_EXTENSIONS
 463     VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT = 1000040000,
 464 #endif
 465 #ifdef VK_ENABLE_BETA_EXTENSIONS
 466     VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT = 1000040001,
 467 #endif
 468 #ifdef VK_ENABLE_BETA_EXTENSIONS
 469     VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT = 1000040002,
 470 #endif
 471 #ifdef VK_ENABLE_BETA_EXTENSIONS
 472     VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT = 1000040003,
 473 #endif
 474 #ifdef VK_ENABLE_BETA_EXTENSIONS
 475     VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT = 1000040004,
 476 #endif
 477 #ifdef VK_ENABLE_BETA_EXTENSIONS
 478     VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT = 1000040005,
 479 #endif
 480 #ifdef VK_ENABLE_BETA_EXTENSIONS
 481     VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT = 1000040006,
 482 #endif
 483 #ifdef VK_ENABLE_BETA_EXTENSIONS
 484     VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT = 1000040007,
 485 #endif
 486     VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD = 1000041000,
 487     VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP = 1000049000,
 488     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV = 1000050000,
 489     VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000,
 490     VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001,
 491     VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000,
 492     VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057001,
 493     VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000,
 494     VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = 1000061000,
 495     VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN = 1000062000,
 496     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT = 1000066000,
 497     VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT = 1000067000,
 498     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT = 1000067001,
 499     VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073000,
 500     VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073001,
 501     VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR = 1000073002,
 502     VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR = 1000073003,
 503     VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR = 1000074000,
 504     VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR = 1000074001,
 505     VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR = 1000074002,
 506     VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR = 1000075000,
 507     VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078000,
 508     VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078001,
 509     VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR = 1000078002,
 510     VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR = 1000078003,
 511     VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR = 1000079000,
 512     VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR = 1000079001,
 513     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = 1000080000,
 514     VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT = 1000081000,
 515     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT = 1000081001,
 516     VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT = 1000081002,
 517     VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000,
 518     VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV = 1000087000,
 519     VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT = 1000090000,
 520     VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT = 1000091000,
 521     VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT = 1000091001,
 522     VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT = 1000091002,
 523     VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT = 1000091003,
 524     VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE = 1000092000,
 525     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX = 1000097000,
 526     VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV = 1000098000,
 527     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT = 1000099000,
 528     VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT = 1000099001,
 529     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT = 1000101000,
 530     VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT = 1000101001,
 531     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT = 1000102000,
 532     VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT = 1000102001,
 533     VK_STRUCTURE_TYPE_HDR_METADATA_EXT = 1000105000,
 534     VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000,
 535     VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114000,
 536     VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114001,
 537     VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR = 1000114002,
 538     VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR = 1000115000,
 539     VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR = 1000115001,
 540     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR = 1000116000,
 541     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR = 1000116001,
 542     VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR = 1000116002,
 543     VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR = 1000116003,
 544     VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR = 1000116004,
 545     VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR = 1000116005,
 546     VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR = 1000116006,
 547     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000,
 548     VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001,
 549     VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002,
 550     VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR = 1000121000,
 551     VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR = 1000121001,
 552     VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR = 1000121002,
 553     VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR = 1000121003,
 554     VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR = 1000121004,
 555     VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK = 1000122000,
 556     VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = 1000123000,
 557     VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT = 1000128000,
 558     VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT = 1000128001,
 559     VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT = 1000128002,
 560     VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT = 1000128003,
 561     VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT = 1000128004,
 562     VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID = 1000129000,
 563     VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID = 1000129001,
 564     VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID = 1000129002,
 565     VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129003,
 566     VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129004,
 567     VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID = 1000129005,
 568     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT = 1000138000,
 569     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT = 1000138001,
 570     VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT = 1000138002,
 571     VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT = 1000138003,
 572     VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT = 1000143000,
 573     VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT = 1000143001,
 574     VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT = 1000143002,
 575     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT = 1000143003,
 576     VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT = 1000143004,
 577     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT = 1000148000,
 578     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT = 1000148001,
 579     VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT = 1000148002,
 580     VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV = 1000149000,
 581     VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR = 1000150007,
 582     VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR = 1000150000,
 583     VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR = 1000150002,
 584     VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR = 1000150003,
 585     VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR = 1000150004,
 586     VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR = 1000150005,
 587     VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR = 1000150006,
 588     VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR = 1000150009,
 589     VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR = 1000150010,
 590     VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR = 1000150011,
 591     VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR = 1000150012,
 592     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR = 1000150013,
 593     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR = 1000150014,
 594     VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR = 1000150017,
 595     VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR = 1000150020,
 596     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR = 1000347000,
 597     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR = 1000347001,
 598     VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR = 1000150015,
 599     VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR = 1000150016,
 600     VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR = 1000150018,
 601     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR = 1000348013,
 602     VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV = 1000152000,
 603     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV = 1000154000,
 604     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV = 1000154001,
 605     VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT = 1000158000,
 606     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT = 1000158002,
 607     VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT = 1000158003,
 608     VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT = 1000158004,
 609     VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT = 1000158005,
 610     VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160000,
 611     VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160001,
 612 #ifdef VK_ENABLE_BETA_EXTENSIONS
 613     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR = 1000163000,
 614 #endif
 615 #ifdef VK_ENABLE_BETA_EXTENSIONS
 616     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR = 1000163001,
 617 #endif
 618     VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV = 1000164000,
 619     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV = 1000164001,
 620     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV = 1000164002,
 621     VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV = 1000164005,
 622     VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV = 1000165000,
 623     VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV = 1000165001,
 624     VK_STRUCTURE_TYPE_GEOMETRY_NV = 1000165003,
 625     VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV = 1000165004,
 626     VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV = 1000165005,
 627     VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV = 1000165006,
 628     VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV = 1000165007,
 629     VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV = 1000165008,
 630     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV = 1000165009,
 631     VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV = 1000165011,
 632     VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV = 1000165012,
 633     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV = 1000166000,
 634     VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV = 1000166001,
 635     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT = 1000170000,
 636     VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT = 1000170001,
 637     VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT = 1000174000,
 638     VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT = 1000178000,
 639     VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT = 1000178001,
 640     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002,
 641     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR = 1000181000,
 642     VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD = 1000183000,
 643     VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT = 1000184000,
 644     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD = 1000185000,
 645 #ifdef VK_ENABLE_BETA_EXTENSIONS
 646     VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT = 1000187000,
 647 #endif
 648 #ifdef VK_ENABLE_BETA_EXTENSIONS
 649     VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT = 1000187001,
 650 #endif
 651 #ifdef VK_ENABLE_BETA_EXTENSIONS
 652     VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT = 1000187002,
 653 #endif
 654 #ifdef VK_ENABLE_BETA_EXTENSIONS
 655     VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT = 1000187003,
 656 #endif
 657 #ifdef VK_ENABLE_BETA_EXTENSIONS
 658     VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT = 1000187004,
 659 #endif
 660 #ifdef VK_ENABLE_BETA_EXTENSIONS
 661     VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT = 1000187005,
 662 #endif
 663 #ifdef VK_ENABLE_BETA_EXTENSIONS
 664     VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT = 1000187006,
 665 #endif
 666     VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD = 1000189000,
 667     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT = 1000190000,
 668     VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT = 1000190001,
 669     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT = 1000190002,
 670     VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP = 1000191000,
 671     VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT = 1000192000,
 672     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV = 1000201000,
 673     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV = 1000202000,
 674     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV = 1000202001,
 675     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV = 1000203000,
 676     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV = 1000204000,
 677     VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV = 1000205000,
 678     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV = 1000205002,
 679     VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV = 1000206000,
 680     VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV = 1000206001,
 681     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL = 1000209000,
 682     VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL = 1000210000,
 683     VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL = 1000210001,
 684     VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL = 1000210002,
 685     VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL = 1000210003,
 686     VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL = 1000210004,
 687     VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL = 1000210005,
 688     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT = 1000212000,
 689     VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD = 1000213000,
 690     VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD = 1000213001,
 691     VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA = 1000214000,
 692     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR = 1000215000,
 693     VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT = 1000217000,
 694     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT = 1000218000,
 695     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT = 1000218001,
 696     VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT = 1000218002,
 697     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT = 1000225000,
 698     VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT = 1000225001,
 699     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT = 1000225002,
 700     VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR = 1000226000,
 701     VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR = 1000226001,
 702     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR = 1000226002,
 703     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR = 1000226003,
 704     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR = 1000226004,
 705     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD = 1000227000,
 706     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD = 1000229000,
 707     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT = 1000234000,
 708     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT = 1000237000,
 709     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT = 1000238000,
 710     VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT = 1000238001,
 711     VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR = 1000239000,
 712     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV = 1000240000,
 713     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT = 1000244000,
 714     VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT = 1000244002,
 715     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT = 1000245000,
 716     VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT = 1000247000,
 717     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR = 1000248000,
 718     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV = 1000249000,
 719     VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV = 1000249001,
 720     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV = 1000249002,
 721     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV = 1000250000,
 722     VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV = 1000250001,
 723     VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV = 1000250002,
 724     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT = 1000251000,
 725     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT = 1000252000,
 726     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT = 1000254000,
 727     VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT = 1000254001,
 728     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT = 1000254002,
 729     VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT = 1000255000,
 730     VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT = 1000255002,
 731     VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT = 1000255001,
 732     VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT = 1000256000,
 733     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT = 1000259000,
 734     VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT = 1000259001,
 735     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT = 1000259002,
 736     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT = 1000260000,
 737     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT = 1000265000,
 738     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT = 1000267000,
 739     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR = 1000269000,
 740     VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR = 1000269001,
 741     VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR = 1000269002,
 742     VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR = 1000269003,
 743     VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR = 1000269004,
 744     VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR = 1000269005,
 745     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT = 1000273000,
 746     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT = 1000276000,
 747     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV = 1000277000,
 748     VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV = 1000277001,
 749     VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV = 1000277002,
 750     VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV = 1000277003,
 751     VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV = 1000277004,
 752     VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV = 1000277005,
 753     VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV = 1000277006,
 754     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV = 1000277007,
 755     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV = 1000278000,
 756     VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV = 1000278001,
 757     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT = 1000281000,
 758     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT = 1000281001,
 759     VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM = 1000282000,
 760     VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM = 1000282001,
 761     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT = 1000284000,
 762     VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT = 1000284001,
 763     VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT = 1000284002,
 764     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT = 1000286000,
 765     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT = 1000286001,
 766     VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT = 1000287000,
 767     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT = 1000287001,
 768     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT = 1000287002,
 769     VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR = 1000290000,
 770     VK_STRUCTURE_TYPE_PRESENT_ID_KHR = 1000294000,
 771     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR = 1000294001,
 772     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT = 1000295000,
 773     VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT = 1000295001,
 774     VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO_EXT = 1000295002,
 775     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT = 1000297000,
 776 #ifdef VK_ENABLE_BETA_EXTENSIONS
 777     VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR = 1000299000,
 778 #endif
 779 #ifdef VK_ENABLE_BETA_EXTENSIONS
 780     VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR = 1000299001,
 781 #endif
 782     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV = 1000300000,
 783     VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV = 1000300001,
 784     VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR = 1000314000,
 785     VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR = 1000314001,
 786     VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR = 1000314002,
 787     VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR = 1000314003,
 788     VK_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR = 1000314004,
 789     VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR = 1000314005,
 790     VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR = 1000314006,
 791     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR = 1000314007,
 792     VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV = 1000314008,
 793     VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV = 1000314009,
 794     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR = 1000323000,
 795     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR = 1000325000,
 796     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV = 1000326000,
 797     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV = 1000326001,
 798     VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV = 1000326002,
 799     VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV = 1000327000,
 800     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV = 1000327001,
 801     VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV = 1000327002,
 802     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT = 1000330000,
 803     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT = 1000332000,
 804     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT = 1000332001,
 805     VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM = 1000333000,
 806     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT = 1000335000,
 807     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR = 1000336000,
 808     VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR = 1000337000,
 809     VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR = 1000337001,
 810     VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR = 1000337002,
 811     VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR = 1000337003,
 812     VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR = 1000337004,
 813     VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR = 1000337005,
 814     VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR = 1000337006,
 815     VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR = 1000337007,
 816     VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR = 1000337008,
 817     VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR = 1000337009,
 818     VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR = 1000337010,
 819     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT = 1000340000,
 820     VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT = 1000346000,
 821     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE = 1000351000,
 822     VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE = 1000351002,
 823     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT = 1000352000,
 824     VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT = 1000352001,
 825     VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT = 1000352002,
 826     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT = 1000353000,
 827     VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA = 1000364000,
 828     VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA = 1000364001,
 829     VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA = 1000364002,
 830     VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA = 1000365000,
 831     VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA = 1000365001,
 832     VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI = 1000369000,
 833     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI = 1000369001,
 834     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI = 1000369002,
 835     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI = 1000370000,
 836     VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV = 1000371000,
 837     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV = 1000371001,
 838     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT = 1000377000,
 839     VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX = 1000378000,
 840     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT = 1000381000,
 841     VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT = 1000381001,
 842     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT = 1000388000,
 843     VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT = 1000388001,
 844     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT = 1000392000,
 845     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT = 1000392001,
 846     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
 847     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES,
 848     VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
 849     VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO,
 850     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES,
 851     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES,
 852     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2,
 853     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2,
 854     VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2,
 855     VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2,
 856     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
 857     VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2,
 858     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2,
 859     VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2,
 860     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2,
 861     VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO,
 862     VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO,
 863     VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO,
 864     VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO,
 865     VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO,
 866     VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO,
 867     VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO,
 868     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES,
 869     VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO,
 870     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO,
 871     VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES,
 872     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO,
 873     VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES,
 874     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES,
 875     VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO,
 876     VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
 877     VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO,
 878     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO,
 879     VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES,
 880     VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO,
 881     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES,
 882     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES,
 883     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES,
 884     VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO,
 885     VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT,
 886     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES,
 887     VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO,
 888     VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO,
 889     VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO,
 890     VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2,
 891     VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2,
 892     VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2,
 893     VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2_KHR = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2,
 894     VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2,
 895     VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO,
 896     VK_STRUCTURE_TYPE_SUBPASS_END_INFO_KHR = VK_STRUCTURE_TYPE_SUBPASS_END_INFO,
 897     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO,
 898     VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES,
 899     VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO,
 900     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES,
 901     VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO,
 902     VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO,
 903     VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO,
 904     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
 905     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR,
 906     VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS,
 907     VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
 908     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES,
 909     VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO,
 910     VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2,
 911     VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2,
 912     VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2,
 913     VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2,
 914     VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2,
 915     VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO,
 916     VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO,
 917     VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO,
 918     VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO,
 919     VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO,
 920     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES,
 921     VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES,
 922     VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO,
 923     VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO,
 924     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO,
 925     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES,
 926     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES,
 927     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO,
 928     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT,
 929     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES,
 930     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT,
 931     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES,
 932     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES,
 933     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES,
 934     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES,
 935     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES,
 936     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES,
 937     VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE,
 938     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES,
 939     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES,
 940     VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO,
 941     VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO,
 942     VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO,
 943     VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO,
 944     VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL,
 945     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES,
 946     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES,
 947     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES,
 948     VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT,
 949     VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT,
 950     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT,
 951     VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO,
 952     VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO,
 953     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES,
 954     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES,
 955     VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO,
 956     VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO,
 957     VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO,
 958     VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO,
 959     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES,
 960     VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
 961 } VkStructureType;
 962
 963 typedef enum VkImageLayout {
 964     VK_IMAGE_LAYOUT_UNDEFINED = 0,
 965     VK_IMAGE_LAYOUT_GENERAL = 1,
 966     VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2,
 967     VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3,
 968     VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4,
 969     VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5,
 970     VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6,
 971     VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7,
 972     VK_IMAGE_LAYOUT_PREINITIALIZED = 8,
 973     VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL = 1000117000,
 974     VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL = 1000117001,
 975     VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL = 1000241000,
 976     VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL = 1000241001,
 977     VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL = 1000241002,
 978     VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL = 1000241003,
 979     VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002,
 980 #ifdef VK_ENABLE_BETA_EXTENSIONS
 981     VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR = 1000024000,
 982 #endif
 983 #ifdef VK_ENABLE_BETA_EXTENSIONS
 984     VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR = 1000024001,
 985 #endif
 986 #ifdef VK_ENABLE_BETA_EXTENSIONS
 987     VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR = 1000024002,
 988 #endif
 989     VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000,
 990     VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT = 1000218000,
 991     VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR = 1000164003,
 992 #ifdef VK_ENABLE_BETA_EXTENSIONS
 993     VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR = 1000299000,
 994 #endif
 995 #ifdef VK_ENABLE_BETA_EXTENSIONS
 996     VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR = 1000299001,
 997 #endif
 998 #ifdef VK_ENABLE_BETA_EXTENSIONS
 999     VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR = 1000299002,
1000 #endif
1001     VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR = 1000314000,
1002     VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR = 1000314001,
1003     VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL,
1004     VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL,
1005     VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV = VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR,
1006     VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL,
1007     VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL,
1008     VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL,
1009     VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL,
1010     VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF
1011 } VkImageLayout;
1012
1013 typedef enum VkObjectType {
1014     VK_OBJECT_TYPE_UNKNOWN = 0,
1015     VK_OBJECT_TYPE_INSTANCE = 1,
1016     VK_OBJECT_TYPE_PHYSICAL_DEVICE = 2,
1017     VK_OBJECT_TYPE_DEVICE = 3,
1018     VK_OBJECT_TYPE_QUEUE = 4,
1019     VK_OBJECT_TYPE_SEMAPHORE = 5,
1020     VK_OBJECT_TYPE_COMMAND_BUFFER = 6,
1021     VK_OBJECT_TYPE_FENCE = 7,
1022     VK_OBJECT_TYPE_DEVICE_MEMORY = 8,
1023     VK_OBJECT_TYPE_BUFFER = 9,
1024     VK_OBJECT_TYPE_IMAGE = 10,
1025     VK_OBJECT_TYPE_EVENT = 11,
1026     VK_OBJECT_TYPE_QUERY_POOL = 12,
1027     VK_OBJECT_TYPE_BUFFER_VIEW = 13,
1028     VK_OBJECT_TYPE_IMAGE_VIEW = 14,
1029     VK_OBJECT_TYPE_SHADER_MODULE = 15,
1030     VK_OBJECT_TYPE_PIPELINE_CACHE = 16,
1031     VK_OBJECT_TYPE_PIPELINE_LAYOUT = 17,
1032     VK_OBJECT_TYPE_RENDER_PASS = 18,
1033     VK_OBJECT_TYPE_PIPELINE = 19,
1034     VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 20,
1035     VK_OBJECT_TYPE_SAMPLER = 21,
1036     VK_OBJECT_TYPE_DESCRIPTOR_POOL = 22,
1037     VK_OBJECT_TYPE_DESCRIPTOR_SET = 23,
1038     VK_OBJECT_TYPE_FRAMEBUFFER = 24,
1039     VK_OBJECT_TYPE_COMMAND_POOL = 25,
1040     VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION = 1000156000,
1041     VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE = 1000085000,
1042     VK_OBJECT_TYPE_SURFACE_KHR = 1000000000,
1043     VK_OBJECT_TYPE_SWAPCHAIN_KHR = 1000001000,
1044     VK_OBJECT_TYPE_DISPLAY_KHR = 1000002000,
1045     VK_OBJECT_TYPE_DISPLAY_MODE_KHR = 1000002001,
1046     VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT = 1000011000,
1047 #ifdef VK_ENABLE_BETA_EXTENSIONS
1048     VK_OBJECT_TYPE_VIDEO_SESSION_KHR = 1000023000,
1049 #endif
1050 #ifdef VK_ENABLE_BETA_EXTENSIONS
1051     VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR = 1000023001,
1052 #endif
1053     VK_OBJECT_TYPE_CU_MODULE_NVX = 1000029000,
1054     VK_OBJECT_TYPE_CU_FUNCTION_NVX = 1000029001,
1055     VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT = 1000128000,
1056     VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR = 1000150000,
1057     VK_OBJECT_TYPE_VALIDATION_CACHE_EXT = 1000160000,
1058     VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000,
1059     VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL = 1000210000,
1060     VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR = 1000268000,
1061     VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV = 1000277000,
1062     VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT = 1000295000,
1063     VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE,
1064     VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION,
1065     VK_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF
1066 } VkObjectType;
1067
1068 typedef enum VkPipelineCacheHeaderVersion {
1069     VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1,
1070     VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF
1071 } VkPipelineCacheHeaderVersion;
1072
1073 typedef enum VkVendorId {
1074     VK_VENDOR_ID_VIV = 0x10001,
1075     VK_VENDOR_ID_VSI = 0x10002,
1076     VK_VENDOR_ID_KAZAN = 0x10003,
1077     VK_VENDOR_ID_CODEPLAY = 0x10004,
1078     VK_VENDOR_ID_MESA = 0x10005,
1079     VK_VENDOR_ID_POCL = 0x10006,
1080     VK_VENDOR_ID_MAX_ENUM = 0x7FFFFFFF
1081 } VkVendorId;
1082
1083 typedef enum VkSystemAllocationScope {
1084     VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0,
1085     VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1,
1086     VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2,
1087     VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3,
1088     VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4,
1089     VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF
1090 } VkSystemAllocationScope;
1091
1092 typedef enum VkInternalAllocationType {
1093     VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0,
1094     VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF
1095 } VkInternalAllocationType;
1096
1097 typedef enum VkFormat {
1098     VK_FORMAT_UNDEFINED = 0,
1099     VK_FORMAT_R4G4_UNORM_PACK8 = 1,
1100     VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2,
1101     VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3,
1102     VK_FORMAT_R5G6B5_UNORM_PACK16 = 4,
1103     VK_FORMAT_B5G6R5_UNORM_PACK16 = 5,
1104     VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6,
1105     VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7,
1106     VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8,
1107     VK_FORMAT_R8_UNORM = 9,
1108     VK_FORMAT_R8_SNORM = 10,
1109     VK_FORMAT_R8_USCALED = 11,
1110     VK_FORMAT_R8_SSCALED = 12,
1111     VK_FORMAT_R8_UINT = 13,
1112     VK_FORMAT_R8_SINT = 14,
1113     VK_FORMAT_R8_SRGB = 15,
1114     VK_FORMAT_R8G8_UNORM = 16,
1115     VK_FORMAT_R8G8_SNORM = 17,
1116     VK_FORMAT_R8G8_USCALED = 18,
1117     VK_FORMAT_R8G8_SSCALED = 19,
1118     VK_FORMAT_R8G8_UINT = 20,
1119     VK_FORMAT_R8G8_SINT = 21,
1120     VK_FORMAT_R8G8_SRGB = 22,
1121     VK_FORMAT_R8G8B8_UNORM = 23,
1122     VK_FORMAT_R8G8B8_SNORM = 24,
1123     VK_FORMAT_R8G8B8_USCALED = 25,
1124     VK_FORMAT_R8G8B8_SSCALED = 26,
1125     VK_FORMAT_R8G8B8_UINT = 27,
1126     VK_FORMAT_R8G8B8_SINT = 28,
1127     VK_FORMAT_R8G8B8_SRGB = 29,
1128     VK_FORMAT_B8G8R8_UNORM = 30,
1129     VK_FORMAT_B8G8R8_SNORM = 31,
1130     VK_FORMAT_B8G8R8_USCALED = 32,
1131     VK_FORMAT_B8G8R8_SSCALED = 33,
1132     VK_FORMAT_B8G8R8_UINT = 34,
1133     VK_FORMAT_B8G8R8_SINT = 35,
1134     VK_FORMAT_B8G8R8_SRGB = 36,
1135     VK_FORMAT_R8G8B8A8_UNORM = 37,
1136     VK_FORMAT_R8G8B8A8_SNORM = 38,
1137     VK_FORMAT_R8G8B8A8_USCALED = 39,
1138     VK_FORMAT_R8G8B8A8_SSCALED = 40,
1139     VK_FORMAT_R8G8B8A8_UINT = 41,
1140     VK_FORMAT_R8G8B8A8_SINT = 42,
1141     VK_FORMAT_R8G8B8A8_SRGB = 43,
1142     VK_FORMAT_B8G8R8A8_UNORM = 44,
1143     VK_FORMAT_B8G8R8A8_SNORM = 45,
1144     VK_FORMAT_B8G8R8A8_USCALED = 46,
1145     VK_FORMAT_B8G8R8A8_SSCALED = 47,
1146     VK_FORMAT_B8G8R8A8_UINT = 48,
1147     VK_FORMAT_B8G8R8A8_SINT = 49,
1148     VK_FORMAT_B8G8R8A8_SRGB = 50,
1149     VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51,
1150     VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52,
1151     VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53,
1152     VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54,
1153     VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55,
1154     VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56,
1155     VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57,
1156     VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58,
1157     VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59,
1158     VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60,
1159     VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61,
1160     VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62,
1161     VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63,
1162     VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64,
1163     VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65,
1164     VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66,
1165     VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67,
1166     VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68,
1167     VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69,
1168     VK_FORMAT_R16_UNORM = 70,
1169     VK_FORMAT_R16_SNORM = 71,
1170     VK_FORMAT_R16_USCALED = 72,
1171     VK_FORMAT_R16_SSCALED = 73,
1172     VK_FORMAT_R16_UINT = 74,
1173     VK_FORMAT_R16_SINT = 75,
1174     VK_FORMAT_R16_SFLOAT = 76,
1175     VK_FORMAT_R16G16_UNORM = 77,
1176     VK_FORMAT_R16G16_SNORM = 78,
1177     VK_FORMAT_R16G16_USCALED = 79,
1178     VK_FORMAT_R16G16_SSCALED = 80,
1179     VK_FORMAT_R16G16_UINT = 81,
1180     VK_FORMAT_R16G16_SINT = 82,
1181     VK_FORMAT_R16G16_SFLOAT = 83,
1182     VK_FORMAT_R16G16B16_UNORM = 84,
1183     VK_FORMAT_R16G16B16_SNORM = 85,
1184     VK_FORMAT_R16G16B16_USCALED = 86,
1185     VK_FORMAT_R16G16B16_SSCALED = 87,
1186     VK_FORMAT_R16G16B16_UINT = 88,
1187     VK_FORMAT_R16G16B16_SINT = 89,
1188     VK_FORMAT_R16G16B16_SFLOAT = 90,
1189     VK_FORMAT_R16G16B16A16_UNORM = 91,
1190     VK_FORMAT_R16G16B16A16_SNORM = 92,
1191     VK_FORMAT_R16G16B16A16_USCALED = 93,
1192     VK_FORMAT_R16G16B16A16_SSCALED = 94,
1193     VK_FORMAT_R16G16B16A16_UINT = 95,
1194     VK_FORMAT_R16G16B16A16_SINT = 96,
1195     VK_FORMAT_R16G16B16A16_SFLOAT = 97,
1196     VK_FORMAT_R32_UINT = 98,
1197     VK_FORMAT_R32_SINT = 99,
1198     VK_FORMAT_R32_SFLOAT = 100,
1199     VK_FORMAT_R32G32_UINT = 101,
1200     VK_FORMAT_R32G32_SINT = 102,
1201     VK_FORMAT_R32G32_SFLOAT = 103,
1202     VK_FORMAT_R32G32B32_UINT = 104,
1203     VK_FORMAT_R32G32B32_SINT = 105,
1204     VK_FORMAT_R32G32B32_SFLOAT = 106,
1205     VK_FORMAT_R32G32B32A32_UINT = 107,
1206     VK_FORMAT_R32G32B32A32_SINT = 108,
1207     VK_FORMAT_R32G32B32A32_SFLOAT = 109,
1208     VK_FORMAT_R64_UINT = 110,
1209     VK_FORMAT_R64_SINT = 111,
1210     VK_FORMAT_R64_SFLOAT = 112,
1211     VK_FORMAT_R64G64_UINT = 113,
1212     VK_FORMAT_R64G64_SINT = 114,
1213     VK_FORMAT_R64G64_SFLOAT = 115,
1214     VK_FORMAT_R64G64B64_UINT = 116,
1215     VK_FORMAT_R64G64B64_SINT = 117,
1216     VK_FORMAT_R64G64B64_SFLOAT = 118,
1217     VK_FORMAT_R64G64B64A64_UINT = 119,
1218     VK_FORMAT_R64G64B64A64_SINT = 120,
1219     VK_FORMAT_R64G64B64A64_SFLOAT = 121,
1220     VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122,
1221     VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123,
1222     VK_FORMAT_D16_UNORM = 124,
1223     VK_FORMAT_X8_D24_UNORM_PACK32 = 125,
1224     VK_FORMAT_D32_SFLOAT = 126,
1225     VK_FORMAT_S8_UINT = 127,
1226     VK_FORMAT_D16_UNORM_S8_UINT = 128,
1227     VK_FORMAT_D24_UNORM_S8_UINT = 129,
1228     VK_FORMAT_D32_SFLOAT_S8_UINT = 130,
1229     VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131,
1230     VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132,
1231     VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133,
1232     VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134,
1233     VK_FORMAT_BC2_UNORM_BLOCK = 135,
1234     VK_FORMAT_BC2_SRGB_BLOCK = 136,
1235     VK_FORMAT_BC3_UNORM_BLOCK = 137,
1236     VK_FORMAT_BC3_SRGB_BLOCK = 138,
1237     VK_FORMAT_BC4_UNORM_BLOCK = 139,
1238     VK_FORMAT_BC4_SNORM_BLOCK = 140,
1239     VK_FORMAT_BC5_UNORM_BLOCK = 141,
1240     VK_FORMAT_BC5_SNORM_BLOCK = 142,
1241     VK_FORMAT_BC6H_UFLOAT_BLOCK = 143,
1242     VK_FORMAT_BC6H_SFLOAT_BLOCK = 144,
1243     VK_FORMAT_BC7_UNORM_BLOCK = 145,
1244     VK_FORMAT_BC7_SRGB_BLOCK = 146,
1245     VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147,
1246     VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148,
1247     VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149,
1248     VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150,
1249     VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151,
1250     VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152,
1251     VK_FORMAT_EAC_R11_UNORM_BLOCK = 153,
1252     VK_FORMAT_EAC_R11_SNORM_BLOCK = 154,
1253     VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155,
1254     VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156,
1255     VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157,
1256     VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158,
1257     VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159,
1258     VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160,
1259     VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161,
1260     VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162,
1261     VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163,
1262     VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164,
1263     VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165,
1264     VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166,
1265     VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167,
1266     VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168,
1267     VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169,
1268     VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170,
1269     VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171,
1270     VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172,
1271     VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173,
1272     VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174,
1273     VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175,
1274     VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176,
1275     VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177,
1276     VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178,
1277     VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179,
1278     VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180,
1279     VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181,
1280     VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182,
1281     VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183,
1282     VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184,
1283     VK_FORMAT_G8B8G8R8_422_UNORM = 1000156000,
1284     VK_FORMAT_B8G8R8G8_422_UNORM = 1000156001,
1285     VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM = 1000156002,
1286     VK_FORMAT_G8_B8R8_2PLANE_420_UNORM = 1000156003,
1287     VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM = 1000156004,
1288     VK_FORMAT_G8_B8R8_2PLANE_422_UNORM = 1000156005,
1289     VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM = 1000156006,
1290     VK_FORMAT_R10X6_UNORM_PACK16 = 1000156007,
1291     VK_FORMAT_R10X6G10X6_UNORM_2PACK16 = 1000156008,
1292     VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 = 1000156009,
1293     VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 = 1000156010,
1294     VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 = 1000156011,
1295     VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 = 1000156012,
1296     VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 = 1000156013,
1297     VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 = 1000156014,
1298     VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 = 1000156015,
1299     VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 = 1000156016,
1300     VK_FORMAT_R12X4_UNORM_PACK16 = 1000156017,
1301     VK_FORMAT_R12X4G12X4_UNORM_2PACK16 = 1000156018,
1302     VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 = 1000156019,
1303     VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 = 1000156020,
1304     VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 = 1000156021,
1305     VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 = 1000156022,
1306     VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 = 1000156023,
1307     VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 = 1000156024,
1308     VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 = 1000156025,
1309     VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 = 1000156026,
1310     VK_FORMAT_G16B16G16R16_422_UNORM = 1000156027,
1311     VK_FORMAT_B16G16R16G16_422_UNORM = 1000156028,
1312     VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM = 1000156029,
1313     VK_FORMAT_G16_B16R16_2PLANE_420_UNORM = 1000156030,
1314     VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM = 1000156031,
1315     VK_FORMAT_G16_B16R16_2PLANE_422_UNORM = 1000156032,
1316     VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM = 1000156033,
1317     VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000,
1318     VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001,
1319     VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002,
1320     VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003,
1321     VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004,
1322     VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005,
1323     VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006,
1324     VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007,
1325     VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT = 1000066000,
1326     VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT = 1000066001,
1327     VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT = 1000066002,
1328     VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT = 1000066003,
1329     VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT = 1000066004,
1330     VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT = 1000066005,
1331     VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT = 1000066006,
1332     VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT = 1000066007,
1333     VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT = 1000066008,
1334     VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT = 1000066009,
1335     VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT = 1000066010,
1336     VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT = 1000066011,
1337     VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT = 1000066012,
1338     VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT = 1000066013,
1339     VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT = 1000330000,
1340     VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT = 1000330001,
1341     VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT = 1000330002,
1342     VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT = 1000330003,
1343     VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT = 1000340000,
1344     VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT = 1000340001,
1345     VK_FORMAT_G8B8G8R8_422_UNORM_KHR = VK_FORMAT_G8B8G8R8_422_UNORM,
1346     VK_FORMAT_B8G8R8G8_422_UNORM_KHR = VK_FORMAT_B8G8R8G8_422_UNORM,
1347     VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM,
1348     VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM,
1349     VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM,
1350     VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM,
1351     VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM,
1352     VK_FORMAT_R10X6_UNORM_PACK16_KHR = VK_FORMAT_R10X6_UNORM_PACK16,
1353     VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR = VK_FORMAT_R10X6G10X6_UNORM_2PACK16,
1354     VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16,
1355     VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR = VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16,
1356     VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16,
1357     VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16,
1358     VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16,
1359     VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16,
1360     VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16,
1361     VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16,
1362     VK_FORMAT_R12X4_UNORM_PACK16_KHR = VK_FORMAT_R12X4_UNORM_PACK16,
1363     VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR = VK_FORMAT_R12X4G12X4_UNORM_2PACK16,
1364     VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR = VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16,
1365     VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR = VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16,
1366     VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR = VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16,
1367     VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16,
1368     VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16,
1369     VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16,
1370     VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16,
1371     VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16,
1372     VK_FORMAT_G16B16G16R16_422_UNORM_KHR = VK_FORMAT_G16B16G16R16_422_UNORM,
1373     VK_FORMAT_B16G16R16G16_422_UNORM_KHR = VK_FORMAT_B16G16R16G16_422_UNORM,
1374     VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM,
1375     VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM,
1376     VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM,
1377     VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM,
1378     VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM,
1379     VK_FORMAT_MAX_ENUM = 0x7FFFFFFF
1380 } VkFormat;
1381
1382 typedef enum VkImageTiling {
1383     VK_IMAGE_TILING_OPTIMAL = 0,
1384     VK_IMAGE_TILING_LINEAR = 1,
1385     VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT = 1000158000,
1386     VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF
1387 } VkImageTiling;
1388
1389 typedef enum VkImageType {
1390     VK_IMAGE_TYPE_1D = 0,
1391     VK_IMAGE_TYPE_2D = 1,
1392     VK_IMAGE_TYPE_3D = 2,
1393     VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF
1394 } VkImageType;
1395
1396 typedef enum VkPhysicalDeviceType {
1397     VK_PHYSICAL_DEVICE_TYPE_OTHER = 0,
1398     VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1,
1399     VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2,
1400     VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3,
1401     VK_PHYSICAL_DEVICE_TYPE_CPU = 4,
1402     VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF
1403 } VkPhysicalDeviceType;
1404
1405 typedef enum VkQueryType {
1406     VK_QUERY_TYPE_OCCLUSION = 0,
1407     VK_QUERY_TYPE_PIPELINE_STATISTICS = 1,
1408     VK_QUERY_TYPE_TIMESTAMP = 2,
1409 #ifdef VK_ENABLE_BETA_EXTENSIONS
1410     VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR = 1000023000,
1411 #endif
1412     VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT = 1000028004,
1413     VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR = 1000116000,
1414     VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR = 1000150000,
1415     VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR = 1000150001,
1416     VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV = 1000165000,
1417     VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL = 1000210000,
1418 #ifdef VK_ENABLE_BETA_EXTENSIONS
1419     VK_QUERY_TYPE_VIDEO_ENCODE_BITSTREAM_BUFFER_RANGE_KHR = 1000299000,
1420 #endif
1421     VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF
1422 } VkQueryType;
1423
1424 typedef enum VkSharingMode {
1425     VK_SHARING_MODE_EXCLUSIVE = 0,
1426     VK_SHARING_MODE_CONCURRENT = 1,
1427     VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF
1428 } VkSharingMode;
1429
1430 typedef enum VkComponentSwizzle {
1431     VK_COMPONENT_SWIZZLE_IDENTITY = 0,
1432     VK_COMPONENT_SWIZZLE_ZERO = 1,
1433     VK_COMPONENT_SWIZZLE_ONE = 2,
1434     VK_COMPONENT_SWIZZLE_R = 3,
1435     VK_COMPONENT_SWIZZLE_G = 4,
1436     VK_COMPONENT_SWIZZLE_B = 5,
1437     VK_COMPONENT_SWIZZLE_A = 6,
1438     VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF
1439 } VkComponentSwizzle;
1440
1441 typedef enum VkImageViewType {
1442     VK_IMAGE_VIEW_TYPE_1D = 0,
1443     VK_IMAGE_VIEW_TYPE_2D = 1,
1444     VK_IMAGE_VIEW_TYPE_3D = 2,
1445     VK_IMAGE_VIEW_TYPE_CUBE = 3,
1446     VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4,
1447     VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5,
1448     VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6,
1449     VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF
1450 } VkImageViewType;
1451
1452 typedef enum VkBlendFactor {
1453     VK_BLEND_FACTOR_ZERO = 0,
1454     VK_BLEND_FACTOR_ONE = 1,
1455     VK_BLEND_FACTOR_SRC_COLOR = 2,
1456     VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3,
1457     VK_BLEND_FACTOR_DST_COLOR = 4,
1458     VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5,
1459     VK_BLEND_FACTOR_SRC_ALPHA = 6,
1460     VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7,
1461     VK_BLEND_FACTOR_DST_ALPHA = 8,
1462     VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9,
1463     VK_BLEND_FACTOR_CONSTANT_COLOR = 10,
1464     VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11,
1465     VK_BLEND_FACTOR_CONSTANT_ALPHA = 12,
1466     VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13,
1467     VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14,
1468     VK_BLEND_FACTOR_SRC1_COLOR = 15,
1469     VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16,
1470     VK_BLEND_FACTOR_SRC1_ALPHA = 17,
1471     VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18,
1472     VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF
1473 } VkBlendFactor;
1474
1475 typedef enum VkBlendOp {
1476     VK_BLEND_OP_ADD = 0,
1477     VK_BLEND_OP_SUBTRACT = 1,
1478     VK_BLEND_OP_REVERSE_SUBTRACT = 2,
1479     VK_BLEND_OP_MIN = 3,
1480     VK_BLEND_OP_MAX = 4,
1481     VK_BLEND_OP_ZERO_EXT = 1000148000,
1482     VK_BLEND_OP_SRC_EXT = 1000148001,
1483     VK_BLEND_OP_DST_EXT = 1000148002,
1484     VK_BLEND_OP_SRC_OVER_EXT = 1000148003,
1485     VK_BLEND_OP_DST_OVER_EXT = 1000148004,
1486     VK_BLEND_OP_SRC_IN_EXT = 1000148005,
1487     VK_BLEND_OP_DST_IN_EXT = 1000148006,
1488     VK_BLEND_OP_SRC_OUT_EXT = 1000148007,
1489     VK_BLEND_OP_DST_OUT_EXT = 1000148008,
1490     VK_BLEND_OP_SRC_ATOP_EXT = 1000148009,
1491     VK_BLEND_OP_DST_ATOP_EXT = 1000148010,
1492     VK_BLEND_OP_XOR_EXT = 1000148011,
1493     VK_BLEND_OP_MULTIPLY_EXT = 1000148012,
1494     VK_BLEND_OP_SCREEN_EXT = 1000148013,
1495     VK_BLEND_OP_OVERLAY_EXT = 1000148014,
1496     VK_BLEND_OP_DARKEN_EXT = 1000148015,
1497     VK_BLEND_OP_LIGHTEN_EXT = 1000148016,
1498     VK_BLEND_OP_COLORDODGE_EXT = 1000148017,
1499     VK_BLEND_OP_COLORBURN_EXT = 1000148018,
1500     VK_BLEND_OP_HARDLIGHT_EXT = 1000148019,
1501     VK_BLEND_OP_SOFTLIGHT_EXT = 1000148020,
1502     VK_BLEND_OP_DIFFERENCE_EXT = 1000148021,
1503     VK_BLEND_OP_EXCLUSION_EXT = 1000148022,
1504     VK_BLEND_OP_INVERT_EXT = 1000148023,
1505     VK_BLEND_OP_INVERT_RGB_EXT = 1000148024,
1506     VK_BLEND_OP_LINEARDODGE_EXT = 1000148025,
1507     VK_BLEND_OP_LINEARBURN_EXT = 1000148026,
1508     VK_BLEND_OP_VIVIDLIGHT_EXT = 1000148027,
1509     VK_BLEND_OP_LINEARLIGHT_EXT = 1000148028,
1510     VK_BLEND_OP_PINLIGHT_EXT = 1000148029,
1511     VK_BLEND_OP_HARDMIX_EXT = 1000148030,
1512     VK_BLEND_OP_HSL_HUE_EXT = 1000148031,
1513     VK_BLEND_OP_HSL_SATURATION_EXT = 1000148032,
1514     VK_BLEND_OP_HSL_COLOR_EXT = 1000148033,
1515     VK_BLEND_OP_HSL_LUMINOSITY_EXT = 1000148034,
1516     VK_BLEND_OP_PLUS_EXT = 1000148035,
1517     VK_BLEND_OP_PLUS_CLAMPED_EXT = 1000148036,
1518     VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT = 1000148037,
1519     VK_BLEND_OP_PLUS_DARKER_EXT = 1000148038,
1520     VK_BLEND_OP_MINUS_EXT = 1000148039,
1521     VK_BLEND_OP_MINUS_CLAMPED_EXT = 1000148040,
1522     VK_BLEND_OP_CONTRAST_EXT = 1000148041,
1523     VK_BLEND_OP_INVERT_OVG_EXT = 1000148042,
1524     VK_BLEND_OP_RED_EXT = 1000148043,
1525     VK_BLEND_OP_GREEN_EXT = 1000148044,
1526     VK_BLEND_OP_BLUE_EXT = 1000148045,
1527     VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF
1528 } VkBlendOp;
1529
1530 typedef enum VkCompareOp {
1531     VK_COMPARE_OP_NEVER = 0,
1532     VK_COMPARE_OP_LESS = 1,
1533     VK_COMPARE_OP_EQUAL = 2,
1534     VK_COMPARE_OP_LESS_OR_EQUAL = 3,
1535     VK_COMPARE_OP_GREATER = 4,
1536     VK_COMPARE_OP_NOT_EQUAL = 5,
1537     VK_COMPARE_OP_GREATER_OR_EQUAL = 6,
1538     VK_COMPARE_OP_ALWAYS = 7,
1539     VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF
1540 } VkCompareOp;
1541
1542 typedef enum VkDynamicState {
1543     VK_DYNAMIC_STATE_VIEWPORT = 0,
1544     VK_DYNAMIC_STATE_SCISSOR = 1,
1545     VK_DYNAMIC_STATE_LINE_WIDTH = 2,
1546     VK_DYNAMIC_STATE_DEPTH_BIAS = 3,
1547     VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4,
1548     VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5,
1549     VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6,
1550     VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7,
1551     VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8,
1552     VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV = 1000087000,
1553     VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = 1000099000,
1554     VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT = 1000143000,
1555     VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR = 1000347000,
1556     VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV = 1000164004,
1557     VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV = 1000164006,
1558     VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV = 1000205001,
1559     VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR = 1000226000,
1560     VK_DYNAMIC_STATE_LINE_STIPPLE_EXT = 1000259000,
1561     VK_DYNAMIC_STATE_CULL_MODE_EXT = 1000267000,
1562     VK_DYNAMIC_STATE_FRONT_FACE_EXT = 1000267001,
1563     VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT = 1000267002,
1564     VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT = 1000267003,
1565     VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT = 1000267004,
1566     VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT = 1000267005,
1567     VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT = 1000267006,
1568     VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT = 1000267007,
1569     VK_DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT = 1000267008,
1570     VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT = 1000267009,
1571     VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT = 1000267010,
1572     VK_DYNAMIC_STATE_STENCIL_OP_EXT = 1000267011,
1573     VK_DYNAMIC_STATE_VERTEX_INPUT_EXT = 1000352000,
1574     VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT = 1000377000,
1575     VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT = 1000377001,
1576     VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT = 1000377002,
1577     VK_DYNAMIC_STATE_LOGIC_OP_EXT = 1000377003,
1578     VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT = 1000377004,
1579     VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT = 1000381000,
1580     VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF
1581 } VkDynamicState;
1582
1583 typedef enum VkFrontFace {
1584     VK_FRONT_FACE_COUNTER_CLOCKWISE = 0,
1585     VK_FRONT_FACE_CLOCKWISE = 1,
1586     VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF
1587 } VkFrontFace;
1588
1589 typedef enum VkVertexInputRate {
1590     VK_VERTEX_INPUT_RATE_VERTEX = 0,
1591     VK_VERTEX_INPUT_RATE_INSTANCE = 1,
1592     VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF
1593 } VkVertexInputRate;
1594
1595 typedef enum VkPrimitiveTopology {
1596     VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0,
1597     VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1,
1598     VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2,
1599     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3,
1600     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4,
1601     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5,
1602     VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6,
1603     VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7,
1604     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8,
1605     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9,
1606     VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10,
1607     VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF
1608 } VkPrimitiveTopology;
1609
1610 typedef enum VkPolygonMode {
1611     VK_POLYGON_MODE_FILL = 0,
1612     VK_POLYGON_MODE_LINE = 1,
1613     VK_POLYGON_MODE_POINT = 2,
1614     VK_POLYGON_MODE_FILL_RECTANGLE_NV = 1000153000,
1615     VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF
1616 } VkPolygonMode;
1617
1618 typedef enum VkStencilOp {
1619     VK_STENCIL_OP_KEEP = 0,
1620     VK_STENCIL_OP_ZERO = 1,
1621     VK_STENCIL_OP_REPLACE = 2,
1622     VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3,
1623     VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4,
1624     VK_STENCIL_OP_INVERT = 5,
1625     VK_STENCIL_OP_INCREMENT_AND_WRAP = 6,
1626     VK_STENCIL_OP_DECREMENT_AND_WRAP = 7,
1627     VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF
1628 } VkStencilOp;
1629
1630 typedef enum VkLogicOp {
1631     VK_LOGIC_OP_CLEAR = 0,
1632     VK_LOGIC_OP_AND = 1,
1633     VK_LOGIC_OP_AND_REVERSE = 2,
1634     VK_LOGIC_OP_COPY = 3,
1635     VK_LOGIC_OP_AND_INVERTED = 4,
1636     VK_LOGIC_OP_NO_OP = 5,
1637     VK_LOGIC_OP_XOR = 6,
1638     VK_LOGIC_OP_OR = 7,
1639     VK_LOGIC_OP_NOR = 8,
1640     VK_LOGIC_OP_EQUIVALENT = 9,
1641     VK_LOGIC_OP_INVERT = 10,
1642     VK_LOGIC_OP_OR_REVERSE = 11,
1643     VK_LOGIC_OP_COPY_INVERTED = 12,
1644     VK_LOGIC_OP_OR_INVERTED = 13,
1645     VK_LOGIC_OP_NAND = 14,
1646     VK_LOGIC_OP_SET = 15,
1647     VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF
1648 } VkLogicOp;
1649
1650 typedef enum VkBorderColor {
1651     VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0,
1652     VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1,
1653     VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2,
1654     VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3,
1655     VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4,
1656     VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5,
1657     VK_BORDER_COLOR_FLOAT_CUSTOM_EXT = 1000287003,
1658     VK_BORDER_COLOR_INT_CUSTOM_EXT = 1000287004,
1659     VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF
1660 } VkBorderColor;
1661
1662 typedef enum VkFilter {
1663     VK_FILTER_NEAREST = 0,
1664     VK_FILTER_LINEAR = 1,
1665     VK_FILTER_CUBIC_IMG = 1000015000,
1666     VK_FILTER_CUBIC_EXT = VK_FILTER_CUBIC_IMG,
1667     VK_FILTER_MAX_ENUM = 0x7FFFFFFF
1668 } VkFilter;
1669
1670 typedef enum VkSamplerAddressMode {
1671     VK_SAMPLER_ADDRESS_MODE_REPEAT = 0,
1672     VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1,
1673     VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2,
1674     VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3,
1675     VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4,
1676     VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE_KHR = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE,
1677     VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF
1678 } VkSamplerAddressMode;
1679
1680 typedef enum VkSamplerMipmapMode {
1681     VK_SAMPLER_MIPMAP_MODE_NEAREST = 0,
1682     VK_SAMPLER_MIPMAP_MODE_LINEAR = 1,
1683     VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF
1684 } VkSamplerMipmapMode;
1685
1686 typedef enum VkDescriptorType {
1687     VK_DESCRIPTOR_TYPE_SAMPLER = 0,
1688     VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1,
1689     VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2,
1690     VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3,
1691     VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4,
1692     VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5,
1693     VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6,
1694     VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7,
1695     VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8,
1696     VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9,
1697     VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10,
1698     VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT = 1000138000,
1699     VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR = 1000150000,
1700     VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000,
1701     VK_DESCRIPTOR_TYPE_MUTABLE_VALVE = 1000351000,
1702     VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF
1703 } VkDescriptorType;
1704
1705 typedef enum VkAttachmentLoadOp {
1706     VK_ATTACHMENT_LOAD_OP_LOAD = 0,
1707     VK_ATTACHMENT_LOAD_OP_CLEAR = 1,
1708     VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2,
1709     VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF
1710 } VkAttachmentLoadOp;
1711
1712 typedef enum VkAttachmentStoreOp {
1713     VK_ATTACHMENT_STORE_OP_STORE = 0,
1714     VK_ATTACHMENT_STORE_OP_DONT_CARE = 1,
1715     VK_ATTACHMENT_STORE_OP_NONE_QCOM = 1000301000,
1716     VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF
1717 } VkAttachmentStoreOp;
1718
1719 typedef enum VkPipelineBindPoint {
1720     VK_PIPELINE_BIND_POINT_GRAPHICS = 0,
1721     VK_PIPELINE_BIND_POINT_COMPUTE = 1,
1722     VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR = 1000165000,
1723     VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI = 1000369003,
1724     VK_PIPELINE_BIND_POINT_RAY_TRACING_NV = VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR,
1725     VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF
1726 } VkPipelineBindPoint;
1727
1728 typedef enum VkCommandBufferLevel {
1729     VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0,
1730     VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1,
1731     VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF
1732 } VkCommandBufferLevel;
1733
1734 typedef enum VkIndexType {
1735     VK_INDEX_TYPE_UINT16 = 0,
1736     VK_INDEX_TYPE_UINT32 = 1,
1737     VK_INDEX_TYPE_NONE_KHR = 1000165000,
1738     VK_INDEX_TYPE_UINT8_EXT = 1000265000,
1739     VK_INDEX_TYPE_NONE_NV = VK_INDEX_TYPE_NONE_KHR,
1740     VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF
1741 } VkIndexType;
1742
1743 typedef enum VkSubpassContents {
1744     VK_SUBPASS_CONTENTS_INLINE = 0,
1745     VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1,
1746     VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF
1747 } VkSubpassContents;
1748
1749 typedef enum VkAccessFlagBits {
1750     VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001,
1751     VK_ACCESS_INDEX_READ_BIT = 0x00000002,
1752     VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004,
1753     VK_ACCESS_UNIFORM_READ_BIT = 0x00000008,
1754     VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0x00000010,
1755     VK_ACCESS_SHADER_READ_BIT = 0x00000020,
1756     VK_ACCESS_SHADER_WRITE_BIT = 0x00000040,
1757     VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0x00000080,
1758     VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100,
1759     VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200,
1760     VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400,
1761     VK_ACCESS_TRANSFER_READ_BIT = 0x00000800,
1762     VK_ACCESS_TRANSFER_WRITE_BIT = 0x00001000,
1763     VK_ACCESS_HOST_READ_BIT = 0x00002000,
1764     VK_ACCESS_HOST_WRITE_BIT = 0x00004000,
1765     VK_ACCESS_MEMORY_READ_BIT = 0x00008000,
1766     VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000,
1767     VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT = 0x02000000,
1768     VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT = 0x04000000,
1769     VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT = 0x08000000,
1770     VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT = 0x00100000,
1771     VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000,
1772     VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR = 0x00200000,
1773     VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR = 0x00400000,
1774     VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT = 0x01000000,
1775     VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR = 0x00800000,
1776     VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV = 0x00020000,
1777     VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV = 0x00040000,
1778     VK_ACCESS_NONE_KHR = 0,
1779     VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV = VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR,
1780     VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV = VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR,
1781     VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV = VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR,
1782     VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1783 } VkAccessFlagBits;
1784 typedef VkFlags VkAccessFlags;
1785
1786 typedef enum VkImageAspectFlagBits {
1787     VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001,
1788     VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002,
1789     VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004,
1790     VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008,
1791     VK_IMAGE_ASPECT_PLANE_0_BIT = 0x00000010,
1792     VK_IMAGE_ASPECT_PLANE_1_BIT = 0x00000020,
1793     VK_IMAGE_ASPECT_PLANE_2_BIT = 0x00000040,
1794     VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT = 0x00000080,
1795     VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT = 0x00000100,
1796     VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT = 0x00000200,
1797     VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT = 0x00000400,
1798     VK_IMAGE_ASPECT_PLANE_0_BIT_KHR = VK_IMAGE_ASPECT_PLANE_0_BIT,
1799     VK_IMAGE_ASPECT_PLANE_1_BIT_KHR = VK_IMAGE_ASPECT_PLANE_1_BIT,
1800     VK_IMAGE_ASPECT_PLANE_2_BIT_KHR = VK_IMAGE_ASPECT_PLANE_2_BIT,
1801     VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1802 } VkImageAspectFlagBits;
1803 typedef VkFlags VkImageAspectFlags;
1804
1805 typedef enum VkFormatFeatureFlagBits {
1806     VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001,
1807     VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002,
1808     VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004,
1809     VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008,
1810     VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010,
1811     VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020,
1812     VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040,
1813     VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080,
1814     VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100,
1815     VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200,
1816     VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400,
1817     VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800,
1818     VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000,
1819     VK_FORMAT_FEATURE_TRANSFER_SRC_BIT = 0x00004000,
1820     VK_FORMAT_FEATURE_TRANSFER_DST_BIT = 0x00008000,
1821     VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT = 0x00020000,
1822     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT = 0x00040000,
1823     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT = 0x00080000,
1824     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT = 0x00100000,
1825     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT = 0x00200000,
1826     VK_FORMAT_FEATURE_DISJOINT_BIT = 0x00400000,
1827     VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT = 0x00800000,
1828     VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT = 0x00010000,
1829     VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = 0x00002000,
1830 #ifdef VK_ENABLE_BETA_EXTENSIONS
1831     VK_FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR = 0x02000000,
1832 #endif
1833 #ifdef VK_ENABLE_BETA_EXTENSIONS
1834     VK_FORMAT_FEATURE_VIDEO_DECODE_DPB_BIT_KHR = 0x04000000,
1835 #endif
1836     VK_FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR = 0x20000000,
1837     VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x01000000,
1838     VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x40000000,
1839 #ifdef VK_ENABLE_BETA_EXTENSIONS
1840     VK_FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR = 0x08000000,
1841 #endif
1842 #ifdef VK_ENABLE_BETA_EXTENSIONS
1843     VK_FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR = 0x10000000,
1844 #endif
1845     VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT,
1846     VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_DST_BIT,
1847     VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT,
1848     VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT,
1849     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT,
1850     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT,
1851     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT,
1852     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,
1853     VK_FORMAT_FEATURE_DISJOINT_BIT_KHR = VK_FORMAT_FEATURE_DISJOINT_BIT,
1854     VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT,
1855     VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG,
1856     VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1857 } VkFormatFeatureFlagBits;
1858 typedef VkFlags VkFormatFeatureFlags;
1859
1860 typedef enum VkImageCreateFlagBits {
1861     VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001,
1862     VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,
1863     VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
1864     VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008,
1865     VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010,
1866     VK_IMAGE_CREATE_ALIAS_BIT = 0x00000400,
1867     VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT = 0x00000040,
1868     VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT = 0x00000020,
1869     VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT = 0x00000080,
1870     VK_IMAGE_CREATE_EXTENDED_USAGE_BIT = 0x00000100,
1871     VK_IMAGE_CREATE_PROTECTED_BIT = 0x00000800,
1872     VK_IMAGE_CREATE_DISJOINT_BIT = 0x00000200,
1873     VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV = 0x00002000,
1874     VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = 0x00001000,
1875     VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT = 0x00004000,
1876     VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT,
1877     VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT,
1878     VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT,
1879     VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT,
1880     VK_IMAGE_CREATE_DISJOINT_BIT_KHR = VK_IMAGE_CREATE_DISJOINT_BIT,
1881     VK_IMAGE_CREATE_ALIAS_BIT_KHR = VK_IMAGE_CREATE_ALIAS_BIT,
1882     VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1883 } VkImageCreateFlagBits;
1884 typedef VkFlags VkImageCreateFlags;
1885
1886 typedef enum VkSampleCountFlagBits {
1887     VK_SAMPLE_COUNT_1_BIT = 0x00000001,
1888     VK_SAMPLE_COUNT_2_BIT = 0x00000002,
1889     VK_SAMPLE_COUNT_4_BIT = 0x00000004,
1890     VK_SAMPLE_COUNT_8_BIT = 0x00000008,
1891     VK_SAMPLE_COUNT_16_BIT = 0x00000010,
1892     VK_SAMPLE_COUNT_32_BIT = 0x00000020,
1893     VK_SAMPLE_COUNT_64_BIT = 0x00000040,
1894     VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1895 } VkSampleCountFlagBits;
1896 typedef VkFlags VkSampleCountFlags;
1897
1898 typedef enum VkImageUsageFlagBits {
1899     VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001,
1900     VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002,
1901     VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004,
1902     VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008,
1903     VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010,
1904     VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020,
1905     VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040,
1906     VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080,
1907 #ifdef VK_ENABLE_BETA_EXTENSIONS
1908     VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR = 0x00000400,
1909 #endif
1910 #ifdef VK_ENABLE_BETA_EXTENSIONS
1911     VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR = 0x00000800,
1912 #endif
1913 #ifdef VK_ENABLE_BETA_EXTENSIONS
1914     VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR = 0x00001000,
1915 #endif
1916     VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x00000200,
1917     VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00000100,
1918 #ifdef VK_ENABLE_BETA_EXTENSIONS
1919     VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR = 0x00002000,
1920 #endif
1921 #ifdef VK_ENABLE_BETA_EXTENSIONS
1922     VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR = 0x00004000,
1923 #endif
1924 #ifdef VK_ENABLE_BETA_EXTENSIONS
1925     VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR = 0x00008000,
1926 #endif
1927     VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI = 0x00040000,
1928     VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV = VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR,
1929     VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1930 } VkImageUsageFlagBits;
1931 typedef VkFlags VkImageUsageFlags;
1932 typedef VkFlags VkInstanceCreateFlags;
1933
1934 typedef enum VkMemoryHeapFlagBits {
1935     VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001,
1936     VK_MEMORY_HEAP_MULTI_INSTANCE_BIT = 0x00000002,
1937     VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT,
1938     VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1939 } VkMemoryHeapFlagBits;
1940 typedef VkFlags VkMemoryHeapFlags;
1941
1942 typedef enum VkMemoryPropertyFlagBits {
1943     VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001,
1944     VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002,
1945     VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004,
1946     VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008,
1947     VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010,
1948     VK_MEMORY_PROPERTY_PROTECTED_BIT = 0x00000020,
1949     VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD = 0x00000040,
1950     VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD = 0x00000080,
1951     VK_MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV = 0x00000100,
1952     VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1953 } VkMemoryPropertyFlagBits;
1954 typedef VkFlags VkMemoryPropertyFlags;
1955
1956 typedef enum VkQueueFlagBits {
1957     VK_QUEUE_GRAPHICS_BIT = 0x00000001,
1958     VK_QUEUE_COMPUTE_BIT = 0x00000002,
1959     VK_QUEUE_TRANSFER_BIT = 0x00000004,
1960     VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008,
1961     VK_QUEUE_PROTECTED_BIT = 0x00000010,
1962 #ifdef VK_ENABLE_BETA_EXTENSIONS
1963     VK_QUEUE_VIDEO_DECODE_BIT_KHR = 0x00000020,
1964 #endif
1965 #ifdef VK_ENABLE_BETA_EXTENSIONS
1966     VK_QUEUE_VIDEO_ENCODE_BIT_KHR = 0x00000040,
1967 #endif
1968     VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1969 } VkQueueFlagBits;
1970 typedef VkFlags VkQueueFlags;
1971 typedef VkFlags VkDeviceCreateFlags;
1972
1973 typedef enum VkDeviceQueueCreateFlagBits {
1974     VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT = 0x00000001,
1975     VK_DEVICE_QUEUE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1976 } VkDeviceQueueCreateFlagBits;
1977 typedef VkFlags VkDeviceQueueCreateFlags;
1978
1979 typedef enum VkPipelineStageFlagBits {
1980     VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001,
1981     VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002,
1982     VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004,
1983     VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008,
1984     VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010,
1985     VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020,
1986     VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040,
1987     VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080,
1988     VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100,
1989     VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200,
1990     VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400,
1991     VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800,
1992     VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000,
1993     VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000,
1994     VK_PIPELINE_STAGE_HOST_BIT = 0x00004000,
1995     VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000,
1996     VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000,
1997     VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT = 0x01000000,
1998     VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00040000,
1999     VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR = 0x02000000,
2000     VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR = 0x00200000,
2001     VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV = 0x00080000,
2002     VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV = 0x00100000,
2003     VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT = 0x00800000,
2004     VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00400000,
2005     VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV = 0x00020000,
2006     VK_PIPELINE_STAGE_NONE_KHR = 0,
2007     VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV = VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR,
2008     VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV = VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR,
2009     VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV = VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR,
2010     VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2011 } VkPipelineStageFlagBits;
2012 typedef VkFlags VkPipelineStageFlags;
2013 typedef VkFlags VkMemoryMapFlags;
2014
2015 typedef enum VkSparseMemoryBindFlagBits {
2016     VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0x00000001,
2017     VK_SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2018 } VkSparseMemoryBindFlagBits;
2019 typedef VkFlags VkSparseMemoryBindFlags;
2020
2021 typedef enum VkSparseImageFormatFlagBits {
2022     VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001,
2023     VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002,
2024     VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004,
2025     VK_SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2026 } VkSparseImageFormatFlagBits;
2027 typedef VkFlags VkSparseImageFormatFlags;
2028
2029 typedef enum VkFenceCreateFlagBits {
2030     VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001,
2031     VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2032 } VkFenceCreateFlagBits;
2033 typedef VkFlags VkFenceCreateFlags;
2034 typedef VkFlags VkSemaphoreCreateFlags;
2035
2036 typedef enum VkEventCreateFlagBits {
2037     VK_EVENT_CREATE_DEVICE_ONLY_BIT_KHR = 0x00000001,
2038     VK_EVENT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2039 } VkEventCreateFlagBits;
2040 typedef VkFlags VkEventCreateFlags;
2041
2042 typedef enum VkQueryPipelineStatisticFlagBits {
2043     VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001,
2044     VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002,
2045     VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004,
2046     VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008,
2047     VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0x00000010,
2048     VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0x00000020,
2049     VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0x00000040,
2050     VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0x00000080,
2051     VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x00000100,
2052     VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0x00000200,
2053     VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400,
2054     VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2055 } VkQueryPipelineStatisticFlagBits;
2056 typedef VkFlags VkQueryPipelineStatisticFlags;
2057 typedef VkFlags VkQueryPoolCreateFlags;
2058
2059 typedef enum VkQueryResultFlagBits {
2060     VK_QUERY_RESULT_64_BIT = 0x00000001,
2061     VK_QUERY_RESULT_WAIT_BIT = 0x00000002,
2062     VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004,
2063     VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008,
2064 #ifdef VK_ENABLE_BETA_EXTENSIONS
2065     VK_QUERY_RESULT_WITH_STATUS_BIT_KHR = 0x00000010,
2066 #endif
2067     VK_QUERY_RESULT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2068 } VkQueryResultFlagBits;
2069 typedef VkFlags VkQueryResultFlags;
2070
2071 typedef enum VkBufferCreateFlagBits {
2072     VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001,
2073     VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,
2074     VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
2075     VK_BUFFER_CREATE_PROTECTED_BIT = 0x00000008,
2076     VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 0x00000010,
2077     VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT,
2078     VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT,
2079     VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2080 } VkBufferCreateFlagBits;
2081 typedef VkFlags VkBufferCreateFlags;
2082
2083 typedef enum VkBufferUsageFlagBits {
2084     VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001,
2085     VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002,
2086     VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004,
2087     VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008,
2088     VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010,
2089     VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020,
2090     VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040,
2091     VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080,
2092     VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100,
2093     VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT = 0x00020000,
2094 #ifdef VK_ENABLE_BETA_EXTENSIONS
2095     VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR = 0x00002000,
2096 #endif
2097 #ifdef VK_ENABLE_BETA_EXTENSIONS
2098     VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR = 0x00004000,
2099 #endif
2100     VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT = 0x00000800,
2101     VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT = 0x00001000,
2102     VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00000200,
2103     VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR = 0x00080000,
2104     VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR = 0x00100000,
2105     VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR = 0x00000400,
2106 #ifdef VK_ENABLE_BETA_EXTENSIONS
2107     VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR = 0x00008000,
2108 #endif
2109 #ifdef VK_ENABLE_BETA_EXTENSIONS
2110     VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR = 0x00010000,
2111 #endif
2112     VK_BUFFER_USAGE_RAY_TRACING_BIT_NV = VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR,
2113     VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
2114     VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
2115     VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2116 } VkBufferUsageFlagBits;
2117 typedef VkFlags VkBufferUsageFlags;
2118 typedef VkFlags VkBufferViewCreateFlags;
2119
2120 typedef enum VkImageViewCreateFlagBits {
2121     VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT = 0x00000001,
2122     VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT = 0x00000002,
2123     VK_IMAGE_VIEW_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2124 } VkImageViewCreateFlagBits;
2125 typedef VkFlags VkImageViewCreateFlags;
2126
2127 typedef enum VkShaderModuleCreateFlagBits {
2128     VK_SHADER_MODULE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2129 } VkShaderModuleCreateFlagBits;
2130 typedef VkFlags VkShaderModuleCreateFlags;
2131
2132 typedef enum VkPipelineCacheCreateFlagBits {
2133     VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT = 0x00000001,
2134     VK_PIPELINE_CACHE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2135 } VkPipelineCacheCreateFlagBits;
2136 typedef VkFlags VkPipelineCacheCreateFlags;
2137
2138 typedef enum VkColorComponentFlagBits {
2139     VK_COLOR_COMPONENT_R_BIT = 0x00000001,
2140     VK_COLOR_COMPONENT_G_BIT = 0x00000002,
2141     VK_COLOR_COMPONENT_B_BIT = 0x00000004,
2142     VK_COLOR_COMPONENT_A_BIT = 0x00000008,
2143     VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2144 } VkColorComponentFlagBits;
2145 typedef VkFlags VkColorComponentFlags;
2146
2147 typedef enum VkPipelineCreateFlagBits {
2148     VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001,
2149     VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002,
2150     VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004,
2151     VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0x00000008,
2152     VK_PIPELINE_CREATE_DISPATCH_BASE_BIT = 0x00000010,
2153     VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR = 0x00004000,
2154     VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR = 0x00008000,
2155     VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR = 0x00010000,
2156     VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR = 0x00020000,
2157     VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR = 0x00001000,
2158     VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR = 0x00002000,
2159     VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR = 0x00080000,
2160     VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV = 0x00000020,
2161     VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR = 0x00000040,
2162     VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR = 0x00000080,
2163     VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV = 0x00040000,
2164     VK_PIPELINE_CREATE_LIBRARY_BIT_KHR = 0x00000800,
2165     VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT = 0x00000100,
2166     VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT = 0x00000200,
2167     VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV = 0x00100000,
2168     VK_PIPELINE_CREATE_DISPATCH_BASE = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT,
2169     VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT,
2170     VK_PIPELINE_CREATE_DISPATCH_BASE_KHR = VK_PIPELINE_CREATE_DISPATCH_BASE,
2171     VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2172 } VkPipelineCreateFlagBits;
2173 typedef VkFlags VkPipelineCreateFlags;
2174
2175 typedef enum VkPipelineShaderStageCreateFlagBits {
2176     VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT = 0x00000001,
2177     VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT = 0x00000002,
2178     VK_PIPELINE_SHADER_STAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2179 } VkPipelineShaderStageCreateFlagBits;
2180 typedef VkFlags VkPipelineShaderStageCreateFlags;
2181
2182 typedef enum VkShaderStageFlagBits {
2183     VK_SHADER_STAGE_VERTEX_BIT = 0x00000001,
2184     VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002,
2185     VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004,
2186     VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008,
2187     VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010,
2188     VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020,
2189     VK_SHADER_STAGE_ALL_GRAPHICS = 0x0000001F,
2190     VK_SHADER_STAGE_ALL = 0x7FFFFFFF,
2191     VK_SHADER_STAGE_RAYGEN_BIT_KHR = 0x00000100,
2192     VK_SHADER_STAGE_ANY_HIT_BIT_KHR = 0x00000200,
2193     VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR = 0x00000400,
2194     VK_SHADER_STAGE_MISS_BIT_KHR = 0x00000800,
2195     VK_SHADER_STAGE_INTERSECTION_BIT_KHR = 0x00001000,
2196     VK_SHADER_STAGE_CALLABLE_BIT_KHR = 0x00002000,
2197     VK_SHADER_STAGE_TASK_BIT_NV = 0x00000040,
2198     VK_SHADER_STAGE_MESH_BIT_NV = 0x00000080,
2199     VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI = 0x00004000,
2200     VK_SHADER_STAGE_RAYGEN_BIT_NV = VK_SHADER_STAGE_RAYGEN_BIT_KHR,
2201     VK_SHADER_STAGE_ANY_HIT_BIT_NV = VK_SHADER_STAGE_ANY_HIT_BIT_KHR,
2202     VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV = VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR,
2203     VK_SHADER_STAGE_MISS_BIT_NV = VK_SHADER_STAGE_MISS_BIT_KHR,
2204     VK_SHADER_STAGE_INTERSECTION_BIT_NV = VK_SHADER_STAGE_INTERSECTION_BIT_KHR,
2205     VK_SHADER_STAGE_CALLABLE_BIT_NV = VK_SHADER_STAGE_CALLABLE_BIT_KHR,
2206     VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2207 } VkShaderStageFlagBits;
2208
2209 typedef enum VkCullModeFlagBits {
2210     VK_CULL_MODE_NONE = 0,
2211     VK_CULL_MODE_FRONT_BIT = 0x00000001,
2212     VK_CULL_MODE_BACK_BIT = 0x00000002,
2213     VK_CULL_MODE_FRONT_AND_BACK = 0x00000003,
2214     VK_CULL_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2215 } VkCullModeFlagBits;
2216 typedef VkFlags VkCullModeFlags;
2217 typedef VkFlags VkPipelineVertexInputStateCreateFlags;
2218 typedef VkFlags VkPipelineInputAssemblyStateCreateFlags;
2219 typedef VkFlags VkPipelineTessellationStateCreateFlags;
2220 typedef VkFlags VkPipelineViewportStateCreateFlags;
2221 typedef VkFlags VkPipelineRasterizationStateCreateFlags;
2222 typedef VkFlags VkPipelineMultisampleStateCreateFlags;
2223 typedef VkFlags VkPipelineDepthStencilStateCreateFlags;
2224 typedef VkFlags VkPipelineColorBlendStateCreateFlags;
2225 typedef VkFlags VkPipelineDynamicStateCreateFlags;
2226 typedef VkFlags VkPipelineLayoutCreateFlags;
2227 typedef VkFlags VkShaderStageFlags;
2228
2229 typedef enum VkSamplerCreateFlagBits {
2230     VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT = 0x00000001,
2231     VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT = 0x00000002,
2232     VK_SAMPLER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2233 } VkSamplerCreateFlagBits;
2234 typedef VkFlags VkSamplerCreateFlags;
2235
2236 typedef enum VkDescriptorPoolCreateFlagBits {
2237     VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001,
2238     VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT = 0x00000002,
2239     VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE = 0x00000004,
2240     VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT,
2241     VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2242 } VkDescriptorPoolCreateFlagBits;
2243 typedef VkFlags VkDescriptorPoolCreateFlags;
2244 typedef VkFlags VkDescriptorPoolResetFlags;
2245
2246 typedef enum VkDescriptorSetLayoutCreateFlagBits {
2247     VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT = 0x00000002,
2248     VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR = 0x00000001,
2249     VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE = 0x00000004,
2250     VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT,
2251     VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2252 } VkDescriptorSetLayoutCreateFlagBits;
2253 typedef VkFlags VkDescriptorSetLayoutCreateFlags;
2254
2255 typedef enum VkAttachmentDescriptionFlagBits {
2256     VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001,
2257     VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2258 } VkAttachmentDescriptionFlagBits;
2259 typedef VkFlags VkAttachmentDescriptionFlags;
2260
2261 typedef enum VkDependencyFlagBits {
2262     VK_DEPENDENCY_BY_REGION_BIT = 0x00000001,
2263     VK_DEPENDENCY_DEVICE_GROUP_BIT = 0x00000004,
2264     VK_DEPENDENCY_VIEW_LOCAL_BIT = 0x00000002,
2265     VK_DEPENDENCY_VIEW_LOCAL_BIT_KHR = VK_DEPENDENCY_VIEW_LOCAL_BIT,
2266     VK_DEPENDENCY_DEVICE_GROUP_BIT_KHR = VK_DEPENDENCY_DEVICE_GROUP_BIT,
2267     VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2268 } VkDependencyFlagBits;
2269 typedef VkFlags VkDependencyFlags;
2270
2271 typedef enum VkFramebufferCreateFlagBits {
2272     VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT = 0x00000001,
2273     VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR = VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT,
2274     VK_FRAMEBUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2275 } VkFramebufferCreateFlagBits;
2276 typedef VkFlags VkFramebufferCreateFlags;
2277
2278 typedef enum VkRenderPassCreateFlagBits {
2279     VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM = 0x00000002,
2280     VK_RENDER_PASS_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2281 } VkRenderPassCreateFlagBits;
2282 typedef VkFlags VkRenderPassCreateFlags;
2283
2284 typedef enum VkSubpassDescriptionFlagBits {
2285     VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX = 0x00000001,
2286     VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX = 0x00000002,
2287     VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM = 0x00000004,
2288     VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM = 0x00000008,
2289     VK_SUBPASS_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2290 } VkSubpassDescriptionFlagBits;
2291 typedef VkFlags VkSubpassDescriptionFlags;
2292
2293 typedef enum VkCommandPoolCreateFlagBits {
2294     VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001,
2295     VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002,
2296     VK_COMMAND_POOL_CREATE_PROTECTED_BIT = 0x00000004,
2297     VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2298 } VkCommandPoolCreateFlagBits;
2299 typedef VkFlags VkCommandPoolCreateFlags;
2300
2301 typedef enum VkCommandPoolResetFlagBits {
2302     VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
2303     VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2304 } VkCommandPoolResetFlagBits;
2305 typedef VkFlags VkCommandPoolResetFlags;
2306
2307 typedef enum VkCommandBufferUsageFlagBits {
2308     VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001,
2309     VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002,
2310     VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004,
2311     VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2312 } VkCommandBufferUsageFlagBits;
2313 typedef VkFlags VkCommandBufferUsageFlags;
2314
2315 typedef enum VkQueryControlFlagBits {
2316     VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001,
2317     VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2318 } VkQueryControlFlagBits;
2319 typedef VkFlags VkQueryControlFlags;
2320
2321 typedef enum VkCommandBufferResetFlagBits {
2322     VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
2323     VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2324 } VkCommandBufferResetFlagBits;
2325 typedef VkFlags VkCommandBufferResetFlags;
2326
2327 typedef enum VkStencilFaceFlagBits {
2328     VK_STENCIL_FACE_FRONT_BIT = 0x00000001,
2329     VK_STENCIL_FACE_BACK_BIT = 0x00000002,
2330     VK_STENCIL_FACE_FRONT_AND_BACK = 0x00000003,
2331     VK_STENCIL_FRONT_AND_BACK = VK_STENCIL_FACE_FRONT_AND_BACK,
2332     VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2333 } VkStencilFaceFlagBits;
2334 typedef VkFlags VkStencilFaceFlags;
2335 typedef struct VkExtent2D {
2336     uint32_t    width;
2337     uint32_t    height;
2338 } VkExtent2D;
2339
2340 typedef struct VkExtent3D {
2341     uint32_t    width;
2342     uint32_t    height;
2343     uint32_t    depth;
2344 } VkExtent3D;
2345
2346 typedef struct VkOffset2D {
2347     int32_t    x;
2348     int32_t    y;
2349 } VkOffset2D;
2350
2351 typedef struct VkOffset3D {
2352     int32_t    x;
2353     int32_t    y;
2354     int32_t    z;
2355 } VkOffset3D;
2356
2357 typedef struct VkRect2D {
2358     VkOffset2D    offset;
2359     VkExtent2D    extent;
2360 } VkRect2D;
2361
2362 typedef struct VkBaseInStructure {
2363     VkStructureType                    sType;
2364     const struct VkBaseInStructure*    pNext;
2365 } VkBaseInStructure;
2366
2367 typedef struct VkBaseOutStructure {
2368     VkStructureType               sType;
2369     struct VkBaseOutStructure*    pNext;
2370 } VkBaseOutStructure;
2371
2372 typedef struct VkBufferMemoryBarrier {
2373     VkStructureType    sType;
2374     const void*        pNext;
2375     VkAccessFlags      srcAccessMask;
2376     VkAccessFlags      dstAccessMask;
2377     uint32_t           srcQueueFamilyIndex;
2378     uint32_t           dstQueueFamilyIndex;
2379     VkBuffer           buffer;
2380     VkDeviceSize       offset;
2381     VkDeviceSize       size;
2382 } VkBufferMemoryBarrier;
2383
2384 typedef struct VkDispatchIndirectCommand {
2385     uint32_t    x;
2386     uint32_t    y;
2387     uint32_t    z;
2388 } VkDispatchIndirectCommand;
2389
2390 typedef struct VkDrawIndexedIndirectCommand {
2391     uint32_t    indexCount;
2392     uint32_t    instanceCount;
2393     uint32_t    firstIndex;
2394     int32_t     vertexOffset;
2395     uint32_t    firstInstance;
2396 } VkDrawIndexedIndirectCommand;
2397
2398 typedef struct VkDrawIndirectCommand {
2399     uint32_t    vertexCount;
2400     uint32_t    instanceCount;
2401     uint32_t    firstVertex;
2402     uint32_t    firstInstance;
2403 } VkDrawIndirectCommand;
2404
2405 typedef struct VkImageSubresourceRange {
2406     VkImageAspectFlags    aspectMask;
2407     uint32_t              baseMipLevel;
2408     uint32_t              levelCount;
2409     uint32_t              baseArrayLayer;
2410     uint32_t              layerCount;
2411 } VkImageSubresourceRange;
2412
2413 typedef struct VkImageMemoryBarrier {
2414     VkStructureType            sType;
2415     const void*                pNext;
2416     VkAccessFlags              srcAccessMask;
2417     VkAccessFlags              dstAccessMask;
2418     VkImageLayout              oldLayout;
2419     VkImageLayout              newLayout;
2420     uint32_t                   srcQueueFamilyIndex;
2421     uint32_t                   dstQueueFamilyIndex;
2422     VkImage                    image;
2423     VkImageSubresourceRange    subresourceRange;
2424 } VkImageMemoryBarrier;
2425
2426 typedef struct VkMemoryBarrier {
2427     VkStructureType    sType;
2428     const void*        pNext;
2429     VkAccessFlags      srcAccessMask;
2430     VkAccessFlags      dstAccessMask;
2431 } VkMemoryBarrier;
2432
2433 typedef struct VkPipelineCacheHeaderVersionOne {
2434     uint32_t                        headerSize;
2435     VkPipelineCacheHeaderVersion    headerVersion;
2436     uint32_t                        vendorID;
2437     uint32_t                        deviceID;
2438     uint8_t                         pipelineCacheUUID[VK_UUID_SIZE];
2439 } VkPipelineCacheHeaderVersionOne;
2440
2441 typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)(
2442     void*                                       pUserData,
2443     size_t                                      size,
2444     size_t                                      alignment,
2445     VkSystemAllocationScope                     allocationScope);
2446
2447 typedef void (VKAPI_PTR *PFN_vkFreeFunction)(
2448     void*                                       pUserData,
2449     void*                                       pMemory);
2450
2451 typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)(
2452     void*                                       pUserData,
2453     size_t                                      size,
2454     VkInternalAllocationType                    allocationType,
2455     VkSystemAllocationScope                     allocationScope);
2456
2457 typedef void (VKAPI_PTR *PFN_vkInternalFreeNotification)(
2458     void*                                       pUserData,
2459     size_t                                      size,
2460     VkInternalAllocationType                    allocationType,
2461     VkSystemAllocationScope                     allocationScope);
2462
2463 typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)(
2464     void*                                       pUserData,
2465     void*                                       pOriginal,
2466     size_t                                      size,
2467     size_t                                      alignment,
2468     VkSystemAllocationScope                     allocationScope);
2469
2470 typedef void (VKAPI_PTR *PFN_vkVoidFunction)(void);
2471 typedef struct VkAllocationCallbacks {
2472     void*                                   pUserData;
2473     PFN_vkAllocationFunction                pfnAllocation;
2474     PFN_vkReallocationFunction              pfnReallocation;
2475     PFN_vkFreeFunction                      pfnFree;
2476     PFN_vkInternalAllocationNotification    pfnInternalAllocation;
2477     PFN_vkInternalFreeNotification          pfnInternalFree;
2478 } VkAllocationCallbacks;
2479
2480 typedef struct VkApplicationInfo {
2481     VkStructureType    sType;
2482     const void*        pNext;
2483     const char*        pApplicationName;
2484     uint32_t           applicationVersion;
2485     const char*        pEngineName;
2486     uint32_t           engineVersion;
2487     uint32_t           apiVersion;
2488 } VkApplicationInfo;
2489
2490 typedef struct VkFormatProperties {
2491     VkFormatFeatureFlags    linearTilingFeatures;
2492     VkFormatFeatureFlags    optimalTilingFeatures;
2493     VkFormatFeatureFlags    bufferFeatures;
2494 } VkFormatProperties;
2495
2496 typedef struct VkImageFormatProperties {
2497     VkExtent3D            maxExtent;
2498     uint32_t              maxMipLevels;
2499     uint32_t              maxArrayLayers;
2500     VkSampleCountFlags    sampleCounts;
2501     VkDeviceSize          maxResourceSize;
2502 } VkImageFormatProperties;
2503
2504 typedef struct VkInstanceCreateInfo {
2505     VkStructureType             sType;
2506     const void*                 pNext;
2507     VkInstanceCreateFlags       flags;
2508     const VkApplicationInfo*    pApplicationInfo;
2509     uint32_t                    enabledLayerCount;
2510     const char* const*          ppEnabledLayerNames;
2511     uint32_t                    enabledExtensionCount;
2512     const char* const*          ppEnabledExtensionNames;
2513 } VkInstanceCreateInfo;
2514
2515 typedef struct VkMemoryHeap {
2516     VkDeviceSize         size;
2517     VkMemoryHeapFlags    flags;
2518 } VkMemoryHeap;
2519
2520 typedef struct VkMemoryType {
2521     VkMemoryPropertyFlags    propertyFlags;
2522     uint32_t                 heapIndex;
2523 } VkMemoryType;
2524
2525 typedef struct VkPhysicalDeviceFeatures {
2526     VkBool32    robustBufferAccess;
2527     VkBool32    fullDrawIndexUint32;
2528     VkBool32    imageCubeArray;
2529     VkBool32    independentBlend;
2530     VkBool32    geometryShader;
2531     VkBool32    tessellationShader;
2532     VkBool32    sampleRateShading;
2533     VkBool32    dualSrcBlend;
2534     VkBool32    logicOp;
2535     VkBool32    multiDrawIndirect;
2536     VkBool32    drawIndirectFirstInstance;
2537     VkBool32    depthClamp;
2538     VkBool32    depthBiasClamp;
2539     VkBool32    fillModeNonSolid;
2540     VkBool32    depthBounds;
2541     VkBool32    wideLines;
2542     VkBool32    largePoints;
2543     VkBool32    alphaToOne;
2544     VkBool32    multiViewport;
2545     VkBool32    samplerAnisotropy;
2546     VkBool32    textureCompressionETC2;
2547     VkBool32    textureCompressionASTC_LDR;
2548     VkBool32    textureCompressionBC;
2549     VkBool32    occlusionQueryPrecise;
2550     VkBool32    pipelineStatisticsQuery;
2551     VkBool32    vertexPipelineStoresAndAtomics;
2552     VkBool32    fragmentStoresAndAtomics;
2553     VkBool32    shaderTessellationAndGeometryPointSize;
2554     VkBool32    shaderImageGatherExtended;
2555     VkBool32    shaderStorageImageExtendedFormats;
2556     VkBool32    shaderStorageImageMultisample;
2557     VkBool32    shaderStorageImageReadWithoutFormat;
2558     VkBool32    shaderStorageImageWriteWithoutFormat;
2559     VkBool32    shaderUniformBufferArrayDynamicIndexing;
2560     VkBool32    shaderSampledImageArrayDynamicIndexing;
2561     VkBool32    shaderStorageBufferArrayDynamicIndexing;
2562     VkBool32    shaderStorageImageArrayDynamicIndexing;
2563     VkBool32    shaderClipDistance;
2564     VkBool32    shaderCullDistance;
2565     VkBool32    shaderFloat64;
2566     VkBool32    shaderInt64;
2567     VkBool32    shaderInt16;
2568     VkBool32    shaderResourceResidency;
2569     VkBool32    shaderResourceMinLod;
2570     VkBool32    sparseBinding;
2571     VkBool32    sparseResidencyBuffer;
2572     VkBool32    sparseResidencyImage2D;
2573     VkBool32    sparseResidencyImage3D;
2574     VkBool32    sparseResidency2Samples;
2575     VkBool32    sparseResidency4Samples;
2576     VkBool32    sparseResidency8Samples;
2577     VkBool32    sparseResidency16Samples;
2578     VkBool32    sparseResidencyAliased;
2579     VkBool32    variableMultisampleRate;
2580     VkBool32    inheritedQueries;
2581 } VkPhysicalDeviceFeatures;
2582
2583 typedef struct VkPhysicalDeviceLimits {
2584     uint32_t              maxImageDimension1D;
2585     uint32_t              maxImageDimension2D;
2586     uint32_t              maxImageDimension3D;
2587     uint32_t              maxImageDimensionCube;
2588     uint32_t              maxImageArrayLayers;
2589     uint32_t              maxTexelBufferElements;
2590     uint32_t              maxUniformBufferRange;
2591     uint32_t              maxStorageBufferRange;
2592     uint32_t              maxPushConstantsSize;
2593     uint32_t              maxMemoryAllocationCount;
2594     uint32_t              maxSamplerAllocationCount;
2595     VkDeviceSize          bufferImageGranularity;
2596     VkDeviceSize          sparseAddressSpaceSize;
2597     uint32_t              maxBoundDescriptorSets;
2598     uint32_t              maxPerStageDescriptorSamplers;
2599     uint32_t              maxPerStageDescriptorUniformBuffers;
2600     uint32_t              maxPerStageDescriptorStorageBuffers;
2601     uint32_t              maxPerStageDescriptorSampledImages;
2602     uint32_t              maxPerStageDescriptorStorageImages;
2603     uint32_t              maxPerStageDescriptorInputAttachments;
2604     uint32_t              maxPerStageResources;
2605     uint32_t              maxDescriptorSetSamplers;
2606     uint32_t              maxDescriptorSetUniformBuffers;
2607     uint32_t              maxDescriptorSetUniformBuffersDynamic;
2608     uint32_t              maxDescriptorSetStorageBuffers;
2609     uint32_t              maxDescriptorSetStorageBuffersDynamic;
2610     uint32_t              maxDescriptorSetSampledImages;
2611     uint32_t              maxDescriptorSetStorageImages;
2612     uint32_t              maxDescriptorSetInputAttachments;
2613     uint32_t              maxVertexInputAttributes;
2614     uint32_t              maxVertexInputBindings;
2615     uint32_t              maxVertexInputAttributeOffset;
2616     uint32_t              maxVertexInputBindingStride;
2617     uint32_t              maxVertexOutputComponents;
2618     uint32_t              maxTessellationGenerationLevel;
2619     uint32_t              maxTessellationPatchSize;
2620     uint32_t              maxTessellationControlPerVertexInputComponents;
2621     uint32_t              maxTessellationControlPerVertexOutputComponents;
2622     uint32_t              maxTessellationControlPerPatchOutputComponents;
2623     uint32_t              maxTessellationControlTotalOutputComponents;
2624     uint32_t              maxTessellationEvaluationInputComponents;
2625     uint32_t              maxTessellationEvaluationOutputComponents;
2626     uint32_t              maxGeometryShaderInvocations;
2627     uint32_t              maxGeometryInputComponents;
2628     uint32_t              maxGeometryOutputComponents;
2629     uint32_t              maxGeometryOutputVertices;
2630     uint32_t              maxGeometryTotalOutputComponents;
2631     uint32_t              maxFragmentInputComponents;
2632     uint32_t              maxFragmentOutputAttachments;
2633     uint32_t              maxFragmentDualSrcAttachments;
2634     uint32_t              maxFragmentCombinedOutputResources;
2635     uint32_t              maxComputeSharedMemorySize;
2636     uint32_t              maxComputeWorkGroupCount[3];
2637     uint32_t              maxComputeWorkGroupInvocations;
2638     uint32_t              maxComputeWorkGroupSize[3];
2639     uint32_t              subPixelPrecisionBits;
2640     uint32_t              subTexelPrecisionBits;
2641     uint32_t              mipmapPrecisionBits;
2642     uint32_t              maxDrawIndexedIndexValue;
2643     uint32_t              maxDrawIndirectCount;
2644     float                 maxSamplerLodBias;
2645     float                 maxSamplerAnisotropy;
2646     uint32_t              maxViewports;
2647     uint32_t              maxViewportDimensions[2];
2648     float                 viewportBoundsRange[2];
2649     uint32_t              viewportSubPixelBits;
2650     size_t                minMemoryMapAlignment;
2651     VkDeviceSize          minTexelBufferOffsetAlignment;
2652     VkDeviceSize          minUniformBufferOffsetAlignment;
2653     VkDeviceSize          minStorageBufferOffsetAlignment;
2654     int32_t               minTexelOffset;
2655     uint32_t              maxTexelOffset;
2656     int32_t               minTexelGatherOffset;
2657     uint32_t              maxTexelGatherOffset;
2658     float                 minInterpolationOffset;
2659     float                 maxInterpolationOffset;
2660     uint32_t              subPixelInterpolationOffsetBits;
2661     uint32_t              maxFramebufferWidth;
2662     uint32_t              maxFramebufferHeight;
2663     uint32_t              maxFramebufferLayers;
2664     VkSampleCountFlags    framebufferColorSampleCounts;
2665     VkSampleCountFlags    framebufferDepthSampleCounts;
2666     VkSampleCountFlags    framebufferStencilSampleCounts;
2667     VkSampleCountFlags    framebufferNoAttachmentsSampleCounts;
2668     uint32_t              maxColorAttachments;
2669     VkSampleCountFlags    sampledImageColorSampleCounts;
2670     VkSampleCountFlags    sampledImageIntegerSampleCounts;
2671     VkSampleCountFlags    sampledImageDepthSampleCounts;
2672     VkSampleCountFlags    sampledImageStencilSampleCounts;
2673     VkSampleCountFlags    storageImageSampleCounts;
2674     uint32_t              maxSampleMaskWords;
2675     VkBool32              timestampComputeAndGraphics;
2676     float                 timestampPeriod;
2677     uint32_t              maxClipDistances;
2678     uint32_t              maxCullDistances;
2679     uint32_t              maxCombinedClipAndCullDistances;
2680     uint32_t              discreteQueuePriorities;
2681     float                 pointSizeRange[2];
2682     float                 lineWidthRange[2];
2683     float                 pointSizeGranularity;
2684     float                 lineWidthGranularity;
2685     VkBool32              strictLines;
2686     VkBool32              standardSampleLocations;
2687     VkDeviceSize          optimalBufferCopyOffsetAlignment;
2688     VkDeviceSize          optimalBufferCopyRowPitchAlignment;
2689     VkDeviceSize          nonCoherentAtomSize;
2690 } VkPhysicalDeviceLimits;
2691
2692 typedef struct VkPhysicalDeviceMemoryProperties {
2693     uint32_t        memoryTypeCount;
2694     VkMemoryType    memoryTypes[VK_MAX_MEMORY_TYPES];
2695     uint32_t        memoryHeapCount;
2696     VkMemoryHeap    memoryHeaps[VK_MAX_MEMORY_HEAPS];
2697 } VkPhysicalDeviceMemoryProperties;
2698
2699 typedef struct VkPhysicalDeviceSparseProperties {
2700     VkBool32    residencyStandard2DBlockShape;
2701     VkBool32    residencyStandard2DMultisampleBlockShape;
2702     VkBool32    residencyStandard3DBlockShape;
2703     VkBool32    residencyAlignedMipSize;
2704     VkBool32    residencyNonResidentStrict;
2705 } VkPhysicalDeviceSparseProperties;
2706
2707 typedef struct VkPhysicalDeviceProperties {
2708     uint32_t                            apiVersion;
2709     uint32_t                            driverVersion;
2710     uint32_t                            vendorID;
2711     uint32_t                            deviceID;
2712     VkPhysicalDeviceType                deviceType;
2713     char                                deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
2714     uint8_t                             pipelineCacheUUID[VK_UUID_SIZE];
2715     VkPhysicalDeviceLimits              limits;
2716     VkPhysicalDeviceSparseProperties    sparseProperties;
2717 } VkPhysicalDeviceProperties;
2718
2719 typedef struct VkQueueFamilyProperties {
2720     VkQueueFlags    queueFlags;
2721     uint32_t        queueCount;
2722     uint32_t        timestampValidBits;
2723     VkExtent3D      minImageTransferGranularity;
2724 } VkQueueFamilyProperties;
2725
2726 typedef struct VkDeviceQueueCreateInfo {
2727     VkStructureType             sType;
2728     const void*                 pNext;
2729     VkDeviceQueueCreateFlags    flags;
2730     uint32_t                    queueFamilyIndex;
2731     uint32_t                    queueCount;
2732     const float*                pQueuePriorities;
2733 } VkDeviceQueueCreateInfo;
2734
2735 typedef struct VkDeviceCreateInfo {
2736     VkStructureType                    sType;
2737     const void*                        pNext;
2738     VkDeviceCreateFlags                flags;
2739     uint32_t                           queueCreateInfoCount;
2740     const VkDeviceQueueCreateInfo*     pQueueCreateInfos;
2741     uint32_t                           enabledLayerCount;
2742     const char* const*                 ppEnabledLayerNames;
2743     uint32_t                           enabledExtensionCount;
2744     const char* const*                 ppEnabledExtensionNames;
2745     const VkPhysicalDeviceFeatures*    pEnabledFeatures;
2746 } VkDeviceCreateInfo;
2747
2748 typedef struct VkExtensionProperties {
2749     char        extensionName[VK_MAX_EXTENSION_NAME_SIZE];
2750     uint32_t    specVersion;
2751 } VkExtensionProperties;
2752
2753 typedef struct VkLayerProperties {
2754     char        layerName[VK_MAX_EXTENSION_NAME_SIZE];
2755     uint32_t    specVersion;
2756     uint32_t    implementationVersion;
2757     char        description[VK_MAX_DESCRIPTION_SIZE];
2758 } VkLayerProperties;
2759
2760 typedef struct VkSubmitInfo {
2761     VkStructureType                sType;
2762     const void*                    pNext;
2763     uint32_t                       waitSemaphoreCount;
2764     const VkSemaphore*             pWaitSemaphores;
2765     const VkPipelineStageFlags*    pWaitDstStageMask;
2766     uint32_t                       commandBufferCount;
2767     const VkCommandBuffer*         pCommandBuffers;
2768     uint32_t                       signalSemaphoreCount;
2769     const VkSemaphore*             pSignalSemaphores;
2770 } VkSubmitInfo;
2771
2772 typedef struct VkMappedMemoryRange {
2773     VkStructureType    sType;
2774     const void*        pNext;
2775     VkDeviceMemory     memory;
2776     VkDeviceSize       offset;
2777     VkDeviceSize       size;
2778 } VkMappedMemoryRange;
2779
2780 typedef struct VkMemoryAllocateInfo {
2781     VkStructureType    sType;
2782     const void*        pNext;
2783     VkDeviceSize       allocationSize;
2784     uint32_t           memoryTypeIndex;
2785 } VkMemoryAllocateInfo;
2786
2787 typedef struct VkMemoryRequirements {
2788     VkDeviceSize    size;
2789     VkDeviceSize    alignment;
2790     uint32_t        memoryTypeBits;
2791 } VkMemoryRequirements;
2792
2793 typedef struct VkSparseMemoryBind {
2794     VkDeviceSize               resourceOffset;
2795     VkDeviceSize               size;
2796     VkDeviceMemory             memory;
2797     VkDeviceSize               memoryOffset;
2798     VkSparseMemoryBindFlags    flags;
2799 } VkSparseMemoryBind;
2800
2801 typedef struct VkSparseBufferMemoryBindInfo {
2802     VkBuffer                     buffer;
2803     uint32_t                     bindCount;
2804     const VkSparseMemoryBind*    pBinds;
2805 } VkSparseBufferMemoryBindInfo;
2806
2807 typedef struct VkSparseImageOpaqueMemoryBindInfo {
2808     VkImage                      image;
2809     uint32_t                     bindCount;
2810     const VkSparseMemoryBind*    pBinds;
2811 } VkSparseImageOpaqueMemoryBindInfo;
2812
2813 typedef struct VkImageSubresource {
2814     VkImageAspectFlags    aspectMask;
2815     uint32_t              mipLevel;
2816     uint32_t              arrayLayer;
2817 } VkImageSubresource;
2818
2819 typedef struct VkSparseImageMemoryBind {
2820     VkImageSubresource         subresource;
2821     VkOffset3D                 offset;
2822     VkExtent3D                 extent;
2823     VkDeviceMemory             memory;
2824     VkDeviceSize               memoryOffset;
2825     VkSparseMemoryBindFlags    flags;
2826 } VkSparseImageMemoryBind;
2827
2828 typedef struct VkSparseImageMemoryBindInfo {
2829     VkImage                           image;
2830     uint32_t                          bindCount;
2831     const VkSparseImageMemoryBind*    pBinds;
2832 } VkSparseImageMemoryBindInfo;
2833
2834 typedef struct VkBindSparseInfo {
2835     VkStructureType                             sType;
2836     const void*                                 pNext;
2837     uint32_t                                    waitSemaphoreCount;
2838     const VkSemaphore*                          pWaitSemaphores;
2839     uint32_t                                    bufferBindCount;
2840     const VkSparseBufferMemoryBindInfo*         pBufferBinds;
2841     uint32_t                                    imageOpaqueBindCount;
2842     const VkSparseImageOpaqueMemoryBindInfo*    pImageOpaqueBinds;
2843     uint32_t                                    imageBindCount;
2844     const VkSparseImageMemoryBindInfo*          pImageBinds;
2845     uint32_t                                    signalSemaphoreCount;
2846     const VkSemaphore*                          pSignalSemaphores;
2847 } VkBindSparseInfo;
2848
2849 typedef struct VkSparseImageFormatProperties {
2850     VkImageAspectFlags          aspectMask;
2851     VkExtent3D                  imageGranularity;
2852     VkSparseImageFormatFlags    flags;
2853 } VkSparseImageFormatProperties;
2854
2855 typedef struct VkSparseImageMemoryRequirements {
2856     VkSparseImageFormatProperties    formatProperties;
2857     uint32_t                         imageMipTailFirstLod;
2858     VkDeviceSize                     imageMipTailSize;
2859     VkDeviceSize                     imageMipTailOffset;
2860     VkDeviceSize                     imageMipTailStride;
2861 } VkSparseImageMemoryRequirements;
2862
2863 typedef struct VkFenceCreateInfo {
2864     VkStructureType       sType;
2865     const void*           pNext;
2866     VkFenceCreateFlags    flags;
2867 } VkFenceCreateInfo;
2868
2869 typedef struct VkSemaphoreCreateInfo {
2870     VkStructureType           sType;
2871     const void*               pNext;
2872     VkSemaphoreCreateFlags    flags;
2873 } VkSemaphoreCreateInfo;
2874
2875 typedef struct VkEventCreateInfo {
2876     VkStructureType       sType;
2877     const void*           pNext;
2878     VkEventCreateFlags    flags;
2879 } VkEventCreateInfo;
2880
2881 typedef struct VkQueryPoolCreateInfo {
2882     VkStructureType                  sType;
2883     const void*                      pNext;
2884     VkQueryPoolCreateFlags           flags;
2885     VkQueryType                      queryType;
2886     uint32_t                         queryCount;
2887     VkQueryPipelineStatisticFlags    pipelineStatistics;
2888 } VkQueryPoolCreateInfo;
2889
2890 typedef struct VkBufferCreateInfo {
2891     VkStructureType        sType;
2892     const void*            pNext;
2893     VkBufferCreateFlags    flags;
2894     VkDeviceSize           size;
2895     VkBufferUsageFlags     usage;
2896     VkSharingMode          sharingMode;
2897     uint32_t               queueFamilyIndexCount;
2898     const uint32_t*        pQueueFamilyIndices;
2899 } VkBufferCreateInfo;
2900
2901 typedef struct VkBufferViewCreateInfo {
2902     VkStructureType            sType;
2903     const void*                pNext;
2904     VkBufferViewCreateFlags    flags;
2905     VkBuffer                   buffer;
2906     VkFormat                   format;
2907     VkDeviceSize               offset;
2908     VkDeviceSize               range;
2909 } VkBufferViewCreateInfo;
2910
2911 typedef struct VkImageCreateInfo {
2912     VkStructureType          sType;
2913     const void*              pNext;
2914     VkImageCreateFlags       flags;
2915     VkImageType              imageType;
2916     VkFormat                 format;
2917     VkExtent3D               extent;
2918     uint32_t                 mipLevels;
2919     uint32_t                 arrayLayers;
2920     VkSampleCountFlagBits    samples;
2921     VkImageTiling            tiling;
2922     VkImageUsageFlags        usage;
2923     VkSharingMode            sharingMode;
2924     uint32_t                 queueFamilyIndexCount;
2925     const uint32_t*          pQueueFamilyIndices;
2926     VkImageLayout            initialLayout;
2927 } VkImageCreateInfo;
2928
2929 typedef struct VkSubresourceLayout {
2930     VkDeviceSize    offset;
2931     VkDeviceSize    size;
2932     VkDeviceSize    rowPitch;
2933     VkDeviceSize    arrayPitch;
2934     VkDeviceSize    depthPitch;
2935 } VkSubresourceLayout;
2936
2937 typedef struct VkComponentMapping {
2938     VkComponentSwizzle    r;
2939     VkComponentSwizzle    g;
2940     VkComponentSwizzle    b;
2941     VkComponentSwizzle    a;
2942 } VkComponentMapping;
2943
2944 typedef struct VkImageViewCreateInfo {
2945     VkStructureType            sType;
2946     const void*                pNext;
2947     VkImageViewCreateFlags     flags;
2948     VkImage                    image;
2949     VkImageViewType            viewType;
2950     VkFormat                   format;
2951     VkComponentMapping         components;
2952     VkImageSubresourceRange    subresourceRange;
2953 } VkImageViewCreateInfo;
2954
2955 typedef struct VkShaderModuleCreateInfo {
2956     VkStructureType              sType;
2957     const void*                  pNext;
2958     VkShaderModuleCreateFlags    flags;
2959     size_t                       codeSize;
2960     const uint32_t*              pCode;
2961 } VkShaderModuleCreateInfo;
2962
2963 typedef struct VkPipelineCacheCreateInfo {
2964     VkStructureType               sType;
2965     const void*                   pNext;
2966     VkPipelineCacheCreateFlags    flags;
2967     size_t                        initialDataSize;
2968     const void*                   pInitialData;
2969 } VkPipelineCacheCreateInfo;
2970
2971 typedef struct VkSpecializationMapEntry {
2972     uint32_t    constantID;
2973     uint32_t    offset;
2974     size_t      size;
2975 } VkSpecializationMapEntry;
2976
2977 typedef struct VkSpecializationInfo {
2978     uint32_t                           mapEntryCount;
2979     const VkSpecializationMapEntry*    pMapEntries;
2980     size_t                             dataSize;
2981     const void*                        pData;
2982 } VkSpecializationInfo;
2983
2984 typedef struct VkPipelineShaderStageCreateInfo {
2985     VkStructureType                     sType;
2986     const void*                         pNext;
2987     VkPipelineShaderStageCreateFlags    flags;
2988     VkShaderStageFlagBits               stage;
2989     VkShaderModule                      module;
2990     const char*                         pName;
2991     const VkSpecializationInfo*         pSpecializationInfo;
2992 } VkPipelineShaderStageCreateInfo;
2993
2994 typedef struct VkComputePipelineCreateInfo {
2995     VkStructureType                    sType;
2996     const void*                        pNext;
2997     VkPipelineCreateFlags              flags;
2998     VkPipelineShaderStageCreateInfo    stage;
2999     VkPipelineLayout                   layout;
3000     VkPipeline                         basePipelineHandle;
3001     int32_t                            basePipelineIndex;
3002 } VkComputePipelineCreateInfo;
3003
3004 typedef struct VkVertexInputBindingDescription {
3005     uint32_t             binding;
3006     uint32_t             stride;
3007     VkVertexInputRate    inputRate;
3008 } VkVertexInputBindingDescription;
3009
3010 typedef struct VkVertexInputAttributeDescription {
3011     uint32_t    location;
3012     uint32_t    binding;
3013     VkFormat    format;
3014     uint32_t    offset;
3015 } VkVertexInputAttributeDescription;
3016
3017 typedef struct VkPipelineVertexInputStateCreateInfo {
3018     VkStructureType                             sType;
3019     const void*                                 pNext;
3020     VkPipelineVertexInputStateCreateFlags       flags;
3021     uint32_t                                    vertexBindingDescriptionCount;
3022     const VkVertexInputBindingDescription*      pVertexBindingDescriptions;
3023     uint32_t                                    vertexAttributeDescriptionCount;
3024     const VkVertexInputAttributeDescription*    pVertexAttributeDescriptions;
3025 } VkPipelineVertexInputStateCreateInfo;
3026
3027 typedef struct VkPipelineInputAssemblyStateCreateInfo {
3028     VkStructureType                            sType;
3029     const void*                                pNext;
3030     VkPipelineInputAssemblyStateCreateFlags    flags;
3031     VkPrimitiveTopology                        topology;
3032     VkBool32                                   primitiveRestartEnable;
3033 } VkPipelineInputAssemblyStateCreateInfo;
3034
3035 typedef struct VkPipelineTessellationStateCreateInfo {
3036     VkStructureType                           sType;
3037     const void*                               pNext;
3038     VkPipelineTessellationStateCreateFlags    flags;
3039     uint32_t                                  patchControlPoints;
3040 } VkPipelineTessellationStateCreateInfo;
3041
3042 typedef struct VkViewport {
3043     float    x;
3044     float    y;
3045     float    width;
3046     float    height;
3047     float    minDepth;
3048     float    maxDepth;
3049 } VkViewport;
3050
3051 typedef struct VkPipelineViewportStateCreateInfo {
3052     VkStructureType                       sType;
3053     const void*                           pNext;
3054     VkPipelineViewportStateCreateFlags    flags;
3055     uint32_t                              viewportCount;
3056     const VkViewport*                     pViewports;
3057     uint32_t                              scissorCount;
3058     const VkRect2D*                       pScissors;
3059 } VkPipelineViewportStateCreateInfo;
3060
3061 typedef struct VkPipelineRasterizationStateCreateInfo {
3062     VkStructureType                            sType;
3063     const void*                                pNext;
3064     VkPipelineRasterizationStateCreateFlags    flags;
3065     VkBool32                                   depthClampEnable;
3066     VkBool32                                   rasterizerDiscardEnable;
3067     VkPolygonMode                              polygonMode;
3068     VkCullModeFlags                            cullMode;
3069     VkFrontFace                                frontFace;
3070     VkBool32                                   depthBiasEnable;
3071     float                                      depthBiasConstantFactor;
3072     float                                      depthBiasClamp;
3073     float                                      depthBiasSlopeFactor;
3074     float                                      lineWidth;
3075 } VkPipelineRasterizationStateCreateInfo;
3076
3077 typedef struct VkPipelineMultisampleStateCreateInfo {
3078     VkStructureType                          sType;
3079     const void*                              pNext;
3080     VkPipelineMultisampleStateCreateFlags    flags;
3081     VkSampleCountFlagBits                    rasterizationSamples;
3082     VkBool32                                 sampleShadingEnable;
3083     float                                    minSampleShading;
3084     const VkSampleMask*                      pSampleMask;
3085     VkBool32                                 alphaToCoverageEnable;
3086     VkBool32                                 alphaToOneEnable;
3087 } VkPipelineMultisampleStateCreateInfo;
3088
3089 typedef struct VkStencilOpState {
3090     VkStencilOp    failOp;
3091     VkStencilOp    passOp;
3092     VkStencilOp    depthFailOp;
3093     VkCompareOp    compareOp;
3094     uint32_t       compareMask;
3095     uint32_t       writeMask;
3096     uint32_t       reference;
3097 } VkStencilOpState;
3098
3099 typedef struct VkPipelineDepthStencilStateCreateInfo {
3100     VkStructureType                           sType;
3101     const void*                               pNext;
3102     VkPipelineDepthStencilStateCreateFlags    flags;
3103     VkBool32                                  depthTestEnable;
3104     VkBool32                                  depthWriteEnable;
3105     VkCompareOp                               depthCompareOp;
3106     VkBool32                                  depthBoundsTestEnable;
3107     VkBool32                                  stencilTestEnable;
3108     VkStencilOpState                          front;
3109     VkStencilOpState                          back;
3110     float                                     minDepthBounds;
3111     float                                     maxDepthBounds;
3112 } VkPipelineDepthStencilStateCreateInfo;
3113
3114 typedef struct VkPipelineColorBlendAttachmentState {
3115     VkBool32                 blendEnable;
3116     VkBlendFactor            srcColorBlendFactor;
3117     VkBlendFactor            dstColorBlendFactor;
3118     VkBlendOp                colorBlendOp;
3119     VkBlendFactor            srcAlphaBlendFactor;
3120     VkBlendFactor            dstAlphaBlendFactor;
3121     VkBlendOp                alphaBlendOp;
3122     VkColorComponentFlags    colorWriteMask;
3123 } VkPipelineColorBlendAttachmentState;
3124
3125 typedef struct VkPipelineColorBlendStateCreateInfo {
3126     VkStructureType                               sType;
3127     const void*                                   pNext;
3128     VkPipelineColorBlendStateCreateFlags          flags;
3129     VkBool32                                      logicOpEnable;
3130     VkLogicOp                                     logicOp;
3131     uint32_t                                      attachmentCount;
3132     const VkPipelineColorBlendAttachmentState*    pAttachments;
3133     float                                         blendConstants[4];
3134 } VkPipelineColorBlendStateCreateInfo;
3135
3136 typedef struct VkPipelineDynamicStateCreateInfo {
3137     VkStructureType                      sType;
3138     const void*                          pNext;
3139     VkPipelineDynamicStateCreateFlags    flags;
3140     uint32_t                             dynamicStateCount;
3141     const VkDynamicState*                pDynamicStates;
3142 } VkPipelineDynamicStateCreateInfo;
3143
3144 typedef struct VkGraphicsPipelineCreateInfo {
3145     VkStructureType                                  sType;
3146     const void*                                      pNext;
3147     VkPipelineCreateFlags                            flags;
3148     uint32_t                                         stageCount;
3149     const VkPipelineShaderStageCreateInfo*           pStages;
3150     const VkPipelineVertexInputStateCreateInfo*      pVertexInputState;
3151     const VkPipelineInputAssemblyStateCreateInfo*    pInputAssemblyState;
3152     const VkPipelineTessellationStateCreateInfo*     pTessellationState;
3153     const VkPipelineViewportStateCreateInfo*         pViewportState;
3154     const VkPipelineRasterizationStateCreateInfo*    pRasterizationState;
3155     const VkPipelineMultisampleStateCreateInfo*      pMultisampleState;
3156     const VkPipelineDepthStencilStateCreateInfo*     pDepthStencilState;
3157     const VkPipelineColorBlendStateCreateInfo*       pColorBlendState;
3158     const VkPipelineDynamicStateCreateInfo*          pDynamicState;
3159     VkPipelineLayout                                 layout;
3160     VkRenderPass                                     renderPass;
3161     uint32_t                                         subpass;
3162     VkPipeline                                       basePipelineHandle;
3163     int32_t                                          basePipelineIndex;
3164 } VkGraphicsPipelineCreateInfo;
3165
3166 typedef struct VkPushConstantRange {
3167     VkShaderStageFlags    stageFlags;
3168     uint32_t              offset;
3169     uint32_t              size;
3170 } VkPushConstantRange;
3171
3172 typedef struct VkPipelineLayoutCreateInfo {
3173     VkStructureType                 sType;
3174     const void*                     pNext;
3175     VkPipelineLayoutCreateFlags     flags;
3176     uint32_t                        setLayoutCount;
3177     const VkDescriptorSetLayout*    pSetLayouts;
3178     uint32_t                        pushConstantRangeCount;
3179     const VkPushConstantRange*      pPushConstantRanges;
3180 } VkPipelineLayoutCreateInfo;
3181
3182 typedef struct VkSamplerCreateInfo {
3183     VkStructureType         sType;
3184     const void*             pNext;
3185     VkSamplerCreateFlags    flags;
3186     VkFilter                magFilter;
3187     VkFilter                minFilter;
3188     VkSamplerMipmapMode     mipmapMode;
3189     VkSamplerAddressMode    addressModeU;
3190     VkSamplerAddressMode    addressModeV;
3191     VkSamplerAddressMode    addressModeW;
3192     float                   mipLodBias;
3193     VkBool32                anisotropyEnable;
3194     float                   maxAnisotropy;
3195     VkBool32                compareEnable;
3196     VkCompareOp             compareOp;
3197     float                   minLod;
3198     float                   maxLod;
3199     VkBorderColor           borderColor;
3200     VkBool32                unnormalizedCoordinates;
3201 } VkSamplerCreateInfo;
3202
3203 typedef struct VkCopyDescriptorSet {
3204     VkStructureType    sType;
3205     const void*        pNext;
3206     VkDescriptorSet    srcSet;
3207     uint32_t           srcBinding;
3208     uint32_t           srcArrayElement;
3209     VkDescriptorSet    dstSet;
3210     uint32_t           dstBinding;
3211     uint32_t           dstArrayElement;
3212     uint32_t           descriptorCount;
3213 } VkCopyDescriptorSet;
3214
3215 typedef struct VkDescriptorBufferInfo {
3216     VkBuffer        buffer;
3217     VkDeviceSize    offset;
3218     VkDeviceSize    range;
3219 } VkDescriptorBufferInfo;
3220
3221 typedef struct VkDescriptorImageInfo {
3222     VkSampler        sampler;
3223     VkImageView      imageView;
3224     VkImageLayout    imageLayout;
3225 } VkDescriptorImageInfo;
3226
3227 typedef struct VkDescriptorPoolSize {
3228     VkDescriptorType    type;
3229     uint32_t            descriptorCount;
3230 } VkDescriptorPoolSize;
3231
3232 typedef struct VkDescriptorPoolCreateInfo {
3233     VkStructureType                sType;
3234     const void*                    pNext;
3235     VkDescriptorPoolCreateFlags    flags;
3236     uint32_t                       maxSets;
3237     uint32_t                       poolSizeCount;
3238     const VkDescriptorPoolSize*    pPoolSizes;
3239 } VkDescriptorPoolCreateInfo;
3240
3241 typedef struct VkDescriptorSetAllocateInfo {
3242     VkStructureType                 sType;
3243     const void*                     pNext;
3244     VkDescriptorPool                descriptorPool;
3245     uint32_t                        descriptorSetCount;
3246     const VkDescriptorSetLayout*    pSetLayouts;
3247 } VkDescriptorSetAllocateInfo;
3248
3249 typedef struct VkDescriptorSetLayoutBinding {
3250     uint32_t              binding;
3251     VkDescriptorType      descriptorType;
3252     uint32_t              descriptorCount;
3253     VkShaderStageFlags    stageFlags;
3254     const VkSampler*      pImmutableSamplers;
3255 } VkDescriptorSetLayoutBinding;
3256
3257 typedef struct VkDescriptorSetLayoutCreateInfo {
3258     VkStructureType                        sType;
3259     const void*                            pNext;
3260     VkDescriptorSetLayoutCreateFlags       flags;
3261     uint32_t                               bindingCount;
3262     const VkDescriptorSetLayoutBinding*    pBindings;
3263 } VkDescriptorSetLayoutCreateInfo;
3264
3265 typedef struct VkWriteDescriptorSet {
3266     VkStructureType                  sType;
3267     const void*                      pNext;
3268     VkDescriptorSet                  dstSet;
3269     uint32_t                         dstBinding;
3270     uint32_t                         dstArrayElement;
3271     uint32_t                         descriptorCount;
3272     VkDescriptorType                 descriptorType;
3273     const VkDescriptorImageInfo*     pImageInfo;
3274     const VkDescriptorBufferInfo*    pBufferInfo;
3275     const VkBufferView*              pTexelBufferView;
3276 } VkWriteDescriptorSet;
3277
3278 typedef struct VkAttachmentDescription {
3279     VkAttachmentDescriptionFlags    flags;
3280     VkFormat                        format;
3281     VkSampleCountFlagBits           samples;
3282     VkAttachmentLoadOp              loadOp;
3283     VkAttachmentStoreOp             storeOp;
3284     VkAttachmentLoadOp              stencilLoadOp;
3285     VkAttachmentStoreOp             stencilStoreOp;
3286     VkImageLayout                   initialLayout;
3287     VkImageLayout                   finalLayout;
3288 } VkAttachmentDescription;
3289
3290 typedef struct VkAttachmentReference {
3291     uint32_t         attachment;
3292     VkImageLayout    layout;
3293 } VkAttachmentReference;
3294
3295 typedef struct VkFramebufferCreateInfo {
3296     VkStructureType             sType;
3297     const void*                 pNext;
3298     VkFramebufferCreateFlags    flags;
3299     VkRenderPass                renderPass;
3300     uint32_t                    attachmentCount;
3301     const VkImageView*          pAttachments;
3302     uint32_t                    width;
3303     uint32_t                    height;
3304     uint32_t                    layers;
3305 } VkFramebufferCreateInfo;
3306
3307 typedef struct VkSubpassDescription {
3308     VkSubpassDescriptionFlags       flags;
3309     VkPipelineBindPoint             pipelineBindPoint;
3310     uint32_t                        inputAttachmentCount;
3311     const VkAttachmentReference*    pInputAttachments;
3312     uint32_t                        colorAttachmentCount;
3313     const VkAttachmentReference*    pColorAttachments;
3314     const VkAttachmentReference*    pResolveAttachments;
3315     const VkAttachmentReference*    pDepthStencilAttachment;
3316     uint32_t                        preserveAttachmentCount;
3317     const uint32_t*                 pPreserveAttachments;
3318 } VkSubpassDescription;
3319
3320 typedef struct VkSubpassDependency {
3321     uint32_t                srcSubpass;
3322     uint32_t                dstSubpass;
3323     VkPipelineStageFlags    srcStageMask;
3324     VkPipelineStageFlags    dstStageMask;
3325     VkAccessFlags           srcAccessMask;
3326     VkAccessFlags           dstAccessMask;
3327     VkDependencyFlags       dependencyFlags;
3328 } VkSubpassDependency;
3329
3330 typedef struct VkRenderPassCreateInfo {
3331     VkStructureType                   sType;
3332     const void*                       pNext;
3333     VkRenderPassCreateFlags           flags;
3334     uint32_t                          attachmentCount;
3335     const VkAttachmentDescription*    pAttachments;
3336     uint32_t                          subpassCount;
3337     const VkSubpassDescription*       pSubpasses;
3338     uint32_t                          dependencyCount;
3339     const VkSubpassDependency*        pDependencies;
3340 } VkRenderPassCreateInfo;
3341
3342 typedef struct VkCommandPoolCreateInfo {
3343     VkStructureType             sType;
3344     const void*                 pNext;
3345     VkCommandPoolCreateFlags    flags;
3346     uint32_t                    queueFamilyIndex;
3347 } VkCommandPoolCreateInfo;
3348
3349 typedef struct VkCommandBufferAllocateInfo {
3350     VkStructureType         sType;
3351     const void*             pNext;
3352     VkCommandPool           commandPool;
3353     VkCommandBufferLevel    level;
3354     uint32_t                commandBufferCount;
3355 } VkCommandBufferAllocateInfo;
3356
3357 typedef struct VkCommandBufferInheritanceInfo {
3358     VkStructureType                  sType;
3359     const void*                      pNext;
3360     VkRenderPass                     renderPass;
3361     uint32_t                         subpass;
3362     VkFramebuffer                    framebuffer;
3363     VkBool32                         occlusionQueryEnable;
3364     VkQueryControlFlags              queryFlags;
3365     VkQueryPipelineStatisticFlags    pipelineStatistics;
3366 } VkCommandBufferInheritanceInfo;
3367
3368 typedef struct VkCommandBufferBeginInfo {
3369     VkStructureType                          sType;
3370     const void*                              pNext;
3371     VkCommandBufferUsageFlags                flags;
3372     const VkCommandBufferInheritanceInfo*    pInheritanceInfo;
3373 } VkCommandBufferBeginInfo;
3374
3375 typedef struct VkBufferCopy {
3376     VkDeviceSize    srcOffset;
3377     VkDeviceSize    dstOffset;
3378     VkDeviceSize    size;
3379 } VkBufferCopy;
3380
3381 typedef struct VkImageSubresourceLayers {
3382     VkImageAspectFlags    aspectMask;
3383     uint32_t              mipLevel;
3384     uint32_t              baseArrayLayer;
3385     uint32_t              layerCount;
3386 } VkImageSubresourceLayers;
3387
3388 typedef struct VkBufferImageCopy {
3389     VkDeviceSize                bufferOffset;
3390     uint32_t                    bufferRowLength;
3391     uint32_t                    bufferImageHeight;
3392     VkImageSubresourceLayers    imageSubresource;
3393     VkOffset3D                  imageOffset;
3394     VkExtent3D                  imageExtent;
3395 } VkBufferImageCopy;
3396
3397 typedef union VkClearColorValue {
3398     float       float32[4];
3399     int32_t     int32[4];
3400     uint32_t    uint32[4];
3401 } VkClearColorValue;
3402
3403 typedef struct VkClearDepthStencilValue {
3404     float       depth;
3405     uint32_t    stencil;
3406 } VkClearDepthStencilValue;
3407
3408 typedef union VkClearValue {
3409     VkClearColorValue           color;
3410     VkClearDepthStencilValue    depthStencil;
3411 } VkClearValue;
3412
3413 typedef struct VkClearAttachment {
3414     VkImageAspectFlags    aspectMask;
3415     uint32_t              colorAttachment;
3416     VkClearValue          clearValue;
3417 } VkClearAttachment;
3418
3419 typedef struct VkClearRect {
3420     VkRect2D    rect;
3421     uint32_t    baseArrayLayer;
3422     uint32_t    layerCount;
3423 } VkClearRect;
3424
3425 typedef struct VkImageBlit {
3426     VkImageSubresourceLayers    srcSubresource;
3427     VkOffset3D                  srcOffsets[2];
3428     VkImageSubresourceLayers    dstSubresource;
3429     VkOffset3D                  dstOffsets[2];
3430 } VkImageBlit;
3431
3432 typedef struct VkImageCopy {
3433     VkImageSubresourceLayers    srcSubresource;
3434     VkOffset3D                  srcOffset;
3435     VkImageSubresourceLayers    dstSubresource;
3436     VkOffset3D                  dstOffset;
3437     VkExtent3D                  extent;
3438 } VkImageCopy;
3439
3440 typedef struct VkImageResolve {
3441     VkImageSubresourceLayers    srcSubresource;
3442     VkOffset3D                  srcOffset;
3443     VkImageSubresourceLayers    dstSubresource;
3444     VkOffset3D                  dstOffset;
3445     VkExtent3D                  extent;
3446 } VkImageResolve;
3447
3448 typedef struct VkRenderPassBeginInfo {
3449     VkStructureType        sType;
3450     const void*            pNext;
3451     VkRenderPass           renderPass;
3452     VkFramebuffer          framebuffer;
3453     VkRect2D               renderArea;
3454     uint32_t               clearValueCount;
3455     const VkClearValue*    pClearValues;
3456 } VkRenderPassBeginInfo;
3457
3458 typedef VkResult (VKAPI_PTR *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance);
3459 typedef void (VKAPI_PTR *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks* pAllocator);
3460 typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
3461 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
3462 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
3463 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
3464 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
3465 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties);
3466 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
3467 typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName);
3468 typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName);
3469 typedef VkResult (VKAPI_PTR *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice);
3470 typedef void (VKAPI_PTR *PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks* pAllocator);
3471 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
3472 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
3473 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties);
3474 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties);
3475 typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
3476 typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence);
3477 typedef VkResult (VKAPI_PTR *PFN_vkQueueWaitIdle)(VkQueue queue);
3478 typedef VkResult (VKAPI_PTR *PFN_vkDeviceWaitIdle)(VkDevice device);
3479 typedef VkResult (VKAPI_PTR *PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory);
3480 typedef void (VKAPI_PTR *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator);
3481 typedef VkResult (VKAPI_PTR *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);
3482 typedef void (VKAPI_PTR *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory);
3483 typedef VkResult (VKAPI_PTR *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
3484 typedef VkResult (VKAPI_PTR *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
3485 typedef void (VKAPI_PTR *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);
3486 typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset);
3487 typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset);
3488 typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
3489 typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
3490 typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
3491 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties);
3492 typedef VkResult (VKAPI_PTR *PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence);
3493 typedef VkResult (VKAPI_PTR *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
3494 typedef void (VKAPI_PTR *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator);
3495 typedef VkResult (VKAPI_PTR *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences);
3496 typedef VkResult (VKAPI_PTR *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence);
3497 typedef VkResult (VKAPI_PTR *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout);
3498 typedef VkResult (VKAPI_PTR *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore);
3499 typedef void (VKAPI_PTR *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator);
3500 typedef VkResult (VKAPI_PTR *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent);
3501 typedef void (VKAPI_PTR *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator);
3502 typedef VkResult (VKAPI_PTR *PFN_vkGetEventStatus)(VkDevice device, VkEvent event);
3503 typedef VkResult (VKAPI_PTR *PFN_vkSetEvent)(VkDevice device, VkEvent event);
3504 typedef VkResult (VKAPI_PTR *PFN_vkResetEvent)(VkDevice device, VkEvent event);
3505 typedef VkResult (VKAPI_PTR *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool);
3506 typedef void (VKAPI_PTR *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator);
3507 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);
3508 typedef VkResult (VKAPI_PTR *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer);
3509 typedef void (VKAPI_PTR *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator);
3510 typedef VkResult (VKAPI_PTR *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView);
3511 typedef void (VKAPI_PTR *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator);
3512 typedef VkResult (VKAPI_PTR *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage);
3513 typedef void (VKAPI_PTR *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator);
3514 typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
3515 typedef VkResult (VKAPI_PTR *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView);
3516 typedef void (VKAPI_PTR *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator);
3517 typedef VkResult (VKAPI_PTR *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule);
3518 typedef void (VKAPI_PTR *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator);
3519 typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache);
3520 typedef void (VKAPI_PTR *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator);
3521 typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData);
3522 typedef VkResult (VKAPI_PTR *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
3523 typedef VkResult (VKAPI_PTR *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
3524 typedef VkResult (VKAPI_PTR *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
3525 typedef void (VKAPI_PTR *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator);
3526 typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout);
3527 typedef void (VKAPI_PTR *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator);
3528 typedef VkResult (VKAPI_PTR *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler);
3529 typedef void (VKAPI_PTR *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator);
3530 typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout);
3531 typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator);
3532 typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool);
3533 typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator);
3534 typedef VkResult (VKAPI_PTR *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);
3535 typedef VkResult (VKAPI_PTR *PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets);
3536 typedef VkResult (VKAPI_PTR *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets);
3537 typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies);
3538 typedef VkResult (VKAPI_PTR *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer);
3539 typedef void (VKAPI_PTR *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator);
3540 typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);
3541 typedef void (VKAPI_PTR *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator);
3542 typedef void (VKAPI_PTR *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
3543 typedef VkResult (VKAPI_PTR *PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool);
3544 typedef void (VKAPI_PTR *PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator);
3545 typedef VkResult (VKAPI_PTR *PFN_vkResetCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags);
3546 typedef VkResult (VKAPI_PTR *PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers);
3547 typedef void (VKAPI_PTR *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
3548 typedef VkResult (VKAPI_PTR *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo);
3549 typedef VkResult (VKAPI_PTR *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer);
3550 typedef VkResult (VKAPI_PTR *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags);
3551 typedef void (VKAPI_PTR *PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
3552 typedef void (VKAPI_PTR *PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports);
3553 typedef void (VKAPI_PTR *PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors);
3554 typedef void (VKAPI_PTR *PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth);
3555 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor);
3556 typedef void (VKAPI_PTR *PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4]);
3557 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds);
3558 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask);
3559 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask);
3560 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference);
3561 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);
3562 typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
3563 typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
3564 typedef void (VKAPI_PTR *PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
3565 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
3566 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
3567 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
3568 typedef void (VKAPI_PTR *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);
3569 typedef void (VKAPI_PTR *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset);
3570 typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions);
3571 typedef void (VKAPI_PTR *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions);
3572 typedef void (VKAPI_PTR *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter);
3573 typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);
3574 typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);
3575 typedef void (VKAPI_PTR *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData);
3576 typedef void (VKAPI_PTR *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data);
3577 typedef void (VKAPI_PTR *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
3578 typedef void (VKAPI_PTR *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
3579 typedef void (VKAPI_PTR *PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects);
3580 typedef void (VKAPI_PTR *PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
3581 typedef void (VKAPI_PTR *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
3582 typedef void (VKAPI_PTR *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
3583 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);
3584 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);
3585 typedef void (VKAPI_PTR *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags);
3586 typedef void (VKAPI_PTR *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query);
3587 typedef void (VKAPI_PTR *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);
3588 typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query);
3589 typedef void (VKAPI_PTR *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags);
3590 typedef void (VKAPI_PTR *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues);
3591 typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents);
3592 typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkSubpassContents contents);
3593 typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer);
3594 typedef void (VKAPI_PTR *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
3595
3596 #ifndef VK_NO_PROTOTYPES
3597 VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(
3598     const VkInstanceCreateInfo*                 pCreateInfo,
3599     const VkAllocationCallbacks*                pAllocator,
3600     VkInstance*                                 pInstance);
3601
3602 VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(
3603     VkInstance                                  instance,
3604     const VkAllocationCallbacks*                pAllocator);
3605
3606 VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices(
3607     VkInstance                                  instance,
3608     uint32_t*                                   pPhysicalDeviceCount,
3609     VkPhysicalDevice*                           pPhysicalDevices);
3610
3611 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures(
3612     VkPhysicalDevice                            physicalDevice,
3613     VkPhysicalDeviceFeatures*                   pFeatures);
3614
3615 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties(
3616     VkPhysicalDevice                            physicalDevice,
3617     VkFormat                                    format,
3618     VkFormatProperties*                         pFormatProperties);
3619
3620 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties(
3621     VkPhysicalDevice                            physicalDevice,
3622     VkFormat                                    format,
3623     VkImageType                                 type,
3624     VkImageTiling                               tiling,
3625     VkImageUsageFlags                           usage,
3626     VkImageCreateFlags                          flags,
3627     VkImageFormatProperties*                    pImageFormatProperties);
3628
3629 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties(
3630     VkPhysicalDevice                            physicalDevice,
3631     VkPhysicalDeviceProperties*                 pProperties);
3632
3633 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties(
3634     VkPhysicalDevice                            physicalDevice,
3635     uint32_t*                                   pQueueFamilyPropertyCount,
3636     VkQueueFamilyProperties*                    pQueueFamilyProperties);
3637
3638 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties(
3639     VkPhysicalDevice                            physicalDevice,
3640     VkPhysicalDeviceMemoryProperties*           pMemoryProperties);
3641
3642 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(
3643     VkInstance                                  instance,
3644     const char*                                 pName);
3645
3646 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(
3647     VkDevice                                    device,
3648     const char*                                 pName);
3649
3650 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(
3651     VkPhysicalDevice                            physicalDevice,
3652     const VkDeviceCreateInfo*                   pCreateInfo,
3653     const VkAllocationCallbacks*                pAllocator,
3654     VkDevice*                                   pDevice);
3655
3656 VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(
3657     VkDevice                                    device,
3658     const VkAllocationCallbacks*                pAllocator);
3659
3660 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(
3661     const char*                                 pLayerName,
3662     uint32_t*                                   pPropertyCount,
3663     VkExtensionProperties*                      pProperties);
3664
3665 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(
3666     VkPhysicalDevice                            physicalDevice,
3667     const char*                                 pLayerName,
3668     uint32_t*                                   pPropertyCount,
3669     VkExtensionProperties*                      pProperties);
3670
3671 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(
3672     uint32_t*                                   pPropertyCount,
3673     VkLayerProperties*                          pProperties);
3674
3675 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(
3676     VkPhysicalDevice                            physicalDevice,
3677     uint32_t*                                   pPropertyCount,
3678     VkLayerProperties*                          pProperties);
3679
3680 VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue(
3681     VkDevice                                    device,
3682     uint32_t                                    queueFamilyIndex,
3683     uint32_t                                    queueIndex,
3684     VkQueue*                                    pQueue);
3685
3686 VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit(
3687     VkQueue                                     queue,
3688     uint32_t                                    submitCount,
3689     const VkSubmitInfo*                         pSubmits,
3690     VkFence                                     fence);
3691
3692 VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle(
3693     VkQueue                                     queue);
3694
3695 VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle(
3696     VkDevice                                    device);
3697
3698 VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory(
3699     VkDevice                                    device,
3700     const VkMemoryAllocateInfo*                 pAllocateInfo,
3701     const VkAllocationCallbacks*                pAllocator,
3702     VkDeviceMemory*                             pMemory);
3703
3704 VKAPI_ATTR void VKAPI_CALL vkFreeMemory(
3705     VkDevice                                    device,
3706     VkDeviceMemory                              memory,
3707     const VkAllocationCallbacks*                pAllocator);
3708
3709 VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory(
3710     VkDevice                                    device,
3711     VkDeviceMemory                              memory,
3712     VkDeviceSize                                offset,
3713     VkDeviceSize                                size,
3714     VkMemoryMapFlags                            flags,
3715     void**                                      ppData);
3716
3717 VKAPI_ATTR void VKAPI_CALL vkUnmapMemory(
3718     VkDevice                                    device,
3719     VkDeviceMemory                              memory);
3720
3721 VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges(
3722     VkDevice                                    device,
3723     uint32_t                                    memoryRangeCount,
3724     const VkMappedMemoryRange*                  pMemoryRanges);
3725
3726 VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges(
3727     VkDevice                                    device,
3728     uint32_t                                    memoryRangeCount,
3729     const VkMappedMemoryRange*                  pMemoryRanges);
3730
3731 VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment(
3732     VkDevice                                    device,
3733     VkDeviceMemory                              memory,
3734     VkDeviceSize*                               pCommittedMemoryInBytes);
3735
3736 VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory(
3737     VkDevice                                    device,
3738     VkBuffer                                    buffer,
3739     VkDeviceMemory                              memory,
3740     VkDeviceSize                                memoryOffset);
3741
3742 VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory(
3743     VkDevice                                    device,
3744     VkImage                                     image,
3745     VkDeviceMemory                              memory,
3746     VkDeviceSize                                memoryOffset);
3747
3748 VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements(
3749     VkDevice                                    device,
3750     VkBuffer                                    buffer,
3751     VkMemoryRequirements*                       pMemoryRequirements);
3752
3753 VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements(
3754     VkDevice                                    device,
3755     VkImage                                     image,
3756     VkMemoryRequirements*                       pMemoryRequirements);
3757
3758 VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements(
3759     VkDevice                                    device,
3760     VkImage                                     image,
3761     uint32_t*                                   pSparseMemoryRequirementCount,
3762     VkSparseImageMemoryRequirements*            pSparseMemoryRequirements);
3763
3764 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties(
3765     VkPhysicalDevice                            physicalDevice,
3766     VkFormat                                    format,
3767     VkImageType                                 type,
3768     VkSampleCountFlagBits                       samples,
3769     VkImageUsageFlags                           usage,
3770     VkImageTiling                               tiling,
3771     uint32_t*                                   pPropertyCount,
3772     VkSparseImageFormatProperties*              pProperties);
3773
3774 VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse(
3775     VkQueue                                     queue,
3776     uint32_t                                    bindInfoCount,
3777     const VkBindSparseInfo*                     pBindInfo,
3778     VkFence                                     fence);
3779
3780 VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence(
3781     VkDevice                                    device,
3782     const VkFenceCreateInfo*                    pCreateInfo,
3783     const VkAllocationCallbacks*                pAllocator,
3784     VkFence*                                    pFence);
3785
3786 VKAPI_ATTR void VKAPI_CALL vkDestroyFence(
3787     VkDevice                                    device,
3788     VkFence                                     fence,
3789     const VkAllocationCallbacks*                pAllocator);
3790
3791 VKAPI_ATTR VkResult VKAPI_CALL vkResetFences(
3792     VkDevice                                    device,
3793     uint32_t                                    fenceCount,
3794     const VkFence*                              pFences);
3795
3796 VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus(
3797     VkDevice                                    device,
3798     VkFence                                     fence);
3799
3800 VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences(
3801     VkDevice                                    device,
3802     uint32_t                                    fenceCount,
3803     const VkFence*                              pFences,
3804     VkBool32                                    waitAll,
3805     uint64_t                                    timeout);
3806
3807 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore(
3808     VkDevice                                    device,
3809     const VkSemaphoreCreateInfo*                pCreateInfo,
3810     const VkAllocationCallbacks*                pAllocator,
3811     VkSemaphore*                                pSemaphore);
3812
3813 VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore(
3814     VkDevice                                    device,
3815     VkSemaphore                                 semaphore,
3816     const VkAllocationCallbacks*                pAllocator);
3817
3818 VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent(
3819     VkDevice                                    device,
3820     const VkEventCreateInfo*                    pCreateInfo,
3821     const VkAllocationCallbacks*                pAllocator,
3822     VkEvent*                                    pEvent);
3823
3824 VKAPI_ATTR void VKAPI_CALL vkDestroyEvent(
3825     VkDevice                                    device,
3826     VkEvent                                     event,
3827     const VkAllocationCallbacks*                pAllocator);
3828
3829 VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus(
3830     VkDevice                                    device,
3831     VkEvent                                     event);
3832
3833 VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent(
3834     VkDevice                                    device,
3835     VkEvent                                     event);
3836
3837 VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent(
3838     VkDevice                                    device,
3839     VkEvent                                     event);
3840
3841 VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool(
3842     VkDevice                                    device,
3843     const VkQueryPoolCreateInfo*                pCreateInfo,
3844     const VkAllocationCallbacks*                pAllocator,
3845     VkQueryPool*                                pQueryPool);
3846
3847 VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool(
3848     VkDevice                                    device,
3849     VkQueryPool                                 queryPool,
3850     const VkAllocationCallbacks*                pAllocator);
3851
3852 VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults(
3853     VkDevice                                    device,
3854     VkQueryPool                                 queryPool,
3855     uint32_t                                    firstQuery,
3856     uint32_t                                    queryCount,
3857     size_t                                      dataSize,
3858     void*                                       pData,
3859     VkDeviceSize                                stride,
3860     VkQueryResultFlags                          flags);
3861
3862 VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer(
3863     VkDevice                                    device,
3864     const VkBufferCreateInfo*                   pCreateInfo,
3865     const VkAllocationCallbacks*                pAllocator,
3866     VkBuffer*                                   pBuffer);
3867
3868 VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer(
3869     VkDevice                                    device,
3870     VkBuffer                                    buffer,
3871     const VkAllocationCallbacks*                pAllocator);
3872
3873 VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView(
3874     VkDevice                                    device,
3875     const VkBufferViewCreateInfo*               pCreateInfo,
3876     const VkAllocationCallbacks*                pAllocator,
3877     VkBufferView*                               pView);
3878
3879 VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView(
3880     VkDevice                                    device,
3881     VkBufferView                                bufferView,
3882     const VkAllocationCallbacks*                pAllocator);
3883
3884 VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(
3885     VkDevice                                    device,
3886     const VkImageCreateInfo*                    pCreateInfo,
3887     const VkAllocationCallbacks*                pAllocator,
3888     VkImage*                                    pImage);
3889
3890 VKAPI_ATTR void VKAPI_CALL vkDestroyImage(
3891     VkDevice                                    device,
3892     VkImage                                     image,
3893     const VkAllocationCallbacks*                pAllocator);
3894
3895 VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout(
3896     VkDevice                                    device,
3897     VkImage                                     image,
3898     const VkImageSubresource*                   pSubresource,
3899     VkSubresourceLayout*                        pLayout);
3900
3901 VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView(
3902     VkDevice                                    device,
3903     const VkImageViewCreateInfo*                pCreateInfo,
3904     const VkAllocationCallbacks*                pAllocator,
3905     VkImageView*                                pView);
3906
3907 VKAPI_ATTR void VKAPI_CALL vkDestroyImageView(
3908     VkDevice                                    device,
3909     VkImageView                                 imageView,
3910     const VkAllocationCallbacks*                pAllocator);
3911
3912 VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule(
3913     VkDevice                                    device,
3914     const VkShaderModuleCreateInfo*             pCreateInfo,
3915     const VkAllocationCallbacks*                pAllocator,
3916     VkShaderModule*                             pShaderModule);
3917
3918 VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule(
3919     VkDevice                                    device,
3920     VkShaderModule                              shaderModule,
3921     const VkAllocationCallbacks*                pAllocator);
3922
3923 VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache(
3924     VkDevice                                    device,
3925     const VkPipelineCacheCreateInfo*            pCreateInfo,
3926     const VkAllocationCallbacks*                pAllocator,
3927     VkPipelineCache*                            pPipelineCache);
3928
3929 VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache(
3930     VkDevice                                    device,
3931     VkPipelineCache                             pipelineCache,
3932     const VkAllocationCallbacks*                pAllocator);
3933
3934 VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData(
3935     VkDevice                                    device,
3936     VkPipelineCache                             pipelineCache,
3937     size_t*                                     pDataSize,
3938     void*                                       pData);
3939
3940 VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches(
3941     VkDevice                                    device,
3942     VkPipelineCache                             dstCache,
3943     uint32_t                                    srcCacheCount,
3944     const VkPipelineCache*                      pSrcCaches);
3945
3946 VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines(
3947     VkDevice                                    device,
3948     VkPipelineCache                             pipelineCache,
3949     uint32_t                                    createInfoCount,
3950     const VkGraphicsPipelineCreateInfo*         pCreateInfos,
3951     const VkAllocationCallbacks*                pAllocator,
3952     VkPipeline*                                 pPipelines);
3953
3954 VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines(
3955     VkDevice                                    device,
3956     VkPipelineCache                             pipelineCache,
3957     uint32_t                                    createInfoCount,
3958     const VkComputePipelineCreateInfo*          pCreateInfos,
3959     const VkAllocationCallbacks*                pAllocator,
3960     VkPipeline*                                 pPipelines);
3961
3962 VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline(
3963     VkDevice                                    device,
3964     VkPipeline                                  pipeline,
3965     const VkAllocationCallbacks*                pAllocator);
3966
3967 VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout(
3968     VkDevice                                    device,
3969     const VkPipelineLayoutCreateInfo*           pCreateInfo,
3970     const VkAllocationCallbacks*                pAllocator,
3971     VkPipelineLayout*                           pPipelineLayout);
3972
3973 VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout(
3974     VkDevice                                    device,
3975     VkPipelineLayout                            pipelineLayout,
3976     const VkAllocationCallbacks*                pAllocator);
3977
3978 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler(
3979     VkDevice                                    device,
3980     const VkSamplerCreateInfo*                  pCreateInfo,
3981     const VkAllocationCallbacks*                pAllocator,
3982     VkSampler*                                  pSampler);
3983
3984 VKAPI_ATTR void VKAPI_CALL vkDestroySampler(
3985     VkDevice                                    device,
3986     VkSampler                                   sampler,
3987     const VkAllocationCallbacks*                pAllocator);
3988
3989 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout(
3990     VkDevice                                    device,
3991     const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
3992     const VkAllocationCallbacks*                pAllocator,
3993     VkDescriptorSetLayout*                      pSetLayout);
3994
3995 VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout(
3996     VkDevice                                    device,
3997     VkDescriptorSetLayout                       descriptorSetLayout,
3998     const VkAllocationCallbacks*                pAllocator);
3999
4000 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool(
4001     VkDevice                                    device,
4002     const VkDescriptorPoolCreateInfo*           pCreateInfo,
4003     const VkAllocationCallbacks*                pAllocator,
4004     VkDescriptorPool*                           pDescriptorPool);
4005
4006 VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool(
4007     VkDevice                                    device,
4008     VkDescriptorPool                            descriptorPool,
4009     const VkAllocationCallbacks*                pAllocator);
4010
4011 VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool(
4012     VkDevice                                    device,
4013     VkDescriptorPool                            descriptorPool,
4014     VkDescriptorPoolResetFlags                  flags);
4015
4016 VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets(
4017     VkDevice                                    device,
4018     const VkDescriptorSetAllocateInfo*          pAllocateInfo,
4019     VkDescriptorSet*                            pDescriptorSets);
4020
4021 VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets(
4022     VkDevice                                    device,
4023     VkDescriptorPool                            descriptorPool,
4024     uint32_t                                    descriptorSetCount,
4025     const VkDescriptorSet*                      pDescriptorSets);
4026
4027 VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets(
4028     VkDevice                                    device,
4029     uint32_t                                    descriptorWriteCount,
4030     const VkWriteDescriptorSet*                 pDescriptorWrites,
4031     uint32_t                                    descriptorCopyCount,
4032     const VkCopyDescriptorSet*                  pDescriptorCopies);
4033
4034 VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer(
4035     VkDevice                                    device,
4036     const VkFramebufferCreateInfo*              pCreateInfo,
4037     const VkAllocationCallbacks*                pAllocator,
4038     VkFramebuffer*                              pFramebuffer);
4039
4040 VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer(
4041     VkDevice                                    device,
4042     VkFramebuffer                               framebuffer,
4043     const VkAllocationCallbacks*                pAllocator);
4044
4045 VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass(
4046     VkDevice                                    device,
4047     const VkRenderPassCreateInfo*               pCreateInfo,
4048     const VkAllocationCallbacks*                pAllocator,
4049     VkRenderPass*                               pRenderPass);
4050
4051 VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass(
4052     VkDevice                                    device,
4053     VkRenderPass                                renderPass,
4054     const VkAllocationCallbacks*                pAllocator);
4055
4056 VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity(
4057     VkDevice                                    device,
4058     VkRenderPass                                renderPass,
4059     VkExtent2D*                                 pGranularity);
4060
4061 VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool(
4062     VkDevice                                    device,
4063     const VkCommandPoolCreateInfo*              pCreateInfo,
4064     const VkAllocationCallbacks*                pAllocator,
4065     VkCommandPool*                              pCommandPool);
4066
4067 VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool(
4068     VkDevice                                    device,
4069     VkCommandPool                               commandPool,
4070     const VkAllocationCallbacks*                pAllocator);
4071
4072 VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool(
4073     VkDevice                                    device,
4074     VkCommandPool                               commandPool,
4075     VkCommandPoolResetFlags                     flags);
4076
4077 VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers(
4078     VkDevice                                    device,
4079     const VkCommandBufferAllocateInfo*          pAllocateInfo,
4080     VkCommandBuffer*                            pCommandBuffers);
4081
4082 VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers(
4083     VkDevice                                    device,
4084     VkCommandPool                               commandPool,
4085     uint32_t                                    commandBufferCount,
4086     const VkCommandBuffer*                      pCommandBuffers);
4087
4088 VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer(
4089     VkCommandBuffer                             commandBuffer,
4090     const VkCommandBufferBeginInfo*             pBeginInfo);
4091
4092 VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer(
4093     VkCommandBuffer                             commandBuffer);
4094
4095 VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer(
4096     VkCommandBuffer                             commandBuffer,
4097     VkCommandBufferResetFlags                   flags);
4098
4099 VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline(
4100     VkCommandBuffer                             commandBuffer,
4101     VkPipelineBindPoint                         pipelineBindPoint,
4102     VkPipeline                                  pipeline);
4103
4104 VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport(
4105     VkCommandBuffer                             commandBuffer,
4106     uint32_t                                    firstViewport,
4107     uint32_t                                    viewportCount,
4108     const VkViewport*                           pViewports);
4109
4110 VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor(
4111     VkCommandBuffer                             commandBuffer,
4112     uint32_t                                    firstScissor,
4113     uint32_t                                    scissorCount,
4114     const VkRect2D*                             pScissors);
4115
4116 VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth(
4117     VkCommandBuffer                             commandBuffer,
4118     float                                       lineWidth);
4119
4120 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias(
4121     VkCommandBuffer                             commandBuffer,
4122     float                                       depthBiasConstantFactor,
4123     float                                       depthBiasClamp,
4124     float                                       depthBiasSlopeFactor);
4125
4126 VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants(
4127     VkCommandBuffer                             commandBuffer,
4128     const float                                 blendConstants[4]);
4129
4130 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds(
4131     VkCommandBuffer                             commandBuffer,
4132     float                                       minDepthBounds,
4133     float                                       maxDepthBounds);
4134
4135 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask(
4136     VkCommandBuffer                             commandBuffer,
4137     VkStencilFaceFlags                          faceMask,
4138     uint32_t                                    compareMask);
4139
4140 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask(
4141     VkCommandBuffer                             commandBuffer,
4142     VkStencilFaceFlags                          faceMask,
4143     uint32_t                                    writeMask);
4144
4145 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference(
4146     VkCommandBuffer                             commandBuffer,
4147     VkStencilFaceFlags                          faceMask,
4148     uint32_t                                    reference);
4149
4150 VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets(
4151     VkCommandBuffer                             commandBuffer,
4152     VkPipelineBindPoint                         pipelineBindPoint,
4153     VkPipelineLayout                            layout,
4154     uint32_t                                    firstSet,
4155     uint32_t                                    descriptorSetCount,
4156     const VkDescriptorSet*                      pDescriptorSets,
4157     uint32_t                                    dynamicOffsetCount,
4158     const uint32_t*                             pDynamicOffsets);
4159
4160 VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer(
4161     VkCommandBuffer                             commandBuffer,
4162     VkBuffer                                    buffer,
4163     VkDeviceSize                                offset,
4164     VkIndexType                                 indexType);
4165
4166 VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers(
4167     VkCommandBuffer                             commandBuffer,
4168     uint32_t                                    firstBinding,
4169     uint32_t                                    bindingCount,
4170     const VkBuffer*                             pBuffers,
4171     const VkDeviceSize*                         pOffsets);
4172
4173 VKAPI_ATTR void VKAPI_CALL vkCmdDraw(
4174     VkCommandBuffer                             commandBuffer,
4175     uint32_t                                    vertexCount,
4176     uint32_t                                    instanceCount,
4177     uint32_t                                    firstVertex,
4178     uint32_t                                    firstInstance);
4179
4180 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed(
4181     VkCommandBuffer                             commandBuffer,
4182     uint32_t                                    indexCount,
4183     uint32_t                                    instanceCount,
4184     uint32_t                                    firstIndex,
4185     int32_t                                     vertexOffset,
4186     uint32_t                                    firstInstance);
4187
4188 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect(
4189     VkCommandBuffer                             commandBuffer,
4190     VkBuffer                                    buffer,
4191     VkDeviceSize                                offset,
4192     uint32_t                                    drawCount,
4193     uint32_t                                    stride);
4194
4195 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect(
4196     VkCommandBuffer                             commandBuffer,
4197     VkBuffer                                    buffer,
4198     VkDeviceSize                                offset,
4199     uint32_t                                    drawCount,
4200     uint32_t                                    stride);
4201
4202 VKAPI_ATTR void VKAPI_CALL vkCmdDispatch(
4203     VkCommandBuffer                             commandBuffer,
4204     uint32_t                                    groupCountX,
4205     uint32_t                                    groupCountY,
4206     uint32_t                                    groupCountZ);
4207
4208 VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect(
4209     VkCommandBuffer                             commandBuffer,
4210     VkBuffer                                    buffer,
4211     VkDeviceSize                                offset);
4212
4213 VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer(
4214     VkCommandBuffer                             commandBuffer,
4215     VkBuffer                                    srcBuffer,
4216     VkBuffer                                    dstBuffer,
4217     uint32_t                                    regionCount,
4218     const VkBufferCopy*                         pRegions);
4219
4220 VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage(
4221     VkCommandBuffer                             commandBuffer,
4222     VkImage                                     srcImage,
4223     VkImageLayout                               srcImageLayout,
4224     VkImage                                     dstImage,
4225     VkImageLayout                               dstImageLayout,
4226     uint32_t                                    regionCount,
4227     const VkImageCopy*                          pRegions);
4228
4229 VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage(
4230     VkCommandBuffer                             commandBuffer,
4231     VkImage                                     srcImage,
4232     VkImageLayout                               srcImageLayout,
4233     VkImage                                     dstImage,
4234     VkImageLayout                               dstImageLayout,
4235     uint32_t                                    regionCount,
4236     const VkImageBlit*                          pRegions,
4237     VkFilter                                    filter);
4238
4239 VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage(
4240     VkCommandBuffer                             commandBuffer,
4241     VkBuffer                                    srcBuffer,
4242     VkImage                                     dstImage,
4243     VkImageLayout                               dstImageLayout,
4244     uint32_t                                    regionCount,
4245     const VkBufferImageCopy*                    pRegions);
4246
4247 VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer(
4248     VkCommandBuffer                             commandBuffer,
4249     VkImage                                     srcImage,
4250     VkImageLayout                               srcImageLayout,
4251     VkBuffer                                    dstBuffer,
4252     uint32_t                                    regionCount,
4253     const VkBufferImageCopy*                    pRegions);
4254
4255 VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer(
4256     VkCommandBuffer                             commandBuffer,
4257     VkBuffer                                    dstBuffer,
4258     VkDeviceSize                                dstOffset,
4259     VkDeviceSize                                dataSize,
4260     const void*                                 pData);
4261
4262 VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer(
4263     VkCommandBuffer                             commandBuffer,
4264     VkBuffer                                    dstBuffer,
4265     VkDeviceSize                                dstOffset,
4266     VkDeviceSize                                size,
4267     uint32_t                                    data);
4268
4269 VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage(
4270     VkCommandBuffer                             commandBuffer,
4271     VkImage                                     image,
4272     VkImageLayout                               imageLayout,
4273     const VkClearColorValue*                    pColor,
4274     uint32_t                                    rangeCount,
4275     const VkImageSubresourceRange*              pRanges);
4276
4277 VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage(
4278     VkCommandBuffer                             commandBuffer,
4279     VkImage                                     image,
4280     VkImageLayout                               imageLayout,
4281     const VkClearDepthStencilValue*             pDepthStencil,
4282     uint32_t                                    rangeCount,
4283     const VkImageSubresourceRange*              pRanges);
4284
4285 VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments(
4286     VkCommandBuffer                             commandBuffer,
4287     uint32_t                                    attachmentCount,
4288     const VkClearAttachment*                    pAttachments,
4289     uint32_t                                    rectCount,
4290     const VkClearRect*                          pRects);
4291
4292 VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage(
4293     VkCommandBuffer                             commandBuffer,
4294     VkImage                                     srcImage,
4295     VkImageLayout                               srcImageLayout,
4296     VkImage                                     dstImage,
4297     VkImageLayout                               dstImageLayout,
4298     uint32_t                                    regionCount,
4299     const VkImageResolve*                       pRegions);
4300
4301 VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent(
4302     VkCommandBuffer                             commandBuffer,
4303     VkEvent                                     event,
4304     VkPipelineStageFlags                        stageMask);
4305
4306 VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent(
4307     VkCommandBuffer                             commandBuffer,
4308     VkEvent                                     event,
4309     VkPipelineStageFlags                        stageMask);
4310
4311 VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents(
4312     VkCommandBuffer                             commandBuffer,
4313     uint32_t                                    eventCount,
4314     const VkEvent*                              pEvents,
4315     VkPipelineStageFlags                        srcStageMask,
4316     VkPipelineStageFlags                        dstStageMask,
4317     uint32_t                                    memoryBarrierCount,
4318     const VkMemoryBarrier*                      pMemoryBarriers,
4319     uint32_t                                    bufferMemoryBarrierCount,
4320     const VkBufferMemoryBarrier*                pBufferMemoryBarriers,
4321     uint32_t                                    imageMemoryBarrierCount,
4322     const VkImageMemoryBarrier*                 pImageMemoryBarriers);
4323
4324 VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier(
4325     VkCommandBuffer                             commandBuffer,
4326     VkPipelineStageFlags                        srcStageMask,
4327     VkPipelineStageFlags                        dstStageMask,
4328     VkDependencyFlags                           dependencyFlags,
4329     uint32_t                                    memoryBarrierCount,
4330     const VkMemoryBarrier*                      pMemoryBarriers,
4331     uint32_t                                    bufferMemoryBarrierCount,
4332     const VkBufferMemoryBarrier*                pBufferMemoryBarriers,
4333     uint32_t                                    imageMemoryBarrierCount,
4334     const VkImageMemoryBarrier*                 pImageMemoryBarriers);
4335
4336 VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery(
4337     VkCommandBuffer                             commandBuffer,
4338     VkQueryPool                                 queryPool,
4339     uint32_t                                    query,
4340     VkQueryControlFlags                         flags);
4341
4342 VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery(
4343     VkCommandBuffer                             commandBuffer,
4344     VkQueryPool                                 queryPool,
4345     uint32_t                                    query);
4346
4347 VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool(
4348     VkCommandBuffer                             commandBuffer,
4349     VkQueryPool                                 queryPool,
4350     uint32_t                                    firstQuery,
4351     uint32_t                                    queryCount);
4352
4353 VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp(
4354     VkCommandBuffer                             commandBuffer,
4355     VkPipelineStageFlagBits                     pipelineStage,
4356     VkQueryPool                                 queryPool,
4357     uint32_t                                    query);
4358
4359 VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults(
4360     VkCommandBuffer                             commandBuffer,
4361     VkQueryPool                                 queryPool,
4362     uint32_t                                    firstQuery,
4363     uint32_t                                    queryCount,
4364     VkBuffer                                    dstBuffer,
4365     VkDeviceSize                                dstOffset,
4366     VkDeviceSize                                stride,
4367     VkQueryResultFlags                          flags);
4368
4369 VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants(
4370     VkCommandBuffer                             commandBuffer,
4371     VkPipelineLayout                            layout,
4372     VkShaderStageFlags                          stageFlags,
4373     uint32_t                                    offset,
4374     uint32_t                                    size,
4375     const void*                                 pValues);
4376
4377 VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass(
4378     VkCommandBuffer                             commandBuffer,
4379     const VkRenderPassBeginInfo*                pRenderPassBegin,
4380     VkSubpassContents                           contents);
4381
4382 VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass(
4383     VkCommandBuffer                             commandBuffer,
4384     VkSubpassContents                           contents);
4385
4386 VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass(
4387     VkCommandBuffer                             commandBuffer);
4388
4389 VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands(
4390     VkCommandBuffer                             commandBuffer,
4391     uint32_t                                    commandBufferCount,
4392     const VkCommandBuffer*                      pCommandBuffers);
4393 #endif
4394
4395
4396 #define VK_VERSION_1_1 1
4397 // Vulkan 1.1 version number
4398 #define VK_API_VERSION_1_1 VK_MAKE_API_VERSION(0, 1, 1, 0)// Patch version should always be set to 0
4399
4400 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSamplerYcbcrConversion)
4401 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorUpdateTemplate)
4402 #define VK_MAX_DEVICE_GROUP_SIZE          32U
4403 #define VK_LUID_SIZE                      8U
4404 #define VK_QUEUE_FAMILY_EXTERNAL          (~1U)
4405
4406 typedef enum VkPointClippingBehavior {
4407     VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES = 0,
4408     VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY = 1,
4409     VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES,
4410     VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY,
4411     VK_POINT_CLIPPING_BEHAVIOR_MAX_ENUM = 0x7FFFFFFF
4412 } VkPointClippingBehavior;
4413
4414 typedef enum VkTessellationDomainOrigin {
4415     VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT = 0,
4416     VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT = 1,
4417     VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT,
4418     VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT,
4419     VK_TESSELLATION_DOMAIN_ORIGIN_MAX_ENUM = 0x7FFFFFFF
4420 } VkTessellationDomainOrigin;
4421
4422 typedef enum VkSamplerYcbcrModelConversion {
4423     VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY = 0,
4424     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY = 1,
4425     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709 = 2,
4426     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601 = 3,
4427     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 = 4,
4428     VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY,
4429     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY,
4430     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709,
4431     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601,
4432     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020,
4433     VK_SAMPLER_YCBCR_MODEL_CONVERSION_MAX_ENUM = 0x7FFFFFFF
4434 } VkSamplerYcbcrModelConversion;
4435
4436 typedef enum VkSamplerYcbcrRange {
4437     VK_SAMPLER_YCBCR_RANGE_ITU_FULL = 0,
4438     VK_SAMPLER_YCBCR_RANGE_ITU_NARROW = 1,
4439     VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_FULL,
4440     VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW,
4441     VK_SAMPLER_YCBCR_RANGE_MAX_ENUM = 0x7FFFFFFF
4442 } VkSamplerYcbcrRange;
4443
4444 typedef enum VkChromaLocation {
4445     VK_CHROMA_LOCATION_COSITED_EVEN = 0,
4446     VK_CHROMA_LOCATION_MIDPOINT = 1,
4447     VK_CHROMA_LOCATION_COSITED_EVEN_KHR = VK_CHROMA_LOCATION_COSITED_EVEN,
4448     VK_CHROMA_LOCATION_MIDPOINT_KHR = VK_CHROMA_LOCATION_MIDPOINT,
4449     VK_CHROMA_LOCATION_MAX_ENUM = 0x7FFFFFFF
4450 } VkChromaLocation;
4451
4452 typedef enum VkDescriptorUpdateTemplateType {
4453     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET = 0,
4454     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = 1,
4455     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET,
4456     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM = 0x7FFFFFFF
4457 } VkDescriptorUpdateTemplateType;
4458
4459 typedef enum VkSubgroupFeatureFlagBits {
4460     VK_SUBGROUP_FEATURE_BASIC_BIT = 0x00000001,
4461     VK_SUBGROUP_FEATURE_VOTE_BIT = 0x00000002,
4462     VK_SUBGROUP_FEATURE_ARITHMETIC_BIT = 0x00000004,
4463     VK_SUBGROUP_FEATURE_BALLOT_BIT = 0x00000008,
4464     VK_SUBGROUP_FEATURE_SHUFFLE_BIT = 0x00000010,
4465     VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT = 0x00000020,
4466     VK_SUBGROUP_FEATURE_CLUSTERED_BIT = 0x00000040,
4467     VK_SUBGROUP_FEATURE_QUAD_BIT = 0x00000080,
4468     VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV = 0x00000100,
4469     VK_SUBGROUP_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
4470 } VkSubgroupFeatureFlagBits;
4471 typedef VkFlags VkSubgroupFeatureFlags;
4472
4473 typedef enum VkPeerMemoryFeatureFlagBits {
4474     VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT = 0x00000001,
4475     VK_PEER_MEMORY_FEATURE_COPY_DST_BIT = 0x00000002,
4476     VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT = 0x00000004,
4477     VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT = 0x00000008,
4478     VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHR = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT,
4479     VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHR = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT,
4480     VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHR = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT,
4481     VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHR = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT,
4482     VK_PEER_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
4483 } VkPeerMemoryFeatureFlagBits;
4484 typedef VkFlags VkPeerMemoryFeatureFlags;
4485
4486 typedef enum VkMemoryAllocateFlagBits {
4487     VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT = 0x00000001,
4488     VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT = 0x00000002,
4489     VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 0x00000004,
4490     VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT,
4491     VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT,
4492     VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT,
4493     VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
4494 } VkMemoryAllocateFlagBits;
4495 typedef VkFlags VkMemoryAllocateFlags;
4496 typedef VkFlags VkCommandPoolTrimFlags;
4497 typedef VkFlags VkDescriptorUpdateTemplateCreateFlags;
4498
4499 typedef enum VkExternalMemoryHandleTypeFlagBits {
4500     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001,
4501     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002,
4502     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004,
4503     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT = 0x00000008,
4504     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT = 0x00000010,
4505     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT = 0x00000020,
4506     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT = 0x00000040,
4507     VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT = 0x00000200,
4508     VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID = 0x00000400,
4509     VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT = 0x00000080,
4510     VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT = 0x00000100,
4511     VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA = 0x00000800,
4512     VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV = 0x00001000,
4513     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT,
4514     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT,
4515     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
4516     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT,
4517     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT,
4518     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT,
4519     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT,
4520     VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
4521 } VkExternalMemoryHandleTypeFlagBits;
4522 typedef VkFlags VkExternalMemoryHandleTypeFlags;
4523
4524 typedef enum VkExternalMemoryFeatureFlagBits {
4525     VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT = 0x00000001,
4526     VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT = 0x00000002,
4527     VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT = 0x00000004,
4528     VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT,
4529     VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT,
4530     VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT,
4531     VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
4532 } VkExternalMemoryFeatureFlagBits;
4533 typedef VkFlags VkExternalMemoryFeatureFlags;
4534
4535 typedef enum VkExternalFenceHandleTypeFlagBits {
4536     VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001,
4537     VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002,
4538     VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004,
4539     VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000008,
4540     VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT,
4541     VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT,
4542     VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
4543     VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT,
4544     VK_EXTERNAL_FENCE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
4545 } VkExternalFenceHandleTypeFlagBits;
4546 typedef VkFlags VkExternalFenceHandleTypeFlags;
4547
4548 typedef enum VkExternalFenceFeatureFlagBits {
4549     VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT = 0x00000001,
4550     VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT = 0x00000002,
4551     VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT,
4552     VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT,
4553     VK_EXTERNAL_FENCE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
4554 } VkExternalFenceFeatureFlagBits;
4555 typedef VkFlags VkExternalFenceFeatureFlags;
4556
4557 typedef enum VkFenceImportFlagBits {
4558     VK_FENCE_IMPORT_TEMPORARY_BIT = 0x00000001,
4559     VK_FENCE_IMPORT_TEMPORARY_BIT_KHR = VK_FENCE_IMPORT_TEMPORARY_BIT,
4560     VK_FENCE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
4561 } VkFenceImportFlagBits;
4562 typedef VkFlags VkFenceImportFlags;
4563
4564 typedef enum VkSemaphoreImportFlagBits {
4565     VK_SEMAPHORE_IMPORT_TEMPORARY_BIT = 0x00000001,
4566     VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT,
4567     VK_SEMAPHORE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
4568 } VkSemaphoreImportFlagBits;
4569 typedef VkFlags VkSemaphoreImportFlags;
4570
4571 typedef enum VkExternalSemaphoreHandleTypeFlagBits {
4572     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001,
4573     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002,
4574     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004,
4575     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT = 0x00000008,
4576     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000010,
4577     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA = 0x00000080,
4578     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE_BIT = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT,
4579     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT,
4580     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT,
4581     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
4582     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT,
4583     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT,
4584     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
4585 } VkExternalSemaphoreHandleTypeFlagBits;
4586 typedef VkFlags VkExternalSemaphoreHandleTypeFlags;
4587
4588 typedef enum VkExternalSemaphoreFeatureFlagBits {
4589     VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT = 0x00000001,
4590     VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT = 0x00000002,
4591     VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT,
4592     VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT,
4593     VK_EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
4594 } VkExternalSemaphoreFeatureFlagBits;
4595 typedef VkFlags VkExternalSemaphoreFeatureFlags;
4596 typedef struct VkPhysicalDeviceSubgroupProperties {
4597     VkStructureType           sType;
4598     void*                     pNext;
4599     uint32_t                  subgroupSize;
4600     VkShaderStageFlags        supportedStages;
4601     VkSubgroupFeatureFlags    supportedOperations;
4602     VkBool32                  quadOperationsInAllStages;
4603 } VkPhysicalDeviceSubgroupProperties;
4604
4605 typedef struct VkBindBufferMemoryInfo {
4606     VkStructureType    sType;
4607     const void*        pNext;
4608     VkBuffer           buffer;
4609     VkDeviceMemory     memory;
4610     VkDeviceSize       memoryOffset;
4611 } VkBindBufferMemoryInfo;
4612
4613 typedef struct VkBindImageMemoryInfo {
4614     VkStructureType    sType;
4615     const void*        pNext;
4616     VkImage            image;
4617     VkDeviceMemory     memory;
4618     VkDeviceSize       memoryOffset;
4619 } VkBindImageMemoryInfo;
4620
4621 typedef struct VkPhysicalDevice16BitStorageFeatures {
4622     VkStructureType    sType;
4623     void*              pNext;
4624     VkBool32           storageBuffer16BitAccess;
4625     VkBool32           uniformAndStorageBuffer16BitAccess;
4626     VkBool32           storagePushConstant16;
4627     VkBool32           storageInputOutput16;
4628 } VkPhysicalDevice16BitStorageFeatures;
4629
4630 typedef struct VkMemoryDedicatedRequirements {
4631     VkStructureType    sType;
4632     void*              pNext;
4633     VkBool32           prefersDedicatedAllocation;
4634     VkBool32           requiresDedicatedAllocation;
4635 } VkMemoryDedicatedRequirements;
4636
4637 typedef struct VkMemoryDedicatedAllocateInfo {
4638     VkStructureType    sType;
4639     const void*        pNext;
4640     VkImage            image;
4641     VkBuffer           buffer;
4642 } VkMemoryDedicatedAllocateInfo;
4643
4644 typedef struct VkMemoryAllocateFlagsInfo {
4645     VkStructureType          sType;
4646     const void*              pNext;
4647     VkMemoryAllocateFlags    flags;
4648     uint32_t                 deviceMask;
4649 } VkMemoryAllocateFlagsInfo;
4650
4651 typedef struct VkDeviceGroupRenderPassBeginInfo {
4652     VkStructureType    sType;
4653     const void*        pNext;
4654     uint32_t           deviceMask;
4655     uint32_t           deviceRenderAreaCount;
4656     const VkRect2D*    pDeviceRenderAreas;
4657 } VkDeviceGroupRenderPassBeginInfo;
4658
4659 typedef struct VkDeviceGroupCommandBufferBeginInfo {
4660     VkStructureType    sType;
4661     const void*        pNext;
4662     uint32_t           deviceMask;
4663 } VkDeviceGroupCommandBufferBeginInfo;
4664
4665 typedef struct VkDeviceGroupSubmitInfo {
4666     VkStructureType    sType;
4667     const void*        pNext;
4668     uint32_t           waitSemaphoreCount;
4669     const uint32_t*    pWaitSemaphoreDeviceIndices;
4670     uint32_t           commandBufferCount;
4671     const uint32_t*    pCommandBufferDeviceMasks;
4672     uint32_t           signalSemaphoreCount;
4673     const uint32_t*    pSignalSemaphoreDeviceIndices;
4674 } VkDeviceGroupSubmitInfo;
4675
4676 typedef struct VkDeviceGroupBindSparseInfo {
4677     VkStructureType    sType;
4678     const void*        pNext;
4679     uint32_t           resourceDeviceIndex;
4680     uint32_t           memoryDeviceIndex;
4681 } VkDeviceGroupBindSparseInfo;
4682
4683 typedef struct VkBindBufferMemoryDeviceGroupInfo {
4684     VkStructureType    sType;
4685     const void*        pNext;
4686     uint32_t           deviceIndexCount;
4687     const uint32_t*    pDeviceIndices;
4688 } VkBindBufferMemoryDeviceGroupInfo;
4689
4690 typedef struct VkBindImageMemoryDeviceGroupInfo {
4691     VkStructureType    sType;
4692     const void*        pNext;
4693     uint32_t           deviceIndexCount;
4694     const uint32_t*    pDeviceIndices;
4695     uint32_t           splitInstanceBindRegionCount;
4696     const VkRect2D*    pSplitInstanceBindRegions;
4697 } VkBindImageMemoryDeviceGroupInfo;
4698
4699 typedef struct VkPhysicalDeviceGroupProperties {
4700     VkStructureType     sType;
4701     void*               pNext;
4702     uint32_t            physicalDeviceCount;
4703     VkPhysicalDevice    physicalDevices[VK_MAX_DEVICE_GROUP_SIZE];
4704     VkBool32            subsetAllocation;
4705 } VkPhysicalDeviceGroupProperties;
4706
4707 typedef struct VkDeviceGroupDeviceCreateInfo {
4708     VkStructureType            sType;
4709     const void*                pNext;
4710     uint32_t                   physicalDeviceCount;
4711     const VkPhysicalDevice*    pPhysicalDevices;
4712 } VkDeviceGroupDeviceCreateInfo;
4713
4714 typedef struct VkBufferMemoryRequirementsInfo2 {
4715     VkStructureType    sType;
4716     const void*        pNext;
4717     VkBuffer           buffer;
4718 } VkBufferMemoryRequirementsInfo2;
4719
4720 typedef struct VkImageMemoryRequirementsInfo2 {
4721     VkStructureType    sType;
4722     const void*        pNext;
4723     VkImage            image;
4724 } VkImageMemoryRequirementsInfo2;
4725
4726 typedef struct VkImageSparseMemoryRequirementsInfo2 {
4727     VkStructureType    sType;
4728     const void*        pNext;
4729     VkImage            image;
4730 } VkImageSparseMemoryRequirementsInfo2;
4731
4732 typedef struct VkMemoryRequirements2 {
4733     VkStructureType         sType;
4734     void*                   pNext;
4735     VkMemoryRequirements    memoryRequirements;
4736 } VkMemoryRequirements2;
4737
4738 typedef struct VkSparseImageMemoryRequirements2 {
4739     VkStructureType                    sType;
4740     void*                              pNext;
4741     VkSparseImageMemoryRequirements    memoryRequirements;
4742 } VkSparseImageMemoryRequirements2;
4743
4744 typedef struct VkPhysicalDeviceFeatures2 {
4745     VkStructureType             sType;
4746     void*                       pNext;
4747     VkPhysicalDeviceFeatures    features;
4748 } VkPhysicalDeviceFeatures2;
4749
4750 typedef struct VkPhysicalDeviceProperties2 {
4751     VkStructureType               sType;
4752     void*                         pNext;
4753     VkPhysicalDeviceProperties    properties;
4754 } VkPhysicalDeviceProperties2;
4755
4756 typedef struct VkFormatProperties2 {
4757     VkStructureType       sType;
4758     void*                 pNext;
4759     VkFormatProperties    formatProperties;
4760 } VkFormatProperties2;
4761
4762 typedef struct VkImageFormatProperties2 {
4763     VkStructureType            sType;
4764     void*                      pNext;
4765     VkImageFormatProperties    imageFormatProperties;
4766 } VkImageFormatProperties2;
4767
4768 typedef struct VkPhysicalDeviceImageFormatInfo2 {
4769     VkStructureType       sType;
4770     const void*           pNext;
4771     VkFormat              format;
4772     VkImageType           type;
4773     VkImageTiling         tiling;
4774     VkImageUsageFlags     usage;
4775     VkImageCreateFlags    flags;
4776 } VkPhysicalDeviceImageFormatInfo2;
4777
4778 typedef struct VkQueueFamilyProperties2 {
4779     VkStructureType            sType;
4780     void*                      pNext;
4781     VkQueueFamilyProperties    queueFamilyProperties;
4782 } VkQueueFamilyProperties2;
4783
4784 typedef struct VkPhysicalDeviceMemoryProperties2 {
4785     VkStructureType                     sType;
4786     void*                               pNext;
4787     VkPhysicalDeviceMemoryProperties    memoryProperties;
4788 } VkPhysicalDeviceMemoryProperties2;
4789
4790 typedef struct VkSparseImageFormatProperties2 {
4791     VkStructureType                  sType;
4792     void*                            pNext;
4793     VkSparseImageFormatProperties    properties;
4794 } VkSparseImageFormatProperties2;
4795
4796 typedef struct VkPhysicalDeviceSparseImageFormatInfo2 {
4797     VkStructureType          sType;
4798     const void*              pNext;
4799     VkFormat                 format;
4800     VkImageType              type;
4801     VkSampleCountFlagBits    samples;
4802     VkImageUsageFlags        usage;
4803     VkImageTiling            tiling;
4804 } VkPhysicalDeviceSparseImageFormatInfo2;
4805
4806 typedef struct VkPhysicalDevicePointClippingProperties {
4807     VkStructureType            sType;
4808     void*                      pNext;
4809     VkPointClippingBehavior    pointClippingBehavior;
4810 } VkPhysicalDevicePointClippingProperties;
4811
4812 typedef struct VkInputAttachmentAspectReference {
4813     uint32_t              subpass;
4814     uint32_t              inputAttachmentIndex;
4815     VkImageAspectFlags    aspectMask;
4816 } VkInputAttachmentAspectReference;
4817
4818 typedef struct VkRenderPassInputAttachmentAspectCreateInfo {
4819     VkStructureType                            sType;
4820     const void*                                pNext;
4821     uint32_t                                   aspectReferenceCount;
4822     const VkInputAttachmentAspectReference*    pAspectReferences;
4823 } VkRenderPassInputAttachmentAspectCreateInfo;
4824
4825 typedef struct VkImageViewUsageCreateInfo {
4826     VkStructureType      sType;
4827     const void*          pNext;
4828     VkImageUsageFlags    usage;
4829 } VkImageViewUsageCreateInfo;
4830
4831 typedef struct VkPipelineTessellationDomainOriginStateCreateInfo {
4832     VkStructureType               sType;
4833     const void*                   pNext;
4834     VkTessellationDomainOrigin    domainOrigin;
4835 } VkPipelineTessellationDomainOriginStateCreateInfo;
4836
4837 typedef struct VkRenderPassMultiviewCreateInfo {
4838     VkStructureType    sType;
4839     const void*        pNext;
4840     uint32_t           subpassCount;
4841     const uint32_t*    pViewMasks;
4842     uint32_t           dependencyCount;
4843     const int32_t*     pViewOffsets;
4844     uint32_t           correlationMaskCount;
4845     const uint32_t*    pCorrelationMasks;
4846 } VkRenderPassMultiviewCreateInfo;
4847
4848 typedef struct VkPhysicalDeviceMultiviewFeatures {
4849     VkStructureType    sType;
4850     void*              pNext;
4851     VkBool32           multiview;
4852     VkBool32           multiviewGeometryShader;
4853     VkBool32           multiviewTessellationShader;
4854 } VkPhysicalDeviceMultiviewFeatures;
4855
4856 typedef struct VkPhysicalDeviceMultiviewProperties {
4857     VkStructureType    sType;
4858     void*              pNext;
4859     uint32_t           maxMultiviewViewCount;
4860     uint32_t           maxMultiviewInstanceIndex;
4861 } VkPhysicalDeviceMultiviewProperties;
4862
4863 typedef struct VkPhysicalDeviceVariablePointersFeatures {
4864     VkStructureType    sType;
4865     void*              pNext;
4866     VkBool32           variablePointersStorageBuffer;
4867     VkBool32           variablePointers;
4868 } VkPhysicalDeviceVariablePointersFeatures;
4869
4870 typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointerFeatures;
4871
4872 typedef struct VkPhysicalDeviceProtectedMemoryFeatures {
4873     VkStructureType    sType;
4874     void*              pNext;
4875     VkBool32           protectedMemory;
4876 } VkPhysicalDeviceProtectedMemoryFeatures;
4877
4878 typedef struct VkPhysicalDeviceProtectedMemoryProperties {
4879     VkStructureType    sType;
4880     void*              pNext;
4881     VkBool32           protectedNoFault;
4882 } VkPhysicalDeviceProtectedMemoryProperties;
4883
4884 typedef struct VkDeviceQueueInfo2 {
4885     VkStructureType             sType;
4886     const void*                 pNext;
4887     VkDeviceQueueCreateFlags    flags;
4888     uint32_t                    queueFamilyIndex;
4889     uint32_t                    queueIndex;
4890 } VkDeviceQueueInfo2;
4891
4892 typedef struct VkProtectedSubmitInfo {
4893     VkStructureType    sType;
4894     const void*        pNext;
4895     VkBool32           protectedSubmit;
4896 } VkProtectedSubmitInfo;
4897
4898 typedef struct VkSamplerYcbcrConversionCreateInfo {
4899     VkStructureType                  sType;
4900     const void*                      pNext;
4901     VkFormat                         format;
4902     VkSamplerYcbcrModelConversion    ycbcrModel;
4903     VkSamplerYcbcrRange              ycbcrRange;
4904     VkComponentMapping               components;
4905     VkChromaLocation                 xChromaOffset;
4906     VkChromaLocation                 yChromaOffset;
4907     VkFilter                         chromaFilter;
4908     VkBool32                         forceExplicitReconstruction;
4909 } VkSamplerYcbcrConversionCreateInfo;
4910
4911 typedef struct VkSamplerYcbcrConversionInfo {
4912     VkStructureType             sType;
4913     const void*                 pNext;
4914     VkSamplerYcbcrConversion    conversion;
4915 } VkSamplerYcbcrConversionInfo;
4916
4917 typedef struct VkBindImagePlaneMemoryInfo {
4918     VkStructureType          sType;
4919     const void*              pNext;
4920     VkImageAspectFlagBits    planeAspect;
4921 } VkBindImagePlaneMemoryInfo;
4922
4923 typedef struct VkImagePlaneMemoryRequirementsInfo {
4924     VkStructureType          sType;
4925     const void*              pNext;
4926     VkImageAspectFlagBits    planeAspect;
4927 } VkImagePlaneMemoryRequirementsInfo;
4928
4929 typedef struct VkPhysicalDeviceSamplerYcbcrConversionFeatures {
4930     VkStructureType    sType;
4931     void*              pNext;
4932     VkBool32           samplerYcbcrConversion;
4933 } VkPhysicalDeviceSamplerYcbcrConversionFeatures;
4934
4935 typedef struct VkSamplerYcbcrConversionImageFormatProperties {
4936     VkStructureType    sType;
4937     void*              pNext;
4938     uint32_t           combinedImageSamplerDescriptorCount;
4939 } VkSamplerYcbcrConversionImageFormatProperties;
4940
4941 typedef struct VkDescriptorUpdateTemplateEntry {
4942     uint32_t            dstBinding;
4943     uint32_t            dstArrayElement;
4944     uint32_t            descriptorCount;
4945     VkDescriptorType    descriptorType;
4946     size_t              offset;
4947     size_t              stride;
4948 } VkDescriptorUpdateTemplateEntry;
4949
4950 typedef struct VkDescriptorUpdateTemplateCreateInfo {
4951     VkStructureType                           sType;
4952     const void*                               pNext;
4953     VkDescriptorUpdateTemplateCreateFlags     flags;
4954     uint32_t                                  descriptorUpdateEntryCount;
4955     const VkDescriptorUpdateTemplateEntry*    pDescriptorUpdateEntries;
4956     VkDescriptorUpdateTemplateType            templateType;
4957     VkDescriptorSetLayout                     descriptorSetLayout;
4958     VkPipelineBindPoint                       pipelineBindPoint;
4959     VkPipelineLayout                          pipelineLayout;
4960     uint32_t                                  set;
4961 } VkDescriptorUpdateTemplateCreateInfo;
4962
4963 typedef struct VkExternalMemoryProperties {
4964     VkExternalMemoryFeatureFlags       externalMemoryFeatures;
4965     VkExternalMemoryHandleTypeFlags    exportFromImportedHandleTypes;
4966     VkExternalMemoryHandleTypeFlags    compatibleHandleTypes;
4967 } VkExternalMemoryProperties;
4968
4969 typedef struct VkPhysicalDeviceExternalImageFormatInfo {
4970     VkStructureType                       sType;
4971     const void*                           pNext;
4972     VkExternalMemoryHandleTypeFlagBits    handleType;
4973 } VkPhysicalDeviceExternalImageFormatInfo;
4974
4975 typedef struct VkExternalImageFormatProperties {
4976     VkStructureType               sType;
4977     void*                         pNext;
4978     VkExternalMemoryProperties    externalMemoryProperties;
4979 } VkExternalImageFormatProperties;
4980
4981 typedef struct VkPhysicalDeviceExternalBufferInfo {
4982     VkStructureType                       sType;
4983     const void*                           pNext;
4984     VkBufferCreateFlags                   flags;
4985     VkBufferUsageFlags                    usage;
4986     VkExternalMemoryHandleTypeFlagBits    handleType;
4987 } VkPhysicalDeviceExternalBufferInfo;
4988
4989 typedef struct VkExternalBufferProperties {
4990     VkStructureType               sType;
4991     void*                         pNext;
4992     VkExternalMemoryProperties    externalMemoryProperties;
4993 } VkExternalBufferProperties;
4994
4995 typedef struct VkPhysicalDeviceIDProperties {
4996     VkStructureType    sType;
4997     void*              pNext;
4998     uint8_t            deviceUUID[VK_UUID_SIZE];
4999     uint8_t            driverUUID[VK_UUID_SIZE];
5000     uint8_t            deviceLUID[VK_LUID_SIZE];
5001     uint32_t           deviceNodeMask;
5002     VkBool32           deviceLUIDValid;
5003 } VkPhysicalDeviceIDProperties;
5004
5005 typedef struct VkExternalMemoryImageCreateInfo {
5006     VkStructureType                    sType;
5007     const void*                        pNext;
5008     VkExternalMemoryHandleTypeFlags    handleTypes;
5009 } VkExternalMemoryImageCreateInfo;
5010
5011 typedef struct VkExternalMemoryBufferCreateInfo {
5012     VkStructureType                    sType;
5013     const void*                        pNext;
5014     VkExternalMemoryHandleTypeFlags    handleTypes;
5015 } VkExternalMemoryBufferCreateInfo;
5016
5017 typedef struct VkExportMemoryAllocateInfo {
5018     VkStructureType                    sType;
5019     const void*                        pNext;
5020     VkExternalMemoryHandleTypeFlags    handleTypes;
5021 } VkExportMemoryAllocateInfo;
5022
5023 typedef struct VkPhysicalDeviceExternalFenceInfo {
5024     VkStructureType                      sType;
5025     const void*                          pNext;
5026     VkExternalFenceHandleTypeFlagBits    handleType;
5027 } VkPhysicalDeviceExternalFenceInfo;
5028
5029 typedef struct VkExternalFenceProperties {
5030     VkStructureType                   sType;
5031     void*                             pNext;
5032     VkExternalFenceHandleTypeFlags    exportFromImportedHandleTypes;
5033     VkExternalFenceHandleTypeFlags    compatibleHandleTypes;
5034     VkExternalFenceFeatureFlags       externalFenceFeatures;
5035 } VkExternalFenceProperties;
5036
5037 typedef struct VkExportFenceCreateInfo {
5038     VkStructureType                   sType;
5039     const void*                       pNext;
5040     VkExternalFenceHandleTypeFlags    handleTypes;
5041 } VkExportFenceCreateInfo;
5042
5043 typedef struct VkExportSemaphoreCreateInfo {
5044     VkStructureType                       sType;
5045     const void*                           pNext;
5046     VkExternalSemaphoreHandleTypeFlags    handleTypes;
5047 } VkExportSemaphoreCreateInfo;
5048
5049 typedef struct VkPhysicalDeviceExternalSemaphoreInfo {
5050     VkStructureType                          sType;
5051     const void*                              pNext;
5052     VkExternalSemaphoreHandleTypeFlagBits    handleType;
5053 } VkPhysicalDeviceExternalSemaphoreInfo;
5054
5055 typedef struct VkExternalSemaphoreProperties {
5056     VkStructureType                       sType;
5057     void*                                 pNext;
5058     VkExternalSemaphoreHandleTypeFlags    exportFromImportedHandleTypes;
5059     VkExternalSemaphoreHandleTypeFlags    compatibleHandleTypes;
5060     VkExternalSemaphoreFeatureFlags       externalSemaphoreFeatures;
5061 } VkExternalSemaphoreProperties;
5062
5063 typedef struct VkPhysicalDeviceMaintenance3Properties {
5064     VkStructureType    sType;
5065     void*              pNext;
5066     uint32_t           maxPerSetDescriptors;
5067     VkDeviceSize       maxMemoryAllocationSize;
5068 } VkPhysicalDeviceMaintenance3Properties;
5069
5070 typedef struct VkDescriptorSetLayoutSupport {
5071     VkStructureType    sType;
5072     void*              pNext;
5073     VkBool32           supported;
5074 } VkDescriptorSetLayoutSupport;
5075
5076 typedef struct VkPhysicalDeviceShaderDrawParametersFeatures {
5077     VkStructureType    sType;
5078     void*              pNext;
5079     VkBool32           shaderDrawParameters;
5080 } VkPhysicalDeviceShaderDrawParametersFeatures;
5081
5082 typedef VkPhysicalDeviceShaderDrawParametersFeatures VkPhysicalDeviceShaderDrawParameterFeatures;
5083
5084 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceVersion)(uint32_t* pApiVersion);
5085 typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos);
5086 typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos);
5087 typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeatures)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);
5088 typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMask)(VkCommandBuffer commandBuffer, uint32_t deviceMask);
5089 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);
5090 typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroups)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);
5091 typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2)(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements);
5092 typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2)(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements);
5093 typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements2)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
5094 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures);
5095 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties);
5096 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties);
5097 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties);
5098 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties);
5099 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties);
5100 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties);
5101 typedef void (VKAPI_PTR *PFN_vkTrimCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags);
5102 typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue2)(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue);
5103 typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversion)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion);
5104 typedef void (VKAPI_PTR *PFN_vkDestroySamplerYcbcrConversion)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator);
5105 typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplate)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);
5106 typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplate)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator);
5107 typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplate)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData);
5108 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties);
5109 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFenceProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties);
5110 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphoreProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties);
5111 typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutSupport)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport);
5112
5113 #ifndef VK_NO_PROTOTYPES
5114 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceVersion(
5115     uint32_t*                                   pApiVersion);
5116
5117 VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2(
5118     VkDevice                                    device,
5119     uint32_t                                    bindInfoCount,
5120     const VkBindBufferMemoryInfo*               pBindInfos);
5121
5122 VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2(
5123     VkDevice                                    device,
5124     uint32_t                                    bindInfoCount,
5125     const VkBindImageMemoryInfo*                pBindInfos);
5126
5127 VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeatures(
5128     VkDevice                                    device,
5129     uint32_t                                    heapIndex,
5130     uint32_t                                    localDeviceIndex,
5131     uint32_t                                    remoteDeviceIndex,
5132     VkPeerMemoryFeatureFlags*                   pPeerMemoryFeatures);
5133
5134 VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMask(
5135     VkCommandBuffer                             commandBuffer,
5136     uint32_t                                    deviceMask);
5137
5138 VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBase(
5139     VkCommandBuffer                             commandBuffer,
5140     uint32_t                                    baseGroupX,
5141     uint32_t                                    baseGroupY,
5142     uint32_t                                    baseGroupZ,
5143     uint32_t                                    groupCountX,
5144     uint32_t                                    groupCountY,
5145     uint32_t                                    groupCountZ);
5146
5147 VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroups(
5148     VkInstance                                  instance,
5149     uint32_t*                                   pPhysicalDeviceGroupCount,
5150     VkPhysicalDeviceGroupProperties*            pPhysicalDeviceGroupProperties);
5151
5152 VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2(
5153     VkDevice                                    device,
5154     const VkImageMemoryRequirementsInfo2*       pInfo,
5155     VkMemoryRequirements2*                      pMemoryRequirements);
5156
5157 VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2(
5158     VkDevice                                    device,
5159     const VkBufferMemoryRequirementsInfo2*      pInfo,
5160     VkMemoryRequirements2*                      pMemoryRequirements);
5161
5162 VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2(
5163     VkDevice                                    device,
5164     const VkImageSparseMemoryRequirementsInfo2* pInfo,
5165     uint32_t*                                   pSparseMemoryRequirementCount,
5166     VkSparseImageMemoryRequirements2*           pSparseMemoryRequirements);
5167
5168 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2(
5169     VkPhysicalDevice                            physicalDevice,
5170     VkPhysicalDeviceFeatures2*                  pFeatures);
5171
5172 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2(
5173     VkPhysicalDevice                            physicalDevice,
5174     VkPhysicalDeviceProperties2*                pProperties);
5175
5176 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2(
5177     VkPhysicalDevice                            physicalDevice,
5178     VkFormat                                    format,
5179     VkFormatProperties2*                        pFormatProperties);
5180
5181 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2(
5182     VkPhysicalDevice                            physicalDevice,
5183     const VkPhysicalDeviceImageFormatInfo2*     pImageFormatInfo,
5184     VkImageFormatProperties2*                   pImageFormatProperties);
5185
5186 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2(
5187     VkPhysicalDevice                            physicalDevice,
5188     uint32_t*                                   pQueueFamilyPropertyCount,
5189     VkQueueFamilyProperties2*                   pQueueFamilyProperties);
5190
5191 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2(
5192     VkPhysicalDevice                            physicalDevice,
5193     VkPhysicalDeviceMemoryProperties2*          pMemoryProperties);
5194
5195 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2(
5196     VkPhysicalDevice                            physicalDevice,
5197     const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
5198     uint32_t*                                   pPropertyCount,
5199     VkSparseImageFormatProperties2*             pProperties);
5200
5201 VKAPI_ATTR void VKAPI_CALL vkTrimCommandPool(
5202     VkDevice                                    device,
5203     VkCommandPool                               commandPool,
5204     VkCommandPoolTrimFlags                      flags);
5205
5206 VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue2(
5207     VkDevice                                    device,
5208     const VkDeviceQueueInfo2*                   pQueueInfo,
5209     VkQueue*                                    pQueue);
5210
5211 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversion(
5212     VkDevice                                    device,
5213     const VkSamplerYcbcrConversionCreateInfo*   pCreateInfo,
5214     const VkAllocationCallbacks*                pAllocator,
5215     VkSamplerYcbcrConversion*                   pYcbcrConversion);
5216
5217 VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversion(
5218     VkDevice                                    device,
5219     VkSamplerYcbcrConversion                    ycbcrConversion,
5220     const VkAllocationCallbacks*                pAllocator);
5221
5222 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplate(
5223     VkDevice                                    device,
5224     const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
5225     const VkAllocationCallbacks*                pAllocator,
5226     VkDescriptorUpdateTemplate*                 pDescriptorUpdateTemplate);
5227
5228 VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplate(
5229     VkDevice                                    device,
5230     VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
5231     const VkAllocationCallbacks*                pAllocator);
5232
5233 VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplate(
5234     VkDevice                                    device,
5235     VkDescriptorSet                             descriptorSet,
5236     VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
5237     const void*                                 pData);
5238
5239 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferProperties(
5240     VkPhysicalDevice                            physicalDevice,
5241     const VkPhysicalDeviceExternalBufferInfo*   pExternalBufferInfo,
5242     VkExternalBufferProperties*                 pExternalBufferProperties);
5243
5244 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFenceProperties(
5245     VkPhysicalDevice                            physicalDevice,
5246     const VkPhysicalDeviceExternalFenceInfo*    pExternalFenceInfo,
5247     VkExternalFenceProperties*                  pExternalFenceProperties);
5248
5249 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphoreProperties(
5250     VkPhysicalDevice                            physicalDevice,
5251     const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
5252     VkExternalSemaphoreProperties*              pExternalSemaphoreProperties);
5253
5254 VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupport(
5255     VkDevice                                    device,
5256     const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
5257     VkDescriptorSetLayoutSupport*               pSupport);
5258 #endif
5259
5260
5261 #define VK_VERSION_1_2 1
5262 // Vulkan 1.2 version number
5263 #define VK_API_VERSION_1_2 VK_MAKE_API_VERSION(0, 1, 2, 0)// Patch version should always be set to 0
5264
5265 #define VK_MAX_DRIVER_NAME_SIZE           256U
5266 #define VK_MAX_DRIVER_INFO_SIZE           256U
5267
5268 typedef enum VkDriverId {
5269     VK_DRIVER_ID_AMD_PROPRIETARY = 1,
5270     VK_DRIVER_ID_AMD_OPEN_SOURCE = 2,
5271     VK_DRIVER_ID_MESA_RADV = 3,
5272     VK_DRIVER_ID_NVIDIA_PROPRIETARY = 4,
5273     VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS = 5,
5274     VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA = 6,
5275     VK_DRIVER_ID_IMAGINATION_PROPRIETARY = 7,
5276     VK_DRIVER_ID_QUALCOMM_PROPRIETARY = 8,
5277     VK_DRIVER_ID_ARM_PROPRIETARY = 9,
5278     VK_DRIVER_ID_GOOGLE_SWIFTSHADER = 10,
5279     VK_DRIVER_ID_GGP_PROPRIETARY = 11,
5280     VK_DRIVER_ID_BROADCOM_PROPRIETARY = 12,
5281     VK_DRIVER_ID_MESA_LLVMPIPE = 13,
5282     VK_DRIVER_ID_MOLTENVK = 14,
5283     VK_DRIVER_ID_COREAVI_PROPRIETARY = 15,
5284     VK_DRIVER_ID_JUICE_PROPRIETARY = 16,
5285     VK_DRIVER_ID_AMD_PROPRIETARY_KHR = VK_DRIVER_ID_AMD_PROPRIETARY,
5286     VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR = VK_DRIVER_ID_AMD_OPEN_SOURCE,
5287     VK_DRIVER_ID_MESA_RADV_KHR = VK_DRIVER_ID_MESA_RADV,
5288     VK_DRIVER_ID_NVIDIA_PROPRIETARY_KHR = VK_DRIVER_ID_NVIDIA_PROPRIETARY,
5289     VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS_KHR = VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS,
5290     VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA_KHR = VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA,
5291     VK_DRIVER_ID_IMAGINATION_PROPRIETARY_KHR = VK_DRIVER_ID_IMAGINATION_PROPRIETARY,
5292     VK_DRIVER_ID_QUALCOMM_PROPRIETARY_KHR = VK_DRIVER_ID_QUALCOMM_PROPRIETARY,
5293     VK_DRIVER_ID_ARM_PROPRIETARY_KHR = VK_DRIVER_ID_ARM_PROPRIETARY,
5294     VK_DRIVER_ID_GOOGLE_SWIFTSHADER_KHR = VK_DRIVER_ID_GOOGLE_SWIFTSHADER,
5295     VK_DRIVER_ID_GGP_PROPRIETARY_KHR = VK_DRIVER_ID_GGP_PROPRIETARY,
5296     VK_DRIVER_ID_BROADCOM_PROPRIETARY_KHR = VK_DRIVER_ID_BROADCOM_PROPRIETARY,
5297     VK_DRIVER_ID_MAX_ENUM = 0x7FFFFFFF
5298 } VkDriverId;
5299
5300 typedef enum VkShaderFloatControlsIndependence {
5301     VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY = 0,
5302     VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL = 1,
5303     VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE = 2,
5304     VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY,
5305     VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL,
5306     VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE,
5307     VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_MAX_ENUM = 0x7FFFFFFF
5308 } VkShaderFloatControlsIndependence;
5309
5310 typedef enum VkSamplerReductionMode {
5311     VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE = 0,
5312     VK_SAMPLER_REDUCTION_MODE_MIN = 1,
5313     VK_SAMPLER_REDUCTION_MODE_MAX = 2,
5314     VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE,
5315     VK_SAMPLER_REDUCTION_MODE_MIN_EXT = VK_SAMPLER_REDUCTION_MODE_MIN,
5316     VK_SAMPLER_REDUCTION_MODE_MAX_EXT = VK_SAMPLER_REDUCTION_MODE_MAX,
5317     VK_SAMPLER_REDUCTION_MODE_MAX_ENUM = 0x7FFFFFFF
5318 } VkSamplerReductionMode;
5319
5320 typedef enum VkSemaphoreType {
5321     VK_SEMAPHORE_TYPE_BINARY = 0,
5322     VK_SEMAPHORE_TYPE_TIMELINE = 1,
5323     VK_SEMAPHORE_TYPE_BINARY_KHR = VK_SEMAPHORE_TYPE_BINARY,
5324     VK_SEMAPHORE_TYPE_TIMELINE_KHR = VK_SEMAPHORE_TYPE_TIMELINE,
5325     VK_SEMAPHORE_TYPE_MAX_ENUM = 0x7FFFFFFF
5326 } VkSemaphoreType;
5327
5328 typedef enum VkResolveModeFlagBits {
5329     VK_RESOLVE_MODE_NONE = 0,
5330     VK_RESOLVE_MODE_SAMPLE_ZERO_BIT = 0x00000001,
5331     VK_RESOLVE_MODE_AVERAGE_BIT = 0x00000002,
5332     VK_RESOLVE_MODE_MIN_BIT = 0x00000004,
5333     VK_RESOLVE_MODE_MAX_BIT = 0x00000008,
5334     VK_RESOLVE_MODE_NONE_KHR = VK_RESOLVE_MODE_NONE,
5335     VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT,
5336     VK_RESOLVE_MODE_AVERAGE_BIT_KHR = VK_RESOLVE_MODE_AVERAGE_BIT,
5337     VK_RESOLVE_MODE_MIN_BIT_KHR = VK_RESOLVE_MODE_MIN_BIT,
5338     VK_RESOLVE_MODE_MAX_BIT_KHR = VK_RESOLVE_MODE_MAX_BIT,
5339     VK_RESOLVE_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
5340 } VkResolveModeFlagBits;
5341 typedef VkFlags VkResolveModeFlags;
5342
5343 typedef enum VkDescriptorBindingFlagBits {
5344     VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT = 0x00000001,
5345     VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT = 0x00000002,
5346     VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT = 0x00000004,
5347     VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT = 0x00000008,
5348     VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT = VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT,
5349     VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT = VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT,
5350     VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT = VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT,
5351     VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT = VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT,
5352     VK_DESCRIPTOR_BINDING_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
5353 } VkDescriptorBindingFlagBits;
5354 typedef VkFlags VkDescriptorBindingFlags;
5355
5356 typedef enum VkSemaphoreWaitFlagBits {
5357     VK_SEMAPHORE_WAIT_ANY_BIT = 0x00000001,
5358     VK_SEMAPHORE_WAIT_ANY_BIT_KHR = VK_SEMAPHORE_WAIT_ANY_BIT,
5359     VK_SEMAPHORE_WAIT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
5360 } VkSemaphoreWaitFlagBits;
5361 typedef VkFlags VkSemaphoreWaitFlags;
5362 typedef struct VkPhysicalDeviceVulkan11Features {
5363     VkStructureType    sType;
5364     void*              pNext;
5365     VkBool32           storageBuffer16BitAccess;
5366     VkBool32           uniformAndStorageBuffer16BitAccess;
5367     VkBool32           storagePushConstant16;
5368     VkBool32           storageInputOutput16;
5369     VkBool32           multiview;
5370     VkBool32           multiviewGeometryShader;
5371     VkBool32           multiviewTessellationShader;
5372     VkBool32           variablePointersStorageBuffer;
5373     VkBool32           variablePointers;
5374     VkBool32           protectedMemory;
5375     VkBool32           samplerYcbcrConversion;
5376     VkBool32           shaderDrawParameters;
5377 } VkPhysicalDeviceVulkan11Features;
5378
5379 typedef struct VkPhysicalDeviceVulkan11Properties {
5380     VkStructureType            sType;
5381     void*                      pNext;
5382     uint8_t                    deviceUUID[VK_UUID_SIZE];
5383     uint8_t                    driverUUID[VK_UUID_SIZE];
5384     uint8_t                    deviceLUID[VK_LUID_SIZE];
5385     uint32_t                   deviceNodeMask;
5386     VkBool32                   deviceLUIDValid;
5387     uint32_t                   subgroupSize;
5388     VkShaderStageFlags         subgroupSupportedStages;
5389     VkSubgroupFeatureFlags     subgroupSupportedOperations;
5390     VkBool32                   subgroupQuadOperationsInAllStages;
5391     VkPointClippingBehavior    pointClippingBehavior;
5392     uint32_t                   maxMultiviewViewCount;
5393     uint32_t                   maxMultiviewInstanceIndex;
5394     VkBool32                   protectedNoFault;
5395     uint32_t                   maxPerSetDescriptors;
5396     VkDeviceSize               maxMemoryAllocationSize;
5397 } VkPhysicalDeviceVulkan11Properties;
5398
5399 typedef struct VkPhysicalDeviceVulkan12Features {
5400     VkStructureType    sType;
5401     void*              pNext;
5402     VkBool32           samplerMirrorClampToEdge;
5403     VkBool32           drawIndirectCount;
5404     VkBool32           storageBuffer8BitAccess;
5405     VkBool32           uniformAndStorageBuffer8BitAccess;
5406     VkBool32           storagePushConstant8;
5407     VkBool32           shaderBufferInt64Atomics;
5408     VkBool32           shaderSharedInt64Atomics;
5409     VkBool32           shaderFloat16;
5410     VkBool32           shaderInt8;
5411     VkBool32           descriptorIndexing;
5412     VkBool32           shaderInputAttachmentArrayDynamicIndexing;
5413     VkBool32           shaderUniformTexelBufferArrayDynamicIndexing;
5414     VkBool32           shaderStorageTexelBufferArrayDynamicIndexing;
5415     VkBool32           shaderUniformBufferArrayNonUniformIndexing;
5416     VkBool32           shaderSampledImageArrayNonUniformIndexing;
5417     VkBool32           shaderStorageBufferArrayNonUniformIndexing;
5418     VkBool32           shaderStorageImageArrayNonUniformIndexing;
5419     VkBool32           shaderInputAttachmentArrayNonUniformIndexing;
5420     VkBool32           shaderUniformTexelBufferArrayNonUniformIndexing;
5421     VkBool32           shaderStorageTexelBufferArrayNonUniformIndexing;
5422     VkBool32           descriptorBindingUniformBufferUpdateAfterBind;
5423     VkBool32           descriptorBindingSampledImageUpdateAfterBind;
5424     VkBool32           descriptorBindingStorageImageUpdateAfterBind;
5425     VkBool32           descriptorBindingStorageBufferUpdateAfterBind;
5426     VkBool32           descriptorBindingUniformTexelBufferUpdateAfterBind;
5427     VkBool32           descriptorBindingStorageTexelBufferUpdateAfterBind;
5428     VkBool32           descriptorBindingUpdateUnusedWhilePending;
5429     VkBool32           descriptorBindingPartiallyBound;
5430     VkBool32           descriptorBindingVariableDescriptorCount;
5431     VkBool32           runtimeDescriptorArray;
5432     VkBool32           samplerFilterMinmax;
5433     VkBool32           scalarBlockLayout;
5434     VkBool32           imagelessFramebuffer;
5435     VkBool32           uniformBufferStandardLayout;
5436     VkBool32           shaderSubgroupExtendedTypes;
5437     VkBool32           separateDepthStencilLayouts;
5438     VkBool32           hostQueryReset;
5439     VkBool32           timelineSemaphore;
5440     VkBool32           bufferDeviceAddress;
5441     VkBool32           bufferDeviceAddressCaptureReplay;
5442     VkBool32           bufferDeviceAddressMultiDevice;
5443     VkBool32           vulkanMemoryModel;
5444     VkBool32           vulkanMemoryModelDeviceScope;
5445     VkBool32           vulkanMemoryModelAvailabilityVisibilityChains;
5446     VkBool32           shaderOutputViewportIndex;
5447     VkBool32           shaderOutputLayer;
5448     VkBool32           subgroupBroadcastDynamicId;
5449 } VkPhysicalDeviceVulkan12Features;
5450
5451 typedef struct VkConformanceVersion {
5452     uint8_t    major;
5453     uint8_t    minor;
5454     uint8_t    subminor;
5455     uint8_t    patch;
5456 } VkConformanceVersion;
5457
5458 typedef struct VkPhysicalDeviceVulkan12Properties {
5459     VkStructureType                      sType;
5460     void*                                pNext;
5461     VkDriverId                           driverID;
5462     char                                 driverName[VK_MAX_DRIVER_NAME_SIZE];
5463     char                                 driverInfo[VK_MAX_DRIVER_INFO_SIZE];
5464     VkConformanceVersion                 conformanceVersion;
5465     VkShaderFloatControlsIndependence    denormBehaviorIndependence;
5466     VkShaderFloatControlsIndependence    roundingModeIndependence;
5467     VkBool32                             shaderSignedZeroInfNanPreserveFloat16;
5468     VkBool32                             shaderSignedZeroInfNanPreserveFloat32;
5469     VkBool32                             shaderSignedZeroInfNanPreserveFloat64;
5470     VkBool32                             shaderDenormPreserveFloat16;
5471     VkBool32                             shaderDenormPreserveFloat32;
5472     VkBool32                             shaderDenormPreserveFloat64;
5473     VkBool32                             shaderDenormFlushToZeroFloat16;
5474     VkBool32                             shaderDenormFlushToZeroFloat32;
5475     VkBool32                             shaderDenormFlushToZeroFloat64;
5476     VkBool32                             shaderRoundingModeRTEFloat16;
5477     VkBool32                             shaderRoundingModeRTEFloat32;
5478     VkBool32                             shaderRoundingModeRTEFloat64;
5479     VkBool32                             shaderRoundingModeRTZFloat16;
5480     VkBool32                             shaderRoundingModeRTZFloat32;
5481     VkBool32                             shaderRoundingModeRTZFloat64;
5482     uint32_t                             maxUpdateAfterBindDescriptorsInAllPools;
5483     VkBool32                             shaderUniformBufferArrayNonUniformIndexingNative;
5484     VkBool32                             shaderSampledImageArrayNonUniformIndexingNative;
5485     VkBool32                             shaderStorageBufferArrayNonUniformIndexingNative;
5486     VkBool32                             shaderStorageImageArrayNonUniformIndexingNative;
5487     VkBool32                             shaderInputAttachmentArrayNonUniformIndexingNative;
5488     VkBool32                             robustBufferAccessUpdateAfterBind;
5489     VkBool32                             quadDivergentImplicitLod;
5490     uint32_t                             maxPerStageDescriptorUpdateAfterBindSamplers;
5491     uint32_t                             maxPerStageDescriptorUpdateAfterBindUniformBuffers;
5492     uint32_t                             maxPerStageDescriptorUpdateAfterBindStorageBuffers;
5493     uint32_t                             maxPerStageDescriptorUpdateAfterBindSampledImages;
5494     uint32_t                             maxPerStageDescriptorUpdateAfterBindStorageImages;
5495     uint32_t                             maxPerStageDescriptorUpdateAfterBindInputAttachments;
5496     uint32_t                             maxPerStageUpdateAfterBindResources;
5497     uint32_t                             maxDescriptorSetUpdateAfterBindSamplers;
5498     uint32_t                             maxDescriptorSetUpdateAfterBindUniformBuffers;
5499     uint32_t                             maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
5500     uint32_t                             maxDescriptorSetUpdateAfterBindStorageBuffers;
5501     uint32_t                             maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
5502     uint32_t                             maxDescriptorSetUpdateAfterBindSampledImages;
5503     uint32_t                             maxDescriptorSetUpdateAfterBindStorageImages;
5504     uint32_t                             maxDescriptorSetUpdateAfterBindInputAttachments;
5505     VkResolveModeFlags                   supportedDepthResolveModes;
5506     VkResolveModeFlags                   supportedStencilResolveModes;
5507     VkBool32                             independentResolveNone;
5508     VkBool32                             independentResolve;
5509     VkBool32                             filterMinmaxSingleComponentFormats;
5510     VkBool32                             filterMinmaxImageComponentMapping;
5511     uint64_t                             maxTimelineSemaphoreValueDifference;
5512     VkSampleCountFlags                   framebufferIntegerColorSampleCounts;
5513 } VkPhysicalDeviceVulkan12Properties;
5514
5515 typedef struct VkImageFormatListCreateInfo {
5516     VkStructureType    sType;
5517     const void*        pNext;
5518     uint32_t           viewFormatCount;
5519     const VkFormat*    pViewFormats;
5520 } VkImageFormatListCreateInfo;
5521
5522 typedef struct VkAttachmentDescription2 {
5523     VkStructureType                 sType;
5524     const void*                     pNext;
5525     VkAttachmentDescriptionFlags    flags;
5526     VkFormat                        format;
5527     VkSampleCountFlagBits           samples;
5528     VkAttachmentLoadOp              loadOp;
5529     VkAttachmentStoreOp             storeOp;
5530     VkAttachmentLoadOp              stencilLoadOp;
5531     VkAttachmentStoreOp             stencilStoreOp;
5532     VkImageLayout                   initialLayout;
5533     VkImageLayout                   finalLayout;
5534 } VkAttachmentDescription2;
5535
5536 typedef struct VkAttachmentReference2 {
5537     VkStructureType       sType;
5538     const void*           pNext;
5539     uint32_t              attachment;
5540     VkImageLayout         layout;
5541     VkImageAspectFlags    aspectMask;
5542 } VkAttachmentReference2;
5543
5544 typedef struct VkSubpassDescription2 {
5545     VkStructureType                  sType;
5546     const void*                      pNext;
5547     VkSubpassDescriptionFlags        flags;
5548     VkPipelineBindPoint              pipelineBindPoint;
5549     uint32_t                         viewMask;
5550     uint32_t                         inputAttachmentCount;
5551     const VkAttachmentReference2*    pInputAttachments;
5552     uint32_t                         colorAttachmentCount;
5553     const VkAttachmentReference2*    pColorAttachments;
5554     const VkAttachmentReference2*    pResolveAttachments;
5555     const VkAttachmentReference2*    pDepthStencilAttachment;
5556     uint32_t                         preserveAttachmentCount;
5557     const uint32_t*                  pPreserveAttachments;
5558 } VkSubpassDescription2;
5559
5560 typedef struct VkSubpassDependency2 {
5561     VkStructureType         sType;
5562     const void*             pNext;
5563     uint32_t                srcSubpass;
5564     uint32_t                dstSubpass;
5565     VkPipelineStageFlags    srcStageMask;
5566     VkPipelineStageFlags    dstStageMask;
5567     VkAccessFlags           srcAccessMask;
5568     VkAccessFlags           dstAccessMask;
5569     VkDependencyFlags       dependencyFlags;
5570     int32_t                 viewOffset;
5571 } VkSubpassDependency2;
5572
5573 typedef struct VkRenderPassCreateInfo2 {
5574     VkStructureType                    sType;
5575     const void*                        pNext;
5576     VkRenderPassCreateFlags            flags;
5577     uint32_t                           attachmentCount;
5578     const VkAttachmentDescription2*    pAttachments;
5579     uint32_t                           subpassCount;
5580     const VkSubpassDescription2*       pSubpasses;
5581     uint32_t                           dependencyCount;
5582     const VkSubpassDependency2*        pDependencies;
5583     uint32_t                           correlatedViewMaskCount;
5584     const uint32_t*                    pCorrelatedViewMasks;
5585 } VkRenderPassCreateInfo2;
5586
5587 typedef struct VkSubpassBeginInfo {
5588     VkStructureType      sType;
5589     const void*          pNext;
5590     VkSubpassContents    contents;
5591 } VkSubpassBeginInfo;
5592
5593 typedef struct VkSubpassEndInfo {
5594     VkStructureType    sType;
5595     const void*        pNext;
5596 } VkSubpassEndInfo;
5597
5598 typedef struct VkPhysicalDevice8BitStorageFeatures {
5599     VkStructureType    sType;
5600     void*              pNext;
5601     VkBool32           storageBuffer8BitAccess;
5602     VkBool32           uniformAndStorageBuffer8BitAccess;
5603     VkBool32           storagePushConstant8;
5604 } VkPhysicalDevice8BitStorageFeatures;
5605
5606 typedef struct VkPhysicalDeviceDriverProperties {
5607     VkStructureType         sType;
5608     void*                   pNext;
5609     VkDriverId              driverID;
5610     char                    driverName[VK_MAX_DRIVER_NAME_SIZE];
5611     char                    driverInfo[VK_MAX_DRIVER_INFO_SIZE];
5612     VkConformanceVersion    conformanceVersion;
5613 } VkPhysicalDeviceDriverProperties;
5614
5615 typedef struct VkPhysicalDeviceShaderAtomicInt64Features {
5616     VkStructureType    sType;
5617     void*              pNext;
5618     VkBool32           shaderBufferInt64Atomics;
5619     VkBool32           shaderSharedInt64Atomics;
5620 } VkPhysicalDeviceShaderAtomicInt64Features;
5621
5622 typedef struct VkPhysicalDeviceShaderFloat16Int8Features {
5623     VkStructureType    sType;
5624     void*              pNext;
5625     VkBool32           shaderFloat16;
5626     VkBool32           shaderInt8;
5627 } VkPhysicalDeviceShaderFloat16Int8Features;
5628
5629 typedef struct VkPhysicalDeviceFloatControlsProperties {
5630     VkStructureType                      sType;
5631     void*                                pNext;
5632     VkShaderFloatControlsIndependence    denormBehaviorIndependence;
5633     VkShaderFloatControlsIndependence    roundingModeIndependence;
5634     VkBool32                             shaderSignedZeroInfNanPreserveFloat16;
5635     VkBool32                             shaderSignedZeroInfNanPreserveFloat32;
5636     VkBool32                             shaderSignedZeroInfNanPreserveFloat64;
5637     VkBool32                             shaderDenormPreserveFloat16;
5638     VkBool32                             shaderDenormPreserveFloat32;
5639     VkBool32                             shaderDenormPreserveFloat64;
5640     VkBool32                             shaderDenormFlushToZeroFloat16;
5641     VkBool32                             shaderDenormFlushToZeroFloat32;
5642     VkBool32                             shaderDenormFlushToZeroFloat64;
5643     VkBool32                             shaderRoundingModeRTEFloat16;
5644     VkBool32                             shaderRoundingModeRTEFloat32;
5645     VkBool32                             shaderRoundingModeRTEFloat64;
5646     VkBool32                             shaderRoundingModeRTZFloat16;
5647     VkBool32                             shaderRoundingModeRTZFloat32;
5648     VkBool32                             shaderRoundingModeRTZFloat64;
5649 } VkPhysicalDeviceFloatControlsProperties;
5650
5651 typedef struct VkDescriptorSetLayoutBindingFlagsCreateInfo {
5652     VkStructureType                    sType;
5653     const void*                        pNext;
5654     uint32_t                           bindingCount;
5655     const VkDescriptorBindingFlags*    pBindingFlags;
5656 } VkDescriptorSetLayoutBindingFlagsCreateInfo;
5657
5658 typedef struct VkPhysicalDeviceDescriptorIndexingFeatures {
5659     VkStructureType    sType;
5660     void*              pNext;
5661     VkBool32           shaderInputAttachmentArrayDynamicIndexing;
5662     VkBool32           shaderUniformTexelBufferArrayDynamicIndexing;
5663     VkBool32           shaderStorageTexelBufferArrayDynamicIndexing;
5664     VkBool32           shaderUniformBufferArrayNonUniformIndexing;
5665     VkBool32           shaderSampledImageArrayNonUniformIndexing;
5666     VkBool32           shaderStorageBufferArrayNonUniformIndexing;
5667     VkBool32           shaderStorageImageArrayNonUniformIndexing;
5668     VkBool32           shaderInputAttachmentArrayNonUniformIndexing;
5669     VkBool32           shaderUniformTexelBufferArrayNonUniformIndexing;
5670     VkBool32           shaderStorageTexelBufferArrayNonUniformIndexing;
5671     VkBool32           descriptorBindingUniformBufferUpdateAfterBind;
5672     VkBool32           descriptorBindingSampledImageUpdateAfterBind;
5673     VkBool32           descriptorBindingStorageImageUpdateAfterBind;
5674     VkBool32           descriptorBindingStorageBufferUpdateAfterBind;
5675     VkBool32           descriptorBindingUniformTexelBufferUpdateAfterBind;
5676     VkBool32           descriptorBindingStorageTexelBufferUpdateAfterBind;
5677     VkBool32           descriptorBindingUpdateUnusedWhilePending;
5678     VkBool32           descriptorBindingPartiallyBound;
5679     VkBool32           descriptorBindingVariableDescriptorCount;
5680     VkBool32           runtimeDescriptorArray;
5681 } VkPhysicalDeviceDescriptorIndexingFeatures;
5682
5683 typedef struct VkPhysicalDeviceDescriptorIndexingProperties {
5684     VkStructureType    sType;
5685     void*              pNext;
5686     uint32_t           maxUpdateAfterBindDescriptorsInAllPools;
5687     VkBool32           shaderUniformBufferArrayNonUniformIndexingNative;
5688     VkBool32           shaderSampledImageArrayNonUniformIndexingNative;
5689     VkBool32           shaderStorageBufferArrayNonUniformIndexingNative;
5690     VkBool32           shaderStorageImageArrayNonUniformIndexingNative;
5691     VkBool32           shaderInputAttachmentArrayNonUniformIndexingNative;
5692     VkBool32           robustBufferAccessUpdateAfterBind;
5693     VkBool32           quadDivergentImplicitLod;
5694     uint32_t           maxPerStageDescriptorUpdateAfterBindSamplers;
5695     uint32_t           maxPerStageDescriptorUpdateAfterBindUniformBuffers;
5696     uint32_t           maxPerStageDescriptorUpdateAfterBindStorageBuffers;
5697     uint32_t           maxPerStageDescriptorUpdateAfterBindSampledImages;
5698     uint32_t           maxPerStageDescriptorUpdateAfterBindStorageImages;
5699     uint32_t           maxPerStageDescriptorUpdateAfterBindInputAttachments;
5700     uint32_t           maxPerStageUpdateAfterBindResources;
5701     uint32_t           maxDescriptorSetUpdateAfterBindSamplers;
5702     uint32_t           maxDescriptorSetUpdateAfterBindUniformBuffers;
5703     uint32_t           maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
5704     uint32_t           maxDescriptorSetUpdateAfterBindStorageBuffers;
5705     uint32_t           maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
5706     uint32_t           maxDescriptorSetUpdateAfterBindSampledImages;
5707     uint32_t           maxDescriptorSetUpdateAfterBindStorageImages;
5708     uint32_t           maxDescriptorSetUpdateAfterBindInputAttachments;
5709 } VkPhysicalDeviceDescriptorIndexingProperties;
5710
5711 typedef struct VkDescriptorSetVariableDescriptorCountAllocateInfo {
5712     VkStructureType    sType;
5713     const void*        pNext;
5714     uint32_t           descriptorSetCount;
5715     const uint32_t*    pDescriptorCounts;
5716 } VkDescriptorSetVariableDescriptorCountAllocateInfo;
5717
5718 typedef struct VkDescriptorSetVariableDescriptorCountLayoutSupport {
5719     VkStructureType    sType;
5720     void*              pNext;
5721     uint32_t           maxVariableDescriptorCount;
5722 } VkDescriptorSetVariableDescriptorCountLayoutSupport;
5723
5724 typedef struct VkSubpassDescriptionDepthStencilResolve {
5725     VkStructureType                  sType;
5726     const void*                      pNext;
5727     VkResolveModeFlagBits            depthResolveMode;
5728     VkResolveModeFlagBits            stencilResolveMode;
5729     const VkAttachmentReference2*    pDepthStencilResolveAttachment;
5730 } VkSubpassDescriptionDepthStencilResolve;
5731
5732 typedef struct VkPhysicalDeviceDepthStencilResolveProperties {
5733     VkStructureType       sType;
5734     void*                 pNext;
5735     VkResolveModeFlags    supportedDepthResolveModes;
5736     VkResolveModeFlags    supportedStencilResolveModes;
5737     VkBool32              independentResolveNone;
5738     VkBool32              independentResolve;
5739 } VkPhysicalDeviceDepthStencilResolveProperties;
5740
5741 typedef struct VkPhysicalDeviceScalarBlockLayoutFeatures {
5742     VkStructureType    sType;
5743     void*              pNext;
5744     VkBool32           scalarBlockLayout;
5745 } VkPhysicalDeviceScalarBlockLayoutFeatures;
5746
5747 typedef struct VkImageStencilUsageCreateInfo {
5748     VkStructureType      sType;
5749     const void*          pNext;
5750     VkImageUsageFlags    stencilUsage;
5751 } VkImageStencilUsageCreateInfo;
5752
5753 typedef struct VkSamplerReductionModeCreateInfo {
5754     VkStructureType           sType;
5755     const void*               pNext;
5756     VkSamplerReductionMode    reductionMode;
5757 } VkSamplerReductionModeCreateInfo;
5758
5759 typedef struct VkPhysicalDeviceSamplerFilterMinmaxProperties {
5760     VkStructureType    sType;
5761     void*              pNext;
5762     VkBool32           filterMinmaxSingleComponentFormats;
5763     VkBool32           filterMinmaxImageComponentMapping;
5764 } VkPhysicalDeviceSamplerFilterMinmaxProperties;
5765
5766 typedef struct VkPhysicalDeviceVulkanMemoryModelFeatures {
5767     VkStructureType    sType;
5768     void*              pNext;
5769     VkBool32           vulkanMemoryModel;
5770     VkBool32           vulkanMemoryModelDeviceScope;
5771     VkBool32           vulkanMemoryModelAvailabilityVisibilityChains;
5772 } VkPhysicalDeviceVulkanMemoryModelFeatures;
5773
5774 typedef struct VkPhysicalDeviceImagelessFramebufferFeatures {
5775     VkStructureType    sType;
5776     void*              pNext;
5777     VkBool32           imagelessFramebuffer;
5778 } VkPhysicalDeviceImagelessFramebufferFeatures;
5779
5780 typedef struct VkFramebufferAttachmentImageInfo {
5781     VkStructureType       sType;
5782     const void*           pNext;
5783     VkImageCreateFlags    flags;
5784     VkImageUsageFlags     usage;
5785     uint32_t              width;
5786     uint32_t              height;
5787     uint32_t              layerCount;
5788     uint32_t              viewFormatCount;
5789     const VkFormat*       pViewFormats;
5790 } VkFramebufferAttachmentImageInfo;
5791
5792 typedef struct VkFramebufferAttachmentsCreateInfo {
5793     VkStructureType                            sType;
5794     const void*                                pNext;
5795     uint32_t                                   attachmentImageInfoCount;
5796     const VkFramebufferAttachmentImageInfo*    pAttachmentImageInfos;
5797 } VkFramebufferAttachmentsCreateInfo;
5798
5799 typedef struct VkRenderPassAttachmentBeginInfo {
5800     VkStructureType       sType;
5801     const void*           pNext;
5802     uint32_t              attachmentCount;
5803     const VkImageView*    pAttachments;
5804 } VkRenderPassAttachmentBeginInfo;
5805
5806 typedef struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures {
5807     VkStructureType    sType;
5808     void*              pNext;
5809     VkBool32           uniformBufferStandardLayout;
5810 } VkPhysicalDeviceUniformBufferStandardLayoutFeatures;
5811
5812 typedef struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures {
5813     VkStructureType    sType;
5814     void*              pNext;
5815     VkBool32           shaderSubgroupExtendedTypes;
5816 } VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures;
5817
5818 typedef struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures {
5819     VkStructureType    sType;
5820     void*              pNext;
5821     VkBool32           separateDepthStencilLayouts;
5822 } VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures;
5823
5824 typedef struct VkAttachmentReferenceStencilLayout {
5825     VkStructureType    sType;
5826     void*              pNext;
5827     VkImageLayout      stencilLayout;
5828 } VkAttachmentReferenceStencilLayout;
5829
5830 typedef struct VkAttachmentDescriptionStencilLayout {
5831     VkStructureType    sType;
5832     void*              pNext;
5833     VkImageLayout      stencilInitialLayout;
5834     VkImageLayout      stencilFinalLayout;
5835 } VkAttachmentDescriptionStencilLayout;
5836
5837 typedef struct VkPhysicalDeviceHostQueryResetFeatures {
5838     VkStructureType    sType;
5839     void*              pNext;
5840     VkBool32           hostQueryReset;
5841 } VkPhysicalDeviceHostQueryResetFeatures;
5842
5843 typedef struct VkPhysicalDeviceTimelineSemaphoreFeatures {
5844     VkStructureType    sType;
5845     void*              pNext;
5846     VkBool32           timelineSemaphore;
5847 } VkPhysicalDeviceTimelineSemaphoreFeatures;
5848
5849 typedef struct VkPhysicalDeviceTimelineSemaphoreProperties {
5850     VkStructureType    sType;
5851     void*              pNext;
5852     uint64_t           maxTimelineSemaphoreValueDifference;
5853 } VkPhysicalDeviceTimelineSemaphoreProperties;
5854
5855 typedef struct VkSemaphoreTypeCreateInfo {
5856     VkStructureType    sType;
5857     const void*        pNext;
5858     VkSemaphoreType    semaphoreType;
5859     uint64_t           initialValue;
5860 } VkSemaphoreTypeCreateInfo;
5861
5862 typedef struct VkTimelineSemaphoreSubmitInfo {
5863     VkStructureType    sType;
5864     const void*        pNext;
5865     uint32_t           waitSemaphoreValueCount;
5866     const uint64_t*    pWaitSemaphoreValues;
5867     uint32_t           signalSemaphoreValueCount;
5868     const uint64_t*    pSignalSemaphoreValues;
5869 } VkTimelineSemaphoreSubmitInfo;
5870
5871 typedef struct VkSemaphoreWaitInfo {
5872     VkStructureType         sType;
5873     const void*             pNext;
5874     VkSemaphoreWaitFlags    flags;
5875     uint32_t                semaphoreCount;
5876     const VkSemaphore*      pSemaphores;
5877     const uint64_t*         pValues;
5878 } VkSemaphoreWaitInfo;
5879
5880 typedef struct VkSemaphoreSignalInfo {
5881     VkStructureType    sType;
5882     const void*        pNext;
5883     VkSemaphore        semaphore;
5884     uint64_t           value;
5885 } VkSemaphoreSignalInfo;
5886
5887 typedef struct VkPhysicalDeviceBufferDeviceAddressFeatures {
5888     VkStructureType    sType;
5889     void*              pNext;
5890     VkBool32           bufferDeviceAddress;
5891     VkBool32           bufferDeviceAddressCaptureReplay;
5892     VkBool32           bufferDeviceAddressMultiDevice;
5893 } VkPhysicalDeviceBufferDeviceAddressFeatures;
5894
5895 typedef struct VkBufferDeviceAddressInfo {
5896     VkStructureType    sType;
5897     const void*        pNext;
5898     VkBuffer           buffer;
5899 } VkBufferDeviceAddressInfo;
5900
5901 typedef struct VkBufferOpaqueCaptureAddressCreateInfo {
5902     VkStructureType    sType;
5903     const void*        pNext;
5904     uint64_t           opaqueCaptureAddress;
5905 } VkBufferOpaqueCaptureAddressCreateInfo;
5906
5907 typedef struct VkMemoryOpaqueCaptureAddressAllocateInfo {
5908     VkStructureType    sType;
5909     const void*        pNext;
5910     uint64_t           opaqueCaptureAddress;
5911 } VkMemoryOpaqueCaptureAddressAllocateInfo;
5912
5913 typedef struct VkDeviceMemoryOpaqueCaptureAddressInfo {
5914     VkStructureType    sType;
5915     const void*        pNext;
5916     VkDeviceMemory     memory;
5917 } VkDeviceMemoryOpaqueCaptureAddressInfo;
5918
5919 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCount)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
5920 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCount)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
5921 typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass2)(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);
5922 typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass2)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo*      pRenderPassBegin, const VkSubpassBeginInfo*      pSubpassBeginInfo);
5923 typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass2)(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo*      pSubpassBeginInfo, const VkSubpassEndInfo*        pSubpassEndInfo);
5924 typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass2)(VkCommandBuffer commandBuffer, const VkSubpassEndInfo*        pSubpassEndInfo);
5925 typedef void (VKAPI_PTR *PFN_vkResetQueryPool)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);
5926 typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreCounterValue)(VkDevice device, VkSemaphore semaphore, uint64_t* pValue);
5927 typedef VkResult (VKAPI_PTR *PFN_vkWaitSemaphores)(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout);
5928 typedef VkResult (VKAPI_PTR *PFN_vkSignalSemaphore)(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo);
5929 typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddress)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo);
5930 typedef uint64_t (VKAPI_PTR *PFN_vkGetBufferOpaqueCaptureAddress)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo);
5931 typedef uint64_t (VKAPI_PTR *PFN_vkGetDeviceMemoryOpaqueCaptureAddress)(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo);
5932
5933 #ifndef VK_NO_PROTOTYPES
5934 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCount(
5935     VkCommandBuffer                             commandBuffer,
5936     VkBuffer                                    buffer,
5937     VkDeviceSize                                offset,
5938     VkBuffer                                    countBuffer,
5939     VkDeviceSize                                countBufferOffset,
5940     uint32_t                                    maxDrawCount,
5941     uint32_t                                    stride);
5942
5943 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCount(
5944     VkCommandBuffer                             commandBuffer,
5945     VkBuffer                                    buffer,
5946     VkDeviceSize                                offset,
5947     VkBuffer                                    countBuffer,
5948     VkDeviceSize                                countBufferOffset,
5949     uint32_t                                    maxDrawCount,
5950     uint32_t                                    stride);
5951
5952 VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass2(
5953     VkDevice                                    device,
5954     const VkRenderPassCreateInfo2*              pCreateInfo,
5955     const VkAllocationCallbacks*                pAllocator,
5956     VkRenderPass*                               pRenderPass);
5957
5958 VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass2(
5959     VkCommandBuffer                             commandBuffer,
5960     const VkRenderPassBeginInfo*                pRenderPassBegin,
5961     const VkSubpassBeginInfo*                   pSubpassBeginInfo);
5962
5963 VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass2(
5964     VkCommandBuffer                             commandBuffer,
5965     const VkSubpassBeginInfo*                   pSubpassBeginInfo,
5966     const VkSubpassEndInfo*                     pSubpassEndInfo);
5967
5968 VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass2(
5969     VkCommandBuffer                             commandBuffer,
5970     const VkSubpassEndInfo*                     pSubpassEndInfo);
5971
5972 VKAPI_ATTR void VKAPI_CALL vkResetQueryPool(
5973     VkDevice                                    device,
5974     VkQueryPool                                 queryPool,
5975     uint32_t                                    firstQuery,
5976     uint32_t                                    queryCount);
5977
5978 VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreCounterValue(
5979     VkDevice                                    device,
5980     VkSemaphore                                 semaphore,
5981     uint64_t*                                   pValue);
5982
5983 VKAPI_ATTR VkResult VKAPI_CALL vkWaitSemaphores(
5984     VkDevice                                    device,
5985     const VkSemaphoreWaitInfo*                  pWaitInfo,
5986     uint64_t                                    timeout);
5987
5988 VKAPI_ATTR VkResult VKAPI_CALL vkSignalSemaphore(
5989     VkDevice                                    device,
5990     const VkSemaphoreSignalInfo*                pSignalInfo);
5991
5992 VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddress(
5993     VkDevice                                    device,
5994     const VkBufferDeviceAddressInfo*            pInfo);
5995
5996 VKAPI_ATTR uint64_t VKAPI_CALL vkGetBufferOpaqueCaptureAddress(
5997     VkDevice                                    device,
5998     const VkBufferDeviceAddressInfo*            pInfo);
5999
6000 VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceMemoryOpaqueCaptureAddress(
6001     VkDevice                                    device,
6002     const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo);
6003 #endif
6004
6005
6006 #define VK_KHR_surface 1
6007 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR)
6008 #define VK_KHR_SURFACE_SPEC_VERSION       25
6009 #define VK_KHR_SURFACE_EXTENSION_NAME     "VK_KHR_surface"
6010
6011 typedef enum VkPresentModeKHR {
6012     VK_PRESENT_MODE_IMMEDIATE_KHR = 0,
6013     VK_PRESENT_MODE_MAILBOX_KHR = 1,
6014     VK_PRESENT_MODE_FIFO_KHR = 2,
6015     VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3,
6016     VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR = 1000111000,
6017     VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR = 1000111001,
6018     VK_PRESENT_MODE_MAX_ENUM_KHR = 0x7FFFFFFF
6019 } VkPresentModeKHR;
6020
6021 typedef enum VkColorSpaceKHR {
6022     VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0,
6023     VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT = 1000104001,
6024     VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT = 1000104002,
6025     VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT = 1000104003,
6026     VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT = 1000104004,
6027     VK_COLOR_SPACE_BT709_LINEAR_EXT = 1000104005,
6028     VK_COLOR_SPACE_BT709_NONLINEAR_EXT = 1000104006,
6029     VK_COLOR_SPACE_BT2020_LINEAR_EXT = 1000104007,
6030     VK_COLOR_SPACE_HDR10_ST2084_EXT = 1000104008,
6031     VK_COLOR_SPACE_DOLBYVISION_EXT = 1000104009,
6032     VK_COLOR_SPACE_HDR10_HLG_EXT = 1000104010,
6033     VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT = 1000104011,
6034     VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT = 1000104012,
6035     VK_COLOR_SPACE_PASS_THROUGH_EXT = 1000104013,
6036     VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT = 1000104014,
6037     VK_COLOR_SPACE_DISPLAY_NATIVE_AMD = 1000213000,
6038     VK_COLORSPACE_SRGB_NONLINEAR_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
6039     VK_COLOR_SPACE_DCI_P3_LINEAR_EXT = VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT,
6040     VK_COLOR_SPACE_MAX_ENUM_KHR = 0x7FFFFFFF
6041 } VkColorSpaceKHR;
6042
6043 typedef enum VkSurfaceTransformFlagBitsKHR {
6044     VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 0x00000001,
6045     VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 0x00000002,
6046     VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 0x00000004,
6047     VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 0x00000008,
6048     VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 0x00000010,
6049     VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 0x00000020,
6050     VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 0x00000040,
6051     VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 0x00000080,
6052     VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100,
6053     VK_SURFACE_TRANSFORM_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
6054 } VkSurfaceTransformFlagBitsKHR;
6055
6056 typedef enum VkCompositeAlphaFlagBitsKHR {
6057     VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001,
6058     VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002,
6059     VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004,
6060     VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008,
6061     VK_COMPOSITE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
6062 } VkCompositeAlphaFlagBitsKHR;
6063 typedef VkFlags VkCompositeAlphaFlagsKHR;
6064 typedef VkFlags VkSurfaceTransformFlagsKHR;
6065 typedef struct VkSurfaceCapabilitiesKHR {
6066     uint32_t                         minImageCount;
6067     uint32_t                         maxImageCount;
6068     VkExtent2D                       currentExtent;
6069     VkExtent2D                       minImageExtent;
6070     VkExtent2D                       maxImageExtent;
6071     uint32_t                         maxImageArrayLayers;
6072     VkSurfaceTransformFlagsKHR       supportedTransforms;
6073     VkSurfaceTransformFlagBitsKHR    currentTransform;
6074     VkCompositeAlphaFlagsKHR         supportedCompositeAlpha;
6075     VkImageUsageFlags                supportedUsageFlags;
6076 } VkSurfaceCapabilitiesKHR;
6077
6078 typedef struct VkSurfaceFormatKHR {
6079     VkFormat           format;
6080     VkColorSpaceKHR    colorSpace;
6081 } VkSurfaceFormatKHR;
6082
6083 typedef void (VKAPI_PTR *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator);
6084 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported);
6085 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);
6086 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats);
6087 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes);
6088
6089 #ifndef VK_NO_PROTOTYPES
6090 VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR(
6091     VkInstance                                  instance,
6092     VkSurfaceKHR                                surface,
6093     const VkAllocationCallbacks*                pAllocator);
6094
6095 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR(
6096     VkPhysicalDevice                            physicalDevice,
6097     uint32_t                                    queueFamilyIndex,
6098     VkSurfaceKHR                                surface,
6099     VkBool32*                                   pSupported);
6100
6101 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
6102     VkPhysicalDevice                            physicalDevice,
6103     VkSurfaceKHR                                surface,
6104     VkSurfaceCapabilitiesKHR*                   pSurfaceCapabilities);
6105
6106 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR(
6107     VkPhysicalDevice                            physicalDevice,
6108     VkSurfaceKHR                                surface,
6109     uint32_t*                                   pSurfaceFormatCount,
6110     VkSurfaceFormatKHR*                         pSurfaceFormats);
6111
6112 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR(
6113     VkPhysicalDevice                            physicalDevice,
6114     VkSurfaceKHR                                surface,
6115     uint32_t*                                   pPresentModeCount,
6116     VkPresentModeKHR*                           pPresentModes);
6117 #endif
6118
6119
6120 #define VK_KHR_swapchain 1
6121 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR)
6122 #define VK_KHR_SWAPCHAIN_SPEC_VERSION     70
6123 #define VK_KHR_SWAPCHAIN_EXTENSION_NAME   "VK_KHR_swapchain"
6124
6125 typedef enum VkSwapchainCreateFlagBitsKHR {
6126     VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = 0x00000001,
6127     VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR = 0x00000002,
6128     VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR = 0x00000004,
6129     VK_SWAPCHAIN_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
6130 } VkSwapchainCreateFlagBitsKHR;
6131 typedef VkFlags VkSwapchainCreateFlagsKHR;
6132
6133 typedef enum VkDeviceGroupPresentModeFlagBitsKHR {
6134     VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR = 0x00000001,
6135     VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR = 0x00000002,
6136     VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR = 0x00000004,
6137     VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR = 0x00000008,
6138     VK_DEVICE_GROUP_PRESENT_MODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
6139 } VkDeviceGroupPresentModeFlagBitsKHR;
6140 typedef VkFlags VkDeviceGroupPresentModeFlagsKHR;
6141 typedef struct VkSwapchainCreateInfoKHR {
6142     VkStructureType                  sType;
6143     const void*                      pNext;
6144     VkSwapchainCreateFlagsKHR        flags;
6145     VkSurfaceKHR                     surface;
6146     uint32_t                         minImageCount;
6147     VkFormat                         imageFormat;
6148     VkColorSpaceKHR                  imageColorSpace;
6149     VkExtent2D                       imageExtent;
6150     uint32_t                         imageArrayLayers;
6151     VkImageUsageFlags                imageUsage;
6152     VkSharingMode                    imageSharingMode;
6153     uint32_t                         queueFamilyIndexCount;
6154     const uint32_t*                  pQueueFamilyIndices;
6155     VkSurfaceTransformFlagBitsKHR    preTransform;
6156     VkCompositeAlphaFlagBitsKHR      compositeAlpha;
6157     VkPresentModeKHR                 presentMode;
6158     VkBool32                         clipped;
6159     VkSwapchainKHR                   oldSwapchain;
6160 } VkSwapchainCreateInfoKHR;
6161
6162 typedef struct VkPresentInfoKHR {
6163     VkStructureType          sType;
6164     const void*              pNext;
6165     uint32_t                 waitSemaphoreCount;
6166     const VkSemaphore*       pWaitSemaphores;
6167     uint32_t                 swapchainCount;
6168     const VkSwapchainKHR*    pSwapchains;
6169     const uint32_t*          pImageIndices;
6170     VkResult*                pResults;
6171 } VkPresentInfoKHR;
6172
6173 typedef struct VkImageSwapchainCreateInfoKHR {
6174     VkStructureType    sType;
6175     const void*        pNext;
6176     VkSwapchainKHR     swapchain;
6177 } VkImageSwapchainCreateInfoKHR;
6178
6179 typedef struct VkBindImageMemorySwapchainInfoKHR {
6180     VkStructureType    sType;
6181     const void*        pNext;
6182     VkSwapchainKHR     swapchain;
6183     uint32_t           imageIndex;
6184 } VkBindImageMemorySwapchainInfoKHR;
6185
6186 typedef struct VkAcquireNextImageInfoKHR {
6187     VkStructureType    sType;
6188     const void*        pNext;
6189     VkSwapchainKHR     swapchain;
6190     uint64_t           timeout;
6191     VkSemaphore        semaphore;
6192     VkFence            fence;
6193     uint32_t           deviceMask;
6194 } VkAcquireNextImageInfoKHR;
6195
6196 typedef struct VkDeviceGroupPresentCapabilitiesKHR {
6197     VkStructureType                     sType;
6198     void*                               pNext;
6199     uint32_t                            presentMask[VK_MAX_DEVICE_GROUP_SIZE];
6200     VkDeviceGroupPresentModeFlagsKHR    modes;
6201 } VkDeviceGroupPresentCapabilitiesKHR;
6202
6203 typedef struct VkDeviceGroupPresentInfoKHR {
6204     VkStructureType                        sType;
6205     const void*                            pNext;
6206     uint32_t                               swapchainCount;
6207     const uint32_t*                        pDeviceMasks;
6208     VkDeviceGroupPresentModeFlagBitsKHR    mode;
6209 } VkDeviceGroupPresentInfoKHR;
6210
6211 typedef struct VkDeviceGroupSwapchainCreateInfoKHR {
6212     VkStructureType                     sType;
6213     const void*                         pNext;
6214     VkDeviceGroupPresentModeFlagsKHR    modes;
6215 } VkDeviceGroupSwapchainCreateInfoKHR;
6216
6217 typedef VkResult (VKAPI_PTR *PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain);
6218 typedef void (VKAPI_PTR *PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator);
6219 typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages);
6220 typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex);
6221 typedef VkResult (VKAPI_PTR *PFN_vkQueuePresentKHR)(VkQueue queue, const VkPresentInfoKHR* pPresentInfo);
6222 typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupPresentCapabilitiesKHR)(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities);
6223 typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupSurfacePresentModesKHR)(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes);
6224 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDevicePresentRectanglesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects);
6225 typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImage2KHR)(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex);
6226
6227 #ifndef VK_NO_PROTOTYPES
6228 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR(
6229     VkDevice                                    device,
6230     const VkSwapchainCreateInfoKHR*             pCreateInfo,
6231     const VkAllocationCallbacks*                pAllocator,
6232     VkSwapchainKHR*                             pSwapchain);
6233
6234 VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR(
6235     VkDevice                                    device,
6236     VkSwapchainKHR                              swapchain,
6237     const VkAllocationCallbacks*                pAllocator);
6238
6239 VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR(
6240     VkDevice                                    device,
6241     VkSwapchainKHR                              swapchain,
6242     uint32_t*                                   pSwapchainImageCount,
6243     VkImage*                                    pSwapchainImages);
6244
6245 VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(
6246     VkDevice                                    device,
6247     VkSwapchainKHR                              swapchain,
6248     uint64_t                                    timeout,
6249     VkSemaphore                                 semaphore,
6250     VkFence                                     fence,
6251     uint32_t*                                   pImageIndex);
6252
6253 VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(
6254     VkQueue                                     queue,
6255     const VkPresentInfoKHR*                     pPresentInfo);
6256
6257 VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupPresentCapabilitiesKHR(
6258     VkDevice                                    device,
6259     VkDeviceGroupPresentCapabilitiesKHR*        pDeviceGroupPresentCapabilities);
6260
6261 VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModesKHR(
6262     VkDevice                                    device,
6263     VkSurfaceKHR                                surface,
6264     VkDeviceGroupPresentModeFlagsKHR*           pModes);
6265
6266 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDevicePresentRectanglesKHR(
6267     VkPhysicalDevice                            physicalDevice,
6268     VkSurfaceKHR                                surface,
6269     uint32_t*                                   pRectCount,
6270     VkRect2D*                                   pRects);
6271
6272 VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImage2KHR(
6273     VkDevice                                    device,
6274     const VkAcquireNextImageInfoKHR*            pAcquireInfo,
6275     uint32_t*                                   pImageIndex);
6276 #endif
6277
6278
6279 #define VK_KHR_display 1
6280 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR)
6281 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR)
6282 #define VK_KHR_DISPLAY_SPEC_VERSION       23
6283 #define VK_KHR_DISPLAY_EXTENSION_NAME     "VK_KHR_display"
6284 typedef VkFlags VkDisplayModeCreateFlagsKHR;
6285
6286 typedef enum VkDisplayPlaneAlphaFlagBitsKHR {
6287     VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0x00000001,
6288     VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000002,
6289     VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000004,
6290     VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000008,
6291     VK_DISPLAY_PLANE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
6292 } VkDisplayPlaneAlphaFlagBitsKHR;
6293 typedef VkFlags VkDisplayPlaneAlphaFlagsKHR;
6294 typedef VkFlags VkDisplaySurfaceCreateFlagsKHR;
6295 typedef struct VkDisplayModeParametersKHR {
6296     VkExtent2D    visibleRegion;
6297     uint32_t      refreshRate;
6298 } VkDisplayModeParametersKHR;
6299
6300 typedef struct VkDisplayModeCreateInfoKHR {
6301     VkStructureType                sType;
6302     const void*                    pNext;
6303     VkDisplayModeCreateFlagsKHR    flags;
6304     VkDisplayModeParametersKHR     parameters;
6305 } VkDisplayModeCreateInfoKHR;
6306
6307 typedef struct VkDisplayModePropertiesKHR {
6308     VkDisplayModeKHR              displayMode;
6309     VkDisplayModeParametersKHR    parameters;
6310 } VkDisplayModePropertiesKHR;
6311
6312 typedef struct VkDisplayPlaneCapabilitiesKHR {
6313     VkDisplayPlaneAlphaFlagsKHR    supportedAlpha;
6314     VkOffset2D                     minSrcPosition;
6315     VkOffset2D                     maxSrcPosition;
6316     VkExtent2D                     minSrcExtent;
6317     VkExtent2D                     maxSrcExtent;
6318     VkOffset2D                     minDstPosition;
6319     VkOffset2D                     maxDstPosition;
6320     VkExtent2D                     minDstExtent;
6321     VkExtent2D                     maxDstExtent;
6322 } VkDisplayPlaneCapabilitiesKHR;
6323
6324 typedef struct VkDisplayPlanePropertiesKHR {
6325     VkDisplayKHR    currentDisplay;
6326     uint32_t        currentStackIndex;
6327 } VkDisplayPlanePropertiesKHR;
6328
6329 typedef struct VkDisplayPropertiesKHR {
6330     VkDisplayKHR                  display;
6331     const char*                   displayName;
6332     VkExtent2D                    physicalDimensions;
6333     VkExtent2D                    physicalResolution;
6334     VkSurfaceTransformFlagsKHR    supportedTransforms;
6335     VkBool32                      planeReorderPossible;
6336     VkBool32                      persistentContent;
6337 } VkDisplayPropertiesKHR;
6338
6339 typedef struct VkDisplaySurfaceCreateInfoKHR {
6340     VkStructureType                   sType;
6341     const void*                       pNext;
6342     VkDisplaySurfaceCreateFlagsKHR    flags;
6343     VkDisplayModeKHR                  displayMode;
6344     uint32_t                          planeIndex;
6345     uint32_t                          planeStackIndex;
6346     VkSurfaceTransformFlagBitsKHR     transform;
6347     float                             globalAlpha;
6348     VkDisplayPlaneAlphaFlagBitsKHR    alphaMode;
6349     VkExtent2D                        imageExtent;
6350 } VkDisplaySurfaceCreateInfoKHR;
6351
6352 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties);
6353 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties);
6354 typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays);
6355 typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties);
6356 typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode);
6357 typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities);
6358 typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
6359
6360 #ifndef VK_NO_PROTOTYPES
6361 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR(
6362     VkPhysicalDevice                            physicalDevice,
6363     uint32_t*                                   pPropertyCount,
6364     VkDisplayPropertiesKHR*                     pProperties);
6365
6366 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
6367     VkPhysicalDevice                            physicalDevice,
6368     uint32_t*                                   pPropertyCount,
6369     VkDisplayPlanePropertiesKHR*                pProperties);
6370
6371 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR(
6372     VkPhysicalDevice                            physicalDevice,
6373     uint32_t                                    planeIndex,
6374     uint32_t*                                   pDisplayCount,
6375     VkDisplayKHR*                               pDisplays);
6376
6377 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR(
6378     VkPhysicalDevice                            physicalDevice,
6379     VkDisplayKHR                                display,
6380     uint32_t*                                   pPropertyCount,
6381     VkDisplayModePropertiesKHR*                 pProperties);
6382
6383 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR(
6384     VkPhysicalDevice                            physicalDevice,
6385     VkDisplayKHR                                display,
6386     const VkDisplayModeCreateInfoKHR*           pCreateInfo,
6387     const VkAllocationCallbacks*                pAllocator,
6388     VkDisplayModeKHR*                           pMode);
6389
6390 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR(
6391     VkPhysicalDevice                            physicalDevice,
6392     VkDisplayModeKHR                            mode,
6393     uint32_t                                    planeIndex,
6394     VkDisplayPlaneCapabilitiesKHR*              pCapabilities);
6395
6396 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR(
6397     VkInstance                                  instance,
6398     const VkDisplaySurfaceCreateInfoKHR*        pCreateInfo,
6399     const VkAllocationCallbacks*                pAllocator,
6400     VkSurfaceKHR*                               pSurface);
6401 #endif
6402
6403
6404 #define VK_KHR_display_swapchain 1
6405 #define VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION 10
6406 #define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain"
6407 typedef struct VkDisplayPresentInfoKHR {
6408     VkStructureType    sType;
6409     const void*        pNext;
6410     VkRect2D           srcRect;
6411     VkRect2D           dstRect;
6412     VkBool32           persistent;
6413 } VkDisplayPresentInfoKHR;
6414
6415 typedef VkResult (VKAPI_PTR *PFN_vkCreateSharedSwapchainsKHR)(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains);
6416
6417 #ifndef VK_NO_PROTOTYPES
6418 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR(
6419     VkDevice                                    device,
6420     uint32_t                                    swapchainCount,
6421     const VkSwapchainCreateInfoKHR*             pCreateInfos,
6422     const VkAllocationCallbacks*                pAllocator,
6423     VkSwapchainKHR*                             pSwapchains);
6424 #endif
6425
6426
6427 #define VK_KHR_sampler_mirror_clamp_to_edge 1
6428 #define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION 3
6429 #define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME "VK_KHR_sampler_mirror_clamp_to_edge"
6430
6431
6432 #define VK_KHR_multiview 1
6433 #define VK_KHR_MULTIVIEW_SPEC_VERSION     1
6434 #define VK_KHR_MULTIVIEW_EXTENSION_NAME   "VK_KHR_multiview"
6435 typedef VkRenderPassMultiviewCreateInfo VkRenderPassMultiviewCreateInfoKHR;
6436
6437 typedef VkPhysicalDeviceMultiviewFeatures VkPhysicalDeviceMultiviewFeaturesKHR;
6438
6439 typedef VkPhysicalDeviceMultiviewProperties VkPhysicalDeviceMultiviewPropertiesKHR;
6440
6441
6442
6443 #define VK_KHR_get_physical_device_properties2 1
6444 #define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION 2
6445 #define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_physical_device_properties2"
6446 typedef VkPhysicalDeviceFeatures2 VkPhysicalDeviceFeatures2KHR;
6447
6448 typedef VkPhysicalDeviceProperties2 VkPhysicalDeviceProperties2KHR;
6449
6450 typedef VkFormatProperties2 VkFormatProperties2KHR;
6451
6452 typedef VkImageFormatProperties2 VkImageFormatProperties2KHR;
6453
6454 typedef VkPhysicalDeviceImageFormatInfo2 VkPhysicalDeviceImageFormatInfo2KHR;
6455
6456 typedef VkQueueFamilyProperties2 VkQueueFamilyProperties2KHR;
6457
6458 typedef VkPhysicalDeviceMemoryProperties2 VkPhysicalDeviceMemoryProperties2KHR;
6459
6460 typedef VkSparseImageFormatProperties2 VkSparseImageFormatProperties2KHR;
6461
6462 typedef VkPhysicalDeviceSparseImageFormatInfo2 VkPhysicalDeviceSparseImageFormatInfo2KHR;
6463
6464 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures);
6465 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties);
6466 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2KHR)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties);
6467 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties);
6468 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties);
6469 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties);
6470 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties);
6471
6472 #ifndef VK_NO_PROTOTYPES
6473 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2KHR(
6474     VkPhysicalDevice                            physicalDevice,
6475     VkPhysicalDeviceFeatures2*                  pFeatures);
6476
6477 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2KHR(
6478     VkPhysicalDevice                            physicalDevice,
6479     VkPhysicalDeviceProperties2*                pProperties);
6480
6481 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2KHR(
6482     VkPhysicalDevice                            physicalDevice,
6483     VkFormat                                    format,
6484     VkFormatProperties2*                        pFormatProperties);
6485
6486 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2KHR(
6487     VkPhysicalDevice                            physicalDevice,
6488     const VkPhysicalDeviceImageFormatInfo2*     pImageFormatInfo,
6489     VkImageFormatProperties2*                   pImageFormatProperties);
6490
6491 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2KHR(
6492     VkPhysicalDevice                            physicalDevice,
6493     uint32_t*                                   pQueueFamilyPropertyCount,
6494     VkQueueFamilyProperties2*                   pQueueFamilyProperties);
6495
6496 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2KHR(
6497     VkPhysicalDevice                            physicalDevice,
6498     VkPhysicalDeviceMemoryProperties2*          pMemoryProperties);
6499
6500 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
6501     VkPhysicalDevice                            physicalDevice,
6502     const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
6503     uint32_t*                                   pPropertyCount,
6504     VkSparseImageFormatProperties2*             pProperties);
6505 #endif
6506
6507
6508 #define VK_KHR_device_group 1
6509 #define VK_KHR_DEVICE_GROUP_SPEC_VERSION  4
6510 #define VK_KHR_DEVICE_GROUP_EXTENSION_NAME "VK_KHR_device_group"
6511 typedef VkPeerMemoryFeatureFlags VkPeerMemoryFeatureFlagsKHR;
6512
6513 typedef VkPeerMemoryFeatureFlagBits VkPeerMemoryFeatureFlagBitsKHR;
6514
6515 typedef VkMemoryAllocateFlags VkMemoryAllocateFlagsKHR;
6516
6517 typedef VkMemoryAllocateFlagBits VkMemoryAllocateFlagBitsKHR;
6518
6519 typedef VkMemoryAllocateFlagsInfo VkMemoryAllocateFlagsInfoKHR;
6520
6521 typedef VkDeviceGroupRenderPassBeginInfo VkDeviceGroupRenderPassBeginInfoKHR;
6522
6523 typedef VkDeviceGroupCommandBufferBeginInfo VkDeviceGroupCommandBufferBeginInfoKHR;
6524
6525 typedef VkDeviceGroupSubmitInfo VkDeviceGroupSubmitInfoKHR;
6526
6527 typedef VkDeviceGroupBindSparseInfo VkDeviceGroupBindSparseInfoKHR;
6528
6529 typedef VkBindBufferMemoryDeviceGroupInfo VkBindBufferMemoryDeviceGroupInfoKHR;
6530
6531 typedef VkBindImageMemoryDeviceGroupInfo VkBindImageMemoryDeviceGroupInfoKHR;
6532
6533 typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);
6534 typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMaskKHR)(VkCommandBuffer commandBuffer, uint32_t deviceMask);
6535 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);
6536
6537 #ifndef VK_NO_PROTOTYPES
6538 VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeaturesKHR(
6539     VkDevice                                    device,
6540     uint32_t                                    heapIndex,
6541     uint32_t                                    localDeviceIndex,
6542     uint32_t                                    remoteDeviceIndex,
6543     VkPeerMemoryFeatureFlags*                   pPeerMemoryFeatures);
6544
6545 VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMaskKHR(
6546     VkCommandBuffer                             commandBuffer,
6547     uint32_t                                    deviceMask);
6548
6549 VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBaseKHR(
6550     VkCommandBuffer                             commandBuffer,
6551     uint32_t                                    baseGroupX,
6552     uint32_t                                    baseGroupY,
6553     uint32_t                                    baseGroupZ,
6554     uint32_t                                    groupCountX,
6555     uint32_t                                    groupCountY,
6556     uint32_t                                    groupCountZ);
6557 #endif
6558
6559
6560 #define VK_KHR_shader_draw_parameters 1
6561 #define VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION 1
6562 #define VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME "VK_KHR_shader_draw_parameters"
6563
6564
6565 #define VK_KHR_maintenance1 1
6566 #define VK_KHR_MAINTENANCE1_SPEC_VERSION  2
6567 #define VK_KHR_MAINTENANCE1_EXTENSION_NAME "VK_KHR_maintenance1"
6568 typedef VkCommandPoolTrimFlags VkCommandPoolTrimFlagsKHR;
6569
6570 typedef void (VKAPI_PTR *PFN_vkTrimCommandPoolKHR)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags);
6571
6572 #ifndef VK_NO_PROTOTYPES
6573 VKAPI_ATTR void VKAPI_CALL vkTrimCommandPoolKHR(
6574     VkDevice                                    device,
6575     VkCommandPool                               commandPool,
6576     VkCommandPoolTrimFlags                      flags);
6577 #endif
6578
6579
6580 #define VK_KHR_device_group_creation 1
6581 #define VK_KHR_DEVICE_GROUP_CREATION_SPEC_VERSION 1
6582 #define VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME "VK_KHR_device_group_creation"
6583 #define VK_MAX_DEVICE_GROUP_SIZE_KHR      VK_MAX_DEVICE_GROUP_SIZE
6584 typedef VkPhysicalDeviceGroupProperties VkPhysicalDeviceGroupPropertiesKHR;
6585
6586 typedef VkDeviceGroupDeviceCreateInfo VkDeviceGroupDeviceCreateInfoKHR;
6587
6588 typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroupsKHR)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);
6589
6590 #ifndef VK_NO_PROTOTYPES
6591 VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroupsKHR(
6592     VkInstance                                  instance,
6593     uint32_t*                                   pPhysicalDeviceGroupCount,
6594     VkPhysicalDeviceGroupProperties*            pPhysicalDeviceGroupProperties);
6595 #endif
6596
6597
6598 #define VK_KHR_external_memory_capabilities 1
6599 #define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1
6600 #define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_memory_capabilities"
6601 #define VK_LUID_SIZE_KHR                  VK_LUID_SIZE
6602 typedef VkExternalMemoryHandleTypeFlags VkExternalMemoryHandleTypeFlagsKHR;
6603
6604 typedef VkExternalMemoryHandleTypeFlagBits VkExternalMemoryHandleTypeFlagBitsKHR;
6605
6606 typedef VkExternalMemoryFeatureFlags VkExternalMemoryFeatureFlagsKHR;
6607
6608 typedef VkExternalMemoryFeatureFlagBits VkExternalMemoryFeatureFlagBitsKHR;
6609
6610 typedef VkExternalMemoryProperties VkExternalMemoryPropertiesKHR;
6611
6612 typedef VkPhysicalDeviceExternalImageFormatInfo VkPhysicalDeviceExternalImageFormatInfoKHR;
6613
6614 typedef VkExternalImageFormatProperties VkExternalImageFormatPropertiesKHR;
6615
6616 typedef VkPhysicalDeviceExternalBufferInfo VkPhysicalDeviceExternalBufferInfoKHR;
6617
6618 typedef VkExternalBufferProperties VkExternalBufferPropertiesKHR;
6619
6620 typedef VkPhysicalDeviceIDProperties VkPhysicalDeviceIDPropertiesKHR;
6621
6622 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties);
6623
6624 #ifndef VK_NO_PROTOTYPES
6625 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferPropertiesKHR(
6626     VkPhysicalDevice                            physicalDevice,
6627     const VkPhysicalDeviceExternalBufferInfo*   pExternalBufferInfo,
6628     VkExternalBufferProperties*                 pExternalBufferProperties);
6629 #endif
6630
6631
6632 #define VK_KHR_external_memory 1
6633 #define VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION 1
6634 #define VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME "VK_KHR_external_memory"
6635 #define VK_QUEUE_FAMILY_EXTERNAL_KHR      VK_QUEUE_FAMILY_EXTERNAL
6636 typedef VkExternalMemoryImageCreateInfo VkExternalMemoryImageCreateInfoKHR;
6637
6638 typedef VkExternalMemoryBufferCreateInfo VkExternalMemoryBufferCreateInfoKHR;
6639
6640 typedef VkExportMemoryAllocateInfo VkExportMemoryAllocateInfoKHR;
6641
6642
6643
6644 #define VK_KHR_external_memory_fd 1
6645 #define VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION 1
6646 #define VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME "VK_KHR_external_memory_fd"
6647 typedef struct VkImportMemoryFdInfoKHR {
6648     VkStructureType                       sType;
6649     const void*                           pNext;
6650     VkExternalMemoryHandleTypeFlagBits    handleType;
6651     int                                   fd;
6652 } VkImportMemoryFdInfoKHR;
6653
6654 typedef struct VkMemoryFdPropertiesKHR {
6655     VkStructureType    sType;
6656     void*              pNext;
6657     uint32_t           memoryTypeBits;
6658 } VkMemoryFdPropertiesKHR;
6659
6660 typedef struct VkMemoryGetFdInfoKHR {
6661     VkStructureType                       sType;
6662     const void*                           pNext;
6663     VkDeviceMemory                        memory;
6664     VkExternalMemoryHandleTypeFlagBits    handleType;
6665 } VkMemoryGetFdInfoKHR;
6666
6667 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdKHR)(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd);
6668 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdPropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties);
6669
6670 #ifndef VK_NO_PROTOTYPES
6671 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdKHR(
6672     VkDevice                                    device,
6673     const VkMemoryGetFdInfoKHR*                 pGetFdInfo,
6674     int*                                        pFd);
6675
6676 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdPropertiesKHR(
6677     VkDevice                                    device,
6678     VkExternalMemoryHandleTypeFlagBits          handleType,
6679     int                                         fd,
6680     VkMemoryFdPropertiesKHR*                    pMemoryFdProperties);
6681 #endif
6682
6683
6684 #define VK_KHR_external_semaphore_capabilities 1
6685 #define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION 1
6686 #define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_semaphore_capabilities"
6687 typedef VkExternalSemaphoreHandleTypeFlags VkExternalSemaphoreHandleTypeFlagsKHR;
6688
6689 typedef VkExternalSemaphoreHandleTypeFlagBits VkExternalSemaphoreHandleTypeFlagBitsKHR;
6690
6691 typedef VkExternalSemaphoreFeatureFlags VkExternalSemaphoreFeatureFlagsKHR;
6692
6693 typedef VkExternalSemaphoreFeatureFlagBits VkExternalSemaphoreFeatureFlagBitsKHR;
6694
6695 typedef VkPhysicalDeviceExternalSemaphoreInfo VkPhysicalDeviceExternalSemaphoreInfoKHR;
6696
6697 typedef VkExternalSemaphoreProperties VkExternalSemaphorePropertiesKHR;
6698
6699 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties);
6700
6701 #ifndef VK_NO_PROTOTYPES
6702 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
6703     VkPhysicalDevice                            physicalDevice,
6704     const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
6705     VkExternalSemaphoreProperties*              pExternalSemaphoreProperties);
6706 #endif
6707
6708
6709 #define VK_KHR_external_semaphore 1
6710 #define VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION 1
6711 #define VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME "VK_KHR_external_semaphore"
6712 typedef VkSemaphoreImportFlags VkSemaphoreImportFlagsKHR;
6713
6714 typedef VkSemaphoreImportFlagBits VkSemaphoreImportFlagBitsKHR;
6715
6716 typedef VkExportSemaphoreCreateInfo VkExportSemaphoreCreateInfoKHR;
6717
6718
6719
6720 #define VK_KHR_external_semaphore_fd 1
6721 #define VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION 1
6722 #define VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME "VK_KHR_external_semaphore_fd"
6723 typedef struct VkImportSemaphoreFdInfoKHR {
6724     VkStructureType                          sType;
6725     const void*                              pNext;
6726     VkSemaphore                              semaphore;
6727     VkSemaphoreImportFlags                   flags;
6728     VkExternalSemaphoreHandleTypeFlagBits    handleType;
6729     int                                      fd;
6730 } VkImportSemaphoreFdInfoKHR;
6731
6732 typedef struct VkSemaphoreGetFdInfoKHR {
6733     VkStructureType                          sType;
6734     const void*                              pNext;
6735     VkSemaphore                              semaphore;
6736     VkExternalSemaphoreHandleTypeFlagBits    handleType;
6737 } VkSemaphoreGetFdInfoKHR;
6738
6739 typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreFdKHR)(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo);
6740 typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreFdKHR)(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd);
6741
6742 #ifndef VK_NO_PROTOTYPES
6743 VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreFdKHR(
6744     VkDevice                                    device,
6745     const VkImportSemaphoreFdInfoKHR*           pImportSemaphoreFdInfo);
6746
6747 VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreFdKHR(
6748     VkDevice                                    device,
6749     const VkSemaphoreGetFdInfoKHR*              pGetFdInfo,
6750     int*                                        pFd);
6751 #endif
6752
6753
6754 #define VK_KHR_push_descriptor 1
6755 #define VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION 2
6756 #define VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME "VK_KHR_push_descriptor"
6757 typedef struct VkPhysicalDevicePushDescriptorPropertiesKHR {
6758     VkStructureType    sType;
6759     void*              pNext;
6760     uint32_t           maxPushDescriptors;
6761 } VkPhysicalDevicePushDescriptorPropertiesKHR;
6762
6763 typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetKHR)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites);
6764 typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetWithTemplateKHR)(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData);
6765
6766 #ifndef VK_NO_PROTOTYPES
6767 VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetKHR(
6768     VkCommandBuffer                             commandBuffer,
6769     VkPipelineBindPoint                         pipelineBindPoint,
6770     VkPipelineLayout                            layout,
6771     uint32_t                                    set,
6772     uint32_t                                    descriptorWriteCount,
6773     const VkWriteDescriptorSet*                 pDescriptorWrites);
6774
6775 VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplateKHR(
6776     VkCommandBuffer                             commandBuffer,
6777     VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
6778     VkPipelineLayout                            layout,
6779     uint32_t                                    set,
6780     const void*                                 pData);
6781 #endif
6782
6783
6784 #define VK_KHR_shader_float16_int8 1
6785 #define VK_KHR_SHADER_FLOAT16_INT8_SPEC_VERSION 1
6786 #define VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME "VK_KHR_shader_float16_int8"
6787 typedef VkPhysicalDeviceShaderFloat16Int8Features VkPhysicalDeviceShaderFloat16Int8FeaturesKHR;
6788
6789 typedef VkPhysicalDeviceShaderFloat16Int8Features VkPhysicalDeviceFloat16Int8FeaturesKHR;
6790
6791
6792
6793 #define VK_KHR_16bit_storage 1
6794 #define VK_KHR_16BIT_STORAGE_SPEC_VERSION 1
6795 #define VK_KHR_16BIT_STORAGE_EXTENSION_NAME "VK_KHR_16bit_storage"
6796 typedef VkPhysicalDevice16BitStorageFeatures VkPhysicalDevice16BitStorageFeaturesKHR;
6797
6798
6799
6800 #define VK_KHR_incremental_present 1
6801 #define VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION 2
6802 #define VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME "VK_KHR_incremental_present"
6803 typedef struct VkRectLayerKHR {
6804     VkOffset2D    offset;
6805     VkExtent2D    extent;
6806     uint32_t      layer;
6807 } VkRectLayerKHR;
6808
6809 typedef struct VkPresentRegionKHR {
6810     uint32_t                 rectangleCount;
6811     const VkRectLayerKHR*    pRectangles;
6812 } VkPresentRegionKHR;
6813
6814 typedef struct VkPresentRegionsKHR {
6815     VkStructureType              sType;
6816     const void*                  pNext;
6817     uint32_t                     swapchainCount;
6818     const VkPresentRegionKHR*    pRegions;
6819 } VkPresentRegionsKHR;
6820
6821
6822
6823 #define VK_KHR_descriptor_update_template 1
6824 typedef VkDescriptorUpdateTemplate VkDescriptorUpdateTemplateKHR;
6825
6826 #define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION 1
6827 #define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME "VK_KHR_descriptor_update_template"
6828 typedef VkDescriptorUpdateTemplateType VkDescriptorUpdateTemplateTypeKHR;
6829
6830 typedef VkDescriptorUpdateTemplateCreateFlags VkDescriptorUpdateTemplateCreateFlagsKHR;
6831
6832 typedef VkDescriptorUpdateTemplateEntry VkDescriptorUpdateTemplateEntryKHR;
6833
6834 typedef VkDescriptorUpdateTemplateCreateInfo VkDescriptorUpdateTemplateCreateInfoKHR;
6835
6836 typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplateKHR)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);
6837 typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplateKHR)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator);
6838 typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplateKHR)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData);
6839
6840 #ifndef VK_NO_PROTOTYPES
6841 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplateKHR(
6842     VkDevice                                    device,
6843     const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
6844     const VkAllocationCallbacks*                pAllocator,
6845     VkDescriptorUpdateTemplate*                 pDescriptorUpdateTemplate);
6846
6847 VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplateKHR(
6848     VkDevice                                    device,
6849     VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
6850     const VkAllocationCallbacks*                pAllocator);
6851
6852 VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplateKHR(
6853     VkDevice                                    device,
6854     VkDescriptorSet                             descriptorSet,
6855     VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
6856     const void*                                 pData);
6857 #endif
6858
6859
6860 #define VK_KHR_imageless_framebuffer 1
6861 #define VK_KHR_IMAGELESS_FRAMEBUFFER_SPEC_VERSION 1
6862 #define VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME "VK_KHR_imageless_framebuffer"
6863 typedef VkPhysicalDeviceImagelessFramebufferFeatures VkPhysicalDeviceImagelessFramebufferFeaturesKHR;
6864
6865 typedef VkFramebufferAttachmentsCreateInfo VkFramebufferAttachmentsCreateInfoKHR;
6866
6867 typedef VkFramebufferAttachmentImageInfo VkFramebufferAttachmentImageInfoKHR;
6868
6869 typedef VkRenderPassAttachmentBeginInfo VkRenderPassAttachmentBeginInfoKHR;
6870
6871
6872
6873 #define VK_KHR_create_renderpass2 1
6874 #define VK_KHR_CREATE_RENDERPASS_2_SPEC_VERSION 1
6875 #define VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME "VK_KHR_create_renderpass2"
6876 typedef VkRenderPassCreateInfo2 VkRenderPassCreateInfo2KHR;
6877
6878 typedef VkAttachmentDescription2 VkAttachmentDescription2KHR;
6879
6880 typedef VkAttachmentReference2 VkAttachmentReference2KHR;
6881
6882 typedef VkSubpassDescription2 VkSubpassDescription2KHR;
6883
6884 typedef VkSubpassDependency2 VkSubpassDependency2KHR;
6885
6886 typedef VkSubpassBeginInfo VkSubpassBeginInfoKHR;
6887
6888 typedef VkSubpassEndInfo VkSubpassEndInfoKHR;
6889
6890 typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass2KHR)(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);
6891 typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass2KHR)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo*      pRenderPassBegin, const VkSubpassBeginInfo*      pSubpassBeginInfo);
6892 typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass2KHR)(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo*      pSubpassBeginInfo, const VkSubpassEndInfo*        pSubpassEndInfo);
6893 typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass2KHR)(VkCommandBuffer commandBuffer, const VkSubpassEndInfo*        pSubpassEndInfo);
6894
6895 #ifndef VK_NO_PROTOTYPES
6896 VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass2KHR(
6897     VkDevice                                    device,
6898     const VkRenderPassCreateInfo2*              pCreateInfo,
6899     const VkAllocationCallbacks*                pAllocator,
6900     VkRenderPass*                               pRenderPass);
6901
6902 VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass2KHR(
6903     VkCommandBuffer                             commandBuffer,
6904     const VkRenderPassBeginInfo*                pRenderPassBegin,
6905     const VkSubpassBeginInfo*                   pSubpassBeginInfo);
6906
6907 VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass2KHR(
6908     VkCommandBuffer                             commandBuffer,
6909     const VkSubpassBeginInfo*                   pSubpassBeginInfo,
6910     const VkSubpassEndInfo*                     pSubpassEndInfo);
6911
6912 VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass2KHR(
6913     VkCommandBuffer                             commandBuffer,
6914     const VkSubpassEndInfo*                     pSubpassEndInfo);
6915 #endif
6916
6917
6918 #define VK_KHR_shared_presentable_image 1
6919 #define VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION 1
6920 #define VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME "VK_KHR_shared_presentable_image"
6921 typedef struct VkSharedPresentSurfaceCapabilitiesKHR {
6922     VkStructureType      sType;
6923     void*                pNext;
6924     VkImageUsageFlags    sharedPresentSupportedUsageFlags;
6925 } VkSharedPresentSurfaceCapabilitiesKHR;
6926
6927 typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainStatusKHR)(VkDevice device, VkSwapchainKHR swapchain);
6928
6929 #ifndef VK_NO_PROTOTYPES
6930 VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainStatusKHR(
6931     VkDevice                                    device,
6932     VkSwapchainKHR                              swapchain);
6933 #endif
6934
6935
6936 #define VK_KHR_external_fence_capabilities 1
6937 #define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION 1
6938 #define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_fence_capabilities"
6939 typedef VkExternalFenceHandleTypeFlags VkExternalFenceHandleTypeFlagsKHR;
6940
6941 typedef VkExternalFenceHandleTypeFlagBits VkExternalFenceHandleTypeFlagBitsKHR;
6942
6943 typedef VkExternalFenceFeatureFlags VkExternalFenceFeatureFlagsKHR;
6944
6945 typedef VkExternalFenceFeatureFlagBits VkExternalFenceFeatureFlagBitsKHR;
6946
6947 typedef VkPhysicalDeviceExternalFenceInfo VkPhysicalDeviceExternalFenceInfoKHR;
6948
6949 typedef VkExternalFenceProperties VkExternalFencePropertiesKHR;
6950
6951 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties);
6952
6953 #ifndef VK_NO_PROTOTYPES
6954 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFencePropertiesKHR(
6955     VkPhysicalDevice                            physicalDevice,
6956     const VkPhysicalDeviceExternalFenceInfo*    pExternalFenceInfo,
6957     VkExternalFenceProperties*                  pExternalFenceProperties);
6958 #endif
6959
6960
6961 #define VK_KHR_external_fence 1
6962 #define VK_KHR_EXTERNAL_FENCE_SPEC_VERSION 1
6963 #define VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME "VK_KHR_external_fence"
6964 typedef VkFenceImportFlags VkFenceImportFlagsKHR;
6965
6966 typedef VkFenceImportFlagBits VkFenceImportFlagBitsKHR;
6967
6968 typedef VkExportFenceCreateInfo VkExportFenceCreateInfoKHR;
6969
6970
6971
6972 #define VK_KHR_external_fence_fd 1
6973 #define VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION 1
6974 #define VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME "VK_KHR_external_fence_fd"
6975 typedef struct VkImportFenceFdInfoKHR {
6976     VkStructureType                      sType;
6977     const void*                          pNext;
6978     VkFence                              fence;
6979     VkFenceImportFlags                   flags;
6980     VkExternalFenceHandleTypeFlagBits    handleType;
6981     int                                  fd;
6982 } VkImportFenceFdInfoKHR;
6983
6984 typedef struct VkFenceGetFdInfoKHR {
6985     VkStructureType                      sType;
6986     const void*                          pNext;
6987     VkFence                              fence;
6988     VkExternalFenceHandleTypeFlagBits    handleType;
6989 } VkFenceGetFdInfoKHR;
6990
6991 typedef VkResult (VKAPI_PTR *PFN_vkImportFenceFdKHR)(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo);
6992 typedef VkResult (VKAPI_PTR *PFN_vkGetFenceFdKHR)(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd);
6993
6994 #ifndef VK_NO_PROTOTYPES
6995 VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceFdKHR(
6996     VkDevice                                    device,
6997     const VkImportFenceFdInfoKHR*               pImportFenceFdInfo);
6998
6999 VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceFdKHR(
7000     VkDevice                                    device,
7001     const VkFenceGetFdInfoKHR*                  pGetFdInfo,
7002     int*                                        pFd);
7003 #endif
7004
7005
7006 #define VK_KHR_performance_query 1
7007 #define VK_KHR_PERFORMANCE_QUERY_SPEC_VERSION 1
7008 #define VK_KHR_PERFORMANCE_QUERY_EXTENSION_NAME "VK_KHR_performance_query"
7009
7010 typedef enum VkPerformanceCounterUnitKHR {
7011     VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR = 0,
7012     VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR = 1,
7013     VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR = 2,
7014     VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR = 3,
7015     VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR = 4,
7016     VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR = 5,
7017     VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR = 6,
7018     VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR = 7,
7019     VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR = 8,
7020     VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR = 9,
7021     VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR = 10,
7022     VK_PERFORMANCE_COUNTER_UNIT_MAX_ENUM_KHR = 0x7FFFFFFF
7023 } VkPerformanceCounterUnitKHR;
7024
7025 typedef enum VkPerformanceCounterScopeKHR {
7026     VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR = 0,
7027     VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR = 1,
7028     VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR = 2,
7029     VK_QUERY_SCOPE_COMMAND_BUFFER_KHR = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR,
7030     VK_QUERY_SCOPE_RENDER_PASS_KHR = VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR,
7031     VK_QUERY_SCOPE_COMMAND_KHR = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR,
7032     VK_PERFORMANCE_COUNTER_SCOPE_MAX_ENUM_KHR = 0x7FFFFFFF
7033 } VkPerformanceCounterScopeKHR;
7034
7035 typedef enum VkPerformanceCounterStorageKHR {
7036     VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR = 0,
7037     VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR = 1,
7038     VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR = 2,
7039     VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR = 3,
7040     VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR = 4,
7041     VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR = 5,
7042     VK_PERFORMANCE_COUNTER_STORAGE_MAX_ENUM_KHR = 0x7FFFFFFF
7043 } VkPerformanceCounterStorageKHR;
7044
7045 typedef enum VkPerformanceCounterDescriptionFlagBitsKHR {
7046     VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR = 0x00000001,
7047     VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR = 0x00000002,
7048     VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR = VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR,
7049     VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR = VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR,
7050     VK_PERFORMANCE_COUNTER_DESCRIPTION_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
7051 } VkPerformanceCounterDescriptionFlagBitsKHR;
7052 typedef VkFlags VkPerformanceCounterDescriptionFlagsKHR;
7053
7054 typedef enum VkAcquireProfilingLockFlagBitsKHR {
7055     VK_ACQUIRE_PROFILING_LOCK_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
7056 } VkAcquireProfilingLockFlagBitsKHR;
7057 typedef VkFlags VkAcquireProfilingLockFlagsKHR;
7058 typedef struct VkPhysicalDevicePerformanceQueryFeaturesKHR {
7059     VkStructureType    sType;
7060     void*              pNext;
7061     VkBool32           performanceCounterQueryPools;
7062     VkBool32           performanceCounterMultipleQueryPools;
7063 } VkPhysicalDevicePerformanceQueryFeaturesKHR;
7064
7065 typedef struct VkPhysicalDevicePerformanceQueryPropertiesKHR {
7066     VkStructureType    sType;
7067     void*              pNext;
7068     VkBool32           allowCommandBufferQueryCopies;
7069 } VkPhysicalDevicePerformanceQueryPropertiesKHR;
7070
7071 typedef struct VkPerformanceCounterKHR {
7072     VkStructureType                   sType;
7073     void*                             pNext;
7074     VkPerformanceCounterUnitKHR       unit;
7075     VkPerformanceCounterScopeKHR      scope;
7076     VkPerformanceCounterStorageKHR    storage;
7077     uint8_t                           uuid[VK_UUID_SIZE];
7078 } VkPerformanceCounterKHR;
7079
7080 typedef struct VkPerformanceCounterDescriptionKHR {
7081     VkStructureType                            sType;
7082     void*                                      pNext;
7083     VkPerformanceCounterDescriptionFlagsKHR    flags;
7084     char                                       name[VK_MAX_DESCRIPTION_SIZE];
7085     char                                       category[VK_MAX_DESCRIPTION_SIZE];
7086     char                                       description[VK_MAX_DESCRIPTION_SIZE];
7087 } VkPerformanceCounterDescriptionKHR;
7088
7089 typedef struct VkQueryPoolPerformanceCreateInfoKHR {
7090     VkStructureType    sType;
7091     const void*        pNext;
7092     uint32_t           queueFamilyIndex;
7093     uint32_t           counterIndexCount;
7094     const uint32_t*    pCounterIndices;
7095 } VkQueryPoolPerformanceCreateInfoKHR;
7096
7097 typedef union VkPerformanceCounterResultKHR {
7098     int32_t     int32;
7099     int64_t     int64;
7100     uint32_t    uint32;
7101     uint64_t    uint64;
7102     float       float32;
7103     double      float64;
7104 } VkPerformanceCounterResultKHR;
7105
7106 typedef struct VkAcquireProfilingLockInfoKHR {
7107     VkStructureType                   sType;
7108     const void*                       pNext;
7109     VkAcquireProfilingLockFlagsKHR    flags;
7110     uint64_t                          timeout;
7111 } VkAcquireProfilingLockInfoKHR;
7112
7113 typedef struct VkPerformanceQuerySubmitInfoKHR {
7114     VkStructureType    sType;
7115     const void*        pNext;
7116     uint32_t           counterPassIndex;
7117 } VkPerformanceQuerySubmitInfoKHR;
7118
7119 typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions);
7120 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR)(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses);
7121 typedef VkResult (VKAPI_PTR *PFN_vkAcquireProfilingLockKHR)(VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo);
7122 typedef void (VKAPI_PTR *PFN_vkReleaseProfilingLockKHR)(VkDevice device);
7123
7124 #ifndef VK_NO_PROTOTYPES
7125 VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
7126     VkPhysicalDevice                            physicalDevice,
7127     uint32_t                                    queueFamilyIndex,
7128     uint32_t*                                   pCounterCount,
7129     VkPerformanceCounterKHR*                    pCounters,
7130     VkPerformanceCounterDescriptionKHR*         pCounterDescriptions);
7131
7132 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(
7133     VkPhysicalDevice                            physicalDevice,
7134     const VkQueryPoolPerformanceCreateInfoKHR*  pPerformanceQueryCreateInfo,
7135     uint32_t*                                   pNumPasses);
7136
7137 VKAPI_ATTR VkResult VKAPI_CALL vkAcquireProfilingLockKHR(
7138     VkDevice                                    device,
7139     const VkAcquireProfilingLockInfoKHR*        pInfo);
7140
7141 VKAPI_ATTR void VKAPI_CALL vkReleaseProfilingLockKHR(
7142     VkDevice                                    device);
7143 #endif
7144
7145
7146 #define VK_KHR_maintenance2 1
7147 #define VK_KHR_MAINTENANCE2_SPEC_VERSION  1
7148 #define VK_KHR_MAINTENANCE2_EXTENSION_NAME "VK_KHR_maintenance2"
7149 typedef VkPointClippingBehavior VkPointClippingBehaviorKHR;
7150
7151 typedef VkTessellationDomainOrigin VkTessellationDomainOriginKHR;
7152
7153 typedef VkPhysicalDevicePointClippingProperties VkPhysicalDevicePointClippingPropertiesKHR;
7154
7155 typedef VkRenderPassInputAttachmentAspectCreateInfo VkRenderPassInputAttachmentAspectCreateInfoKHR;
7156
7157 typedef VkInputAttachmentAspectReference VkInputAttachmentAspectReferenceKHR;
7158
7159 typedef VkImageViewUsageCreateInfo VkImageViewUsageCreateInfoKHR;
7160
7161 typedef VkPipelineTessellationDomainOriginStateCreateInfo VkPipelineTessellationDomainOriginStateCreateInfoKHR;
7162
7163
7164
7165 #define VK_KHR_get_surface_capabilities2 1
7166 #define VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION 1
7167 #define VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME "VK_KHR_get_surface_capabilities2"
7168 typedef struct VkPhysicalDeviceSurfaceInfo2KHR {
7169     VkStructureType    sType;
7170     const void*        pNext;
7171     VkSurfaceKHR       surface;
7172 } VkPhysicalDeviceSurfaceInfo2KHR;
7173
7174 typedef struct VkSurfaceCapabilities2KHR {
7175     VkStructureType             sType;
7176     void*                       pNext;
7177     VkSurfaceCapabilitiesKHR    surfaceCapabilities;
7178 } VkSurfaceCapabilities2KHR;
7179
7180 typedef struct VkSurfaceFormat2KHR {
7181     VkStructureType       sType;
7182     void*                 pNext;
7183     VkSurfaceFormatKHR    surfaceFormat;
7184 } VkSurfaceFormat2KHR;
7185
7186 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities);
7187 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormats2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats);
7188
7189 #ifndef VK_NO_PROTOTYPES
7190 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2KHR(
7191     VkPhysicalDevice                            physicalDevice,
7192     const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
7193     VkSurfaceCapabilities2KHR*                  pSurfaceCapabilities);
7194
7195 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormats2KHR(
7196     VkPhysicalDevice                            physicalDevice,
7197     const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
7198     uint32_t*                                   pSurfaceFormatCount,
7199     VkSurfaceFormat2KHR*                        pSurfaceFormats);
7200 #endif
7201
7202
7203 #define VK_KHR_variable_pointers 1
7204 #define VK_KHR_VARIABLE_POINTERS_SPEC_VERSION 1
7205 #define VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME "VK_KHR_variable_pointers"
7206 typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointerFeaturesKHR;
7207
7208 typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointersFeaturesKHR;
7209
7210
7211
7212 #define VK_KHR_get_display_properties2 1
7213 #define VK_KHR_GET_DISPLAY_PROPERTIES_2_SPEC_VERSION 1
7214 #define VK_KHR_GET_DISPLAY_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_display_properties2"
7215 typedef struct VkDisplayProperties2KHR {
7216     VkStructureType           sType;
7217     void*                     pNext;
7218     VkDisplayPropertiesKHR    displayProperties;
7219 } VkDisplayProperties2KHR;
7220
7221 typedef struct VkDisplayPlaneProperties2KHR {
7222     VkStructureType                sType;
7223     void*                          pNext;
7224     VkDisplayPlanePropertiesKHR    displayPlaneProperties;
7225 } VkDisplayPlaneProperties2KHR;
7226
7227 typedef struct VkDisplayModeProperties2KHR {
7228     VkStructureType               sType;
7229     void*                         pNext;
7230     VkDisplayModePropertiesKHR    displayModeProperties;
7231 } VkDisplayModeProperties2KHR;
7232
7233 typedef struct VkDisplayPlaneInfo2KHR {
7234     VkStructureType     sType;
7235     const void*         pNext;
7236     VkDisplayModeKHR    mode;
7237     uint32_t            planeIndex;
7238 } VkDisplayPlaneInfo2KHR;
7239
7240 typedef struct VkDisplayPlaneCapabilities2KHR {
7241     VkStructureType                  sType;
7242     void*                            pNext;
7243     VkDisplayPlaneCapabilitiesKHR    capabilities;
7244 } VkDisplayPlaneCapabilities2KHR;
7245
7246 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties);
7247 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties);
7248 typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModeProperties2KHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties);
7249 typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities);
7250
7251 #ifndef VK_NO_PROTOTYPES
7252 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayProperties2KHR(
7253     VkPhysicalDevice                            physicalDevice,
7254     uint32_t*                                   pPropertyCount,
7255     VkDisplayProperties2KHR*                    pProperties);
7256
7257 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
7258     VkPhysicalDevice                            physicalDevice,
7259     uint32_t*                                   pPropertyCount,
7260     VkDisplayPlaneProperties2KHR*               pProperties);
7261
7262 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModeProperties2KHR(
7263     VkPhysicalDevice                            physicalDevice,
7264     VkDisplayKHR                                display,
7265     uint32_t*                                   pPropertyCount,
7266     VkDisplayModeProperties2KHR*                pProperties);
7267
7268 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilities2KHR(
7269     VkPhysicalDevice                            physicalDevice,
7270     const VkDisplayPlaneInfo2KHR*               pDisplayPlaneInfo,
7271     VkDisplayPlaneCapabilities2KHR*             pCapabilities);
7272 #endif
7273
7274
7275 #define VK_KHR_dedicated_allocation 1
7276 #define VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION 3
7277 #define VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_KHR_dedicated_allocation"
7278 typedef VkMemoryDedicatedRequirements VkMemoryDedicatedRequirementsKHR;
7279
7280 typedef VkMemoryDedicatedAllocateInfo VkMemoryDedicatedAllocateInfoKHR;
7281
7282
7283
7284 #define VK_KHR_storage_buffer_storage_class 1
7285 #define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION 1
7286 #define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME "VK_KHR_storage_buffer_storage_class"
7287
7288
7289 #define VK_KHR_relaxed_block_layout 1
7290 #define VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION 1
7291 #define VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME "VK_KHR_relaxed_block_layout"
7292
7293
7294 #define VK_KHR_get_memory_requirements2 1
7295 #define VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION 1
7296 #define VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME "VK_KHR_get_memory_requirements2"
7297 typedef VkBufferMemoryRequirementsInfo2 VkBufferMemoryRequirementsInfo2KHR;
7298
7299 typedef VkImageMemoryRequirementsInfo2 VkImageMemoryRequirementsInfo2KHR;
7300
7301 typedef VkImageSparseMemoryRequirementsInfo2 VkImageSparseMemoryRequirementsInfo2KHR;
7302
7303 typedef VkMemoryRequirements2 VkMemoryRequirements2KHR;
7304
7305 typedef VkSparseImageMemoryRequirements2 VkSparseImageMemoryRequirements2KHR;
7306
7307 typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2KHR)(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements);
7308 typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2KHR)(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements);
7309 typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements2KHR)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
7310
7311 #ifndef VK_NO_PROTOTYPES
7312 VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2KHR(
7313     VkDevice                                    device,
7314     const VkImageMemoryRequirementsInfo2*       pInfo,
7315     VkMemoryRequirements2*                      pMemoryRequirements);
7316
7317 VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2KHR(
7318     VkDevice                                    device,
7319     const VkBufferMemoryRequirementsInfo2*      pInfo,
7320     VkMemoryRequirements2*                      pMemoryRequirements);
7321
7322 VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2KHR(
7323     VkDevice                                    device,
7324     const VkImageSparseMemoryRequirementsInfo2* pInfo,
7325     uint32_t*                                   pSparseMemoryRequirementCount,
7326     VkSparseImageMemoryRequirements2*           pSparseMemoryRequirements);
7327 #endif
7328
7329
7330 #define VK_KHR_image_format_list 1
7331 #define VK_KHR_IMAGE_FORMAT_LIST_SPEC_VERSION 1
7332 #define VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME "VK_KHR_image_format_list"
7333 typedef VkImageFormatListCreateInfo VkImageFormatListCreateInfoKHR;
7334
7335
7336
7337 #define VK_KHR_sampler_ycbcr_conversion 1
7338 typedef VkSamplerYcbcrConversion VkSamplerYcbcrConversionKHR;
7339
7340 #define VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION 14
7341 #define VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME "VK_KHR_sampler_ycbcr_conversion"
7342 typedef VkSamplerYcbcrModelConversion VkSamplerYcbcrModelConversionKHR;
7343
7344 typedef VkSamplerYcbcrRange VkSamplerYcbcrRangeKHR;
7345
7346 typedef VkChromaLocation VkChromaLocationKHR;
7347
7348 typedef VkSamplerYcbcrConversionCreateInfo VkSamplerYcbcrConversionCreateInfoKHR;
7349
7350 typedef VkSamplerYcbcrConversionInfo VkSamplerYcbcrConversionInfoKHR;
7351
7352 typedef VkBindImagePlaneMemoryInfo VkBindImagePlaneMemoryInfoKHR;
7353
7354 typedef VkImagePlaneMemoryRequirementsInfo VkImagePlaneMemoryRequirementsInfoKHR;
7355
7356 typedef VkPhysicalDeviceSamplerYcbcrConversionFeatures VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR;
7357
7358 typedef VkSamplerYcbcrConversionImageFormatProperties VkSamplerYcbcrConversionImageFormatPropertiesKHR;
7359
7360 typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversionKHR)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion);
7361 typedef void (VKAPI_PTR *PFN_vkDestroySamplerYcbcrConversionKHR)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator);
7362
7363 #ifndef VK_NO_PROTOTYPES
7364 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversionKHR(
7365     VkDevice                                    device,
7366     const VkSamplerYcbcrConversionCreateInfo*   pCreateInfo,
7367     const VkAllocationCallbacks*                pAllocator,
7368     VkSamplerYcbcrConversion*                   pYcbcrConversion);
7369
7370 VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversionKHR(
7371     VkDevice                                    device,
7372     VkSamplerYcbcrConversion                    ycbcrConversion,
7373     const VkAllocationCallbacks*                pAllocator);
7374 #endif
7375
7376
7377 #define VK_KHR_bind_memory2 1
7378 #define VK_KHR_BIND_MEMORY_2_SPEC_VERSION 1
7379 #define VK_KHR_BIND_MEMORY_2_EXTENSION_NAME "VK_KHR_bind_memory2"
7380 typedef VkBindBufferMemoryInfo VkBindBufferMemoryInfoKHR;
7381
7382 typedef VkBindImageMemoryInfo VkBindImageMemoryInfoKHR;
7383
7384 typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos);
7385 typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos);
7386
7387 #ifndef VK_NO_PROTOTYPES
7388 VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2KHR(
7389     VkDevice                                    device,
7390     uint32_t                                    bindInfoCount,
7391     const VkBindBufferMemoryInfo*               pBindInfos);
7392
7393 VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2KHR(
7394     VkDevice                                    device,
7395     uint32_t                                    bindInfoCount,
7396     const VkBindImageMemoryInfo*                pBindInfos);
7397 #endif
7398
7399
7400 #define VK_KHR_maintenance3 1
7401 #define VK_KHR_MAINTENANCE3_SPEC_VERSION  1
7402 #define VK_KHR_MAINTENANCE3_EXTENSION_NAME "VK_KHR_maintenance3"
7403 typedef VkPhysicalDeviceMaintenance3Properties VkPhysicalDeviceMaintenance3PropertiesKHR;
7404
7405 typedef VkDescriptorSetLayoutSupport VkDescriptorSetLayoutSupportKHR;
7406
7407 typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutSupportKHR)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport);
7408
7409 #ifndef VK_NO_PROTOTYPES
7410 VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupportKHR(
7411     VkDevice                                    device,
7412     const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
7413     VkDescriptorSetLayoutSupport*               pSupport);
7414 #endif
7415
7416
7417 #define VK_KHR_draw_indirect_count 1
7418 #define VK_KHR_DRAW_INDIRECT_COUNT_SPEC_VERSION 1
7419 #define VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_KHR_draw_indirect_count"
7420 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountKHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
7421 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCountKHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
7422
7423 #ifndef VK_NO_PROTOTYPES
7424 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountKHR(
7425     VkCommandBuffer                             commandBuffer,
7426     VkBuffer                                    buffer,
7427     VkDeviceSize                                offset,
7428     VkBuffer                                    countBuffer,
7429     VkDeviceSize                                countBufferOffset,
7430     uint32_t                                    maxDrawCount,
7431     uint32_t                                    stride);
7432
7433 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountKHR(
7434     VkCommandBuffer                             commandBuffer,
7435     VkBuffer                                    buffer,
7436     VkDeviceSize                                offset,
7437     VkBuffer                                    countBuffer,
7438     VkDeviceSize                                countBufferOffset,
7439     uint32_t                                    maxDrawCount,
7440     uint32_t                                    stride);
7441 #endif
7442
7443
7444 #define VK_KHR_shader_subgroup_extended_types 1
7445 #define VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_SPEC_VERSION 1
7446 #define VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_EXTENSION_NAME "VK_KHR_shader_subgroup_extended_types"
7447 typedef VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR;
7448
7449
7450
7451 #define VK_KHR_8bit_storage 1
7452 #define VK_KHR_8BIT_STORAGE_SPEC_VERSION  1
7453 #define VK_KHR_8BIT_STORAGE_EXTENSION_NAME "VK_KHR_8bit_storage"
7454 typedef VkPhysicalDevice8BitStorageFeatures VkPhysicalDevice8BitStorageFeaturesKHR;
7455
7456
7457
7458 #define VK_KHR_shader_atomic_int64 1
7459 #define VK_KHR_SHADER_ATOMIC_INT64_SPEC_VERSION 1
7460 #define VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME "VK_KHR_shader_atomic_int64"
7461 typedef VkPhysicalDeviceShaderAtomicInt64Features VkPhysicalDeviceShaderAtomicInt64FeaturesKHR;
7462
7463
7464
7465 #define VK_KHR_shader_clock 1
7466 #define VK_KHR_SHADER_CLOCK_SPEC_VERSION  1
7467 #define VK_KHR_SHADER_CLOCK_EXTENSION_NAME "VK_KHR_shader_clock"
7468 typedef struct VkPhysicalDeviceShaderClockFeaturesKHR {
7469     VkStructureType    sType;
7470     void*              pNext;
7471     VkBool32           shaderSubgroupClock;
7472     VkBool32           shaderDeviceClock;
7473 } VkPhysicalDeviceShaderClockFeaturesKHR;
7474
7475
7476
7477 #define VK_KHR_driver_properties 1
7478 #define VK_KHR_DRIVER_PROPERTIES_SPEC_VERSION 1
7479 #define VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME "VK_KHR_driver_properties"
7480 #define VK_MAX_DRIVER_NAME_SIZE_KHR       VK_MAX_DRIVER_NAME_SIZE
7481 #define VK_MAX_DRIVER_INFO_SIZE_KHR       VK_MAX_DRIVER_INFO_SIZE
7482 typedef VkDriverId VkDriverIdKHR;
7483
7484 typedef VkConformanceVersion VkConformanceVersionKHR;
7485
7486 typedef VkPhysicalDeviceDriverProperties VkPhysicalDeviceDriverPropertiesKHR;
7487
7488
7489
7490 #define VK_KHR_shader_float_controls 1
7491 #define VK_KHR_SHADER_FLOAT_CONTROLS_SPEC_VERSION 4
7492 #define VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME "VK_KHR_shader_float_controls"
7493 typedef VkShaderFloatControlsIndependence VkShaderFloatControlsIndependenceKHR;
7494
7495 typedef VkPhysicalDeviceFloatControlsProperties VkPhysicalDeviceFloatControlsPropertiesKHR;
7496
7497
7498
7499 #define VK_KHR_depth_stencil_resolve 1
7500 #define VK_KHR_DEPTH_STENCIL_RESOLVE_SPEC_VERSION 1
7501 #define VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME "VK_KHR_depth_stencil_resolve"
7502 typedef VkResolveModeFlagBits VkResolveModeFlagBitsKHR;
7503
7504 typedef VkResolveModeFlags VkResolveModeFlagsKHR;
7505
7506 typedef VkSubpassDescriptionDepthStencilResolve VkSubpassDescriptionDepthStencilResolveKHR;
7507
7508 typedef VkPhysicalDeviceDepthStencilResolveProperties VkPhysicalDeviceDepthStencilResolvePropertiesKHR;
7509
7510
7511
7512 #define VK_KHR_swapchain_mutable_format 1
7513 #define VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_SPEC_VERSION 1
7514 #define VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME "VK_KHR_swapchain_mutable_format"
7515
7516
7517 #define VK_KHR_timeline_semaphore 1
7518 #define VK_KHR_TIMELINE_SEMAPHORE_SPEC_VERSION 2
7519 #define VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME "VK_KHR_timeline_semaphore"
7520 typedef VkSemaphoreType VkSemaphoreTypeKHR;
7521
7522 typedef VkSemaphoreWaitFlagBits VkSemaphoreWaitFlagBitsKHR;
7523
7524 typedef VkSemaphoreWaitFlags VkSemaphoreWaitFlagsKHR;
7525
7526 typedef VkPhysicalDeviceTimelineSemaphoreFeatures VkPhysicalDeviceTimelineSemaphoreFeaturesKHR;
7527
7528 typedef VkPhysicalDeviceTimelineSemaphoreProperties VkPhysicalDeviceTimelineSemaphorePropertiesKHR;
7529
7530 typedef VkSemaphoreTypeCreateInfo VkSemaphoreTypeCreateInfoKHR;
7531
7532 typedef VkTimelineSemaphoreSubmitInfo VkTimelineSemaphoreSubmitInfoKHR;
7533
7534 typedef VkSemaphoreWaitInfo VkSemaphoreWaitInfoKHR;
7535
7536 typedef VkSemaphoreSignalInfo VkSemaphoreSignalInfoKHR;
7537
7538 typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreCounterValueKHR)(VkDevice device, VkSemaphore semaphore, uint64_t* pValue);
7539 typedef VkResult (VKAPI_PTR *PFN_vkWaitSemaphoresKHR)(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout);
7540 typedef VkResult (VKAPI_PTR *PFN_vkSignalSemaphoreKHR)(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo);
7541
7542 #ifndef VK_NO_PROTOTYPES
7543 VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreCounterValueKHR(
7544     VkDevice                                    device,
7545     VkSemaphore                                 semaphore,
7546     uint64_t*                                   pValue);
7547
7548 VKAPI_ATTR VkResult VKAPI_CALL vkWaitSemaphoresKHR(
7549     VkDevice                                    device,
7550     const VkSemaphoreWaitInfo*                  pWaitInfo,
7551     uint64_t                                    timeout);
7552
7553 VKAPI_ATTR VkResult VKAPI_CALL vkSignalSemaphoreKHR(
7554     VkDevice                                    device,
7555     const VkSemaphoreSignalInfo*                pSignalInfo);
7556 #endif
7557
7558
7559 #define VK_KHR_vulkan_memory_model 1
7560 #define VK_KHR_VULKAN_MEMORY_MODEL_SPEC_VERSION 3
7561 #define VK_KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME "VK_KHR_vulkan_memory_model"
7562 typedef VkPhysicalDeviceVulkanMemoryModelFeatures VkPhysicalDeviceVulkanMemoryModelFeaturesKHR;
7563
7564
7565
7566 #define VK_KHR_shader_terminate_invocation 1
7567 #define VK_KHR_SHADER_TERMINATE_INVOCATION_SPEC_VERSION 1
7568 #define VK_KHR_SHADER_TERMINATE_INVOCATION_EXTENSION_NAME "VK_KHR_shader_terminate_invocation"
7569 typedef struct VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR {
7570     VkStructureType    sType;
7571     void*              pNext;
7572     VkBool32           shaderTerminateInvocation;
7573 } VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR;
7574
7575
7576
7577 #define VK_KHR_fragment_shading_rate 1
7578 #define VK_KHR_FRAGMENT_SHADING_RATE_SPEC_VERSION 1
7579 #define VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME "VK_KHR_fragment_shading_rate"
7580
7581 typedef enum VkFragmentShadingRateCombinerOpKHR {
7582     VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR = 0,
7583     VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR = 1,
7584     VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR = 2,
7585     VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR = 3,
7586     VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR = 4,
7587     VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_ENUM_KHR = 0x7FFFFFFF
7588 } VkFragmentShadingRateCombinerOpKHR;
7589 typedef struct VkFragmentShadingRateAttachmentInfoKHR {
7590     VkStructureType                  sType;
7591     const void*                      pNext;
7592     const VkAttachmentReference2*    pFragmentShadingRateAttachment;
7593     VkExtent2D                       shadingRateAttachmentTexelSize;
7594 } VkFragmentShadingRateAttachmentInfoKHR;
7595
7596 typedef struct VkPipelineFragmentShadingRateStateCreateInfoKHR {
7597     VkStructureType                       sType;
7598     const void*                           pNext;
7599     VkExtent2D                            fragmentSize;
7600     VkFragmentShadingRateCombinerOpKHR    combinerOps[2];
7601 } VkPipelineFragmentShadingRateStateCreateInfoKHR;
7602
7603 typedef struct VkPhysicalDeviceFragmentShadingRateFeaturesKHR {
7604     VkStructureType    sType;
7605     void*              pNext;
7606     VkBool32           pipelineFragmentShadingRate;
7607     VkBool32           primitiveFragmentShadingRate;
7608     VkBool32           attachmentFragmentShadingRate;
7609 } VkPhysicalDeviceFragmentShadingRateFeaturesKHR;
7610
7611 typedef struct VkPhysicalDeviceFragmentShadingRatePropertiesKHR {
7612     VkStructureType          sType;
7613     void*                    pNext;
7614     VkExtent2D               minFragmentShadingRateAttachmentTexelSize;
7615     VkExtent2D               maxFragmentShadingRateAttachmentTexelSize;
7616     uint32_t                 maxFragmentShadingRateAttachmentTexelSizeAspectRatio;
7617     VkBool32                 primitiveFragmentShadingRateWithMultipleViewports;
7618     VkBool32                 layeredShadingRateAttachments;
7619     VkBool32                 fragmentShadingRateNonTrivialCombinerOps;
7620     VkExtent2D               maxFragmentSize;
7621     uint32_t                 maxFragmentSizeAspectRatio;
7622     uint32_t                 maxFragmentShadingRateCoverageSamples;
7623     VkSampleCountFlagBits    maxFragmentShadingRateRasterizationSamples;
7624     VkBool32                 fragmentShadingRateWithShaderDepthStencilWrites;
7625     VkBool32                 fragmentShadingRateWithSampleMask;
7626     VkBool32                 fragmentShadingRateWithShaderSampleMask;
7627     VkBool32                 fragmentShadingRateWithConservativeRasterization;
7628     VkBool32                 fragmentShadingRateWithFragmentShaderInterlock;
7629     VkBool32                 fragmentShadingRateWithCustomSampleLocations;
7630     VkBool32                 fragmentShadingRateStrictMultiplyCombiner;
7631 } VkPhysicalDeviceFragmentShadingRatePropertiesKHR;
7632
7633 typedef struct VkPhysicalDeviceFragmentShadingRateKHR {
7634     VkStructureType       sType;
7635     void*                 pNext;
7636     VkSampleCountFlags    sampleCounts;
7637     VkExtent2D            fragmentSize;
7638 } VkPhysicalDeviceFragmentShadingRateKHR;
7639
7640 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates);
7641 typedef void (VKAPI_PTR *PFN_vkCmdSetFragmentShadingRateKHR)(VkCommandBuffer           commandBuffer, const VkExtent2D*                           pFragmentSize, const VkFragmentShadingRateCombinerOpKHR    combinerOps[2]);
7642
7643 #ifndef VK_NO_PROTOTYPES
7644 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceFragmentShadingRatesKHR(
7645     VkPhysicalDevice                            physicalDevice,
7646     uint32_t*                                   pFragmentShadingRateCount,
7647     VkPhysicalDeviceFragmentShadingRateKHR*     pFragmentShadingRates);
7648
7649 VKAPI_ATTR void VKAPI_CALL vkCmdSetFragmentShadingRateKHR(
7650     VkCommandBuffer                             commandBuffer,
7651     const VkExtent2D*                           pFragmentSize,
7652     const VkFragmentShadingRateCombinerOpKHR    combinerOps[2]);
7653 #endif
7654
7655
7656 #define VK_KHR_spirv_1_4 1
7657 #define VK_KHR_SPIRV_1_4_SPEC_VERSION     1
7658 #define VK_KHR_SPIRV_1_4_EXTENSION_NAME   "VK_KHR_spirv_1_4"
7659
7660
7661 #define VK_KHR_surface_protected_capabilities 1
7662 #define VK_KHR_SURFACE_PROTECTED_CAPABILITIES_SPEC_VERSION 1
7663 #define VK_KHR_SURFACE_PROTECTED_CAPABILITIES_EXTENSION_NAME "VK_KHR_surface_protected_capabilities"
7664 typedef struct VkSurfaceProtectedCapabilitiesKHR {
7665     VkStructureType    sType;
7666     const void*        pNext;
7667     VkBool32           supportsProtected;
7668 } VkSurfaceProtectedCapabilitiesKHR;
7669
7670
7671
7672 #define VK_KHR_separate_depth_stencil_layouts 1
7673 #define VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_SPEC_VERSION 1
7674 #define VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME "VK_KHR_separate_depth_stencil_layouts"
7675 typedef VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR;
7676
7677 typedef VkAttachmentReferenceStencilLayout VkAttachmentReferenceStencilLayoutKHR;
7678
7679 typedef VkAttachmentDescriptionStencilLayout VkAttachmentDescriptionStencilLayoutKHR;
7680
7681
7682
7683 #define VK_KHR_present_wait 1
7684 #define VK_KHR_PRESENT_WAIT_SPEC_VERSION  1
7685 #define VK_KHR_PRESENT_WAIT_EXTENSION_NAME "VK_KHR_present_wait"
7686 typedef struct VkPhysicalDevicePresentWaitFeaturesKHR {
7687     VkStructureType    sType;
7688     void*              pNext;
7689     VkBool32           presentWait;
7690 } VkPhysicalDevicePresentWaitFeaturesKHR;
7691
7692 typedef VkResult (VKAPI_PTR *PFN_vkWaitForPresentKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout);
7693
7694 #ifndef VK_NO_PROTOTYPES
7695 VKAPI_ATTR VkResult VKAPI_CALL vkWaitForPresentKHR(
7696     VkDevice                                    device,
7697     VkSwapchainKHR                              swapchain,
7698     uint64_t                                    presentId,
7699     uint64_t                                    timeout);
7700 #endif
7701
7702
7703 #define VK_KHR_uniform_buffer_standard_layout 1
7704 #define VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_SPEC_VERSION 1
7705 #define VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME "VK_KHR_uniform_buffer_standard_layout"
7706 typedef VkPhysicalDeviceUniformBufferStandardLayoutFeatures VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR;
7707
7708
7709
7710 #define VK_KHR_buffer_device_address 1
7711 #define VK_KHR_BUFFER_DEVICE_ADDRESS_SPEC_VERSION 1
7712 #define VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME "VK_KHR_buffer_device_address"
7713 typedef VkPhysicalDeviceBufferDeviceAddressFeatures VkPhysicalDeviceBufferDeviceAddressFeaturesKHR;
7714
7715 typedef VkBufferDeviceAddressInfo VkBufferDeviceAddressInfoKHR;
7716
7717 typedef VkBufferOpaqueCaptureAddressCreateInfo VkBufferOpaqueCaptureAddressCreateInfoKHR;
7718
7719 typedef VkMemoryOpaqueCaptureAddressAllocateInfo VkMemoryOpaqueCaptureAddressAllocateInfoKHR;
7720
7721 typedef VkDeviceMemoryOpaqueCaptureAddressInfo VkDeviceMemoryOpaqueCaptureAddressInfoKHR;
7722
7723 typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddressKHR)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo);
7724 typedef uint64_t (VKAPI_PTR *PFN_vkGetBufferOpaqueCaptureAddressKHR)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo);
7725 typedef uint64_t (VKAPI_PTR *PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR)(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo);
7726
7727 #ifndef VK_NO_PROTOTYPES
7728 VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressKHR(
7729     VkDevice                                    device,
7730     const VkBufferDeviceAddressInfo*            pInfo);
7731
7732 VKAPI_ATTR uint64_t VKAPI_CALL vkGetBufferOpaqueCaptureAddressKHR(
7733     VkDevice                                    device,
7734     const VkBufferDeviceAddressInfo*            pInfo);
7735
7736 VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceMemoryOpaqueCaptureAddressKHR(
7737     VkDevice                                    device,
7738     const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo);
7739 #endif
7740
7741
7742 #define VK_KHR_deferred_host_operations 1
7743 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeferredOperationKHR)
7744 #define VK_KHR_DEFERRED_HOST_OPERATIONS_SPEC_VERSION 4
7745 #define VK_KHR_DEFERRED_HOST_OPERATIONS_EXTENSION_NAME "VK_KHR_deferred_host_operations"
7746 typedef VkResult (VKAPI_PTR *PFN_vkCreateDeferredOperationKHR)(VkDevice device, const VkAllocationCallbacks* pAllocator, VkDeferredOperationKHR* pDeferredOperation);
7747 typedef void (VKAPI_PTR *PFN_vkDestroyDeferredOperationKHR)(VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks* pAllocator);
7748 typedef uint32_t (VKAPI_PTR *PFN_vkGetDeferredOperationMaxConcurrencyKHR)(VkDevice device, VkDeferredOperationKHR operation);
7749 typedef VkResult (VKAPI_PTR *PFN_vkGetDeferredOperationResultKHR)(VkDevice device, VkDeferredOperationKHR operation);
7750 typedef VkResult (VKAPI_PTR *PFN_vkDeferredOperationJoinKHR)(VkDevice device, VkDeferredOperationKHR operation);
7751
7752 #ifndef VK_NO_PROTOTYPES
7753 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDeferredOperationKHR(
7754     VkDevice                                    device,
7755     const VkAllocationCallbacks*                pAllocator,
7756     VkDeferredOperationKHR*                     pDeferredOperation);
7757
7758 VKAPI_ATTR void VKAPI_CALL vkDestroyDeferredOperationKHR(
7759     VkDevice                                    device,
7760     VkDeferredOperationKHR                      operation,
7761     const VkAllocationCallbacks*                pAllocator);
7762
7763 VKAPI_ATTR uint32_t VKAPI_CALL vkGetDeferredOperationMaxConcurrencyKHR(
7764     VkDevice                                    device,
7765     VkDeferredOperationKHR                      operation);
7766
7767 VKAPI_ATTR VkResult VKAPI_CALL vkGetDeferredOperationResultKHR(
7768     VkDevice                                    device,
7769     VkDeferredOperationKHR                      operation);
7770
7771 VKAPI_ATTR VkResult VKAPI_CALL vkDeferredOperationJoinKHR(
7772     VkDevice                                    device,
7773     VkDeferredOperationKHR                      operation);
7774 #endif
7775
7776
7777 #define VK_KHR_pipeline_executable_properties 1
7778 #define VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION 1
7779 #define VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME "VK_KHR_pipeline_executable_properties"
7780
7781 typedef enum VkPipelineExecutableStatisticFormatKHR {
7782     VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR = 0,
7783     VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR = 1,
7784     VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR = 2,
7785     VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR = 3,
7786     VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_MAX_ENUM_KHR = 0x7FFFFFFF
7787 } VkPipelineExecutableStatisticFormatKHR;
7788 typedef struct VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
7789     VkStructureType    sType;
7790     void*              pNext;
7791     VkBool32           pipelineExecutableInfo;
7792 } VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
7793
7794 typedef struct VkPipelineInfoKHR {
7795     VkStructureType    sType;
7796     const void*        pNext;
7797     VkPipeline         pipeline;
7798 } VkPipelineInfoKHR;
7799
7800 typedef struct VkPipelineExecutablePropertiesKHR {
7801     VkStructureType       sType;
7802     void*                 pNext;
7803     VkShaderStageFlags    stages;
7804     char                  name[VK_MAX_DESCRIPTION_SIZE];
7805     char                  description[VK_MAX_DESCRIPTION_SIZE];
7806     uint32_t              subgroupSize;
7807 } VkPipelineExecutablePropertiesKHR;
7808
7809 typedef struct VkPipelineExecutableInfoKHR {
7810     VkStructureType    sType;
7811     const void*        pNext;
7812     VkPipeline         pipeline;
7813     uint32_t           executableIndex;
7814 } VkPipelineExecutableInfoKHR;
7815
7816 typedef union VkPipelineExecutableStatisticValueKHR {
7817     VkBool32    b32;
7818     int64_t     i64;
7819     uint64_t    u64;
7820     double      f64;
7821 } VkPipelineExecutableStatisticValueKHR;
7822
7823 typedef struct VkPipelineExecutableStatisticKHR {
7824     VkStructureType                           sType;
7825     void*                                     pNext;
7826     char                                      name[VK_MAX_DESCRIPTION_SIZE];
7827     char                                      description[VK_MAX_DESCRIPTION_SIZE];
7828     VkPipelineExecutableStatisticFormatKHR    format;
7829     VkPipelineExecutableStatisticValueKHR     value;
7830 } VkPipelineExecutableStatisticKHR;
7831
7832 typedef struct VkPipelineExecutableInternalRepresentationKHR {
7833     VkStructureType    sType;
7834     void*              pNext;
7835     char               name[VK_MAX_DESCRIPTION_SIZE];
7836     char               description[VK_MAX_DESCRIPTION_SIZE];
7837     VkBool32           isText;
7838     size_t             dataSize;
7839     void*              pData;
7840 } VkPipelineExecutableInternalRepresentationKHR;
7841
7842 typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutablePropertiesKHR)(VkDevice                        device, const VkPipelineInfoKHR*        pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties);
7843 typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutableStatisticsKHR)(VkDevice                        device, const VkPipelineExecutableInfoKHR*  pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics);
7844 typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutableInternalRepresentationsKHR)(VkDevice                        device, const VkPipelineExecutableInfoKHR*  pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations);
7845
7846 #ifndef VK_NO_PROTOTYPES
7847 VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutablePropertiesKHR(
7848     VkDevice                                    device,
7849     const VkPipelineInfoKHR*                    pPipelineInfo,
7850     uint32_t*                                   pExecutableCount,
7851     VkPipelineExecutablePropertiesKHR*          pProperties);
7852
7853 VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableStatisticsKHR(
7854     VkDevice                                    device,
7855     const VkPipelineExecutableInfoKHR*          pExecutableInfo,
7856     uint32_t*                                   pStatisticCount,
7857     VkPipelineExecutableStatisticKHR*           pStatistics);
7858
7859 VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableInternalRepresentationsKHR(
7860     VkDevice                                    device,
7861     const VkPipelineExecutableInfoKHR*          pExecutableInfo,
7862     uint32_t*                                   pInternalRepresentationCount,
7863     VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations);
7864 #endif
7865
7866
7867 #define VK_KHR_pipeline_library 1
7868 #define VK_KHR_PIPELINE_LIBRARY_SPEC_VERSION 1
7869 #define VK_KHR_PIPELINE_LIBRARY_EXTENSION_NAME "VK_KHR_pipeline_library"
7870 typedef struct VkPipelineLibraryCreateInfoKHR {
7871     VkStructureType      sType;
7872     const void*          pNext;
7873     uint32_t             libraryCount;
7874     const VkPipeline*    pLibraries;
7875 } VkPipelineLibraryCreateInfoKHR;
7876
7877
7878
7879 #define VK_KHR_shader_non_semantic_info 1
7880 #define VK_KHR_SHADER_NON_SEMANTIC_INFO_SPEC_VERSION 1
7881 #define VK_KHR_SHADER_NON_SEMANTIC_INFO_EXTENSION_NAME "VK_KHR_shader_non_semantic_info"
7882
7883
7884 #define VK_KHR_present_id 1
7885 #define VK_KHR_PRESENT_ID_SPEC_VERSION    1
7886 #define VK_KHR_PRESENT_ID_EXTENSION_NAME  "VK_KHR_present_id"
7887 typedef struct VkPresentIdKHR {
7888     VkStructureType    sType;
7889     const void*        pNext;
7890     uint32_t           swapchainCount;
7891     const uint64_t*    pPresentIds;
7892 } VkPresentIdKHR;
7893
7894 typedef struct VkPhysicalDevicePresentIdFeaturesKHR {
7895     VkStructureType    sType;
7896     void*              pNext;
7897     VkBool32           presentId;
7898 } VkPhysicalDevicePresentIdFeaturesKHR;
7899
7900
7901
7902 #define VK_KHR_synchronization2 1
7903 typedef uint64_t VkFlags64;
7904 #define VK_KHR_SYNCHRONIZATION_2_SPEC_VERSION 1
7905 #define VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME "VK_KHR_synchronization2"
7906 typedef VkFlags64 VkPipelineStageFlags2KHR;
7907
7908 // Flag bits for VkPipelineStageFlagBits2KHR
7909 typedef VkFlags64 VkPipelineStageFlagBits2KHR;
7910 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_NONE_KHR = 0ULL;
7911 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR = 0x00000001ULL;
7912 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR = 0x00000002ULL;
7913 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR = 0x00000004ULL;
7914 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT_KHR = 0x00000008ULL;
7915 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR = 0x00000010ULL;
7916 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR = 0x00000020ULL;
7917 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR = 0x00000040ULL;
7918 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR = 0x00000080ULL;
7919 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR = 0x00000100ULL;
7920 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR = 0x00000200ULL;
7921 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR = 0x00000400ULL;
7922 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT_KHR = 0x00000800ULL;
7923 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR = 0x00001000ULL;
7924 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR = 0x00001000ULL;
7925 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR = 0x00002000ULL;
7926 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_HOST_BIT_KHR = 0x00004000ULL;
7927 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR = 0x00008000ULL;
7928 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR = 0x00010000ULL;
7929 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_COPY_BIT_KHR = 0x100000000ULL;
7930 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR = 0x200000000ULL;
7931 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_BLIT_BIT_KHR = 0x400000000ULL;
7932 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR = 0x800000000ULL;
7933 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR = 0x1000000000ULL;
7934 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR = 0x2000000000ULL;
7935 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR = 0x4000000000ULL;
7936 #ifdef VK_ENABLE_BETA_EXTENSIONS
7937 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR = 0x04000000ULL;
7938 #endif
7939 #ifdef VK_ENABLE_BETA_EXTENSIONS
7940 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR = 0x08000000ULL;
7941 #endif
7942 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT = 0x01000000ULL;
7943 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT = 0x00040000ULL;
7944 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV = 0x00020000ULL;
7945 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00400000ULL;
7946 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV = 0x00400000ULL;
7947 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR = 0x02000000ULL;
7948 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR = 0x00200000ULL;
7949 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_NV = 0x00200000ULL;
7950 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_NV = 0x02000000ULL;
7951 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT = 0x00800000ULL;
7952 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV = 0x00080000ULL;
7953 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV = 0x00100000ULL;
7954 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI = 0x8000000000ULL;
7955 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI = 0x10000000000ULL;
7956
7957 typedef VkFlags64 VkAccessFlags2KHR;
7958
7959 // Flag bits for VkAccessFlagBits2KHR
7960 typedef VkFlags64 VkAccessFlagBits2KHR;
7961 static const VkAccessFlagBits2KHR VK_ACCESS_2_NONE_KHR = 0ULL;
7962 static const VkAccessFlagBits2KHR VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR = 0x00000001ULL;
7963 static const VkAccessFlagBits2KHR VK_ACCESS_2_INDEX_READ_BIT_KHR = 0x00000002ULL;
7964 static const VkAccessFlagBits2KHR VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR = 0x00000004ULL;
7965 static const VkAccessFlagBits2KHR VK_ACCESS_2_UNIFORM_READ_BIT_KHR = 0x00000008ULL;
7966 static const VkAccessFlagBits2KHR VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR = 0x00000010ULL;
7967 static const VkAccessFlagBits2KHR VK_ACCESS_2_SHADER_READ_BIT_KHR = 0x00000020ULL;
7968 static const VkAccessFlagBits2KHR VK_ACCESS_2_SHADER_WRITE_BIT_KHR = 0x00000040ULL;
7969 static const VkAccessFlagBits2KHR VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR = 0x00000080ULL;
7970 static const VkAccessFlagBits2KHR VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR = 0x00000100ULL;
7971 static const VkAccessFlagBits2KHR VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR = 0x00000200ULL;
7972 static const VkAccessFlagBits2KHR VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR = 0x00000400ULL;
7973 static const VkAccessFlagBits2KHR VK_ACCESS_2_TRANSFER_READ_BIT_KHR = 0x00000800ULL;
7974 static const VkAccessFlagBits2KHR VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR = 0x00001000ULL;
7975 static const VkAccessFlagBits2KHR VK_ACCESS_2_HOST_READ_BIT_KHR = 0x00002000ULL;
7976 static const VkAccessFlagBits2KHR VK_ACCESS_2_HOST_WRITE_BIT_KHR = 0x00004000ULL;
7977 static const VkAccessFlagBits2KHR VK_ACCESS_2_MEMORY_READ_BIT_KHR = 0x00008000ULL;
7978 static const VkAccessFlagBits2KHR VK_ACCESS_2_MEMORY_WRITE_BIT_KHR = 0x00010000ULL;
7979 static const VkAccessFlagBits2KHR VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR = 0x100000000ULL;
7980 static const VkAccessFlagBits2KHR VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR = 0x200000000ULL;
7981 static const VkAccessFlagBits2KHR VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR = 0x400000000ULL;
7982 #ifdef VK_ENABLE_BETA_EXTENSIONS
7983 static const VkAccessFlagBits2KHR VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR = 0x800000000ULL;
7984 #endif
7985 #ifdef VK_ENABLE_BETA_EXTENSIONS
7986 static const VkAccessFlagBits2KHR VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR = 0x1000000000ULL;
7987 #endif
7988 #ifdef VK_ENABLE_BETA_EXTENSIONS
7989 static const VkAccessFlagBits2KHR VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR = 0x2000000000ULL;
7990 #endif
7991 #ifdef VK_ENABLE_BETA_EXTENSIONS
7992 static const VkAccessFlagBits2KHR VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR = 0x4000000000ULL;
7993 #endif
7994 static const VkAccessFlagBits2KHR VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT = 0x02000000ULL;
7995 static const VkAccessFlagBits2KHR VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT = 0x04000000ULL;
7996 static const VkAccessFlagBits2KHR VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT = 0x08000000ULL;
7997 static const VkAccessFlagBits2KHR VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT = 0x00100000ULL;
7998 static const VkAccessFlagBits2KHR VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV = 0x00020000ULL;
7999 static const VkAccessFlagBits2KHR VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV = 0x00040000ULL;
8000 static const VkAccessFlagBits2KHR VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR = 0x00800000ULL;
8001 static const VkAccessFlagBits2KHR VK_ACCESS_2_SHADING_RATE_IMAGE_READ_BIT_NV = 0x00800000ULL;
8002 static const VkAccessFlagBits2KHR VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR = 0x00200000ULL;
8003 static const VkAccessFlagBits2KHR VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR = 0x00400000ULL;
8004 static const VkAccessFlagBits2KHR VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_NV = 0x00200000ULL;
8005 static const VkAccessFlagBits2KHR VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_NV = 0x00400000ULL;
8006 static const VkAccessFlagBits2KHR VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT = 0x01000000ULL;
8007 static const VkAccessFlagBits2KHR VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000ULL;
8008 static const VkAccessFlagBits2KHR VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI = 0x8000000000ULL;
8009
8010
8011 typedef enum VkSubmitFlagBitsKHR {
8012     VK_SUBMIT_PROTECTED_BIT_KHR = 0x00000001,
8013     VK_SUBMIT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
8014 } VkSubmitFlagBitsKHR;
8015 typedef VkFlags VkSubmitFlagsKHR;
8016 typedef struct VkMemoryBarrier2KHR {
8017     VkStructureType             sType;
8018     const void*                 pNext;
8019     VkPipelineStageFlags2KHR    srcStageMask;
8020     VkAccessFlags2KHR           srcAccessMask;
8021     VkPipelineStageFlags2KHR    dstStageMask;
8022     VkAccessFlags2KHR           dstAccessMask;
8023 } VkMemoryBarrier2KHR;
8024
8025 typedef struct VkBufferMemoryBarrier2KHR {
8026     VkStructureType             sType;
8027     const void*                 pNext;
8028     VkPipelineStageFlags2KHR    srcStageMask;
8029     VkAccessFlags2KHR           srcAccessMask;
8030     VkPipelineStageFlags2KHR    dstStageMask;
8031     VkAccessFlags2KHR           dstAccessMask;
8032     uint32_t                    srcQueueFamilyIndex;
8033     uint32_t                    dstQueueFamilyIndex;
8034     VkBuffer                    buffer;
8035     VkDeviceSize                offset;
8036     VkDeviceSize                size;
8037 } VkBufferMemoryBarrier2KHR;
8038
8039 typedef struct VkImageMemoryBarrier2KHR {
8040     VkStructureType             sType;
8041     const void*                 pNext;
8042     VkPipelineStageFlags2KHR    srcStageMask;
8043     VkAccessFlags2KHR           srcAccessMask;
8044     VkPipelineStageFlags2KHR    dstStageMask;
8045     VkAccessFlags2KHR           dstAccessMask;
8046     VkImageLayout               oldLayout;
8047     VkImageLayout               newLayout;
8048     uint32_t                    srcQueueFamilyIndex;
8049     uint32_t                    dstQueueFamilyIndex;
8050     VkImage                     image;
8051     VkImageSubresourceRange     subresourceRange;
8052 } VkImageMemoryBarrier2KHR;
8053
8054 typedef struct VkDependencyInfoKHR {
8055     VkStructureType                     sType;
8056     const void*                         pNext;
8057     VkDependencyFlags                   dependencyFlags;
8058     uint32_t                            memoryBarrierCount;
8059     const VkMemoryBarrier2KHR*          pMemoryBarriers;
8060     uint32_t                            bufferMemoryBarrierCount;
8061     const VkBufferMemoryBarrier2KHR*    pBufferMemoryBarriers;
8062     uint32_t                            imageMemoryBarrierCount;
8063     const VkImageMemoryBarrier2KHR*     pImageMemoryBarriers;
8064 } VkDependencyInfoKHR;
8065
8066 typedef struct VkSemaphoreSubmitInfoKHR {
8067     VkStructureType             sType;
8068     const void*                 pNext;
8069     VkSemaphore                 semaphore;
8070     uint64_t                    value;
8071     VkPipelineStageFlags2KHR    stageMask;
8072     uint32_t                    deviceIndex;
8073 } VkSemaphoreSubmitInfoKHR;
8074
8075 typedef struct VkCommandBufferSubmitInfoKHR {
8076     VkStructureType    sType;
8077     const void*        pNext;
8078     VkCommandBuffer    commandBuffer;
8079     uint32_t           deviceMask;
8080 } VkCommandBufferSubmitInfoKHR;
8081
8082 typedef struct VkSubmitInfo2KHR {
8083     VkStructureType                        sType;
8084     const void*                            pNext;
8085     VkSubmitFlagsKHR                       flags;
8086     uint32_t                               waitSemaphoreInfoCount;
8087     const VkSemaphoreSubmitInfoKHR*        pWaitSemaphoreInfos;
8088     uint32_t                               commandBufferInfoCount;
8089     const VkCommandBufferSubmitInfoKHR*    pCommandBufferInfos;
8090     uint32_t                               signalSemaphoreInfoCount;
8091     const VkSemaphoreSubmitInfoKHR*        pSignalSemaphoreInfos;
8092 } VkSubmitInfo2KHR;
8093
8094 typedef struct VkPhysicalDeviceSynchronization2FeaturesKHR {
8095     VkStructureType    sType;
8096     void*              pNext;
8097     VkBool32           synchronization2;
8098 } VkPhysicalDeviceSynchronization2FeaturesKHR;
8099
8100 typedef struct VkQueueFamilyCheckpointProperties2NV {
8101     VkStructureType             sType;
8102     void*                       pNext;
8103     VkPipelineStageFlags2KHR    checkpointExecutionStageMask;
8104 } VkQueueFamilyCheckpointProperties2NV;
8105
8106 typedef struct VkCheckpointData2NV {
8107     VkStructureType             sType;
8108     void*                       pNext;
8109     VkPipelineStageFlags2KHR    stage;
8110     void*                       pCheckpointMarker;
8111 } VkCheckpointData2NV;
8112
8113 typedef void (VKAPI_PTR *PFN_vkCmdSetEvent2KHR)(VkCommandBuffer                   commandBuffer, VkEvent                                             event, const VkDependencyInfoKHR*                          pDependencyInfo);
8114 typedef void (VKAPI_PTR *PFN_vkCmdResetEvent2KHR)(VkCommandBuffer                   commandBuffer, VkEvent                                             event, VkPipelineStageFlags2KHR                            stageMask);
8115 typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents2KHR)(VkCommandBuffer                   commandBuffer, uint32_t                                            eventCount, const VkEvent*                     pEvents, const VkDependencyInfoKHR*         pDependencyInfos);
8116 typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier2KHR)(VkCommandBuffer                   commandBuffer, const VkDependencyInfoKHR*                                pDependencyInfo);
8117 typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp2KHR)(VkCommandBuffer                   commandBuffer, VkPipelineStageFlags2KHR                            stage, VkQueryPool                                         queryPool, uint32_t                                            query);
8118 typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit2KHR)(VkQueue                           queue, uint32_t                            submitCount, const VkSubmitInfo2KHR*           pSubmits, VkFence           fence);
8119 typedef void (VKAPI_PTR *PFN_vkCmdWriteBufferMarker2AMD)(VkCommandBuffer                   commandBuffer, VkPipelineStageFlags2KHR                            stage, VkBuffer                                            dstBuffer, VkDeviceSize                                        dstOffset, uint32_t                                            marker);
8120 typedef void (VKAPI_PTR *PFN_vkGetQueueCheckpointData2NV)(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointData2NV* pCheckpointData);
8121
8122 #ifndef VK_NO_PROTOTYPES
8123 VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent2KHR(
8124     VkCommandBuffer                             commandBuffer,
8125     VkEvent                                     event,
8126     const VkDependencyInfoKHR*                  pDependencyInfo);
8127
8128 VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent2KHR(
8129     VkCommandBuffer                             commandBuffer,
8130     VkEvent                                     event,
8131     VkPipelineStageFlags2KHR                    stageMask);
8132
8133 VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents2KHR(
8134     VkCommandBuffer                             commandBuffer,
8135     uint32_t                                    eventCount,
8136     const VkEvent*                              pEvents,
8137     const VkDependencyInfoKHR*                  pDependencyInfos);
8138
8139 VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier2KHR(
8140     VkCommandBuffer                             commandBuffer,
8141     const VkDependencyInfoKHR*                  pDependencyInfo);
8142
8143 VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp2KHR(
8144     VkCommandBuffer                             commandBuffer,
8145     VkPipelineStageFlags2KHR                    stage,
8146     VkQueryPool                                 queryPool,
8147     uint32_t                                    query);
8148
8149 VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit2KHR(
8150     VkQueue                                     queue,
8151     uint32_t                                    submitCount,
8152     const VkSubmitInfo2KHR*                     pSubmits,
8153     VkFence                                     fence);
8154
8155 VKAPI_ATTR void VKAPI_CALL vkCmdWriteBufferMarker2AMD(
8156     VkCommandBuffer                             commandBuffer,
8157     VkPipelineStageFlags2KHR                    stage,
8158     VkBuffer                                    dstBuffer,
8159     VkDeviceSize                                dstOffset,
8160     uint32_t                                    marker);
8161
8162 VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointData2NV(
8163     VkQueue                                     queue,
8164     uint32_t*                                   pCheckpointDataCount,
8165     VkCheckpointData2NV*                        pCheckpointData);
8166 #endif
8167
8168
8169 #define VK_KHR_shader_subgroup_uniform_control_flow 1
8170 #define VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_SPEC_VERSION 1
8171 #define VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_EXTENSION_NAME "VK_KHR_shader_subgroup_uniform_control_flow"
8172 typedef struct VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {
8173     VkStructureType    sType;
8174     void*              pNext;
8175     VkBool32           shaderSubgroupUniformControlFlow;
8176 } VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR;
8177
8178
8179
8180 #define VK_KHR_zero_initialize_workgroup_memory 1
8181 #define VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_SPEC_VERSION 1
8182 #define VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_EXTENSION_NAME "VK_KHR_zero_initialize_workgroup_memory"
8183 typedef struct VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR {
8184     VkStructureType    sType;
8185     void*              pNext;
8186     VkBool32           shaderZeroInitializeWorkgroupMemory;
8187 } VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR;
8188
8189
8190
8191 #define VK_KHR_workgroup_memory_explicit_layout 1
8192 #define VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_SPEC_VERSION 1
8193 #define VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_EXTENSION_NAME "VK_KHR_workgroup_memory_explicit_layout"
8194 typedef struct VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {
8195     VkStructureType    sType;
8196     void*              pNext;
8197     VkBool32           workgroupMemoryExplicitLayout;
8198     VkBool32           workgroupMemoryExplicitLayoutScalarBlockLayout;
8199     VkBool32           workgroupMemoryExplicitLayout8BitAccess;
8200     VkBool32           workgroupMemoryExplicitLayout16BitAccess;
8201 } VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR;
8202
8203
8204
8205 #define VK_KHR_copy_commands2 1
8206 #define VK_KHR_COPY_COMMANDS_2_SPEC_VERSION 1
8207 #define VK_KHR_COPY_COMMANDS_2_EXTENSION_NAME "VK_KHR_copy_commands2"
8208 typedef struct VkBufferCopy2KHR {
8209     VkStructureType    sType;
8210     const void*        pNext;
8211     VkDeviceSize       srcOffset;
8212     VkDeviceSize       dstOffset;
8213     VkDeviceSize       size;
8214 } VkBufferCopy2KHR;
8215
8216 typedef struct VkCopyBufferInfo2KHR {
8217     VkStructureType            sType;
8218     const void*                pNext;
8219     VkBuffer                   srcBuffer;
8220     VkBuffer                   dstBuffer;
8221     uint32_t                   regionCount;
8222     const VkBufferCopy2KHR*    pRegions;
8223 } VkCopyBufferInfo2KHR;
8224
8225 typedef struct VkImageCopy2KHR {
8226     VkStructureType             sType;
8227     const void*                 pNext;
8228     VkImageSubresourceLayers    srcSubresource;
8229     VkOffset3D                  srcOffset;
8230     VkImageSubresourceLayers    dstSubresource;
8231     VkOffset3D                  dstOffset;
8232     VkExtent3D                  extent;
8233 } VkImageCopy2KHR;
8234
8235 typedef struct VkCopyImageInfo2KHR {
8236     VkStructureType           sType;
8237     const void*               pNext;
8238     VkImage                   srcImage;
8239     VkImageLayout             srcImageLayout;
8240     VkImage                   dstImage;
8241     VkImageLayout             dstImageLayout;
8242     uint32_t                  regionCount;
8243     const VkImageCopy2KHR*    pRegions;
8244 } VkCopyImageInfo2KHR;
8245
8246 typedef struct VkBufferImageCopy2KHR {
8247     VkStructureType             sType;
8248     const void*                 pNext;
8249     VkDeviceSize                bufferOffset;
8250     uint32_t                    bufferRowLength;
8251     uint32_t                    bufferImageHeight;
8252     VkImageSubresourceLayers    imageSubresource;
8253     VkOffset3D                  imageOffset;
8254     VkExtent3D                  imageExtent;
8255 } VkBufferImageCopy2KHR;
8256
8257 typedef struct VkCopyBufferToImageInfo2KHR {
8258     VkStructureType                 sType;
8259     const void*                     pNext;
8260     VkBuffer                        srcBuffer;
8261     VkImage                         dstImage;
8262     VkImageLayout                   dstImageLayout;
8263     uint32_t                        regionCount;
8264     const VkBufferImageCopy2KHR*    pRegions;
8265 } VkCopyBufferToImageInfo2KHR;
8266
8267 typedef struct VkCopyImageToBufferInfo2KHR {
8268     VkStructureType                 sType;
8269     const void*                     pNext;
8270     VkImage                         srcImage;
8271     VkImageLayout                   srcImageLayout;
8272     VkBuffer                        dstBuffer;
8273     uint32_t                        regionCount;
8274     const VkBufferImageCopy2KHR*    pRegions;
8275 } VkCopyImageToBufferInfo2KHR;
8276
8277 typedef struct VkImageBlit2KHR {
8278     VkStructureType             sType;
8279     const void*                 pNext;
8280     VkImageSubresourceLayers    srcSubresource;
8281     VkOffset3D                  srcOffsets[2];
8282     VkImageSubresourceLayers    dstSubresource;
8283     VkOffset3D                  dstOffsets[2];
8284 } VkImageBlit2KHR;
8285
8286 typedef struct VkBlitImageInfo2KHR {
8287     VkStructureType           sType;
8288     const void*               pNext;
8289     VkImage                   srcImage;
8290     VkImageLayout             srcImageLayout;
8291     VkImage                   dstImage;
8292     VkImageLayout             dstImageLayout;
8293     uint32_t                  regionCount;
8294     const VkImageBlit2KHR*    pRegions;
8295     VkFilter                  filter;
8296 } VkBlitImageInfo2KHR;
8297
8298 typedef struct VkImageResolve2KHR {
8299     VkStructureType             sType;
8300     const void*                 pNext;
8301     VkImageSubresourceLayers    srcSubresource;
8302     VkOffset3D                  srcOffset;
8303     VkImageSubresourceLayers    dstSubresource;
8304     VkOffset3D                  dstOffset;
8305     VkExtent3D                  extent;
8306 } VkImageResolve2KHR;
8307
8308 typedef struct VkResolveImageInfo2KHR {
8309     VkStructureType              sType;
8310     const void*                  pNext;
8311     VkImage                      srcImage;
8312     VkImageLayout                srcImageLayout;
8313     VkImage                      dstImage;
8314     VkImageLayout                dstImageLayout;
8315     uint32_t                     regionCount;
8316     const VkImageResolve2KHR*    pRegions;
8317 } VkResolveImageInfo2KHR;
8318
8319 typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer2KHR)(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2KHR* pCopyBufferInfo);
8320 typedef void (VKAPI_PTR *PFN_vkCmdCopyImage2KHR)(VkCommandBuffer commandBuffer, const VkCopyImageInfo2KHR* pCopyImageInfo);
8321 typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage2KHR)(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2KHR* pCopyBufferToImageInfo);
8322 typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer2KHR)(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2KHR* pCopyImageToBufferInfo);
8323 typedef void (VKAPI_PTR *PFN_vkCmdBlitImage2KHR)(VkCommandBuffer commandBuffer, const VkBlitImageInfo2KHR* pBlitImageInfo);
8324 typedef void (VKAPI_PTR *PFN_vkCmdResolveImage2KHR)(VkCommandBuffer commandBuffer, const VkResolveImageInfo2KHR* pResolveImageInfo);
8325
8326 #ifndef VK_NO_PROTOTYPES
8327 VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer2KHR(
8328     VkCommandBuffer                             commandBuffer,
8329     const VkCopyBufferInfo2KHR*                 pCopyBufferInfo);
8330
8331 VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage2KHR(
8332     VkCommandBuffer                             commandBuffer,
8333     const VkCopyImageInfo2KHR*                  pCopyImageInfo);
8334
8335 VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage2KHR(
8336     VkCommandBuffer                             commandBuffer,
8337     const VkCopyBufferToImageInfo2KHR*          pCopyBufferToImageInfo);
8338
8339 VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer2KHR(
8340     VkCommandBuffer                             commandBuffer,
8341     const VkCopyImageToBufferInfo2KHR*          pCopyImageToBufferInfo);
8342
8343 VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage2KHR(
8344     VkCommandBuffer                             commandBuffer,
8345     const VkBlitImageInfo2KHR*                  pBlitImageInfo);
8346
8347 VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage2KHR(
8348     VkCommandBuffer                             commandBuffer,
8349     const VkResolveImageInfo2KHR*               pResolveImageInfo);
8350 #endif
8351
8352
8353 #define VK_EXT_debug_report 1
8354 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT)
8355 #define VK_EXT_DEBUG_REPORT_SPEC_VERSION  10
8356 #define VK_EXT_DEBUG_REPORT_EXTENSION_NAME "VK_EXT_debug_report"
8357
8358 typedef enum VkDebugReportObjectTypeEXT {
8359     VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0,
8360     VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1,
8361     VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2,
8362     VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3,
8363     VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4,
8364     VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5,
8365     VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6,
8366     VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7,
8367     VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8,
8368     VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9,
8369     VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10,
8370     VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11,
8371     VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12,
8372     VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13,
8373     VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14,
8374     VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15,
8375     VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16,
8376     VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17,
8377     VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18,
8378     VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19,
8379     VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20,
8380     VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21,
8381     VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22,
8382     VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23,
8383     VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24,
8384     VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25,
8385     VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26,
8386     VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27,
8387     VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT = 28,
8388     VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT = 29,
8389     VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT = 30,
8390     VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT = 33,
8391     VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT = 1000156000,
8392     VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT = 1000085000,
8393     VK_DEBUG_REPORT_OBJECT_TYPE_CU_MODULE_NVX_EXT = 1000029000,
8394     VK_DEBUG_REPORT_OBJECT_TYPE_CU_FUNCTION_NVX_EXT = 1000029001,
8395     VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT = 1000150000,
8396     VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT = 1000165000,
8397     VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT,
8398     VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT,
8399     VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT,
8400     VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT,
8401     VK_DEBUG_REPORT_OBJECT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
8402 } VkDebugReportObjectTypeEXT;
8403
8404 typedef enum VkDebugReportFlagBitsEXT {
8405     VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 0x00000001,
8406     VK_DEBUG_REPORT_WARNING_BIT_EXT = 0x00000002,
8407     VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 0x00000004,
8408     VK_DEBUG_REPORT_ERROR_BIT_EXT = 0x00000008,
8409     VK_DEBUG_REPORT_DEBUG_BIT_EXT = 0x00000010,
8410     VK_DEBUG_REPORT_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
8411 } VkDebugReportFlagBitsEXT;
8412 typedef VkFlags VkDebugReportFlagsEXT;
8413 typedef VkBool32 (VKAPI_PTR *PFN_vkDebugReportCallbackEXT)(
8414     VkDebugReportFlagsEXT                       flags,
8415     VkDebugReportObjectTypeEXT                  objectType,
8416     uint64_t                                    object,
8417     size_t                                      location,
8418     int32_t                                     messageCode,
8419     const char*                                 pLayerPrefix,
8420     const char*                                 pMessage,
8421     void*                                       pUserData);
8422
8423 typedef struct VkDebugReportCallbackCreateInfoEXT {
8424     VkStructureType                 sType;
8425     const void*                     pNext;
8426     VkDebugReportFlagsEXT           flags;
8427     PFN_vkDebugReportCallbackEXT    pfnCallback;
8428     void*                           pUserData;
8429 } VkDebugReportCallbackCreateInfoEXT;
8430
8431 typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugReportCallbackEXT)(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback);
8432 typedef void (VKAPI_PTR *PFN_vkDestroyDebugReportCallbackEXT)(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator);
8433 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);
8434
8435 #ifndef VK_NO_PROTOTYPES
8436 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT(
8437     VkInstance                                  instance,
8438     const VkDebugReportCallbackCreateInfoEXT*   pCreateInfo,
8439     const VkAllocationCallbacks*                pAllocator,
8440     VkDebugReportCallbackEXT*                   pCallback);
8441
8442 VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT(
8443     VkInstance                                  instance,
8444     VkDebugReportCallbackEXT                    callback,
8445     const VkAllocationCallbacks*                pAllocator);
8446
8447 VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT(
8448     VkInstance                                  instance,
8449     VkDebugReportFlagsEXT                       flags,
8450     VkDebugReportObjectTypeEXT                  objectType,
8451     uint64_t                                    object,
8452     size_t                                      location,
8453     int32_t                                     messageCode,
8454     const char*                                 pLayerPrefix,
8455     const char*                                 pMessage);
8456 #endif
8457
8458
8459 #define VK_NV_glsl_shader 1
8460 #define VK_NV_GLSL_SHADER_SPEC_VERSION    1
8461 #define VK_NV_GLSL_SHADER_EXTENSION_NAME  "VK_NV_glsl_shader"
8462
8463
8464 #define VK_EXT_depth_range_unrestricted 1
8465 #define VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION 1
8466 #define VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME "VK_EXT_depth_range_unrestricted"
8467
8468
8469 #define VK_IMG_filter_cubic 1
8470 #define VK_IMG_FILTER_CUBIC_SPEC_VERSION  1
8471 #define VK_IMG_FILTER_CUBIC_EXTENSION_NAME "VK_IMG_filter_cubic"
8472
8473
8474 #define VK_AMD_rasterization_order 1
8475 #define VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION 1
8476 #define VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME "VK_AMD_rasterization_order"
8477
8478 typedef enum VkRasterizationOrderAMD {
8479     VK_RASTERIZATION_ORDER_STRICT_AMD = 0,
8480     VK_RASTERIZATION_ORDER_RELAXED_AMD = 1,
8481     VK_RASTERIZATION_ORDER_MAX_ENUM_AMD = 0x7FFFFFFF
8482 } VkRasterizationOrderAMD;
8483 typedef struct VkPipelineRasterizationStateRasterizationOrderAMD {
8484     VkStructureType            sType;
8485     const void*                pNext;
8486     VkRasterizationOrderAMD    rasterizationOrder;
8487 } VkPipelineRasterizationStateRasterizationOrderAMD;
8488
8489
8490
8491 #define VK_AMD_shader_trinary_minmax 1
8492 #define VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION 1
8493 #define VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME "VK_AMD_shader_trinary_minmax"
8494
8495
8496 #define VK_AMD_shader_explicit_vertex_parameter 1
8497 #define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION 1
8498 #define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME "VK_AMD_shader_explicit_vertex_parameter"
8499
8500
8501 #define VK_EXT_debug_marker 1
8502 #define VK_EXT_DEBUG_MARKER_SPEC_VERSION  4
8503 #define VK_EXT_DEBUG_MARKER_EXTENSION_NAME "VK_EXT_debug_marker"
8504 typedef struct VkDebugMarkerObjectNameInfoEXT {
8505     VkStructureType               sType;
8506     const void*                   pNext;
8507     VkDebugReportObjectTypeEXT    objectType;
8508     uint64_t                      object;
8509     const char*                   pObjectName;
8510 } VkDebugMarkerObjectNameInfoEXT;
8511
8512 typedef struct VkDebugMarkerObjectTagInfoEXT {
8513     VkStructureType               sType;
8514     const void*                   pNext;
8515     VkDebugReportObjectTypeEXT    objectType;
8516     uint64_t                      object;
8517     uint64_t                      tagName;
8518     size_t                        tagSize;
8519     const void*                   pTag;
8520 } VkDebugMarkerObjectTagInfoEXT;
8521
8522 typedef struct VkDebugMarkerMarkerInfoEXT {
8523     VkStructureType    sType;
8524     const void*        pNext;
8525     const char*        pMarkerName;
8526     float              color[4];
8527 } VkDebugMarkerMarkerInfoEXT;
8528
8529 typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectTagEXT)(VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo);
8530 typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectNameEXT)(VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo);
8531 typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerBeginEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
8532 typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerEndEXT)(VkCommandBuffer commandBuffer);
8533 typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerInsertEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
8534
8535 #ifndef VK_NO_PROTOTYPES
8536 VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectTagEXT(
8537     VkDevice                                    device,
8538     const VkDebugMarkerObjectTagInfoEXT*        pTagInfo);
8539
8540 VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectNameEXT(
8541     VkDevice                                    device,
8542     const VkDebugMarkerObjectNameInfoEXT*       pNameInfo);
8543
8544 VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerBeginEXT(
8545     VkCommandBuffer                             commandBuffer,
8546     const VkDebugMarkerMarkerInfoEXT*           pMarkerInfo);
8547
8548 VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerEndEXT(
8549     VkCommandBuffer                             commandBuffer);
8550
8551 VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerInsertEXT(
8552     VkCommandBuffer                             commandBuffer,
8553     const VkDebugMarkerMarkerInfoEXT*           pMarkerInfo);
8554 #endif
8555
8556
8557 #define VK_AMD_gcn_shader 1
8558 #define VK_AMD_GCN_SHADER_SPEC_VERSION    1
8559 #define VK_AMD_GCN_SHADER_EXTENSION_NAME  "VK_AMD_gcn_shader"
8560
8561
8562 #define VK_NV_dedicated_allocation 1
8563 #define VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION 1
8564 #define VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_NV_dedicated_allocation"
8565 typedef struct VkDedicatedAllocationImageCreateInfoNV {
8566     VkStructureType    sType;
8567     const void*        pNext;
8568     VkBool32           dedicatedAllocation;
8569 } VkDedicatedAllocationImageCreateInfoNV;
8570
8571 typedef struct VkDedicatedAllocationBufferCreateInfoNV {
8572     VkStructureType    sType;
8573     const void*        pNext;
8574     VkBool32           dedicatedAllocation;
8575 } VkDedicatedAllocationBufferCreateInfoNV;
8576
8577 typedef struct VkDedicatedAllocationMemoryAllocateInfoNV {
8578     VkStructureType    sType;
8579     const void*        pNext;
8580     VkImage            image;
8581     VkBuffer           buffer;
8582 } VkDedicatedAllocationMemoryAllocateInfoNV;
8583
8584
8585
8586 #define VK_EXT_transform_feedback 1
8587 #define VK_EXT_TRANSFORM_FEEDBACK_SPEC_VERSION 1
8588 #define VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME "VK_EXT_transform_feedback"
8589 typedef VkFlags VkPipelineRasterizationStateStreamCreateFlagsEXT;
8590 typedef struct VkPhysicalDeviceTransformFeedbackFeaturesEXT {
8591     VkStructureType    sType;
8592     void*              pNext;
8593     VkBool32           transformFeedback;
8594     VkBool32           geometryStreams;
8595 } VkPhysicalDeviceTransformFeedbackFeaturesEXT;
8596
8597 typedef struct VkPhysicalDeviceTransformFeedbackPropertiesEXT {
8598     VkStructureType    sType;
8599     void*              pNext;
8600     uint32_t           maxTransformFeedbackStreams;
8601     uint32_t           maxTransformFeedbackBuffers;
8602     VkDeviceSize       maxTransformFeedbackBufferSize;
8603     uint32_t           maxTransformFeedbackStreamDataSize;
8604     uint32_t           maxTransformFeedbackBufferDataSize;
8605     uint32_t           maxTransformFeedbackBufferDataStride;
8606     VkBool32           transformFeedbackQueries;
8607     VkBool32           transformFeedbackStreamsLinesTriangles;
8608     VkBool32           transformFeedbackRasterizationStreamSelect;
8609     VkBool32           transformFeedbackDraw;
8610 } VkPhysicalDeviceTransformFeedbackPropertiesEXT;
8611
8612 typedef struct VkPipelineRasterizationStateStreamCreateInfoEXT {
8613     VkStructureType                                     sType;
8614     const void*                                         pNext;
8615     VkPipelineRasterizationStateStreamCreateFlagsEXT    flags;
8616     uint32_t                                            rasterizationStream;
8617 } VkPipelineRasterizationStateStreamCreateInfoEXT;
8618
8619 typedef void (VKAPI_PTR *PFN_vkCmdBindTransformFeedbackBuffersEXT)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes);
8620 typedef void (VKAPI_PTR *PFN_vkCmdBeginTransformFeedbackEXT)(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets);
8621 typedef void (VKAPI_PTR *PFN_vkCmdEndTransformFeedbackEXT)(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets);
8622 typedef void (VKAPI_PTR *PFN_vkCmdBeginQueryIndexedEXT)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index);
8623 typedef void (VKAPI_PTR *PFN_vkCmdEndQueryIndexedEXT)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index);
8624 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectByteCountEXT)(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride);
8625
8626 #ifndef VK_NO_PROTOTYPES
8627 VKAPI_ATTR void VKAPI_CALL vkCmdBindTransformFeedbackBuffersEXT(
8628     VkCommandBuffer                             commandBuffer,
8629     uint32_t                                    firstBinding,
8630     uint32_t                                    bindingCount,
8631     const VkBuffer*                             pBuffers,
8632     const VkDeviceSize*                         pOffsets,
8633     const VkDeviceSize*                         pSizes);
8634
8635 VKAPI_ATTR void VKAPI_CALL vkCmdBeginTransformFeedbackEXT(
8636     VkCommandBuffer                             commandBuffer,
8637     uint32_t                                    firstCounterBuffer,
8638     uint32_t                                    counterBufferCount,
8639     const VkBuffer*                             pCounterBuffers,
8640     const VkDeviceSize*                         pCounterBufferOffsets);
8641
8642 VKAPI_ATTR void VKAPI_CALL vkCmdEndTransformFeedbackEXT(
8643     VkCommandBuffer                             commandBuffer,
8644     uint32_t                                    firstCounterBuffer,
8645     uint32_t                                    counterBufferCount,
8646     const VkBuffer*                             pCounterBuffers,
8647     const VkDeviceSize*                         pCounterBufferOffsets);
8648
8649 VKAPI_ATTR void VKAPI_CALL vkCmdBeginQueryIndexedEXT(
8650     VkCommandBuffer                             commandBuffer,
8651     VkQueryPool                                 queryPool,
8652     uint32_t                                    query,
8653     VkQueryControlFlags                         flags,
8654     uint32_t                                    index);
8655
8656 VKAPI_ATTR void VKAPI_CALL vkCmdEndQueryIndexedEXT(
8657     VkCommandBuffer                             commandBuffer,
8658     VkQueryPool                                 queryPool,
8659     uint32_t                                    query,
8660     uint32_t                                    index);
8661
8662 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectByteCountEXT(
8663     VkCommandBuffer                             commandBuffer,
8664     uint32_t                                    instanceCount,
8665     uint32_t                                    firstInstance,
8666     VkBuffer                                    counterBuffer,
8667     VkDeviceSize                                counterBufferOffset,
8668     uint32_t                                    counterOffset,
8669     uint32_t                                    vertexStride);
8670 #endif
8671
8672
8673 #define VK_NVX_binary_import 1
8674 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCuModuleNVX)
8675 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCuFunctionNVX)
8676 #define VK_NVX_BINARY_IMPORT_SPEC_VERSION 1
8677 #define VK_NVX_BINARY_IMPORT_EXTENSION_NAME "VK_NVX_binary_import"
8678 typedef struct VkCuModuleCreateInfoNVX {
8679     VkStructureType    sType;
8680     const void*        pNext;
8681     size_t             dataSize;
8682     const void*        pData;
8683 } VkCuModuleCreateInfoNVX;
8684
8685 typedef struct VkCuFunctionCreateInfoNVX {
8686     VkStructureType    sType;
8687     const void*        pNext;
8688     VkCuModuleNVX      module;
8689     const char*        pName;
8690 } VkCuFunctionCreateInfoNVX;
8691
8692 typedef struct VkCuLaunchInfoNVX {
8693     VkStructureType        sType;
8694     const void*            pNext;
8695     VkCuFunctionNVX        function;
8696     uint32_t               gridDimX;
8697     uint32_t               gridDimY;
8698     uint32_t               gridDimZ;
8699     uint32_t               blockDimX;
8700     uint32_t               blockDimY;
8701     uint32_t               blockDimZ;
8702     uint32_t               sharedMemBytes;
8703     size_t                 paramCount;
8704     const void* const *    pParams;
8705     size_t                 extraCount;
8706     const void* const *    pExtras;
8707 } VkCuLaunchInfoNVX;
8708
8709 typedef VkResult (VKAPI_PTR *PFN_vkCreateCuModuleNVX)(VkDevice device, const VkCuModuleCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuModuleNVX* pModule);
8710 typedef VkResult (VKAPI_PTR *PFN_vkCreateCuFunctionNVX)(VkDevice device, const VkCuFunctionCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuFunctionNVX* pFunction);
8711 typedef void (VKAPI_PTR *PFN_vkDestroyCuModuleNVX)(VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks* pAllocator);
8712 typedef void (VKAPI_PTR *PFN_vkDestroyCuFunctionNVX)(VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks* pAllocator);
8713 typedef void (VKAPI_PTR *PFN_vkCmdCuLaunchKernelNVX)(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX* pLaunchInfo);
8714
8715 #ifndef VK_NO_PROTOTYPES
8716 VKAPI_ATTR VkResult VKAPI_CALL vkCreateCuModuleNVX(
8717     VkDevice                                    device,
8718     const VkCuModuleCreateInfoNVX*              pCreateInfo,
8719     const VkAllocationCallbacks*                pAllocator,
8720     VkCuModuleNVX*                              pModule);
8721
8722 VKAPI_ATTR VkResult VKAPI_CALL vkCreateCuFunctionNVX(
8723     VkDevice                                    device,
8724     const VkCuFunctionCreateInfoNVX*            pCreateInfo,
8725     const VkAllocationCallbacks*                pAllocator,
8726     VkCuFunctionNVX*                            pFunction);
8727
8728 VKAPI_ATTR void VKAPI_CALL vkDestroyCuModuleNVX(
8729     VkDevice                                    device,
8730     VkCuModuleNVX                               module,
8731     const VkAllocationCallbacks*                pAllocator);
8732
8733 VKAPI_ATTR void VKAPI_CALL vkDestroyCuFunctionNVX(
8734     VkDevice                                    device,
8735     VkCuFunctionNVX                             function,
8736     const VkAllocationCallbacks*                pAllocator);
8737
8738 VKAPI_ATTR void VKAPI_CALL vkCmdCuLaunchKernelNVX(
8739     VkCommandBuffer                             commandBuffer,
8740     const VkCuLaunchInfoNVX*                    pLaunchInfo);
8741 #endif
8742
8743
8744 #define VK_NVX_image_view_handle 1
8745 #define VK_NVX_IMAGE_VIEW_HANDLE_SPEC_VERSION 2
8746 #define VK_NVX_IMAGE_VIEW_HANDLE_EXTENSION_NAME "VK_NVX_image_view_handle"
8747 typedef struct VkImageViewHandleInfoNVX {
8748     VkStructureType     sType;
8749     const void*         pNext;
8750     VkImageView         imageView;
8751     VkDescriptorType    descriptorType;
8752     VkSampler           sampler;
8753 } VkImageViewHandleInfoNVX;
8754
8755 typedef struct VkImageViewAddressPropertiesNVX {
8756     VkStructureType    sType;
8757     void*              pNext;
8758     VkDeviceAddress    deviceAddress;
8759     VkDeviceSize       size;
8760 } VkImageViewAddressPropertiesNVX;
8761
8762 typedef uint32_t (VKAPI_PTR *PFN_vkGetImageViewHandleNVX)(VkDevice device, const VkImageViewHandleInfoNVX* pInfo);
8763 typedef VkResult (VKAPI_PTR *PFN_vkGetImageViewAddressNVX)(VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX* pProperties);
8764
8765 #ifndef VK_NO_PROTOTYPES
8766 VKAPI_ATTR uint32_t VKAPI_CALL vkGetImageViewHandleNVX(
8767     VkDevice                                    device,
8768     const VkImageViewHandleInfoNVX*             pInfo);
8769
8770 VKAPI_ATTR VkResult VKAPI_CALL vkGetImageViewAddressNVX(
8771     VkDevice                                    device,
8772     VkImageView                                 imageView,
8773     VkImageViewAddressPropertiesNVX*            pProperties);
8774 #endif
8775
8776
8777 #define VK_AMD_draw_indirect_count 1
8778 #define VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION 2
8779 #define VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_AMD_draw_indirect_count"
8780 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
8781 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
8782
8783 #ifndef VK_NO_PROTOTYPES
8784 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountAMD(
8785     VkCommandBuffer                             commandBuffer,
8786     VkBuffer                                    buffer,
8787     VkDeviceSize                                offset,
8788     VkBuffer                                    countBuffer,
8789     VkDeviceSize                                countBufferOffset,
8790     uint32_t                                    maxDrawCount,
8791     uint32_t                                    stride);
8792
8793 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountAMD(
8794     VkCommandBuffer                             commandBuffer,
8795     VkBuffer                                    buffer,
8796     VkDeviceSize                                offset,
8797     VkBuffer                                    countBuffer,
8798     VkDeviceSize                                countBufferOffset,
8799     uint32_t                                    maxDrawCount,
8800     uint32_t                                    stride);
8801 #endif
8802
8803
8804 #define VK_AMD_negative_viewport_height 1
8805 #define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION 1
8806 #define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME "VK_AMD_negative_viewport_height"
8807
8808
8809 #define VK_AMD_gpu_shader_half_float 1
8810 #define VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION 2
8811 #define VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME "VK_AMD_gpu_shader_half_float"
8812
8813
8814 #define VK_AMD_shader_ballot 1
8815 #define VK_AMD_SHADER_BALLOT_SPEC_VERSION 1
8816 #define VK_AMD_SHADER_BALLOT_EXTENSION_NAME "VK_AMD_shader_ballot"
8817
8818
8819 #define VK_AMD_texture_gather_bias_lod 1
8820 #define VK_AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION 1
8821 #define VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME "VK_AMD_texture_gather_bias_lod"
8822 typedef struct VkTextureLODGatherFormatPropertiesAMD {
8823     VkStructureType    sType;
8824     void*              pNext;
8825     VkBool32           supportsTextureGatherLODBiasAMD;
8826 } VkTextureLODGatherFormatPropertiesAMD;
8827
8828
8829
8830 #define VK_AMD_shader_info 1
8831 #define VK_AMD_SHADER_INFO_SPEC_VERSION   1
8832 #define VK_AMD_SHADER_INFO_EXTENSION_NAME "VK_AMD_shader_info"
8833
8834 typedef enum VkShaderInfoTypeAMD {
8835     VK_SHADER_INFO_TYPE_STATISTICS_AMD = 0,
8836     VK_SHADER_INFO_TYPE_BINARY_AMD = 1,
8837     VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD = 2,
8838     VK_SHADER_INFO_TYPE_MAX_ENUM_AMD = 0x7FFFFFFF
8839 } VkShaderInfoTypeAMD;
8840 typedef struct VkShaderResourceUsageAMD {
8841     uint32_t    numUsedVgprs;
8842     uint32_t    numUsedSgprs;
8843     uint32_t    ldsSizePerLocalWorkGroup;
8844     size_t      ldsUsageSizeInBytes;
8845     size_t      scratchMemUsageInBytes;
8846 } VkShaderResourceUsageAMD;
8847
8848 typedef struct VkShaderStatisticsInfoAMD {
8849     VkShaderStageFlags          shaderStageMask;
8850     VkShaderResourceUsageAMD    resourceUsage;
8851     uint32_t                    numPhysicalVgprs;
8852     uint32_t                    numPhysicalSgprs;
8853     uint32_t                    numAvailableVgprs;
8854     uint32_t                    numAvailableSgprs;
8855     uint32_t                    computeWorkGroupSize[3];
8856 } VkShaderStatisticsInfoAMD;
8857
8858 typedef VkResult (VKAPI_PTR *PFN_vkGetShaderInfoAMD)(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo);
8859
8860 #ifndef VK_NO_PROTOTYPES
8861 VKAPI_ATTR VkResult VKAPI_CALL vkGetShaderInfoAMD(
8862     VkDevice                                    device,
8863     VkPipeline                                  pipeline,
8864     VkShaderStageFlagBits                       shaderStage,
8865     VkShaderInfoTypeAMD                         infoType,
8866     size_t*                                     pInfoSize,
8867     void*                                       pInfo);
8868 #endif
8869
8870
8871 #define VK_AMD_shader_image_load_store_lod 1
8872 #define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION 1
8873 #define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME "VK_AMD_shader_image_load_store_lod"
8874
8875
8876 #define VK_NV_corner_sampled_image 1
8877 #define VK_NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION 2
8878 #define VK_NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME "VK_NV_corner_sampled_image"
8879 typedef struct VkPhysicalDeviceCornerSampledImageFeaturesNV {
8880     VkStructureType    sType;
8881     void*              pNext;
8882     VkBool32           cornerSampledImage;
8883 } VkPhysicalDeviceCornerSampledImageFeaturesNV;
8884
8885
8886
8887 #define VK_IMG_format_pvrtc 1
8888 #define VK_IMG_FORMAT_PVRTC_SPEC_VERSION  1
8889 #define VK_IMG_FORMAT_PVRTC_EXTENSION_NAME "VK_IMG_format_pvrtc"
8890
8891
8892 #define VK_NV_external_memory_capabilities 1
8893 #define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1
8894 #define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_NV_external_memory_capabilities"
8895
8896 typedef enum VkExternalMemoryHandleTypeFlagBitsNV {
8897     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = 0x00000001,
8898     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = 0x00000002,
8899     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = 0x00000004,
8900     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = 0x00000008,
8901     VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
8902 } VkExternalMemoryHandleTypeFlagBitsNV;
8903 typedef VkFlags VkExternalMemoryHandleTypeFlagsNV;
8904
8905 typedef enum VkExternalMemoryFeatureFlagBitsNV {
8906     VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = 0x00000001,
8907     VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = 0x00000002,
8908     VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = 0x00000004,
8909     VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
8910 } VkExternalMemoryFeatureFlagBitsNV;
8911 typedef VkFlags VkExternalMemoryFeatureFlagsNV;
8912 typedef struct VkExternalImageFormatPropertiesNV {
8913     VkImageFormatProperties              imageFormatProperties;
8914     VkExternalMemoryFeatureFlagsNV       externalMemoryFeatures;
8915     VkExternalMemoryHandleTypeFlagsNV    exportFromImportedHandleTypes;
8916     VkExternalMemoryHandleTypeFlagsNV    compatibleHandleTypes;
8917 } VkExternalImageFormatPropertiesNV;
8918
8919 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties);
8920
8921 #ifndef VK_NO_PROTOTYPES
8922 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
8923     VkPhysicalDevice                            physicalDevice,
8924     VkFormat                                    format,
8925     VkImageType                                 type,
8926     VkImageTiling                               tiling,
8927     VkImageUsageFlags                           usage,
8928     VkImageCreateFlags                          flags,
8929     VkExternalMemoryHandleTypeFlagsNV           externalHandleType,
8930     VkExternalImageFormatPropertiesNV*          pExternalImageFormatProperties);
8931 #endif
8932
8933
8934 #define VK_NV_external_memory 1
8935 #define VK_NV_EXTERNAL_MEMORY_SPEC_VERSION 1
8936 #define VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME "VK_NV_external_memory"
8937 typedef struct VkExternalMemoryImageCreateInfoNV {
8938     VkStructureType                      sType;
8939     const void*                          pNext;
8940     VkExternalMemoryHandleTypeFlagsNV    handleTypes;
8941 } VkExternalMemoryImageCreateInfoNV;
8942
8943 typedef struct VkExportMemoryAllocateInfoNV {
8944     VkStructureType                      sType;
8945     const void*                          pNext;
8946     VkExternalMemoryHandleTypeFlagsNV    handleTypes;
8947 } VkExportMemoryAllocateInfoNV;
8948
8949
8950
8951 #define VK_EXT_validation_flags 1
8952 #define VK_EXT_VALIDATION_FLAGS_SPEC_VERSION 2
8953 #define VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME "VK_EXT_validation_flags"
8954
8955 typedef enum VkValidationCheckEXT {
8956     VK_VALIDATION_CHECK_ALL_EXT = 0,
8957     VK_VALIDATION_CHECK_SHADERS_EXT = 1,
8958     VK_VALIDATION_CHECK_MAX_ENUM_EXT = 0x7FFFFFFF
8959 } VkValidationCheckEXT;
8960 typedef struct VkValidationFlagsEXT {
8961     VkStructureType                sType;
8962     const void*                    pNext;
8963     uint32_t                       disabledValidationCheckCount;
8964     const VkValidationCheckEXT*    pDisabledValidationChecks;
8965 } VkValidationFlagsEXT;
8966
8967
8968
8969 #define VK_EXT_shader_subgroup_ballot 1
8970 #define VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION 1
8971 #define VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME "VK_EXT_shader_subgroup_ballot"
8972
8973
8974 #define VK_EXT_shader_subgroup_vote 1
8975 #define VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION 1
8976 #define VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME "VK_EXT_shader_subgroup_vote"
8977
8978
8979 #define VK_EXT_texture_compression_astc_hdr 1
8980 #define VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_SPEC_VERSION 1
8981 #define VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME "VK_EXT_texture_compression_astc_hdr"
8982 typedef struct VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT {
8983     VkStructureType    sType;
8984     void*              pNext;
8985     VkBool32           textureCompressionASTC_HDR;
8986 } VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT;
8987
8988
8989
8990 #define VK_EXT_astc_decode_mode 1
8991 #define VK_EXT_ASTC_DECODE_MODE_SPEC_VERSION 1
8992 #define VK_EXT_ASTC_DECODE_MODE_EXTENSION_NAME "VK_EXT_astc_decode_mode"
8993 typedef struct VkImageViewASTCDecodeModeEXT {
8994     VkStructureType    sType;
8995     const void*        pNext;
8996     VkFormat           decodeMode;
8997 } VkImageViewASTCDecodeModeEXT;
8998
8999 typedef struct VkPhysicalDeviceASTCDecodeFeaturesEXT {
9000     VkStructureType    sType;
9001     void*              pNext;
9002     VkBool32           decodeModeSharedExponent;
9003 } VkPhysicalDeviceASTCDecodeFeaturesEXT;
9004
9005
9006
9007 #define VK_EXT_conditional_rendering 1
9008 #define VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION 2
9009 #define VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME "VK_EXT_conditional_rendering"
9010
9011 typedef enum VkConditionalRenderingFlagBitsEXT {
9012     VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT = 0x00000001,
9013     VK_CONDITIONAL_RENDERING_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
9014 } VkConditionalRenderingFlagBitsEXT;
9015 typedef VkFlags VkConditionalRenderingFlagsEXT;
9016 typedef struct VkConditionalRenderingBeginInfoEXT {
9017     VkStructureType                   sType;
9018     const void*                       pNext;
9019     VkBuffer                          buffer;
9020     VkDeviceSize                      offset;
9021     VkConditionalRenderingFlagsEXT    flags;
9022 } VkConditionalRenderingBeginInfoEXT;
9023
9024 typedef struct VkPhysicalDeviceConditionalRenderingFeaturesEXT {
9025     VkStructureType    sType;
9026     void*              pNext;
9027     VkBool32           conditionalRendering;
9028     VkBool32           inheritedConditionalRendering;
9029 } VkPhysicalDeviceConditionalRenderingFeaturesEXT;
9030
9031 typedef struct VkCommandBufferInheritanceConditionalRenderingInfoEXT {
9032     VkStructureType    sType;
9033     const void*        pNext;
9034     VkBool32           conditionalRenderingEnable;
9035 } VkCommandBufferInheritanceConditionalRenderingInfoEXT;
9036
9037 typedef void (VKAPI_PTR *PFN_vkCmdBeginConditionalRenderingEXT)(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin);
9038 typedef void (VKAPI_PTR *PFN_vkCmdEndConditionalRenderingEXT)(VkCommandBuffer commandBuffer);
9039
9040 #ifndef VK_NO_PROTOTYPES
9041 VKAPI_ATTR void VKAPI_CALL vkCmdBeginConditionalRenderingEXT(
9042     VkCommandBuffer                             commandBuffer,
9043     const VkConditionalRenderingBeginInfoEXT*   pConditionalRenderingBegin);
9044
9045 VKAPI_ATTR void VKAPI_CALL vkCmdEndConditionalRenderingEXT(
9046     VkCommandBuffer                             commandBuffer);
9047 #endif
9048
9049
9050 #define VK_NV_clip_space_w_scaling 1
9051 #define VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION 1
9052 #define VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME "VK_NV_clip_space_w_scaling"
9053 typedef struct VkViewportWScalingNV {
9054     float    xcoeff;
9055     float    ycoeff;
9056 } VkViewportWScalingNV;
9057
9058 typedef struct VkPipelineViewportWScalingStateCreateInfoNV {
9059     VkStructureType                sType;
9060     const void*                    pNext;
9061     VkBool32                       viewportWScalingEnable;
9062     uint32_t                       viewportCount;
9063     const VkViewportWScalingNV*    pViewportWScalings;
9064 } VkPipelineViewportWScalingStateCreateInfoNV;
9065
9066 typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWScalingNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings);
9067
9068 #ifndef VK_NO_PROTOTYPES
9069 VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingNV(
9070     VkCommandBuffer                             commandBuffer,
9071     uint32_t                                    firstViewport,
9072     uint32_t                                    viewportCount,
9073     const VkViewportWScalingNV*                 pViewportWScalings);
9074 #endif
9075
9076
9077 #define VK_EXT_direct_mode_display 1
9078 #define VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION 1
9079 #define VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME "VK_EXT_direct_mode_display"
9080 typedef VkResult (VKAPI_PTR *PFN_vkReleaseDisplayEXT)(VkPhysicalDevice physicalDevice, VkDisplayKHR display);
9081
9082 #ifndef VK_NO_PROTOTYPES
9083 VKAPI_ATTR VkResult VKAPI_CALL vkReleaseDisplayEXT(
9084     VkPhysicalDevice                            physicalDevice,
9085     VkDisplayKHR                                display);
9086 #endif
9087
9088
9089 #define VK_EXT_display_surface_counter 1
9090 #define VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION 1
9091 #define VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME "VK_EXT_display_surface_counter"
9092
9093 typedef enum VkSurfaceCounterFlagBitsEXT {
9094     VK_SURFACE_COUNTER_VBLANK_BIT_EXT = 0x00000001,
9095     VK_SURFACE_COUNTER_VBLANK_EXT = VK_SURFACE_COUNTER_VBLANK_BIT_EXT,
9096     VK_SURFACE_COUNTER_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
9097 } VkSurfaceCounterFlagBitsEXT;
9098 typedef VkFlags VkSurfaceCounterFlagsEXT;
9099 typedef struct VkSurfaceCapabilities2EXT {
9100     VkStructureType                  sType;
9101     void*                            pNext;
9102     uint32_t                         minImageCount;
9103     uint32_t                         maxImageCount;
9104     VkExtent2D                       currentExtent;
9105     VkExtent2D                       minImageExtent;
9106     VkExtent2D                       maxImageExtent;
9107     uint32_t                         maxImageArrayLayers;
9108     VkSurfaceTransformFlagsKHR       supportedTransforms;
9109     VkSurfaceTransformFlagBitsKHR    currentTransform;
9110     VkCompositeAlphaFlagsKHR         supportedCompositeAlpha;
9111     VkImageUsageFlags                supportedUsageFlags;
9112     VkSurfaceCounterFlagsEXT         supportedSurfaceCounters;
9113 } VkSurfaceCapabilities2EXT;
9114
9115 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities);
9116
9117 #ifndef VK_NO_PROTOTYPES
9118 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2EXT(
9119     VkPhysicalDevice                            physicalDevice,
9120     VkSurfaceKHR                                surface,
9121     VkSurfaceCapabilities2EXT*                  pSurfaceCapabilities);
9122 #endif
9123
9124
9125 #define VK_EXT_display_control 1
9126 #define VK_EXT_DISPLAY_CONTROL_SPEC_VERSION 1
9127 #define VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME "VK_EXT_display_control"
9128
9129 typedef enum VkDisplayPowerStateEXT {
9130     VK_DISPLAY_POWER_STATE_OFF_EXT = 0,
9131     VK_DISPLAY_POWER_STATE_SUSPEND_EXT = 1,
9132     VK_DISPLAY_POWER_STATE_ON_EXT = 2,
9133     VK_DISPLAY_POWER_STATE_MAX_ENUM_EXT = 0x7FFFFFFF
9134 } VkDisplayPowerStateEXT;
9135
9136 typedef enum VkDeviceEventTypeEXT {
9137     VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT = 0,
9138     VK_DEVICE_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
9139 } VkDeviceEventTypeEXT;
9140
9141 typedef enum VkDisplayEventTypeEXT {
9142     VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT = 0,
9143     VK_DISPLAY_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
9144 } VkDisplayEventTypeEXT;
9145 typedef struct VkDisplayPowerInfoEXT {
9146     VkStructureType           sType;
9147     const void*               pNext;
9148     VkDisplayPowerStateEXT    powerState;
9149 } VkDisplayPowerInfoEXT;
9150
9151 typedef struct VkDeviceEventInfoEXT {
9152     VkStructureType         sType;
9153     const void*             pNext;
9154     VkDeviceEventTypeEXT    deviceEvent;
9155 } VkDeviceEventInfoEXT;
9156
9157 typedef struct VkDisplayEventInfoEXT {
9158     VkStructureType          sType;
9159     const void*              pNext;
9160     VkDisplayEventTypeEXT    displayEvent;
9161 } VkDisplayEventInfoEXT;
9162
9163 typedef struct VkSwapchainCounterCreateInfoEXT {
9164     VkStructureType             sType;
9165     const void*                 pNext;
9166     VkSurfaceCounterFlagsEXT    surfaceCounters;
9167 } VkSwapchainCounterCreateInfoEXT;
9168
9169 typedef VkResult (VKAPI_PTR *PFN_vkDisplayPowerControlEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo);
9170 typedef VkResult (VKAPI_PTR *PFN_vkRegisterDeviceEventEXT)(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
9171 typedef VkResult (VKAPI_PTR *PFN_vkRegisterDisplayEventEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
9172 typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainCounterEXT)(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue);
9173
9174 #ifndef VK_NO_PROTOTYPES
9175 VKAPI_ATTR VkResult VKAPI_CALL vkDisplayPowerControlEXT(
9176     VkDevice                                    device,
9177     VkDisplayKHR                                display,
9178     const VkDisplayPowerInfoEXT*                pDisplayPowerInfo);
9179
9180 VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDeviceEventEXT(
9181     VkDevice                                    device,
9182     const VkDeviceEventInfoEXT*                 pDeviceEventInfo,
9183     const VkAllocationCallbacks*                pAllocator,
9184     VkFence*                                    pFence);
9185
9186 VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDisplayEventEXT(
9187     VkDevice                                    device,
9188     VkDisplayKHR                                display,
9189     const VkDisplayEventInfoEXT*                pDisplayEventInfo,
9190     const VkAllocationCallbacks*                pAllocator,
9191     VkFence*                                    pFence);
9192
9193 VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainCounterEXT(
9194     VkDevice                                    device,
9195     VkSwapchainKHR                              swapchain,
9196     VkSurfaceCounterFlagBitsEXT                 counter,
9197     uint64_t*                                   pCounterValue);
9198 #endif
9199
9200
9201 #define VK_GOOGLE_display_timing 1
9202 #define VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION 1
9203 #define VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME "VK_GOOGLE_display_timing"
9204 typedef struct VkRefreshCycleDurationGOOGLE {
9205     uint64_t    refreshDuration;
9206 } VkRefreshCycleDurationGOOGLE;
9207
9208 typedef struct VkPastPresentationTimingGOOGLE {
9209     uint32_t    presentID;
9210     uint64_t    desiredPresentTime;
9211     uint64_t    actualPresentTime;
9212     uint64_t    earliestPresentTime;
9213     uint64_t    presentMargin;
9214 } VkPastPresentationTimingGOOGLE;
9215
9216 typedef struct VkPresentTimeGOOGLE {
9217     uint32_t    presentID;
9218     uint64_t    desiredPresentTime;
9219 } VkPresentTimeGOOGLE;
9220
9221 typedef struct VkPresentTimesInfoGOOGLE {
9222     VkStructureType               sType;
9223     const void*                   pNext;
9224     uint32_t                      swapchainCount;
9225     const VkPresentTimeGOOGLE*    pTimes;
9226 } VkPresentTimesInfoGOOGLE;
9227
9228 typedef VkResult (VKAPI_PTR *PFN_vkGetRefreshCycleDurationGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties);
9229 typedef VkResult (VKAPI_PTR *PFN_vkGetPastPresentationTimingGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings);
9230
9231 #ifndef VK_NO_PROTOTYPES
9232 VKAPI_ATTR VkResult VKAPI_CALL vkGetRefreshCycleDurationGOOGLE(
9233     VkDevice                                    device,
9234     VkSwapchainKHR                              swapchain,
9235     VkRefreshCycleDurationGOOGLE*               pDisplayTimingProperties);
9236
9237 VKAPI_ATTR VkResult VKAPI_CALL vkGetPastPresentationTimingGOOGLE(
9238     VkDevice                                    device,
9239     VkSwapchainKHR                              swapchain,
9240     uint32_t*                                   pPresentationTimingCount,
9241     VkPastPresentationTimingGOOGLE*             pPresentationTimings);
9242 #endif
9243
9244
9245 #define VK_NV_sample_mask_override_coverage 1
9246 #define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION 1
9247 #define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME "VK_NV_sample_mask_override_coverage"
9248
9249
9250 #define VK_NV_geometry_shader_passthrough 1
9251 #define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION 1
9252 #define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME "VK_NV_geometry_shader_passthrough"
9253
9254
9255 #define VK_NV_viewport_array2 1
9256 #define VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION 1
9257 #define VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME "VK_NV_viewport_array2"
9258
9259
9260 #define VK_NVX_multiview_per_view_attributes 1
9261 #define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION 1
9262 #define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME "VK_NVX_multiview_per_view_attributes"
9263 typedef struct VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
9264     VkStructureType    sType;
9265     void*              pNext;
9266     VkBool32           perViewPositionAllComponents;
9267 } VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
9268
9269
9270
9271 #define VK_NV_viewport_swizzle 1
9272 #define VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION 1
9273 #define VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME "VK_NV_viewport_swizzle"
9274
9275 typedef enum VkViewportCoordinateSwizzleNV {
9276     VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV = 0,
9277     VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV = 1,
9278     VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV = 2,
9279     VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV = 3,
9280     VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV = 4,
9281     VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV = 5,
9282     VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV = 6,
9283     VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV = 7,
9284     VK_VIEWPORT_COORDINATE_SWIZZLE_MAX_ENUM_NV = 0x7FFFFFFF
9285 } VkViewportCoordinateSwizzleNV;
9286 typedef VkFlags VkPipelineViewportSwizzleStateCreateFlagsNV;
9287 typedef struct VkViewportSwizzleNV {
9288     VkViewportCoordinateSwizzleNV    x;
9289     VkViewportCoordinateSwizzleNV    y;
9290     VkViewportCoordinateSwizzleNV    z;
9291     VkViewportCoordinateSwizzleNV    w;
9292 } VkViewportSwizzleNV;
9293
9294 typedef struct VkPipelineViewportSwizzleStateCreateInfoNV {
9295     VkStructureType                                sType;
9296     const void*                                    pNext;
9297     VkPipelineViewportSwizzleStateCreateFlagsNV    flags;
9298     uint32_t                                       viewportCount;
9299     const VkViewportSwizzleNV*                     pViewportSwizzles;
9300 } VkPipelineViewportSwizzleStateCreateInfoNV;
9301
9302
9303
9304 #define VK_EXT_discard_rectangles 1
9305 #define VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION 1
9306 #define VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME "VK_EXT_discard_rectangles"
9307
9308 typedef enum VkDiscardRectangleModeEXT {
9309     VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = 0,
9310     VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = 1,
9311     VK_DISCARD_RECTANGLE_MODE_MAX_ENUM_EXT = 0x7FFFFFFF
9312 } VkDiscardRectangleModeEXT;
9313 typedef VkFlags VkPipelineDiscardRectangleStateCreateFlagsEXT;
9314 typedef struct VkPhysicalDeviceDiscardRectanglePropertiesEXT {
9315     VkStructureType    sType;
9316     void*              pNext;
9317     uint32_t           maxDiscardRectangles;
9318 } VkPhysicalDeviceDiscardRectanglePropertiesEXT;
9319
9320 typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT {
9321     VkStructureType                                  sType;
9322     const void*                                      pNext;
9323     VkPipelineDiscardRectangleStateCreateFlagsEXT    flags;
9324     VkDiscardRectangleModeEXT                        discardRectangleMode;
9325     uint32_t                                         discardRectangleCount;
9326     const VkRect2D*                                  pDiscardRectangles;
9327 } VkPipelineDiscardRectangleStateCreateInfoEXT;
9328
9329 typedef void (VKAPI_PTR *PFN_vkCmdSetDiscardRectangleEXT)(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles);
9330
9331 #ifndef VK_NO_PROTOTYPES
9332 VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEXT(
9333     VkCommandBuffer                             commandBuffer,
9334     uint32_t                                    firstDiscardRectangle,
9335     uint32_t                                    discardRectangleCount,
9336     const VkRect2D*                             pDiscardRectangles);
9337 #endif
9338
9339
9340 #define VK_EXT_conservative_rasterization 1
9341 #define VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION 1
9342 #define VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME "VK_EXT_conservative_rasterization"
9343
9344 typedef enum VkConservativeRasterizationModeEXT {
9345     VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT = 0,
9346     VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT = 1,
9347     VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT = 2,
9348     VK_CONSERVATIVE_RASTERIZATION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF
9349 } VkConservativeRasterizationModeEXT;
9350 typedef VkFlags VkPipelineRasterizationConservativeStateCreateFlagsEXT;
9351 typedef struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT {
9352     VkStructureType    sType;
9353     void*              pNext;
9354     float              primitiveOverestimationSize;
9355     float              maxExtraPrimitiveOverestimationSize;
9356     float              extraPrimitiveOverestimationSizeGranularity;
9357     VkBool32           primitiveUnderestimation;
9358     VkBool32           conservativePointAndLineRasterization;
9359     VkBool32           degenerateTrianglesRasterized;
9360     VkBool32           degenerateLinesRasterized;
9361     VkBool32           fullyCoveredFragmentShaderInputVariable;
9362     VkBool32           conservativeRasterizationPostDepthCoverage;
9363 } VkPhysicalDeviceConservativeRasterizationPropertiesEXT;
9364
9365 typedef struct VkPipelineRasterizationConservativeStateCreateInfoEXT {
9366     VkStructureType                                           sType;
9367     const void*                                               pNext;
9368     VkPipelineRasterizationConservativeStateCreateFlagsEXT    flags;
9369     VkConservativeRasterizationModeEXT                        conservativeRasterizationMode;
9370     float                                                     extraPrimitiveOverestimationSize;
9371 } VkPipelineRasterizationConservativeStateCreateInfoEXT;
9372
9373
9374
9375 #define VK_EXT_depth_clip_enable 1
9376 #define VK_EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION 1
9377 #define VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME "VK_EXT_depth_clip_enable"
9378 typedef VkFlags VkPipelineRasterizationDepthClipStateCreateFlagsEXT;
9379 typedef struct VkPhysicalDeviceDepthClipEnableFeaturesEXT {
9380     VkStructureType    sType;
9381     void*              pNext;
9382     VkBool32           depthClipEnable;
9383 } VkPhysicalDeviceDepthClipEnableFeaturesEXT;
9384
9385 typedef struct VkPipelineRasterizationDepthClipStateCreateInfoEXT {
9386     VkStructureType                                        sType;
9387     const void*                                            pNext;
9388     VkPipelineRasterizationDepthClipStateCreateFlagsEXT    flags;
9389     VkBool32                                               depthClipEnable;
9390 } VkPipelineRasterizationDepthClipStateCreateInfoEXT;
9391
9392
9393
9394 #define VK_EXT_swapchain_colorspace 1
9395 #define VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION 4
9396 #define VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME "VK_EXT_swapchain_colorspace"
9397
9398
9399 #define VK_EXT_hdr_metadata 1
9400 #define VK_EXT_HDR_METADATA_SPEC_VERSION  2
9401 #define VK_EXT_HDR_METADATA_EXTENSION_NAME "VK_EXT_hdr_metadata"
9402 typedef struct VkXYColorEXT {
9403     float    x;
9404     float    y;
9405 } VkXYColorEXT;
9406
9407 typedef struct VkHdrMetadataEXT {
9408     VkStructureType    sType;
9409     const void*        pNext;
9410     VkXYColorEXT       displayPrimaryRed;
9411     VkXYColorEXT       displayPrimaryGreen;
9412     VkXYColorEXT       displayPrimaryBlue;
9413     VkXYColorEXT       whitePoint;
9414     float              maxLuminance;
9415     float              minLuminance;
9416     float              maxContentLightLevel;
9417     float              maxFrameAverageLightLevel;
9418 } VkHdrMetadataEXT;
9419
9420 typedef void (VKAPI_PTR *PFN_vkSetHdrMetadataEXT)(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata);
9421
9422 #ifndef VK_NO_PROTOTYPES
9423 VKAPI_ATTR void VKAPI_CALL vkSetHdrMetadataEXT(
9424     VkDevice                                    device,
9425     uint32_t                                    swapchainCount,
9426     const VkSwapchainKHR*                       pSwapchains,
9427     const VkHdrMetadataEXT*                     pMetadata);
9428 #endif
9429
9430
9431 #define VK_EXT_external_memory_dma_buf 1
9432 #define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION 1
9433 #define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME "VK_EXT_external_memory_dma_buf"
9434
9435
9436 #define VK_EXT_queue_family_foreign 1
9437 #define VK_EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION 1
9438 #define VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME "VK_EXT_queue_family_foreign"
9439 #define VK_QUEUE_FAMILY_FOREIGN_EXT       (~2U)
9440
9441
9442 #define VK_EXT_debug_utils 1
9443 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugUtilsMessengerEXT)
9444 #define VK_EXT_DEBUG_UTILS_SPEC_VERSION   2
9445 #define VK_EXT_DEBUG_UTILS_EXTENSION_NAME "VK_EXT_debug_utils"
9446 typedef VkFlags VkDebugUtilsMessengerCallbackDataFlagsEXT;
9447
9448 typedef enum VkDebugUtilsMessageSeverityFlagBitsEXT {
9449     VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT = 0x00000001,
9450     VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT = 0x00000010,
9451     VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT = 0x00000100,
9452     VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT = 0x00001000,
9453     VK_DEBUG_UTILS_MESSAGE_SEVERITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
9454 } VkDebugUtilsMessageSeverityFlagBitsEXT;
9455
9456 typedef enum VkDebugUtilsMessageTypeFlagBitsEXT {
9457     VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT = 0x00000001,
9458     VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT = 0x00000002,
9459     VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT = 0x00000004,
9460     VK_DEBUG_UTILS_MESSAGE_TYPE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
9461 } VkDebugUtilsMessageTypeFlagBitsEXT;
9462 typedef VkFlags VkDebugUtilsMessageTypeFlagsEXT;
9463 typedef VkFlags VkDebugUtilsMessageSeverityFlagsEXT;
9464 typedef VkFlags VkDebugUtilsMessengerCreateFlagsEXT;
9465 typedef struct VkDebugUtilsLabelEXT {
9466     VkStructureType    sType;
9467     const void*        pNext;
9468     const char*        pLabelName;
9469     float              color[4];
9470 } VkDebugUtilsLabelEXT;
9471
9472 typedef struct VkDebugUtilsObjectNameInfoEXT {
9473     VkStructureType    sType;
9474     const void*        pNext;
9475     VkObjectType       objectType;
9476     uint64_t           objectHandle;
9477     const char*        pObjectName;
9478 } VkDebugUtilsObjectNameInfoEXT;
9479
9480 typedef struct VkDebugUtilsMessengerCallbackDataEXT {
9481     VkStructureType                              sType;
9482     const void*                                  pNext;
9483     VkDebugUtilsMessengerCallbackDataFlagsEXT    flags;
9484     const char*                                  pMessageIdName;
9485     int32_t                                      messageIdNumber;
9486     const char*                                  pMessage;
9487     uint32_t                                     queueLabelCount;
9488     const VkDebugUtilsLabelEXT*                  pQueueLabels;
9489     uint32_t                                     cmdBufLabelCount;
9490     const VkDebugUtilsLabelEXT*                  pCmdBufLabels;
9491     uint32_t                                     objectCount;
9492     const VkDebugUtilsObjectNameInfoEXT*         pObjects;
9493 } VkDebugUtilsMessengerCallbackDataEXT;
9494
9495 typedef VkBool32 (VKAPI_PTR *PFN_vkDebugUtilsMessengerCallbackEXT)(
9496     VkDebugUtilsMessageSeverityFlagBitsEXT           messageSeverity,
9497     VkDebugUtilsMessageTypeFlagsEXT                  messageTypes,
9498     const VkDebugUtilsMessengerCallbackDataEXT*      pCallbackData,
9499     void*                                            pUserData);
9500
9501 typedef struct VkDebugUtilsMessengerCreateInfoEXT {
9502     VkStructureType                         sType;
9503     const void*                             pNext;
9504     VkDebugUtilsMessengerCreateFlagsEXT     flags;
9505     VkDebugUtilsMessageSeverityFlagsEXT     messageSeverity;
9506     VkDebugUtilsMessageTypeFlagsEXT         messageType;
9507     PFN_vkDebugUtilsMessengerCallbackEXT    pfnUserCallback;
9508     void*                                   pUserData;
9509 } VkDebugUtilsMessengerCreateInfoEXT;
9510
9511 typedef struct VkDebugUtilsObjectTagInfoEXT {
9512     VkStructureType    sType;
9513     const void*        pNext;
9514     VkObjectType       objectType;
9515     uint64_t           objectHandle;
9516     uint64_t           tagName;
9517     size_t             tagSize;
9518     const void*        pTag;
9519 } VkDebugUtilsObjectTagInfoEXT;
9520
9521 typedef VkResult (VKAPI_PTR *PFN_vkSetDebugUtilsObjectNameEXT)(VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo);
9522 typedef VkResult (VKAPI_PTR *PFN_vkSetDebugUtilsObjectTagEXT)(VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo);
9523 typedef void (VKAPI_PTR *PFN_vkQueueBeginDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo);
9524 typedef void (VKAPI_PTR *PFN_vkQueueEndDebugUtilsLabelEXT)(VkQueue queue);
9525 typedef void (VKAPI_PTR *PFN_vkQueueInsertDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo);
9526 typedef void (VKAPI_PTR *PFN_vkCmdBeginDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo);
9527 typedef void (VKAPI_PTR *PFN_vkCmdEndDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer);
9528 typedef void (VKAPI_PTR *PFN_vkCmdInsertDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo);
9529 typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugUtilsMessengerEXT)(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger);
9530 typedef void (VKAPI_PTR *PFN_vkDestroyDebugUtilsMessengerEXT)(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator);
9531 typedef void (VKAPI_PTR *PFN_vkSubmitDebugUtilsMessageEXT)(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData);
9532
9533 #ifndef VK_NO_PROTOTYPES
9534 VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectNameEXT(
9535     VkDevice                                    device,
9536     const VkDebugUtilsObjectNameInfoEXT*        pNameInfo);
9537
9538 VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectTagEXT(
9539     VkDevice                                    device,
9540     const VkDebugUtilsObjectTagInfoEXT*         pTagInfo);
9541
9542 VKAPI_ATTR void VKAPI_CALL vkQueueBeginDebugUtilsLabelEXT(
9543     VkQueue                                     queue,
9544     const VkDebugUtilsLabelEXT*                 pLabelInfo);
9545
9546 VKAPI_ATTR void VKAPI_CALL vkQueueEndDebugUtilsLabelEXT(
9547     VkQueue                                     queue);
9548
9549 VKAPI_ATTR void VKAPI_CALL vkQueueInsertDebugUtilsLabelEXT(
9550     VkQueue                                     queue,
9551     const VkDebugUtilsLabelEXT*                 pLabelInfo);
9552
9553 VKAPI_ATTR void VKAPI_CALL vkCmdBeginDebugUtilsLabelEXT(
9554     VkCommandBuffer                             commandBuffer,
9555     const VkDebugUtilsLabelEXT*                 pLabelInfo);
9556
9557 VKAPI_ATTR void VKAPI_CALL vkCmdEndDebugUtilsLabelEXT(
9558     VkCommandBuffer                             commandBuffer);
9559
9560 VKAPI_ATTR void VKAPI_CALL vkCmdInsertDebugUtilsLabelEXT(
9561     VkCommandBuffer                             commandBuffer,
9562     const VkDebugUtilsLabelEXT*                 pLabelInfo);
9563
9564 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugUtilsMessengerEXT(
9565     VkInstance                                  instance,
9566     const VkDebugUtilsMessengerCreateInfoEXT*   pCreateInfo,
9567     const VkAllocationCallbacks*                pAllocator,
9568     VkDebugUtilsMessengerEXT*                   pMessenger);
9569
9570 VKAPI_ATTR void VKAPI_CALL vkDestroyDebugUtilsMessengerEXT(
9571     VkInstance                                  instance,
9572     VkDebugUtilsMessengerEXT                    messenger,
9573     const VkAllocationCallbacks*                pAllocator);
9574
9575 VKAPI_ATTR void VKAPI_CALL vkSubmitDebugUtilsMessageEXT(
9576     VkInstance                                  instance,
9577     VkDebugUtilsMessageSeverityFlagBitsEXT      messageSeverity,
9578     VkDebugUtilsMessageTypeFlagsEXT             messageTypes,
9579     const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData);
9580 #endif
9581
9582
9583 #define VK_EXT_sampler_filter_minmax 1
9584 #define VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION 2
9585 #define VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME "VK_EXT_sampler_filter_minmax"
9586 typedef VkSamplerReductionMode VkSamplerReductionModeEXT;
9587
9588 typedef VkSamplerReductionModeCreateInfo VkSamplerReductionModeCreateInfoEXT;
9589
9590 typedef VkPhysicalDeviceSamplerFilterMinmaxProperties VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT;
9591
9592
9593
9594 #define VK_AMD_gpu_shader_int16 1
9595 #define VK_AMD_GPU_SHADER_INT16_SPEC_VERSION 2
9596 #define VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME "VK_AMD_gpu_shader_int16"
9597
9598
9599 #define VK_AMD_mixed_attachment_samples 1
9600 #define VK_AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION 1
9601 #define VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME "VK_AMD_mixed_attachment_samples"
9602
9603
9604 #define VK_AMD_shader_fragment_mask 1
9605 #define VK_AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION 1
9606 #define VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME "VK_AMD_shader_fragment_mask"
9607
9608
9609 #define VK_EXT_inline_uniform_block 1
9610 #define VK_EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION 1
9611 #define VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME "VK_EXT_inline_uniform_block"
9612 typedef struct VkPhysicalDeviceInlineUniformBlockFeaturesEXT {
9613     VkStructureType    sType;
9614     void*              pNext;
9615     VkBool32           inlineUniformBlock;
9616     VkBool32           descriptorBindingInlineUniformBlockUpdateAfterBind;
9617 } VkPhysicalDeviceInlineUniformBlockFeaturesEXT;
9618
9619 typedef struct VkPhysicalDeviceInlineUniformBlockPropertiesEXT {
9620     VkStructureType    sType;
9621     void*              pNext;
9622     uint32_t           maxInlineUniformBlockSize;
9623     uint32_t           maxPerStageDescriptorInlineUniformBlocks;
9624     uint32_t           maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
9625     uint32_t           maxDescriptorSetInlineUniformBlocks;
9626     uint32_t           maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
9627 } VkPhysicalDeviceInlineUniformBlockPropertiesEXT;
9628
9629 typedef struct VkWriteDescriptorSetInlineUniformBlockEXT {
9630     VkStructureType    sType;
9631     const void*        pNext;
9632     uint32_t           dataSize;
9633     const void*        pData;
9634 } VkWriteDescriptorSetInlineUniformBlockEXT;
9635
9636 typedef struct VkDescriptorPoolInlineUniformBlockCreateInfoEXT {
9637     VkStructureType    sType;
9638     const void*        pNext;
9639     uint32_t           maxInlineUniformBlockBindings;
9640 } VkDescriptorPoolInlineUniformBlockCreateInfoEXT;
9641
9642
9643
9644 #define VK_EXT_shader_stencil_export 1
9645 #define VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION 1
9646 #define VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME "VK_EXT_shader_stencil_export"
9647
9648
9649 #define VK_EXT_sample_locations 1
9650 #define VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION 1
9651 #define VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME "VK_EXT_sample_locations"
9652 typedef struct VkSampleLocationEXT {
9653     float    x;
9654     float    y;
9655 } VkSampleLocationEXT;
9656
9657 typedef struct VkSampleLocationsInfoEXT {
9658     VkStructureType               sType;
9659     const void*                   pNext;
9660     VkSampleCountFlagBits         sampleLocationsPerPixel;
9661     VkExtent2D                    sampleLocationGridSize;
9662     uint32_t                      sampleLocationsCount;
9663     const VkSampleLocationEXT*    pSampleLocations;
9664 } VkSampleLocationsInfoEXT;
9665
9666 typedef struct VkAttachmentSampleLocationsEXT {
9667     uint32_t                    attachmentIndex;
9668     VkSampleLocationsInfoEXT    sampleLocationsInfo;
9669 } VkAttachmentSampleLocationsEXT;
9670
9671 typedef struct VkSubpassSampleLocationsEXT {
9672     uint32_t                    subpassIndex;
9673     VkSampleLocationsInfoEXT    sampleLocationsInfo;
9674 } VkSubpassSampleLocationsEXT;
9675
9676 typedef struct VkRenderPassSampleLocationsBeginInfoEXT {
9677     VkStructureType                          sType;
9678     const void*                              pNext;
9679     uint32_t                                 attachmentInitialSampleLocationsCount;
9680     const VkAttachmentSampleLocationsEXT*    pAttachmentInitialSampleLocations;
9681     uint32_t                                 postSubpassSampleLocationsCount;
9682     const VkSubpassSampleLocationsEXT*       pPostSubpassSampleLocations;
9683 } VkRenderPassSampleLocationsBeginInfoEXT;
9684
9685 typedef struct VkPipelineSampleLocationsStateCreateInfoEXT {
9686     VkStructureType             sType;
9687     const void*                 pNext;
9688     VkBool32                    sampleLocationsEnable;
9689     VkSampleLocationsInfoEXT    sampleLocationsInfo;
9690 } VkPipelineSampleLocationsStateCreateInfoEXT;
9691
9692 typedef struct VkPhysicalDeviceSampleLocationsPropertiesEXT {
9693     VkStructureType       sType;
9694     void*                 pNext;
9695     VkSampleCountFlags    sampleLocationSampleCounts;
9696     VkExtent2D            maxSampleLocationGridSize;
9697     float                 sampleLocationCoordinateRange[2];
9698     uint32_t              sampleLocationSubPixelBits;
9699     VkBool32              variableSampleLocations;
9700 } VkPhysicalDeviceSampleLocationsPropertiesEXT;
9701
9702 typedef struct VkMultisamplePropertiesEXT {
9703     VkStructureType    sType;
9704     void*              pNext;
9705     VkExtent2D         maxSampleLocationGridSize;
9706 } VkMultisamplePropertiesEXT;
9707
9708 typedef void (VKAPI_PTR *PFN_vkCmdSetSampleLocationsEXT)(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo);
9709 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT)(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties);
9710
9711 #ifndef VK_NO_PROTOTYPES
9712 VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleLocationsEXT(
9713     VkCommandBuffer                             commandBuffer,
9714     const VkSampleLocationsInfoEXT*             pSampleLocationsInfo);
9715
9716 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMultisamplePropertiesEXT(
9717     VkPhysicalDevice                            physicalDevice,
9718     VkSampleCountFlagBits                       samples,
9719     VkMultisamplePropertiesEXT*                 pMultisampleProperties);
9720 #endif
9721
9722
9723 #define VK_EXT_blend_operation_advanced 1
9724 #define VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION 2
9725 #define VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME "VK_EXT_blend_operation_advanced"
9726
9727 typedef enum VkBlendOverlapEXT {
9728     VK_BLEND_OVERLAP_UNCORRELATED_EXT = 0,
9729     VK_BLEND_OVERLAP_DISJOINT_EXT = 1,
9730     VK_BLEND_OVERLAP_CONJOINT_EXT = 2,
9731     VK_BLEND_OVERLAP_MAX_ENUM_EXT = 0x7FFFFFFF
9732 } VkBlendOverlapEXT;
9733 typedef struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT {
9734     VkStructureType    sType;
9735     void*              pNext;
9736     VkBool32           advancedBlendCoherentOperations;
9737 } VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT;
9738
9739 typedef struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT {
9740     VkStructureType    sType;
9741     void*              pNext;
9742     uint32_t           advancedBlendMaxColorAttachments;
9743     VkBool32           advancedBlendIndependentBlend;
9744     VkBool32           advancedBlendNonPremultipliedSrcColor;
9745     VkBool32           advancedBlendNonPremultipliedDstColor;
9746     VkBool32           advancedBlendCorrelatedOverlap;
9747     VkBool32           advancedBlendAllOperations;
9748 } VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT;
9749
9750 typedef struct VkPipelineColorBlendAdvancedStateCreateInfoEXT {
9751     VkStructureType      sType;
9752     const void*          pNext;
9753     VkBool32             srcPremultiplied;
9754     VkBool32             dstPremultiplied;
9755     VkBlendOverlapEXT    blendOverlap;
9756 } VkPipelineColorBlendAdvancedStateCreateInfoEXT;
9757
9758
9759
9760 #define VK_NV_fragment_coverage_to_color 1
9761 #define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION 1
9762 #define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME "VK_NV_fragment_coverage_to_color"
9763 typedef VkFlags VkPipelineCoverageToColorStateCreateFlagsNV;
9764 typedef struct VkPipelineCoverageToColorStateCreateInfoNV {
9765     VkStructureType                                sType;
9766     const void*                                    pNext;
9767     VkPipelineCoverageToColorStateCreateFlagsNV    flags;
9768     VkBool32                                       coverageToColorEnable;
9769     uint32_t                                       coverageToColorLocation;
9770 } VkPipelineCoverageToColorStateCreateInfoNV;
9771
9772
9773
9774 #define VK_NV_framebuffer_mixed_samples 1
9775 #define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION 1
9776 #define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME "VK_NV_framebuffer_mixed_samples"
9777
9778 typedef enum VkCoverageModulationModeNV {
9779     VK_COVERAGE_MODULATION_MODE_NONE_NV = 0,
9780     VK_COVERAGE_MODULATION_MODE_RGB_NV = 1,
9781     VK_COVERAGE_MODULATION_MODE_ALPHA_NV = 2,
9782     VK_COVERAGE_MODULATION_MODE_RGBA_NV = 3,
9783     VK_COVERAGE_MODULATION_MODE_MAX_ENUM_NV = 0x7FFFFFFF
9784 } VkCoverageModulationModeNV;
9785 typedef VkFlags VkPipelineCoverageModulationStateCreateFlagsNV;
9786 typedef struct VkPipelineCoverageModulationStateCreateInfoNV {
9787     VkStructureType                                   sType;
9788     const void*                                       pNext;
9789     VkPipelineCoverageModulationStateCreateFlagsNV    flags;
9790     VkCoverageModulationModeNV                        coverageModulationMode;
9791     VkBool32                                          coverageModulationTableEnable;
9792     uint32_t                                          coverageModulationTableCount;
9793     const float*                                      pCoverageModulationTable;
9794 } VkPipelineCoverageModulationStateCreateInfoNV;
9795
9796
9797
9798 #define VK_NV_fill_rectangle 1
9799 #define VK_NV_FILL_RECTANGLE_SPEC_VERSION 1
9800 #define VK_NV_FILL_RECTANGLE_EXTENSION_NAME "VK_NV_fill_rectangle"
9801
9802
9803 #define VK_NV_shader_sm_builtins 1
9804 #define VK_NV_SHADER_SM_BUILTINS_SPEC_VERSION 1
9805 #define VK_NV_SHADER_SM_BUILTINS_EXTENSION_NAME "VK_NV_shader_sm_builtins"
9806 typedef struct VkPhysicalDeviceShaderSMBuiltinsPropertiesNV {
9807     VkStructureType    sType;
9808     void*              pNext;
9809     uint32_t           shaderSMCount;
9810     uint32_t           shaderWarpsPerSM;
9811 } VkPhysicalDeviceShaderSMBuiltinsPropertiesNV;
9812
9813 typedef struct VkPhysicalDeviceShaderSMBuiltinsFeaturesNV {
9814     VkStructureType    sType;
9815     void*              pNext;
9816     VkBool32           shaderSMBuiltins;
9817 } VkPhysicalDeviceShaderSMBuiltinsFeaturesNV;
9818
9819
9820
9821 #define VK_EXT_post_depth_coverage 1
9822 #define VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION 1
9823 #define VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME "VK_EXT_post_depth_coverage"
9824
9825
9826 #define VK_EXT_image_drm_format_modifier 1
9827 #define VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION 1
9828 #define VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME "VK_EXT_image_drm_format_modifier"
9829 typedef struct VkDrmFormatModifierPropertiesEXT {
9830     uint64_t                drmFormatModifier;
9831     uint32_t                drmFormatModifierPlaneCount;
9832     VkFormatFeatureFlags    drmFormatModifierTilingFeatures;
9833 } VkDrmFormatModifierPropertiesEXT;
9834
9835 typedef struct VkDrmFormatModifierPropertiesListEXT {
9836     VkStructureType                      sType;
9837     void*                                pNext;
9838     uint32_t                             drmFormatModifierCount;
9839     VkDrmFormatModifierPropertiesEXT*    pDrmFormatModifierProperties;
9840 } VkDrmFormatModifierPropertiesListEXT;
9841
9842 typedef struct VkPhysicalDeviceImageDrmFormatModifierInfoEXT {
9843     VkStructureType    sType;
9844     const void*        pNext;
9845     uint64_t           drmFormatModifier;
9846     VkSharingMode      sharingMode;
9847     uint32_t           queueFamilyIndexCount;
9848     const uint32_t*    pQueueFamilyIndices;
9849 } VkPhysicalDeviceImageDrmFormatModifierInfoEXT;
9850
9851 typedef struct VkImageDrmFormatModifierListCreateInfoEXT {
9852     VkStructureType    sType;
9853     const void*        pNext;
9854     uint32_t           drmFormatModifierCount;
9855     const uint64_t*    pDrmFormatModifiers;
9856 } VkImageDrmFormatModifierListCreateInfoEXT;
9857
9858 typedef struct VkImageDrmFormatModifierExplicitCreateInfoEXT {
9859     VkStructureType               sType;
9860     const void*                   pNext;
9861     uint64_t                      drmFormatModifier;
9862     uint32_t                      drmFormatModifierPlaneCount;
9863     const VkSubresourceLayout*    pPlaneLayouts;
9864 } VkImageDrmFormatModifierExplicitCreateInfoEXT;
9865
9866 typedef struct VkImageDrmFormatModifierPropertiesEXT {
9867     VkStructureType    sType;
9868     void*              pNext;
9869     uint64_t           drmFormatModifier;
9870 } VkImageDrmFormatModifierPropertiesEXT;
9871
9872 typedef VkResult (VKAPI_PTR *PFN_vkGetImageDrmFormatModifierPropertiesEXT)(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties);
9873
9874 #ifndef VK_NO_PROTOTYPES
9875 VKAPI_ATTR VkResult VKAPI_CALL vkGetImageDrmFormatModifierPropertiesEXT(
9876     VkDevice                                    device,
9877     VkImage                                     image,
9878     VkImageDrmFormatModifierPropertiesEXT*      pProperties);
9879 #endif
9880
9881
9882 #define VK_EXT_validation_cache 1
9883 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkValidationCacheEXT)
9884 #define VK_EXT_VALIDATION_CACHE_SPEC_VERSION 1
9885 #define VK_EXT_VALIDATION_CACHE_EXTENSION_NAME "VK_EXT_validation_cache"
9886
9887 typedef enum VkValidationCacheHeaderVersionEXT {
9888     VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT = 1,
9889     VK_VALIDATION_CACHE_HEADER_VERSION_MAX_ENUM_EXT = 0x7FFFFFFF
9890 } VkValidationCacheHeaderVersionEXT;
9891 typedef VkFlags VkValidationCacheCreateFlagsEXT;
9892 typedef struct VkValidationCacheCreateInfoEXT {
9893     VkStructureType                    sType;
9894     const void*                        pNext;
9895     VkValidationCacheCreateFlagsEXT    flags;
9896     size_t                             initialDataSize;
9897     const void*                        pInitialData;
9898 } VkValidationCacheCreateInfoEXT;
9899
9900 typedef struct VkShaderModuleValidationCacheCreateInfoEXT {
9901     VkStructureType         sType;
9902     const void*             pNext;
9903     VkValidationCacheEXT    validationCache;
9904 } VkShaderModuleValidationCacheCreateInfoEXT;
9905
9906 typedef VkResult (VKAPI_PTR *PFN_vkCreateValidationCacheEXT)(VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache);
9907 typedef void (VKAPI_PTR *PFN_vkDestroyValidationCacheEXT)(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator);
9908 typedef VkResult (VKAPI_PTR *PFN_vkMergeValidationCachesEXT)(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches);
9909 typedef VkResult (VKAPI_PTR *PFN_vkGetValidationCacheDataEXT)(VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData);
9910
9911 #ifndef VK_NO_PROTOTYPES
9912 VKAPI_ATTR VkResult VKAPI_CALL vkCreateValidationCacheEXT(
9913     VkDevice                                    device,
9914     const VkValidationCacheCreateInfoEXT*       pCreateInfo,
9915     const VkAllocationCallbacks*                pAllocator,
9916     VkValidationCacheEXT*                       pValidationCache);
9917
9918 VKAPI_ATTR void VKAPI_CALL vkDestroyValidationCacheEXT(
9919     VkDevice                                    device,
9920     VkValidationCacheEXT                        validationCache,
9921     const VkAllocationCallbacks*                pAllocator);
9922
9923 VKAPI_ATTR VkResult VKAPI_CALL vkMergeValidationCachesEXT(
9924     VkDevice                                    device,
9925     VkValidationCacheEXT                        dstCache,
9926     uint32_t                                    srcCacheCount,
9927     const VkValidationCacheEXT*                 pSrcCaches);
9928
9929 VKAPI_ATTR VkResult VKAPI_CALL vkGetValidationCacheDataEXT(
9930     VkDevice                                    device,
9931     VkValidationCacheEXT                        validationCache,
9932     size_t*                                     pDataSize,
9933     void*                                       pData);
9934 #endif
9935
9936
9937 #define VK_EXT_descriptor_indexing 1
9938 #define VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION 2
9939 #define VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME "VK_EXT_descriptor_indexing"
9940 typedef VkDescriptorBindingFlagBits VkDescriptorBindingFlagBitsEXT;
9941
9942 typedef VkDescriptorBindingFlags VkDescriptorBindingFlagsEXT;
9943
9944 typedef VkDescriptorSetLayoutBindingFlagsCreateInfo VkDescriptorSetLayoutBindingFlagsCreateInfoEXT;
9945
9946 typedef VkPhysicalDeviceDescriptorIndexingFeatures VkPhysicalDeviceDescriptorIndexingFeaturesEXT;
9947
9948 typedef VkPhysicalDeviceDescriptorIndexingProperties VkPhysicalDeviceDescriptorIndexingPropertiesEXT;
9949
9950 typedef VkDescriptorSetVariableDescriptorCountAllocateInfo VkDescriptorSetVariableDescriptorCountAllocateInfoEXT;
9951
9952 typedef VkDescriptorSetVariableDescriptorCountLayoutSupport VkDescriptorSetVariableDescriptorCountLayoutSupportEXT;
9953
9954
9955
9956 #define VK_EXT_shader_viewport_index_layer 1
9957 #define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION 1
9958 #define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME "VK_EXT_shader_viewport_index_layer"
9959
9960
9961 #define VK_NV_shading_rate_image 1
9962 #define VK_NV_SHADING_RATE_IMAGE_SPEC_VERSION 3
9963 #define VK_NV_SHADING_RATE_IMAGE_EXTENSION_NAME "VK_NV_shading_rate_image"
9964
9965 typedef enum VkShadingRatePaletteEntryNV {
9966     VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV = 0,
9967     VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV = 1,
9968     VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV = 2,
9969     VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV = 3,
9970     VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV = 4,
9971     VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV = 5,
9972     VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV = 6,
9973     VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV = 7,
9974     VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV = 8,
9975     VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV = 9,
9976     VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV = 10,
9977     VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV = 11,
9978     VK_SHADING_RATE_PALETTE_ENTRY_MAX_ENUM_NV = 0x7FFFFFFF
9979 } VkShadingRatePaletteEntryNV;
9980
9981 typedef enum VkCoarseSampleOrderTypeNV {
9982     VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV = 0,
9983     VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV = 1,
9984     VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV = 2,
9985     VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV = 3,
9986     VK_COARSE_SAMPLE_ORDER_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
9987 } VkCoarseSampleOrderTypeNV;
9988 typedef struct VkShadingRatePaletteNV {
9989     uint32_t                              shadingRatePaletteEntryCount;
9990     const VkShadingRatePaletteEntryNV*    pShadingRatePaletteEntries;
9991 } VkShadingRatePaletteNV;
9992
9993 typedef struct VkPipelineViewportShadingRateImageStateCreateInfoNV {
9994     VkStructureType                  sType;
9995     const void*                      pNext;
9996     VkBool32                         shadingRateImageEnable;
9997     uint32_t                         viewportCount;
9998     const VkShadingRatePaletteNV*    pShadingRatePalettes;
9999 } VkPipelineViewportShadingRateImageStateCreateInfoNV;
10000
10001 typedef struct VkPhysicalDeviceShadingRateImageFeaturesNV {
10002     VkStructureType    sType;
10003     void*              pNext;
10004     VkBool32           shadingRateImage;
10005     VkBool32           shadingRateCoarseSampleOrder;
10006 } VkPhysicalDeviceShadingRateImageFeaturesNV;
10007
10008 typedef struct VkPhysicalDeviceShadingRateImagePropertiesNV {
10009     VkStructureType    sType;
10010     void*              pNext;
10011     VkExtent2D         shadingRateTexelSize;
10012     uint32_t           shadingRatePaletteSize;
10013     uint32_t           shadingRateMaxCoarseSamples;
10014 } VkPhysicalDeviceShadingRateImagePropertiesNV;
10015
10016 typedef struct VkCoarseSampleLocationNV {
10017     uint32_t    pixelX;
10018     uint32_t    pixelY;
10019     uint32_t    sample;
10020 } VkCoarseSampleLocationNV;
10021
10022 typedef struct VkCoarseSampleOrderCustomNV {
10023     VkShadingRatePaletteEntryNV        shadingRate;
10024     uint32_t                           sampleCount;
10025     uint32_t                           sampleLocationCount;
10026     const VkCoarseSampleLocationNV*    pSampleLocations;
10027 } VkCoarseSampleOrderCustomNV;
10028
10029 typedef struct VkPipelineViewportCoarseSampleOrderStateCreateInfoNV {
10030     VkStructureType                       sType;
10031     const void*                           pNext;
10032     VkCoarseSampleOrderTypeNV             sampleOrderType;
10033     uint32_t                              customSampleOrderCount;
10034     const VkCoarseSampleOrderCustomNV*    pCustomSampleOrders;
10035 } VkPipelineViewportCoarseSampleOrderStateCreateInfoNV;
10036
10037 typedef void (VKAPI_PTR *PFN_vkCmdBindShadingRateImageNV)(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout);
10038 typedef void (VKAPI_PTR *PFN_vkCmdSetViewportShadingRatePaletteNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes);
10039 typedef void (VKAPI_PTR *PFN_vkCmdSetCoarseSampleOrderNV)(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders);
10040
10041 #ifndef VK_NO_PROTOTYPES
10042 VKAPI_ATTR void VKAPI_CALL vkCmdBindShadingRateImageNV(
10043     VkCommandBuffer                             commandBuffer,
10044     VkImageView                                 imageView,
10045     VkImageLayout                               imageLayout);
10046
10047 VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportShadingRatePaletteNV(
10048     VkCommandBuffer                             commandBuffer,
10049     uint32_t                                    firstViewport,
10050     uint32_t                                    viewportCount,
10051     const VkShadingRatePaletteNV*               pShadingRatePalettes);
10052
10053 VKAPI_ATTR void VKAPI_CALL vkCmdSetCoarseSampleOrderNV(
10054     VkCommandBuffer                             commandBuffer,
10055     VkCoarseSampleOrderTypeNV                   sampleOrderType,
10056     uint32_t                                    customSampleOrderCount,
10057     const VkCoarseSampleOrderCustomNV*          pCustomSampleOrders);
10058 #endif
10059
10060
10061 #define VK_NV_ray_tracing 1
10062 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureNV)
10063 #define VK_NV_RAY_TRACING_SPEC_VERSION    3
10064 #define VK_NV_RAY_TRACING_EXTENSION_NAME  "VK_NV_ray_tracing"
10065 #define VK_SHADER_UNUSED_KHR              (~0U)
10066 #define VK_SHADER_UNUSED_NV               VK_SHADER_UNUSED_KHR
10067
10068 typedef enum VkRayTracingShaderGroupTypeKHR {
10069     VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR = 0,
10070     VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR = 1,
10071     VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR = 2,
10072     VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR,
10073     VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR,
10074     VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR,
10075     VK_RAY_TRACING_SHADER_GROUP_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF
10076 } VkRayTracingShaderGroupTypeKHR;
10077 typedef VkRayTracingShaderGroupTypeKHR VkRayTracingShaderGroupTypeNV;
10078
10079
10080 typedef enum VkGeometryTypeKHR {
10081     VK_GEOMETRY_TYPE_TRIANGLES_KHR = 0,
10082     VK_GEOMETRY_TYPE_AABBS_KHR = 1,
10083     VK_GEOMETRY_TYPE_INSTANCES_KHR = 2,
10084     VK_GEOMETRY_TYPE_TRIANGLES_NV = VK_GEOMETRY_TYPE_TRIANGLES_KHR,
10085     VK_GEOMETRY_TYPE_AABBS_NV = VK_GEOMETRY_TYPE_AABBS_KHR,
10086     VK_GEOMETRY_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF
10087 } VkGeometryTypeKHR;
10088 typedef VkGeometryTypeKHR VkGeometryTypeNV;
10089
10090
10091 typedef enum VkAccelerationStructureTypeKHR {
10092     VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR = 0,
10093     VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR = 1,
10094     VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR = 2,
10095     VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR,
10096     VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR,
10097     VK_ACCELERATION_STRUCTURE_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF
10098 } VkAccelerationStructureTypeKHR;
10099 typedef VkAccelerationStructureTypeKHR VkAccelerationStructureTypeNV;
10100
10101
10102 typedef enum VkCopyAccelerationStructureModeKHR {
10103     VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR = 0,
10104     VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR = 1,
10105     VK_COPY_ACCELERATION_STRUCTURE_MODE_SERIALIZE_KHR = 2,
10106     VK_COPY_ACCELERATION_STRUCTURE_MODE_DESERIALIZE_KHR = 3,
10107     VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV = VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR,
10108     VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV = VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR,
10109     VK_COPY_ACCELERATION_STRUCTURE_MODE_MAX_ENUM_KHR = 0x7FFFFFFF
10110 } VkCopyAccelerationStructureModeKHR;
10111 typedef VkCopyAccelerationStructureModeKHR VkCopyAccelerationStructureModeNV;
10112
10113
10114 typedef enum VkAccelerationStructureMemoryRequirementsTypeNV {
10115     VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV = 0,
10116     VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV = 1,
10117     VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV = 2,
10118     VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
10119 } VkAccelerationStructureMemoryRequirementsTypeNV;
10120
10121 typedef enum VkGeometryFlagBitsKHR {
10122     VK_GEOMETRY_OPAQUE_BIT_KHR = 0x00000001,
10123     VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR = 0x00000002,
10124     VK_GEOMETRY_OPAQUE_BIT_NV = VK_GEOMETRY_OPAQUE_BIT_KHR,
10125     VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_NV = VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR,
10126     VK_GEOMETRY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
10127 } VkGeometryFlagBitsKHR;
10128 typedef VkFlags VkGeometryFlagsKHR;
10129 typedef VkGeometryFlagsKHR VkGeometryFlagsNV;
10130
10131 typedef VkGeometryFlagBitsKHR VkGeometryFlagBitsNV;
10132
10133
10134 typedef enum VkGeometryInstanceFlagBitsKHR {
10135     VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR = 0x00000001,
10136     VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR = 0x00000002,
10137     VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR = 0x00000004,
10138     VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR = 0x00000008,
10139     VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV = VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR,
10140     VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_NV = VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR,
10141     VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NV = VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR,
10142     VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NV = VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR,
10143     VK_GEOMETRY_INSTANCE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
10144 } VkGeometryInstanceFlagBitsKHR;
10145 typedef VkFlags VkGeometryInstanceFlagsKHR;
10146 typedef VkGeometryInstanceFlagsKHR VkGeometryInstanceFlagsNV;
10147
10148 typedef VkGeometryInstanceFlagBitsKHR VkGeometryInstanceFlagBitsNV;
10149
10150
10151 typedef enum VkBuildAccelerationStructureFlagBitsKHR {
10152     VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR = 0x00000001,
10153     VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR = 0x00000002,
10154     VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR = 0x00000004,
10155     VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR = 0x00000008,
10156     VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR = 0x00000010,
10157     VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV = 0x00000020,
10158     VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR,
10159     VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR,
10160     VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR,
10161     VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR,
10162     VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR,
10163     VK_BUILD_ACCELERATION_STRUCTURE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
10164 } VkBuildAccelerationStructureFlagBitsKHR;
10165 typedef VkFlags VkBuildAccelerationStructureFlagsKHR;
10166 typedef VkBuildAccelerationStructureFlagsKHR VkBuildAccelerationStructureFlagsNV;
10167
10168 typedef VkBuildAccelerationStructureFlagBitsKHR VkBuildAccelerationStructureFlagBitsNV;
10169
10170 typedef struct VkRayTracingShaderGroupCreateInfoNV {
10171     VkStructureType                   sType;
10172     const void*                       pNext;
10173     VkRayTracingShaderGroupTypeKHR    type;
10174     uint32_t                          generalShader;
10175     uint32_t                          closestHitShader;
10176     uint32_t                          anyHitShader;
10177     uint32_t                          intersectionShader;
10178 } VkRayTracingShaderGroupCreateInfoNV;
10179
10180 typedef struct VkRayTracingPipelineCreateInfoNV {
10181     VkStructureType                               sType;
10182     const void*                                   pNext;
10183     VkPipelineCreateFlags                         flags;
10184     uint32_t                                      stageCount;
10185     const VkPipelineShaderStageCreateInfo*        pStages;
10186     uint32_t                                      groupCount;
10187     const VkRayTracingShaderGroupCreateInfoNV*    pGroups;
10188     uint32_t                                      maxRecursionDepth;
10189     VkPipelineLayout                              layout;
10190     VkPipeline                                    basePipelineHandle;
10191     int32_t                                       basePipelineIndex;
10192 } VkRayTracingPipelineCreateInfoNV;
10193
10194 typedef struct VkGeometryTrianglesNV {
10195     VkStructureType    sType;
10196     const void*        pNext;
10197     VkBuffer           vertexData;
10198     VkDeviceSize       vertexOffset;
10199     uint32_t           vertexCount;
10200     VkDeviceSize       vertexStride;
10201     VkFormat           vertexFormat;
10202     VkBuffer           indexData;
10203     VkDeviceSize       indexOffset;
10204     uint32_t           indexCount;
10205     VkIndexType        indexType;
10206     VkBuffer           transformData;
10207     VkDeviceSize       transformOffset;
10208 } VkGeometryTrianglesNV;
10209
10210 typedef struct VkGeometryAABBNV {
10211     VkStructureType    sType;
10212     const void*        pNext;
10213     VkBuffer           aabbData;
10214     uint32_t           numAABBs;
10215     uint32_t           stride;
10216     VkDeviceSize       offset;
10217 } VkGeometryAABBNV;
10218
10219 typedef struct VkGeometryDataNV {
10220     VkGeometryTrianglesNV    triangles;
10221     VkGeometryAABBNV         aabbs;
10222 } VkGeometryDataNV;
10223
10224 typedef struct VkGeometryNV {
10225     VkStructureType       sType;
10226     const void*           pNext;
10227     VkGeometryTypeKHR     geometryType;
10228     VkGeometryDataNV      geometry;
10229     VkGeometryFlagsKHR    flags;
10230 } VkGeometryNV;
10231
10232 typedef struct VkAccelerationStructureInfoNV {
10233     VkStructureType                        sType;
10234     const void*                            pNext;
10235     VkAccelerationStructureTypeNV          type;
10236     VkBuildAccelerationStructureFlagsNV    flags;
10237     uint32_t                               instanceCount;
10238     uint32_t                               geometryCount;
10239     const VkGeometryNV*                    pGeometries;
10240 } VkAccelerationStructureInfoNV;
10241
10242 typedef struct VkAccelerationStructureCreateInfoNV {
10243     VkStructureType                  sType;
10244     const void*                      pNext;
10245     VkDeviceSize                     compactedSize;
10246     VkAccelerationStructureInfoNV    info;
10247 } VkAccelerationStructureCreateInfoNV;
10248
10249 typedef struct VkBindAccelerationStructureMemoryInfoNV {
10250     VkStructureType              sType;
10251     const void*                  pNext;
10252     VkAccelerationStructureNV    accelerationStructure;
10253     VkDeviceMemory               memory;
10254     VkDeviceSize                 memoryOffset;
10255     uint32_t                     deviceIndexCount;
10256     const uint32_t*              pDeviceIndices;
10257 } VkBindAccelerationStructureMemoryInfoNV;
10258
10259 typedef struct VkWriteDescriptorSetAccelerationStructureNV {
10260     VkStructureType                     sType;
10261     const void*                         pNext;
10262     uint32_t                            accelerationStructureCount;
10263     const VkAccelerationStructureNV*    pAccelerationStructures;
10264 } VkWriteDescriptorSetAccelerationStructureNV;
10265
10266 typedef struct VkAccelerationStructureMemoryRequirementsInfoNV {
10267     VkStructureType                                    sType;
10268     const void*                                        pNext;
10269     VkAccelerationStructureMemoryRequirementsTypeNV    type;
10270     VkAccelerationStructureNV                          accelerationStructure;
10271 } VkAccelerationStructureMemoryRequirementsInfoNV;
10272
10273 typedef struct VkPhysicalDeviceRayTracingPropertiesNV {
10274     VkStructureType    sType;
10275     void*              pNext;
10276     uint32_t           shaderGroupHandleSize;
10277     uint32_t           maxRecursionDepth;
10278     uint32_t           maxShaderGroupStride;
10279     uint32_t           shaderGroupBaseAlignment;
10280     uint64_t           maxGeometryCount;
10281     uint64_t           maxInstanceCount;
10282     uint64_t           maxTriangleCount;
10283     uint32_t           maxDescriptorSetAccelerationStructures;
10284 } VkPhysicalDeviceRayTracingPropertiesNV;
10285
10286 typedef struct VkTransformMatrixKHR {
10287     float    matrix[3][4];
10288 } VkTransformMatrixKHR;
10289
10290 typedef VkTransformMatrixKHR VkTransformMatrixNV;
10291
10292 typedef struct VkAabbPositionsKHR {
10293     float    minX;
10294     float    minY;
10295     float    minZ;
10296     float    maxX;
10297     float    maxY;
10298     float    maxZ;
10299 } VkAabbPositionsKHR;
10300
10301 typedef VkAabbPositionsKHR VkAabbPositionsNV;
10302
10303 typedef struct VkAccelerationStructureInstanceKHR {
10304     VkTransformMatrixKHR          transform;
10305     uint32_t                      instanceCustomIndex:24;
10306     uint32_t                      mask:8;
10307     uint32_t                      instanceShaderBindingTableRecordOffset:24;
10308     VkGeometryInstanceFlagsKHR    flags:8;
10309     uint64_t                      accelerationStructureReference;
10310 } VkAccelerationStructureInstanceKHR;
10311
10312 typedef VkAccelerationStructureInstanceKHR VkAccelerationStructureInstanceNV;
10313
10314 typedef VkResult (VKAPI_PTR *PFN_vkCreateAccelerationStructureNV)(VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure);
10315 typedef void (VKAPI_PTR *PFN_vkDestroyAccelerationStructureNV)(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator);
10316 typedef void (VKAPI_PTR *PFN_vkGetAccelerationStructureMemoryRequirementsNV)(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements);
10317 typedef VkResult (VKAPI_PTR *PFN_vkBindAccelerationStructureMemoryNV)(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos);
10318 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);
10319 typedef void (VKAPI_PTR *PFN_vkCmdCopyAccelerationStructureNV)(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode);
10320 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);
10321 typedef VkResult (VKAPI_PTR *PFN_vkCreateRayTracingPipelinesNV)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
10322 typedef VkResult (VKAPI_PTR *PFN_vkGetRayTracingShaderGroupHandlesKHR)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData);
10323 typedef VkResult (VKAPI_PTR *PFN_vkGetRayTracingShaderGroupHandlesNV)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData);
10324 typedef VkResult (VKAPI_PTR *PFN_vkGetAccelerationStructureHandleNV)(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData);
10325 typedef void (VKAPI_PTR *PFN_vkCmdWriteAccelerationStructuresPropertiesNV)(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery);
10326 typedef VkResult (VKAPI_PTR *PFN_vkCompileDeferredNV)(VkDevice device, VkPipeline pipeline, uint32_t shader);
10327
10328 #ifndef VK_NO_PROTOTYPES
10329 VKAPI_ATTR VkResult VKAPI_CALL vkCreateAccelerationStructureNV(
10330     VkDevice                                    device,
10331     const VkAccelerationStructureCreateInfoNV*  pCreateInfo,
10332     const VkAllocationCallbacks*                pAllocator,
10333     VkAccelerationStructureNV*                  pAccelerationStructure);
10334
10335 VKAPI_ATTR void VKAPI_CALL vkDestroyAccelerationStructureNV(
10336     VkDevice                                    device,
10337     VkAccelerationStructureNV                   accelerationStructure,
10338     const VkAllocationCallbacks*                pAllocator);
10339
10340 VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureMemoryRequirementsNV(
10341     VkDevice                                    device,
10342     const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo,
10343     VkMemoryRequirements2KHR*                   pMemoryRequirements);
10344
10345 VKAPI_ATTR VkResult VKAPI_CALL vkBindAccelerationStructureMemoryNV(
10346     VkDevice                                    device,
10347     uint32_t                                    bindInfoCount,
10348     const VkBindAccelerationStructureMemoryInfoNV* pBindInfos);
10349
10350 VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructureNV(
10351     VkCommandBuffer                             commandBuffer,
10352     const VkAccelerationStructureInfoNV*        pInfo,
10353     VkBuffer                                    instanceData,
10354     VkDeviceSize                                instanceOffset,
10355     VkBool32                                    update,
10356     VkAccelerationStructureNV                   dst,
10357     VkAccelerationStructureNV                   src,
10358     VkBuffer                                    scratch,
10359     VkDeviceSize                                scratchOffset);
10360
10361 VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureNV(
10362     VkCommandBuffer                             commandBuffer,
10363     VkAccelerationStructureNV                   dst,
10364     VkAccelerationStructureNV                   src,
10365     VkCopyAccelerationStructureModeKHR          mode);
10366
10367 VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysNV(
10368     VkCommandBuffer                             commandBuffer,
10369     VkBuffer                                    raygenShaderBindingTableBuffer,
10370     VkDeviceSize                                raygenShaderBindingOffset,
10371     VkBuffer                                    missShaderBindingTableBuffer,
10372     VkDeviceSize                                missShaderBindingOffset,
10373     VkDeviceSize                                missShaderBindingStride,
10374     VkBuffer                                    hitShaderBindingTableBuffer,
10375     VkDeviceSize                                hitShaderBindingOffset,
10376     VkDeviceSize                                hitShaderBindingStride,
10377     VkBuffer                                    callableShaderBindingTableBuffer,
10378     VkDeviceSize                                callableShaderBindingOffset,
10379     VkDeviceSize                                callableShaderBindingStride,
10380     uint32_t                                    width,
10381     uint32_t                                    height,
10382     uint32_t                                    depth);
10383
10384 VKAPI_ATTR VkResult VKAPI_CALL vkCreateRayTracingPipelinesNV(
10385     VkDevice                                    device,
10386     VkPipelineCache                             pipelineCache,
10387     uint32_t                                    createInfoCount,
10388     const VkRayTracingPipelineCreateInfoNV*     pCreateInfos,
10389     const VkAllocationCallbacks*                pAllocator,
10390     VkPipeline*                                 pPipelines);
10391
10392 VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingShaderGroupHandlesKHR(
10393     VkDevice                                    device,
10394     VkPipeline                                  pipeline,
10395     uint32_t                                    firstGroup,
10396     uint32_t                                    groupCount,
10397     size_t                                      dataSize,
10398     void*                                       pData);
10399
10400 VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingShaderGroupHandlesNV(
10401     VkDevice                                    device,
10402     VkPipeline                                  pipeline,
10403     uint32_t                                    firstGroup,
10404     uint32_t                                    groupCount,
10405     size_t                                      dataSize,
10406     void*                                       pData);
10407
10408 VKAPI_ATTR VkResult VKAPI_CALL vkGetAccelerationStructureHandleNV(
10409     VkDevice                                    device,
10410     VkAccelerationStructureNV                   accelerationStructure,
10411     size_t                                      dataSize,
10412     void*                                       pData);
10413
10414 VKAPI_ATTR void VKAPI_CALL vkCmdWriteAccelerationStructuresPropertiesNV(
10415     VkCommandBuffer                             commandBuffer,
10416     uint32_t                                    accelerationStructureCount,
10417     const VkAccelerationStructureNV*            pAccelerationStructures,
10418     VkQueryType                                 queryType,
10419     VkQueryPool                                 queryPool,
10420     uint32_t                                    firstQuery);
10421
10422 VKAPI_ATTR VkResult VKAPI_CALL vkCompileDeferredNV(
10423     VkDevice                                    device,
10424     VkPipeline                                  pipeline,
10425     uint32_t                                    shader);
10426 #endif
10427
10428
10429 #define VK_NV_representative_fragment_test 1
10430 #define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION 2
10431 #define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME "VK_NV_representative_fragment_test"
10432 typedef struct VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV {
10433     VkStructureType    sType;
10434     void*              pNext;
10435     VkBool32           representativeFragmentTest;
10436 } VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV;
10437
10438 typedef struct VkPipelineRepresentativeFragmentTestStateCreateInfoNV {
10439     VkStructureType    sType;
10440     const void*        pNext;
10441     VkBool32           representativeFragmentTestEnable;
10442 } VkPipelineRepresentativeFragmentTestStateCreateInfoNV;
10443
10444
10445
10446 #define VK_EXT_filter_cubic 1
10447 #define VK_EXT_FILTER_CUBIC_SPEC_VERSION  3
10448 #define VK_EXT_FILTER_CUBIC_EXTENSION_NAME "VK_EXT_filter_cubic"
10449 typedef struct VkPhysicalDeviceImageViewImageFormatInfoEXT {
10450     VkStructureType    sType;
10451     void*              pNext;
10452     VkImageViewType    imageViewType;
10453 } VkPhysicalDeviceImageViewImageFormatInfoEXT;
10454
10455 typedef struct VkFilterCubicImageViewImageFormatPropertiesEXT {
10456     VkStructureType    sType;
10457     void*              pNext;
10458     VkBool32           filterCubic;
10459     VkBool32           filterCubicMinmax;
10460 } VkFilterCubicImageViewImageFormatPropertiesEXT;
10461
10462
10463
10464 #define VK_QCOM_render_pass_shader_resolve 1
10465 #define VK_QCOM_RENDER_PASS_SHADER_RESOLVE_SPEC_VERSION 4
10466 #define VK_QCOM_RENDER_PASS_SHADER_RESOLVE_EXTENSION_NAME "VK_QCOM_render_pass_shader_resolve"
10467
10468
10469 #define VK_EXT_global_priority 1
10470 #define VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION 2
10471 #define VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME "VK_EXT_global_priority"
10472
10473 typedef enum VkQueueGlobalPriorityEXT {
10474     VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT = 128,
10475     VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT = 256,
10476     VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT = 512,
10477     VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT = 1024,
10478     VK_QUEUE_GLOBAL_PRIORITY_MAX_ENUM_EXT = 0x7FFFFFFF
10479 } VkQueueGlobalPriorityEXT;
10480 typedef struct VkDeviceQueueGlobalPriorityCreateInfoEXT {
10481     VkStructureType             sType;
10482     const void*                 pNext;
10483     VkQueueGlobalPriorityEXT    globalPriority;
10484 } VkDeviceQueueGlobalPriorityCreateInfoEXT;
10485
10486
10487
10488 #define VK_EXT_external_memory_host 1
10489 #define VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION 1
10490 #define VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME "VK_EXT_external_memory_host"
10491 typedef struct VkImportMemoryHostPointerInfoEXT {
10492     VkStructureType                       sType;
10493     const void*                           pNext;
10494     VkExternalMemoryHandleTypeFlagBits    handleType;
10495     void*                                 pHostPointer;
10496 } VkImportMemoryHostPointerInfoEXT;
10497
10498 typedef struct VkMemoryHostPointerPropertiesEXT {
10499     VkStructureType    sType;
10500     void*              pNext;
10501     uint32_t           memoryTypeBits;
10502 } VkMemoryHostPointerPropertiesEXT;
10503
10504 typedef struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT {
10505     VkStructureType    sType;
10506     void*              pNext;
10507     VkDeviceSize       minImportedHostPointerAlignment;
10508 } VkPhysicalDeviceExternalMemoryHostPropertiesEXT;
10509
10510 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryHostPointerPropertiesEXT)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties);
10511
10512 #ifndef VK_NO_PROTOTYPES
10513 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryHostPointerPropertiesEXT(
10514     VkDevice                                    device,
10515     VkExternalMemoryHandleTypeFlagBits          handleType,
10516     const void*                                 pHostPointer,
10517     VkMemoryHostPointerPropertiesEXT*           pMemoryHostPointerProperties);
10518 #endif
10519
10520
10521 #define VK_AMD_buffer_marker 1
10522 #define VK_AMD_BUFFER_MARKER_SPEC_VERSION 1
10523 #define VK_AMD_BUFFER_MARKER_EXTENSION_NAME "VK_AMD_buffer_marker"
10524 typedef void (VKAPI_PTR *PFN_vkCmdWriteBufferMarkerAMD)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker);
10525
10526 #ifndef VK_NO_PROTOTYPES
10527 VKAPI_ATTR void VKAPI_CALL vkCmdWriteBufferMarkerAMD(
10528     VkCommandBuffer                             commandBuffer,
10529     VkPipelineStageFlagBits                     pipelineStage,
10530     VkBuffer                                    dstBuffer,
10531     VkDeviceSize                                dstOffset,
10532     uint32_t                                    marker);
10533 #endif
10534
10535
10536 #define VK_AMD_pipeline_compiler_control 1
10537 #define VK_AMD_PIPELINE_COMPILER_CONTROL_SPEC_VERSION 1
10538 #define VK_AMD_PIPELINE_COMPILER_CONTROL_EXTENSION_NAME "VK_AMD_pipeline_compiler_control"
10539
10540 typedef enum VkPipelineCompilerControlFlagBitsAMD {
10541     VK_PIPELINE_COMPILER_CONTROL_FLAG_BITS_MAX_ENUM_AMD = 0x7FFFFFFF
10542 } VkPipelineCompilerControlFlagBitsAMD;
10543 typedef VkFlags VkPipelineCompilerControlFlagsAMD;
10544 typedef struct VkPipelineCompilerControlCreateInfoAMD {
10545     VkStructureType                      sType;
10546     const void*                          pNext;
10547     VkPipelineCompilerControlFlagsAMD    compilerControlFlags;
10548 } VkPipelineCompilerControlCreateInfoAMD;
10549
10550
10551
10552 #define VK_EXT_calibrated_timestamps 1
10553 #define VK_EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION 2
10554 #define VK_EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME "VK_EXT_calibrated_timestamps"
10555
10556 typedef enum VkTimeDomainEXT {
10557     VK_TIME_DOMAIN_DEVICE_EXT = 0,
10558     VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT = 1,
10559     VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT = 2,
10560     VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT = 3,
10561     VK_TIME_DOMAIN_MAX_ENUM_EXT = 0x7FFFFFFF
10562 } VkTimeDomainEXT;
10563 typedef struct VkCalibratedTimestampInfoEXT {
10564     VkStructureType    sType;
10565     const void*        pNext;
10566     VkTimeDomainEXT    timeDomain;
10567 } VkCalibratedTimestampInfoEXT;
10568
10569 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains);
10570 typedef VkResult (VKAPI_PTR *PFN_vkGetCalibratedTimestampsEXT)(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation);
10571
10572 #ifndef VK_NO_PROTOTYPES
10573 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(
10574     VkPhysicalDevice                            physicalDevice,
10575     uint32_t*                                   pTimeDomainCount,
10576     VkTimeDomainEXT*                            pTimeDomains);
10577
10578 VKAPI_ATTR VkResult VKAPI_CALL vkGetCalibratedTimestampsEXT(
10579     VkDevice                                    device,
10580     uint32_t                                    timestampCount,
10581     const VkCalibratedTimestampInfoEXT*         pTimestampInfos,
10582     uint64_t*                                   pTimestamps,
10583     uint64_t*                                   pMaxDeviation);
10584 #endif
10585
10586
10587 #define VK_AMD_shader_core_properties 1
10588 #define VK_AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION 2
10589 #define VK_AMD_SHADER_CORE_PROPERTIES_EXTENSION_NAME "VK_AMD_shader_core_properties"
10590 typedef struct VkPhysicalDeviceShaderCorePropertiesAMD {
10591     VkStructureType    sType;
10592     void*              pNext;
10593     uint32_t           shaderEngineCount;
10594     uint32_t           shaderArraysPerEngineCount;
10595     uint32_t           computeUnitsPerShaderArray;
10596     uint32_t           simdPerComputeUnit;
10597     uint32_t           wavefrontsPerSimd;
10598     uint32_t           wavefrontSize;
10599     uint32_t           sgprsPerSimd;
10600     uint32_t           minSgprAllocation;
10601     uint32_t           maxSgprAllocation;
10602     uint32_t           sgprAllocationGranularity;
10603     uint32_t           vgprsPerSimd;
10604     uint32_t           minVgprAllocation;
10605     uint32_t           maxVgprAllocation;
10606     uint32_t           vgprAllocationGranularity;
10607 } VkPhysicalDeviceShaderCorePropertiesAMD;
10608
10609
10610
10611 #define VK_AMD_memory_overallocation_behavior 1
10612 #define VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_SPEC_VERSION 1
10613 #define VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_EXTENSION_NAME "VK_AMD_memory_overallocation_behavior"
10614
10615 typedef enum VkMemoryOverallocationBehaviorAMD {
10616     VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD = 0,
10617     VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD = 1,
10618     VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD = 2,
10619     VK_MEMORY_OVERALLOCATION_BEHAVIOR_MAX_ENUM_AMD = 0x7FFFFFFF
10620 } VkMemoryOverallocationBehaviorAMD;
10621 typedef struct VkDeviceMemoryOverallocationCreateInfoAMD {
10622     VkStructureType                      sType;
10623     const void*                          pNext;
10624     VkMemoryOverallocationBehaviorAMD    overallocationBehavior;
10625 } VkDeviceMemoryOverallocationCreateInfoAMD;
10626
10627
10628
10629 #define VK_EXT_vertex_attribute_divisor 1
10630 #define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION 3
10631 #define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME "VK_EXT_vertex_attribute_divisor"
10632 typedef struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT {
10633     VkStructureType    sType;
10634     void*              pNext;
10635     uint32_t           maxVertexAttribDivisor;
10636 } VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT;
10637
10638 typedef struct VkVertexInputBindingDivisorDescriptionEXT {
10639     uint32_t    binding;
10640     uint32_t    divisor;
10641 } VkVertexInputBindingDivisorDescriptionEXT;
10642
10643 typedef struct VkPipelineVertexInputDivisorStateCreateInfoEXT {
10644     VkStructureType                                     sType;
10645     const void*                                         pNext;
10646     uint32_t                                            vertexBindingDivisorCount;
10647     const VkVertexInputBindingDivisorDescriptionEXT*    pVertexBindingDivisors;
10648 } VkPipelineVertexInputDivisorStateCreateInfoEXT;
10649
10650 typedef struct VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT {
10651     VkStructureType    sType;
10652     void*              pNext;
10653     VkBool32           vertexAttributeInstanceRateDivisor;
10654     VkBool32           vertexAttributeInstanceRateZeroDivisor;
10655 } VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT;
10656
10657
10658
10659 #define VK_EXT_pipeline_creation_feedback 1
10660 #define VK_EXT_PIPELINE_CREATION_FEEDBACK_SPEC_VERSION 1
10661 #define VK_EXT_PIPELINE_CREATION_FEEDBACK_EXTENSION_NAME "VK_EXT_pipeline_creation_feedback"
10662
10663 typedef enum VkPipelineCreationFeedbackFlagBitsEXT {
10664     VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT = 0x00000001,
10665     VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT = 0x00000002,
10666     VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT_EXT = 0x00000004,
10667     VK_PIPELINE_CREATION_FEEDBACK_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
10668 } VkPipelineCreationFeedbackFlagBitsEXT;
10669 typedef VkFlags VkPipelineCreationFeedbackFlagsEXT;
10670 typedef struct VkPipelineCreationFeedbackEXT {
10671     VkPipelineCreationFeedbackFlagsEXT    flags;
10672     uint64_t                              duration;
10673 } VkPipelineCreationFeedbackEXT;
10674
10675 typedef struct VkPipelineCreationFeedbackCreateInfoEXT {
10676     VkStructureType                   sType;
10677     const void*                       pNext;
10678     VkPipelineCreationFeedbackEXT*    pPipelineCreationFeedback;
10679     uint32_t                          pipelineStageCreationFeedbackCount;
10680     VkPipelineCreationFeedbackEXT*    pPipelineStageCreationFeedbacks;
10681 } VkPipelineCreationFeedbackCreateInfoEXT;
10682
10683
10684
10685 #define VK_NV_shader_subgroup_partitioned 1
10686 #define VK_NV_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION 1
10687 #define VK_NV_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME "VK_NV_shader_subgroup_partitioned"
10688
10689
10690 #define VK_NV_compute_shader_derivatives 1
10691 #define VK_NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION 1
10692 #define VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME "VK_NV_compute_shader_derivatives"
10693 typedef struct VkPhysicalDeviceComputeShaderDerivativesFeaturesNV {
10694     VkStructureType    sType;
10695     void*              pNext;
10696     VkBool32           computeDerivativeGroupQuads;
10697     VkBool32           computeDerivativeGroupLinear;
10698 } VkPhysicalDeviceComputeShaderDerivativesFeaturesNV;
10699
10700
10701
10702 #define VK_NV_mesh_shader 1
10703 #define VK_NV_MESH_SHADER_SPEC_VERSION    1
10704 #define VK_NV_MESH_SHADER_EXTENSION_NAME  "VK_NV_mesh_shader"
10705 typedef struct VkPhysicalDeviceMeshShaderFeaturesNV {
10706     VkStructureType    sType;
10707     void*              pNext;
10708     VkBool32           taskShader;
10709     VkBool32           meshShader;
10710 } VkPhysicalDeviceMeshShaderFeaturesNV;
10711
10712 typedef struct VkPhysicalDeviceMeshShaderPropertiesNV {
10713     VkStructureType    sType;
10714     void*              pNext;
10715     uint32_t           maxDrawMeshTasksCount;
10716     uint32_t           maxTaskWorkGroupInvocations;
10717     uint32_t           maxTaskWorkGroupSize[3];
10718     uint32_t           maxTaskTotalMemorySize;
10719     uint32_t           maxTaskOutputCount;
10720     uint32_t           maxMeshWorkGroupInvocations;
10721     uint32_t           maxMeshWorkGroupSize[3];
10722     uint32_t           maxMeshTotalMemorySize;
10723     uint32_t           maxMeshOutputVertices;
10724     uint32_t           maxMeshOutputPrimitives;
10725     uint32_t           maxMeshMultiviewViewCount;
10726     uint32_t           meshOutputPerVertexGranularity;
10727     uint32_t           meshOutputPerPrimitiveGranularity;
10728 } VkPhysicalDeviceMeshShaderPropertiesNV;
10729
10730 typedef struct VkDrawMeshTasksIndirectCommandNV {
10731     uint32_t    taskCount;
10732     uint32_t    firstTask;
10733 } VkDrawMeshTasksIndirectCommandNV;
10734
10735 typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksNV)(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask);
10736 typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirectNV)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
10737 typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirectCountNV)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
10738
10739 #ifndef VK_NO_PROTOTYPES
10740 VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksNV(
10741     VkCommandBuffer                             commandBuffer,
10742     uint32_t                                    taskCount,
10743     uint32_t                                    firstTask);
10744
10745 VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectNV(
10746     VkCommandBuffer                             commandBuffer,
10747     VkBuffer                                    buffer,
10748     VkDeviceSize                                offset,
10749     uint32_t                                    drawCount,
10750     uint32_t                                    stride);
10751
10752 VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectCountNV(
10753     VkCommandBuffer                             commandBuffer,
10754     VkBuffer                                    buffer,
10755     VkDeviceSize                                offset,
10756     VkBuffer                                    countBuffer,
10757     VkDeviceSize                                countBufferOffset,
10758     uint32_t                                    maxDrawCount,
10759     uint32_t                                    stride);
10760 #endif
10761
10762
10763 #define VK_NV_fragment_shader_barycentric 1
10764 #define VK_NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION 1
10765 #define VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME "VK_NV_fragment_shader_barycentric"
10766 typedef struct VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV {
10767     VkStructureType    sType;
10768     void*              pNext;
10769     VkBool32           fragmentShaderBarycentric;
10770 } VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV;
10771
10772
10773
10774 #define VK_NV_shader_image_footprint 1
10775 #define VK_NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION 2
10776 #define VK_NV_SHADER_IMAGE_FOOTPRINT_EXTENSION_NAME "VK_NV_shader_image_footprint"
10777 typedef struct VkPhysicalDeviceShaderImageFootprintFeaturesNV {
10778     VkStructureType    sType;
10779     void*              pNext;
10780     VkBool32           imageFootprint;
10781 } VkPhysicalDeviceShaderImageFootprintFeaturesNV;
10782
10783
10784
10785 #define VK_NV_scissor_exclusive 1
10786 #define VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION 1
10787 #define VK_NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME "VK_NV_scissor_exclusive"
10788 typedef struct VkPipelineViewportExclusiveScissorStateCreateInfoNV {
10789     VkStructureType    sType;
10790     const void*        pNext;
10791     uint32_t           exclusiveScissorCount;
10792     const VkRect2D*    pExclusiveScissors;
10793 } VkPipelineViewportExclusiveScissorStateCreateInfoNV;
10794
10795 typedef struct VkPhysicalDeviceExclusiveScissorFeaturesNV {
10796     VkStructureType    sType;
10797     void*              pNext;
10798     VkBool32           exclusiveScissor;
10799 } VkPhysicalDeviceExclusiveScissorFeaturesNV;
10800
10801 typedef void (VKAPI_PTR *PFN_vkCmdSetExclusiveScissorNV)(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors);
10802
10803 #ifndef VK_NO_PROTOTYPES
10804 VKAPI_ATTR void VKAPI_CALL vkCmdSetExclusiveScissorNV(
10805     VkCommandBuffer                             commandBuffer,
10806     uint32_t                                    firstExclusiveScissor,
10807     uint32_t                                    exclusiveScissorCount,
10808     const VkRect2D*                             pExclusiveScissors);
10809 #endif
10810
10811
10812 #define VK_NV_device_diagnostic_checkpoints 1
10813 #define VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_SPEC_VERSION 2
10814 #define VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_EXTENSION_NAME "VK_NV_device_diagnostic_checkpoints"
10815 typedef struct VkQueueFamilyCheckpointPropertiesNV {
10816     VkStructureType         sType;
10817     void*                   pNext;
10818     VkPipelineStageFlags    checkpointExecutionStageMask;
10819 } VkQueueFamilyCheckpointPropertiesNV;
10820
10821 typedef struct VkCheckpointDataNV {
10822     VkStructureType            sType;
10823     void*                      pNext;
10824     VkPipelineStageFlagBits    stage;
10825     void*                      pCheckpointMarker;
10826 } VkCheckpointDataNV;
10827
10828 typedef void (VKAPI_PTR *PFN_vkCmdSetCheckpointNV)(VkCommandBuffer commandBuffer, const void* pCheckpointMarker);
10829 typedef void (VKAPI_PTR *PFN_vkGetQueueCheckpointDataNV)(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData);
10830
10831 #ifndef VK_NO_PROTOTYPES
10832 VKAPI_ATTR void VKAPI_CALL vkCmdSetCheckpointNV(
10833     VkCommandBuffer                             commandBuffer,
10834     const void*                                 pCheckpointMarker);
10835
10836 VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointDataNV(
10837     VkQueue                                     queue,
10838     uint32_t*                                   pCheckpointDataCount,
10839     VkCheckpointDataNV*                         pCheckpointData);
10840 #endif
10841
10842
10843 #define VK_INTEL_shader_integer_functions2 1
10844 #define VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_SPEC_VERSION 1
10845 #define VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_EXTENSION_NAME "VK_INTEL_shader_integer_functions2"
10846 typedef struct VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
10847     VkStructureType    sType;
10848     void*              pNext;
10849     VkBool32           shaderIntegerFunctions2;
10850 } VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
10851
10852
10853
10854 #define VK_INTEL_performance_query 1
10855 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPerformanceConfigurationINTEL)
10856 #define VK_INTEL_PERFORMANCE_QUERY_SPEC_VERSION 2
10857 #define VK_INTEL_PERFORMANCE_QUERY_EXTENSION_NAME "VK_INTEL_performance_query"
10858
10859 typedef enum VkPerformanceConfigurationTypeINTEL {
10860     VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL = 0,
10861     VK_PERFORMANCE_CONFIGURATION_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF
10862 } VkPerformanceConfigurationTypeINTEL;
10863
10864 typedef enum VkQueryPoolSamplingModeINTEL {
10865     VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL = 0,
10866     VK_QUERY_POOL_SAMPLING_MODE_MAX_ENUM_INTEL = 0x7FFFFFFF
10867 } VkQueryPoolSamplingModeINTEL;
10868
10869 typedef enum VkPerformanceOverrideTypeINTEL {
10870     VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL = 0,
10871     VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL = 1,
10872     VK_PERFORMANCE_OVERRIDE_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF
10873 } VkPerformanceOverrideTypeINTEL;
10874
10875 typedef enum VkPerformanceParameterTypeINTEL {
10876     VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL = 0,
10877     VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL = 1,
10878     VK_PERFORMANCE_PARAMETER_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF
10879 } VkPerformanceParameterTypeINTEL;
10880
10881 typedef enum VkPerformanceValueTypeINTEL {
10882     VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL = 0,
10883     VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL = 1,
10884     VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL = 2,
10885     VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL = 3,
10886     VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL = 4,
10887     VK_PERFORMANCE_VALUE_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF
10888 } VkPerformanceValueTypeINTEL;
10889 typedef union VkPerformanceValueDataINTEL {
10890     uint32_t       value32;
10891     uint64_t       value64;
10892     float          valueFloat;
10893     VkBool32       valueBool;
10894     const char*    valueString;
10895 } VkPerformanceValueDataINTEL;
10896
10897 typedef struct VkPerformanceValueINTEL {
10898     VkPerformanceValueTypeINTEL    type;
10899     VkPerformanceValueDataINTEL    data;
10900 } VkPerformanceValueINTEL;
10901
10902 typedef struct VkInitializePerformanceApiInfoINTEL {
10903     VkStructureType    sType;
10904     const void*        pNext;
10905     void*              pUserData;
10906 } VkInitializePerformanceApiInfoINTEL;
10907
10908 typedef struct VkQueryPoolPerformanceQueryCreateInfoINTEL {
10909     VkStructureType                 sType;
10910     const void*                     pNext;
10911     VkQueryPoolSamplingModeINTEL    performanceCountersSampling;
10912 } VkQueryPoolPerformanceQueryCreateInfoINTEL;
10913
10914 typedef VkQueryPoolPerformanceQueryCreateInfoINTEL VkQueryPoolCreateInfoINTEL;
10915
10916 typedef struct VkPerformanceMarkerInfoINTEL {
10917     VkStructureType    sType;
10918     const void*        pNext;
10919     uint64_t           marker;
10920 } VkPerformanceMarkerInfoINTEL;
10921
10922 typedef struct VkPerformanceStreamMarkerInfoINTEL {
10923     VkStructureType    sType;
10924     const void*        pNext;
10925     uint32_t           marker;
10926 } VkPerformanceStreamMarkerInfoINTEL;
10927
10928 typedef struct VkPerformanceOverrideInfoINTEL {
10929     VkStructureType                   sType;
10930     const void*                       pNext;
10931     VkPerformanceOverrideTypeINTEL    type;
10932     VkBool32                          enable;
10933     uint64_t                          parameter;
10934 } VkPerformanceOverrideInfoINTEL;
10935
10936 typedef struct VkPerformanceConfigurationAcquireInfoINTEL {
10937     VkStructureType                        sType;
10938     const void*                            pNext;
10939     VkPerformanceConfigurationTypeINTEL    type;
10940 } VkPerformanceConfigurationAcquireInfoINTEL;
10941
10942 typedef VkResult (VKAPI_PTR *PFN_vkInitializePerformanceApiINTEL)(VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo);
10943 typedef void (VKAPI_PTR *PFN_vkUninitializePerformanceApiINTEL)(VkDevice device);
10944 typedef VkResult (VKAPI_PTR *PFN_vkCmdSetPerformanceMarkerINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo);
10945 typedef VkResult (VKAPI_PTR *PFN_vkCmdSetPerformanceStreamMarkerINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo);
10946 typedef VkResult (VKAPI_PTR *PFN_vkCmdSetPerformanceOverrideINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo);
10947 typedef VkResult (VKAPI_PTR *PFN_vkAcquirePerformanceConfigurationINTEL)(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration);
10948 typedef VkResult (VKAPI_PTR *PFN_vkReleasePerformanceConfigurationINTEL)(VkDevice device, VkPerformanceConfigurationINTEL configuration);
10949 typedef VkResult (VKAPI_PTR *PFN_vkQueueSetPerformanceConfigurationINTEL)(VkQueue queue, VkPerformanceConfigurationINTEL configuration);
10950 typedef VkResult (VKAPI_PTR *PFN_vkGetPerformanceParameterINTEL)(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue);
10951
10952 #ifndef VK_NO_PROTOTYPES
10953 VKAPI_ATTR VkResult VKAPI_CALL vkInitializePerformanceApiINTEL(
10954     VkDevice                                    device,
10955     const VkInitializePerformanceApiInfoINTEL*  pInitializeInfo);
10956
10957 VKAPI_ATTR void VKAPI_CALL vkUninitializePerformanceApiINTEL(
10958     VkDevice                                    device);
10959
10960 VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceMarkerINTEL(
10961     VkCommandBuffer                             commandBuffer,
10962     const VkPerformanceMarkerInfoINTEL*         pMarkerInfo);
10963
10964 VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceStreamMarkerINTEL(
10965     VkCommandBuffer                             commandBuffer,
10966     const VkPerformanceStreamMarkerInfoINTEL*   pMarkerInfo);
10967
10968 VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceOverrideINTEL(
10969     VkCommandBuffer                             commandBuffer,
10970     const VkPerformanceOverrideInfoINTEL*       pOverrideInfo);
10971
10972 VKAPI_ATTR VkResult VKAPI_CALL vkAcquirePerformanceConfigurationINTEL(
10973     VkDevice                                    device,
10974     const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo,
10975     VkPerformanceConfigurationINTEL*            pConfiguration);
10976
10977 VKAPI_ATTR VkResult VKAPI_CALL vkReleasePerformanceConfigurationINTEL(
10978     VkDevice                                    device,
10979     VkPerformanceConfigurationINTEL             configuration);
10980
10981 VKAPI_ATTR VkResult VKAPI_CALL vkQueueSetPerformanceConfigurationINTEL(
10982     VkQueue                                     queue,
10983     VkPerformanceConfigurationINTEL             configuration);
10984
10985 VKAPI_ATTR VkResult VKAPI_CALL vkGetPerformanceParameterINTEL(
10986     VkDevice                                    device,
10987     VkPerformanceParameterTypeINTEL             parameter,
10988     VkPerformanceValueINTEL*                    pValue);
10989 #endif
10990
10991
10992 #define VK_EXT_pci_bus_info 1
10993 #define VK_EXT_PCI_BUS_INFO_SPEC_VERSION  2
10994 #define VK_EXT_PCI_BUS_INFO_EXTENSION_NAME "VK_EXT_pci_bus_info"
10995 typedef struct VkPhysicalDevicePCIBusInfoPropertiesEXT {
10996     VkStructureType    sType;
10997     void*              pNext;
10998     uint32_t           pciDomain;
10999     uint32_t           pciBus;
11000     uint32_t           pciDevice;
11001     uint32_t           pciFunction;
11002 } VkPhysicalDevicePCIBusInfoPropertiesEXT;
11003
11004
11005
11006 #define VK_AMD_display_native_hdr 1
11007 #define VK_AMD_DISPLAY_NATIVE_HDR_SPEC_VERSION 1
11008 #define VK_AMD_DISPLAY_NATIVE_HDR_EXTENSION_NAME "VK_AMD_display_native_hdr"
11009 typedef struct VkDisplayNativeHdrSurfaceCapabilitiesAMD {
11010     VkStructureType    sType;
11011     void*              pNext;
11012     VkBool32           localDimmingSupport;
11013 } VkDisplayNativeHdrSurfaceCapabilitiesAMD;
11014
11015 typedef struct VkSwapchainDisplayNativeHdrCreateInfoAMD {
11016     VkStructureType    sType;
11017     const void*        pNext;
11018     VkBool32           localDimmingEnable;
11019 } VkSwapchainDisplayNativeHdrCreateInfoAMD;
11020
11021 typedef void (VKAPI_PTR *PFN_vkSetLocalDimmingAMD)(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable);
11022
11023 #ifndef VK_NO_PROTOTYPES
11024 VKAPI_ATTR void VKAPI_CALL vkSetLocalDimmingAMD(
11025     VkDevice                                    device,
11026     VkSwapchainKHR                              swapChain,
11027     VkBool32                                    localDimmingEnable);
11028 #endif
11029
11030
11031 #define VK_EXT_fragment_density_map 1
11032 #define VK_EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION 1
11033 #define VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME "VK_EXT_fragment_density_map"
11034 typedef struct VkPhysicalDeviceFragmentDensityMapFeaturesEXT {
11035     VkStructureType    sType;
11036     void*              pNext;
11037     VkBool32           fragmentDensityMap;
11038     VkBool32           fragmentDensityMapDynamic;
11039     VkBool32           fragmentDensityMapNonSubsampledImages;
11040 } VkPhysicalDeviceFragmentDensityMapFeaturesEXT;
11041
11042 typedef struct VkPhysicalDeviceFragmentDensityMapPropertiesEXT {
11043     VkStructureType    sType;
11044     void*              pNext;
11045     VkExtent2D         minFragmentDensityTexelSize;
11046     VkExtent2D         maxFragmentDensityTexelSize;
11047     VkBool32           fragmentDensityInvocations;
11048 } VkPhysicalDeviceFragmentDensityMapPropertiesEXT;
11049
11050 typedef struct VkRenderPassFragmentDensityMapCreateInfoEXT {
11051     VkStructureType          sType;
11052     const void*              pNext;
11053     VkAttachmentReference    fragmentDensityMapAttachment;
11054 } VkRenderPassFragmentDensityMapCreateInfoEXT;
11055
11056
11057
11058 #define VK_EXT_scalar_block_layout 1
11059 #define VK_EXT_SCALAR_BLOCK_LAYOUT_SPEC_VERSION 1
11060 #define VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME "VK_EXT_scalar_block_layout"
11061 typedef VkPhysicalDeviceScalarBlockLayoutFeatures VkPhysicalDeviceScalarBlockLayoutFeaturesEXT;
11062
11063
11064
11065 #define VK_GOOGLE_hlsl_functionality1 1
11066 #define VK_GOOGLE_HLSL_FUNCTIONALITY1_SPEC_VERSION 1
11067 #define VK_GOOGLE_HLSL_FUNCTIONALITY1_EXTENSION_NAME "VK_GOOGLE_hlsl_functionality1"
11068
11069
11070 #define VK_GOOGLE_decorate_string 1
11071 #define VK_GOOGLE_DECORATE_STRING_SPEC_VERSION 1
11072 #define VK_GOOGLE_DECORATE_STRING_EXTENSION_NAME "VK_GOOGLE_decorate_string"
11073
11074
11075 #define VK_EXT_subgroup_size_control 1
11076 #define VK_EXT_SUBGROUP_SIZE_CONTROL_SPEC_VERSION 2
11077 #define VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME "VK_EXT_subgroup_size_control"
11078 typedef struct VkPhysicalDeviceSubgroupSizeControlFeaturesEXT {
11079     VkStructureType    sType;
11080     void*              pNext;
11081     VkBool32           subgroupSizeControl;
11082     VkBool32           computeFullSubgroups;
11083 } VkPhysicalDeviceSubgroupSizeControlFeaturesEXT;
11084
11085 typedef struct VkPhysicalDeviceSubgroupSizeControlPropertiesEXT {
11086     VkStructureType       sType;
11087     void*                 pNext;
11088     uint32_t              minSubgroupSize;
11089     uint32_t              maxSubgroupSize;
11090     uint32_t              maxComputeWorkgroupSubgroups;
11091     VkShaderStageFlags    requiredSubgroupSizeStages;
11092 } VkPhysicalDeviceSubgroupSizeControlPropertiesEXT;
11093
11094 typedef struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT {
11095     VkStructureType    sType;
11096     void*              pNext;
11097     uint32_t           requiredSubgroupSize;
11098 } VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT;
11099
11100
11101
11102 #define VK_AMD_shader_core_properties2 1
11103 #define VK_AMD_SHADER_CORE_PROPERTIES_2_SPEC_VERSION 1
11104 #define VK_AMD_SHADER_CORE_PROPERTIES_2_EXTENSION_NAME "VK_AMD_shader_core_properties2"
11105
11106 typedef enum VkShaderCorePropertiesFlagBitsAMD {
11107     VK_SHADER_CORE_PROPERTIES_FLAG_BITS_MAX_ENUM_AMD = 0x7FFFFFFF
11108 } VkShaderCorePropertiesFlagBitsAMD;
11109 typedef VkFlags VkShaderCorePropertiesFlagsAMD;
11110 typedef struct VkPhysicalDeviceShaderCoreProperties2AMD {
11111     VkStructureType                   sType;
11112     void*                             pNext;
11113     VkShaderCorePropertiesFlagsAMD    shaderCoreFeatures;
11114     uint32_t                          activeComputeUnitCount;
11115 } VkPhysicalDeviceShaderCoreProperties2AMD;
11116
11117
11118
11119 #define VK_AMD_device_coherent_memory 1
11120 #define VK_AMD_DEVICE_COHERENT_MEMORY_SPEC_VERSION 1
11121 #define VK_AMD_DEVICE_COHERENT_MEMORY_EXTENSION_NAME "VK_AMD_device_coherent_memory"
11122 typedef struct VkPhysicalDeviceCoherentMemoryFeaturesAMD {
11123     VkStructureType    sType;
11124     void*              pNext;
11125     VkBool32           deviceCoherentMemory;
11126 } VkPhysicalDeviceCoherentMemoryFeaturesAMD;
11127
11128
11129
11130 #define VK_EXT_shader_image_atomic_int64 1
11131 #define VK_EXT_SHADER_IMAGE_ATOMIC_INT64_SPEC_VERSION 1
11132 #define VK_EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME "VK_EXT_shader_image_atomic_int64"
11133 typedef struct VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT {
11134     VkStructureType    sType;
11135     void*              pNext;
11136     VkBool32           shaderImageInt64Atomics;
11137     VkBool32           sparseImageInt64Atomics;
11138 } VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT;
11139
11140
11141
11142 #define VK_EXT_memory_budget 1
11143 #define VK_EXT_MEMORY_BUDGET_SPEC_VERSION 1
11144 #define VK_EXT_MEMORY_BUDGET_EXTENSION_NAME "VK_EXT_memory_budget"
11145 typedef struct VkPhysicalDeviceMemoryBudgetPropertiesEXT {
11146     VkStructureType    sType;
11147     void*              pNext;
11148     VkDeviceSize       heapBudget[VK_MAX_MEMORY_HEAPS];
11149     VkDeviceSize       heapUsage[VK_MAX_MEMORY_HEAPS];
11150 } VkPhysicalDeviceMemoryBudgetPropertiesEXT;
11151
11152
11153
11154 #define VK_EXT_memory_priority 1
11155 #define VK_EXT_MEMORY_PRIORITY_SPEC_VERSION 1
11156 #define VK_EXT_MEMORY_PRIORITY_EXTENSION_NAME "VK_EXT_memory_priority"
11157 typedef struct VkPhysicalDeviceMemoryPriorityFeaturesEXT {
11158     VkStructureType    sType;
11159     void*              pNext;
11160     VkBool32           memoryPriority;
11161 } VkPhysicalDeviceMemoryPriorityFeaturesEXT;
11162
11163 typedef struct VkMemoryPriorityAllocateInfoEXT {
11164     VkStructureType    sType;
11165     const void*        pNext;
11166     float              priority;
11167 } VkMemoryPriorityAllocateInfoEXT;
11168
11169
11170
11171 #define VK_NV_dedicated_allocation_image_aliasing 1
11172 #define VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_SPEC_VERSION 1
11173 #define VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_EXTENSION_NAME "VK_NV_dedicated_allocation_image_aliasing"
11174 typedef struct VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
11175     VkStructureType    sType;
11176     void*              pNext;
11177     VkBool32           dedicatedAllocationImageAliasing;
11178 } VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;
11179
11180
11181
11182 #define VK_EXT_buffer_device_address 1
11183 #define VK_EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION 2
11184 #define VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME "VK_EXT_buffer_device_address"
11185 typedef struct VkPhysicalDeviceBufferDeviceAddressFeaturesEXT {
11186     VkStructureType    sType;
11187     void*              pNext;
11188     VkBool32           bufferDeviceAddress;
11189     VkBool32           bufferDeviceAddressCaptureReplay;
11190     VkBool32           bufferDeviceAddressMultiDevice;
11191 } VkPhysicalDeviceBufferDeviceAddressFeaturesEXT;
11192
11193 typedef VkPhysicalDeviceBufferDeviceAddressFeaturesEXT VkPhysicalDeviceBufferAddressFeaturesEXT;
11194
11195 typedef VkBufferDeviceAddressInfo VkBufferDeviceAddressInfoEXT;
11196
11197 typedef struct VkBufferDeviceAddressCreateInfoEXT {
11198     VkStructureType    sType;
11199     const void*        pNext;
11200     VkDeviceAddress    deviceAddress;
11201 } VkBufferDeviceAddressCreateInfoEXT;
11202
11203 typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddressEXT)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo);
11204
11205 #ifndef VK_NO_PROTOTYPES
11206 VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressEXT(
11207     VkDevice                                    device,
11208     const VkBufferDeviceAddressInfo*            pInfo);
11209 #endif
11210
11211
11212 #define VK_EXT_tooling_info 1
11213 #define VK_EXT_TOOLING_INFO_SPEC_VERSION  1
11214 #define VK_EXT_TOOLING_INFO_EXTENSION_NAME "VK_EXT_tooling_info"
11215
11216 typedef enum VkToolPurposeFlagBitsEXT {
11217     VK_TOOL_PURPOSE_VALIDATION_BIT_EXT = 0x00000001,
11218     VK_TOOL_PURPOSE_PROFILING_BIT_EXT = 0x00000002,
11219     VK_TOOL_PURPOSE_TRACING_BIT_EXT = 0x00000004,
11220     VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT_EXT = 0x00000008,
11221     VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT_EXT = 0x00000010,
11222     VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT = 0x00000020,
11223     VK_TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT = 0x00000040,
11224     VK_TOOL_PURPOSE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
11225 } VkToolPurposeFlagBitsEXT;
11226 typedef VkFlags VkToolPurposeFlagsEXT;
11227 typedef struct VkPhysicalDeviceToolPropertiesEXT {
11228     VkStructureType          sType;
11229     void*                    pNext;
11230     char                     name[VK_MAX_EXTENSION_NAME_SIZE];
11231     char                     version[VK_MAX_EXTENSION_NAME_SIZE];
11232     VkToolPurposeFlagsEXT    purposes;
11233     char                     description[VK_MAX_DESCRIPTION_SIZE];
11234     char                     layer[VK_MAX_EXTENSION_NAME_SIZE];
11235 } VkPhysicalDeviceToolPropertiesEXT;
11236
11237 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceToolPropertiesEXT)(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolPropertiesEXT* pToolProperties);
11238
11239 #ifndef VK_NO_PROTOTYPES
11240 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceToolPropertiesEXT(
11241     VkPhysicalDevice                            physicalDevice,
11242     uint32_t*                                   pToolCount,
11243     VkPhysicalDeviceToolPropertiesEXT*          pToolProperties);
11244 #endif
11245
11246
11247 #define VK_EXT_separate_stencil_usage 1
11248 #define VK_EXT_SEPARATE_STENCIL_USAGE_SPEC_VERSION 1
11249 #define VK_EXT_SEPARATE_STENCIL_USAGE_EXTENSION_NAME "VK_EXT_separate_stencil_usage"
11250 typedef VkImageStencilUsageCreateInfo VkImageStencilUsageCreateInfoEXT;
11251
11252
11253
11254 #define VK_EXT_validation_features 1
11255 #define VK_EXT_VALIDATION_FEATURES_SPEC_VERSION 5
11256 #define VK_EXT_VALIDATION_FEATURES_EXTENSION_NAME "VK_EXT_validation_features"
11257
11258 typedef enum VkValidationFeatureEnableEXT {
11259     VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT = 0,
11260     VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT = 1,
11261     VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT = 2,
11262     VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT = 3,
11263     VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT = 4,
11264     VK_VALIDATION_FEATURE_ENABLE_MAX_ENUM_EXT = 0x7FFFFFFF
11265 } VkValidationFeatureEnableEXT;
11266
11267 typedef enum VkValidationFeatureDisableEXT {
11268     VK_VALIDATION_FEATURE_DISABLE_ALL_EXT = 0,
11269     VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT = 1,
11270     VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT = 2,
11271     VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT = 3,
11272     VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT = 4,
11273     VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT = 5,
11274     VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT = 6,
11275     VK_VALIDATION_FEATURE_DISABLE_SHADER_VALIDATION_CACHE_EXT = 7,
11276     VK_VALIDATION_FEATURE_DISABLE_MAX_ENUM_EXT = 0x7FFFFFFF
11277 } VkValidationFeatureDisableEXT;
11278 typedef struct VkValidationFeaturesEXT {
11279     VkStructureType                         sType;
11280     const void*                             pNext;
11281     uint32_t                                enabledValidationFeatureCount;
11282     const VkValidationFeatureEnableEXT*     pEnabledValidationFeatures;
11283     uint32_t                                disabledValidationFeatureCount;
11284     const VkValidationFeatureDisableEXT*    pDisabledValidationFeatures;
11285 } VkValidationFeaturesEXT;
11286
11287
11288
11289 #define VK_NV_cooperative_matrix 1
11290 #define VK_NV_COOPERATIVE_MATRIX_SPEC_VERSION 1
11291 #define VK_NV_COOPERATIVE_MATRIX_EXTENSION_NAME "VK_NV_cooperative_matrix"
11292
11293 typedef enum VkComponentTypeNV {
11294     VK_COMPONENT_TYPE_FLOAT16_NV = 0,
11295     VK_COMPONENT_TYPE_FLOAT32_NV = 1,
11296     VK_COMPONENT_TYPE_FLOAT64_NV = 2,
11297     VK_COMPONENT_TYPE_SINT8_NV = 3,
11298     VK_COMPONENT_TYPE_SINT16_NV = 4,
11299     VK_COMPONENT_TYPE_SINT32_NV = 5,
11300     VK_COMPONENT_TYPE_SINT64_NV = 6,
11301     VK_COMPONENT_TYPE_UINT8_NV = 7,
11302     VK_COMPONENT_TYPE_UINT16_NV = 8,
11303     VK_COMPONENT_TYPE_UINT32_NV = 9,
11304     VK_COMPONENT_TYPE_UINT64_NV = 10,
11305     VK_COMPONENT_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
11306 } VkComponentTypeNV;
11307
11308 typedef enum VkScopeNV {
11309     VK_SCOPE_DEVICE_NV = 1,
11310     VK_SCOPE_WORKGROUP_NV = 2,
11311     VK_SCOPE_SUBGROUP_NV = 3,
11312     VK_SCOPE_QUEUE_FAMILY_NV = 5,
11313     VK_SCOPE_MAX_ENUM_NV = 0x7FFFFFFF
11314 } VkScopeNV;
11315 typedef struct VkCooperativeMatrixPropertiesNV {
11316     VkStructureType      sType;
11317     void*                pNext;
11318     uint32_t             MSize;
11319     uint32_t             NSize;
11320     uint32_t             KSize;
11321     VkComponentTypeNV    AType;
11322     VkComponentTypeNV    BType;
11323     VkComponentTypeNV    CType;
11324     VkComponentTypeNV    DType;
11325     VkScopeNV            scope;
11326 } VkCooperativeMatrixPropertiesNV;
11327
11328 typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesNV {
11329     VkStructureType    sType;
11330     void*              pNext;
11331     VkBool32           cooperativeMatrix;
11332     VkBool32           cooperativeMatrixRobustBufferAccess;
11333 } VkPhysicalDeviceCooperativeMatrixFeaturesNV;
11334
11335 typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesNV {
11336     VkStructureType       sType;
11337     void*                 pNext;
11338     VkShaderStageFlags    cooperativeMatrixSupportedStages;
11339 } VkPhysicalDeviceCooperativeMatrixPropertiesNV;
11340
11341 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties);
11342
11343 #ifndef VK_NO_PROTOTYPES
11344 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(
11345     VkPhysicalDevice                            physicalDevice,
11346     uint32_t*                                   pPropertyCount,
11347     VkCooperativeMatrixPropertiesNV*            pProperties);
11348 #endif
11349
11350
11351 #define VK_NV_coverage_reduction_mode 1
11352 #define VK_NV_COVERAGE_REDUCTION_MODE_SPEC_VERSION 1
11353 #define VK_NV_COVERAGE_REDUCTION_MODE_EXTENSION_NAME "VK_NV_coverage_reduction_mode"
11354
11355 typedef enum VkCoverageReductionModeNV {
11356     VK_COVERAGE_REDUCTION_MODE_MERGE_NV = 0,
11357     VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV = 1,
11358     VK_COVERAGE_REDUCTION_MODE_MAX_ENUM_NV = 0x7FFFFFFF
11359 } VkCoverageReductionModeNV;
11360 typedef VkFlags VkPipelineCoverageReductionStateCreateFlagsNV;
11361 typedef struct VkPhysicalDeviceCoverageReductionModeFeaturesNV {
11362     VkStructureType    sType;
11363     void*              pNext;
11364     VkBool32           coverageReductionMode;
11365 } VkPhysicalDeviceCoverageReductionModeFeaturesNV;
11366
11367 typedef struct VkPipelineCoverageReductionStateCreateInfoNV {
11368     VkStructureType                                  sType;
11369     const void*                                      pNext;
11370     VkPipelineCoverageReductionStateCreateFlagsNV    flags;
11371     VkCoverageReductionModeNV                        coverageReductionMode;
11372 } VkPipelineCoverageReductionStateCreateInfoNV;
11373
11374 typedef struct VkFramebufferMixedSamplesCombinationNV {
11375     VkStructureType              sType;
11376     void*                        pNext;
11377     VkCoverageReductionModeNV    coverageReductionMode;
11378     VkSampleCountFlagBits        rasterizationSamples;
11379     VkSampleCountFlags           depthStencilSamples;
11380     VkSampleCountFlags           colorSamples;
11381 } VkFramebufferMixedSamplesCombinationNV;
11382
11383 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV)(VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations);
11384
11385 #ifndef VK_NO_PROTOTYPES
11386 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
11387     VkPhysicalDevice                            physicalDevice,
11388     uint32_t*                                   pCombinationCount,
11389     VkFramebufferMixedSamplesCombinationNV*     pCombinations);
11390 #endif
11391
11392
11393 #define VK_EXT_fragment_shader_interlock 1
11394 #define VK_EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION 1
11395 #define VK_EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME "VK_EXT_fragment_shader_interlock"
11396 typedef struct VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT {
11397     VkStructureType    sType;
11398     void*              pNext;
11399     VkBool32           fragmentShaderSampleInterlock;
11400     VkBool32           fragmentShaderPixelInterlock;
11401     VkBool32           fragmentShaderShadingRateInterlock;
11402 } VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT;
11403
11404
11405
11406 #define VK_EXT_ycbcr_image_arrays 1
11407 #define VK_EXT_YCBCR_IMAGE_ARRAYS_SPEC_VERSION 1
11408 #define VK_EXT_YCBCR_IMAGE_ARRAYS_EXTENSION_NAME "VK_EXT_ycbcr_image_arrays"
11409 typedef struct VkPhysicalDeviceYcbcrImageArraysFeaturesEXT {
11410     VkStructureType    sType;
11411     void*              pNext;
11412     VkBool32           ycbcrImageArrays;
11413 } VkPhysicalDeviceYcbcrImageArraysFeaturesEXT;
11414
11415
11416
11417 #define VK_EXT_provoking_vertex 1
11418 #define VK_EXT_PROVOKING_VERTEX_SPEC_VERSION 1
11419 #define VK_EXT_PROVOKING_VERTEX_EXTENSION_NAME "VK_EXT_provoking_vertex"
11420
11421 typedef enum VkProvokingVertexModeEXT {
11422     VK_PROVOKING_VERTEX_MODE_FIRST_VERTEX_EXT = 0,
11423     VK_PROVOKING_VERTEX_MODE_LAST_VERTEX_EXT = 1,
11424     VK_PROVOKING_VERTEX_MODE_MAX_ENUM_EXT = 0x7FFFFFFF
11425 } VkProvokingVertexModeEXT;
11426 typedef struct VkPhysicalDeviceProvokingVertexFeaturesEXT {
11427     VkStructureType    sType;
11428     void*              pNext;
11429     VkBool32           provokingVertexLast;
11430     VkBool32           transformFeedbackPreservesProvokingVertex;
11431 } VkPhysicalDeviceProvokingVertexFeaturesEXT;
11432
11433 typedef struct VkPhysicalDeviceProvokingVertexPropertiesEXT {
11434     VkStructureType    sType;
11435     void*              pNext;
11436     VkBool32           provokingVertexModePerPipeline;
11437     VkBool32           transformFeedbackPreservesTriangleFanProvokingVertex;
11438 } VkPhysicalDeviceProvokingVertexPropertiesEXT;
11439
11440 typedef struct VkPipelineRasterizationProvokingVertexStateCreateInfoEXT {
11441     VkStructureType             sType;
11442     const void*                 pNext;
11443     VkProvokingVertexModeEXT    provokingVertexMode;
11444 } VkPipelineRasterizationProvokingVertexStateCreateInfoEXT;
11445
11446
11447
11448 #define VK_EXT_headless_surface 1
11449 #define VK_EXT_HEADLESS_SURFACE_SPEC_VERSION 1
11450 #define VK_EXT_HEADLESS_SURFACE_EXTENSION_NAME "VK_EXT_headless_surface"
11451 typedef VkFlags VkHeadlessSurfaceCreateFlagsEXT;
11452 typedef struct VkHeadlessSurfaceCreateInfoEXT {
11453     VkStructureType                    sType;
11454     const void*                        pNext;
11455     VkHeadlessSurfaceCreateFlagsEXT    flags;
11456 } VkHeadlessSurfaceCreateInfoEXT;
11457
11458 typedef VkResult (VKAPI_PTR *PFN_vkCreateHeadlessSurfaceEXT)(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
11459
11460 #ifndef VK_NO_PROTOTYPES
11461 VKAPI_ATTR VkResult VKAPI_CALL vkCreateHeadlessSurfaceEXT(
11462     VkInstance                                  instance,
11463     const VkHeadlessSurfaceCreateInfoEXT*       pCreateInfo,
11464     const VkAllocationCallbacks*                pAllocator,
11465     VkSurfaceKHR*                               pSurface);
11466 #endif
11467
11468
11469 #define VK_EXT_line_rasterization 1
11470 #define VK_EXT_LINE_RASTERIZATION_SPEC_VERSION 1
11471 #define VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME "VK_EXT_line_rasterization"
11472
11473 typedef enum VkLineRasterizationModeEXT {
11474     VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT = 0,
11475     VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT = 1,
11476     VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT = 2,
11477     VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT = 3,
11478     VK_LINE_RASTERIZATION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF
11479 } VkLineRasterizationModeEXT;
11480 typedef struct VkPhysicalDeviceLineRasterizationFeaturesEXT {
11481     VkStructureType    sType;
11482     void*              pNext;
11483     VkBool32           rectangularLines;
11484     VkBool32           bresenhamLines;
11485     VkBool32           smoothLines;
11486     VkBool32           stippledRectangularLines;
11487     VkBool32           stippledBresenhamLines;
11488     VkBool32           stippledSmoothLines;
11489 } VkPhysicalDeviceLineRasterizationFeaturesEXT;
11490
11491 typedef struct VkPhysicalDeviceLineRasterizationPropertiesEXT {
11492     VkStructureType    sType;
11493     void*              pNext;
11494     uint32_t           lineSubPixelPrecisionBits;
11495 } VkPhysicalDeviceLineRasterizationPropertiesEXT;
11496
11497 typedef struct VkPipelineRasterizationLineStateCreateInfoEXT {
11498     VkStructureType               sType;
11499     const void*                   pNext;
11500     VkLineRasterizationModeEXT    lineRasterizationMode;
11501     VkBool32                      stippledLineEnable;
11502     uint32_t                      lineStippleFactor;
11503     uint16_t                      lineStipplePattern;
11504 } VkPipelineRasterizationLineStateCreateInfoEXT;
11505
11506 typedef void (VKAPI_PTR *PFN_vkCmdSetLineStippleEXT)(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern);
11507
11508 #ifndef VK_NO_PROTOTYPES
11509 VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleEXT(
11510     VkCommandBuffer                             commandBuffer,
11511     uint32_t                                    lineStippleFactor,
11512     uint16_t                                    lineStipplePattern);
11513 #endif
11514
11515
11516 #define VK_EXT_shader_atomic_float 1
11517 #define VK_EXT_SHADER_ATOMIC_FLOAT_SPEC_VERSION 1
11518 #define VK_EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME "VK_EXT_shader_atomic_float"
11519 typedef struct VkPhysicalDeviceShaderAtomicFloatFeaturesEXT {
11520     VkStructureType    sType;
11521     void*              pNext;
11522     VkBool32           shaderBufferFloat32Atomics;
11523     VkBool32           shaderBufferFloat32AtomicAdd;
11524     VkBool32           shaderBufferFloat64Atomics;
11525     VkBool32           shaderBufferFloat64AtomicAdd;
11526     VkBool32           shaderSharedFloat32Atomics;
11527     VkBool32           shaderSharedFloat32AtomicAdd;
11528     VkBool32           shaderSharedFloat64Atomics;
11529     VkBool32           shaderSharedFloat64AtomicAdd;
11530     VkBool32           shaderImageFloat32Atomics;
11531     VkBool32           shaderImageFloat32AtomicAdd;
11532     VkBool32           sparseImageFloat32Atomics;
11533     VkBool32           sparseImageFloat32AtomicAdd;
11534 } VkPhysicalDeviceShaderAtomicFloatFeaturesEXT;
11535
11536
11537
11538 #define VK_EXT_host_query_reset 1
11539 #define VK_EXT_HOST_QUERY_RESET_SPEC_VERSION 1
11540 #define VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME "VK_EXT_host_query_reset"
11541 typedef VkPhysicalDeviceHostQueryResetFeatures VkPhysicalDeviceHostQueryResetFeaturesEXT;
11542
11543 typedef void (VKAPI_PTR *PFN_vkResetQueryPoolEXT)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);
11544
11545 #ifndef VK_NO_PROTOTYPES
11546 VKAPI_ATTR void VKAPI_CALL vkResetQueryPoolEXT(
11547     VkDevice                                    device,
11548     VkQueryPool                                 queryPool,
11549     uint32_t                                    firstQuery,
11550     uint32_t                                    queryCount);
11551 #endif
11552
11553
11554 #define VK_EXT_index_type_uint8 1
11555 #define VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION 1
11556 #define VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME "VK_EXT_index_type_uint8"
11557 typedef struct VkPhysicalDeviceIndexTypeUint8FeaturesEXT {
11558     VkStructureType    sType;
11559     void*              pNext;
11560     VkBool32           indexTypeUint8;
11561 } VkPhysicalDeviceIndexTypeUint8FeaturesEXT;
11562
11563
11564
11565 #define VK_EXT_extended_dynamic_state 1
11566 #define VK_EXT_EXTENDED_DYNAMIC_STATE_SPEC_VERSION 1
11567 #define VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME "VK_EXT_extended_dynamic_state"
11568 typedef struct VkPhysicalDeviceExtendedDynamicStateFeaturesEXT {
11569     VkStructureType    sType;
11570     void*              pNext;
11571     VkBool32           extendedDynamicState;
11572 } VkPhysicalDeviceExtendedDynamicStateFeaturesEXT;
11573
11574 typedef void (VKAPI_PTR *PFN_vkCmdSetCullModeEXT)(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode);
11575 typedef void (VKAPI_PTR *PFN_vkCmdSetFrontFaceEXT)(VkCommandBuffer commandBuffer, VkFrontFace frontFace);
11576 typedef void (VKAPI_PTR *PFN_vkCmdSetPrimitiveTopologyEXT)(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology);
11577 typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWithCountEXT)(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports);
11578 typedef void (VKAPI_PTR *PFN_vkCmdSetScissorWithCountEXT)(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors);
11579 typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers2EXT)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides);
11580 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable);
11581 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthWriteEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable);
11582 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthCompareOpEXT)(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp);
11583 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBoundsTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable);
11584 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable);
11585 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilOpEXT)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp);
11586
11587 #ifndef VK_NO_PROTOTYPES
11588 VKAPI_ATTR void VKAPI_CALL vkCmdSetCullModeEXT(
11589     VkCommandBuffer                             commandBuffer,
11590     VkCullModeFlags                             cullMode);
11591
11592 VKAPI_ATTR void VKAPI_CALL vkCmdSetFrontFaceEXT(
11593     VkCommandBuffer                             commandBuffer,
11594     VkFrontFace                                 frontFace);
11595
11596 VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveTopologyEXT(
11597     VkCommandBuffer                             commandBuffer,
11598     VkPrimitiveTopology                         primitiveTopology);
11599
11600 VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWithCountEXT(
11601     VkCommandBuffer                             commandBuffer,
11602     uint32_t                                    viewportCount,
11603     const VkViewport*                           pViewports);
11604
11605 VKAPI_ATTR void VKAPI_CALL vkCmdSetScissorWithCountEXT(
11606     VkCommandBuffer                             commandBuffer,
11607     uint32_t                                    scissorCount,
11608     const VkRect2D*                             pScissors);
11609
11610 VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers2EXT(
11611     VkCommandBuffer                             commandBuffer,
11612     uint32_t                                    firstBinding,
11613     uint32_t                                    bindingCount,
11614     const VkBuffer*                             pBuffers,
11615     const VkDeviceSize*                         pOffsets,
11616     const VkDeviceSize*                         pSizes,
11617     const VkDeviceSize*                         pStrides);
11618
11619 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthTestEnableEXT(
11620     VkCommandBuffer                             commandBuffer,
11621     VkBool32                                    depthTestEnable);
11622
11623 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthWriteEnableEXT(
11624     VkCommandBuffer                             commandBuffer,
11625     VkBool32                                    depthWriteEnable);
11626
11627 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthCompareOpEXT(
11628     VkCommandBuffer                             commandBuffer,
11629     VkCompareOp                                 depthCompareOp);
11630
11631 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBoundsTestEnableEXT(
11632     VkCommandBuffer                             commandBuffer,
11633     VkBool32                                    depthBoundsTestEnable);
11634
11635 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilTestEnableEXT(
11636     VkCommandBuffer                             commandBuffer,
11637     VkBool32                                    stencilTestEnable);
11638
11639 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilOpEXT(
11640     VkCommandBuffer                             commandBuffer,
11641     VkStencilFaceFlags                          faceMask,
11642     VkStencilOp                                 failOp,
11643     VkStencilOp                                 passOp,
11644     VkStencilOp                                 depthFailOp,
11645     VkCompareOp                                 compareOp);
11646 #endif
11647
11648
11649 #define VK_EXT_shader_atomic_float2 1
11650 #define VK_EXT_SHADER_ATOMIC_FLOAT_2_SPEC_VERSION 1
11651 #define VK_EXT_SHADER_ATOMIC_FLOAT_2_EXTENSION_NAME "VK_EXT_shader_atomic_float2"
11652 typedef struct VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT {
11653     VkStructureType    sType;
11654     void*              pNext;
11655     VkBool32           shaderBufferFloat16Atomics;
11656     VkBool32           shaderBufferFloat16AtomicAdd;
11657     VkBool32           shaderBufferFloat16AtomicMinMax;
11658     VkBool32           shaderBufferFloat32AtomicMinMax;
11659     VkBool32           shaderBufferFloat64AtomicMinMax;
11660     VkBool32           shaderSharedFloat16Atomics;
11661     VkBool32           shaderSharedFloat16AtomicAdd;
11662     VkBool32           shaderSharedFloat16AtomicMinMax;
11663     VkBool32           shaderSharedFloat32AtomicMinMax;
11664     VkBool32           shaderSharedFloat64AtomicMinMax;
11665     VkBool32           shaderImageFloat32AtomicMinMax;
11666     VkBool32           sparseImageFloat32AtomicMinMax;
11667 } VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT;
11668
11669
11670
11671 #define VK_EXT_shader_demote_to_helper_invocation 1
11672 #define VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_SPEC_VERSION 1
11673 #define VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME "VK_EXT_shader_demote_to_helper_invocation"
11674 typedef struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT {
11675     VkStructureType    sType;
11676     void*              pNext;
11677     VkBool32           shaderDemoteToHelperInvocation;
11678 } VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT;
11679
11680
11681
11682 #define VK_NV_device_generated_commands 1
11683 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutNV)
11684 #define VK_NV_DEVICE_GENERATED_COMMANDS_SPEC_VERSION 3
11685 #define VK_NV_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME "VK_NV_device_generated_commands"
11686
11687 typedef enum VkIndirectCommandsTokenTypeNV {
11688     VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV = 0,
11689     VK_INDIRECT_COMMANDS_TOKEN_TYPE_STATE_FLAGS_NV = 1,
11690     VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NV = 2,
11691     VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NV = 3,
11692     VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV = 4,
11693     VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV = 5,
11694     VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV = 6,
11695     VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV = 7,
11696     VK_INDIRECT_COMMANDS_TOKEN_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
11697 } VkIndirectCommandsTokenTypeNV;
11698
11699 typedef enum VkIndirectStateFlagBitsNV {
11700     VK_INDIRECT_STATE_FLAG_FRONTFACE_BIT_NV = 0x00000001,
11701     VK_INDIRECT_STATE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
11702 } VkIndirectStateFlagBitsNV;
11703 typedef VkFlags VkIndirectStateFlagsNV;
11704
11705 typedef enum VkIndirectCommandsLayoutUsageFlagBitsNV {
11706     VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV = 0x00000001,
11707     VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NV = 0x00000002,
11708     VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NV = 0x00000004,
11709     VK_INDIRECT_COMMANDS_LAYOUT_USAGE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
11710 } VkIndirectCommandsLayoutUsageFlagBitsNV;
11711 typedef VkFlags VkIndirectCommandsLayoutUsageFlagsNV;
11712 typedef struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
11713     VkStructureType    sType;
11714     void*              pNext;
11715     uint32_t           maxGraphicsShaderGroupCount;
11716     uint32_t           maxIndirectSequenceCount;
11717     uint32_t           maxIndirectCommandsTokenCount;
11718     uint32_t           maxIndirectCommandsStreamCount;
11719     uint32_t           maxIndirectCommandsTokenOffset;
11720     uint32_t           maxIndirectCommandsStreamStride;
11721     uint32_t           minSequencesCountBufferOffsetAlignment;
11722     uint32_t           minSequencesIndexBufferOffsetAlignment;
11723     uint32_t           minIndirectCommandsBufferOffsetAlignment;
11724 } VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV;
11725
11726 typedef struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
11727     VkStructureType    sType;
11728     void*              pNext;
11729     VkBool32           deviceGeneratedCommands;
11730 } VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV;
11731
11732 typedef struct VkGraphicsShaderGroupCreateInfoNV {
11733     VkStructureType                                 sType;
11734     const void*                                     pNext;
11735     uint32_t                                        stageCount;
11736     const VkPipelineShaderStageCreateInfo*          pStages;
11737     const VkPipelineVertexInputStateCreateInfo*     pVertexInputState;
11738     const VkPipelineTessellationStateCreateInfo*    pTessellationState;
11739 } VkGraphicsShaderGroupCreateInfoNV;
11740
11741 typedef struct VkGraphicsPipelineShaderGroupsCreateInfoNV {
11742     VkStructureType                             sType;
11743     const void*                                 pNext;
11744     uint32_t                                    groupCount;
11745     const VkGraphicsShaderGroupCreateInfoNV*    pGroups;
11746     uint32_t                                    pipelineCount;
11747     const VkPipeline*                           pPipelines;
11748 } VkGraphicsPipelineShaderGroupsCreateInfoNV;
11749
11750 typedef struct VkBindShaderGroupIndirectCommandNV {
11751     uint32_t    groupIndex;
11752 } VkBindShaderGroupIndirectCommandNV;
11753
11754 typedef struct VkBindIndexBufferIndirectCommandNV {
11755     VkDeviceAddress    bufferAddress;
11756     uint32_t           size;
11757     VkIndexType        indexType;
11758 } VkBindIndexBufferIndirectCommandNV;
11759
11760 typedef struct VkBindVertexBufferIndirectCommandNV {
11761     VkDeviceAddress    bufferAddress;
11762     uint32_t           size;
11763     uint32_t           stride;
11764 } VkBindVertexBufferIndirectCommandNV;
11765
11766 typedef struct VkSetStateFlagsIndirectCommandNV {
11767     uint32_t    data;
11768 } VkSetStateFlagsIndirectCommandNV;
11769
11770 typedef struct VkIndirectCommandsStreamNV {
11771     VkBuffer        buffer;
11772     VkDeviceSize    offset;
11773 } VkIndirectCommandsStreamNV;
11774
11775 typedef struct VkIndirectCommandsLayoutTokenNV {
11776     VkStructureType                  sType;
11777     const void*                      pNext;
11778     VkIndirectCommandsTokenTypeNV    tokenType;
11779     uint32_t                         stream;
11780     uint32_t                         offset;
11781     uint32_t                         vertexBindingUnit;
11782     VkBool32                         vertexDynamicStride;
11783     VkPipelineLayout                 pushconstantPipelineLayout;
11784     VkShaderStageFlags               pushconstantShaderStageFlags;
11785     uint32_t                         pushconstantOffset;
11786     uint32_t                         pushconstantSize;
11787     VkIndirectStateFlagsNV           indirectStateFlags;
11788     uint32_t                         indexTypeCount;
11789     const VkIndexType*               pIndexTypes;
11790     const uint32_t*                  pIndexTypeValues;
11791 } VkIndirectCommandsLayoutTokenNV;
11792
11793 typedef struct VkIndirectCommandsLayoutCreateInfoNV {
11794     VkStructureType                           sType;
11795     const void*                               pNext;
11796     VkIndirectCommandsLayoutUsageFlagsNV      flags;
11797     VkPipelineBindPoint                       pipelineBindPoint;
11798     uint32_t                                  tokenCount;
11799     const VkIndirectCommandsLayoutTokenNV*    pTokens;
11800     uint32_t                                  streamCount;
11801     const uint32_t*                           pStreamStrides;
11802 } VkIndirectCommandsLayoutCreateInfoNV;
11803
11804 typedef struct VkGeneratedCommandsInfoNV {
11805     VkStructureType                      sType;
11806     const void*                          pNext;
11807     VkPipelineBindPoint                  pipelineBindPoint;
11808     VkPipeline                           pipeline;
11809     VkIndirectCommandsLayoutNV           indirectCommandsLayout;
11810     uint32_t                             streamCount;
11811     const VkIndirectCommandsStreamNV*    pStreams;
11812     uint32_t                             sequencesCount;
11813     VkBuffer                             preprocessBuffer;
11814     VkDeviceSize                         preprocessOffset;
11815     VkDeviceSize                         preprocessSize;
11816     VkBuffer                             sequencesCountBuffer;
11817     VkDeviceSize                         sequencesCountOffset;
11818     VkBuffer                             sequencesIndexBuffer;
11819     VkDeviceSize                         sequencesIndexOffset;
11820 } VkGeneratedCommandsInfoNV;
11821
11822 typedef struct VkGeneratedCommandsMemoryRequirementsInfoNV {
11823     VkStructureType               sType;
11824     const void*                   pNext;
11825     VkPipelineBindPoint           pipelineBindPoint;
11826     VkPipeline                    pipeline;
11827     VkIndirectCommandsLayoutNV    indirectCommandsLayout;
11828     uint32_t                      maxSequencesCount;
11829 } VkGeneratedCommandsMemoryRequirementsInfoNV;
11830
11831 typedef void (VKAPI_PTR *PFN_vkGetGeneratedCommandsMemoryRequirementsNV)(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2* pMemoryRequirements);
11832 typedef void (VKAPI_PTR *PFN_vkCmdPreprocessGeneratedCommandsNV)(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo);
11833 typedef void (VKAPI_PTR *PFN_vkCmdExecuteGeneratedCommandsNV)(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo);
11834 typedef void (VKAPI_PTR *PFN_vkCmdBindPipelineShaderGroupNV)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex);
11835 typedef VkResult (VKAPI_PTR *PFN_vkCreateIndirectCommandsLayoutNV)(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNV* pIndirectCommandsLayout);
11836 typedef void (VKAPI_PTR *PFN_vkDestroyIndirectCommandsLayoutNV)(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks* pAllocator);
11837
11838 #ifndef VK_NO_PROTOTYPES
11839 VKAPI_ATTR void VKAPI_CALL vkGetGeneratedCommandsMemoryRequirementsNV(
11840     VkDevice                                    device,
11841     const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo,
11842     VkMemoryRequirements2*                      pMemoryRequirements);
11843
11844 VKAPI_ATTR void VKAPI_CALL vkCmdPreprocessGeneratedCommandsNV(
11845     VkCommandBuffer                             commandBuffer,
11846     const VkGeneratedCommandsInfoNV*            pGeneratedCommandsInfo);
11847
11848 VKAPI_ATTR void VKAPI_CALL vkCmdExecuteGeneratedCommandsNV(
11849     VkCommandBuffer                             commandBuffer,
11850     VkBool32                                    isPreprocessed,
11851     const VkGeneratedCommandsInfoNV*            pGeneratedCommandsInfo);
11852
11853 VKAPI_ATTR void VKAPI_CALL vkCmdBindPipelineShaderGroupNV(
11854     VkCommandBuffer                             commandBuffer,
11855     VkPipelineBindPoint                         pipelineBindPoint,
11856     VkPipeline                                  pipeline,
11857     uint32_t                                    groupIndex);
11858
11859 VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutNV(
11860     VkDevice                                    device,
11861     const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo,
11862     const VkAllocationCallbacks*                pAllocator,
11863     VkIndirectCommandsLayoutNV*                 pIndirectCommandsLayout);
11864
11865 VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectCommandsLayoutNV(
11866     VkDevice                                    device,
11867     VkIndirectCommandsLayoutNV                  indirectCommandsLayout,
11868     const VkAllocationCallbacks*                pAllocator);
11869 #endif
11870
11871
11872 #define VK_NV_inherited_viewport_scissor 1
11873 #define VK_NV_INHERITED_VIEWPORT_SCISSOR_SPEC_VERSION 1
11874 #define VK_NV_INHERITED_VIEWPORT_SCISSOR_EXTENSION_NAME "VK_NV_inherited_viewport_scissor"
11875 typedef struct VkPhysicalDeviceInheritedViewportScissorFeaturesNV {
11876     VkStructureType    sType;
11877     void*              pNext;
11878     VkBool32           inheritedViewportScissor2D;
11879 } VkPhysicalDeviceInheritedViewportScissorFeaturesNV;
11880
11881 typedef struct VkCommandBufferInheritanceViewportScissorInfoNV {
11882     VkStructureType      sType;
11883     const void*          pNext;
11884     VkBool32             viewportScissor2D;
11885     uint32_t             viewportDepthCount;
11886     const VkViewport*    pViewportDepths;
11887 } VkCommandBufferInheritanceViewportScissorInfoNV;
11888
11889
11890
11891 #define VK_EXT_texel_buffer_alignment 1
11892 #define VK_EXT_TEXEL_BUFFER_ALIGNMENT_SPEC_VERSION 1
11893 #define VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME "VK_EXT_texel_buffer_alignment"
11894 typedef struct VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT {
11895     VkStructureType    sType;
11896     void*              pNext;
11897     VkBool32           texelBufferAlignment;
11898 } VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT;
11899
11900 typedef struct VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT {
11901     VkStructureType    sType;
11902     void*              pNext;
11903     VkDeviceSize       storageTexelBufferOffsetAlignmentBytes;
11904     VkBool32           storageTexelBufferOffsetSingleTexelAlignment;
11905     VkDeviceSize       uniformTexelBufferOffsetAlignmentBytes;
11906     VkBool32           uniformTexelBufferOffsetSingleTexelAlignment;
11907 } VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT;
11908
11909
11910
11911 #define VK_QCOM_render_pass_transform 1
11912 #define VK_QCOM_RENDER_PASS_TRANSFORM_SPEC_VERSION 2
11913 #define VK_QCOM_RENDER_PASS_TRANSFORM_EXTENSION_NAME "VK_QCOM_render_pass_transform"
11914 typedef struct VkRenderPassTransformBeginInfoQCOM {
11915     VkStructureType                  sType;
11916     void*                            pNext;
11917     VkSurfaceTransformFlagBitsKHR    transform;
11918 } VkRenderPassTransformBeginInfoQCOM;
11919
11920 typedef struct VkCommandBufferInheritanceRenderPassTransformInfoQCOM {
11921     VkStructureType                  sType;
11922     void*                            pNext;
11923     VkSurfaceTransformFlagBitsKHR    transform;
11924     VkRect2D                         renderArea;
11925 } VkCommandBufferInheritanceRenderPassTransformInfoQCOM;
11926
11927
11928
11929 #define VK_EXT_device_memory_report 1
11930 #define VK_EXT_DEVICE_MEMORY_REPORT_SPEC_VERSION 2
11931 #define VK_EXT_DEVICE_MEMORY_REPORT_EXTENSION_NAME "VK_EXT_device_memory_report"
11932
11933 typedef enum VkDeviceMemoryReportEventTypeEXT {
11934     VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT = 0,
11935     VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT = 1,
11936     VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT = 2,
11937     VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT = 3,
11938     VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT = 4,
11939     VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
11940 } VkDeviceMemoryReportEventTypeEXT;
11941 typedef VkFlags VkDeviceMemoryReportFlagsEXT;
11942 typedef struct VkPhysicalDeviceDeviceMemoryReportFeaturesEXT {
11943     VkStructureType    sType;
11944     void*              pNext;
11945     VkBool32           deviceMemoryReport;
11946 } VkPhysicalDeviceDeviceMemoryReportFeaturesEXT;
11947
11948 typedef struct VkDeviceMemoryReportCallbackDataEXT {
11949     VkStructureType                     sType;
11950     void*                               pNext;
11951     VkDeviceMemoryReportFlagsEXT        flags;
11952     VkDeviceMemoryReportEventTypeEXT    type;
11953     uint64_t                            memoryObjectId;
11954     VkDeviceSize                        size;
11955     VkObjectType                        objectType;
11956     uint64_t                            objectHandle;
11957     uint32_t                            heapIndex;
11958 } VkDeviceMemoryReportCallbackDataEXT;
11959
11960 typedef void (VKAPI_PTR *PFN_vkDeviceMemoryReportCallbackEXT)(
11961     const VkDeviceMemoryReportCallbackDataEXT*  pCallbackData,
11962     void*                                       pUserData);
11963
11964 typedef struct VkDeviceDeviceMemoryReportCreateInfoEXT {
11965     VkStructureType                        sType;
11966     const void*                            pNext;
11967     VkDeviceMemoryReportFlagsEXT           flags;
11968     PFN_vkDeviceMemoryReportCallbackEXT    pfnUserCallback;
11969     void*                                  pUserData;
11970 } VkDeviceDeviceMemoryReportCreateInfoEXT;
11971
11972
11973
11974 #define VK_EXT_acquire_drm_display 1
11975 #define VK_EXT_ACQUIRE_DRM_DISPLAY_SPEC_VERSION 1
11976 #define VK_EXT_ACQUIRE_DRM_DISPLAY_EXTENSION_NAME "VK_EXT_acquire_drm_display"
11977 typedef VkResult (VKAPI_PTR *PFN_vkAcquireDrmDisplayEXT)(VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display);
11978 typedef VkResult (VKAPI_PTR *PFN_vkGetDrmDisplayEXT)(VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR* display);
11979
11980 #ifndef VK_NO_PROTOTYPES
11981 VKAPI_ATTR VkResult VKAPI_CALL vkAcquireDrmDisplayEXT(
11982     VkPhysicalDevice                            physicalDevice,
11983     int32_t                                     drmFd,
11984     VkDisplayKHR                                display);
11985
11986 VKAPI_ATTR VkResult VKAPI_CALL vkGetDrmDisplayEXT(
11987     VkPhysicalDevice                            physicalDevice,
11988     int32_t                                     drmFd,
11989     uint32_t                                    connectorId,
11990     VkDisplayKHR*                               display);
11991 #endif
11992
11993
11994 #define VK_EXT_robustness2 1
11995 #define VK_EXT_ROBUSTNESS_2_SPEC_VERSION  1
11996 #define VK_EXT_ROBUSTNESS_2_EXTENSION_NAME "VK_EXT_robustness2"
11997 typedef struct VkPhysicalDeviceRobustness2FeaturesEXT {
11998     VkStructureType    sType;
11999     void*              pNext;
12000     VkBool32           robustBufferAccess2;
12001     VkBool32           robustImageAccess2;
12002     VkBool32           nullDescriptor;
12003 } VkPhysicalDeviceRobustness2FeaturesEXT;
12004
12005 typedef struct VkPhysicalDeviceRobustness2PropertiesEXT {
12006     VkStructureType    sType;
12007     void*              pNext;
12008     VkDeviceSize       robustStorageBufferAccessSizeAlignment;
12009     VkDeviceSize       robustUniformBufferAccessSizeAlignment;
12010 } VkPhysicalDeviceRobustness2PropertiesEXT;
12011
12012
12013
12014 #define VK_EXT_custom_border_color 1
12015 #define VK_EXT_CUSTOM_BORDER_COLOR_SPEC_VERSION 12
12016 #define VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME "VK_EXT_custom_border_color"
12017 typedef struct VkSamplerCustomBorderColorCreateInfoEXT {
12018     VkStructureType      sType;
12019     const void*          pNext;
12020     VkClearColorValue    customBorderColor;
12021     VkFormat             format;
12022 } VkSamplerCustomBorderColorCreateInfoEXT;
12023
12024 typedef struct VkPhysicalDeviceCustomBorderColorPropertiesEXT {
12025     VkStructureType    sType;
12026     void*              pNext;
12027     uint32_t           maxCustomBorderColorSamplers;
12028 } VkPhysicalDeviceCustomBorderColorPropertiesEXT;
12029
12030 typedef struct VkPhysicalDeviceCustomBorderColorFeaturesEXT {
12031     VkStructureType    sType;
12032     void*              pNext;
12033     VkBool32           customBorderColors;
12034     VkBool32           customBorderColorWithoutFormat;
12035 } VkPhysicalDeviceCustomBorderColorFeaturesEXT;
12036
12037
12038
12039 #define VK_GOOGLE_user_type 1
12040 #define VK_GOOGLE_USER_TYPE_SPEC_VERSION  1
12041 #define VK_GOOGLE_USER_TYPE_EXTENSION_NAME "VK_GOOGLE_user_type"
12042
12043
12044 #define VK_EXT_private_data 1
12045 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPrivateDataSlotEXT)
12046 #define VK_EXT_PRIVATE_DATA_SPEC_VERSION  1
12047 #define VK_EXT_PRIVATE_DATA_EXTENSION_NAME "VK_EXT_private_data"
12048
12049 typedef enum VkPrivateDataSlotCreateFlagBitsEXT {
12050     VK_PRIVATE_DATA_SLOT_CREATE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
12051 } VkPrivateDataSlotCreateFlagBitsEXT;
12052 typedef VkFlags VkPrivateDataSlotCreateFlagsEXT;
12053 typedef struct VkPhysicalDevicePrivateDataFeaturesEXT {
12054     VkStructureType    sType;
12055     void*              pNext;
12056     VkBool32           privateData;
12057 } VkPhysicalDevicePrivateDataFeaturesEXT;
12058
12059 typedef struct VkDevicePrivateDataCreateInfoEXT {
12060     VkStructureType    sType;
12061     const void*        pNext;
12062     uint32_t           privateDataSlotRequestCount;
12063 } VkDevicePrivateDataCreateInfoEXT;
12064
12065 typedef struct VkPrivateDataSlotCreateInfoEXT {
12066     VkStructureType                    sType;
12067     const void*                        pNext;
12068     VkPrivateDataSlotCreateFlagsEXT    flags;
12069 } VkPrivateDataSlotCreateInfoEXT;
12070
12071 typedef VkResult (VKAPI_PTR *PFN_vkCreatePrivateDataSlotEXT)(VkDevice device, const VkPrivateDataSlotCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlotEXT* pPrivateDataSlot);
12072 typedef void (VKAPI_PTR *PFN_vkDestroyPrivateDataSlotEXT)(VkDevice device, VkPrivateDataSlotEXT privateDataSlot, const VkAllocationCallbacks* pAllocator);
12073 typedef VkResult (VKAPI_PTR *PFN_vkSetPrivateDataEXT)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlotEXT privateDataSlot, uint64_t data);
12074 typedef void (VKAPI_PTR *PFN_vkGetPrivateDataEXT)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlotEXT privateDataSlot, uint64_t* pData);
12075
12076 #ifndef VK_NO_PROTOTYPES
12077 VKAPI_ATTR VkResult VKAPI_CALL vkCreatePrivateDataSlotEXT(
12078     VkDevice                                    device,
12079     const VkPrivateDataSlotCreateInfoEXT*       pCreateInfo,
12080     const VkAllocationCallbacks*                pAllocator,
12081     VkPrivateDataSlotEXT*                       pPrivateDataSlot);
12082
12083 VKAPI_ATTR void VKAPI_CALL vkDestroyPrivateDataSlotEXT(
12084     VkDevice                                    device,
12085     VkPrivateDataSlotEXT                        privateDataSlot,
12086     const VkAllocationCallbacks*                pAllocator);
12087
12088 VKAPI_ATTR VkResult VKAPI_CALL vkSetPrivateDataEXT(
12089     VkDevice                                    device,
12090     VkObjectType                                objectType,
12091     uint64_t                                    objectHandle,
12092     VkPrivateDataSlotEXT                        privateDataSlot,
12093     uint64_t                                    data);
12094
12095 VKAPI_ATTR void VKAPI_CALL vkGetPrivateDataEXT(
12096     VkDevice                                    device,
12097     VkObjectType                                objectType,
12098     uint64_t                                    objectHandle,
12099     VkPrivateDataSlotEXT                        privateDataSlot,
12100     uint64_t*                                   pData);
12101 #endif
12102
12103
12104 #define VK_EXT_pipeline_creation_cache_control 1
12105 #define VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_SPEC_VERSION 3
12106 #define VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_EXTENSION_NAME "VK_EXT_pipeline_creation_cache_control"
12107 typedef struct VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT {
12108     VkStructureType    sType;
12109     void*              pNext;
12110     VkBool32           pipelineCreationCacheControl;
12111 } VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT;
12112
12113
12114
12115 #define VK_NV_device_diagnostics_config 1
12116 #define VK_NV_DEVICE_DIAGNOSTICS_CONFIG_SPEC_VERSION 1
12117 #define VK_NV_DEVICE_DIAGNOSTICS_CONFIG_EXTENSION_NAME "VK_NV_device_diagnostics_config"
12118
12119 typedef enum VkDeviceDiagnosticsConfigFlagBitsNV {
12120     VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_DEBUG_INFO_BIT_NV = 0x00000001,
12121     VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_RESOURCE_TRACKING_BIT_NV = 0x00000002,
12122     VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_AUTOMATIC_CHECKPOINTS_BIT_NV = 0x00000004,
12123     VK_DEVICE_DIAGNOSTICS_CONFIG_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
12124 } VkDeviceDiagnosticsConfigFlagBitsNV;
12125 typedef VkFlags VkDeviceDiagnosticsConfigFlagsNV;
12126 typedef struct VkPhysicalDeviceDiagnosticsConfigFeaturesNV {
12127     VkStructureType    sType;
12128     void*              pNext;
12129     VkBool32           diagnosticsConfig;
12130 } VkPhysicalDeviceDiagnosticsConfigFeaturesNV;
12131
12132 typedef struct VkDeviceDiagnosticsConfigCreateInfoNV {
12133     VkStructureType                     sType;
12134     const void*                         pNext;
12135     VkDeviceDiagnosticsConfigFlagsNV    flags;
12136 } VkDeviceDiagnosticsConfigCreateInfoNV;
12137
12138
12139
12140 #define VK_QCOM_render_pass_store_ops 1
12141 #define VK_QCOM_RENDER_PASS_STORE_OPS_SPEC_VERSION 2
12142 #define VK_QCOM_RENDER_PASS_STORE_OPS_EXTENSION_NAME "VK_QCOM_render_pass_store_ops"
12143
12144
12145 #define VK_NV_fragment_shading_rate_enums 1
12146 #define VK_NV_FRAGMENT_SHADING_RATE_ENUMS_SPEC_VERSION 1
12147 #define VK_NV_FRAGMENT_SHADING_RATE_ENUMS_EXTENSION_NAME "VK_NV_fragment_shading_rate_enums"
12148
12149 typedef enum VkFragmentShadingRateTypeNV {
12150     VK_FRAGMENT_SHADING_RATE_TYPE_FRAGMENT_SIZE_NV = 0,
12151     VK_FRAGMENT_SHADING_RATE_TYPE_ENUMS_NV = 1,
12152     VK_FRAGMENT_SHADING_RATE_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
12153 } VkFragmentShadingRateTypeNV;
12154
12155 typedef enum VkFragmentShadingRateNV {
12156     VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV = 0,
12157     VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV = 1,
12158     VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV = 4,
12159     VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV = 5,
12160     VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV = 6,
12161     VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV = 9,
12162     VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV = 10,
12163     VK_FRAGMENT_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV = 11,
12164     VK_FRAGMENT_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV = 12,
12165     VK_FRAGMENT_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV = 13,
12166     VK_FRAGMENT_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV = 14,
12167     VK_FRAGMENT_SHADING_RATE_NO_INVOCATIONS_NV = 15,
12168     VK_FRAGMENT_SHADING_RATE_MAX_ENUM_NV = 0x7FFFFFFF
12169 } VkFragmentShadingRateNV;
12170 typedef struct VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV {
12171     VkStructureType    sType;
12172     void*              pNext;
12173     VkBool32           fragmentShadingRateEnums;
12174     VkBool32           supersampleFragmentShadingRates;
12175     VkBool32           noInvocationFragmentShadingRates;
12176 } VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV;
12177
12178 typedef struct VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV {
12179     VkStructureType          sType;
12180     void*                    pNext;
12181     VkSampleCountFlagBits    maxFragmentShadingRateInvocationCount;
12182 } VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV;
12183
12184 typedef struct VkPipelineFragmentShadingRateEnumStateCreateInfoNV {
12185     VkStructureType                       sType;
12186     const void*                           pNext;
12187     VkFragmentShadingRateTypeNV           shadingRateType;
12188     VkFragmentShadingRateNV               shadingRate;
12189     VkFragmentShadingRateCombinerOpKHR    combinerOps[2];
12190 } VkPipelineFragmentShadingRateEnumStateCreateInfoNV;
12191
12192 typedef void (VKAPI_PTR *PFN_vkCmdSetFragmentShadingRateEnumNV)(VkCommandBuffer           commandBuffer, VkFragmentShadingRateNV                     shadingRate, const VkFragmentShadingRateCombinerOpKHR    combinerOps[2]);
12193
12194 #ifndef VK_NO_PROTOTYPES
12195 VKAPI_ATTR void VKAPI_CALL vkCmdSetFragmentShadingRateEnumNV(
12196     VkCommandBuffer                             commandBuffer,
12197     VkFragmentShadingRateNV                     shadingRate,
12198     const VkFragmentShadingRateCombinerOpKHR    combinerOps[2]);
12199 #endif
12200
12201
12202 #define VK_NV_ray_tracing_motion_blur 1
12203 #define VK_NV_RAY_TRACING_MOTION_BLUR_SPEC_VERSION 1
12204 #define VK_NV_RAY_TRACING_MOTION_BLUR_EXTENSION_NAME "VK_NV_ray_tracing_motion_blur"
12205
12206 typedef enum VkAccelerationStructureMotionInstanceTypeNV {
12207     VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_STATIC_NV = 0,
12208     VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MATRIX_MOTION_NV = 1,
12209     VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_SRT_MOTION_NV = 2,
12210     VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
12211 } VkAccelerationStructureMotionInstanceTypeNV;
12212 typedef VkFlags VkAccelerationStructureMotionInfoFlagsNV;
12213 typedef VkFlags VkAccelerationStructureMotionInstanceFlagsNV;
12214 typedef union VkDeviceOrHostAddressConstKHR {
12215     VkDeviceAddress    deviceAddress;
12216     const void*        hostAddress;
12217 } VkDeviceOrHostAddressConstKHR;
12218
12219 typedef struct VkAccelerationStructureGeometryMotionTrianglesDataNV {
12220     VkStructureType                  sType;
12221     const void*                      pNext;
12222     VkDeviceOrHostAddressConstKHR    vertexData;
12223 } VkAccelerationStructureGeometryMotionTrianglesDataNV;
12224
12225 typedef struct VkAccelerationStructureMotionInfoNV {
12226     VkStructureType                             sType;
12227     const void*                                 pNext;
12228     uint32_t                                    maxInstances;
12229     VkAccelerationStructureMotionInfoFlagsNV    flags;
12230 } VkAccelerationStructureMotionInfoNV;
12231
12232 typedef struct VkAccelerationStructureMatrixMotionInstanceNV {
12233     VkTransformMatrixKHR          transformT0;
12234     VkTransformMatrixKHR          transformT1;
12235     uint32_t                      instanceCustomIndex:24;
12236     uint32_t                      mask:8;
12237     uint32_t                      instanceShaderBindingTableRecordOffset:24;
12238     VkGeometryInstanceFlagsKHR    flags:8;
12239     uint64_t                      accelerationStructureReference;
12240 } VkAccelerationStructureMatrixMotionInstanceNV;
12241
12242 typedef struct VkSRTDataNV {
12243     float    sx;
12244     float    a;
12245     float    b;
12246     float    pvx;
12247     float    sy;
12248     float    c;
12249     float    pvy;
12250     float    sz;
12251     float    pvz;
12252     float    qx;
12253     float    qy;
12254     float    qz;
12255     float    qw;
12256     float    tx;
12257     float    ty;
12258     float    tz;
12259 } VkSRTDataNV;
12260
12261 typedef struct VkAccelerationStructureSRTMotionInstanceNV {
12262     VkSRTDataNV                   transformT0;
12263     VkSRTDataNV                   transformT1;
12264     uint32_t                      instanceCustomIndex:24;
12265     uint32_t                      mask:8;
12266     uint32_t                      instanceShaderBindingTableRecordOffset:24;
12267     VkGeometryInstanceFlagsKHR    flags:8;
12268     uint64_t                      accelerationStructureReference;
12269 } VkAccelerationStructureSRTMotionInstanceNV;
12270
12271 typedef union VkAccelerationStructureMotionInstanceDataNV {
12272     VkAccelerationStructureInstanceKHR               staticInstance;
12273     VkAccelerationStructureMatrixMotionInstanceNV    matrixMotionInstance;
12274     VkAccelerationStructureSRTMotionInstanceNV       srtMotionInstance;
12275 } VkAccelerationStructureMotionInstanceDataNV;
12276
12277 typedef struct VkAccelerationStructureMotionInstanceNV {
12278     VkAccelerationStructureMotionInstanceTypeNV     type;
12279     VkAccelerationStructureMotionInstanceFlagsNV    flags;
12280     VkAccelerationStructureMotionInstanceDataNV     data;
12281 } VkAccelerationStructureMotionInstanceNV;
12282
12283 typedef struct VkPhysicalDeviceRayTracingMotionBlurFeaturesNV {
12284     VkStructureType    sType;
12285     void*              pNext;
12286     VkBool32           rayTracingMotionBlur;
12287     VkBool32           rayTracingMotionBlurPipelineTraceRaysIndirect;
12288 } VkPhysicalDeviceRayTracingMotionBlurFeaturesNV;
12289
12290
12291
12292 #define VK_EXT_ycbcr_2plane_444_formats 1
12293 #define VK_EXT_YCBCR_2PLANE_444_FORMATS_SPEC_VERSION 1
12294 #define VK_EXT_YCBCR_2PLANE_444_FORMATS_EXTENSION_NAME "VK_EXT_ycbcr_2plane_444_formats"
12295 typedef struct VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {
12296     VkStructureType    sType;
12297     void*              pNext;
12298     VkBool32           ycbcr2plane444Formats;
12299 } VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT;
12300
12301
12302
12303 #define VK_EXT_fragment_density_map2 1
12304 #define VK_EXT_FRAGMENT_DENSITY_MAP_2_SPEC_VERSION 1
12305 #define VK_EXT_FRAGMENT_DENSITY_MAP_2_EXTENSION_NAME "VK_EXT_fragment_density_map2"
12306 typedef struct VkPhysicalDeviceFragmentDensityMap2FeaturesEXT {
12307     VkStructureType    sType;
12308     void*              pNext;
12309     VkBool32           fragmentDensityMapDeferred;
12310 } VkPhysicalDeviceFragmentDensityMap2FeaturesEXT;
12311
12312 typedef struct VkPhysicalDeviceFragmentDensityMap2PropertiesEXT {
12313     VkStructureType    sType;
12314     void*              pNext;
12315     VkBool32           subsampledLoads;
12316     VkBool32           subsampledCoarseReconstructionEarlyAccess;
12317     uint32_t           maxSubsampledArrayLayers;
12318     uint32_t           maxDescriptorSetSubsampledSamplers;
12319 } VkPhysicalDeviceFragmentDensityMap2PropertiesEXT;
12320
12321
12322
12323 #define VK_QCOM_rotated_copy_commands 1
12324 #define VK_QCOM_ROTATED_COPY_COMMANDS_SPEC_VERSION 1
12325 #define VK_QCOM_ROTATED_COPY_COMMANDS_EXTENSION_NAME "VK_QCOM_rotated_copy_commands"
12326 typedef struct VkCopyCommandTransformInfoQCOM {
12327     VkStructureType                  sType;
12328     const void*                      pNext;
12329     VkSurfaceTransformFlagBitsKHR    transform;
12330 } VkCopyCommandTransformInfoQCOM;
12331
12332
12333
12334 #define VK_EXT_image_robustness 1
12335 #define VK_EXT_IMAGE_ROBUSTNESS_SPEC_VERSION 1
12336 #define VK_EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME "VK_EXT_image_robustness"
12337 typedef struct VkPhysicalDeviceImageRobustnessFeaturesEXT {
12338     VkStructureType    sType;
12339     void*              pNext;
12340     VkBool32           robustImageAccess;
12341 } VkPhysicalDeviceImageRobustnessFeaturesEXT;
12342
12343
12344
12345 #define VK_EXT_4444_formats 1
12346 #define VK_EXT_4444_FORMATS_SPEC_VERSION  1
12347 #define VK_EXT_4444_FORMATS_EXTENSION_NAME "VK_EXT_4444_formats"
12348 typedef struct VkPhysicalDevice4444FormatsFeaturesEXT {
12349     VkStructureType    sType;
12350     void*              pNext;
12351     VkBool32           formatA4R4G4B4;
12352     VkBool32           formatA4B4G4R4;
12353 } VkPhysicalDevice4444FormatsFeaturesEXT;
12354
12355
12356
12357 #define VK_NV_acquire_winrt_display 1
12358 #define VK_NV_ACQUIRE_WINRT_DISPLAY_SPEC_VERSION 1
12359 #define VK_NV_ACQUIRE_WINRT_DISPLAY_EXTENSION_NAME "VK_NV_acquire_winrt_display"
12360 typedef VkResult (VKAPI_PTR *PFN_vkAcquireWinrtDisplayNV)(VkPhysicalDevice physicalDevice, VkDisplayKHR display);
12361 typedef VkResult (VKAPI_PTR *PFN_vkGetWinrtDisplayNV)(VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR* pDisplay);
12362
12363 #ifndef VK_NO_PROTOTYPES
12364 VKAPI_ATTR VkResult VKAPI_CALL vkAcquireWinrtDisplayNV(
12365     VkPhysicalDevice                            physicalDevice,
12366     VkDisplayKHR                                display);
12367
12368 VKAPI_ATTR VkResult VKAPI_CALL vkGetWinrtDisplayNV(
12369     VkPhysicalDevice                            physicalDevice,
12370     uint32_t                                    deviceRelativeId,
12371     VkDisplayKHR*                               pDisplay);
12372 #endif
12373
12374
12375 #define VK_VALVE_mutable_descriptor_type 1
12376 #define VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION 1
12377 #define VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME "VK_VALVE_mutable_descriptor_type"
12378 typedef struct VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE {
12379     VkStructureType    sType;
12380     void*              pNext;
12381     VkBool32           mutableDescriptorType;
12382 } VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE;
12383
12384 typedef struct VkMutableDescriptorTypeListVALVE {
12385     uint32_t                   descriptorTypeCount;
12386     const VkDescriptorType*    pDescriptorTypes;
12387 } VkMutableDescriptorTypeListVALVE;
12388
12389 typedef struct VkMutableDescriptorTypeCreateInfoVALVE {
12390     VkStructureType                            sType;
12391     const void*                                pNext;
12392     uint32_t                                   mutableDescriptorTypeListCount;
12393     const VkMutableDescriptorTypeListVALVE*    pMutableDescriptorTypeLists;
12394 } VkMutableDescriptorTypeCreateInfoVALVE;
12395
12396
12397
12398 #define VK_EXT_vertex_input_dynamic_state 1
12399 #define VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_SPEC_VERSION 2
12400 #define VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME "VK_EXT_vertex_input_dynamic_state"
12401 typedef struct VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT {
12402     VkStructureType    sType;
12403     void*              pNext;
12404     VkBool32           vertexInputDynamicState;
12405 } VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT;
12406
12407 typedef struct VkVertexInputBindingDescription2EXT {
12408     VkStructureType      sType;
12409     void*                pNext;
12410     uint32_t             binding;
12411     uint32_t             stride;
12412     VkVertexInputRate    inputRate;
12413     uint32_t             divisor;
12414 } VkVertexInputBindingDescription2EXT;
12415
12416 typedef struct VkVertexInputAttributeDescription2EXT {
12417     VkStructureType    sType;
12418     void*              pNext;
12419     uint32_t           location;
12420     uint32_t           binding;
12421     VkFormat           format;
12422     uint32_t           offset;
12423 } VkVertexInputAttributeDescription2EXT;
12424
12425 typedef void (VKAPI_PTR *PFN_vkCmdSetVertexInputEXT)(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions);
12426
12427 #ifndef VK_NO_PROTOTYPES
12428 VKAPI_ATTR void VKAPI_CALL vkCmdSetVertexInputEXT(
12429     VkCommandBuffer                             commandBuffer,
12430     uint32_t                                    vertexBindingDescriptionCount,
12431     const VkVertexInputBindingDescription2EXT*  pVertexBindingDescriptions,
12432     uint32_t                                    vertexAttributeDescriptionCount,
12433     const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions);
12434 #endif
12435
12436
12437 #define VK_EXT_physical_device_drm 1
12438 #define VK_EXT_PHYSICAL_DEVICE_DRM_SPEC_VERSION 1
12439 #define VK_EXT_PHYSICAL_DEVICE_DRM_EXTENSION_NAME "VK_EXT_physical_device_drm"
12440 typedef struct VkPhysicalDeviceDrmPropertiesEXT {
12441     VkStructureType    sType;
12442     void*              pNext;
12443     VkBool32           hasPrimary;
12444     VkBool32           hasRender;
12445     int64_t            primaryMajor;
12446     int64_t            primaryMinor;
12447     int64_t            renderMajor;
12448     int64_t            renderMinor;
12449 } VkPhysicalDeviceDrmPropertiesEXT;
12450
12451
12452
12453 #define VK_HUAWEI_subpass_shading 1
12454 #define VK_HUAWEI_SUBPASS_SHADING_SPEC_VERSION 2
12455 #define VK_HUAWEI_SUBPASS_SHADING_EXTENSION_NAME "VK_HUAWEI_subpass_shading"
12456 typedef struct VkSubpassShadingPipelineCreateInfoHUAWEI {
12457     VkStructureType    sType;
12458     void*              pNext;
12459     VkRenderPass       renderPass;
12460     uint32_t           subpass;
12461 } VkSubpassShadingPipelineCreateInfoHUAWEI;
12462
12463 typedef struct VkPhysicalDeviceSubpassShadingFeaturesHUAWEI {
12464     VkStructureType    sType;
12465     void*              pNext;
12466     VkBool32           subpassShading;
12467 } VkPhysicalDeviceSubpassShadingFeaturesHUAWEI;
12468
12469 typedef struct VkPhysicalDeviceSubpassShadingPropertiesHUAWEI {
12470     VkStructureType    sType;
12471     void*              pNext;
12472     uint32_t           maxSubpassShadingWorkgroupSizeAspectRatio;
12473 } VkPhysicalDeviceSubpassShadingPropertiesHUAWEI;
12474
12475 typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI)(VkDevice device, VkRenderPass renderpass, VkExtent2D* pMaxWorkgroupSize);
12476 typedef void (VKAPI_PTR *PFN_vkCmdSubpassShadingHUAWEI)(VkCommandBuffer commandBuffer);
12477
12478 #ifndef VK_NO_PROTOTYPES
12479 VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(
12480     VkDevice                                    device,
12481     VkRenderPass                                renderpass,
12482     VkExtent2D*                                 pMaxWorkgroupSize);
12483
12484 VKAPI_ATTR void VKAPI_CALL vkCmdSubpassShadingHUAWEI(
12485     VkCommandBuffer                             commandBuffer);
12486 #endif
12487
12488
12489 #define VK_HUAWEI_invocation_mask 1
12490 #define VK_HUAWEI_INVOCATION_MASK_SPEC_VERSION 1
12491 #define VK_HUAWEI_INVOCATION_MASK_EXTENSION_NAME "VK_HUAWEI_invocation_mask"
12492 typedef struct VkPhysicalDeviceInvocationMaskFeaturesHUAWEI {
12493     VkStructureType    sType;
12494     void*              pNext;
12495     VkBool32           invocationMask;
12496 } VkPhysicalDeviceInvocationMaskFeaturesHUAWEI;
12497
12498 typedef void (VKAPI_PTR *PFN_vkCmdBindInvocationMaskHUAWEI)(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout);
12499
12500 #ifndef VK_NO_PROTOTYPES
12501 VKAPI_ATTR void VKAPI_CALL vkCmdBindInvocationMaskHUAWEI(
12502     VkCommandBuffer                             commandBuffer,
12503     VkImageView                                 imageView,
12504     VkImageLayout                               imageLayout);
12505 #endif
12506
12507
12508 #define VK_NV_external_memory_rdma 1
12509 typedef void* VkRemoteAddressNV;
12510 #define VK_NV_EXTERNAL_MEMORY_RDMA_SPEC_VERSION 1
12511 #define VK_NV_EXTERNAL_MEMORY_RDMA_EXTENSION_NAME "VK_NV_external_memory_rdma"
12512 typedef struct VkMemoryGetRemoteAddressInfoNV {
12513     VkStructureType                       sType;
12514     const void*                           pNext;
12515     VkDeviceMemory                        memory;
12516     VkExternalMemoryHandleTypeFlagBits    handleType;
12517 } VkMemoryGetRemoteAddressInfoNV;
12518
12519 typedef struct VkPhysicalDeviceExternalMemoryRDMAFeaturesNV {
12520     VkStructureType    sType;
12521     void*              pNext;
12522     VkBool32           externalMemoryRDMA;
12523 } VkPhysicalDeviceExternalMemoryRDMAFeaturesNV;
12524
12525 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryRemoteAddressNV)(VkDevice device, const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, VkRemoteAddressNV* pAddress);
12526
12527 #ifndef VK_NO_PROTOTYPES
12528 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryRemoteAddressNV(
12529     VkDevice                                    device,
12530     const VkMemoryGetRemoteAddressInfoNV*       pMemoryGetRemoteAddressInfo,
12531     VkRemoteAddressNV*                          pAddress);
12532 #endif
12533
12534
12535 #define VK_EXT_extended_dynamic_state2 1
12536 #define VK_EXT_EXTENDED_DYNAMIC_STATE_2_SPEC_VERSION 1
12537 #define VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME "VK_EXT_extended_dynamic_state2"
12538 typedef struct VkPhysicalDeviceExtendedDynamicState2FeaturesEXT {
12539     VkStructureType    sType;
12540     void*              pNext;
12541     VkBool32           extendedDynamicState2;
12542     VkBool32           extendedDynamicState2LogicOp;
12543     VkBool32           extendedDynamicState2PatchControlPoints;
12544 } VkPhysicalDeviceExtendedDynamicState2FeaturesEXT;
12545
12546 typedef void (VKAPI_PTR *PFN_vkCmdSetPatchControlPointsEXT)(VkCommandBuffer commandBuffer, uint32_t patchControlPoints);
12547 typedef void (VKAPI_PTR *PFN_vkCmdSetRasterizerDiscardEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable);
12548 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBiasEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable);
12549 typedef void (VKAPI_PTR *PFN_vkCmdSetLogicOpEXT)(VkCommandBuffer commandBuffer, VkLogicOp logicOp);
12550 typedef void (VKAPI_PTR *PFN_vkCmdSetPrimitiveRestartEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable);
12551
12552 #ifndef VK_NO_PROTOTYPES
12553 VKAPI_ATTR void VKAPI_CALL vkCmdSetPatchControlPointsEXT(
12554     VkCommandBuffer                             commandBuffer,
12555     uint32_t                                    patchControlPoints);
12556
12557 VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizerDiscardEnableEXT(
12558     VkCommandBuffer                             commandBuffer,
12559     VkBool32                                    rasterizerDiscardEnable);
12560
12561 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBiasEnableEXT(
12562     VkCommandBuffer                             commandBuffer,
12563     VkBool32                                    depthBiasEnable);
12564
12565 VKAPI_ATTR void VKAPI_CALL vkCmdSetLogicOpEXT(
12566     VkCommandBuffer                             commandBuffer,
12567     VkLogicOp                                   logicOp);
12568
12569 VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveRestartEnableEXT(
12570     VkCommandBuffer                             commandBuffer,
12571     VkBool32                                    primitiveRestartEnable);
12572 #endif
12573
12574
12575 #define VK_EXT_color_write_enable 1
12576 #define VK_EXT_COLOR_WRITE_ENABLE_SPEC_VERSION 1
12577 #define VK_EXT_COLOR_WRITE_ENABLE_EXTENSION_NAME "VK_EXT_color_write_enable"
12578 typedef struct VkPhysicalDeviceColorWriteEnableFeaturesEXT {
12579     VkStructureType    sType;
12580     void*              pNext;
12581     VkBool32           colorWriteEnable;
12582 } VkPhysicalDeviceColorWriteEnableFeaturesEXT;
12583
12584 typedef struct VkPipelineColorWriteCreateInfoEXT {
12585     VkStructureType    sType;
12586     const void*        pNext;
12587     uint32_t           attachmentCount;
12588     const VkBool32*    pColorWriteEnables;
12589 } VkPipelineColorWriteCreateInfoEXT;
12590
12591 typedef void                                    (VKAPI_PTR *PFN_vkCmdSetColorWriteEnableEXT)(VkCommandBuffer       commandBuffer, uint32_t                                attachmentCount, const VkBool32*   pColorWriteEnables);
12592
12593 #ifndef VK_NO_PROTOTYPES
12594 VKAPI_ATTR void                                    VKAPI_CALL vkCmdSetColorWriteEnableEXT(
12595     VkCommandBuffer                             commandBuffer,
12596     uint32_t                                    attachmentCount,
12597     const VkBool32*                             pColorWriteEnables);
12598 #endif
12599
12600
12601 #define VK_EXT_global_priority_query 1
12602 #define VK_MAX_GLOBAL_PRIORITY_SIZE_EXT   16U
12603 #define VK_EXT_GLOBAL_PRIORITY_QUERY_SPEC_VERSION 1
12604 #define VK_EXT_GLOBAL_PRIORITY_QUERY_EXTENSION_NAME "VK_EXT_global_priority_query"
12605 typedef struct VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT {
12606     VkStructureType    sType;
12607     void*              pNext;
12608     VkBool32           globalPriorityQuery;
12609 } VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT;
12610
12611 typedef struct VkQueueFamilyGlobalPriorityPropertiesEXT {
12612     VkStructureType             sType;
12613     void*                       pNext;
12614     uint32_t                    priorityCount;
12615     VkQueueGlobalPriorityEXT    priorities[VK_MAX_GLOBAL_PRIORITY_SIZE_EXT];
12616 } VkQueueFamilyGlobalPriorityPropertiesEXT;
12617
12618
12619
12620 #define VK_EXT_multi_draw 1
12621 #define VK_EXT_MULTI_DRAW_SPEC_VERSION    1
12622 #define VK_EXT_MULTI_DRAW_EXTENSION_NAME  "VK_EXT_multi_draw"
12623 typedef struct VkPhysicalDeviceMultiDrawFeaturesEXT {
12624     VkStructureType    sType;
12625     void*              pNext;
12626     VkBool32           multiDraw;
12627 } VkPhysicalDeviceMultiDrawFeaturesEXT;
12628
12629 typedef struct VkPhysicalDeviceMultiDrawPropertiesEXT {
12630     VkStructureType    sType;
12631     void*              pNext;
12632     uint32_t           maxMultiDrawCount;
12633 } VkPhysicalDeviceMultiDrawPropertiesEXT;
12634
12635 typedef struct VkMultiDrawInfoEXT {
12636     uint32_t    firstVertex;
12637     uint32_t    vertexCount;
12638 } VkMultiDrawInfoEXT;
12639
12640 typedef struct VkMultiDrawIndexedInfoEXT {
12641     uint32_t    firstIndex;
12642     uint32_t    indexCount;
12643     int32_t     vertexOffset;
12644 } VkMultiDrawIndexedInfoEXT;
12645
12646 typedef void (VKAPI_PTR *PFN_vkCmdDrawMultiEXT)(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride);
12647 typedef void (VKAPI_PTR *PFN_vkCmdDrawMultiIndexedEXT)(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t* pVertexOffset);
12648
12649 #ifndef VK_NO_PROTOTYPES
12650 VKAPI_ATTR void VKAPI_CALL vkCmdDrawMultiEXT(
12651     VkCommandBuffer                             commandBuffer,
12652     uint32_t                                    drawCount,
12653     const VkMultiDrawInfoEXT*                   pVertexInfo,
12654     uint32_t                                    instanceCount,
12655     uint32_t                                    firstInstance,
12656     uint32_t                                    stride);
12657
12658 VKAPI_ATTR void VKAPI_CALL vkCmdDrawMultiIndexedEXT(
12659     VkCommandBuffer                             commandBuffer,
12660     uint32_t                                    drawCount,
12661     const VkMultiDrawIndexedInfoEXT*            pIndexInfo,
12662     uint32_t                                    instanceCount,
12663     uint32_t                                    firstInstance,
12664     uint32_t                                    stride,
12665     const int32_t*                              pVertexOffset);
12666 #endif
12667
12668
12669 #define VK_KHR_acceleration_structure 1
12670 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureKHR)
12671 #define VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION 11
12672 #define VK_KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME "VK_KHR_acceleration_structure"
12673
12674 typedef enum VkBuildAccelerationStructureModeKHR {
12675     VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR = 0,
12676     VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR = 1,
12677     VK_BUILD_ACCELERATION_STRUCTURE_MODE_MAX_ENUM_KHR = 0x7FFFFFFF
12678 } VkBuildAccelerationStructureModeKHR;
12679
12680 typedef enum VkAccelerationStructureBuildTypeKHR {
12681     VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_KHR = 0,
12682     VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR = 1,
12683     VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_OR_DEVICE_KHR = 2,
12684     VK_ACCELERATION_STRUCTURE_BUILD_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF
12685 } VkAccelerationStructureBuildTypeKHR;
12686
12687 typedef enum VkAccelerationStructureCompatibilityKHR {
12688     VK_ACCELERATION_STRUCTURE_COMPATIBILITY_COMPATIBLE_KHR = 0,
12689     VK_ACCELERATION_STRUCTURE_COMPATIBILITY_INCOMPATIBLE_KHR = 1,
12690     VK_ACCELERATION_STRUCTURE_COMPATIBILITY_MAX_ENUM_KHR = 0x7FFFFFFF
12691 } VkAccelerationStructureCompatibilityKHR;
12692
12693 typedef enum VkAccelerationStructureCreateFlagBitsKHR {
12694     VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = 0x00000001,
12695     VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV = 0x00000004,
12696     VK_ACCELERATION_STRUCTURE_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
12697 } VkAccelerationStructureCreateFlagBitsKHR;
12698 typedef VkFlags VkAccelerationStructureCreateFlagsKHR;
12699 typedef union VkDeviceOrHostAddressKHR {
12700     VkDeviceAddress    deviceAddress;
12701     void*              hostAddress;
12702 } VkDeviceOrHostAddressKHR;
12703
12704 typedef struct VkAccelerationStructureBuildRangeInfoKHR {
12705     uint32_t    primitiveCount;
12706     uint32_t    primitiveOffset;
12707     uint32_t    firstVertex;
12708     uint32_t    transformOffset;
12709 } VkAccelerationStructureBuildRangeInfoKHR;
12710
12711 typedef struct VkAccelerationStructureGeometryTrianglesDataKHR {
12712     VkStructureType                  sType;
12713     const void*                      pNext;
12714     VkFormat                         vertexFormat;
12715     VkDeviceOrHostAddressConstKHR    vertexData;
12716     VkDeviceSize                     vertexStride;
12717     uint32_t                         maxVertex;
12718     VkIndexType                      indexType;
12719     VkDeviceOrHostAddressConstKHR    indexData;
12720     VkDeviceOrHostAddressConstKHR    transformData;
12721 } VkAccelerationStructureGeometryTrianglesDataKHR;
12722
12723 typedef struct VkAccelerationStructureGeometryAabbsDataKHR {
12724     VkStructureType                  sType;
12725     const void*                      pNext;
12726     VkDeviceOrHostAddressConstKHR    data;
12727     VkDeviceSize                     stride;
12728 } VkAccelerationStructureGeometryAabbsDataKHR;
12729
12730 typedef struct VkAccelerationStructureGeometryInstancesDataKHR {
12731     VkStructureType                  sType;
12732     const void*                      pNext;
12733     VkBool32                         arrayOfPointers;
12734     VkDeviceOrHostAddressConstKHR    data;
12735 } VkAccelerationStructureGeometryInstancesDataKHR;
12736
12737 typedef union VkAccelerationStructureGeometryDataKHR {
12738     VkAccelerationStructureGeometryTrianglesDataKHR    triangles;
12739     VkAccelerationStructureGeometryAabbsDataKHR        aabbs;
12740     VkAccelerationStructureGeometryInstancesDataKHR    instances;
12741 } VkAccelerationStructureGeometryDataKHR;
12742
12743 typedef struct VkAccelerationStructureGeometryKHR {
12744     VkStructureType                           sType;
12745     const void*                               pNext;
12746     VkGeometryTypeKHR                         geometryType;
12747     VkAccelerationStructureGeometryDataKHR    geometry;
12748     VkGeometryFlagsKHR                        flags;
12749 } VkAccelerationStructureGeometryKHR;
12750
12751 typedef struct VkAccelerationStructureBuildGeometryInfoKHR {
12752     VkStructureType                                     sType;
12753     const void*                                         pNext;
12754     VkAccelerationStructureTypeKHR                      type;
12755     VkBuildAccelerationStructureFlagsKHR                flags;
12756     VkBuildAccelerationStructureModeKHR                 mode;
12757     VkAccelerationStructureKHR                          srcAccelerationStructure;
12758     VkAccelerationStructureKHR                          dstAccelerationStructure;
12759     uint32_t                                            geometryCount;
12760     const VkAccelerationStructureGeometryKHR*           pGeometries;
12761     const VkAccelerationStructureGeometryKHR* const*    ppGeometries;
12762     VkDeviceOrHostAddressKHR                            scratchData;
12763 } VkAccelerationStructureBuildGeometryInfoKHR;
12764
12765 typedef struct VkAccelerationStructureCreateInfoKHR {
12766     VkStructureType                          sType;
12767     const void*                              pNext;
12768     VkAccelerationStructureCreateFlagsKHR    createFlags;
12769     VkBuffer                                 buffer;
12770     VkDeviceSize                             offset;
12771     VkDeviceSize                             size;
12772     VkAccelerationStructureTypeKHR           type;
12773     VkDeviceAddress                          deviceAddress;
12774 } VkAccelerationStructureCreateInfoKHR;
12775
12776 typedef struct VkWriteDescriptorSetAccelerationStructureKHR {
12777     VkStructureType                      sType;
12778     const void*                          pNext;
12779     uint32_t                             accelerationStructureCount;
12780     const VkAccelerationStructureKHR*    pAccelerationStructures;
12781 } VkWriteDescriptorSetAccelerationStructureKHR;
12782
12783 typedef struct VkPhysicalDeviceAccelerationStructureFeaturesKHR {
12784     VkStructureType    sType;
12785     void*              pNext;
12786     VkBool32           accelerationStructure;
12787     VkBool32           accelerationStructureCaptureReplay;
12788     VkBool32           accelerationStructureIndirectBuild;
12789     VkBool32           accelerationStructureHostCommands;
12790     VkBool32           descriptorBindingAccelerationStructureUpdateAfterBind;
12791 } VkPhysicalDeviceAccelerationStructureFeaturesKHR;
12792
12793 typedef struct VkPhysicalDeviceAccelerationStructurePropertiesKHR {
12794     VkStructureType    sType;
12795     void*              pNext;
12796     uint64_t           maxGeometryCount;
12797     uint64_t           maxInstanceCount;
12798     uint64_t           maxPrimitiveCount;
12799     uint32_t           maxPerStageDescriptorAccelerationStructures;
12800     uint32_t           maxPerStageDescriptorUpdateAfterBindAccelerationStructures;
12801     uint32_t           maxDescriptorSetAccelerationStructures;
12802     uint32_t           maxDescriptorSetUpdateAfterBindAccelerationStructures;
12803     uint32_t           minAccelerationStructureScratchOffsetAlignment;
12804 } VkPhysicalDeviceAccelerationStructurePropertiesKHR;
12805
12806 typedef struct VkAccelerationStructureDeviceAddressInfoKHR {
12807     VkStructureType               sType;
12808     const void*                   pNext;
12809     VkAccelerationStructureKHR    accelerationStructure;
12810 } VkAccelerationStructureDeviceAddressInfoKHR;
12811
12812 typedef struct VkAccelerationStructureVersionInfoKHR {
12813     VkStructureType    sType;
12814     const void*        pNext;
12815     const uint8_t*     pVersionData;
12816 } VkAccelerationStructureVersionInfoKHR;
12817
12818 typedef struct VkCopyAccelerationStructureToMemoryInfoKHR {
12819     VkStructureType                       sType;
12820     const void*                           pNext;
12821     VkAccelerationStructureKHR            src;
12822     VkDeviceOrHostAddressKHR              dst;
12823     VkCopyAccelerationStructureModeKHR    mode;
12824 } VkCopyAccelerationStructureToMemoryInfoKHR;
12825
12826 typedef struct VkCopyMemoryToAccelerationStructureInfoKHR {
12827     VkStructureType                       sType;
12828     const void*                           pNext;
12829     VkDeviceOrHostAddressConstKHR         src;
12830     VkAccelerationStructureKHR            dst;
12831     VkCopyAccelerationStructureModeKHR    mode;
12832 } VkCopyMemoryToAccelerationStructureInfoKHR;
12833
12834 typedef struct VkCopyAccelerationStructureInfoKHR {
12835     VkStructureType                       sType;
12836     const void*                           pNext;
12837     VkAccelerationStructureKHR            src;
12838     VkAccelerationStructureKHR            dst;
12839     VkCopyAccelerationStructureModeKHR    mode;
12840 } VkCopyAccelerationStructureInfoKHR;
12841
12842 typedef struct VkAccelerationStructureBuildSizesInfoKHR {
12843     VkStructureType    sType;
12844     const void*        pNext;
12845     VkDeviceSize       accelerationStructureSize;
12846     VkDeviceSize       updateScratchSize;
12847     VkDeviceSize       buildScratchSize;
12848 } VkAccelerationStructureBuildSizesInfoKHR;
12849
12850 typedef VkResult (VKAPI_PTR *PFN_vkCreateAccelerationStructureKHR)(VkDevice                                           device, const VkAccelerationStructureCreateInfoKHR*        pCreateInfo, const VkAllocationCallbacks*       pAllocator, VkAccelerationStructureKHR*                        pAccelerationStructure);
12851 typedef void (VKAPI_PTR *PFN_vkDestroyAccelerationStructureKHR)(VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks* pAllocator);
12852 typedef void (VKAPI_PTR *PFN_vkCmdBuildAccelerationStructuresKHR)(VkCommandBuffer                                    commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos);
12853 typedef void (VKAPI_PTR *PFN_vkCmdBuildAccelerationStructuresIndirectKHR)(VkCommandBuffer                  commandBuffer, uint32_t                                           infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkDeviceAddress*             pIndirectDeviceAddresses, const uint32_t*                    pIndirectStrides, const uint32_t* const*             ppMaxPrimitiveCounts);
12854 typedef VkResult (VKAPI_PTR *PFN_vkBuildAccelerationStructuresKHR)(VkDevice                                           device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos);
12855 typedef VkResult (VKAPI_PTR *PFN_vkCopyAccelerationStructureKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR* pInfo);
12856 typedef VkResult (VKAPI_PTR *PFN_vkCopyAccelerationStructureToMemoryKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo);
12857 typedef VkResult (VKAPI_PTR *PFN_vkCopyMemoryToAccelerationStructureKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo);
12858 typedef VkResult (VKAPI_PTR *PFN_vkWriteAccelerationStructuresPropertiesKHR)(VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType  queryType, size_t       dataSize, void* pData, size_t stride);
12859 typedef void (VKAPI_PTR *PFN_vkCmdCopyAccelerationStructureKHR)(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR* pInfo);
12860 typedef void (VKAPI_PTR *PFN_vkCmdCopyAccelerationStructureToMemoryKHR)(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo);
12861 typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryToAccelerationStructureKHR)(VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo);
12862 typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetAccelerationStructureDeviceAddressKHR)(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR* pInfo);
12863 typedef void (VKAPI_PTR *PFN_vkCmdWriteAccelerationStructuresPropertiesKHR)(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery);
12864 typedef void (VKAPI_PTR *PFN_vkGetDeviceAccelerationStructureCompatibilityKHR)(VkDevice device, const VkAccelerationStructureVersionInfoKHR* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility);
12865 typedef void (VKAPI_PTR *PFN_vkGetAccelerationStructureBuildSizesKHR)(VkDevice                                            device, VkAccelerationStructureBuildTypeKHR                 buildType, const VkAccelerationStructureBuildGeometryInfoKHR*  pBuildInfo, const uint32_t*  pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR*           pSizeInfo);
12866
12867 #ifndef VK_NO_PROTOTYPES
12868 VKAPI_ATTR VkResult VKAPI_CALL vkCreateAccelerationStructureKHR(
12869     VkDevice                                    device,
12870     const VkAccelerationStructureCreateInfoKHR* pCreateInfo,
12871     const VkAllocationCallbacks*                pAllocator,
12872     VkAccelerationStructureKHR*                 pAccelerationStructure);
12873
12874 VKAPI_ATTR void VKAPI_CALL vkDestroyAccelerationStructureKHR(
12875     VkDevice                                    device,
12876     VkAccelerationStructureKHR                  accelerationStructure,
12877     const VkAllocationCallbacks*                pAllocator);
12878
12879 VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructuresKHR(
12880     VkCommandBuffer                             commandBuffer,
12881     uint32_t                                    infoCount,
12882     const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
12883     const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos);
12884
12885 VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructuresIndirectKHR(
12886     VkCommandBuffer                             commandBuffer,
12887     uint32_t                                    infoCount,
12888     const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
12889     const VkDeviceAddress*                      pIndirectDeviceAddresses,
12890     const uint32_t*                             pIndirectStrides,
12891     const uint32_t* const*                      ppMaxPrimitiveCounts);
12892
12893 VKAPI_ATTR VkResult VKAPI_CALL vkBuildAccelerationStructuresKHR(
12894     VkDevice                                    device,
12895     VkDeferredOperationKHR                      deferredOperation,
12896     uint32_t                                    infoCount,
12897     const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
12898     const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos);
12899
12900 VKAPI_ATTR VkResult VKAPI_CALL vkCopyAccelerationStructureKHR(
12901     VkDevice                                    device,
12902     VkDeferredOperationKHR                      deferredOperation,
12903     const VkCopyAccelerationStructureInfoKHR*   pInfo);
12904
12905 VKAPI_ATTR VkResult VKAPI_CALL vkCopyAccelerationStructureToMemoryKHR(
12906     VkDevice                                    device,
12907     VkDeferredOperationKHR                      deferredOperation,
12908     const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo);
12909
12910 VKAPI_ATTR VkResult VKAPI_CALL vkCopyMemoryToAccelerationStructureKHR(
12911     VkDevice                                    device,
12912     VkDeferredOperationKHR                      deferredOperation,
12913     const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo);
12914
12915 VKAPI_ATTR VkResult VKAPI_CALL vkWriteAccelerationStructuresPropertiesKHR(
12916     VkDevice                                    device,
12917     uint32_t                                    accelerationStructureCount,
12918     const VkAccelerationStructureKHR*           pAccelerationStructures,
12919     VkQueryType                                 queryType,
12920     size_t                                      dataSize,
12921     void*                                       pData,
12922     size_t                                      stride);
12923
12924 VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureKHR(
12925     VkCommandBuffer                             commandBuffer,
12926     const VkCopyAccelerationStructureInfoKHR*   pInfo);
12927
12928 VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureToMemoryKHR(
12929     VkCommandBuffer                             commandBuffer,
12930     const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo);
12931
12932 VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToAccelerationStructureKHR(
12933     VkCommandBuffer                             commandBuffer,
12934     const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo);
12935
12936 VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetAccelerationStructureDeviceAddressKHR(
12937     VkDevice                                    device,
12938     const VkAccelerationStructureDeviceAddressInfoKHR* pInfo);
12939
12940 VKAPI_ATTR void VKAPI_CALL vkCmdWriteAccelerationStructuresPropertiesKHR(
12941     VkCommandBuffer                             commandBuffer,
12942     uint32_t                                    accelerationStructureCount,
12943     const VkAccelerationStructureKHR*           pAccelerationStructures,
12944     VkQueryType                                 queryType,
12945     VkQueryPool                                 queryPool,
12946     uint32_t                                    firstQuery);
12947
12948 VKAPI_ATTR void VKAPI_CALL vkGetDeviceAccelerationStructureCompatibilityKHR(
12949     VkDevice                                    device,
12950     const VkAccelerationStructureVersionInfoKHR* pVersionInfo,
12951     VkAccelerationStructureCompatibilityKHR*    pCompatibility);
12952
12953 VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureBuildSizesKHR(
12954     VkDevice                                    device,
12955     VkAccelerationStructureBuildTypeKHR         buildType,
12956     const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo,
12957     const uint32_t*                             pMaxPrimitiveCounts,
12958     VkAccelerationStructureBuildSizesInfoKHR*   pSizeInfo);
12959 #endif
12960
12961
12962 #define VK_KHR_ray_tracing_pipeline 1
12963 #define VK_KHR_RAY_TRACING_PIPELINE_SPEC_VERSION 1
12964 #define VK_KHR_RAY_TRACING_PIPELINE_EXTENSION_NAME "VK_KHR_ray_tracing_pipeline"
12965
12966 typedef enum VkShaderGroupShaderKHR {
12967     VK_SHADER_GROUP_SHADER_GENERAL_KHR = 0,
12968     VK_SHADER_GROUP_SHADER_CLOSEST_HIT_KHR = 1,
12969     VK_SHADER_GROUP_SHADER_ANY_HIT_KHR = 2,
12970     VK_SHADER_GROUP_SHADER_INTERSECTION_KHR = 3,
12971     VK_SHADER_GROUP_SHADER_MAX_ENUM_KHR = 0x7FFFFFFF
12972 } VkShaderGroupShaderKHR;
12973 typedef struct VkRayTracingShaderGroupCreateInfoKHR {
12974     VkStructureType                   sType;
12975     const void*                       pNext;
12976     VkRayTracingShaderGroupTypeKHR    type;
12977     uint32_t                          generalShader;
12978     uint32_t                          closestHitShader;
12979     uint32_t                          anyHitShader;
12980     uint32_t                          intersectionShader;
12981     const void*                       pShaderGroupCaptureReplayHandle;
12982 } VkRayTracingShaderGroupCreateInfoKHR;
12983
12984 typedef struct VkRayTracingPipelineInterfaceCreateInfoKHR {
12985     VkStructureType    sType;
12986     const void*        pNext;
12987     uint32_t           maxPipelineRayPayloadSize;
12988     uint32_t           maxPipelineRayHitAttributeSize;
12989 } VkRayTracingPipelineInterfaceCreateInfoKHR;
12990
12991 typedef struct VkRayTracingPipelineCreateInfoKHR {
12992     VkStructureType                                      sType;
12993     const void*                                          pNext;
12994     VkPipelineCreateFlags                                flags;
12995     uint32_t                                             stageCount;
12996     const VkPipelineShaderStageCreateInfo*               pStages;
12997     uint32_t                                             groupCount;
12998     const VkRayTracingShaderGroupCreateInfoKHR*          pGroups;
12999     uint32_t                                             maxPipelineRayRecursionDepth;
13000     const VkPipelineLibraryCreateInfoKHR*                pLibraryInfo;
13001     const VkRayTracingPipelineInterfaceCreateInfoKHR*    pLibraryInterface;
13002     const VkPipelineDynamicStateCreateInfo*              pDynamicState;
13003     VkPipelineLayout                                     layout;
13004     VkPipeline                                           basePipelineHandle;
13005     int32_t                                              basePipelineIndex;
13006 } VkRayTracingPipelineCreateInfoKHR;
13007
13008 typedef struct VkPhysicalDeviceRayTracingPipelineFeaturesKHR {
13009     VkStructureType    sType;
13010     void*              pNext;
13011     VkBool32           rayTracingPipeline;
13012     VkBool32           rayTracingPipelineShaderGroupHandleCaptureReplay;
13013     VkBool32           rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
13014     VkBool32           rayTracingPipelineTraceRaysIndirect;
13015     VkBool32           rayTraversalPrimitiveCulling;
13016 } VkPhysicalDeviceRayTracingPipelineFeaturesKHR;
13017
13018 typedef struct VkPhysicalDeviceRayTracingPipelinePropertiesKHR {
13019     VkStructureType    sType;
13020     void*              pNext;
13021     uint32_t           shaderGroupHandleSize;
13022     uint32_t           maxRayRecursionDepth;
13023     uint32_t           maxShaderGroupStride;
13024     uint32_t           shaderGroupBaseAlignment;
13025     uint32_t           shaderGroupHandleCaptureReplaySize;
13026     uint32_t           maxRayDispatchInvocationCount;
13027     uint32_t           shaderGroupHandleAlignment;
13028     uint32_t           maxRayHitAttributeSize;
13029 } VkPhysicalDeviceRayTracingPipelinePropertiesKHR;
13030
13031 typedef struct VkStridedDeviceAddressRegionKHR {
13032     VkDeviceAddress    deviceAddress;
13033     VkDeviceSize       stride;
13034     VkDeviceSize       size;
13035 } VkStridedDeviceAddressRegionKHR;
13036
13037 typedef struct VkTraceRaysIndirectCommandKHR {
13038     uint32_t    width;
13039     uint32_t    height;
13040     uint32_t    depth;
13041 } VkTraceRaysIndirectCommandKHR;
13042
13043 typedef void (VKAPI_PTR *PFN_vkCmdTraceRaysKHR)(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth);
13044 typedef VkResult (VKAPI_PTR *PFN_vkCreateRayTracingPipelinesKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
13045 typedef VkResult (VKAPI_PTR *PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData);
13046 typedef void (VKAPI_PTR *PFN_vkCmdTraceRaysIndirectKHR)(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress);
13047 typedef VkDeviceSize (VKAPI_PTR *PFN_vkGetRayTracingShaderGroupStackSizeKHR)(VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader);
13048 typedef void (VKAPI_PTR *PFN_vkCmdSetRayTracingPipelineStackSizeKHR)(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize);
13049
13050 #ifndef VK_NO_PROTOTYPES
13051 VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysKHR(
13052     VkCommandBuffer                             commandBuffer,
13053     const VkStridedDeviceAddressRegionKHR*      pRaygenShaderBindingTable,
13054     const VkStridedDeviceAddressRegionKHR*      pMissShaderBindingTable,
13055     const VkStridedDeviceAddressRegionKHR*      pHitShaderBindingTable,
13056     const VkStridedDeviceAddressRegionKHR*      pCallableShaderBindingTable,
13057     uint32_t                                    width,
13058     uint32_t                                    height,
13059     uint32_t                                    depth);
13060
13061 VKAPI_ATTR VkResult VKAPI_CALL vkCreateRayTracingPipelinesKHR(
13062     VkDevice                                    device,
13063     VkDeferredOperationKHR                      deferredOperation,
13064     VkPipelineCache                             pipelineCache,
13065     uint32_t                                    createInfoCount,
13066     const VkRayTracingPipelineCreateInfoKHR*    pCreateInfos,
13067     const VkAllocationCallbacks*                pAllocator,
13068     VkPipeline*                                 pPipelines);
13069
13070 VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(
13071     VkDevice                                    device,
13072     VkPipeline                                  pipeline,
13073     uint32_t                                    firstGroup,
13074     uint32_t                                    groupCount,
13075     size_t                                      dataSize,
13076     void*                                       pData);
13077
13078 VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysIndirectKHR(
13079     VkCommandBuffer                             commandBuffer,
13080     const VkStridedDeviceAddressRegionKHR*      pRaygenShaderBindingTable,
13081     const VkStridedDeviceAddressRegionKHR*      pMissShaderBindingTable,
13082     const VkStridedDeviceAddressRegionKHR*      pHitShaderBindingTable,
13083     const VkStridedDeviceAddressRegionKHR*      pCallableShaderBindingTable,
13084     VkDeviceAddress                             indirectDeviceAddress);
13085
13086 VKAPI_ATTR VkDeviceSize VKAPI_CALL vkGetRayTracingShaderGroupStackSizeKHR(
13087     VkDevice                                    device,
13088     VkPipeline                                  pipeline,
13089     uint32_t                                    group,
13090     VkShaderGroupShaderKHR                      groupShader);
13091
13092 VKAPI_ATTR void VKAPI_CALL vkCmdSetRayTracingPipelineStackSizeKHR(
13093     VkCommandBuffer                             commandBuffer,
13094     uint32_t                                    pipelineStackSize);
13095 #endif
13096
13097
13098 #define VK_KHR_ray_query 1
13099 #define VK_KHR_RAY_QUERY_SPEC_VERSION     1
13100 #define VK_KHR_RAY_QUERY_EXTENSION_NAME   "VK_KHR_ray_query"
13101 typedef struct VkPhysicalDeviceRayQueryFeaturesKHR {
13102     VkStructureType    sType;
13103     void*              pNext;
13104     VkBool32           rayQuery;
13105 } VkPhysicalDeviceRayQueryFeaturesKHR;
13106
13107
13108 #ifdef __cplusplus
13109 }
13110 #endif
13111
13112 #endif