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