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