include/vulkan/vulkan_core.h

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