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