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