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