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