external/vulkancts/scripts/src/vulkan_core.h

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