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)
  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 49
  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_SURFACE_LOST_KHR = -1000000000,
 142     VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001,
 143     VK_SUBOPTIMAL_KHR = 1000001003,
 144     VK_ERROR_OUT_OF_DATE_KHR = -1000001004,
 145     VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001,
 146     VK_ERROR_VALIDATION_FAILED_EXT = -1000011001,
 147     VK_ERROR_INVALID_SHADER_NV = -1000012000,
 148     VK_ERROR_OUT_OF_POOL_MEMORY_KHR = -1000069000,
 149     VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = -1000072003,
 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_SWAPCHAIN_CREATE_INFO_KHR = 1000001000,
 207     VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001,
 208     VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000,
 209     VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001,
 210     VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000,
 211     VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000,
 212     VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000,
 213     VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000,
 214     VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR = 1000007000,
 215     VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000,
 216     VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000,
 217     VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000,
 218     VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHX = 1000053000,
 219     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHX = 1000053001,
 220     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHX = 1000053002,
 221     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR = 1000059000,
 222     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR = 1000059001,
 223     VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR = 1000059002,
 224     VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR = 1000059003,
 225     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR = 1000059004,
 226     VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR = 1000059005,
 227     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR = 1000059006,
 228     VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR = 1000059007,
 229     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR = 1000059008,
 230     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR = 1000071000,
 231     VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR = 1000071001,
 232     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR = 1000071002,
 233     VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR = 1000071003,
 234     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR = 1000071004,
 235     VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR = 1000072000,
 236     VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR = 1000072001,
 237     VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR = 1000072002,
 238     VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073000,
 239     VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073001,
 240     VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR = 1000073002,
 241     VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR = 1000073003,
 242     VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR = 1000074000,
 243     VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR = 1000074001,
 244     VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR = 1000074002,
 245     VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR = 1000075000,
 246     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR = 1000076000,
 247     VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR = 1000076001,
 248     VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR = 1000077000,
 249     VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078000,
 250     VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078001,
 251     VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR = 1000078002,
 252     VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR = 1000078003,
 253     VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR = 1000079000,
 254     VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR = 1000079001,
 255     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = 1000080000,
 256     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR = 1000083000,
 257     VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000,
 258     VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = 1000085000,
 259     VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE = 1000092000,
 260     VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000,
 261     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR = 1000112000,
 262     VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR = 1000112001,
 263     VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR = 1000113000,
 264     VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114000,
 265     VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114001,
 266     VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR = 1000114002,
 267     VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR = 1000115000,
 268     VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR = 1000115001,
 269     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR = 1000117000,
 270     VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR = 1000117001,
 271     VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR = 1000117002,
 272     VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR = 1000117003,
 273     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000,
 274     VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001,
 275     VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002,
 276     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR = 1000120000,
 277     VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR = 1000127000,
 278     VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR = 1000127001,
 279     VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR = 1000146000,
 280     VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR = 1000146001,
 281     VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR = 1000147000,
 282     VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR = 1000146002,
 283     VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR = 1000146003,
 284     VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR = 1000146004,
 285         VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR = 1000157000,
 286     VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR = 1000157001,
 287     VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO,
 288     VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO,
 289     VK_STRUCTURE_TYPE_RANGE_SIZE = (VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1),
 290     VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
 291 } VkStructureType;
 292
 293 typedef enum VkSystemAllocationScope {
 294     VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0,
 295     VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1,
 296     VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2,
 297     VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3,
 298     VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4,
 299     VK_SYSTEM_ALLOCATION_SCOPE_BEGIN_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_COMMAND,
 300     VK_SYSTEM_ALLOCATION_SCOPE_END_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE,
 301     VK_SYSTEM_ALLOCATION_SCOPE_RANGE_SIZE = (VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE - VK_SYSTEM_ALLOCATION_SCOPE_COMMAND + 1),
 302     VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF
 303 } VkSystemAllocationScope;
 304
 305 typedef enum VkInternalAllocationType {
 306     VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0,
 307     VK_INTERNAL_ALLOCATION_TYPE_BEGIN_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE,
 308     VK_INTERNAL_ALLOCATION_TYPE_END_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE,
 309     VK_INTERNAL_ALLOCATION_TYPE_RANGE_SIZE = (VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE - VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE + 1),
 310     VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF
 311 } VkInternalAllocationType;
 312
 313 typedef enum VkFormat {
 314     VK_FORMAT_UNDEFINED = 0,
 315     VK_FORMAT_R4G4_UNORM_PACK8 = 1,
 316     VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2,
 317     VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3,
 318     VK_FORMAT_R5G6B5_UNORM_PACK16 = 4,
 319     VK_FORMAT_B5G6R5_UNORM_PACK16 = 5,
 320     VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6,
 321     VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7,
 322     VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8,
 323     VK_FORMAT_R8_UNORM = 9,
 324     VK_FORMAT_R8_SNORM = 10,
 325     VK_FORMAT_R8_USCALED = 11,
 326     VK_FORMAT_R8_SSCALED = 12,
 327     VK_FORMAT_R8_UINT = 13,
 328     VK_FORMAT_R8_SINT = 14,
 329     VK_FORMAT_R8_SRGB = 15,
 330     VK_FORMAT_R8G8_UNORM = 16,
 331     VK_FORMAT_R8G8_SNORM = 17,
 332     VK_FORMAT_R8G8_USCALED = 18,
 333     VK_FORMAT_R8G8_SSCALED = 19,
 334     VK_FORMAT_R8G8_UINT = 20,
 335     VK_FORMAT_R8G8_SINT = 21,
 336     VK_FORMAT_R8G8_SRGB = 22,
 337     VK_FORMAT_R8G8B8_UNORM = 23,
 338     VK_FORMAT_R8G8B8_SNORM = 24,
 339     VK_FORMAT_R8G8B8_USCALED = 25,
 340     VK_FORMAT_R8G8B8_SSCALED = 26,
 341     VK_FORMAT_R8G8B8_UINT = 27,
 342     VK_FORMAT_R8G8B8_SINT = 28,
 343     VK_FORMAT_R8G8B8_SRGB = 29,
 344     VK_FORMAT_B8G8R8_UNORM = 30,
 345     VK_FORMAT_B8G8R8_SNORM = 31,
 346     VK_FORMAT_B8G8R8_USCALED = 32,
 347     VK_FORMAT_B8G8R8_SSCALED = 33,
 348     VK_FORMAT_B8G8R8_UINT = 34,
 349     VK_FORMAT_B8G8R8_SINT = 35,
 350     VK_FORMAT_B8G8R8_SRGB = 36,
 351     VK_FORMAT_R8G8B8A8_UNORM = 37,
 352     VK_FORMAT_R8G8B8A8_SNORM = 38,
 353     VK_FORMAT_R8G8B8A8_USCALED = 39,
 354     VK_FORMAT_R8G8B8A8_SSCALED = 40,
 355     VK_FORMAT_R8G8B8A8_UINT = 41,
 356     VK_FORMAT_R8G8B8A8_SINT = 42,
 357     VK_FORMAT_R8G8B8A8_SRGB = 43,
 358     VK_FORMAT_B8G8R8A8_UNORM = 44,
 359     VK_FORMAT_B8G8R8A8_SNORM = 45,
 360     VK_FORMAT_B8G8R8A8_USCALED = 46,
 361     VK_FORMAT_B8G8R8A8_SSCALED = 47,
 362     VK_FORMAT_B8G8R8A8_UINT = 48,
 363     VK_FORMAT_B8G8R8A8_SINT = 49,
 364     VK_FORMAT_B8G8R8A8_SRGB = 50,
 365     VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51,
 366     VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52,
 367     VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53,
 368     VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54,
 369     VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55,
 370     VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56,
 371     VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57,
 372     VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58,
 373     VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59,
 374     VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60,
 375     VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61,
 376     VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62,
 377     VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63,
 378     VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64,
 379     VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65,
 380     VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66,
 381     VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67,
 382     VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68,
 383     VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69,
 384     VK_FORMAT_R16_UNORM = 70,
 385     VK_FORMAT_R16_SNORM = 71,
 386     VK_FORMAT_R16_USCALED = 72,
 387     VK_FORMAT_R16_SSCALED = 73,
 388     VK_FORMAT_R16_UINT = 74,
 389     VK_FORMAT_R16_SINT = 75,
 390     VK_FORMAT_R16_SFLOAT = 76,
 391     VK_FORMAT_R16G16_UNORM = 77,
 392     VK_FORMAT_R16G16_SNORM = 78,
 393     VK_FORMAT_R16G16_USCALED = 79,
 394     VK_FORMAT_R16G16_SSCALED = 80,
 395     VK_FORMAT_R16G16_UINT = 81,
 396     VK_FORMAT_R16G16_SINT = 82,
 397     VK_FORMAT_R16G16_SFLOAT = 83,
 398     VK_FORMAT_R16G16B16_UNORM = 84,
 399     VK_FORMAT_R16G16B16_SNORM = 85,
 400     VK_FORMAT_R16G16B16_USCALED = 86,
 401     VK_FORMAT_R16G16B16_SSCALED = 87,
 402     VK_FORMAT_R16G16B16_UINT = 88,
 403     VK_FORMAT_R16G16B16_SINT = 89,
 404     VK_FORMAT_R16G16B16_SFLOAT = 90,
 405     VK_FORMAT_R16G16B16A16_UNORM = 91,
 406     VK_FORMAT_R16G16B16A16_SNORM = 92,
 407     VK_FORMAT_R16G16B16A16_USCALED = 93,
 408     VK_FORMAT_R16G16B16A16_SSCALED = 94,
 409     VK_FORMAT_R16G16B16A16_UINT = 95,
 410     VK_FORMAT_R16G16B16A16_SINT = 96,
 411     VK_FORMAT_R16G16B16A16_SFLOAT = 97,
 412     VK_FORMAT_R32_UINT = 98,
 413     VK_FORMAT_R32_SINT = 99,
 414     VK_FORMAT_R32_SFLOAT = 100,
 415     VK_FORMAT_R32G32_UINT = 101,
 416     VK_FORMAT_R32G32_SINT = 102,
 417     VK_FORMAT_R32G32_SFLOAT = 103,
 418     VK_FORMAT_R32G32B32_UINT = 104,
 419     VK_FORMAT_R32G32B32_SINT = 105,
 420     VK_FORMAT_R32G32B32_SFLOAT = 106,
 421     VK_FORMAT_R32G32B32A32_UINT = 107,
 422     VK_FORMAT_R32G32B32A32_SINT = 108,
 423     VK_FORMAT_R32G32B32A32_SFLOAT = 109,
 424     VK_FORMAT_R64_UINT = 110,
 425     VK_FORMAT_R64_SINT = 111,
 426     VK_FORMAT_R64_SFLOAT = 112,
 427     VK_FORMAT_R64G64_UINT = 113,
 428     VK_FORMAT_R64G64_SINT = 114,
 429     VK_FORMAT_R64G64_SFLOAT = 115,
 430     VK_FORMAT_R64G64B64_UINT = 116,
 431     VK_FORMAT_R64G64B64_SINT = 117,
 432     VK_FORMAT_R64G64B64_SFLOAT = 118,
 433     VK_FORMAT_R64G64B64A64_UINT = 119,
 434     VK_FORMAT_R64G64B64A64_SINT = 120,
 435     VK_FORMAT_R64G64B64A64_SFLOAT = 121,
 436     VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122,
 437     VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123,
 438     VK_FORMAT_D16_UNORM = 124,
 439     VK_FORMAT_X8_D24_UNORM_PACK32 = 125,
 440     VK_FORMAT_D32_SFLOAT = 126,
 441     VK_FORMAT_S8_UINT = 127,
 442     VK_FORMAT_D16_UNORM_S8_UINT = 128,
 443     VK_FORMAT_D24_UNORM_S8_UINT = 129,
 444     VK_FORMAT_D32_SFLOAT_S8_UINT = 130,
 445     VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131,
 446     VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132,
 447     VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133,
 448     VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134,
 449     VK_FORMAT_BC2_UNORM_BLOCK = 135,
 450     VK_FORMAT_BC2_SRGB_BLOCK = 136,
 451     VK_FORMAT_BC3_UNORM_BLOCK = 137,
 452     VK_FORMAT_BC3_SRGB_BLOCK = 138,
 453     VK_FORMAT_BC4_UNORM_BLOCK = 139,
 454     VK_FORMAT_BC4_SNORM_BLOCK = 140,
 455     VK_FORMAT_BC5_UNORM_BLOCK = 141,
 456     VK_FORMAT_BC5_SNORM_BLOCK = 142,
 457     VK_FORMAT_BC6H_UFLOAT_BLOCK = 143,
 458     VK_FORMAT_BC6H_SFLOAT_BLOCK = 144,
 459     VK_FORMAT_BC7_UNORM_BLOCK = 145,
 460     VK_FORMAT_BC7_SRGB_BLOCK = 146,
 461     VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147,
 462     VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148,
 463     VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149,
 464     VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150,
 465     VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151,
 466     VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152,
 467     VK_FORMAT_EAC_R11_UNORM_BLOCK = 153,
 468     VK_FORMAT_EAC_R11_SNORM_BLOCK = 154,
 469     VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155,
 470     VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156,
 471     VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157,
 472     VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158,
 473     VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159,
 474     VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160,
 475     VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161,
 476     VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162,
 477     VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163,
 478     VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164,
 479     VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165,
 480     VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166,
 481     VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167,
 482     VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168,
 483     VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169,
 484     VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170,
 485     VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171,
 486     VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172,
 487     VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173,
 488     VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174,
 489     VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175,
 490     VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176,
 491     VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177,
 492     VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178,
 493     VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179,
 494     VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180,
 495     VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181,
 496     VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182,
 497     VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183,
 498     VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184,
 499     VK_FORMAT_BEGIN_RANGE = VK_FORMAT_UNDEFINED,
 500     VK_FORMAT_END_RANGE = VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
 501     VK_FORMAT_RANGE_SIZE = (VK_FORMAT_ASTC_12x12_SRGB_BLOCK - VK_FORMAT_UNDEFINED + 1),
 502     VK_FORMAT_MAX_ENUM = 0x7FFFFFFF
 503 } VkFormat;
 504
 505 typedef enum VkImageType {
 506     VK_IMAGE_TYPE_1D = 0,
 507     VK_IMAGE_TYPE_2D = 1,
 508     VK_IMAGE_TYPE_3D = 2,
 509     VK_IMAGE_TYPE_BEGIN_RANGE = VK_IMAGE_TYPE_1D,
 510     VK_IMAGE_TYPE_END_RANGE = VK_IMAGE_TYPE_3D,
 511     VK_IMAGE_TYPE_RANGE_SIZE = (VK_IMAGE_TYPE_3D - VK_IMAGE_TYPE_1D + 1),
 512     VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF
 513 } VkImageType;
 514
 515 typedef enum VkImageTiling {
 516     VK_IMAGE_TILING_OPTIMAL = 0,
 517     VK_IMAGE_TILING_LINEAR = 1,
 518     VK_IMAGE_TILING_BEGIN_RANGE = VK_IMAGE_TILING_OPTIMAL,
 519     VK_IMAGE_TILING_END_RANGE = VK_IMAGE_TILING_LINEAR,
 520     VK_IMAGE_TILING_RANGE_SIZE = (VK_IMAGE_TILING_LINEAR - VK_IMAGE_TILING_OPTIMAL + 1),
 521     VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF
 522 } VkImageTiling;
 523
 524 typedef enum VkPhysicalDeviceType {
 525     VK_PHYSICAL_DEVICE_TYPE_OTHER = 0,
 526     VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1,
 527     VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2,
 528     VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3,
 529     VK_PHYSICAL_DEVICE_TYPE_CPU = 4,
 530     VK_PHYSICAL_DEVICE_TYPE_BEGIN_RANGE = VK_PHYSICAL_DEVICE_TYPE_OTHER,
 531     VK_PHYSICAL_DEVICE_TYPE_END_RANGE = VK_PHYSICAL_DEVICE_TYPE_CPU,
 532     VK_PHYSICAL_DEVICE_TYPE_RANGE_SIZE = (VK_PHYSICAL_DEVICE_TYPE_CPU - VK_PHYSICAL_DEVICE_TYPE_OTHER + 1),
 533     VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF
 534 } VkPhysicalDeviceType;
 535
 536 typedef enum VkQueryType {
 537     VK_QUERY_TYPE_OCCLUSION = 0,
 538     VK_QUERY_TYPE_PIPELINE_STATISTICS = 1,
 539     VK_QUERY_TYPE_TIMESTAMP = 2,
 540     VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION,
 541     VK_QUERY_TYPE_END_RANGE = VK_QUERY_TYPE_TIMESTAMP,
 542     VK_QUERY_TYPE_RANGE_SIZE = (VK_QUERY_TYPE_TIMESTAMP - VK_QUERY_TYPE_OCCLUSION + 1),
 543     VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF
 544 } VkQueryType;
 545
 546 typedef enum VkSharingMode {
 547     VK_SHARING_MODE_EXCLUSIVE = 0,
 548     VK_SHARING_MODE_CONCURRENT = 1,
 549     VK_SHARING_MODE_BEGIN_RANGE = VK_SHARING_MODE_EXCLUSIVE,
 550     VK_SHARING_MODE_END_RANGE = VK_SHARING_MODE_CONCURRENT,
 551     VK_SHARING_MODE_RANGE_SIZE = (VK_SHARING_MODE_CONCURRENT - VK_SHARING_MODE_EXCLUSIVE + 1),
 552     VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF
 553 } VkSharingMode;
 554
 555 typedef enum VkImageLayout {
 556     VK_IMAGE_LAYOUT_UNDEFINED = 0,
 557     VK_IMAGE_LAYOUT_GENERAL = 1,
 558     VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2,
 559     VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3,
 560     VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4,
 561     VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5,
 562     VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6,
 563     VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7,
 564     VK_IMAGE_LAYOUT_PREINITIALIZED = 8,
 565     VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002,
 566     VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000,
 567     VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR = 1000117000,
 568     VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR = 1000117001,
 569     VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED,
 570     VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_PREINITIALIZED,
 571     VK_IMAGE_LAYOUT_RANGE_SIZE = (VK_IMAGE_LAYOUT_PREINITIALIZED - VK_IMAGE_LAYOUT_UNDEFINED + 1),
 572     VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF
 573 } VkImageLayout;
 574
 575 typedef enum VkImageViewType {
 576     VK_IMAGE_VIEW_TYPE_1D = 0,
 577     VK_IMAGE_VIEW_TYPE_2D = 1,
 578     VK_IMAGE_VIEW_TYPE_3D = 2,
 579     VK_IMAGE_VIEW_TYPE_CUBE = 3,
 580     VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4,
 581     VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5,
 582     VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6,
 583     VK_IMAGE_VIEW_TYPE_BEGIN_RANGE = VK_IMAGE_VIEW_TYPE_1D,
 584     VK_IMAGE_VIEW_TYPE_END_RANGE = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY,
 585     VK_IMAGE_VIEW_TYPE_RANGE_SIZE = (VK_IMAGE_VIEW_TYPE_CUBE_ARRAY - VK_IMAGE_VIEW_TYPE_1D + 1),
 586     VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF
 587 } VkImageViewType;
 588
 589 typedef enum VkComponentSwizzle {
 590     VK_COMPONENT_SWIZZLE_IDENTITY = 0,
 591     VK_COMPONENT_SWIZZLE_ZERO = 1,
 592     VK_COMPONENT_SWIZZLE_ONE = 2,
 593     VK_COMPONENT_SWIZZLE_R = 3,
 594     VK_COMPONENT_SWIZZLE_G = 4,
 595     VK_COMPONENT_SWIZZLE_B = 5,
 596     VK_COMPONENT_SWIZZLE_A = 6,
 597     VK_COMPONENT_SWIZZLE_BEGIN_RANGE = VK_COMPONENT_SWIZZLE_IDENTITY,
 598     VK_COMPONENT_SWIZZLE_END_RANGE = VK_COMPONENT_SWIZZLE_A,
 599     VK_COMPONENT_SWIZZLE_RANGE_SIZE = (VK_COMPONENT_SWIZZLE_A - VK_COMPONENT_SWIZZLE_IDENTITY + 1),
 600     VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF
 601 } VkComponentSwizzle;
 602
 603 typedef enum VkVertexInputRate {
 604     VK_VERTEX_INPUT_RATE_VERTEX = 0,
 605     VK_VERTEX_INPUT_RATE_INSTANCE = 1,
 606     VK_VERTEX_INPUT_RATE_BEGIN_RANGE = VK_VERTEX_INPUT_RATE_VERTEX,
 607     VK_VERTEX_INPUT_RATE_END_RANGE = VK_VERTEX_INPUT_RATE_INSTANCE,
 608     VK_VERTEX_INPUT_RATE_RANGE_SIZE = (VK_VERTEX_INPUT_RATE_INSTANCE - VK_VERTEX_INPUT_RATE_VERTEX + 1),
 609     VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF
 610 } VkVertexInputRate;
 611
 612 typedef enum VkPrimitiveTopology {
 613     VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0,
 614     VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1,
 615     VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2,
 616     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3,
 617     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4,
 618     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5,
 619     VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6,
 620     VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7,
 621     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8,
 622     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9,
 623     VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10,
 624     VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = VK_PRIMITIVE_TOPOLOGY_POINT_LIST,
 625     VK_PRIMITIVE_TOPOLOGY_END_RANGE = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST,
 626     VK_PRIMITIVE_TOPOLOGY_RANGE_SIZE = (VK_PRIMITIVE_TOPOLOGY_PATCH_LIST - VK_PRIMITIVE_TOPOLOGY_POINT_LIST + 1),
 627     VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF
 628 } VkPrimitiveTopology;
 629
 630 typedef enum VkPolygonMode {
 631     VK_POLYGON_MODE_FILL = 0,
 632     VK_POLYGON_MODE_LINE = 1,
 633     VK_POLYGON_MODE_POINT = 2,
 634     VK_POLYGON_MODE_BEGIN_RANGE = VK_POLYGON_MODE_FILL,
 635     VK_POLYGON_MODE_END_RANGE = VK_POLYGON_MODE_POINT,
 636     VK_POLYGON_MODE_RANGE_SIZE = (VK_POLYGON_MODE_POINT - VK_POLYGON_MODE_FILL + 1),
 637     VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF
 638 } VkPolygonMode;
 639
 640 typedef enum VkFrontFace {
 641     VK_FRONT_FACE_COUNTER_CLOCKWISE = 0,
 642     VK_FRONT_FACE_CLOCKWISE = 1,
 643     VK_FRONT_FACE_BEGIN_RANGE = VK_FRONT_FACE_COUNTER_CLOCKWISE,
 644     VK_FRONT_FACE_END_RANGE = VK_FRONT_FACE_CLOCKWISE,
 645     VK_FRONT_FACE_RANGE_SIZE = (VK_FRONT_FACE_CLOCKWISE - VK_FRONT_FACE_COUNTER_CLOCKWISE + 1),
 646     VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF
 647 } VkFrontFace;
 648
 649 typedef enum VkCompareOp {
 650     VK_COMPARE_OP_NEVER = 0,
 651     VK_COMPARE_OP_LESS = 1,
 652     VK_COMPARE_OP_EQUAL = 2,
 653     VK_COMPARE_OP_LESS_OR_EQUAL = 3,
 654     VK_COMPARE_OP_GREATER = 4,
 655     VK_COMPARE_OP_NOT_EQUAL = 5,
 656     VK_COMPARE_OP_GREATER_OR_EQUAL = 6,
 657     VK_COMPARE_OP_ALWAYS = 7,
 658     VK_COMPARE_OP_BEGIN_RANGE = VK_COMPARE_OP_NEVER,
 659     VK_COMPARE_OP_END_RANGE = VK_COMPARE_OP_ALWAYS,
 660     VK_COMPARE_OP_RANGE_SIZE = (VK_COMPARE_OP_ALWAYS - VK_COMPARE_OP_NEVER + 1),
 661     VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF
 662 } VkCompareOp;
 663
 664 typedef enum VkStencilOp {
 665     VK_STENCIL_OP_KEEP = 0,
 666     VK_STENCIL_OP_ZERO = 1,
 667     VK_STENCIL_OP_REPLACE = 2,
 668     VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3,
 669     VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4,
 670     VK_STENCIL_OP_INVERT = 5,
 671     VK_STENCIL_OP_INCREMENT_AND_WRAP = 6,
 672     VK_STENCIL_OP_DECREMENT_AND_WRAP = 7,
 673     VK_STENCIL_OP_BEGIN_RANGE = VK_STENCIL_OP_KEEP,
 674     VK_STENCIL_OP_END_RANGE = VK_STENCIL_OP_DECREMENT_AND_WRAP,
 675     VK_STENCIL_OP_RANGE_SIZE = (VK_STENCIL_OP_DECREMENT_AND_WRAP - VK_STENCIL_OP_KEEP + 1),
 676     VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF
 677 } VkStencilOp;
 678
 679 typedef enum VkLogicOp {
 680     VK_LOGIC_OP_CLEAR = 0,
 681     VK_LOGIC_OP_AND = 1,
 682     VK_LOGIC_OP_AND_REVERSE = 2,
 683     VK_LOGIC_OP_COPY = 3,
 684     VK_LOGIC_OP_AND_INVERTED = 4,
 685     VK_LOGIC_OP_NO_OP = 5,
 686     VK_LOGIC_OP_XOR = 6,
 687     VK_LOGIC_OP_OR = 7,
 688     VK_LOGIC_OP_NOR = 8,
 689     VK_LOGIC_OP_EQUIVALENT = 9,
 690     VK_LOGIC_OP_INVERT = 10,
 691     VK_LOGIC_OP_OR_REVERSE = 11,
 692     VK_LOGIC_OP_COPY_INVERTED = 12,
 693     VK_LOGIC_OP_OR_INVERTED = 13,
 694     VK_LOGIC_OP_NAND = 14,
 695     VK_LOGIC_OP_SET = 15,
 696     VK_LOGIC_OP_BEGIN_RANGE = VK_LOGIC_OP_CLEAR,
 697     VK_LOGIC_OP_END_RANGE = VK_LOGIC_OP_SET,
 698     VK_LOGIC_OP_RANGE_SIZE = (VK_LOGIC_OP_SET - VK_LOGIC_OP_CLEAR + 1),
 699     VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF
 700 } VkLogicOp;
 701
 702 typedef enum VkBlendFactor {
 703     VK_BLEND_FACTOR_ZERO = 0,
 704     VK_BLEND_FACTOR_ONE = 1,
 705     VK_BLEND_FACTOR_SRC_COLOR = 2,
 706     VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3,
 707     VK_BLEND_FACTOR_DST_COLOR = 4,
 708     VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5,
 709     VK_BLEND_FACTOR_SRC_ALPHA = 6,
 710     VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7,
 711     VK_BLEND_FACTOR_DST_ALPHA = 8,
 712     VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9,
 713     VK_BLEND_FACTOR_CONSTANT_COLOR = 10,
 714     VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11,
 715     VK_BLEND_FACTOR_CONSTANT_ALPHA = 12,
 716     VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13,
 717     VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14,
 718     VK_BLEND_FACTOR_SRC1_COLOR = 15,
 719     VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16,
 720     VK_BLEND_FACTOR_SRC1_ALPHA = 17,
 721     VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18,
 722     VK_BLEND_FACTOR_BEGIN_RANGE = VK_BLEND_FACTOR_ZERO,
 723     VK_BLEND_FACTOR_END_RANGE = VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA,
 724     VK_BLEND_FACTOR_RANGE_SIZE = (VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA - VK_BLEND_FACTOR_ZERO + 1),
 725     VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF
 726 } VkBlendFactor;
 727
 728 typedef enum VkBlendOp {
 729     VK_BLEND_OP_ADD = 0,
 730     VK_BLEND_OP_SUBTRACT = 1,
 731     VK_BLEND_OP_REVERSE_SUBTRACT = 2,
 732     VK_BLEND_OP_MIN = 3,
 733     VK_BLEND_OP_MAX = 4,
 734     VK_BLEND_OP_BEGIN_RANGE = VK_BLEND_OP_ADD,
 735     VK_BLEND_OP_END_RANGE = VK_BLEND_OP_MAX,
 736     VK_BLEND_OP_RANGE_SIZE = (VK_BLEND_OP_MAX - VK_BLEND_OP_ADD + 1),
 737     VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF
 738 } VkBlendOp;
 739
 740 typedef enum VkDynamicState {
 741     VK_DYNAMIC_STATE_VIEWPORT = 0,
 742     VK_DYNAMIC_STATE_SCISSOR = 1,
 743     VK_DYNAMIC_STATE_LINE_WIDTH = 2,
 744     VK_DYNAMIC_STATE_DEPTH_BIAS = 3,
 745     VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4,
 746     VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5,
 747     VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6,
 748     VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7,
 749     VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8,
 750     VK_DYNAMIC_STATE_BEGIN_RANGE = VK_DYNAMIC_STATE_VIEWPORT,
 751     VK_DYNAMIC_STATE_END_RANGE = VK_DYNAMIC_STATE_STENCIL_REFERENCE,
 752     VK_DYNAMIC_STATE_RANGE_SIZE = (VK_DYNAMIC_STATE_STENCIL_REFERENCE - VK_DYNAMIC_STATE_VIEWPORT + 1),
 753     VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF
 754 } VkDynamicState;
 755
 756 typedef enum VkFilter {
 757     VK_FILTER_NEAREST = 0,
 758     VK_FILTER_LINEAR = 1,
 759     VK_FILTER_BEGIN_RANGE = VK_FILTER_NEAREST,
 760     VK_FILTER_END_RANGE = VK_FILTER_LINEAR,
 761     VK_FILTER_RANGE_SIZE = (VK_FILTER_LINEAR - VK_FILTER_NEAREST + 1),
 762     VK_FILTER_MAX_ENUM = 0x7FFFFFFF
 763 } VkFilter;
 764
 765 typedef enum VkSamplerMipmapMode {
 766     VK_SAMPLER_MIPMAP_MODE_NEAREST = 0,
 767     VK_SAMPLER_MIPMAP_MODE_LINEAR = 1,
 768     VK_SAMPLER_MIPMAP_MODE_BEGIN_RANGE = VK_SAMPLER_MIPMAP_MODE_NEAREST,
 769     VK_SAMPLER_MIPMAP_MODE_END_RANGE = VK_SAMPLER_MIPMAP_MODE_LINEAR,
 770     VK_SAMPLER_MIPMAP_MODE_RANGE_SIZE = (VK_SAMPLER_MIPMAP_MODE_LINEAR - VK_SAMPLER_MIPMAP_MODE_NEAREST + 1),
 771     VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF
 772 } VkSamplerMipmapMode;
 773
 774 typedef enum VkSamplerAddressMode {
 775     VK_SAMPLER_ADDRESS_MODE_REPEAT = 0,
 776     VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1,
 777     VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2,
 778     VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3,
 779     VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4,
 780     VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE = VK_SAMPLER_ADDRESS_MODE_REPEAT,
 781     VK_SAMPLER_ADDRESS_MODE_END_RANGE = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,
 782     VK_SAMPLER_ADDRESS_MODE_RANGE_SIZE = (VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER - VK_SAMPLER_ADDRESS_MODE_REPEAT + 1),
 783     VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF
 784 } VkSamplerAddressMode;
 785
 786 typedef enum VkBorderColor {
 787     VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0,
 788     VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1,
 789     VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2,
 790     VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3,
 791     VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4,
 792     VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5,
 793     VK_BORDER_COLOR_BEGIN_RANGE = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
 794     VK_BORDER_COLOR_END_RANGE = VK_BORDER_COLOR_INT_OPAQUE_WHITE,
 795     VK_BORDER_COLOR_RANGE_SIZE = (VK_BORDER_COLOR_INT_OPAQUE_WHITE - VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK + 1),
 796     VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF
 797 } VkBorderColor;
 798
 799 typedef enum VkDescriptorType {
 800     VK_DESCRIPTOR_TYPE_SAMPLER = 0,
 801     VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1,
 802     VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2,
 803     VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3,
 804     VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4,
 805     VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5,
 806     VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6,
 807     VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7,
 808     VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8,
 809     VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9,
 810     VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10,
 811     VK_DESCRIPTOR_TYPE_BEGIN_RANGE = VK_DESCRIPTOR_TYPE_SAMPLER,
 812     VK_DESCRIPTOR_TYPE_END_RANGE = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
 813     VK_DESCRIPTOR_TYPE_RANGE_SIZE = (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT - VK_DESCRIPTOR_TYPE_SAMPLER + 1),
 814     VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF
 815 } VkDescriptorType;
 816
 817 typedef enum VkAttachmentLoadOp {
 818     VK_ATTACHMENT_LOAD_OP_LOAD = 0,
 819     VK_ATTACHMENT_LOAD_OP_CLEAR = 1,
 820     VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2,
 821     VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE = VK_ATTACHMENT_LOAD_OP_LOAD,
 822     VK_ATTACHMENT_LOAD_OP_END_RANGE = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
 823     VK_ATTACHMENT_LOAD_OP_RANGE_SIZE = (VK_ATTACHMENT_LOAD_OP_DONT_CARE - VK_ATTACHMENT_LOAD_OP_LOAD + 1),
 824     VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF
 825 } VkAttachmentLoadOp;
 826
 827 typedef enum VkAttachmentStoreOp {
 828     VK_ATTACHMENT_STORE_OP_STORE = 0,
 829     VK_ATTACHMENT_STORE_OP_DONT_CARE = 1,
 830     VK_ATTACHMENT_STORE_OP_BEGIN_RANGE = VK_ATTACHMENT_STORE_OP_STORE,
 831     VK_ATTACHMENT_STORE_OP_END_RANGE = VK_ATTACHMENT_STORE_OP_DONT_CARE,
 832     VK_ATTACHMENT_STORE_OP_RANGE_SIZE = (VK_ATTACHMENT_STORE_OP_DONT_CARE - VK_ATTACHMENT_STORE_OP_STORE + 1),
 833     VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF
 834 } VkAttachmentStoreOp;
 835
 836 typedef enum VkPipelineBindPoint {
 837     VK_PIPELINE_BIND_POINT_GRAPHICS = 0,
 838     VK_PIPELINE_BIND_POINT_COMPUTE = 1,
 839     VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VK_PIPELINE_BIND_POINT_GRAPHICS,
 840     VK_PIPELINE_BIND_POINT_END_RANGE = VK_PIPELINE_BIND_POINT_COMPUTE,
 841     VK_PIPELINE_BIND_POINT_RANGE_SIZE = (VK_PIPELINE_BIND_POINT_COMPUTE - VK_PIPELINE_BIND_POINT_GRAPHICS + 1),
 842     VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF
 843 } VkPipelineBindPoint;
 844
 845 typedef enum VkCommandBufferLevel {
 846     VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0,
 847     VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1,
 848     VK_COMMAND_BUFFER_LEVEL_BEGIN_RANGE = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
 849     VK_COMMAND_BUFFER_LEVEL_END_RANGE = VK_COMMAND_BUFFER_LEVEL_SECONDARY,
 850     VK_COMMAND_BUFFER_LEVEL_RANGE_SIZE = (VK_COMMAND_BUFFER_LEVEL_SECONDARY - VK_COMMAND_BUFFER_LEVEL_PRIMARY + 1),
 851     VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF
 852 } VkCommandBufferLevel;
 853
 854 typedef enum VkIndexType {
 855     VK_INDEX_TYPE_UINT16 = 0,
 856     VK_INDEX_TYPE_UINT32 = 1,
 857     VK_INDEX_TYPE_BEGIN_RANGE = VK_INDEX_TYPE_UINT16,
 858     VK_INDEX_TYPE_END_RANGE = VK_INDEX_TYPE_UINT32,
 859     VK_INDEX_TYPE_RANGE_SIZE = (VK_INDEX_TYPE_UINT32 - VK_INDEX_TYPE_UINT16 + 1),
 860     VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF
 861 } VkIndexType;
 862
 863 typedef enum VkSubpassContents {
 864     VK_SUBPASS_CONTENTS_INLINE = 0,
 865     VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1,
 866     VK_SUBPASS_CONTENTS_BEGIN_RANGE = VK_SUBPASS_CONTENTS_INLINE,
 867     VK_SUBPASS_CONTENTS_END_RANGE = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS,
 868     VK_SUBPASS_CONTENTS_RANGE_SIZE = (VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS - VK_SUBPASS_CONTENTS_INLINE + 1),
 869     VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF
 870 } VkSubpassContents;
 871
 872 typedef enum VkObjectType {
 873     VK_OBJECT_TYPE_UNKNOWN = 0,
 874     VK_OBJECT_TYPE_INSTANCE = 1,
 875     VK_OBJECT_TYPE_PHYSICAL_DEVICE = 2,
 876     VK_OBJECT_TYPE_DEVICE = 3,
 877     VK_OBJECT_TYPE_QUEUE = 4,
 878     VK_OBJECT_TYPE_SEMAPHORE = 5,
 879     VK_OBJECT_TYPE_COMMAND_BUFFER = 6,
 880     VK_OBJECT_TYPE_FENCE = 7,
 881     VK_OBJECT_TYPE_DEVICE_MEMORY = 8,
 882     VK_OBJECT_TYPE_BUFFER = 9,
 883     VK_OBJECT_TYPE_IMAGE = 10,
 884     VK_OBJECT_TYPE_EVENT = 11,
 885     VK_OBJECT_TYPE_QUERY_POOL = 12,
 886     VK_OBJECT_TYPE_BUFFER_VIEW = 13,
 887     VK_OBJECT_TYPE_IMAGE_VIEW = 14,
 888     VK_OBJECT_TYPE_SHADER_MODULE = 15,
 889     VK_OBJECT_TYPE_PIPELINE_CACHE = 16,
 890     VK_OBJECT_TYPE_PIPELINE_LAYOUT = 17,
 891     VK_OBJECT_TYPE_RENDER_PASS = 18,
 892     VK_OBJECT_TYPE_PIPELINE = 19,
 893     VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 20,
 894     VK_OBJECT_TYPE_SAMPLER = 21,
 895     VK_OBJECT_TYPE_DESCRIPTOR_POOL = 22,
 896     VK_OBJECT_TYPE_DESCRIPTOR_SET = 23,
 897     VK_OBJECT_TYPE_FRAMEBUFFER = 24,
 898     VK_OBJECT_TYPE_COMMAND_POOL = 25,
 899     VK_OBJECT_TYPE_SURFACE_KHR = 1000000000,
 900     VK_OBJECT_TYPE_SWAPCHAIN_KHR = 1000001000,
 901     VK_OBJECT_TYPE_DISPLAY_KHR = 1000002000,
 902     VK_OBJECT_TYPE_DISPLAY_MODE_KHR = 1000002001,
 903     VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT = 1000011000,
 904     VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = 1000085000,
 905     VK_OBJECT_TYPE_OBJECT_TABLE_NVX = 1000086000,
 906     VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX = 1000086001,
 907     VK_OBJECT_TYPE_BEGIN_RANGE = VK_OBJECT_TYPE_UNKNOWN,
 908     VK_OBJECT_TYPE_END_RANGE = VK_OBJECT_TYPE_COMMAND_POOL,
 909     VK_OBJECT_TYPE_RANGE_SIZE = (VK_OBJECT_TYPE_COMMAND_POOL - VK_OBJECT_TYPE_UNKNOWN + 1),
 910     VK_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF
 911 } VkObjectType;
 912
 913 typedef VkFlags VkInstanceCreateFlags;
 914
 915 typedef enum VkFormatFeatureFlagBits {
 916     VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001,
 917     VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002,
 918     VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004,
 919     VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008,
 920     VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010,
 921     VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020,
 922     VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040,
 923     VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080,
 924     VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100,
 925     VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200,
 926     VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400,
 927     VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800,
 928     VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000,
 929     VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = 0x00004000,
 930     VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = 0x00008000,
 931     VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 932 } VkFormatFeatureFlagBits;
 933 typedef VkFlags VkFormatFeatureFlags;
 934
 935 typedef enum VkImageUsageFlagBits {
 936     VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001,
 937     VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002,
 938     VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004,
 939     VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008,
 940     VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010,
 941     VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020,
 942     VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040,
 943     VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080,
 944     VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 945 } VkImageUsageFlagBits;
 946 typedef VkFlags VkImageUsageFlags;
 947
 948 typedef enum VkImageCreateFlagBits {
 949     VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001,
 950     VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,
 951     VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
 952     VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008,
 953     VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010,
 954     VK_IMAGE_CREATE_BIND_SFR_BIT_KHX = 0x00000040,
 955     VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = 0x00000020,
 956     VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR = 0x00000080,
 957     VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR = 0x00000100,
 958         VK_IMAGE_CREATE_ALIAS_BIT_KHR = 0x00000400,
 959     VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 960 } VkImageCreateFlagBits;
 961 typedef VkFlags VkImageCreateFlags;
 962
 963 typedef enum VkSampleCountFlagBits {
 964     VK_SAMPLE_COUNT_1_BIT = 0x00000001,
 965     VK_SAMPLE_COUNT_2_BIT = 0x00000002,
 966     VK_SAMPLE_COUNT_4_BIT = 0x00000004,
 967     VK_SAMPLE_COUNT_8_BIT = 0x00000008,
 968     VK_SAMPLE_COUNT_16_BIT = 0x00000010,
 969     VK_SAMPLE_COUNT_32_BIT = 0x00000020,
 970     VK_SAMPLE_COUNT_64_BIT = 0x00000040,
 971     VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 972 } VkSampleCountFlagBits;
 973 typedef VkFlags VkSampleCountFlags;
 974
 975 typedef enum VkQueueFlagBits {
 976     VK_QUEUE_GRAPHICS_BIT = 0x00000001,
 977     VK_QUEUE_COMPUTE_BIT = 0x00000002,
 978     VK_QUEUE_TRANSFER_BIT = 0x00000004,
 979     VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008,
 980     VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 981 } VkQueueFlagBits;
 982 typedef VkFlags VkQueueFlags;
 983
 984 typedef enum VkMemoryPropertyFlagBits {
 985     VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001,
 986     VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002,
 987     VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004,
 988     VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008,
 989     VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010,
 990     VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 991 } VkMemoryPropertyFlagBits;
 992 typedef VkFlags VkMemoryPropertyFlags;
 993
 994 typedef enum VkMemoryHeapFlagBits {
 995     VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001,
 996     VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHX = 0x00000002,
 997     VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 998 } VkMemoryHeapFlagBits;
 999 typedef VkFlags VkMemoryHeapFlags;
