include/vulkan/vulkan_core.h

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