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