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