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