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