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