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