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