include/vulkan/vulkan_core.h

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