include/vulkan/vulkan_core.h

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