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