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