include/vulkan/vulkan_core.h

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