include/vulkan/vulkan_core.h

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