include/vulkan/vulkan_core.h

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