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