include/vulkan/vulkan_core.h

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