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