external/vulkancts/scripts/src/vulkan.h.in

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