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