include/vulkan/vulkan_core.h

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