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