1000 typedef VkFlags VkDeviceCreateFlags;
1001 typedef VkFlags VkDeviceQueueCreateFlags;
1002
1003 typedef enum VkPipelineStageFlagBits {
1004     VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001,
1005     VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002,
1006     VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004,
1007     VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008,
1008     VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010,
1009     VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020,
1010     VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040,
1011     VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080,
1012     VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100,
1013     VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200,
1014     VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400,
1015     VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800,
1016     VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000,
1017     VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000,
1018     VK_PIPELINE_STAGE_HOST_BIT = 0x00004000,
1019     VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000,
1020     VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000,
1021     VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1022 } VkPipelineStageFlagBits;
1023 typedef VkFlags VkPipelineStageFlags;
1024 typedef VkFlags VkMemoryMapFlags;
1025
1026 typedef enum VkImageAspectFlagBits {
1027     VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001,
1028     VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002,
1029     VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004,
1030     VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008,
1031     VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1032 } VkImageAspectFlagBits;
1033 typedef VkFlags VkImageAspectFlags;
1034
1035 typedef enum VkSparseImageFormatFlagBits {
1036     VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001,
1037     VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002,
1038     VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004,
1039     VK_SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1040 } VkSparseImageFormatFlagBits;
1041 typedef VkFlags VkSparseImageFormatFlags;
1042
1043 typedef enum VkSparseMemoryBindFlagBits {
1044     VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0x00000001,
1045     VK_SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1046 } VkSparseMemoryBindFlagBits;
1047 typedef VkFlags VkSparseMemoryBindFlags;
1048
1049 typedef enum VkFenceCreateFlagBits {
1050     VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001,
1051     VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1052 } VkFenceCreateFlagBits;
1053 typedef VkFlags VkFenceCreateFlags;
1054 typedef VkFlags VkSemaphoreCreateFlags;
1055 typedef VkFlags VkEventCreateFlags;
1056 typedef VkFlags VkQueryPoolCreateFlags;
1057
1058 typedef enum VkQueryPipelineStatisticFlagBits {
1059     VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001,
1060     VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002,
1061     VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004,
1062     VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008,
1063     VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0x00000010,
1064     VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0x00000020,
1065     VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0x00000040,
1066     VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0x00000080,
1067     VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x00000100,
1068     VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0x00000200,
1069     VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400,
1070     VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1071 } VkQueryPipelineStatisticFlagBits;
1072 typedef VkFlags VkQueryPipelineStatisticFlags;
1073
1074 typedef enum VkQueryResultFlagBits {
1075     VK_QUERY_RESULT_64_BIT = 0x00000001,
1076     VK_QUERY_RESULT_WAIT_BIT = 0x00000002,
1077     VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004,
1078     VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008,
1079     VK_QUERY_RESULT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1080 } VkQueryResultFlagBits;
1081 typedef VkFlags VkQueryResultFlags;
1082
1083 typedef enum VkBufferCreateFlagBits {
1084     VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001,
1085     VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,
1086     VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
1087     VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1088 } VkBufferCreateFlagBits;
1089 typedef VkFlags VkBufferCreateFlags;
1090
1091 typedef enum VkBufferUsageFlagBits {
1092     VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001,
1093     VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002,
1094     VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004,
1095     VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008,
1096     VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010,
1097     VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020,
1098     VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040,
1099     VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080,
1100     VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100,
1101     VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1102 } VkBufferUsageFlagBits;
1103 typedef VkFlags VkBufferUsageFlags;
1104 typedef VkFlags VkBufferViewCreateFlags;
1105 typedef VkFlags VkImageViewCreateFlags;
1106 typedef VkFlags VkShaderModuleCreateFlags;
1107 typedef VkFlags VkPipelineCacheCreateFlags;
1108
1109 typedef enum VkPipelineCreateFlagBits {
1110     VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001,
1111     VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002,
1112     VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004,
1113     VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHX = 0x00000008,
1114     VK_PIPELINE_CREATE_DISPATCH_BASE_KHX = 0x00000010,
1115     VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1116 } VkPipelineCreateFlagBits;
1117 typedef VkFlags VkPipelineCreateFlags;
1118 typedef VkFlags VkPipelineShaderStageCreateFlags;
1119
1120 typedef enum VkShaderStageFlagBits {
1121     VK_SHADER_STAGE_VERTEX_BIT = 0x00000001,
1122     VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002,
1123     VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004,
1124     VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008,
1125     VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010,
1126     VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020,
1127     VK_SHADER_STAGE_ALL_GRAPHICS = 0x0000001F,
1128     VK_SHADER_STAGE_ALL = 0x7FFFFFFF,
1129     VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1130 } VkShaderStageFlagBits;
1131 typedef VkFlags VkPipelineVertexInputStateCreateFlags;
1132 typedef VkFlags VkPipelineInputAssemblyStateCreateFlags;
1133 typedef VkFlags VkPipelineTessellationStateCreateFlags;
1134 typedef VkFlags VkPipelineViewportStateCreateFlags;
1135 typedef VkFlags VkPipelineRasterizationStateCreateFlags;
1136
1137 typedef enum VkCullModeFlagBits {
1138     VK_CULL_MODE_NONE = 0,
1139     VK_CULL_MODE_FRONT_BIT = 0x00000001,
1140     VK_CULL_MODE_BACK_BIT = 0x00000002,
1141     VK_CULL_MODE_FRONT_AND_BACK = 0x00000003,
1142     VK_CULL_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1143 } VkCullModeFlagBits;
1144 typedef VkFlags VkCullModeFlags;
1145 typedef VkFlags VkPipelineMultisampleStateCreateFlags;
1146 typedef VkFlags VkPipelineDepthStencilStateCreateFlags;
1147 typedef VkFlags VkPipelineColorBlendStateCreateFlags;
1148
1149 typedef enum VkColorComponentFlagBits {
1150     VK_COLOR_COMPONENT_R_BIT = 0x00000001,
1151     VK_COLOR_COMPONENT_G_BIT = 0x00000002,
1152     VK_COLOR_COMPONENT_B_BIT = 0x00000004,
1153     VK_COLOR_COMPONENT_A_BIT = 0x00000008,
1154     VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1155 } VkColorComponentFlagBits;
1156 typedef VkFlags VkColorComponentFlags;
1157 typedef VkFlags VkPipelineDynamicStateCreateFlags;
1158 typedef VkFlags VkPipelineLayoutCreateFlags;
1159 typedef VkFlags VkShaderStageFlags;
1160 typedef VkFlags VkSamplerCreateFlags;
1161
1162 typedef enum VkDescriptorSetLayoutCreateFlagBits {
1163     VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR = 0x00000001,
1164     VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1165 } VkDescriptorSetLayoutCreateFlagBits;
1166 typedef VkFlags VkDescriptorSetLayoutCreateFlags;
1167
1168 typedef enum VkDescriptorPoolCreateFlagBits {
1169     VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001,
1170     VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1171 } VkDescriptorPoolCreateFlagBits;
1172 typedef VkFlags VkDescriptorPoolCreateFlags;
1173 typedef VkFlags VkDescriptorPoolResetFlags;
1174 typedef VkFlags VkFramebufferCreateFlags;
1175 typedef VkFlags VkRenderPassCreateFlags;
1176
1177 typedef enum VkAttachmentDescriptionFlagBits {
1178     VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001,
1179     VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1180 } VkAttachmentDescriptionFlagBits;
1181 typedef VkFlags VkAttachmentDescriptionFlags;
1182
1183 typedef enum VkSubpassDescriptionFlagBits {
1184     VK_SUBPASS_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1185 } VkSubpassDescriptionFlagBits;
1186 typedef VkFlags VkSubpassDescriptionFlags;
1187
1188 typedef enum VkAccessFlagBits {
1189     VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001,
1190     VK_ACCESS_INDEX_READ_BIT = 0x00000002,
1191     VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004,
1192     VK_ACCESS_UNIFORM_READ_BIT = 0x00000008,
1193     VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0x00000010,
1194     VK_ACCESS_SHADER_READ_BIT = 0x00000020,
1195     VK_ACCESS_SHADER_WRITE_BIT = 0x00000040,
1196     VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0x00000080,
1197     VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100,
1198     VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200,
1199     VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400,
1200     VK_ACCESS_TRANSFER_READ_BIT = 0x00000800,
1201     VK_ACCESS_TRANSFER_WRITE_BIT = 0x00001000,
1202     VK_ACCESS_HOST_READ_BIT = 0x00002000,
1203     VK_ACCESS_HOST_WRITE_BIT = 0x00004000,
1204     VK_ACCESS_MEMORY_READ_BIT = 0x00008000,
1205     VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000,
1206     VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1207 } VkAccessFlagBits;
1208 typedef VkFlags VkAccessFlags;
1209
1210 typedef enum VkDependencyFlagBits {
1211     VK_DEPENDENCY_BY_REGION_BIT = 0x00000001,
1212     VK_DEPENDENCY_VIEW_LOCAL_BIT_KHX = 0x00000002,
1213     VK_DEPENDENCY_DEVICE_GROUP_BIT_KHX = 0x00000004,
1214     VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1215 } VkDependencyFlagBits;
1216 typedef VkFlags VkDependencyFlags;
1217
1218 typedef enum VkCommandPoolCreateFlagBits {
1219     VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001,
1220     VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002,
1221     VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1222 } VkCommandPoolCreateFlagBits;
1223 typedef VkFlags VkCommandPoolCreateFlags;
1224
1225 typedef enum VkCommandPoolResetFlagBits {
1226     VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
1227     VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1228 } VkCommandPoolResetFlagBits;
1229 typedef VkFlags VkCommandPoolResetFlags;
1230
1231 typedef enum VkCommandBufferUsageFlagBits {
1232     VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001,
1233     VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002,
1234     VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004,
1235     VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1236 } VkCommandBufferUsageFlagBits;
1237 typedef VkFlags VkCommandBufferUsageFlags;
1238
1239 typedef enum VkQueryControlFlagBits {
1240     VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001,
1241     VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1242 } VkQueryControlFlagBits;
1243 typedef VkFlags VkQueryControlFlags;
1244
1245 typedef enum VkCommandBufferResetFlagBits {
1246     VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
1247     VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1248 } VkCommandBufferResetFlagBits;
1249 typedef VkFlags VkCommandBufferResetFlags;
1250
1251 typedef enum VkStencilFaceFlagBits {
1252     VK_STENCIL_FACE_FRONT_BIT = 0x00000001,
1253     VK_STENCIL_FACE_BACK_BIT = 0x00000002,
1254     VK_STENCIL_FRONT_AND_BACK = 0x00000003,
1255     VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1256 } VkStencilFaceFlagBits;
1257 typedef VkFlags VkStencilFaceFlags;
1258
1259 typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)(
1260     void*                                       pUserData,
1261     size_t                                      size,
1262     size_t                                      alignment,
1263     VkSystemAllocationScope                     allocationScope);
1264
1265 typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)(
1266     void*                                       pUserData,
1267     void*                                       pOriginal,
1268     size_t                                      size,
1269     size_t                                      alignment,
1270     VkSystemAllocationScope                     allocationScope);
1271
1272 typedef void (VKAPI_PTR *PFN_vkFreeFunction)(
1273     void*                                       pUserData,
1274     void*                                       pMemory);
1275
1276 typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)(
1277     void*                                       pUserData,
1278     size_t                                      size,
1279     VkInternalAllocationType                    allocationType,
1280     VkSystemAllocationScope                     allocationScope);
1281
1282 typedef void (VKAPI_PTR *PFN_vkInternalFreeNotification)(
1283     void*                                       pUserData,
1284     size_t                                      size,
1285     VkInternalAllocationType                    allocationType,
1286     VkSystemAllocationScope                     allocationScope);
1287
1288 typedef void (VKAPI_PTR *PFN_vkVoidFunction)(void);
1289
1290 typedef struct VkApplicationInfo {
1291     VkStructureType    sType;
1292     const void*        pNext;
1293     const char*        pApplicationName;
1294     uint32_t           applicationVersion;
1295     const char*        pEngineName;
1296     uint32_t           engineVersion;
1297     uint32_t           apiVersion;
1298 } VkApplicationInfo;
1299
1300 typedef struct VkInstanceCreateInfo {
1301     VkStructureType             sType;
1302     const void*                 pNext;
1303     VkInstanceCreateFlags       flags;
1304     const VkApplicationInfo*    pApplicationInfo;
1305     uint32_t                    enabledLayerCount;
1306     const char* const*          ppEnabledLayerNames;
1307     uint32_t                    enabledExtensionCount;
1308     const char* const*          ppEnabledExtensionNames;
1309 } VkInstanceCreateInfo;
1310
1311 typedef struct VkAllocationCallbacks {
1312     void*                                   pUserData;
1313     PFN_vkAllocationFunction                pfnAllocation;
1314     PFN_vkReallocationFunction              pfnReallocation;
1315     PFN_vkFreeFunction                      pfnFree;
1316     PFN_vkInternalAllocationNotification    pfnInternalAllocation;
1317     PFN_vkInternalFreeNotification          pfnInternalFree;
1318 } VkAllocationCallbacks;
1319
1320 typedef struct VkPhysicalDeviceFeatures {
1321     VkBool32    robustBufferAccess;
1322     VkBool32    fullDrawIndexUint32;
1323     VkBool32    imageCubeArray;
1324     VkBool32    independentBlend;
1325     VkBool32    geometryShader;
1326     VkBool32    tessellationShader;
1327     VkBool32    sampleRateShading;
1328     VkBool32    dualSrcBlend;
1329     VkBool32    logicOp;
1330     VkBool32    multiDrawIndirect;
1331     VkBool32    drawIndirectFirstInstance;
1332     VkBool32    depthClamp;
1333     VkBool32    depthBiasClamp;
1334     VkBool32    fillModeNonSolid;
1335     VkBool32    depthBounds;
1336     VkBool32    wideLines;
1337     VkBool32    largePoints;
1338     VkBool32    alphaToOne;
1339     VkBool32    multiViewport;
1340     VkBool32    samplerAnisotropy;
1341     VkBool32    textureCompressionETC2;
1342     VkBool32    textureCompressionASTC_LDR;
1343     VkBool32    textureCompressionBC;
1344     VkBool32    occlusionQueryPrecise;
1345     VkBool32    pipelineStatisticsQuery;
1346     VkBool32    vertexPipelineStoresAndAtomics;
1347     VkBool32    fragmentStoresAndAtomics;
1348     VkBool32    shaderTessellationAndGeometryPointSize;
1349     VkBool32    shaderImageGatherExtended;
1350     VkBool32    shaderStorageImageExtendedFormats;
1351     VkBool32    shaderStorageImageMultisample;
1352     VkBool32    shaderStorageImageReadWithoutFormat;
1353     VkBool32    shaderStorageImageWriteWithoutFormat;
1354     VkBool32    shaderUniformBufferArrayDynamicIndexing;
1355     VkBool32    shaderSampledImageArrayDynamicIndexing;
1356     VkBool32    shaderStorageBufferArrayDynamicIndexing;
1357     VkBool32    shaderStorageImageArrayDynamicIndexing;
1358     VkBool32    shaderClipDistance;
1359     VkBool32    shaderCullDistance;
1360     VkBool32    shaderFloat64;
1361     VkBool32    shaderInt64;
1362     VkBool32    shaderInt16;
1363     VkBool32    shaderResourceResidency;
1364     VkBool32    shaderResourceMinLod;
1365     VkBool32    sparseBinding;
1366     VkBool32    sparseResidencyBuffer;
1367     VkBool32    sparseResidencyImage2D;
1368     VkBool32    sparseResidencyImage3D;
1369     VkBool32    sparseResidency2Samples;
1370     VkBool32    sparseResidency4Samples;
1371     VkBool32    sparseResidency8Samples;
1372     VkBool32    sparseResidency16Samples;
1373     VkBool32    sparseResidencyAliased;
1374     VkBool32    variableMultisampleRate;
1375     VkBool32    inheritedQueries;
1376 } VkPhysicalDeviceFeatures;
1377
1378 typedef struct VkFormatProperties {
1379     VkFormatFeatureFlags    linearTilingFeatures;
1380     VkFormatFeatureFlags    optimalTilingFeatures;
1381     VkFormatFeatureFlags    bufferFeatures;
1382 } VkFormatProperties;
1383
1384 typedef struct VkExtent3D {
1385     uint32_t    width;
1386     uint32_t    height;
1387     uint32_t    depth;
1388 } VkExtent3D;
1389
1390 typedef struct VkImageFormatProperties {
1391     VkExtent3D            maxExtent;
1392     uint32_t              maxMipLevels;
1393     uint32_t              maxArrayLayers;
1394     VkSampleCountFlags    sampleCounts;
1395     VkDeviceSize          maxResourceSize;
1396 } VkImageFormatProperties;
1397
1398 typedef struct VkPhysicalDeviceLimits {
1399     uint32_t              maxImageDimension1D;
1400     uint32_t              maxImageDimension2D;
1401     uint32_t              maxImageDimension3D;
1402     uint32_t              maxImageDimensionCube;
1403     uint32_t              maxImageArrayLayers;
1404     uint32_t              maxTexelBufferElements;
1405     uint32_t              maxUniformBufferRange;
1406     uint32_t              maxStorageBufferRange;
1407     uint32_t              maxPushConstantsSize;
1408     uint32_t              maxMemoryAllocationCount;
1409     uint32_t              maxSamplerAllocationCount;
1410     VkDeviceSize          bufferImageGranularity;
1411     VkDeviceSize          sparseAddressSpaceSize;
1412     uint32_t              maxBoundDescriptorSets;
1413     uint32_t              maxPerStageDescriptorSamplers;
1414     uint32_t              maxPerStageDescriptorUniformBuffers;
1415     uint32_t              maxPerStageDescriptorStorageBuffers;
1416     uint32_t              maxPerStageDescriptorSampledImages;
1417     uint32_t              maxPerStageDescriptorStorageImages;
1418     uint32_t              maxPerStageDescriptorInputAttachments;
1419     uint32_t              maxPerStageResources;
1420     uint32_t              maxDescriptorSetSamplers;
1421     uint32_t              maxDescriptorSetUniformBuffers;
1422     uint32_t              maxDescriptorSetUniformBuffersDynamic;
1423     uint32_t              maxDescriptorSetStorageBuffers;
1424     uint32_t              maxDescriptorSetStorageBuffersDynamic;
1425     uint32_t              maxDescriptorSetSampledImages;
1426     uint32_t              maxDescriptorSetStorageImages;
1427     uint32_t              maxDescriptorSetInputAttachments;
1428     uint32_t              maxVertexInputAttributes;
1429     uint32_t              maxVertexInputBindings;
1430     uint32_t              maxVertexInputAttributeOffset;
1431     uint32_t              maxVertexInputBindingStride;
1432     uint32_t              maxVertexOutputComponents;
1433     uint32_t              maxTessellationGenerationLevel;
1434     uint32_t              maxTessellationPatchSize;
1435     uint32_t              maxTessellationControlPerVertexInputComponents;
1436     uint32_t              maxTessellationControlPerVertexOutputComponents;
1437     uint32_t              maxTessellationControlPerPatchOutputComponents;
1438     uint32_t              maxTessellationControlTotalOutputComponents;
1439     uint32_t              maxTessellationEvaluationInputComponents;
1440     uint32_t              maxTessellationEvaluationOutputComponents;
1441     uint32_t              maxGeometryShaderInvocations;
1442     uint32_t              maxGeometryInputComponents;
1443     uint32_t              maxGeometryOutputComponents;
1444     uint32_t              maxGeometryOutputVertices;
1445     uint32_t              maxGeometryTotalOutputComponents;
1446     uint32_t              maxFragmentInputComponents;
1447     uint32_t              maxFragmentOutputAttachments;
1448     uint32_t              maxFragmentDualSrcAttachments;
1449     uint32_t              maxFragmentCombinedOutputResources;
1450     uint32_t              maxComputeSharedMemorySize;
1451     uint32_t              maxComputeWorkGroupCount[3];
1452     uint32_t              maxComputeWorkGroupInvocations;
1453     uint32_t              maxComputeWorkGroupSize[3];
1454     uint32_t              subPixelPrecisionBits;
1455     uint32_t              subTexelPrecisionBits;
1456     uint32_t              mipmapPrecisionBits;
1457     uint32_t              maxDrawIndexedIndexValue;
1458     uint32_t              maxDrawIndirectCount;
1459     float                 maxSamplerLodBias;
1460     float                 maxSamplerAnisotropy;
1461     uint32_t              maxViewports;
1462     uint32_t              maxViewportDimensions[2];
1463     float                 viewportBoundsRange[2];
1464     uint32_t              viewportSubPixelBits;
1465     size_t                minMemoryMapAlignment;
1466     VkDeviceSize          minTexelBufferOffsetAlignment;
1467     VkDeviceSize          minUniformBufferOffsetAlignment;
1468     VkDeviceSize          minStorageBufferOffsetAlignment;
1469     int32_t               minTexelOffset;
1470     uint32_t              maxTexelOffset;
1471     int32_t               minTexelGatherOffset;
1472     uint32_t              maxTexelGatherOffset;
1473     float                 minInterpolationOffset;
1474     float                 maxInterpolationOffset;
1475     uint32_t              subPixelInterpolationOffsetBits;
1476     uint32_t              maxFramebufferWidth;
1477     uint32_t              maxFramebufferHeight;
1478     uint32_t              maxFramebufferLayers;
1479     VkSampleCountFlags    framebufferColorSampleCounts;
1480     VkSampleCountFlags    framebufferDepthSampleCounts;
1481     VkSampleCountFlags    framebufferStencilSampleCounts;
1482     VkSampleCountFlags    framebufferNoAttachmentsSampleCounts;
1483     uint32_t              maxColorAttachments;
1484     VkSampleCountFlags    sampledImageColorSampleCounts;
1485     VkSampleCountFlags    sampledImageIntegerSampleCounts;
1486     VkSampleCountFlags    sampledImageDepthSampleCounts;
1487     VkSampleCountFlags    sampledImageStencilSampleCounts;
1488     VkSampleCountFlags    storageImageSampleCounts;
1489     uint32_t              maxSampleMaskWords;
1490     VkBool32              timestampComputeAndGraphics;
1491     float                 timestampPeriod;
1492     uint32_t              maxClipDistances;
1493     uint32_t              maxCullDistances;
1494     uint32_t              maxCombinedClipAndCullDistances;
1495     uint32_t              discreteQueuePriorities;
1496     float                 pointSizeRange[2];
1497     float                 lineWidthRange[2];
1498     float                 pointSizeGranularity;
1499     float                 lineWidthGranularity;
1500     VkBool32              strictLines;
1501     VkBool32              standardSampleLocations;
1502     VkDeviceSize          optimalBufferCopyOffsetAlignment;
1503     VkDeviceSize          optimalBufferCopyRowPitchAlignment;
1504     VkDeviceSize          nonCoherentAtomSize;
1505 } VkPhysicalDeviceLimits;
1506
1507 typedef struct VkPhysicalDeviceSparseProperties {
1508     VkBool32    residencyStandard2DBlockShape;
1509     VkBool32    residencyStandard2DMultisampleBlockShape;
1510     VkBool32    residencyStandard3DBlockShape;
1511     VkBool32    residencyAlignedMipSize;
1512     VkBool32    residencyNonResidentStrict;
1513 } VkPhysicalDeviceSparseProperties;
1514
1515 typedef struct VkPhysicalDeviceProperties {
1516     uint32_t                            apiVersion;
1517     uint32_t                            driverVersion;
1518     uint32_t                            vendorID;
1519     uint32_t                            deviceID;
1520     VkPhysicalDeviceType                deviceType;
1521     char                                deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
1522     uint8_t                             pipelineCacheUUID[VK_UUID_SIZE];
1523     VkPhysicalDeviceLimits              limits;
1524     VkPhysicalDeviceSparseProperties    sparseProperties;
1525 } VkPhysicalDeviceProperties;
1526
1527 typedef struct VkQueueFamilyProperties {
1528     VkQueueFlags    queueFlags;
1529     uint32_t        queueCount;
1530     uint32_t        timestampValidBits;
1531     VkExtent3D      minImageTransferGranularity;
1532 } VkQueueFamilyProperties;
1533
1534 typedef struct VkMemoryType {
1535     VkMemoryPropertyFlags    propertyFlags;
1536     uint32_t                 heapIndex;
1537 } VkMemoryType;
1538
1539 typedef struct VkMemoryHeap {
1540     VkDeviceSize         size;
1541     VkMemoryHeapFlags    flags;
1542 } VkMemoryHeap;
1543
1544 typedef struct VkPhysicalDeviceMemoryProperties {
1545     uint32_t        memoryTypeCount;
1546     VkMemoryType    memoryTypes[VK_MAX_MEMORY_TYPES];
1547     uint32_t        memoryHeapCount;
1548     VkMemoryHeap    memoryHeaps[VK_MAX_MEMORY_HEAPS];
1549 } VkPhysicalDeviceMemoryProperties;
1550
1551 typedef struct VkDeviceQueueCreateInfo {
1552     VkStructureType             sType;
1553     const void*                 pNext;
1554     VkDeviceQueueCreateFlags    flags;
1555     uint32_t                    queueFamilyIndex;
1556     uint32_t                    queueCount;
1557     const float*                pQueuePriorities;
1558 } VkDeviceQueueCreateInfo;
1559
1560 typedef struct VkDeviceCreateInfo {
1561     VkStructureType                    sType;
1562     const void*                        pNext;
1563     VkDeviceCreateFlags                flags;
1564     uint32_t                           queueCreateInfoCount;
1565     const VkDeviceQueueCreateInfo*     pQueueCreateInfos;
1566     uint32_t                           enabledLayerCount;
1567     const char* const*                 ppEnabledLayerNames;
1568     uint32_t                           enabledExtensionCount;
1569     const char* const*                 ppEnabledExtensionNames;
1570     const VkPhysicalDeviceFeatures*    pEnabledFeatures;
1571 } VkDeviceCreateInfo;
1572
1573 typedef struct VkExtensionProperties {
1574     char        extensionName[VK_MAX_EXTENSION_NAME_SIZE];
1575     uint32_t    specVersion;
1576 } VkExtensionProperties;
1577
1578 typedef struct VkLayerProperties {
1579     char        layerName[VK_MAX_EXTENSION_NAME_SIZE];
1580     uint32_t    specVersion;
1581     uint32_t    implementationVersion;
1582     char        description[VK_MAX_DESCRIPTION_SIZE];
1583 } VkLayerProperties;
1584
1585 typedef struct VkSubmitInfo {
1586     VkStructureType                sType;
1587     const void*                    pNext;
1588     uint32_t                       waitSemaphoreCount;
1589     const VkSemaphore*             pWaitSemaphores;
1590     const VkPipelineStageFlags*    pWaitDstStageMask;
1591     uint32_t                       commandBufferCount;
1592     const VkCommandBuffer*         pCommandBuffers;
1593     uint32_t                       signalSemaphoreCount;
1594     const VkSemaphore*             pSignalSemaphores;
1595 } VkSubmitInfo;
1596
1597 typedef struct VkMemoryAllocateInfo {
1598     VkStructureType    sType;
1599     const void*        pNext;
1600     VkDeviceSize       allocationSize;
1601     uint32_t           memoryTypeIndex;
1602 } VkMemoryAllocateInfo;
1603
1604 typedef struct VkMappedMemoryRange {
1605     VkStructureType    sType;
1606     const void*        pNext;
1607     VkDeviceMemory     memory;
1608     VkDeviceSize       offset;
1609     VkDeviceSize       size;
1610 } VkMappedMemoryRange;
1611
1612 typedef struct VkMemoryRequirements {
1613     VkDeviceSize    size;
1614     VkDeviceSize    alignment;
1615     uint32_t        memoryTypeBits;
1616 } VkMemoryRequirements;
1617
1618 typedef struct VkSparseImageFormatProperties {
1619     VkImageAspectFlags          aspectMask;
1620     VkExtent3D                  imageGranularity;
1621     VkSparseImageFormatFlags    flags;
1622 } VkSparseImageFormatProperties;
1623
1624 typedef struct VkSparseImageMemoryRequirements {
1625     VkSparseImageFormatProperties    formatProperties;
1626     uint32_t                         imageMipTailFirstLod;
1627     VkDeviceSize                     imageMipTailSize;
1628     VkDeviceSize                     imageMipTailOffset;
1629     VkDeviceSize                     imageMipTailStride;
1630 } VkSparseImageMemoryRequirements;
1631
1632 typedef struct VkSparseMemoryBind {
1633     VkDeviceSize               resourceOffset;
1634     VkDeviceSize               size;
1635     VkDeviceMemory             memory;
1636     VkDeviceSize               memoryOffset;
1637     VkSparseMemoryBindFlags    flags;
1638 } VkSparseMemoryBind;
1639
1640 typedef struct VkSparseBufferMemoryBindInfo {
1641     VkBuffer                     buffer;
1642     uint32_t                     bindCount;
1643     const VkSparseMemoryBind*    pBinds;
1644 } VkSparseBufferMemoryBindInfo;
1645
1646 typedef struct VkSparseImageOpaqueMemoryBindInfo {
1647     VkImage                      image;
1648     uint32_t                     bindCount;
1649     const VkSparseMemoryBind*    pBinds;
1650 } VkSparseImageOpaqueMemoryBindInfo;
1651
1652 typedef struct VkImageSubresource {
1653     VkImageAspectFlags    aspectMask;
1654     uint32_t              mipLevel;
1655     uint32_t              arrayLayer;
1656 } VkImageSubresource;
1657
1658 typedef struct VkOffset3D {
1659     int32_t    x;
1660     int32_t    y;
1661     int32_t    z;
1662 } VkOffset3D;
1663
1664 typedef struct VkSparseImageMemoryBind {
1665     VkImageSubresource         subresource;
1666     VkOffset3D                 offset;
1667     VkExtent3D                 extent;
1668     VkDeviceMemory             memory;
1669     VkDeviceSize               memoryOffset;
1670     VkSparseMemoryBindFlags    flags;
1671 } VkSparseImageMemoryBind;
1672
1673 typedef struct VkSparseImageMemoryBindInfo {
1674     VkImage                           image;
1675     uint32_t                          bindCount;
1676     const VkSparseImageMemoryBind*    pBinds;
1677 } VkSparseImageMemoryBindInfo;
1678
1679 typedef struct VkBindSparseInfo {
1680     VkStructureType                             sType;
1681     const void*                                 pNext;
1682     uint32_t                                    waitSemaphoreCount;
1683     const VkSemaphore*                          pWaitSemaphores;
1684     uint32_t                                    bufferBindCount;
1685     const VkSparseBufferMemoryBindInfo*         pBufferBinds;
1686     uint32_t                                    imageOpaqueBindCount;
1687     const VkSparseImageOpaqueMemoryBindInfo*    pImageOpaqueBinds;
1688     uint32_t                                    imageBindCount;
1689     const VkSparseImageMemoryBindInfo*          pImageBinds;
1690     uint32_t                                    signalSemaphoreCount;
1691     const VkSemaphore*                          pSignalSemaphores;
1692 } VkBindSparseInfo;
1693
1694 typedef struct VkFenceCreateInfo {
1695     VkStructureType       sType;
1696     const void*           pNext;
1697     VkFenceCreateFlags    flags;
1698 } VkFenceCreateInfo;
1699
1700 typedef struct VkSemaphoreCreateInfo {
1701     VkStructureType           sType;
1702     const void*               pNext;
1703     VkSemaphoreCreateFlags    flags;
1704 } VkSemaphoreCreateInfo;
1705
1706 typedef struct VkEventCreateInfo {
1707     VkStructureType       sType;
1708     const void*           pNext;
1709     VkEventCreateFlags    flags;
1710 } VkEventCreateInfo;
1711
1712 typedef struct VkQueryPoolCreateInfo {
1713     VkStructureType                  sType;
1714     const void*                      pNext;
1715     VkQueryPoolCreateFlags           flags;
1716     VkQueryType                      queryType;
1717     uint32_t                         queryCount;
1718     VkQueryPipelineStatisticFlags    pipelineStatistics;
1719 } VkQueryPoolCreateInfo;
1720
1721 typedef struct VkBufferCreateInfo {
1722     VkStructureType        sType;
1723     const void*            pNext;
1724     VkBufferCreateFlags    flags;
1725     VkDeviceSize           size;
1726     VkBufferUsageFlags     usage;
1727     VkSharingMode          sharingMode;
1728     uint32_t               queueFamilyIndexCount;
1729     const uint32_t*        pQueueFamilyIndices;
1730 } VkBufferCreateInfo;
1731
1732 typedef struct VkBufferViewCreateInfo {
1733     VkStructureType            sType;
1734     const void*                pNext;
1735     VkBufferViewCreateFlags    flags;
1736     VkBuffer                   buffer;
1737     VkFormat                   format;
1738     VkDeviceSize               offset;
1739     VkDeviceSize               range;
1740 } VkBufferViewCreateInfo;
1741
1742 typedef struct VkImageCreateInfo {
1743     VkStructureType          sType;
1744     const void*              pNext;
1745     VkImageCreateFlags       flags;
1746     VkImageType              imageType;
1747     VkFormat                 format;
1748     VkExtent3D               extent;
1749     uint32_t                 mipLevels;
1750     uint32_t                 arrayLayers;
1751     VkSampleCountFlagBits    samples;
1752     VkImageTiling            tiling;
1753     VkImageUsageFlags        usage;
1754     VkSharingMode            sharingMode;
1755     uint32_t                 queueFamilyIndexCount;
1756     const uint32_t*          pQueueFamilyIndices;
1757     VkImageLayout            initialLayout;
1758 } VkImageCreateInfo;
1759
1760 typedef struct VkSubresourceLayout {
1761     VkDeviceSize    offset;
1762     VkDeviceSize    size;
1763     VkDeviceSize    rowPitch;
1764     VkDeviceSize    arrayPitch;
1765     VkDeviceSize    depthPitch;
1766 } VkSubresourceLayout;
1767
1768 typedef struct VkComponentMapping {
1769     VkComponentSwizzle    r;
1770     VkComponentSwizzle    g;
1771     VkComponentSwizzle    b;
1772     VkComponentSwizzle    a;
1773 } VkComponentMapping;
1774
1775 typedef struct VkImageSubresourceRange {
1776     VkImageAspectFlags    aspectMask;
1777     uint32_t              baseMipLevel;
1778     uint32_t              levelCount;
1779     uint32_t              baseArrayLayer;
1780     uint32_t              layerCount;
1781 } VkImageSubresourceRange;
1782
1783 typedef struct VkImageViewCreateInfo {
1784     VkStructureType            sType;
1785     const void*                pNext;
1786     VkImageViewCreateFlags     flags;
1787     VkImage                    image;
1788     VkImageViewType            viewType;
1789     VkFormat                   format;
1790     VkComponentMapping         components;
1791     VkImageSubresourceRange    subresourceRange;
1792 } VkImageViewCreateInfo;
1793
1794 typedef struct VkShaderModuleCreateInfo {
1795     VkStructureType              sType;
1796     const void*                  pNext;
1797     VkShaderModuleCreateFlags    flags;
1798     size_t                       codeSize;
1799     const uint32_t*              pCode;
1800 } VkShaderModuleCreateInfo;
1801
1802 typedef struct VkPipelineCacheCreateInfo {
1803     VkStructureType               sType;
1804     const void*                   pNext;
1805     VkPipelineCacheCreateFlags    flags;
1806     size_t                        initialDataSize;
1807     const void*                   pInitialData;
1808 } VkPipelineCacheCreateInfo;
1809
1810 typedef struct VkSpecializationMapEntry {
1811     uint32_t    constantID;
1812     uint32_t    offset;
1813     size_t      size;
1814 } VkSpecializationMapEntry;
1815
1816 typedef struct VkSpecializationInfo {
1817     uint32_t                           mapEntryCount;
1818     const VkSpecializationMapEntry*    pMapEntries;
1819     size_t                             dataSize;
1820     const void*                        pData;
1821 } VkSpecializationInfo;
1822
1823 typedef struct VkPipelineShaderStageCreateInfo {
1824     VkStructureType                     sType;
1825     const void*                         pNext;
1826     VkPipelineShaderStageCreateFlags    flags;
1827     VkShaderStageFlagBits               stage;
1828     VkShaderModule                      module;
1829     const char*                         pName;
1830     const VkSpecializationInfo*         pSpecializationInfo;
1831 } VkPipelineShaderStageCreateInfo;
1832
1833 typedef struct VkVertexInputBindingDescription {
1834     uint32_t             binding;
1835     uint32_t             stride;
1836     VkVertexInputRate    inputRate;
1837 } VkVertexInputBindingDescription;
1838
1839 typedef struct VkVertexInputAttributeDescription {
1840     uint32_t    location;
1841     uint32_t    binding;
1842     VkFormat    format;
1843     uint32_t    offset;
1844 } VkVertexInputAttributeDescription;
1845
1846 typedef struct VkPipelineVertexInputStateCreateInfo {
1847     VkStructureType                             sType;
1848     const void*                                 pNext;
1849     VkPipelineVertexInputStateCreateFlags       flags;
1850     uint32_t                                    vertexBindingDescriptionCount;
1851     const VkVertexInputBindingDescription*      pVertexBindingDescriptions;
1852     uint32_t                                    vertexAttributeDescriptionCount;
1853     const VkVertexInputAttributeDescription*    pVertexAttributeDescriptions;
1854 } VkPipelineVertexInputStateCreateInfo;
1855
1856 typedef struct VkPipelineInputAssemblyStateCreateInfo {
1857     VkStructureType                            sType;
1858     const void*                                pNext;
1859     VkPipelineInputAssemblyStateCreateFlags    flags;
1860     VkPrimitiveTopology                        topology;
1861     VkBool32                                   primitiveRestartEnable;
1862 } VkPipelineInputAssemblyStateCreateInfo;
1863
1864 typedef struct VkPipelineTessellationStateCreateInfo {
1865     VkStructureType                           sType;
1866     const void*                               pNext;
1867     VkPipelineTessellationStateCreateFlags    flags;
1868     uint32_t                                  patchControlPoints;
1869 } VkPipelineTessellationStateCreateInfo;
1870
1871 typedef struct VkViewport {
1872     float    x;
1873     float    y;
1874     float    width;
1875     float    height;
1876     float    minDepth;
1877     float    maxDepth;
1878 } VkViewport;
1879
1880 typedef struct VkOffset2D {
1881     int32_t    x;
1882     int32_t    y;
1883 } VkOffset2D;
1884
1885 typedef struct VkExtent2D {
1886     uint32_t    width;
1887     uint32_t    height;
1888 } VkExtent2D;
1889
1890 typedef struct VkRect2D {
1891     VkOffset2D    offset;
1892     VkExtent2D    extent;
1893 } VkRect2D;
1894
1895 typedef struct VkPipelineViewportStateCreateInfo {
1896     VkStructureType                       sType;
1897     const void*                           pNext;
1898     VkPipelineViewportStateCreateFlags    flags;
1899     uint32_t                              viewportCount;
1900     const VkViewport*                     pViewports;
1901     uint32_t                              scissorCount;
1902     const VkRect2D*                       pScissors;
1903 } VkPipelineViewportStateCreateInfo;
1904
1905 typedef struct VkPipelineRasterizationStateCreateInfo {
1906     VkStructureType                            sType;
1907     const void*                                pNext;
1908     VkPipelineRasterizationStateCreateFlags    flags;
1909     VkBool32                                   depthClampEnable;
1910     VkBool32                                   rasterizerDiscardEnable;
1911     VkPolygonMode                              polygonMode;
1912     VkCullModeFlags                            cullMode;
1913     VkFrontFace                                frontFace;
1914     VkBool32                                   depthBiasEnable;
1915     float                                      depthBiasConstantFactor;
1916     float                                      depthBiasClamp;
1917     float                                      depthBiasSlopeFactor;
1918     float                                      lineWidth;
1919 } VkPipelineRasterizationStateCreateInfo;
1920
1921 typedef struct VkPipelineMultisampleStateCreateInfo {
1922     VkStructureType                          sType;
1923     const void*                              pNext;
1924     VkPipelineMultisampleStateCreateFlags    flags;
1925     VkSampleCountFlagBits                    rasterizationSamples;
1926     VkBool32                                 sampleShadingEnable;
1927     float                                    minSampleShading;
1928     const VkSampleMask*                      pSampleMask;
1929     VkBool32                                 alphaToCoverageEnable;
1930     VkBool32                                 alphaToOneEnable;
1931 } VkPipelineMultisampleStateCreateInfo;
1932
1933 typedef struct VkStencilOpState {
1934     VkStencilOp    failOp;
1935     VkStencilOp    passOp;
1936     VkStencilOp    depthFailOp;
1937     VkCompareOp    compareOp;
1938     uint32_t       compareMask;
1939     uint32_t       writeMask;
1940     uint32_t       reference;
1941 } VkStencilOpState;
1942
1943 typedef struct VkPipelineDepthStencilStateCreateInfo {
1944     VkStructureType                           sType;
1945     const void*                               pNext;
1946     VkPipelineDepthStencilStateCreateFlags    flags;
1947     VkBool32                                  depthTestEnable;
1948     VkBool32                                  depthWriteEnable;
1949     VkCompareOp                               depthCompareOp;
1950     VkBool32                                  depthBoundsTestEnable;
1951     VkBool32                                  stencilTestEnable;
1952     VkStencilOpState                          front;
1953     VkStencilOpState                          back;
1954     float                                     minDepthBounds;
1955     float                                     maxDepthBounds;
1956 } VkPipelineDepthStencilStateCreateInfo;
1957
1958 typedef struct VkPipelineColorBlendAttachmentState {
1959     VkBool32                 blendEnable;
1960     VkBlendFactor            srcColorBlendFactor;
1961     VkBlendFactor            dstColorBlendFactor;
1962     VkBlendOp                colorBlendOp;
1963     VkBlendFactor            srcAlphaBlendFactor;
1964     VkBlendFactor            dstAlphaBlendFactor;
1965     VkBlendOp                alphaBlendOp;
1966     VkColorComponentFlags    colorWriteMask;
1967 } VkPipelineColorBlendAttachmentState;
1968
1969 typedef struct VkPipelineColorBlendStateCreateInfo {
1970     VkStructureType                               sType;
1971     const void*                                   pNext;
1972     VkPipelineColorBlendStateCreateFlags          flags;
1973     VkBool32                                      logicOpEnable;
1974     VkLogicOp                                     logicOp;
1975     uint32_t                                      attachmentCount;
1976     const VkPipelineColorBlendAttachmentState*    pAttachments;
1977     float                                         blendConstants[4];
1978 } VkPipelineColorBlendStateCreateInfo;
1979
1980 typedef struct VkPipelineDynamicStateCreateInfo {
1981     VkStructureType                      sType;
1982     const void*                          pNext;
1983     VkPipelineDynamicStateCreateFlags    flags;
1984     uint32_t                             dynamicStateCount;
1985     const VkDynamicState*                pDynamicStates;
1986 } VkPipelineDynamicStateCreateInfo;
1987
1988 typedef struct VkGraphicsPipelineCreateInfo {
1989     VkStructureType                                  sType;
1990     const void*                                      pNext;
1991     VkPipelineCreateFlags                            flags;
1992     uint32_t                                         stageCount;
1993     const VkPipelineShaderStageCreateInfo*           pStages;
1994     const VkPipelineVertexInputStateCreateInfo*      pVertexInputState;
1995     const VkPipelineInputAssemblyStateCreateInfo*    pInputAssemblyState;
1996     const VkPipelineTessellationStateCreateInfo*     pTessellationState;
1997     const VkPipelineViewportStateCreateInfo*         pViewportState;
1998     const VkPipelineRasterizationStateCreateInfo*    pRasterizationState;
1999     const VkPipelineMultisampleStateCreateInfo*      pMultisampleState;
2000     const VkPipelineDepthStencilStateCreateInfo*     pDepthStencilState;
2001     const VkPipelineColorBlendStateCreateInfo*       pColorBlendState;
2002     const VkPipelineDynamicStateCreateInfo*          pDynamicState;
2003     VkPipelineLayout                                 layout;
2004     VkRenderPass                                     renderPass;
2005     uint32_t                                         subpass;
2006     VkPipeline                                       basePipelineHandle;
2007     int32_t                                          basePipelineIndex;
2008 } VkGraphicsPipelineCreateInfo;
2009
2010 typedef struct VkComputePipelineCreateInfo {
2011     VkStructureType                    sType;
2012     const void*                        pNext;
2013     VkPipelineCreateFlags              flags;
2014     VkPipelineShaderStageCreateInfo    stage;
2015     VkPipelineLayout                   layout;
2016     VkPipeline                         basePipelineHandle;
2017     int32_t                            basePipelineIndex;
2018 } VkComputePipelineCreateInfo;
2019
2020 typedef struct VkPushConstantRange {
2021     VkShaderStageFlags    stageFlags;
2022     uint32_t              offset;
2023     uint32_t              size;
2024 } VkPushConstantRange;
2025
2026 typedef struct VkPipelineLayoutCreateInfo {
2027     VkStructureType                 sType;
2028     const void*                     pNext;
2029     VkPipelineLayoutCreateFlags     flags;
2030     uint32_t                        setLayoutCount;
2031     const VkDescriptorSetLayout*    pSetLayouts;
2032     uint32_t                        pushConstantRangeCount;
2033     const VkPushConstantRange*      pPushConstantRanges;
2034 } VkPipelineLayoutCreateInfo;
2035
2036 typedef struct VkSamplerCreateInfo {
2037     VkStructureType         sType;
2038     const void*             pNext;
2039     VkSamplerCreateFlags    flags;
2040     VkFilter                magFilter;
2041     VkFilter                minFilter;
2042     VkSamplerMipmapMode     mipmapMode;
2043     VkSamplerAddressMode    addressModeU;
2044     VkSamplerAddressMode    addressModeV;
2045     VkSamplerAddressMode    addressModeW;
2046     float                   mipLodBias;
2047     VkBool32                anisotropyEnable;
2048     float                   maxAnisotropy;
2049     VkBool32                compareEnable;
2050     VkCompareOp             compareOp;
2051     float                   minLod;
2052     float                   maxLod;
2053     VkBorderColor           borderColor;
2054     VkBool32                unnormalizedCoordinates;
2055 } VkSamplerCreateInfo;
2056
2057 typedef struct VkDescriptorSetLayoutBinding {
2058     uint32_t              binding;
2059     VkDescriptorType      descriptorType;
2060     uint32_t              descriptorCount;
2061     VkShaderStageFlags    stageFlags;
2062     const VkSampler*      pImmutableSamplers;
2063 } VkDescriptorSetLayoutBinding;
2064
2065 typedef struct VkDescriptorSetLayoutCreateInfo {
2066     VkStructureType                        sType;
2067     const void*                            pNext;
2068     VkDescriptorSetLayoutCreateFlags       flags;
2069     uint32_t                               bindingCount;
2070     const VkDescriptorSetLayoutBinding*    pBindings;
2071 } VkDescriptorSetLayoutCreateInfo;
2072
2073 typedef struct VkDescriptorPoolSize {
2074     VkDescriptorType    type;
2075     uint32_t            descriptorCount;
2076 } VkDescriptorPoolSize;
2077
2078 typedef struct VkDescriptorPoolCreateInfo {
2079     VkStructureType                sType;
2080     const void*                    pNext;
2081     VkDescriptorPoolCreateFlags    flags;
2082     uint32_t                       maxSets;
2083     uint32_t                       poolSizeCount;
2084     const VkDescriptorPoolSize*    pPoolSizes;
2085 } VkDescriptorPoolCreateInfo;
2086
2087 typedef struct VkDescriptorSetAllocateInfo {
2088     VkStructureType                 sType;
2089     const void*                     pNext;
2090     VkDescriptorPool                descriptorPool;
2091     uint32_t                        descriptorSetCount;
2092     const VkDescriptorSetLayout*    pSetLayouts;
2093 } VkDescriptorSetAllocateInfo;
2094
2095 typedef struct VkDescriptorImageInfo {
2096     VkSampler        sampler;
2097     VkImageView      imageView;
2098     VkImageLayout    imageLayout;
2099 } VkDescriptorImageInfo;
2100
2101 typedef struct VkDescriptorBufferInfo {
2102     VkBuffer        buffer;
2103     VkDeviceSize    offset;
2104     VkDeviceSize    range;
2105 } VkDescriptorBufferInfo;
2106
2107 typedef struct VkWriteDescriptorSet {
2108     VkStructureType                  sType;
2109     const void*                      pNext;
2110     VkDescriptorSet                  dstSet;
2111     uint32_t                         dstBinding;
2112     uint32_t                         dstArrayElement;
2113     uint32_t                         descriptorCount;
2114     VkDescriptorType                 descriptorType;
2115     const VkDescriptorImageInfo*     pImageInfo;
2116     const VkDescriptorBufferInfo*    pBufferInfo;
2117     const VkBufferView*              pTexelBufferView;
2118 } VkWriteDescriptorSet;
2119
2120 typedef struct VkCopyDescriptorSet {
2121     VkStructureType    sType;
2122     const void*        pNext;
2123     VkDescriptorSet    srcSet;
2124     uint32_t           srcBinding;
2125     uint32_t           srcArrayElement;
2126     VkDescriptorSet    dstSet;
2127     uint32_t           dstBinding;
2128     uint32_t           dstArrayElement;
2129     uint32_t           descriptorCount;
2130 } VkCopyDescriptorSet;
2131
2132 typedef struct VkFramebufferCreateInfo {
2133     VkStructureType             sType;
2134     const void*                 pNext;
2135     VkFramebufferCreateFlags    flags;
2136     VkRenderPass                renderPass;
2137     uint32_t                    attachmentCount;
2138     const VkImageView*          pAttachments;
2139     uint32_t                    width;
2140     uint32_t                    height;
2141     uint32_t                    layers;
2142 } VkFramebufferCreateInfo;
2143
2144 typedef struct VkAttachmentDescription {
2145     VkAttachmentDescriptionFlags    flags;
2146     VkFormat                        format;
2147     VkSampleCountFlagBits           samples;
2148     VkAttachmentLoadOp              loadOp;
2149     VkAttachmentStoreOp             storeOp;
2150     VkAttachmentLoadOp              stencilLoadOp;
2151     VkAttachmentStoreOp             stencilStoreOp;
2152     VkImageLayout                   initialLayout;
2153     VkImageLayout                   finalLayout;
2154 } VkAttachmentDescription;
2155
2156 typedef struct VkAttachmentReference {
2157     uint32_t         attachment;
2158     VkImageLayout    layout;
2159 } VkAttachmentReference;
2160
2161 typedef struct VkSubpassDescription {
2162     VkSubpassDescriptionFlags       flags;
2163     VkPipelineBindPoint             pipelineBindPoint;
2164     uint32_t                        inputAttachmentCount;
2165     const VkAttachmentReference*    pInputAttachments;
2166     uint32_t                        colorAttachmentCount;
2167     const VkAttachmentReference*    pColorAttachments;
2168     const VkAttachmentReference*    pResolveAttachments;
2169     const VkAttachmentReference*    pDepthStencilAttachment;
2170     uint32_t                        preserveAttachmentCount;
2171     const uint32_t*                 pPreserveAttachments;
2172 } VkSubpassDescription;
2173
2174 typedef struct VkSubpassDependency {
2175     uint32_t                srcSubpass;
2176     uint32_t                dstSubpass;
2177     VkPipelineStageFlags    srcStageMask;
2178     VkPipelineStageFlags    dstStageMask;
2179     VkAccessFlags           srcAccessMask;
2180     VkAccessFlags           dstAccessMask;
2181     VkDependencyFlags       dependencyFlags;
2182 } VkSubpassDependency;
2183
2184 typedef struct VkRenderPassCreateInfo {
2185     VkStructureType                   sType;
2186     const void*                       pNext;
2187     VkRenderPassCreateFlags           flags;
2188     uint32_t                          attachmentCount;
2189     const VkAttachmentDescription*    pAttachments;
2190     uint32_t                          subpassCount;
2191     const VkSubpassDescription*       pSubpasses;
2192     uint32_t                          dependencyCount;
2193     const VkSubpassDependency*        pDependencies;
2194 } VkRenderPassCreateInfo;
2195
2196 typedef struct VkCommandPoolCreateInfo {
2197     VkStructureType             sType;
2198     const void*                 pNext;
2199     VkCommandPoolCreateFlags    flags;
2200     uint32_t                    queueFamilyIndex;
2201 } VkCommandPoolCreateInfo;
2202
2203 typedef struct VkCommandBufferAllocateInfo {
2204     VkStructureType         sType;
2205     const void*             pNext;
2206     VkCommandPool           commandPool;
2207     VkCommandBufferLevel    level;
2208     uint32_t                commandBufferCount;
2209 } VkCommandBufferAllocateInfo;
2210
2211 typedef struct VkCommandBufferInheritanceInfo {
2212     VkStructureType                  sType;
2213     const void*                      pNext;
2214     VkRenderPass                     renderPass;
2215     uint32_t                         subpass;
2216     VkFramebuffer                    framebuffer;
2217     VkBool32                         occlusionQueryEnable;
2218     VkQueryControlFlags              queryFlags;
2219     VkQueryPipelineStatisticFlags    pipelineStatistics;
2220 } VkCommandBufferInheritanceInfo;
2221
2222 typedef struct VkCommandBufferBeginInfo {
2223     VkStructureType                          sType;
2224     const void*                              pNext;
2225     VkCommandBufferUsageFlags                flags;
2226     const VkCommandBufferInheritanceInfo*    pInheritanceInfo;
2227 } VkCommandBufferBeginInfo;
2228
2229 typedef struct VkBufferCopy {
2230     VkDeviceSize    srcOffset;
2231     VkDeviceSize    dstOffset;
2232     VkDeviceSize    size;
2233 } VkBufferCopy;
2234
2235 typedef struct VkImageSubresourceLayers {
2236     VkImageAspectFlags    aspectMask;
2237     uint32_t              mipLevel;
2238     uint32_t              baseArrayLayer;
2239     uint32_t              layerCount;
2240 } VkImageSubresourceLayers;
2241
2242 typedef struct VkImageCopy {
2243     VkImageSubresourceLayers    srcSubresource;
2244     VkOffset3D                  srcOffset;
2245     VkImageSubresourceLayers    dstSubresource;
2246     VkOffset3D                  dstOffset;
2247     VkExtent3D                  extent;
2248 } VkImageCopy;
2249
2250 typedef struct VkImageBlit {
2251     VkImageSubresourceLayers    srcSubresource;
2252     VkOffset3D                  srcOffsets[2];
2253     VkImageSubresourceLayers    dstSubresource;
2254     VkOffset3D                  dstOffsets[2];
2255 } VkImageBlit;
2256
2257 typedef struct VkBufferImageCopy {
2258     VkDeviceSize                bufferOffset;
2259     uint32_t                    bufferRowLength;
2260     uint32_t                    bufferImageHeight;
2261     VkImageSubresourceLayers    imageSubresource;
2262     VkOffset3D                  imageOffset;
2263     VkExtent3D                  imageExtent;
2264 } VkBufferImageCopy;
2265
2266 typedef union VkClearColorValue {
2267     float       float32[4];
2268     int32_t     int32[4];
2269     uint32_t    uint32[4];
2270 } VkClearColorValue;
2271
2272 typedef struct VkClearDepthStencilValue {
2273     float       depth;
2274     uint32_t    stencil;
2275 } VkClearDepthStencilValue;
2276
2277 typedef union VkClearValue {
2278     VkClearColorValue           color;
2279     VkClearDepthStencilValue    depthStencil;
2280 } VkClearValue;
2281
2282 typedef struct VkClearAttachment {
2283     VkImageAspectFlags    aspectMask;
2284     uint32_t              colorAttachment;
2285     VkClearValue          clearValue;
2286 } VkClearAttachment;
2287
2288 typedef struct VkClearRect {
2289     VkRect2D    rect;
2290     uint32_t    baseArrayLayer;
2291     uint32_t    layerCount;
2292 } VkClearRect;
2293
2294 typedef struct VkImageResolve {
2295     VkImageSubresourceLayers    srcSubresource;
2296     VkOffset3D                  srcOffset;
2297     VkImageSubresourceLayers    dstSubresource;
2298     VkOffset3D                  dstOffset;
2299     VkExtent3D                  extent;
2300 } VkImageResolve;
2301
2302 typedef struct VkMemoryBarrier {
2303     VkStructureType    sType;
2304     const void*        pNext;
2305     VkAccessFlags      srcAccessMask;
2306     VkAccessFlags      dstAccessMask;
2307 } VkMemoryBarrier;
2308
2309 typedef struct VkBufferMemoryBarrier {
2310     VkStructureType    sType;
2311     const void*        pNext;
2312     VkAccessFlags      srcAccessMask;
2313     VkAccessFlags      dstAccessMask;
2314     uint32_t           srcQueueFamilyIndex;
2315     uint32_t           dstQueueFamilyIndex;
2316     VkBuffer           buffer;
2317     VkDeviceSize       offset;
2318     VkDeviceSize       size;
2319 } VkBufferMemoryBarrier;
2320
2321 typedef struct VkImageMemoryBarrier {
2322     VkStructureType            sType;
2323     const void*                pNext;
2324     VkAccessFlags              srcAccessMask;
2325     VkAccessFlags              dstAccessMask;
2326     VkImageLayout              oldLayout;
2327     VkImageLayout              newLayout;
2328     uint32_t                   srcQueueFamilyIndex;
2329     uint32_t                   dstQueueFamilyIndex;
2330     VkImage                    image;
2331     VkImageSubresourceRange    subresourceRange;
2332 } VkImageMemoryBarrier;
2333
2334 typedef struct VkRenderPassBeginInfo {
2335     VkStructureType        sType;
2336     const void*            pNext;
2337     VkRenderPass           renderPass;
2338     VkFramebuffer          framebuffer;
2339     VkRect2D               renderArea;
2340     uint32_t               clearValueCount;
2341     const VkClearValue*    pClearValues;
2342 } VkRenderPassBeginInfo;
2343
2344 typedef struct VkDispatchIndirectCommand {
2345     uint32_t    x;
2346     uint32_t    y;
2347     uint32_t    z;
2348 } VkDispatchIndirectCommand;
2349
2350 typedef struct VkDrawIndexedIndirectCommand {
2351     uint32_t    indexCount;
2352     uint32_t    instanceCount;
2353     uint32_t    firstIndex;
2354     int32_t     vertexOffset;
2355     uint32_t    firstInstance;
2356 } VkDrawIndexedIndirectCommand;
2357
2358 typedef struct VkDrawIndirectCommand {
2359     uint32_t    vertexCount;
2360     uint32_t    instanceCount;
2361     uint32_t    firstVertex;
2362     uint32_t    firstInstance;
2363 } VkDrawIndirectCommand;
2364
2365
2366 typedef VkResult (VKAPI_PTR *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance);
2367 typedef void (VKAPI_PTR *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks* pAllocator);
2368 typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
2369 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
2370 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
2371 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
2372 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
2373 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties);
2374 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
2375 typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName);
2376 typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName);
2377 typedef VkResult (VKAPI_PTR *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice);
2378 typedef void (VKAPI_PTR *PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks* pAllocator);
2379 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
2380 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
2381 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties);
2382 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties);
2383 typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
2384 typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence);
2385 typedef VkResult (VKAPI_PTR *PFN_vkQueueWaitIdle)(VkQueue queue);
2386 typedef VkResult (VKAPI_PTR *PFN_vkDeviceWaitIdle)(VkDevice device);
2387 typedef VkResult (VKAPI_PTR *PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory);
2388 typedef void (VKAPI_PTR *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator);
2389 typedef VkResult (VKAPI_PTR *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);
2390 typedef void (VKAPI_PTR *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory);
2391 typedef VkResult (VKAPI_PTR *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
2392 typedef VkResult (VKAPI_PTR *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
2393 typedef void (VKAPI_PTR *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);
2394 typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset);
2395 typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset);
2396 typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
2397 typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
2398 typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
2399 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties);
2400 typedef VkResult (VKAPI_PTR *PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence);
2401 typedef VkResult (VKAPI_PTR *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
2402 typedef void (VKAPI_PTR *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator);
2403 typedef VkResult (VKAPI_PTR *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences);
2404 typedef VkResult (VKAPI_PTR *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence);
2405 typedef VkResult (VKAPI_PTR *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout);
2406 typedef VkResult (VKAPI_PTR *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore);
2407 typedef void (VKAPI_PTR *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator);
2408 typedef VkResult (VKAPI_PTR *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent);
2409 typedef void (VKAPI_PTR *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator);
2410 typedef VkResult (VKAPI_PTR *PFN_vkGetEventStatus)(VkDevice device, VkEvent event);
2411 typedef VkResult (VKAPI_PTR *PFN_vkSetEvent)(VkDevice device, VkEvent event);
2412 typedef VkResult (VKAPI_PTR *PFN_vkResetEvent)(VkDevice device, VkEvent event);
2413 typedef VkResult (VKAPI_PTR *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool);
2414 typedef void (VKAPI_PTR *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator);
2415 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);
2416 typedef VkResult (VKAPI_PTR *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer);
2417 typedef void (VKAPI_PTR *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator);
2418 typedef VkResult (VKAPI_PTR *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView);
2419 typedef void (VKAPI_PTR *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator);
2420 typedef VkResult (VKAPI_PTR *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage);
2421 typedef void (VKAPI_PTR *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator);
2422 typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
2423 typedef VkResult (VKAPI_PTR *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView);
2424 typedef void (VKAPI_PTR *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator);
2425 typedef VkResult (VKAPI_PTR *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule);
2426 typedef void (VKAPI_PTR *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator);
2427 typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache);
2428 typedef void (VKAPI_PTR *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator);
2429 typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData);
2430 typedef VkResult (VKAPI_PTR *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
2431 typedef VkResult (VKAPI_PTR *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
2432 typedef VkResult (VKAPI_PTR *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
2433 typedef void (VKAPI_PTR *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator);
2434 typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout);
2435 typedef void (VKAPI_PTR *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator);
2436 typedef VkResult (VKAPI_PTR *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler);
2437 typedef void (VKAPI_PTR *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator);
2438 typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout);
2439 typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator);
2440 typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool);
2441 typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator);
2442 typedef VkResult (VKAPI_PTR *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);
2443 typedef VkResult (VKAPI_PTR *PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets);
2444 typedef VkResult (VKAPI_PTR *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets);
2445 typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies);
2446 typedef VkResult (VKAPI_PTR *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer);
2447 typedef void (VKAPI_PTR *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator);
2448 typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);
2449 typedef void (VKAPI_PTR *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator);
2450 typedef void (VKAPI_PTR *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
2451 typedef VkResult (VKAPI_PTR *PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool);
2452 typedef void (VKAPI_PTR *PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator);
2453 typedef VkResult (VKAPI_PTR *PFN_vkResetCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags);
2454 typedef VkResult (VKAPI_PTR *PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers);
2455 typedef void (VKAPI_PTR *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
2456 typedef VkResult (VKAPI_PTR *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo);
2457 typedef VkResult (VKAPI_PTR *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer);
2458 typedef VkResult (VKAPI_PTR *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags);
2459 typedef void (VKAPI_PTR *PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
2460 typedef void (VKAPI_PTR *PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports);
2461 typedef void (VKAPI_PTR *PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors);
2462 typedef void (VKAPI_PTR *PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth);
2463 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor);
2464 typedef void (VKAPI_PTR *PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4]);
2465 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds);
2466 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask);
2467 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask);
2468 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference);
2469 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);
2470 typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
2471 typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
2472 typedef void (VKAPI_PTR *PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
2473 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
2474 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
2475 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
2476 typedef void (VKAPI_PTR *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);
2477 typedef void (VKAPI_PTR *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset);
2478 typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions);
2479 typedef void (VKAPI_PTR *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions);
2480 typedef void (VKAPI_PTR *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter);
2481 typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);
2482 typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);
2483 typedef void (VKAPI_PTR *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData);
2484 typedef void (VKAPI_PTR *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data);
2485 typedef void (VKAPI_PTR *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
2486 typedef void (VKAPI_PTR *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
2487 typedef void (VKAPI_PTR *PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects);
2488 typedef void (VKAPI_PTR *PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
2489 typedef void (VKAPI_PTR *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
2490 typedef void (VKAPI_PTR *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
2491 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);
2492 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);
2493 typedef void (VKAPI_PTR *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags);
2494 typedef void (VKAPI_PTR *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query);
2495 typedef void (VKAPI_PTR *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);
2496 typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query);
2497 typedef void (VKAPI_PTR *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags);
2498 typedef void (VKAPI_PTR *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues);
2499 typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents);
2500 typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkSubpassContents contents);
2501 typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer);
2502 typedef void (VKAPI_PTR *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
2503
2504 #ifndef VK_NO_PROTOTYPES
2505 VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(
2506     const VkInstanceCreateInfo*                 pCreateInfo,
2507     const VkAllocationCallbacks*                pAllocator,
2508     VkInstance*                                 pInstance);
2509
2510 VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(
2511     VkInstance                                  instance,
2512     const VkAllocationCallbacks*                pAllocator);
2513
2514 VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices(
2515     VkInstance                                  instance,
2516     uint32_t*                                   pPhysicalDeviceCount,
2517     VkPhysicalDevice*                           pPhysicalDevices);
2518
2519 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures(
2520     VkPhysicalDevice                            physicalDevice,
2521     VkPhysicalDeviceFeatures*                   pFeatures);
2522
2523 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties(
2524     VkPhysicalDevice                            physicalDevice,
2525     VkFormat                                    format,
2526     VkFormatProperties*                         pFormatProperties);
2527
2528 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties(
2529     VkPhysicalDevice                            physicalDevice,
2530     VkFormat                                    format,
2531     VkImageType                                 type,
2532     VkImageTiling                               tiling,
2533     VkImageUsageFlags                           usage,
2534     VkImageCreateFlags                          flags,
2535     VkImageFormatProperties*                    pImageFormatProperties);
2536
2537 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties(
2538     VkPhysicalDevice                            physicalDevice,
2539     VkPhysicalDeviceProperties*                 pProperties);
2540
2541 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties(
2542     VkPhysicalDevice                            physicalDevice,
2543     uint32_t*                                   pQueueFamilyPropertyCount,
2544     VkQueueFamilyProperties*                    pQueueFamilyProperties);
2545
2546 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties(
2547     VkPhysicalDevice                            physicalDevice,
2548     VkPhysicalDeviceMemoryProperties*           pMemoryProperties);
2549
2550 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(
2551     VkInstance                                  instance,
2552     const char*                                 pName);
2553
2554 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(
2555     VkDevice                                    device,
2556     const char*                                 pName);
2557
2558 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(
2559     VkPhysicalDevice                            physicalDevice,
2560     const VkDeviceCreateInfo*                   pCreateInfo,
2561     const VkAllocationCallbacks*                pAllocator,
2562     VkDevice*                                   pDevice);
2563
2564 VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(
2565     VkDevice                                    device,
2566     const VkAllocationCallbacks*                pAllocator);
2567
2568 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(
2569     const char*                                 pLayerName,
2570     uint32_t*                                   pPropertyCount,
2571     VkExtensionProperties*                      pProperties);
2572
2573 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(
2574     VkPhysicalDevice                            physicalDevice,
2575     const char*                                 pLayerName,
2576     uint32_t*                                   pPropertyCount,
2577     VkExtensionProperties*                      pProperties);
2578
2579 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(
2580     uint32_t*                                   pPropertyCount,
2581     VkLayerProperties*                          pProperties);
2582
2583 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(
2584     VkPhysicalDevice                            physicalDevice,
2585     uint32_t*                                   pPropertyCount,
2586     VkLayerProperties*                          pProperties);
2587
2588 VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue(
2589     VkDevice                                    device,
2590     uint32_t                                    queueFamilyIndex,
2591     uint32_t                                    queueIndex,
2592     VkQueue*                                    pQueue);
2593
2594 VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit(
2595     VkQueue                                     queue,
2596     uint32_t                                    submitCount,
2597     const VkSubmitInfo*                         pSubmits,
2598     VkFence                                     fence);
2599
2600 VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle(
2601     VkQueue                                     queue);
2602
2603 VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle(
2604     VkDevice                                    device);
2605
2606 VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory(
2607     VkDevice                                    device,
2608     const VkMemoryAllocateInfo*                 pAllocateInfo,
2609     const VkAllocationCallbacks*                pAllocator,
2610     VkDeviceMemory*                             pMemory);
2611
2612 VKAPI_ATTR void VKAPI_CALL vkFreeMemory(
2613     VkDevice                                    device,
2614     VkDeviceMemory                              memory,
2615     const VkAllocationCallbacks*                pAllocator);
2616
2617 VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory(
2618     VkDevice                                    device,
2619     VkDeviceMemory                              memory,
2620     VkDeviceSize                                offset,
2621     VkDeviceSize                                size,
2622     VkMemoryMapFlags                            flags,
2623     void**                                      ppData);
2624
2625 VKAPI_ATTR void VKAPI_CALL vkUnmapMemory(
2626     VkDevice                                    device,
2627     VkDeviceMemory                              memory);
2628
2629 VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges(
2630     VkDevice                                    device,
2631     uint32_t                                    memoryRangeCount,
2632     const VkMappedMemoryRange*                  pMemoryRanges);
2633
2634 VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges(
2635     VkDevice                                    device,
2636     uint32_t                                    memoryRangeCount,
2637     const VkMappedMemoryRange*                  pMemoryRanges);
2638
2639 VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment(
2640     VkDevice                                    device,
2641     VkDeviceMemory                              memory,
2642     VkDeviceSize*                               pCommittedMemoryInBytes);
2643
2644 VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory(
2645     VkDevice                                    device,
2646     VkBuffer                                    buffer,
2647     VkDeviceMemory                              memory,
2648     VkDeviceSize                                memoryOffset);
2649
2650 VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory(
2651     VkDevice                                    device,
2652     VkImage                                     image,
2653     VkDeviceMemory                              memory,
2654     VkDeviceSize                                memoryOffset);
2655
2656 VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements(
2657     VkDevice                                    device,
2658     VkBuffer                                    buffer,
2659     VkMemoryRequirements*                       pMemoryRequirements);
2660
2661 VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements(
2662     VkDevice                                    device,
2663     VkImage                                     image,
2664     VkMemoryRequirements*                       pMemoryRequirements);
2665
2666 VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements(
2667     VkDevice                                    device,
2668     VkImage                                     image,
2669     uint32_t*                                   pSparseMemoryRequirementCount,
2670     VkSparseImageMemoryRequirements*            pSparseMemoryRequirements);
2671
2672 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties(
2673     VkPhysicalDevice                            physicalDevice,
2674     VkFormat                                    format,
2675     VkImageType                                 type,
2676     VkSampleCountFlagBits                       samples,
2677     VkImageUsageFlags                           usage,
2678     VkImageTiling                               tiling,
2679     uint32_t*                                   pPropertyCount,
2680     VkSparseImageFormatProperties*              pProperties);
2681
2682 VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse(
2683     VkQueue                                     queue,
2684     uint32_t                                    bindInfoCount,
2685     const VkBindSparseInfo*                     pBindInfo,
2686     VkFence                                     fence);
2687
2688 VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence(
2689     VkDevice                                    device,
2690     const VkFenceCreateInfo*                    pCreateInfo,
2691     const VkAllocationCallbacks*                pAllocator,
2692     VkFence*                                    pFence);
2693
2694 VKAPI_ATTR void VKAPI_CALL vkDestroyFence(
2695     VkDevice                                    device,
2696     VkFence                                     fence,
2697     const VkAllocationCallbacks*                pAllocator);
2698
2699 VKAPI_ATTR VkResult VKAPI_CALL vkResetFences(
2700     VkDevice                                    device,
2701     uint32_t                                    fenceCount,
2702     const VkFence*                              pFences);
2703
2704 VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus(
2705     VkDevice                                    device,
2706     VkFence                                     fence);
2707
2708 VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences(
2709     VkDevice                                    device,
2710     uint32_t                                    fenceCount,
2711     const VkFence*                              pFences,
2712     VkBool32                                    waitAll,
2713     uint64_t                                    timeout);
2714
2715 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore(
2716     VkDevice                                    device,
2717     const VkSemaphoreCreateInfo*                pCreateInfo,
2718     const VkAllocationCallbacks*                pAllocator,
2719     VkSemaphore*                                pSemaphore);
2720
2721 VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore(
2722     VkDevice                                    device,
2723     VkSemaphore                                 semaphore,
2724     const VkAllocationCallbacks*                pAllocator);
2725
2726 VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent(
2727     VkDevice                                    device,
2728     const VkEventCreateInfo*                    pCreateInfo,
2729     const VkAllocationCallbacks*                pAllocator,
2730     VkEvent*                                    pEvent);
2731
2732 VKAPI_ATTR void VKAPI_CALL vkDestroyEvent(
2733     VkDevice                                    device,
2734     VkEvent                                     event,
2735     const VkAllocationCallbacks*                pAllocator);
2736
2737 VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus(
2738     VkDevice                                    device,
2739     VkEvent                                     event);
2740
2741 VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent(
2742     VkDevice                                    device,
2743     VkEvent                                     event);
2744
2745 VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent(
2746     VkDevice                                    device,
2747     VkEvent                                     event);
2748
2749 VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool(
2750     VkDevice                                    device,
2751     const VkQueryPoolCreateInfo*                pCreateInfo,
2752     const VkAllocationCallbacks*                pAllocator,
2753     VkQueryPool*                                pQueryPool);
2754
2755 VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool(
2756     VkDevice                                    device,
2757     VkQueryPool                                 queryPool,
2758     const VkAllocationCallbacks*                pAllocator);
2759
2760 VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults(
2761     VkDevice                                    device,
2762     VkQueryPool                                 queryPool,
2763     uint32_t                                    firstQuery,
2764     uint32_t                                    queryCount,
2765     size_t                                      dataSize,
2766     void*                                       pData,
2767     VkDeviceSize                                stride,
2768     VkQueryResultFlags                          flags);
2769
2770 VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer(
2771     VkDevice                                    device,
2772     const VkBufferCreateInfo*                   pCreateInfo,
2773     const VkAllocationCallbacks*                pAllocator,
2774     VkBuffer*                                   pBuffer);
2775
2776 VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer(
2777     VkDevice                                    device,
2778     VkBuffer                                    buffer,
2779     const VkAllocationCallbacks*                pAllocator);
2780
2781 VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView(
2782     VkDevice                                    device,
2783     const VkBufferViewCreateInfo*               pCreateInfo,
2784     const VkAllocationCallbacks*                pAllocator,
2785     VkBufferView*                               pView);
2786
2787 VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView(
2788     VkDevice                                    device,
2789     VkBufferView                                bufferView,
2790     const VkAllocationCallbacks*                pAllocator);
2791
2792 VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(
2793     VkDevice                                    device,
2794     const VkImageCreateInfo*                    pCreateInfo,
2795     const VkAllocationCallbacks*                pAllocator,
2796     VkImage*                                    pImage);
2797
2798 VKAPI_ATTR void VKAPI_CALL vkDestroyImage(
2799     VkDevice                                    device,
2800     VkImage                                     image,
2801     const VkAllocationCallbacks*                pAllocator);
2802
2803 VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout(
2804     VkDevice                                    device,
2805     VkImage                                     image,
2806     const VkImageSubresource*                   pSubresource,
2807     VkSubresourceLayout*                        pLayout);
2808
2809 VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView(
2810     VkDevice                                    device,
2811     const VkImageViewCreateInfo*                pCreateInfo,
2812     const VkAllocationCallbacks*                pAllocator,
2813     VkImageView*                                pView);
2814
2815 VKAPI_ATTR void VKAPI_CALL vkDestroyImageView(
2816     VkDevice                                    device,
2817     VkImageView                                 imageView,
2818     const VkAllocationCallbacks*                pAllocator);
2819
2820 VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule(
2821     VkDevice                                    device,
2822     const VkShaderModuleCreateInfo*             pCreateInfo,
2823     const VkAllocationCallbacks*                pAllocator,
2824     VkShaderModule*                             pShaderModule);
2825
2826 VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule(
2827     VkDevice                                    device,
2828     VkShaderModule                              shaderModule,
2829     const VkAllocationCallbacks*                pAllocator);
2830
2831 VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache(
2832     VkDevice                                    device,
2833     const VkPipelineCacheCreateInfo*            pCreateInfo,
2834     const VkAllocationCallbacks*                pAllocator,
2835     VkPipelineCache*                            pPipelineCache);
2836
2837 VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache(
2838     VkDevice                                    device,
2839     VkPipelineCache                             pipelineCache,
2840     const VkAllocationCallbacks*                pAllocator);
2841
2842 VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData(
2843     VkDevice                                    device,
2844     VkPipelineCache                             pipelineCache,
2845     size_t*                                     pDataSize,
2846     void*                                       pData);
2847
2848 VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches(
2849     VkDevice                                    device,
2850     VkPipelineCache                             dstCache,
2851     uint32_t                                    srcCacheCount,
2852     const VkPipelineCache*                      pSrcCaches);
2853
2854 VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines(
2855     VkDevice                                    device,
2856     VkPipelineCache                             pipelineCache,
2857     uint32_t                                    createInfoCount,
2858     const VkGraphicsPipelineCreateInfo*         pCreateInfos,
2859     const VkAllocationCallbacks*                pAllocator,
2860     VkPipeline*                                 pPipelines);
2861
2862 VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines(
2863     VkDevice                                    device,
2864     VkPipelineCache                             pipelineCache,
2865     uint32_t                                    createInfoCount,
2866     const VkComputePipelineCreateInfo*          pCreateInfos,
2867     const VkAllocationCallbacks*                pAllocator,
2868     VkPipeline*                                 pPipelines);
2869
2870 VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline(
2871     VkDevice                                    device,
2872     VkPipeline                                  pipeline,
2873     const VkAllocationCallbacks*                pAllocator);
2874
2875 VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout(
2876     VkDevice                                    device,
2877     const VkPipelineLayoutCreateInfo*           pCreateInfo,
2878     const VkAllocationCallbacks*                pAllocator,
2879     VkPipelineLayout*                           pPipelineLayout);
2880
2881 VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout(
2882     VkDevice                                    device,
2883     VkPipelineLayout                            pipelineLayout,
2884     const VkAllocationCallbacks*                pAllocator);
2885
2886 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler(
2887     VkDevice                                    device,
2888     const VkSamplerCreateInfo*                  pCreateInfo,
2889     const VkAllocationCallbacks*                pAllocator,
2890     VkSampler*                                  pSampler);
2891
2892 VKAPI_ATTR void VKAPI_CALL vkDestroySampler(
2893     VkDevice                                    device,
2894     VkSampler                                   sampler,
2895     const VkAllocationCallbacks*                pAllocator);
2896
2897 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout(
2898     VkDevice                                    device,
2899     const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
2900     const VkAllocationCallbacks*                pAllocator,
2901     VkDescriptorSetLayout*                      pSetLayout);
2902
2903 VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout(
2904     VkDevice                                    device,
2905     VkDescriptorSetLayout                       descriptorSetLayout,
2906     const VkAllocationCallbacks*                pAllocator);
2907
2908 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool(
2909     VkDevice                                    device,
2910     const VkDescriptorPoolCreateInfo*           pCreateInfo,
2911     const VkAllocationCallbacks*                pAllocator,
2912     VkDescriptorPool*                           pDescriptorPool);
2913
2914 VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool(
2915     VkDevice                                    device,
2916     VkDescriptorPool                            descriptorPool,
2917     const VkAllocationCallbacks*                pAllocator);
2918
2919 VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool(
2920     VkDevice                                    device,
2921     VkDescriptorPool                            descriptorPool,
2922     VkDescriptorPoolResetFlags                  flags);
2923
2924 VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets(
2925     VkDevice                                    device,
2926     const VkDescriptorSetAllocateInfo*          pAllocateInfo,
2927     VkDescriptorSet*                            pDescriptorSets);
2928
2929 VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets(
2930     VkDevice                                    device,
2931     VkDescriptorPool                            descriptorPool,
2932     uint32_t                                    descriptorSetCount,
2933     const VkDescriptorSet*                      pDescriptorSets);
2934
2935 VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets(
2936     VkDevice                                    device,
2937     uint32_t                                    descriptorWriteCount,
2938     const VkWriteDescriptorSet*                 pDescriptorWrites,
2939     uint32_t                                    descriptorCopyCount,
2940     const VkCopyDescriptorSet*                  pDescriptorCopies);
2941
2942 VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer(
2943     VkDevice                                    device,
2944     const VkFramebufferCreateInfo*              pCreateInfo,
2945     const VkAllocationCallbacks*                pAllocator,
2946     VkFramebuffer*                              pFramebuffer);
2947
2948 VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer(
2949     VkDevice                                    device,
2950     VkFramebuffer                               framebuffer,
2951     const VkAllocationCallbacks*                pAllocator);
2952
2953 VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass(
2954     VkDevice                                    device,
2955     const VkRenderPassCreateInfo*               pCreateInfo,
2956     const VkAllocationCallbacks*                pAllocator,
2957     VkRenderPass*                               pRenderPass);
2958
2959 VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass(
2960     VkDevice                                    device,
2961     VkRenderPass                                renderPass,
2962     const VkAllocationCallbacks*                pAllocator);
2963
2964 VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity(
2965     VkDevice                                    device,
2966     VkRenderPass                                renderPass,
2967     VkExtent2D*                                 pGranularity);
2968
2969 VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool(
2970     VkDevice                                    device,
2971     const VkCommandPoolCreateInfo*              pCreateInfo,
2972     const VkAllocationCallbacks*                pAllocator,
2973     VkCommandPool*                              pCommandPool);
2974
2975 VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool(
2976     VkDevice                                    device,
2977     VkCommandPool                               commandPool,
2978     const VkAllocationCallbacks*                pAllocator);
2979
2980 VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool(
2981     VkDevice                                    device,
2982     VkCommandPool                               commandPool,
2983     VkCommandPoolResetFlags                     flags);
2984
2985 VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers(
2986     VkDevice                                    device,
2987     const VkCommandBufferAllocateInfo*          pAllocateInfo,
2988     VkCommandBuffer*                            pCommandBuffers);
2989
2990 VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers(
2991     VkDevice                                    device,
2992     VkCommandPool                               commandPool,
2993     uint32_t                                    commandBufferCount,
2994     const VkCommandBuffer*                      pCommandBuffers);
2995
2996 VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer(
2997     VkCommandBuffer                             commandBuffer,
2998     const VkCommandBufferBeginInfo*             pBeginInfo);
2999
3000 VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer(
3001     VkCommandBuffer                             commandBuffer);
3002
3003 VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer(
3004     VkCommandBuffer                             commandBuffer,
3005     VkCommandBufferResetFlags                   flags);
3006
3007 VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline(
3008     VkCommandBuffer                             commandBuffer,
3009     VkPipelineBindPoint                         pipelineBindPoint,
3010     VkPipeline                                  pipeline);
3011
3012 VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport(
3013     VkCommandBuffer                             commandBuffer,
3014     uint32_t                                    firstViewport,
3015     uint32_t                                    viewportCount,
3016     const VkViewport*                           pViewports);
3017
3018 VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor(
3019     VkCommandBuffer                             commandBuffer,
3020     uint32_t                                    firstScissor,
3021     uint32_t                                    scissorCount,
3022     const VkRect2D*                             pScissors);
3023
3024 VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth(
3025     VkCommandBuffer                             commandBuffer,
3026     float                                       lineWidth);
3027
3028 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias(
3029     VkCommandBuffer                             commandBuffer,
3030     float                                       depthBiasConstantFactor,
3031     float                                       depthBiasClamp,
3032     float                                       depthBiasSlopeFactor);
3033
3034 VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants(
3035     VkCommandBuffer                             commandBuffer,
3036     const float                                 blendConstants[4]);
3037
3038 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds(
3039     VkCommandBuffer                             commandBuffer,
3040     float                                       minDepthBounds,
3041     float                                       maxDepthBounds);
3042
3043 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask(
3044     VkCommandBuffer                             commandBuffer,
3045     VkStencilFaceFlags                          faceMask,
3046     uint32_t                                    compareMask);
3047
3048 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask(
3049     VkCommandBuffer                             commandBuffer,
3050     VkStencilFaceFlags                          faceMask,
3051     uint32_t                                    writeMask);
3052
3053 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference(
3054     VkCommandBuffer                             commandBuffer,
3055     VkStencilFaceFlags                          faceMask,
3056     uint32_t                                    reference);
3057
3058 VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets(
3059     VkCommandBuffer                             commandBuffer,
3060     VkPipelineBindPoint                         pipelineBindPoint,
3061     VkPipelineLayout                            layout,
3062     uint32_t                                    firstSet,
3063     uint32_t                                    descriptorSetCount,
3064     const VkDescriptorSet*                      pDescriptorSets,
3065     uint32_t                                    dynamicOffsetCount,
3066     const uint32_t*                             pDynamicOffsets);
3067
3068 VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer(
3069     VkCommandBuffer                             commandBuffer,
3070     VkBuffer                                    buffer,
3071     VkDeviceSize                                offset,
3072     VkIndexType                                 indexType);
3073
3074 VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers(
3075     VkCommandBuffer                             commandBuffer,
3076     uint32_t                                    firstBinding,
3077     uint32_t                                    bindingCount,
3078     const VkBuffer*                             pBuffers,
3079     const VkDeviceSize*                         pOffsets);
3080
3081 VKAPI_ATTR void VKAPI_CALL vkCmdDraw(
3082     VkCommandBuffer                             commandBuffer,
3083     uint32_t                                    vertexCount,
3084     uint32_t                                    instanceCount,
3085     uint32_t                                    firstVertex,
3086     uint32_t                                    firstInstance);
3087
3088 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed(
3089     VkCommandBuffer                             commandBuffer,
3090     uint32_t                                    indexCount,
3091     uint32_t                                    instanceCount,
3092     uint32_t                                    firstIndex,
3093     int32_t                                     vertexOffset,
3094     uint32_t                                    firstInstance);
3095
3096 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect(
3097     VkCommandBuffer                             commandBuffer,
3098     VkBuffer                                    buffer,
3099     VkDeviceSize                                offset,
3100     uint32_t                                    drawCount,
3101     uint32_t                                    stride);
3102
3103 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect(
3104     VkCommandBuffer                             commandBuffer,
3105     VkBuffer                                    buffer,
3106     VkDeviceSize                                offset,
3107     uint32_t                                    drawCount,
3108     uint32_t                                    stride);
3109
3110 VKAPI_ATTR void VKAPI_CALL vkCmdDispatch(
3111     VkCommandBuffer                             commandBuffer,
3112     uint32_t                                    groupCountX,
3113     uint32_t                                    groupCountY,
3114     uint32_t                                    groupCountZ);
3115
3116 VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect(
3117     VkCommandBuffer                             commandBuffer,
3118     VkBuffer                                    buffer,
3119     VkDeviceSize                                offset);
3120
3121 VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer(
3122     VkCommandBuffer                             commandBuffer,
3123     VkBuffer                                    srcBuffer,
3124     VkBuffer                                    dstBuffer,
3125     uint32_t                                    regionCount,
3126     const VkBufferCopy*                         pRegions);
3127
3128 VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage(
3129     VkCommandBuffer                             commandBuffer,
3130     VkImage                                     srcImage,
3131     VkImageLayout                               srcImageLayout,
3132     VkImage                                     dstImage,
3133     VkImageLayout                               dstImageLayout,
3134     uint32_t                                    regionCount,
3135     const VkImageCopy*                          pRegions);
3136
3137 VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage(
3138     VkCommandBuffer                             commandBuffer,
3139     VkImage                                     srcImage,
3140     VkImageLayout                               srcImageLayout,
3141     VkImage                                     dstImage,
3142     VkImageLayout                               dstImageLayout,
3143     uint32_t                                    regionCount,
3144     const VkImageBlit*                          pRegions,
3145     VkFilter                                    filter);
3146
3147 VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage(
3148     VkCommandBuffer                             commandBuffer,
3149     VkBuffer                                    srcBuffer,
3150     VkImage                                     dstImage,
3151     VkImageLayout                               dstImageLayout,
3152     uint32_t                                    regionCount,
3153     const VkBufferImageCopy*                    pRegions);
3154
3155 VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer(
3156     VkCommandBuffer                             commandBuffer,
3157     VkImage                                     srcImage,
3158     VkImageLayout                               srcImageLayout,
3159     VkBuffer                                    dstBuffer,
3160     uint32_t                                    regionCount,
3161     const VkBufferImageCopy*                    pRegions);
3162
3163 VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer(
3164     VkCommandBuffer                             commandBuffer,
3165     VkBuffer                                    dstBuffer,
3166     VkDeviceSize                                dstOffset,
3167     VkDeviceSize                                dataSize,
3168     const void*                                 pData);
3169
3170 VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer(
3171     VkCommandBuffer                             commandBuffer,
3172     VkBuffer                                    dstBuffer,
3173     VkDeviceSize                                dstOffset,
3174     VkDeviceSize                                size,
3175     uint32_t                                    data);
3176
3177 VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage(
3178     VkCommandBuffer                             commandBuffer,
3179     VkImage                                     image,
3180     VkImageLayout                               imageLayout,
3181     const VkClearColorValue*                    pColor,
3182     uint32_t                                    rangeCount,
3183     const VkImageSubresourceRange*              pRanges);
3184
3185 VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage(
3186     VkCommandBuffer                             commandBuffer,
3187     VkImage                                     image,
3188     VkImageLayout                               imageLayout,
3189     const VkClearDepthStencilValue*             pDepthStencil,
3190     uint32_t                                    rangeCount,
3191     const VkImageSubresourceRange*              pRanges);
3192
3193 VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments(
3194     VkCommandBuffer                             commandBuffer,
3195     uint32_t                                    attachmentCount,
3196     const VkClearAttachment*                    pAttachments,
3197     uint32_t                                    rectCount,
3198     const VkClearRect*                          pRects);
3199
3200 VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage(
3201     VkCommandBuffer                             commandBuffer,
3202     VkImage                                     srcImage,
3203     VkImageLayout                               srcImageLayout,
3204     VkImage                                     dstImage,
3205     VkImageLayout                               dstImageLayout,
3206     uint32_t                                    regionCount,
3207     const VkImageResolve*                       pRegions);
3208
3209 VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent(
3210     VkCommandBuffer                             commandBuffer,
3211     VkEvent                                     event,
3212     VkPipelineStageFlags                        stageMask);
3213
3214 VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent(
3215     VkCommandBuffer                             commandBuffer,
3216     VkEvent                                     event,
3217     VkPipelineStageFlags                        stageMask);
3218
3219 VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents(
3220     VkCommandBuffer                             commandBuffer,
3221     uint32_t                                    eventCount,
3222     const VkEvent*                              pEvents,
3223     VkPipelineStageFlags                        srcStageMask,
3224     VkPipelineStageFlags                        dstStageMask,
3225     uint32_t                                    memoryBarrierCount,
3226     const VkMemoryBarrier*                      pMemoryBarriers,
3227     uint32_t                                    bufferMemoryBarrierCount,
3228     const VkBufferMemoryBarrier*                pBufferMemoryBarriers,
3229     uint32_t                                    imageMemoryBarrierCount,
3230     const VkImageMemoryBarrier*                 pImageMemoryBarriers);
3231
3232 VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier(
3233     VkCommandBuffer                             commandBuffer,
3234     VkPipelineStageFlags                        srcStageMask,
3235     VkPipelineStageFlags                        dstStageMask,
3236     VkDependencyFlags                           dependencyFlags,
3237     uint32_t                                    memoryBarrierCount,
3238     const VkMemoryBarrier*                      pMemoryBarriers,
3239     uint32_t                                    bufferMemoryBarrierCount,
3240     const VkBufferMemoryBarrier*                pBufferMemoryBarriers,
3241     uint32_t                                    imageMemoryBarrierCount,
3242     const VkImageMemoryBarrier*                 pImageMemoryBarriers);
3243
3244 VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery(
3245     VkCommandBuffer                             commandBuffer,
3246     VkQueryPool                                 queryPool,
3247     uint32_t                                    query,
3248     VkQueryControlFlags                         flags);
3249
3250 VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery(
3251     VkCommandBuffer                             commandBuffer,
3252     VkQueryPool                                 queryPool,
3253     uint32_t                                    query);
3254
3255 VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool(
3256     VkCommandBuffer                             commandBuffer,
3257     VkQueryPool                                 queryPool,
3258     uint32_t                                    firstQuery,
3259     uint32_t                                    queryCount);
3260
3261 VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp(
3262     VkCommandBuffer                             commandBuffer,
3263     VkPipelineStageFlagBits                     pipelineStage,
3264     VkQueryPool                                 queryPool,
3265     uint32_t                                    query);
3266
3267 VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults(
3268     VkCommandBuffer                             commandBuffer,
3269     VkQueryPool                                 queryPool,
3270     uint32_t                                    firstQuery,
3271     uint32_t                                    queryCount,
3272     VkBuffer                                    dstBuffer,
3273     VkDeviceSize                                dstOffset,
3274     VkDeviceSize                                stride,
3275     VkQueryResultFlags                          flags);
3276
3277 VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants(
3278     VkCommandBuffer                             commandBuffer,
3279     VkPipelineLayout                            layout,
3280     VkShaderStageFlags                          stageFlags,
3281     uint32_t                                    offset,
3282     uint32_t                                    size,
3283     const void*                                 pValues);
3284
3285 VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass(
3286     VkCommandBuffer                             commandBuffer,
3287     const VkRenderPassBeginInfo*                pRenderPassBegin,
3288     VkSubpassContents                           contents);
3289
3290 VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass(
3291     VkCommandBuffer                             commandBuffer,
3292     VkSubpassContents                           contents);
3293
3294 VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass(
3295     VkCommandBuffer                             commandBuffer);
3296
3297 VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands(
3298     VkCommandBuffer                             commandBuffer,
3299     uint32_t                                    commandBufferCount,
3300     const VkCommandBuffer*                      pCommandBuffers);
3301 #endif
3302
3303 #define VK_KHR_surface 1
3304 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR)
3305
3306 #define VK_KHR_SURFACE_SPEC_VERSION       25
3307 #define VK_KHR_SURFACE_EXTENSION_NAME     "VK_KHR_surface"
3308 #define VK_COLORSPACE_SRGB_NONLINEAR_KHR  VK_COLOR_SPACE_SRGB_NONLINEAR_KHR
3309
3310
3311 typedef enum VkColorSpaceKHR {
3312     VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0,
3313     VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT = 1000104001,
3314     VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT = 1000104002,
3315     VK_COLOR_SPACE_DCI_P3_LINEAR_EXT = 1000104003,
3316     VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT = 1000104004,
3317     VK_COLOR_SPACE_BT709_LINEAR_EXT = 1000104005,
3318     VK_COLOR_SPACE_BT709_NONLINEAR_EXT = 1000104006,
3319     VK_COLOR_SPACE_BT2020_LINEAR_EXT = 1000104007,
3320     VK_COLOR_SPACE_HDR10_ST2084_EXT = 1000104008,
3321     VK_COLOR_SPACE_DOLBYVISION_EXT = 1000104009,
3322     VK_COLOR_SPACE_HDR10_HLG_EXT = 1000104010,
3323     VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT = 1000104011,
3324     VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT = 1000104012,
3325     VK_COLOR_SPACE_PASS_THROUGH_EXT = 1000104013,
3326     VK_COLOR_SPACE_BEGIN_RANGE_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
3327     VK_COLOR_SPACE_END_RANGE_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
3328     VK_COLOR_SPACE_RANGE_SIZE_KHR = (VK_COLOR_SPACE_SRGB_NONLINEAR_KHR - VK_COLOR_SPACE_SRGB_NONLINEAR_KHR + 1),
3329     VK_COLOR_SPACE_MAX_ENUM_KHR = 0x7FFFFFFF
3330 } VkColorSpaceKHR;
3331
3332 typedef enum VkPresentModeKHR {
3333     VK_PRESENT_MODE_IMMEDIATE_KHR = 0,
3334     VK_PRESENT_MODE_MAILBOX_KHR = 1,
3335     VK_PRESENT_MODE_FIFO_KHR = 2,
3336     VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3,
3337     VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR = 1000111000,
3338     VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR = 1000111001,
3339     VK_PRESENT_MODE_BEGIN_RANGE_KHR = VK_PRESENT_MODE_IMMEDIATE_KHR,
3340     VK_PRESENT_MODE_END_RANGE_KHR = VK_PRESENT_MODE_FIFO_RELAXED_KHR,
3341     VK_PRESENT_MODE_RANGE_SIZE_KHR = (VK_PRESENT_MODE_FIFO_RELAXED_KHR - VK_PRESENT_MODE_IMMEDIATE_KHR + 1),
3342     VK_PRESENT_MODE_MAX_ENUM_KHR = 0x7FFFFFFF
3343 } VkPresentModeKHR;
3344
3345
3346 typedef enum VkSurfaceTransformFlagBitsKHR {
3347     VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 0x00000001,
3348     VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 0x00000002,
3349     VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 0x00000004,
3350     VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 0x00000008,
3351     VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 0x00000010,
3352     VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 0x00000020,
3353     VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 0x00000040,
3354     VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 0x00000080,
3355     VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100,
3356     VK_SURFACE_TRANSFORM_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
3357 } VkSurfaceTransformFlagBitsKHR;
3358 typedef VkFlags VkSurfaceTransformFlagsKHR;
3359
3360 typedef enum VkCompositeAlphaFlagBitsKHR {
3361     VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001,
3362     VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002,
3363     VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004,
3364     VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008,
3365     VK_COMPOSITE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
3366 } VkCompositeAlphaFlagBitsKHR;
3367 typedef VkFlags VkCompositeAlphaFlagsKHR;
3368
3369 typedef struct VkSurfaceCapabilitiesKHR {
3370     uint32_t                         minImageCount;
3371     uint32_t                         maxImageCount;
3372     VkExtent2D                       currentExtent;
3373     VkExtent2D                       minImageExtent;
3374     VkExtent2D                       maxImageExtent;
3375     uint32_t                         maxImageArrayLayers;
3376     VkSurfaceTransformFlagsKHR       supportedTransforms;
3377     VkSurfaceTransformFlagBitsKHR    currentTransform;
3378     VkCompositeAlphaFlagsKHR         supportedCompositeAlpha;
3379     VkImageUsageFlags                supportedUsageFlags;
3380 } VkSurfaceCapabilitiesKHR;
3381
3382 typedef struct VkSurfaceFormatKHR {
3383     VkFormat           format;
3384     VkColorSpaceKHR    colorSpace;
3385 } VkSurfaceFormatKHR;
3386
3387
3388 typedef void (VKAPI_PTR *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator);
3389 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported);
3390 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);
3391 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats);
3392 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes);
3393
3394 #ifndef VK_NO_PROTOTYPES
3395 VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR(
3396     VkInstance                                  instance,
3397     VkSurfaceKHR                                surface,
3398     const VkAllocationCallbacks*                pAllocator);
3399
3400 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR(
3401     VkPhysicalDevice                            physicalDevice,
3402     uint32_t                                    queueFamilyIndex,
3403     VkSurfaceKHR                                surface,
3404     VkBool32*                                   pSupported);
3405
3406 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
3407     VkPhysicalDevice                            physicalDevice,
3408     VkSurfaceKHR                                surface,
3409     VkSurfaceCapabilitiesKHR*                   pSurfaceCapabilities);
3410
3411 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR(
3412     VkPhysicalDevice                            physicalDevice,
3413     VkSurfaceKHR                                surface,
3414     uint32_t*                                   pSurfaceFormatCount,
3415     VkSurfaceFormatKHR*                         pSurfaceFormats);
3416
3417 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR(
3418     VkPhysicalDevice                            physicalDevice,
3419     VkSurfaceKHR                                surface,
3420     uint32_t*                                   pPresentModeCount,
3421     VkPresentModeKHR*                           pPresentModes);
3422 #endif
3423
3424 #define VK_KHR_swapchain 1
3425 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR)
3426
3427 #define VK_KHR_SWAPCHAIN_SPEC_VERSION     68
3428 #define VK_KHR_SWAPCHAIN_EXTENSION_NAME   "VK_KHR_swapchain"
3429
3430
3431 typedef enum VkSwapchainCreateFlagBitsKHR {
3432     VK_SWAPCHAIN_CREATE_BIND_SFR_BIT_KHX = 0x00000001,
3433     VK_SWAPCHAIN_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
3434 } VkSwapchainCreateFlagBitsKHR;
3435 typedef VkFlags VkSwapchainCreateFlagsKHR;
3436
3437 typedef struct VkSwapchainCreateInfoKHR {
3438     VkStructureType                  sType;
3439     const void*                      pNext;
3440     VkSwapchainCreateFlagsKHR        flags;
3441     VkSurfaceKHR                     surface;
3442     uint32_t                         minImageCount;
3443     VkFormat                         imageFormat;
3444     VkColorSpaceKHR                  imageColorSpace;
3445     VkExtent2D                       imageExtent;
3446     uint32_t                         imageArrayLayers;
3447     VkImageUsageFlags                imageUsage;
3448     VkSharingMode                    imageSharingMode;
3449     uint32_t                         queueFamilyIndexCount;
3450     const uint32_t*                  pQueueFamilyIndices;
3451     VkSurfaceTransformFlagBitsKHR    preTransform;
3452     VkCompositeAlphaFlagBitsKHR      compositeAlpha;
3453     VkPresentModeKHR                 presentMode;
3454     VkBool32                         clipped;
3455     VkSwapchainKHR                   oldSwapchain;
3456 } VkSwapchainCreateInfoKHR;
3457
3458 typedef struct VkPresentInfoKHR {
3459     VkStructureType          sType;
3460     const void*              pNext;
3461     uint32_t                 waitSemaphoreCount;
3462     const VkSemaphore*       pWaitSemaphores;
3463     uint32_t                 swapchainCount;
3464     const VkSwapchainKHR*    pSwapchains;
3465     const uint32_t*          pImageIndices;
3466     VkResult*                pResults;
3467 } VkPresentInfoKHR;
3468
3469
3470 typedef VkResult (VKAPI_PTR *PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain);
3471 typedef void (VKAPI_PTR *PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator);
3472 typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages);
3473 typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex);
3474 typedef VkResult (VKAPI_PTR *PFN_vkQueuePresentKHR)(VkQueue queue, const VkPresentInfoKHR* pPresentInfo);
3475
3476 #ifndef VK_NO_PROTOTYPES
3477 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR(
3478     VkDevice                                    device,
3479     const VkSwapchainCreateInfoKHR*             pCreateInfo,
3480     const VkAllocationCallbacks*                pAllocator,
3481     VkSwapchainKHR*                             pSwapchain);
3482
3483 VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR(
3484     VkDevice                                    device,
3485     VkSwapchainKHR                              swapchain,
3486     const VkAllocationCallbacks*                pAllocator);
3487
3488 VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR(
3489     VkDevice                                    device,
3490     VkSwapchainKHR                              swapchain,
3491     uint32_t*                                   pSwapchainImageCount,
3492     VkImage*                                    pSwapchainImages);
3493
3494 VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(
3495     VkDevice                                    device,
3496     VkSwapchainKHR                              swapchain,
3497     uint64_t                                    timeout,
3498     VkSemaphore                                 semaphore,
3499     VkFence                                     fence,
3500     uint32_t*                                   pImageIndex);
3501
3502 VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(
3503     VkQueue                                     queue,
3504     const VkPresentInfoKHR*                     pPresentInfo);
3505 #endif
3506
3507 #define VK_KHR_display 1
3508 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR)
3509 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR)
3510
3511 #define VK_KHR_DISPLAY_SPEC_VERSION       21
3512 #define VK_KHR_DISPLAY_EXTENSION_NAME     "VK_KHR_display"
3513
3514
3515 typedef enum VkDisplayPlaneAlphaFlagBitsKHR {
3516     VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0x00000001,
3517     VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000002,
3518     VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000004,
3519     VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000008,
3520     VK_DISPLAY_PLANE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
3521 } VkDisplayPlaneAlphaFlagBitsKHR;
3522 typedef VkFlags VkDisplayPlaneAlphaFlagsKHR;
3523 typedef VkFlags VkDisplayModeCreateFlagsKHR;
3524 typedef VkFlags VkDisplaySurfaceCreateFlagsKHR;
3525
3526 typedef struct VkDisplayPropertiesKHR {
3527     VkDisplayKHR                  display;
3528     const char*                   displayName;
3529     VkExtent2D                    physicalDimensions;
3530     VkExtent2D                    physicalResolution;
3531     VkSurfaceTransformFlagsKHR    supportedTransforms;
3532     VkBool32                      planeReorderPossible;
3533     VkBool32                      persistentContent;
3534 } VkDisplayPropertiesKHR;
3535
3536 typedef struct VkDisplayModeParametersKHR {
3537     VkExtent2D    visibleRegion;
3538     uint32_t      refreshRate;
3539 } VkDisplayModeParametersKHR;
3540
3541 typedef struct VkDisplayModePropertiesKHR {
3542     VkDisplayModeKHR              displayMode;
3543     VkDisplayModeParametersKHR    parameters;
3544 } VkDisplayModePropertiesKHR;
3545
3546 typedef struct VkDisplayModeCreateInfoKHR {
3547     VkStructureType                sType;
3548     const void*                    pNext;
3549     VkDisplayModeCreateFlagsKHR    flags;
3550     VkDisplayModeParametersKHR     parameters;
3551 } VkDisplayModeCreateInfoKHR;
3552
3553 typedef struct VkDisplayPlaneCapabilitiesKHR {
3554     VkDisplayPlaneAlphaFlagsKHR    supportedAlpha;
3555     VkOffset2D                     minSrcPosition;
3556     VkOffset2D                     maxSrcPosition;
3557     VkExtent2D                     minSrcExtent;
3558     VkExtent2D                     maxSrcExtent;
3559     VkOffset2D                     minDstPosition;
3560     VkOffset2D                     maxDstPosition;
3561     VkExtent2D                     minDstExtent;
3562     VkExtent2D                     maxDstExtent;
3563 } VkDisplayPlaneCapabilitiesKHR;
3564
3565 typedef struct VkDisplayPlanePropertiesKHR {
3566     VkDisplayKHR    currentDisplay;
3567     uint32_t        currentStackIndex;
3568 } VkDisplayPlanePropertiesKHR;
3569
3570 typedef struct VkDisplaySurfaceCreateInfoKHR {
3571     VkStructureType                   sType;
3572     const void*                       pNext;
3573     VkDisplaySurfaceCreateFlagsKHR    flags;
3574     VkDisplayModeKHR                  displayMode;
3575     uint32_t                          planeIndex;
3576     uint32_t                          planeStackIndex;
3577     VkSurfaceTransformFlagBitsKHR     transform;
3578     float                             globalAlpha;
3579     VkDisplayPlaneAlphaFlagBitsKHR    alphaMode;
3580     VkExtent2D                        imageExtent;
3581 } VkDisplaySurfaceCreateInfoKHR;
3582
3583
3584 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties);
3585 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties);
3586 typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays);
3587 typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties);
3588 typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode);
3589 typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities);
3590 typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
3591
3592 #ifndef VK_NO_PROTOTYPES
3593 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR(
3594     VkPhysicalDevice                            physicalDevice,
3595     uint32_t*                                   pPropertyCount,
3596     VkDisplayPropertiesKHR*                     pProperties);
3597
3598 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
3599     VkPhysicalDevice                            physicalDevice,
3600     uint32_t*                                   pPropertyCount,
3601     VkDisplayPlanePropertiesKHR*                pProperties);
3602
3603 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR(
3604     VkPhysicalDevice                            physicalDevice,
3605     uint32_t                                    planeIndex,
3606     uint32_t*                                   pDisplayCount,
3607     VkDisplayKHR*                               pDisplays);
3608
3609 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR(
3610     VkPhysicalDevice                            physicalDevice,
3611     VkDisplayKHR                                display,
3612     uint32_t*                                   pPropertyCount,
3613     VkDisplayModePropertiesKHR*                 pProperties);
3614
3615 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR(
3616     VkPhysicalDevice                            physicalDevice,
3617     VkDisplayKHR                                display,
3618     const VkDisplayModeCreateInfoKHR*           pCreateInfo,
3619     const VkAllocationCallbacks*                pAllocator,
3620     VkDisplayModeKHR*                           pMode);
3621
3622 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR(
3623     VkPhysicalDevice                            physicalDevice,
3624     VkDisplayModeKHR                            mode,
3625     uint32_t                                    planeIndex,
3626     VkDisplayPlaneCapabilitiesKHR*              pCapabilities);
3627
3628 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR(
3629     VkInstance                                  instance,
3630     const VkDisplaySurfaceCreateInfoKHR*        pCreateInfo,
3631     const VkAllocationCallbacks*                pAllocator,
3632     VkSurfaceKHR*                               pSurface);
3633 #endif
3634
3635 #define VK_KHR_display_swapchain 1
3636 #define VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION 9
3637 #define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain"
3638
3639 typedef struct VkDisplayPresentInfoKHR {
3640     VkStructureType    sType;
3641     const void*        pNext;
3642     VkRect2D           srcRect;
3643     VkRect2D           dstRect;
3644     VkBool32           persistent;
3645 } VkDisplayPresentInfoKHR;
3646
3647
3648 typedef VkResult (VKAPI_PTR *PFN_vkCreateSharedSwapchainsKHR)(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains);
3649
3650 #ifndef VK_NO_PROTOTYPES
3651 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR(
3652     VkDevice                                    device,
3653     uint32_t                                    swapchainCount,
3654     const VkSwapchainCreateInfoKHR*             pCreateInfos,
3655     const VkAllocationCallbacks*                pAllocator,
3656     VkSwapchainKHR*                             pSwapchains);
3657 #endif
3658
3659 #ifdef VK_USE_PLATFORM_XLIB_KHR
3660 #define VK_KHR_xlib_surface 1
3661 #include <X11/Xlib.h>
3662
3663 #define VK_KHR_XLIB_SURFACE_SPEC_VERSION  6
3664 #define VK_KHR_XLIB_SURFACE_EXTENSION_NAME "VK_KHR_xlib_surface"
3665
3666 typedef VkFlags VkXlibSurfaceCreateFlagsKHR;
3667
3668 typedef struct VkXlibSurfaceCreateInfoKHR {
3669     VkStructureType                sType;
3670     const void*                    pNext;
3671     VkXlibSurfaceCreateFlagsKHR    flags;
3672     Display*                       dpy;
3673     Window                         window;
3674 } VkXlibSurfaceCreateInfoKHR;
3675
3676
3677 typedef VkResult (VKAPI_PTR *PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
3678 typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID);
3679
3680 #ifndef VK_NO_PROTOTYPES
3681 VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR(
3682     VkInstance                                  instance,
3683     const VkXlibSurfaceCreateInfoKHR*           pCreateInfo,
3684     const VkAllocationCallbacks*                pAllocator,
3685     VkSurfaceKHR*                               pSurface);
3686
3687 VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR(
3688     VkPhysicalDevice                            physicalDevice,
3689     uint32_t                                    queueFamilyIndex,
3690     Display*                                    dpy,
3691     VisualID                                    visualID);
3692 #endif
3693 #endif /* VK_USE_PLATFORM_XLIB_KHR */
3694
3695 #ifdef VK_USE_PLATFORM_XCB_KHR
3696 #define VK_KHR_xcb_surface 1
3697 #include <xcb/xcb.h>
3698
3699 #define VK_KHR_XCB_SURFACE_SPEC_VERSION   6
3700 #define VK_KHR_XCB_SURFACE_EXTENSION_NAME "VK_KHR_xcb_surface"
3701
3702 typedef VkFlags VkXcbSurfaceCreateFlagsKHR;
3703
3704 typedef struct VkXcbSurfaceCreateInfoKHR {
3705     VkStructureType               sType;
3706     const void*                   pNext;
3707     VkXcbSurfaceCreateFlagsKHR    flags;
3708     xcb_connection_t*             connection;
3709     xcb_window_t                  window;
3710 } VkXcbSurfaceCreateInfoKHR;
3711
3712
3713 typedef VkResult (VKAPI_PTR *PFN_vkCreateXcbSurfaceKHR)(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
3714 typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id);
3715
3716 #ifndef VK_NO_PROTOTYPES
3717 VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR(
3718     VkInstance                                  instance,
3719     const VkXcbSurfaceCreateInfoKHR*            pCreateInfo,
3720     const VkAllocationCallbacks*                pAllocator,
3721     VkSurfaceKHR*                               pSurface);
3722
3723 VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR(
3724     VkPhysicalDevice                            physicalDevice,
3725     uint32_t                                    queueFamilyIndex,
3726     xcb_connection_t*                           connection,
3727     xcb_visualid_t                              visual_id);
3728 #endif
3729 #endif /* VK_USE_PLATFORM_XCB_KHR */
3730
3731 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
3732 #define VK_KHR_wayland_surface 1
3733 #include <wayland-client.h>
3734
3735 #define VK_KHR_WAYLAND_SURFACE_SPEC_VERSION 6
3736 #define VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME "VK_KHR_wayland_surface"
3737
3738 typedef VkFlags VkWaylandSurfaceCreateFlagsKHR;
3739
3740 typedef struct VkWaylandSurfaceCreateInfoKHR {
3741     VkStructureType                   sType;
3742     const void*                       pNext;
3743     VkWaylandSurfaceCreateFlagsKHR    flags;
3744     struct wl_display*                display;
3745     struct wl_surface*                surface;
3746 } VkWaylandSurfaceCreateInfoKHR;
3747
3748
3749 typedef VkResult (VKAPI_PTR *PFN_vkCreateWaylandSurfaceKHR)(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
3750 typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display);
3751
3752 #ifndef VK_NO_PROTOTYPES
3753 VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR(
3754     VkInstance                                  instance,
3755     const VkWaylandSurfaceCreateInfoKHR*        pCreateInfo,
3756     const VkAllocationCallbacks*                pAllocator,
3757     VkSurfaceKHR*                               pSurface);
3758
3759 VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR(
3760     VkPhysicalDevice                            physicalDevice,
3761     uint32_t                                    queueFamilyIndex,
3762     struct wl_display*                          display);
3763 #endif
3764 #endif /* VK_USE_PLATFORM_WAYLAND_KHR */
3765
3766 #ifdef VK_USE_PLATFORM_MIR_KHR
3767 #define VK_KHR_mir_surface 1
3768 #include <mir_toolkit/client_types.h>
3769
3770 #define VK_KHR_MIR_SURFACE_SPEC_VERSION   4
3771 #define VK_KHR_MIR_SURFACE_EXTENSION_NAME "VK_KHR_mir_surface"
3772
3773 typedef VkFlags VkMirSurfaceCreateFlagsKHR;
3774
3775 typedef struct VkMirSurfaceCreateInfoKHR {
3776     VkStructureType               sType;
3777     const void*                   pNext;
3778     VkMirSurfaceCreateFlagsKHR    flags;
3779     MirConnection*                connection;
3780     MirSurface*                   mirSurface;
3781 } VkMirSurfaceCreateInfoKHR;
3782
3783
3784 typedef VkResult (VKAPI_PTR *PFN_vkCreateMirSurfaceKHR)(VkInstance instance, const VkMirSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
3785 typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceMirPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, MirConnection* connection);
3786
3787 #ifndef VK_NO_PROTOTYPES
3788 VKAPI_ATTR VkResult VKAPI_CALL vkCreateMirSurfaceKHR(
3789     VkInstance                                  instance,
3790     const VkMirSurfaceCreateInfoKHR*            pCreateInfo,
3791     const VkAllocationCallbacks*                pAllocator,
3792     VkSurfaceKHR*                               pSurface);
3793
3794 VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceMirPresentationSupportKHR(
3795     VkPhysicalDevice                            physicalDevice,
3796     uint32_t                                    queueFamilyIndex,
3797     MirConnection*                              connection);
3798 #endif
3799 #endif /* VK_USE_PLATFORM_MIR_KHR */
3800
3801 #ifdef VK_USE_PLATFORM_ANDROID_KHR
3802 #define VK_KHR_android_surface 1
3803 #include <android/native_window.h>
3804
3805 #define VK_KHR_ANDROID_SURFACE_SPEC_VERSION 6
3806 #define VK_KHR_ANDROID_SURFACE_EXTENSION_NAME "VK_KHR_android_surface"
3807
3808 typedef VkFlags VkAndroidSurfaceCreateFlagsKHR;
3809
3810 typedef struct VkAndroidSurfaceCreateInfoKHR {
3811     VkStructureType                   sType;
3812     const void*                       pNext;
3813     VkAndroidSurfaceCreateFlagsKHR    flags;
3814     ANativeWindow*                    window;
3815 } VkAndroidSurfaceCreateInfoKHR;
3816
3817
3818 typedef VkResult (VKAPI_PTR *PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
3819
3820 #ifndef VK_NO_PROTOTYPES
3821 VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR(
3822     VkInstance                                  instance,
3823     const VkAndroidSurfaceCreateInfoKHR*        pCreateInfo,
3824     const VkAllocationCallbacks*                pAllocator,
3825     VkSurfaceKHR*                               pSurface);
3826 #endif
3827 #endif /* VK_USE_PLATFORM_ANDROID_KHR */
3828
3829 #ifdef VK_USE_PLATFORM_WIN32_KHR
3830 #define VK_KHR_win32_surface 1
3831 #include <windows.h>
3832
3833 #define VK_KHR_WIN32_SURFACE_SPEC_VERSION 5
3834 #define VK_KHR_WIN32_SURFACE_EXTENSION_NAME "VK_KHR_win32_surface"
3835
3836 typedef VkFlags VkWin32SurfaceCreateFlagsKHR;
3837
3838 typedef struct VkWin32SurfaceCreateInfoKHR {
3839     VkStructureType                 sType;
3840     const void*                     pNext;
3841     VkWin32SurfaceCreateFlagsKHR    flags;
3842     HINSTANCE                       hinstance;
3843     HWND                            hwnd;
3844 } VkWin32SurfaceCreateInfoKHR;
3845
3846
3847 typedef VkResult (VKAPI_PTR *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
3848 typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex);
3849
3850 #ifndef VK_NO_PROTOTYPES
3851 VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR(
3852     VkInstance                                  instance,
3853     const VkWin32SurfaceCreateInfoKHR*          pCreateInfo,
3854     const VkAllocationCallbacks*                pAllocator,
3855     VkSurfaceKHR*                               pSurface);
3856
3857 VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR(
3858     VkPhysicalDevice                            physicalDevice,
3859     uint32_t                                    queueFamilyIndex);
3860 #endif
3861 #endif /* VK_USE_PLATFORM_WIN32_KHR */
3862
3863 #define VK_KHR_sampler_mirror_clamp_to_edge 1
3864 #define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION 1
3865 #define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME "VK_KHR_sampler_mirror_clamp_to_edge"
3866
3867
3868 #define VK_KHR_get_physical_device_properties2 1
3869 #define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION 1
3870 #define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_physical_device_properties2"
3871
3872 typedef struct VkPhysicalDeviceFeatures2KHR {
3873     VkStructureType             sType;
3874     void*                       pNext;
3875     VkPhysicalDeviceFeatures    features;
3876 } VkPhysicalDeviceFeatures2KHR;
3877
3878 typedef struct VkPhysicalDeviceProperties2KHR {
3879     VkStructureType               sType;
3880     void*                         pNext;
3881     VkPhysicalDeviceProperties    properties;
3882 } VkPhysicalDeviceProperties2KHR;
3883
3884 typedef struct VkFormatProperties2KHR {
3885     VkStructureType       sType;
3886     void*                 pNext;
3887     VkFormatProperties    formatProperties;
3888 } VkFormatProperties2KHR;
3889
3890 typedef struct VkImageFormatProperties2KHR {
3891     VkStructureType            sType;
3892     void*                      pNext;
3893     VkImageFormatProperties    imageFormatProperties;
3894 } VkImageFormatProperties2KHR;
3895
3896 typedef struct VkPhysicalDeviceImageFormatInfo2KHR {
3897     VkStructureType       sType;
3898     const void*           pNext;
3899     VkFormat              format;
3900     VkImageType           type;
3901     VkImageTiling         tiling;
3902     VkImageUsageFlags     usage;
3903     VkImageCreateFlags    flags;
3904 } VkPhysicalDeviceImageFormatInfo2KHR;
3905
3906 typedef struct VkQueueFamilyProperties2KHR {
3907     VkStructureType            sType;
3908     void*                      pNext;
3909     VkQueueFamilyProperties    queueFamilyProperties;
3910 } VkQueueFamilyProperties2KHR;
3911
3912 typedef struct VkPhysicalDeviceMemoryProperties2KHR {
3913     VkStructureType                     sType;
3914     void*                               pNext;
3915     VkPhysicalDeviceMemoryProperties    memoryProperties;
3916 } VkPhysicalDeviceMemoryProperties2KHR;
3917
3918 typedef struct VkSparseImageFormatProperties2KHR {
3919     VkStructureType                  sType;
3920     void*                            pNext;
3921     VkSparseImageFormatProperties    properties;
3922 } VkSparseImageFormatProperties2KHR;
3923
3924 typedef struct VkPhysicalDeviceSparseImageFormatInfo2KHR {
3925     VkStructureType          sType;
3926     const void*              pNext;
3927     VkFormat                 format;
3928     VkImageType              type;
3929     VkSampleCountFlagBits    samples;
3930     VkImageUsageFlags        usage;
3931     VkImageTiling            tiling;
3932 } VkPhysicalDeviceSparseImageFormatInfo2KHR;
3933
3934
3935 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2KHR* pFeatures);
3936 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2KHR* pProperties);
3937 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2KHR)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2KHR* pFormatProperties);
3938 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2KHR* pImageFormatInfo, VkImageFormatProperties2KHR* pImageFormatProperties);
3939 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2KHR* pQueueFamilyProperties);
3940 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2KHR* pMemoryProperties);
3941 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2KHR* pProperties);
3942
3943 #ifndef VK_NO_PROTOTYPES
3944 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2KHR(
3945     VkPhysicalDevice                            physicalDevice,
3946     VkPhysicalDeviceFeatures2KHR*               pFeatures);
3947
3948 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2KHR(
3949     VkPhysicalDevice                            physicalDevice,
3950     VkPhysicalDeviceProperties2KHR*             pProperties);
3951
3952 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2KHR(
3953     VkPhysicalDevice                            physicalDevice,
3954     VkFormat                                    format,
3955     VkFormatProperties2KHR*                     pFormatProperties);
3956
3957 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2KHR(
3958     VkPhysicalDevice                            physicalDevice,
3959     const VkPhysicalDeviceImageFormatInfo2KHR*  pImageFormatInfo,
3960     VkImageFormatProperties2KHR*                pImageFormatProperties);
3961
3962 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2KHR(
3963     VkPhysicalDevice                            physicalDevice,
3964     uint32_t*                                   pQueueFamilyPropertyCount,
3965     VkQueueFamilyProperties2KHR*                pQueueFamilyProperties);
3966
3967 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2KHR(
3968     VkPhysicalDevice                            physicalDevice,
3969     VkPhysicalDeviceMemoryProperties2KHR*       pMemoryProperties);
3970
3971 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
3972     VkPhysicalDevice                            physicalDevice,
3973     const VkPhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo,
3974     uint32_t*                                   pPropertyCount,
3975     VkSparseImageFormatProperties2KHR*          pProperties);
3976 #endif
3977
3978 #define VK_KHR_shader_draw_parameters 1
3979 #define VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION 1
3980 #define VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME "VK_KHR_shader_draw_parameters"
3981
3982
3983 #define VK_KHR_maintenance1 1
3984 #define VK_KHR_MAINTENANCE1_SPEC_VERSION  1
3985 #define VK_KHR_MAINTENANCE1_EXTENSION_NAME "VK_KHR_maintenance1"
3986
3987 typedef VkFlags VkCommandPoolTrimFlagsKHR;
3988
3989 typedef void (VKAPI_PTR *PFN_vkTrimCommandPoolKHR)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlagsKHR flags);
3990
3991 #ifndef VK_NO_PROTOTYPES
3992 VKAPI_ATTR void VKAPI_CALL vkTrimCommandPoolKHR(
3993     VkDevice                                    device,
3994     VkCommandPool                               commandPool,
3995     VkCommandPoolTrimFlagsKHR                   flags);
3996 #endif
3997
3998 #define VK_KHR_push_descriptor 1
3999 #define VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION 1
4000 #define VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME "VK_KHR_push_descriptor"
4001
4002 typedef struct VkPhysicalDevicePushDescriptorPropertiesKHR {
4003     VkStructureType    sType;
4004     void*              pNext;
4005     uint32_t           maxPushDescriptors;
4006 } VkPhysicalDevicePushDescriptorPropertiesKHR;
4007
4008
4009 typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetKHR)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites);
4010
4011 #ifndef VK_NO_PROTOTYPES
4012 VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetKHR(
4013     VkCommandBuffer                             commandBuffer,
4014     VkPipelineBindPoint                         pipelineBindPoint,
4015     VkPipelineLayout                            layout,
4016     uint32_t                                    set,
4017     uint32_t                                    descriptorWriteCount,
4018     const VkWriteDescriptorSet*                 pDescriptorWrites);
4019 #endif
4020
4021 #define VK_KHR_16bit_storage 1
4022 #define VK_KHR_16BIT_STORAGE_SPEC_VERSION 1
4023 #define VK_KHR_16BIT_STORAGE_EXTENSION_NAME "VK_KHR_16bit_storage"
4024
4025 typedef struct VkPhysicalDevice16BitStorageFeaturesKHR {
4026     VkStructureType    sType;
4027     void*              pNext;
4028     VkBool32           storageBuffer16BitAccess;
4029     VkBool32           uniformAndStorageBuffer16BitAccess;
4030     VkBool32           storagePushConstant16;
4031     VkBool32           storageInputOutput16;
4032 } VkPhysicalDevice16BitStorageFeaturesKHR;
4033
4034
4035
4036 #define VK_KHR_incremental_present 1
4037 #define VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION 1
4038 #define VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME "VK_KHR_incremental_present"
4039
4040 typedef struct VkRectLayerKHR {
4041     VkOffset2D    offset;
4042     VkExtent2D    extent;
4043     uint32_t      layer;
4044 } VkRectLayerKHR;
4045
4046 typedef struct VkPresentRegionKHR {
4047     uint32_t                 rectangleCount;
4048     const VkRectLayerKHR*    pRectangles;
4049 } VkPresentRegionKHR;
4050
4051 typedef struct VkPresentRegionsKHR {
4052     VkStructureType              sType;
4053     const void*                  pNext;
4054     uint32_t                     swapchainCount;
4055     const VkPresentRegionKHR*    pRegions;
4056 } VkPresentRegionsKHR;
4057
4058
4059
4060 #define VK_KHR_descriptor_update_template 1
4061 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorUpdateTemplateKHR)
4062
4063 #define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION 1
4064 #define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME "VK_KHR_descriptor_update_template"
4065
4066
4067 typedef enum VkDescriptorUpdateTemplateTypeKHR {
4068     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR = 0,
4069     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = 1,
4070     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_BEGIN_RANGE_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR,
4071     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_END_RANGE_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR,
4072     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_RANGE_SIZE_KHR = (VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR - VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR + 1),
4073     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF
4074 } VkDescriptorUpdateTemplateTypeKHR;
4075
4076 typedef VkFlags VkDescriptorUpdateTemplateCreateFlagsKHR;
4077
4078 typedef struct VkDescriptorUpdateTemplateEntryKHR {
4079     uint32_t            dstBinding;
4080     uint32_t            dstArrayElement;
4081     uint32_t            descriptorCount;
4082     VkDescriptorType    descriptorType;
4083     size_t              offset;
4084     size_t              stride;
4085 } VkDescriptorUpdateTemplateEntryKHR;
4086
4087 typedef struct VkDescriptorUpdateTemplateCreateInfoKHR {
4088     VkStructureType                              sType;
4089     void*                                        pNext;
4090     VkDescriptorUpdateTemplateCreateFlagsKHR     flags;
4091     uint32_t                                     descriptorUpdateEntryCount;
4092     const VkDescriptorUpdateTemplateEntryKHR*    pDescriptorUpdateEntries;
4093     VkDescriptorUpdateTemplateTypeKHR            templateType;
4094     VkDescriptorSetLayout                        descriptorSetLayout;
4095     VkPipelineBindPoint                          pipelineBindPoint;
4096     VkPipelineLayout                             pipelineLayout;
4097     uint32_t                                     set;
4098 } VkDescriptorUpdateTemplateCreateInfoKHR;
4099
4100
4101 typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplateKHR)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplateKHR* pDescriptorUpdateTemplate);
4102 typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplateKHR)(VkDevice device, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator);
4103 typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplateKHR)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, const void* pData);
4104 typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetWithTemplateKHR)(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData);
4105
4106 #ifndef VK_NO_PROTOTYPES
4107 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplateKHR(
4108     VkDevice                                    device,
4109     const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo,
4110     const VkAllocationCallbacks*                pAllocator,
4111     VkDescriptorUpdateTemplateKHR*              pDescriptorUpdateTemplate);
4112
4113 VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplateKHR(
4114     VkDevice                                    device,
4115     VkDescriptorUpdateTemplateKHR               descriptorUpdateTemplate,
4116     const VkAllocationCallbacks*                pAllocator);
4117
4118 VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplateKHR(
4119     VkDevice                                    device,
4120     VkDescriptorSet                             descriptorSet,
4121     VkDescriptorUpdateTemplateKHR               descriptorUpdateTemplate,
4122     const void*                                 pData);
4123
4124 VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplateKHR(
4125     VkCommandBuffer                             commandBuffer,
4126     VkDescriptorUpdateTemplateKHR               descriptorUpdateTemplate,
4127     VkPipelineLayout                            layout,
4128     uint32_t                                    set,
4129     const void*                                 pData);
4130 #endif
4131
4132 #define VK_KHR_shared_presentable_image 1
4133 #define VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION 1
4134 #define VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME "VK_KHR_shared_presentable_image"
4135
4136 typedef struct VkSharedPresentSurfaceCapabilitiesKHR {
4137     VkStructureType      sType;
4138     void*                pNext;
4139     VkImageUsageFlags    sharedPresentSupportedUsageFlags;
4140 } VkSharedPresentSurfaceCapabilitiesKHR;
4141
4142
4143 typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainStatusKHR)(VkDevice device, VkSwapchainKHR swapchain);
4144
4145 #ifndef VK_NO_PROTOTYPES
4146 VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainStatusKHR(
4147     VkDevice                                    device,
4148     VkSwapchainKHR                              swapchain);
4149 #endif
4150
4151 #define VK_KHR_maintenance2 1
4152 #define VK_KHR_MAINTENANCE2_SPEC_VERSION  1
4153 #define VK_KHR_MAINTENANCE2_EXTENSION_NAME "VK_KHR_maintenance2"
4154
4155
4156 typedef enum VkPointClippingBehaviorKHR {
4157     VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR = 0,
4158     VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR = 1,
4159     VK_POINT_CLIPPING_BEHAVIOR_BEGIN_RANGE_KHR = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR,
4160     VK_POINT_CLIPPING_BEHAVIOR_END_RANGE_KHR = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR,
4161     VK_POINT_CLIPPING_BEHAVIOR_RANGE_SIZE_KHR = (VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR - VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR + 1),
4162     VK_POINT_CLIPPING_BEHAVIOR_MAX_ENUM_KHR = 0x7FFFFFFF
4163 } VkPointClippingBehaviorKHR;
4164
4165 typedef enum VkTessellationDomainOriginKHR {
4166     VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR = 0,
4167     VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR = 1,
4168     VK_TESSELLATION_DOMAIN_ORIGIN_BEGIN_RANGE_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR,
4169     VK_TESSELLATION_DOMAIN_ORIGIN_END_RANGE_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR,
4170     VK_TESSELLATION_DOMAIN_ORIGIN_RANGE_SIZE_KHR = (VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR - VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR + 1),
4171     VK_TESSELLATION_DOMAIN_ORIGIN_MAX_ENUM_KHR = 0x7FFFFFFF
4172 } VkTessellationDomainOriginKHR;
4173
4174 typedef struct VkPhysicalDevicePointClippingPropertiesKHR {
4175     VkStructureType               sType;
4176     void*                         pNext;
4177     VkPointClippingBehaviorKHR    pointClippingBehavior;
4178 } VkPhysicalDevicePointClippingPropertiesKHR;
4179
4180 typedef struct VkInputAttachmentAspectReferenceKHR {
4181     uint32_t              subpass;
4182     uint32_t              inputAttachmentIndex;
4183     VkImageAspectFlags    aspectMask;
4184 } VkInputAttachmentAspectReferenceKHR;
4185
4186 typedef struct VkRenderPassInputAttachmentAspectCreateInfoKHR {
4187     VkStructureType                               sType;
4188     const void*                                   pNext;
4189     uint32_t                                      aspectReferenceCount;
4190     const VkInputAttachmentAspectReferenceKHR*    pAspectReferences;
4191 } VkRenderPassInputAttachmentAspectCreateInfoKHR;
4192
4193 typedef struct VkImageViewUsageCreateInfoKHR {
4194     VkStructureType      sType;
4195     const void*          pNext;
4196     VkImageUsageFlags    usage;
4197 } VkImageViewUsageCreateInfoKHR;
4198
4199 typedef struct VkPipelineTessellationDomainOriginStateCreateInfoKHR {
4200     VkStructureType                  sType;
4201     const void*                      pNext;
4202     VkTessellationDomainOriginKHR    domainOrigin;
4203 } VkPipelineTessellationDomainOriginStateCreateInfoKHR;
4204
4205 #define VK_KHR_get_surface_capabilities2 1
4206 #define VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION 1
4207 #define VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME "VK_KHR_get_surface_capabilities2"
4208
4209 typedef struct VkPhysicalDeviceSurfaceInfo2KHR {
4210     VkStructureType    sType;
4211     const void*        pNext;
4212     VkSurfaceKHR       surface;
4213 } VkPhysicalDeviceSurfaceInfo2KHR;
4214
4215 typedef struct VkSurfaceCapabilities2KHR {
4216     VkStructureType             sType;
4217     void*                       pNext;
4218     VkSurfaceCapabilitiesKHR    surfaceCapabilities;
4219 } VkSurfaceCapabilities2KHR;
4220
4221 typedef struct VkSurfaceFormat2KHR {
4222     VkStructureType       sType;
4223     void*                 pNext;
4224     VkSurfaceFormatKHR    surfaceFormat;
4225 } VkSurfaceFormat2KHR;
4226
4227
4228 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities);
4229 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormats2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats);
4230
4231 #ifndef VK_NO_PROTOTYPES
4232 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2KHR(
4233     VkPhysicalDevice                            physicalDevice,
4234     const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
4235     VkSurfaceCapabilities2KHR*                  pSurfaceCapabilities);
4236
4237 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormats2KHR(
4238     VkPhysicalDevice                            physicalDevice,
4239     const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
4240     uint32_t*                                   pSurfaceFormatCount,
4241     VkSurfaceFormat2KHR*                        pSurfaceFormats);
4242 #endif
4243
4244 #define VK_KHR_external_fence_capabilities 1
4245 #define VK_LUID_SIZE_KHR                  8
4246 #define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION 1
4247 #define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_fence_capabilities"
4248
4249
4250 typedef enum VkExternalFenceHandleTypeFlagBitsKHR {
4251     VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = 0x00000001,
4252     VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = 0x00000002,
4253     VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = 0x00000004,
4254     VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR = 0x00000008,
4255     VK_EXTERNAL_FENCE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
4256 } VkExternalFenceHandleTypeFlagBitsKHR;
4257 typedef VkFlags VkExternalFenceHandleTypeFlagsKHR;
4258
4259 typedef enum VkExternalFenceFeatureFlagBitsKHR {
4260     VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR = 0x00000001,
4261     VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR = 0x00000002,
4262     VK_EXTERNAL_FENCE_FEATURE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
4263 } VkExternalFenceFeatureFlagBitsKHR;
4264 typedef VkFlags VkExternalFenceFeatureFlagsKHR;
4265
4266 typedef struct VkPhysicalDeviceExternalFenceInfoKHR {
4267     VkStructureType                         sType;
4268     const void*                             pNext;
4269     VkExternalFenceHandleTypeFlagBitsKHR    handleType;
4270 } VkPhysicalDeviceExternalFenceInfoKHR;
4271
4272 typedef struct VkExternalFencePropertiesKHR {
4273     VkStructureType                      sType;
4274     void*                                pNext;
4275     VkExternalFenceHandleTypeFlagsKHR    exportFromImportedHandleTypes;
4276     VkExternalFenceHandleTypeFlagsKHR    compatibleHandleTypes;
4277     VkExternalFenceFeatureFlagsKHR       externalFenceFeatures;
4278 } VkExternalFencePropertiesKHR;
4279
4280 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo, VkExternalFencePropertiesKHR* pExternalFenceProperties);
4281
4282 #ifndef VK_NO_PROTOTYPES
4283 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFencePropertiesKHR(
4284     VkPhysicalDevice                            physicalDevice,
4285     const VkPhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo,
4286     VkExternalFencePropertiesKHR*               pExternalFenceProperties);
4287 #endif
4288
4289 #define VK_KHR_external_fence 1
4290 #define VK_KHR_EXTERNAL_FENCE_SPEC_VERSION 1
4291 #define VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME "VK_KHR_external_fence"
4292
4293
4294 typedef enum VkFenceImportFlagBitsKHR {
4295     VK_FENCE_IMPORT_TEMPORARY_BIT_KHR = 0x00000001,
4296     VK_FENCE_IMPORT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
4297 } VkFenceImportFlagBitsKHR;
4298 typedef VkFlags VkFenceImportFlagsKHR;
4299
4300 typedef struct VkExportFenceCreateInfoKHR {
4301     VkStructureType                      sType;
4302     const void*                          pNext;
4303     VkExternalFenceHandleTypeFlagsKHR    handleTypes;
4304 } VkExportFenceCreateInfoKHR;
4305
4306
4307
4308 #ifdef VK_USE_PLATFORM_WIN32_KHR
4309 #define VK_KHR_external_fence_win32 1
4310 #define VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION 1
4311 #define VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME "VK_KHR_external_fence_win32"
4312
4313 typedef struct VkImportFenceWin32HandleInfoKHR {
4314     VkStructureType                         sType;
4315     const void*                             pNext;
4316     VkFence                                 fence;
4317     VkFenceImportFlagsKHR                   flags;
4318     VkExternalFenceHandleTypeFlagBitsKHR    handleType;
4319     HANDLE                                  handle;
4320     LPCWSTR                                 name;
4321 } VkImportFenceWin32HandleInfoKHR;
4322
4323 typedef struct VkExportFenceWin32HandleInfoKHR {
4324     VkStructureType               sType;
4325     const void*                   pNext;
4326     const SECURITY_ATTRIBUTES*    pAttributes;
4327     DWORD                         dwAccess;
4328     LPCWSTR                       name;
4329 } VkExportFenceWin32HandleInfoKHR;
4330
4331 typedef struct VkFenceGetWin32HandleInfoKHR {
4332     VkStructureType                         sType;
4333     const void*                             pNext;
4334     VkFence                                 fence;
4335     VkExternalFenceHandleTypeFlagBitsKHR    handleType;
4336 } VkFenceGetWin32HandleInfoKHR;
4337
4338
4339 typedef VkResult (VKAPI_PTR *PFN_vkImportFenceWin32HandleKHR)(VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo);
4340 typedef VkResult (VKAPI_PTR *PFN_vkGetFenceWin32HandleKHR)(VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
4341
4342 #ifndef VK_NO_PROTOTYPES
4343 VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceWin32HandleKHR(
4344     VkDevice                                    device,
4345     const VkImportFenceWin32HandleInfoKHR*      pImportFenceWin32HandleInfo);
4346
4347 VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceWin32HandleKHR(
4348     VkDevice                                    device,
4349     const VkFenceGetWin32HandleInfoKHR*         pGetWin32HandleInfo,
4350     HANDLE*                                     pHandle);
4351 #endif
4352 #endif /* VK_USE_PLATFORM_WIN32_KHR */
4353
4354 #define VK_KHR_external_fence_fd 1
4355 #define VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION 1
4356 #define VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME "VK_KHR_external_fence_fd"
4357
4358 typedef struct VkImportFenceFdInfoKHR {
4359     VkStructureType                         sType;
4360     const void*                             pNext;
4361     VkFence                                 fence;
4362     VkFenceImportFlagsKHR                   flags;
4363     VkExternalFenceHandleTypeFlagBitsKHR    handleType;
4364     int                                     fd;
4365 } VkImportFenceFdInfoKHR;
4366
4367 typedef struct VkFenceGetFdInfoKHR {
4368     VkStructureType                         sType;
4369     const void*                             pNext;
4370     VkFence                                 fence;
4371     VkExternalFenceHandleTypeFlagBitsKHR    handleType;
4372 } VkFenceGetFdInfoKHR;
4373
4374
4375 typedef VkResult (VKAPI_PTR *PFN_vkImportFenceFdKHR)(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo);
4376 typedef VkResult (VKAPI_PTR *PFN_vkGetFenceFdKHR)(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd);
4377
4378 #ifndef VK_NO_PROTOTYPES
4379 VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceFdKHR(
4380     VkDevice                                    device,
4381     const VkImportFenceFdInfoKHR*               pImportFenceFdInfo);
4382
4383 VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceFdKHR(
4384     VkDevice                                    device,
4385     const VkFenceGetFdInfoKHR*                  pGetFdInfo,
4386     int*                                        pFd);
4387 #endif
4388
4389 #define VK_KHR_dedicated_allocation 1
4390 #define VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION 1
4391 #define VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_KHR_dedicated_allocation"
4392
4393 typedef struct VkMemoryDedicatedRequirementsKHR {
4394     VkStructureType    sType;
4395     void*              pNext;
4396     VkBool32           prefersDedicatedAllocation;
4397     VkBool32           requiresDedicatedAllocation;
4398 } VkMemoryDedicatedRequirementsKHR;
4399
4400 typedef struct VkMemoryDedicatedAllocateInfoKHR {
4401     VkStructureType    sType;
4402     const void*        pNext;
4403     VkImage            image;
4404     VkBuffer           buffer;
4405 } VkMemoryDedicatedAllocateInfoKHR;
4406
4407
4408 #define VK_KHR_get_memory_requirements2 1
4409 #define VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION 1
4410 #define VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME "VK_KHR_get_memory_requirements2"
4411
4412 typedef struct VkBufferMemoryRequirementsInfo2KHR {
4413     VkStructureType    sType;
4414     const void*        pNext;
4415     VkBuffer           buffer;
4416 } VkBufferMemoryRequirementsInfo2KHR;
4417
4418 typedef struct VkImageMemoryRequirementsInfo2KHR {
4419     VkStructureType    sType;
4420     const void*        pNext;
4421     VkImage            image;
4422 } VkImageMemoryRequirementsInfo2KHR;
4423
4424 typedef struct VkImageSparseMemoryRequirementsInfo2KHR {
4425     VkStructureType    sType;
4426     const void*        pNext;
4427     VkImage            image;
4428 } VkImageSparseMemoryRequirementsInfo2KHR;
4429
4430 typedef struct VkMemoryRequirements2KHR {
4431     VkStructureType         sType;
4432     void*                   pNext;
4433     VkMemoryRequirements    memoryRequirements;
4434 } VkMemoryRequirements2KHR;
4435
4436 typedef struct VkSparseImageMemoryRequirements2KHR {
4437     VkStructureType                    sType;
4438     void*                              pNext;
4439     VkSparseImageMemoryRequirements    memoryRequirements;
4440 } VkSparseImageMemoryRequirements2KHR;
4441
4442
4443 typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2KHR)(VkDevice device, const VkImageMemoryRequirementsInfo2KHR* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements);
4444 typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2KHR)(VkDevice device, const VkBufferMemoryRequirementsInfo2KHR* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements);
4445 typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements2KHR)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2KHR* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2KHR* pSparseMemoryRequirements);
4446
4447 #ifndef VK_NO_PROTOTYPES
4448 VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2KHR(
4449     VkDevice                                    device,
4450     const VkImageMemoryRequirementsInfo2KHR*    pInfo,
4451     VkMemoryRequirements2KHR*                   pMemoryRequirements);
4452
4453 VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2KHR(
4454     VkDevice                                    device,
4455     const VkBufferMemoryRequirementsInfo2KHR*   pInfo,
4456     VkMemoryRequirements2KHR*                   pMemoryRequirements);
4457
4458 VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2KHR(
4459     VkDevice                                    device,
4460     const VkImageSparseMemoryRequirementsInfo2KHR* pInfo,
4461     uint32_t*                                   pSparseMemoryRequirementCount,
4462     VkSparseImageMemoryRequirements2KHR*        pSparseMemoryRequirements);
4463 #endif
4464
4465 #define VK_KHR_image_format_list 1
4466 #define VK_KHR_IMAGE_FORMAT_LIST_SPEC_VERSION 1
4467 #define VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME "VK_KHR_image_format_list"
4468
4469 typedef struct VkImageFormatListCreateInfoKHR {
4470     VkStructureType    sType;
4471     const void*        pNext;
4472     uint32_t           viewFormatCount;
4473     const VkFormat*    pViewFormats;
4474 } VkImageFormatListCreateInfoKHR;
4475
4476 #define VK_EXT_debug_report 1
4477 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT)
4478
4479 #define VK_EXT_DEBUG_REPORT_SPEC_VERSION  6
4480 #define VK_EXT_DEBUG_REPORT_EXTENSION_NAME "VK_EXT_debug_report"
4481 #define VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT
4482
4483
4484 typedef enum VkDebugReportObjectTypeEXT {
4485     VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0,
4486     VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1,
4487     VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2,
4488     VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3,
4489     VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4,
4490     VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5,
4491     VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6,
4492     VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7,
4493     VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8,
4494     VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9,
4495     VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10,
4496     VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11,
4497     VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12,
4498     VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13,
4499     VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14,
4500     VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15,
4501     VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16,
4502     VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17,
4503     VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18,
4504     VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19,
4505     VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20,
4506     VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21,
4507     VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22,
4508     VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23,
4509     VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24,
4510     VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25,
4511     VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26,
4512     VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27,
4513     VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = 28,
4514     VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT = 29,
4515     VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT = 30,
4516     VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT = 1000085000,
4517     VK_DEBUG_REPORT_OBJECT_TYPE_BEGIN_RANGE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT,
4518     VK_DEBUG_REPORT_OBJECT_TYPE_END_RANGE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT,
4519     VK_DEBUG_REPORT_OBJECT_TYPE_RANGE_SIZE_EXT = (VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT - VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT + 1),
4520     VK_DEBUG_REPORT_OBJECT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
4521 } VkDebugReportObjectTypeEXT;
4522
4523 typedef enum VkDebugReportErrorEXT {
4524     VK_DEBUG_REPORT_ERROR_NONE_EXT = 0,
4525     VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT = 1,
4526     VK_DEBUG_REPORT_ERROR_BEGIN_RANGE_EXT = VK_DEBUG_REPORT_ERROR_NONE_EXT,
4527     VK_DEBUG_REPORT_ERROR_END_RANGE_EXT = VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT,
4528     VK_DEBUG_REPORT_ERROR_RANGE_SIZE_EXT = (VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT - VK_DEBUG_REPORT_ERROR_NONE_EXT + 1),
4529     VK_DEBUG_REPORT_ERROR_MAX_ENUM_EXT = 0x7FFFFFFF
4530 } VkDebugReportErrorEXT;
4531
4532
4533 typedef enum VkDebugReportFlagBitsEXT {
4534     VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 0x00000001,
4535     VK_DEBUG_REPORT_WARNING_BIT_EXT = 0x00000002,
4536     VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 0x00000004,
4537     VK_DEBUG_REPORT_ERROR_BIT_EXT = 0x00000008,
4538     VK_DEBUG_REPORT_DEBUG_BIT_EXT = 0x00000010,
4539     VK_DEBUG_REPORT_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
4540 } VkDebugReportFlagBitsEXT;
4541 typedef VkFlags VkDebugReportFlagsEXT;
4542
4543 typedef VkBool32 (VKAPI_PTR *PFN_vkDebugReportCallbackEXT)(
4544     VkDebugReportFlagsEXT                       flags,
4545     VkDebugReportObjectTypeEXT                  objectType,
4546     uint64_t                                    object,
4547     size_t                                      location,
4548     int32_t                                     messageCode,
4549     const char*                                 pLayerPrefix,
4550     const char*                                 pMessage,
4551     void*                                       pUserData);
4552
4553
4554 typedef struct VkDebugReportCallbackCreateInfoEXT {
4555     VkStructureType                 sType;
4556     const void*                     pNext;
4557     VkDebugReportFlagsEXT           flags;
4558     PFN_vkDebugReportCallbackEXT    pfnCallback;
4559     void*                           pUserData;
4560 } VkDebugReportCallbackCreateInfoEXT;
4561
4562
4563 typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugReportCallbackEXT)(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback);
4564 typedef void (VKAPI_PTR *PFN_vkDestroyDebugReportCallbackEXT)(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator);
4565 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);
4566
4567 #ifndef VK_NO_PROTOTYPES
4568 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT(
4569     VkInstance                                  instance,
4570     const VkDebugReportCallbackCreateInfoEXT*   pCreateInfo,
4571     const VkAllocationCallbacks*                pAllocator,
4572     VkDebugReportCallbackEXT*                   pCallback);
4573
4574 VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT(
4575     VkInstance                                  instance,
4576     VkDebugReportCallbackEXT                    callback,
4577     const VkAllocationCallbacks*                pAllocator);
4578
4579 VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT(
4580     VkInstance                                  instance,
4581     VkDebugReportFlagsEXT                       flags,
4582     VkDebugReportObjectTypeEXT                  objectType,
4583     uint64_t                                    object,
4584     size_t                                      location,
4585     int32_t                                     messageCode,
4586     const char*                                 pLayerPrefix,
4587     const char*                                 pMessage);
4588 #endif
4589
4590
4591 #define VK_KHX_multiview 1
4592 #define VK_KHX_MULTIVIEW_SPEC_VERSION     1
4593 #define VK_KHX_MULTIVIEW_EXTENSION_NAME   "VK_KHX_multiview"
4594
4595 typedef struct VkRenderPassMultiviewCreateInfoKHX {
4596     VkStructureType    sType;
4597     const void*        pNext;
4598     uint32_t           subpassCount;
4599     const uint32_t*    pViewMasks;
4600     uint32_t           dependencyCount;
4601     const int32_t*     pViewOffsets;
4602     uint32_t           correlationMaskCount;
4603     const uint32_t*    pCorrelationMasks;
4604 } VkRenderPassMultiviewCreateInfoKHX;
4605
4606 typedef struct VkPhysicalDeviceMultiviewFeaturesKHX {
4607     VkStructureType    sType;
4608     void*              pNext;
4609     VkBool32           multiview;
4610     VkBool32           multiviewGeometryShader;
4611     VkBool32           multiviewTessellationShader;
4612 } VkPhysicalDeviceMultiviewFeaturesKHX;
4613
4614 typedef struct VkPhysicalDeviceMultiviewPropertiesKHX {
4615     VkStructureType    sType;
4616     void*              pNext;
4617     uint32_t           maxMultiviewViewCount;
4618     uint32_t           maxMultiviewInstanceIndex;
4619 } VkPhysicalDeviceMultiviewPropertiesKHX;
4620
4621
4622 #define VK_KHR_external_memory_capabilities 1
4623 #define VK_LUID_SIZE_KHR                  8
4624 #define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1
4625 #define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_memory_capabilities"
4626
4627 typedef enum VkExternalMemoryHandleTypeFlagBitsKHR {
4628     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = 0x00000001,
4629     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = 0x00000002,
4630     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = 0x00000004,
4631     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR = 0x00000008,
4632     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR = 0x00000010,
4633     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR = 0x00000020,
4634     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR = 0x00000040,
4635     VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
4636 } VkExternalMemoryHandleTypeFlagBitsKHR;
4637 typedef VkFlags VkExternalMemoryHandleTypeFlagsKHR;
4638
4639 typedef enum VkExternalMemoryFeatureFlagBitsKHR {
4640     VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR = 0x00000001,
4641     VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR = 0x00000002,
4642     VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR = 0x00000004,
4643     VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
4644 } VkExternalMemoryFeatureFlagBitsKHR;
4645 typedef VkFlags VkExternalMemoryFeatureFlagsKHR;
4646
4647 typedef struct VkExternalMemoryPropertiesKHR {
4648     VkExternalMemoryFeatureFlagsKHR       externalMemoryFeatures;
4649     VkExternalMemoryHandleTypeFlagsKHR    exportFromImportedHandleTypes;
4650     VkExternalMemoryHandleTypeFlagsKHR    compatibleHandleTypes;
4651 } VkExternalMemoryPropertiesKHR;
4652
4653 typedef struct VkPhysicalDeviceExternalImageFormatInfoKHR {
4654     VkStructureType                          sType;
4655     const void*                              pNext;
4656     VkExternalMemoryHandleTypeFlagBitsKHR    handleType;
4657 } VkPhysicalDeviceExternalImageFormatInfoKHR;
4658
4659 typedef struct VkExternalImageFormatPropertiesKHR {
4660     VkStructureType                  sType;
4661     void*                            pNext;
4662     VkExternalMemoryPropertiesKHR    externalMemoryProperties;
4663 } VkExternalImageFormatPropertiesKHR;
4664
4665 typedef struct VkPhysicalDeviceExternalBufferInfoKHR {
4666     VkStructureType                          sType;
4667     const void*                              pNext;
4668     VkBufferCreateFlags                      flags;
4669     VkBufferUsageFlags                       usage;
4670     VkExternalMemoryHandleTypeFlagBitsKHR    handleType;
4671 } VkPhysicalDeviceExternalBufferInfoKHR;
4672
4673 typedef struct VkExternalBufferPropertiesKHR {
4674     VkStructureType                  sType;
4675     void*                            pNext;
4676     VkExternalMemoryPropertiesKHR    externalMemoryProperties;
4677 } VkExternalBufferPropertiesKHR;
4678
4679 typedef struct VkPhysicalDeviceIDPropertiesKHR {
4680     VkStructureType    sType;
4681     void*              pNext;
4682     uint8_t            deviceUUID[VK_UUID_SIZE];
4683     uint8_t            driverUUID[VK_UUID_SIZE];
4684     uint8_t            deviceLUID[VK_LUID_SIZE_KHR];
4685     uint32_t           deviceNodeMask;
4686     VkBool32           deviceLUIDValid;
4687 } VkPhysicalDeviceIDPropertiesKHR;
4688
4689
4690 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo, VkExternalBufferPropertiesKHR* pExternalBufferProperties);
4691
4692 #ifndef VK_NO_PROTOTYPES
4693 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferPropertiesKHR(
4694     VkPhysicalDevice                            physicalDevice,
4695     const VkPhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo,
4696     VkExternalBufferPropertiesKHR*              pExternalBufferProperties);
4697 #endif
4698
4699 #define VK_KHR_external_memory 1
4700 #define VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION 1
4701 #define VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME "VK_KHR_external_memory"
4702 #define VK_QUEUE_FAMILY_EXTERNAL_KHR      (~0U-1)
4703
4704 typedef struct VkExternalMemoryImageCreateInfoKHR {
4705     VkStructureType                       sType;
4706     const void*                           pNext;
4707     VkExternalMemoryHandleTypeFlagsKHR    handleTypes;
4708 } VkExternalMemoryImageCreateInfoKHR;
4709
4710 typedef struct VkExternalMemoryBufferCreateInfoKHR {
4711     VkStructureType                       sType;
4712     const void*                           pNext;
4713     VkExternalMemoryHandleTypeFlagsKHR    handleTypes;
4714 } VkExternalMemoryBufferCreateInfoKHR;
4715
4716 typedef struct VkExportMemoryAllocateInfoKHR {
4717     VkStructureType                       sType;
4718     const void*                           pNext;
4719     VkExternalMemoryHandleTypeFlagsKHR    handleTypes;
4720 } VkExportMemoryAllocateInfoKHR;
4721
4722
4723
4724 #ifdef VK_USE_PLATFORM_WIN32_KHR
4725 #define VK_KHR_external_memory_win32 1
4726 #define VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
4727 #define VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_KHR_external_memory_win32"
4728
4729 typedef struct VkImportMemoryWin32HandleInfoKHR {
4730     VkStructureType                          sType;
4731     const void*                              pNext;
4732     VkExternalMemoryHandleTypeFlagBitsKHR    handleType;
4733     HANDLE                                   handle;
4734     LPCWSTR                                  name;
4735 } VkImportMemoryWin32HandleInfoKHR;
4736
4737 typedef struct VkExportMemoryWin32HandleInfoKHR {
4738     VkStructureType               sType;
4739     const void*                   pNext;
4740     const SECURITY_ATTRIBUTES*    pAttributes;
4741     DWORD                         dwAccess;
4742     LPCWSTR                       name;
4743 } VkExportMemoryWin32HandleInfoKHR;
4744
4745 typedef struct VkMemoryWin32HandlePropertiesKHR {
4746     VkStructureType    sType;
4747     void*              pNext;
4748     uint32_t           memoryTypeBits;
4749 } VkMemoryWin32HandlePropertiesKHR;
4750
4751 typedef struct VkMemoryGetWin32HandleInfoKHR {
4752     VkStructureType                          sType;
4753     const void*                              pNext;
4754     VkDeviceMemory                           memory;
4755     VkExternalMemoryHandleTypeFlagBitsKHR    handleType;
4756 } VkMemoryGetWin32HandleInfoKHR;
4757
4758
4759 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleKHR)(VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
4760 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHR handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties);
4761
4762 #ifndef VK_NO_PROTOTYPES
4763 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR(
4764     VkDevice                                    device,
4765     const VkMemoryGetWin32HandleInfoKHR*        pGetWin32HandleInfo,
4766     HANDLE*                                     pHandle);
4767
4768 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR(
4769     VkDevice                                    device,
4770     VkExternalMemoryHandleTypeFlagBitsKHR       handleType,
4771     HANDLE                                      handle,
4772     VkMemoryWin32HandlePropertiesKHR*           pMemoryWin32HandleProperties);
4773 #endif
4774 #endif /* VK_USE_PLATFORM_WIN32_KHR */
4775
4776 #define VK_KHR_external_memory_fd 1
4777 #define VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION 1
4778 #define VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME "VK_KHR_external_memory_fd"
4779
4780 typedef struct VkImportMemoryFdInfoKHR {
4781     VkStructureType                          sType;
4782     const void*                              pNext;
4783     VkExternalMemoryHandleTypeFlagBitsKHR    handleType;
4784     int                                      fd;
4785 } VkImportMemoryFdInfoKHR;
4786
4787 typedef struct VkMemoryFdPropertiesKHR {
4788     VkStructureType    sType;
4789     void*              pNext;
4790     uint32_t           memoryTypeBits;
4791 } VkMemoryFdPropertiesKHR;
4792
4793 typedef struct VkMemoryGetFdInfoKHR {
4794     VkStructureType                          sType;
4795     const void*                              pNext;
4796     VkDeviceMemory                           memory;
4797     VkExternalMemoryHandleTypeFlagBitsKHR    handleType;
4798 } VkMemoryGetFdInfoKHR;
4799
4800
4801 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdKHR)(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd);
4802 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdPropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHR handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties);
4803
4804 #ifndef VK_NO_PROTOTYPES
4805 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdKHR(
4806     VkDevice                                    device,
4807     const VkMemoryGetFdInfoKHR*                 pGetFdInfo,
4808     int*                                        pFd);
4809
4810 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdPropertiesKHR(
4811     VkDevice                                    device,
4812     VkExternalMemoryHandleTypeFlagBitsKHR       handleType,
4813     int                                         fd,
4814     VkMemoryFdPropertiesKHR*                    pMemoryFdProperties);
4815 #endif
4816
4817 #ifdef VK_USE_PLATFORM_WIN32_KHR
4818 #define VK_KHR_win32_keyed_mutex 1
4819 #define VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION 1
4820 #define VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_KHR_win32_keyed_mutex"
4821
4822 typedef struct VkWin32KeyedMutexAcquireReleaseInfoKHR {
4823     VkStructureType          sType;
4824     const void*              pNext;
4825     uint32_t                 acquireCount;
4826     const VkDeviceMemory*    pAcquireSyncs;
4827     const uint64_t*          pAcquireKeys;
4828     const uint32_t*          pAcquireTimeouts;
4829     uint32_t                 releaseCount;
4830     const VkDeviceMemory*    pReleaseSyncs;
4831     const uint64_t*          pReleaseKeys;
4832 } VkWin32KeyedMutexAcquireReleaseInfoKHR;
4833
4834
4835 #endif /* VK_USE_PLATFORM_WIN32_KHR */
4836
4837 #define VK_KHR_external_semaphore_capabilities 1
4838 #define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION 1
4839 #define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_semaphore_capabilities"
4840
4841
4842 typedef enum VkExternalSemaphoreHandleTypeFlagBitsKHR {
4843     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = 0x00000001,
4844     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = 0x00000002,
4845     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = 0x00000004,
4846     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR = 0x00000008,
4847     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR = 0x00000010,
4848     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
4849 } VkExternalSemaphoreHandleTypeFlagBitsKHR;
4850 typedef VkFlags VkExternalSemaphoreHandleTypeFlagsKHR;
4851
4852 typedef enum VkExternalSemaphoreFeatureFlagBitsKHR {
4853     VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR = 0x00000001,
4854     VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR = 0x00000002,
4855     VK_EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
4856 } VkExternalSemaphoreFeatureFlagBitsKHR;
4857 typedef VkFlags VkExternalSemaphoreFeatureFlagsKHR;
4858
4859 typedef struct VkPhysicalDeviceExternalSemaphoreInfoKHR {
4860     VkStructureType                             sType;
4861     const void*                                 pNext;
4862     VkExternalSemaphoreHandleTypeFlagBitsKHR    handleType;
4863 } VkPhysicalDeviceExternalSemaphoreInfoKHR;
4864
4865 typedef struct VkExternalSemaphorePropertiesKHR {
4866     VkStructureType                          sType;
4867     void*                                    pNext;
4868     VkExternalSemaphoreHandleTypeFlagsKHR    exportFromImportedHandleTypes;
4869     VkExternalSemaphoreHandleTypeFlagsKHR    compatibleHandleTypes;
4870     VkExternalSemaphoreFeatureFlagsKHR       externalSemaphoreFeatures;
4871 } VkExternalSemaphorePropertiesKHR;
4872
4873
4874 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo, VkExternalSemaphorePropertiesKHR* pExternalSemaphoreProperties);
4875
4876 #ifndef VK_NO_PROTOTYPES
4877 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
4878     VkPhysicalDevice                            physicalDevice,
4879     const VkPhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo,
4880     VkExternalSemaphorePropertiesKHR*           pExternalSemaphoreProperties);
4881 #endif
4882
4883 #define VK_KHR_external_semaphore 1
4884 #define VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION 1
4885 #define VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME "VK_KHR_external_semaphore"
4886
4887
4888 typedef enum VkSemaphoreImportFlagBitsKHR {
4889     VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR = 0x00000001,
4890     VK_SEMAPHORE_IMPORT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
4891 } VkSemaphoreImportFlagBitsKHR;
4892 typedef VkFlags VkSemaphoreImportFlagsKHR;
4893
4894 typedef struct VkExportSemaphoreCreateInfoKHR {
4895     VkStructureType                          sType;
4896     const void*                              pNext;
4897     VkExternalSemaphoreHandleTypeFlagsKHR    handleTypes;
4898 } VkExportSemaphoreCreateInfoKHR;
4899
4900
4901
4902 #ifdef VK_USE_PLATFORM_WIN32_KHR
4903 #define VK_KHR_external_semaphore_win32 1
4904 #define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION 1
4905 #define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME "VK_KHR_external_semaphore_win32"
4906
4907 typedef struct VkImportSemaphoreWin32HandleInfoKHR {
4908     VkStructureType                             sType;
4909     const void*                                 pNext;
4910     VkSemaphore                                 semaphore;
4911     VkSemaphoreImportFlagsKHR                   flags;
4912     VkExternalSemaphoreHandleTypeFlagBitsKHR    handleType;
4913     HANDLE                                      handle;
4914     LPCWSTR                                     name;
4915 } VkImportSemaphoreWin32HandleInfoKHR;
4916
4917 typedef struct VkExportSemaphoreWin32HandleInfoKHR {
4918     VkStructureType               sType;
4919     const void*                   pNext;
4920     const SECURITY_ATTRIBUTES*    pAttributes;
4921     DWORD                         dwAccess;
4922     LPCWSTR                       name;
4923 } VkExportSemaphoreWin32HandleInfoKHR;
4924
4925 typedef struct VkD3D12FenceSubmitInfoKHR {
4926     VkStructureType    sType;
4927     const void*        pNext;
4928     uint32_t           waitSemaphoreValuesCount;
4929     const uint64_t*    pWaitSemaphoreValues;
4930     uint32_t           signalSemaphoreValuesCount;
4931     const uint64_t*    pSignalSemaphoreValues;
4932 } VkD3D12FenceSubmitInfoKHR;
4933
4934 typedef struct VkSemaphoreGetWin32HandleInfoKHR {
4935     VkStructureType                             sType;
4936     const void*                                 pNext;
4937     VkSemaphore                                 semaphore;
4938     VkExternalSemaphoreHandleTypeFlagBitsKHR    handleType;
4939 } VkSemaphoreGetWin32HandleInfoKHR;
4940
4941
4942 typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreWin32HandleKHR)(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo);
4943 typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreWin32HandleKHR)(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
4944
4945 #ifndef VK_NO_PROTOTYPES
4946 VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHR(
4947     VkDevice                                    device,
4948     const VkImportSemaphoreWin32HandleInfoKHR*  pImportSemaphoreWin32HandleInfo);
4949
4950 VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHR(
4951     VkDevice                                    device,
4952     const VkSemaphoreGetWin32HandleInfoKHR*     pGetWin32HandleInfo,
4953     HANDLE*                                     pHandle);
4954 #endif
4955 #endif /* VK_USE_PLATFORM_WIN32_KHR */
4956
4957 #define VK_KHR_external_semaphore_fd 1
4958 #define VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION 1
4959 #define VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME "VK_KHR_external_semaphore_fd"
4960
4961 typedef struct VkImportSemaphoreFdInfoKHR {
4962     VkStructureType                             sType;
4963     const void*                                 pNext;
4964     VkSemaphore                                 semaphore;
4965     VkSemaphoreImportFlagsKHR                   flags;
4966     VkExternalSemaphoreHandleTypeFlagBitsKHR    handleType;
4967     int                                         fd;
4968 } VkImportSemaphoreFdInfoKHR;
4969
4970 typedef struct VkSemaphoreGetFdInfoKHR {
4971     VkStructureType                             sType;
4972     const void*                                 pNext;
4973     VkSemaphore                                 semaphore;
4974     VkExternalSemaphoreHandleTypeFlagBitsKHR    handleType;
4975 } VkSemaphoreGetFdInfoKHR;
4976
4977
4978 typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreFdKHR)(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo);
4979 typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreFdKHR)(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd);
4980
4981 #ifndef VK_NO_PROTOTYPES
4982 VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreFdKHR(
4983     VkDevice                                    device,
4984     const VkImportSemaphoreFdInfoKHR*           pImportSemaphoreFdInfo);
4985
4986 VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreFdKHR(
4987     VkDevice                                    device,
4988     const VkSemaphoreGetFdInfoKHR*              pGetFdInfo,
4989     int*                                        pFd);
4990 #endif
4991
4992 #define VK_GOOGLE_display_timing 1
4993 #define VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION 1
4994 #define VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME "VK_GOOGLE_display_timing"
4995
4996 typedef struct VkRefreshCycleDurationGOOGLE {
4997     uint64_t    refreshDuration;
4998 } VkRefreshCycleDurationGOOGLE;
4999
5000 typedef struct VkPastPresentationTimingGOOGLE {
5001     uint32_t    presentID;
5002     uint64_t    desiredPresentTime;
5003     uint64_t    actualPresentTime;
5004     uint64_t    earliestPresentTime;
5005     uint64_t    presentMargin;
5006 } VkPastPresentationTimingGOOGLE;
5007
5008 typedef struct VkPresentTimeGOOGLE {
5009     uint32_t    presentID;
5010     uint64_t    desiredPresentTime;
5011 } VkPresentTimeGOOGLE;
5012
5013 typedef struct VkPresentTimesInfoGOOGLE {
5014     VkStructureType               sType;
5015     const void*                   pNext;
5016     uint32_t                      swapchainCount;
5017     const VkPresentTimeGOOGLE*    pTimes;
5018 } VkPresentTimesInfoGOOGLE;
5019
5020
5021 typedef VkResult (VKAPI_PTR *PFN_vkGetRefreshCycleDurationGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties);
5022 typedef VkResult (VKAPI_PTR *PFN_vkGetPastPresentationTimingGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings);
5023
5024 #ifndef VK_NO_PROTOTYPES
5025 VKAPI_ATTR VkResult VKAPI_CALL vkGetRefreshCycleDurationGOOGLE(
5026     VkDevice                                    device,
5027     VkSwapchainKHR                              swapchain,
5028     VkRefreshCycleDurationGOOGLE*               pDisplayTimingProperties);
5029
5030 VKAPI_ATTR VkResult VKAPI_CALL vkGetPastPresentationTimingGOOGLE(
5031     VkDevice                                    device,
5032     VkSwapchainKHR                              swapchain,
5033     uint32_t*                                   pPresentationTimingCount,
5034     VkPastPresentationTimingGOOGLE*             pPresentationTimings);
5035 #endif
5036
5037 #define VK_EXT_swapchain_colorspace 1
5038 #define VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION 2
5039 #define VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME "VK_EXT_swapchain_colorspace"
5040
5041 #define VK_KHR_variable_pointers 1
5042 #define VK_KHR_VARIABLE_POINTERS_SPEC_VERSION 1
5043 #define VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME "VK_KHR_variable_pointers"
5044
5045 typedef struct VkPhysicalDeviceVariablePointerFeaturesKHR {
5046     VkStructureType    sType;
5047     const void*        pNext;
5048     VkBool32           variablePointersStorageBuffer;
5049     VkBool32           variablePointers;
5050 } VkPhysicalDeviceVariablePointerFeaturesKHR;
5051
5052 #define VK_KHR_bind_memory2 1
5053 #define VK_KHR_BIND_MEMORY_2_SPEC_VERSION 1
5054 #define VK_KHR_BIND_MEMORY_2_EXTENSION_NAME "VK_KHR_bind_memory2"
5055
5056 typedef struct VkBindBufferMemoryInfoKHR {
5057     VkStructureType    sType;
5058     const void*        pNext;
5059     VkBuffer           buffer;
5060     VkDeviceMemory     memory;
5061     VkDeviceSize       memoryOffset;
5062 } VkBindBufferMemoryInfoKHR;
5063
5064 typedef struct VkBindImageMemoryInfoKHR {
5065     VkStructureType    sType;
5066     const void*        pNext;
5067     VkImage            image;
5068     VkDeviceMemory     memory;
5069     VkDeviceSize       memoryOffset;
5070 } VkBindImageMemoryInfoKHR;
5071
5072
5073 typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfoKHR* pBindInfos);
5074 typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfoKHR* pBindInfos);
5075
5076 #ifndef VK_NO_PROTOTYPES
5077 VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2KHR(
5078     VkDevice                                    device,
5079     uint32_t                                    bindInfoCount,
5080     const VkBindBufferMemoryInfoKHR*            pBindInfos);
5081
5082 VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2KHR(
5083     VkDevice                                    device,
5084     uint32_t                                    bindInfoCount,
5085     const VkBindImageMemoryInfoKHR*             pBindInfos);
5086 #endif
5087
5088 #ifdef __cplusplus
5089 }
5090 #endif
5091
5092 #endif