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