include/vulkan/vulkan_core.h

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