include/vulkan/vulkan_core.h

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