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