include/vulkan/vulkan.h

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