include/vulkan/vulkan_core.h

   1 #ifndef VULKAN_CORE_H_
   2 #define VULKAN_CORE_H_ 1
   3
   4 #ifdef __cplusplus
   5 extern "C" {
   6 #endif
   7
   8 /*
   9 ** Copyright (c) 2015-2019 The Khronos Group Inc.
  10 **
  11 ** Licensed under the Apache License, Version 2.0 (the "License");
  12 ** you may not use this file except in compliance with the License.
  13 ** You may obtain a copy of the License at
  14 **
  15 **     http://www.apache.org/licenses/LICENSE-2.0
  16 **
  17 ** Unless required by applicable law or agreed to in writing, software
  18 ** distributed under the License is distributed on an "AS IS" BASIS,
  19 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  20 ** See the License for the specific language governing permissions and
  21 ** limitations under the License.
  22 */
  23
  24 /*
  25 ** This header is generated from the Khronos Vulkan XML API Registry.
  26 **
  27 */
  28
  29
  30
  31 #define VK_VERSION_1_0 1
  32 #include "vk_platform.h"
  33 #define VK_MAKE_VERSION(major, minor, patch) \
  34     (((major) << 22) | ((minor) << 12) | (patch))
  35
  36 // DEPRECATED: This define has been removed. Specific version defines (e.g. VK_API_VERSION_1_0), or the VK_MAKE_VERSION macro, should be used instead.
  37 //#define VK_API_VERSION VK_MAKE_VERSION(1, 0, 0) // Patch version should always be set to 0
  38
  39 // Vulkan 1.0 version number
  40 #define VK_API_VERSION_1_0 VK_MAKE_VERSION(1, 0, 0)// Patch version should always be set to 0
  41
  42 #define VK_VERSION_MAJOR(version) ((uint32_t)(version) >> 22)
  43 #define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff)
  44 #define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff)
  45 // Version of this file
  46 #define VK_HEADER_VERSION 108
  47
  48
  49 #define VK_NULL_HANDLE 0
  50
  51
  52 #define VK_DEFINE_HANDLE(object) typedef struct object##_T* object;
  53
  54
  55 #if !defined(VK_DEFINE_NON_DISPATCHABLE_HANDLE)
  56 #if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
  57         #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object;
  58 #else
  59         #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object;
  60 #endif
  61 #endif
  62
  63 typedef uint32_t VkFlags;
  64 typedef uint32_t VkBool32;
  65 typedef uint64_t VkDeviceSize;
  66 typedef uint32_t VkSampleMask;
  67 VK_DEFINE_HANDLE(VkInstance)
  68 VK_DEFINE_HANDLE(VkPhysicalDevice)
  69 VK_DEFINE_HANDLE(VkDevice)
  70 VK_DEFINE_HANDLE(VkQueue)
  71 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore)
  72 VK_DEFINE_HANDLE(VkCommandBuffer)
  73 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence)
  74 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory)
  75 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer)
  76 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage)
  77 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent)
  78 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool)
  79 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView)
  80 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView)
  81 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule)
  82 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache)
  83 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout)
  84 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass)
  85 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline)
  86 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout)
  87 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler)
  88 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool)
  89 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet)
  90 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer)
  91 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool)
  92 #define VK_LOD_CLAMP_NONE                 1000.0f
  93 #define VK_REMAINING_MIP_LEVELS           (~0U)
  94 #define VK_REMAINING_ARRAY_LAYERS         (~0U)
  95 #define VK_WHOLE_SIZE                     (~0ULL)
  96 #define VK_ATTACHMENT_UNUSED              (~0U)
  97 #define VK_TRUE                           1
  98 #define VK_FALSE                          0
  99 #define VK_QUEUE_FAMILY_IGNORED           (~0U)
 100 #define VK_SUBPASS_EXTERNAL               (~0U)
 101 #define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE  256
 102 #define VK_UUID_SIZE                      16
 103 #define VK_MAX_MEMORY_TYPES               32
 104 #define VK_MAX_MEMORY_HEAPS               16
 105 #define VK_MAX_EXTENSION_NAME_SIZE        256
 106 #define VK_MAX_DESCRIPTION_SIZE           256
 107
 108 typedef enum VkPipelineCacheHeaderVersion {
 109     VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1,
 110     VK_PIPELINE_CACHE_HEADER_VERSION_BEGIN_RANGE = VK_PIPELINE_CACHE_HEADER_VERSION_ONE,
 111     VK_PIPELINE_CACHE_HEADER_VERSION_END_RANGE = VK_PIPELINE_CACHE_HEADER_VERSION_ONE,
 112     VK_PIPELINE_CACHE_HEADER_VERSION_RANGE_SIZE = (VK_PIPELINE_CACHE_HEADER_VERSION_ONE - VK_PIPELINE_CACHE_HEADER_VERSION_ONE + 1),
 113     VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF
 114 } VkPipelineCacheHeaderVersion;
 115
 116 typedef enum VkResult {
 117     VK_SUCCESS = 0,
 118     VK_NOT_READY = 1,
 119     VK_TIMEOUT = 2,
 120     VK_EVENT_SET = 3,
 121     VK_EVENT_RESET = 4,
 122     VK_INCOMPLETE = 5,
 123     VK_ERROR_OUT_OF_HOST_MEMORY = -1,
 124     VK_ERROR_OUT_OF_DEVICE_MEMORY = -2,
 125     VK_ERROR_INITIALIZATION_FAILED = -3,
 126     VK_ERROR_DEVICE_LOST = -4,
 127     VK_ERROR_MEMORY_MAP_FAILED = -5,
 128     VK_ERROR_LAYER_NOT_PRESENT = -6,
 129     VK_ERROR_EXTENSION_NOT_PRESENT = -7,
 130     VK_ERROR_FEATURE_NOT_PRESENT = -8,
 131     VK_ERROR_INCOMPATIBLE_DRIVER = -9,
 132     VK_ERROR_TOO_MANY_OBJECTS = -10,
 133     VK_ERROR_FORMAT_NOT_SUPPORTED = -11,
 134     VK_ERROR_FRAGMENTED_POOL = -12,
 135     VK_ERROR_OUT_OF_POOL_MEMORY = -1000069000,
 136     VK_ERROR_INVALID_EXTERNAL_HANDLE = -1000072003,
 137     VK_ERROR_SURFACE_LOST_KHR = -1000000000,
 138     VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001,
 139     VK_SUBOPTIMAL_KHR = 1000001003,
 140     VK_ERROR_OUT_OF_DATE_KHR = -1000001004,
 141     VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001,
 142     VK_ERROR_VALIDATION_FAILED_EXT = -1000011001,
 143     VK_ERROR_INVALID_SHADER_NV = -1000012000,
 144     VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT = -1000158000,
 145     VK_ERROR_FRAGMENTATION_EXT = -1000161000,
 146     VK_ERROR_NOT_PERMITTED_EXT = -1000174001,
 147     VK_ERROR_INVALID_DEVICE_ADDRESS_EXT = -1000244000,
 148     VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT = -1000255000,
 149     VK_ERROR_OUT_OF_POOL_MEMORY_KHR = VK_ERROR_OUT_OF_POOL_MEMORY,
 150     VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = VK_ERROR_INVALID_EXTERNAL_HANDLE,
 151     VK_RESULT_BEGIN_RANGE = VK_ERROR_FRAGMENTED_POOL,
 152     VK_RESULT_END_RANGE = VK_INCOMPLETE,
 153     VK_RESULT_RANGE_SIZE = (VK_INCOMPLETE - VK_ERROR_FRAGMENTED_POOL + 1),
 154     VK_RESULT_MAX_ENUM = 0x7FFFFFFF
 155 } VkResult;
 156
 157 typedef enum VkStructureType {
 158     VK_STRUCTURE_TYPE_APPLICATION_INFO = 0,
 159     VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1,
 160     VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2,
 161     VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3,
 162     VK_STRUCTURE_TYPE_SUBMIT_INFO = 4,
 163     VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5,
 164     VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6,
 165     VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7,
 166     VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8,
 167     VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9,
 168     VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10,
 169     VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11,
 170     VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12,
 171     VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13,
 172     VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14,
 173     VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15,
 174     VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16,
 175     VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17,
 176     VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18,
 177     VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19,
 178     VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20,
 179     VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21,
 180     VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22,
 181     VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23,
 182     VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24,
 183     VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25,
 184     VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26,
 185     VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27,
 186     VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28,
 187     VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29,
 188     VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30,
 189     VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31,
 190     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32,
 191     VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33,
 192     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34,
 193     VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35,
 194     VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36,
 195     VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37,
 196     VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38,
 197     VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39,
 198     VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40,
 199     VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41,
 200     VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42,
 201     VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43,
 202     VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44,
 203     VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45,
 204     VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46,
 205     VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47,
 206     VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48,
 207     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES = 1000094000,
 208     VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO = 1000157000,
 209     VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO = 1000157001,
 210     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES = 1000083000,
 211     VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS = 1000127000,
 212     VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO = 1000127001,
 213     VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO = 1000060000,
 214     VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO = 1000060003,
 215     VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO = 1000060004,
 216     VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO = 1000060005,
 217     VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO = 1000060006,
 218     VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO = 1000060013,
 219     VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO = 1000060014,
 220     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES = 1000070000,
 221     VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO = 1000070001,
 222     VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2 = 1000146000,
 223     VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2 = 1000146001,
 224     VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 = 1000146002,
 225     VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 = 1000146003,
 226     VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 = 1000146004,
 227     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 = 1000059000,
 228     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 = 1000059001,
 229     VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 = 1000059002,
 230     VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 = 1000059003,
 231     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 = 1000059004,
 232     VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 = 1000059005,
 233     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 = 1000059006,
 234     VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 = 1000059007,
 235     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 = 1000059008,
 236     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES = 1000117000,
 237     VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO = 1000117001,
 238     VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO = 1000117002,
 239     VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO = 1000117003,
 240     VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO = 1000053000,
 241     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES = 1000053001,
 242     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES = 1000053002,
 243     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES = 1000120000,
 244     VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO = 1000145000,
 245     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES = 1000145001,
 246     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES = 1000145002,
 247     VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 = 1000145003,
 248     VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO = 1000156000,
 249     VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO = 1000156001,
 250     VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO = 1000156002,
 251     VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO = 1000156003,
 252     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES = 1000156004,
 253     VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES = 1000156005,
 254     VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO = 1000085000,
 255     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO = 1000071000,
 256     VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES = 1000071001,
 257     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO = 1000071002,
 258     VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES = 1000071003,
 259     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES = 1000071004,
 260     VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO = 1000072000,
 261     VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO = 1000072001,
 262     VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO = 1000072002,
 263     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO = 1000112000,
 264     VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES = 1000112001,
 265     VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO = 1000113000,
 266     VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO = 1000077000,
 267     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO = 1000076000,
 268     VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES = 1000076001,
 269     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES = 1000168000,
 270     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT = 1000168001,
 271     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES = 1000063000,
 272     VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000,
 273     VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001,
 274     VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR = 1000060007,
 275     VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR = 1000060008,
 276     VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR = 1000060009,
 277     VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR = 1000060010,
 278     VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR = 1000060011,
 279     VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR = 1000060012,
 280     VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000,
 281     VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001,
 282     VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000,
 283     VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000,
 284     VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000,
 285     VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000,
 286     VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000,
 287     VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000,
 288     VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000,
 289     VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000,
 290     VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000,
 291     VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001,
 292     VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002,
 293     VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000,
 294     VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001,
 295     VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002,
 296     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT = 1000028000,
 297     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT = 1000028001,
 298     VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT = 1000028002,
 299     VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX = 1000030000,
 300     VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD = 1000041000,
 301     VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP = 1000049000,
 302     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV = 1000050000,
 303     VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000,
 304     VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001,
 305     VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000,
 306     VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057001,
 307     VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000,
 308     VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = 1000061000,
 309     VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN = 1000062000,
 310     VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT = 1000067000,
 311     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT = 1000067001,
 312     VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073000,
 313     VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073001,
 314     VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR = 1000073002,
 315     VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR = 1000073003,
 316     VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR = 1000074000,
 317     VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR = 1000074001,
 318     VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR = 1000074002,
 319     VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR = 1000075000,
 320     VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078000,
 321     VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078001,
 322     VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR = 1000078002,
 323     VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR = 1000078003,
 324     VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR = 1000079000,
 325     VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR = 1000079001,
 326     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = 1000080000,
 327     VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT = 1000081000,
 328     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT = 1000081001,
 329     VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT = 1000081002,
 330     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR = 1000082000,
 331     VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000,
 332     VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX = 1000086000,
 333     VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX = 1000086001,
 334     VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX = 1000086002,
 335     VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX = 1000086003,
 336     VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX = 1000086004,
 337     VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX = 1000086005,
 338     VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV = 1000087000,
 339     VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT = 1000090000,
 340     VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT = 1000091000,
 341     VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT = 1000091001,
 342     VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT = 1000091002,
 343     VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT = 1000091003,
 344     VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE = 1000092000,
 345     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX = 1000097000,
 346     VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV = 1000098000,
 347     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT = 1000099000,
 348     VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT = 1000099001,
 349     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT = 1000101000,
 350     VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT = 1000101001,
 351     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT = 1000102000,
 352     VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT = 1000102001,
 353     VK_STRUCTURE_TYPE_HDR_METADATA_EXT = 1000105000,
 354     VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR = 1000109000,
 355     VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR = 1000109001,
 356     VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR = 1000109002,
 357     VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2_KHR = 1000109003,
 358     VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR = 1000109004,
 359     VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO_KHR = 1000109005,
 360     VK_STRUCTURE_TYPE_SUBPASS_END_INFO_KHR = 1000109006,
 361     VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000,
 362     VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114000,
 363     VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114001,
 364     VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR = 1000114002,
 365     VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR = 1000115000,
 366     VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR = 1000115001,
 367     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000,
 368     VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001,
 369     VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002,
 370     VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR = 1000121000,
 371     VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR = 1000121001,
 372     VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR = 1000121002,
 373     VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR = 1000121003,
 374     VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR = 1000121004,
 375     VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK = 1000122000,
 376     VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = 1000123000,
 377     VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT = 1000128000,
 378     VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT = 1000128001,
 379     VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT = 1000128002,
 380     VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT = 1000128003,
 381     VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT = 1000128004,
 382     VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID = 1000129000,
 383     VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID = 1000129001,
 384     VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID = 1000129002,
 385     VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129003,
 386     VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129004,
 387     VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID = 1000129005,
 388     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT = 1000130000,
 389     VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT = 1000130001,
 390     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT = 1000138000,
 391     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT = 1000138001,
 392     VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT = 1000138002,
 393     VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT = 1000138003,
 394     VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT = 1000143000,
 395     VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT = 1000143001,
 396     VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT = 1000143002,
 397     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT = 1000143003,
 398     VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT = 1000143004,
 399     VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR = 1000147000,
 400     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT = 1000148000,
 401     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT = 1000148001,
 402     VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT = 1000148002,
 403     VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV = 1000149000,
 404     VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV = 1000152000,
 405     VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT = 1000158000,
 406     VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT = 1000158001,
 407     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT = 1000158002,
 408     VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT = 1000158003,
 409     VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT = 1000158004,
 410     VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT = 1000158005,
 411     VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160000,
 412     VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160001,
 413     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT = 1000161000,
 414     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT = 1000161001,
 415     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT = 1000161002,
 416     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT = 1000161003,
 417     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT = 1000161004,
 418     VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV = 1000164000,
 419     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV = 1000164001,
 420     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV = 1000164002,
 421     VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV = 1000164005,
 422     VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV = 1000165000,
 423     VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV = 1000165001,
 424     VK_STRUCTURE_TYPE_GEOMETRY_NV = 1000165003,
 425     VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV = 1000165004,
 426     VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV = 1000165005,
 427     VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV = 1000165006,
 428     VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV = 1000165007,
 429     VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV = 1000165008,
 430     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV = 1000165009,
 431     VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV = 1000165011,
 432     VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV = 1000165012,
 433     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV = 1000166000,
 434     VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV = 1000166001,
 435     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT = 1000170000,
 436     VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT = 1000170001,
 437     VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT = 1000174000,
 438     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR = 1000177000,
 439     VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT = 1000178000,
 440     VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT = 1000178001,
 441     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002,
 442     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR = 1000180000,
 443     VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT = 1000184000,
 444     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD = 1000185000,
 445     VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD = 1000189000,
 446     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT = 1000190000,
 447     VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT = 1000190001,
 448     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT = 1000190002,
 449     VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP = 1000191000,
 450     VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT = 1000192000,
 451     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR = 1000196000,
 452     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR = 1000197000,
 453     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR = 1000199000,
 454     VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR = 1000199001,
 455     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV = 1000201000,
 456     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV = 1000202000,
 457     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV = 1000202001,
 458     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV = 1000203000,
 459     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV = 1000204000,
 460     VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV = 1000205000,
 461     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV = 1000205002,
 462     VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV = 1000206000,
 463     VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV = 1000206001,
 464     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR = 1000211000,
 465     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT = 1000212000,
 466     VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD = 1000213000,
 467     VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD = 1000213001,
 468     VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA = 1000214000,
 469     VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT = 1000217000,
 470     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT = 1000218000,
 471     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT = 1000218001,
 472     VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT = 1000218002,
 473     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT = 1000221000,
 474     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT = 1000237000,
 475     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT = 1000238000,
 476     VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT = 1000238001,
 477     VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR = 1000239000,
 478     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV = 1000240000,
 479     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT = 1000244000,
 480     VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT = 1000244001,
 481     VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT = 1000244002,
 482     VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT = 1000246000,
 483     VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT = 1000247000,
 484     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV = 1000249000,
 485     VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV = 1000249001,
 486     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV = 1000249002,
 487     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV = 1000250000,
 488     VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV = 1000250001,
 489     VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV = 1000250002,
 490     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT = 1000252000,
 491     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR = 1000253000,
 492     VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT = 1000255000,
 493     VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT = 1000255002,
 494     VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT = 1000255001,
 495     VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT = 1000256000,
 496     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT = 1000261000,
 497     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
 498     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES,
 499     VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
 500     VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO,
 501     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES,
 502     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES,
 503     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2,
 504     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2,
 505     VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2,
 506     VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2,
 507     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
 508     VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2,
 509     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2,
 510     VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2,
 511     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2,
 512     VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO,
 513     VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO,
 514     VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO,
 515     VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO,
 516     VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO,
 517     VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO,
 518     VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO,
 519     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES,
 520     VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO,
 521     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO,
 522     VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES,
 523     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO,
 524     VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES,
 525     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES,
 526     VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO,
 527     VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
 528     VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO,
 529     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO,
 530     VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES,
 531     VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO,
 532     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES,
 533     VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO,
 534     VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT,
 535     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO,
 536     VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES,
 537     VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO,
 538     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES,
 539     VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO,
 540     VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO,
 541     VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO,
 542     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES,
 543     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES,
 544     VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS,
 545     VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
 546     VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2,
 547     VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2,
 548     VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2,
 549     VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2,
 550     VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2,
 551     VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO,
 552     VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO,
 553     VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO,
 554     VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO,
 555     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES,
 556     VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES,
 557     VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO,
 558     VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO,
 559     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES,
 560     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT,
 561     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT,
 562     VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO,
 563     VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO,
 564     VK_STRUCTURE_TYPE_RANGE_SIZE = (VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1),
 565     VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
 566 } VkStructureType;
 567
 568 typedef enum VkSystemAllocationScope {
 569     VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0,
 570     VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1,
 571     VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2,
 572     VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3,
 573     VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4,
 574     VK_SYSTEM_ALLOCATION_SCOPE_BEGIN_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_COMMAND,
 575     VK_SYSTEM_ALLOCATION_SCOPE_END_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE,
 576     VK_SYSTEM_ALLOCATION_SCOPE_RANGE_SIZE = (VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE - VK_SYSTEM_ALLOCATION_SCOPE_COMMAND + 1),
 577     VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF
 578 } VkSystemAllocationScope;
 579
 580 typedef enum VkInternalAllocationType {
 581     VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0,
 582     VK_INTERNAL_ALLOCATION_TYPE_BEGIN_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE,
 583     VK_INTERNAL_ALLOCATION_TYPE_END_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE,
 584     VK_INTERNAL_ALLOCATION_TYPE_RANGE_SIZE = (VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE - VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE + 1),
 585     VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF
 586 } VkInternalAllocationType;
 587
 588 typedef enum VkFormat {
 589     VK_FORMAT_UNDEFINED = 0,
 590     VK_FORMAT_R4G4_UNORM_PACK8 = 1,
 591     VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2,
 592     VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3,
 593     VK_FORMAT_R5G6B5_UNORM_PACK16 = 4,
 594     VK_FORMAT_B5G6R5_UNORM_PACK16 = 5,
 595     VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6,
 596     VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7,
 597     VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8,
 598     VK_FORMAT_R8_UNORM = 9,
 599     VK_FORMAT_R8_SNORM = 10,
 600     VK_FORMAT_R8_USCALED = 11,
 601     VK_FORMAT_R8_SSCALED = 12,
 602     VK_FORMAT_R8_UINT = 13,
 603     VK_FORMAT_R8_SINT = 14,
 604     VK_FORMAT_R8_SRGB = 15,
 605     VK_FORMAT_R8G8_UNORM = 16,
 606     VK_FORMAT_R8G8_SNORM = 17,
 607     VK_FORMAT_R8G8_USCALED = 18,
 608     VK_FORMAT_R8G8_SSCALED = 19,
 609     VK_FORMAT_R8G8_UINT = 20,
 610     VK_FORMAT_R8G8_SINT = 21,
 611     VK_FORMAT_R8G8_SRGB = 22,
 612     VK_FORMAT_R8G8B8_UNORM = 23,
 613     VK_FORMAT_R8G8B8_SNORM = 24,
 614     VK_FORMAT_R8G8B8_USCALED = 25,
 615     VK_FORMAT_R8G8B8_SSCALED = 26,
 616     VK_FORMAT_R8G8B8_UINT = 27,
 617     VK_FORMAT_R8G8B8_SINT = 28,
 618     VK_FORMAT_R8G8B8_SRGB = 29,
 619     VK_FORMAT_B8G8R8_UNORM = 30,
 620     VK_FORMAT_B8G8R8_SNORM = 31,
 621     VK_FORMAT_B8G8R8_USCALED = 32,
 622     VK_FORMAT_B8G8R8_SSCALED = 33,
 623     VK_FORMAT_B8G8R8_UINT = 34,
 624     VK_FORMAT_B8G8R8_SINT = 35,
 625     VK_FORMAT_B8G8R8_SRGB = 36,
 626     VK_FORMAT_R8G8B8A8_UNORM = 37,
 627     VK_FORMAT_R8G8B8A8_SNORM = 38,
 628     VK_FORMAT_R8G8B8A8_USCALED = 39,
 629     VK_FORMAT_R8G8B8A8_SSCALED = 40,
 630     VK_FORMAT_R8G8B8A8_UINT = 41,
 631     VK_FORMAT_R8G8B8A8_SINT = 42,
 632     VK_FORMAT_R8G8B8A8_SRGB = 43,
 633     VK_FORMAT_B8G8R8A8_UNORM = 44,
 634     VK_FORMAT_B8G8R8A8_SNORM = 45,
 635     VK_FORMAT_B8G8R8A8_USCALED = 46,
 636     VK_FORMAT_B8G8R8A8_SSCALED = 47,
 637     VK_FORMAT_B8G8R8A8_UINT = 48,
 638     VK_FORMAT_B8G8R8A8_SINT = 49,
 639     VK_FORMAT_B8G8R8A8_SRGB = 50,
 640     VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51,
 641     VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52,
 642     VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53,
 643     VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54,
 644     VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55,
 645     VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56,
 646     VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57,
 647     VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58,
 648     VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59,
 649     VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60,
 650     VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61,
 651     VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62,
 652     VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63,
 653     VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64,
 654     VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65,
 655     VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66,
 656     VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67,
 657     VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68,
 658     VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69,
 659     VK_FORMAT_R16_UNORM = 70,
 660     VK_FORMAT_R16_SNORM = 71,
 661     VK_FORMAT_R16_USCALED = 72,
 662     VK_FORMAT_R16_SSCALED = 73,
 663     VK_FORMAT_R16_UINT = 74,
 664     VK_FORMAT_R16_SINT = 75,
 665     VK_FORMAT_R16_SFLOAT = 76,
 666     VK_FORMAT_R16G16_UNORM = 77,
 667     VK_FORMAT_R16G16_SNORM = 78,
 668     VK_FORMAT_R16G16_USCALED = 79,
 669     VK_FORMAT_R16G16_SSCALED = 80,
 670     VK_FORMAT_R16G16_UINT = 81,
 671     VK_FORMAT_R16G16_SINT = 82,
 672     VK_FORMAT_R16G16_SFLOAT = 83,
 673     VK_FORMAT_R16G16B16_UNORM = 84,
 674     VK_FORMAT_R16G16B16_SNORM = 85,
 675     VK_FORMAT_R16G16B16_USCALED = 86,
 676     VK_FORMAT_R16G16B16_SSCALED = 87,
 677     VK_FORMAT_R16G16B16_UINT = 88,
 678     VK_FORMAT_R16G16B16_SINT = 89,
 679     VK_FORMAT_R16G16B16_SFLOAT = 90,
 680     VK_FORMAT_R16G16B16A16_UNORM = 91,
 681     VK_FORMAT_R16G16B16A16_SNORM = 92,
 682     VK_FORMAT_R16G16B16A16_USCALED = 93,
 683     VK_FORMAT_R16G16B16A16_SSCALED = 94,
 684     VK_FORMAT_R16G16B16A16_UINT = 95,
 685     VK_FORMAT_R16G16B16A16_SINT = 96,
 686     VK_FORMAT_R16G16B16A16_SFLOAT = 97,
 687     VK_FORMAT_R32_UINT = 98,
 688     VK_FORMAT_R32_SINT = 99,
 689     VK_FORMAT_R32_SFLOAT = 100,
 690     VK_FORMAT_R32G32_UINT = 101,
 691     VK_FORMAT_R32G32_SINT = 102,
 692     VK_FORMAT_R32G32_SFLOAT = 103,
 693     VK_FORMAT_R32G32B32_UINT = 104,
 694     VK_FORMAT_R32G32B32_SINT = 105,
 695     VK_FORMAT_R32G32B32_SFLOAT = 106,
 696     VK_FORMAT_R32G32B32A32_UINT = 107,
 697     VK_FORMAT_R32G32B32A32_SINT = 108,
 698     VK_FORMAT_R32G32B32A32_SFLOAT = 109,
 699     VK_FORMAT_R64_UINT = 110,
 700     VK_FORMAT_R64_SINT = 111,
 701     VK_FORMAT_R64_SFLOAT = 112,
 702     VK_FORMAT_R64G64_UINT = 113,
 703     VK_FORMAT_R64G64_SINT = 114,
 704     VK_FORMAT_R64G64_SFLOAT = 115,
 705     VK_FORMAT_R64G64B64_UINT = 116,
 706     VK_FORMAT_R64G64B64_SINT = 117,
 707     VK_FORMAT_R64G64B64_SFLOAT = 118,
 708     VK_FORMAT_R64G64B64A64_UINT = 119,
 709     VK_FORMAT_R64G64B64A64_SINT = 120,
 710     VK_FORMAT_R64G64B64A64_SFLOAT = 121,
 711     VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122,
 712     VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123,
 713     VK_FORMAT_D16_UNORM = 124,
 714     VK_FORMAT_X8_D24_UNORM_PACK32 = 125,
 715     VK_FORMAT_D32_SFLOAT = 126,
 716     VK_FORMAT_S8_UINT = 127,
 717     VK_FORMAT_D16_UNORM_S8_UINT = 128,
 718     VK_FORMAT_D24_UNORM_S8_UINT = 129,
 719     VK_FORMAT_D32_SFLOAT_S8_UINT = 130,
 720     VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131,
 721     VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132,
 722     VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133,
 723     VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134,
 724     VK_FORMAT_BC2_UNORM_BLOCK = 135,
 725     VK_FORMAT_BC2_SRGB_BLOCK = 136,
 726     VK_FORMAT_BC3_UNORM_BLOCK = 137,
 727     VK_FORMAT_BC3_SRGB_BLOCK = 138,
 728     VK_FORMAT_BC4_UNORM_BLOCK = 139,
 729     VK_FORMAT_BC4_SNORM_BLOCK = 140,
 730     VK_FORMAT_BC5_UNORM_BLOCK = 141,
 731     VK_FORMAT_BC5_SNORM_BLOCK = 142,
 732     VK_FORMAT_BC6H_UFLOAT_BLOCK = 143,
 733     VK_FORMAT_BC6H_SFLOAT_BLOCK = 144,
 734     VK_FORMAT_BC7_UNORM_BLOCK = 145,
 735     VK_FORMAT_BC7_SRGB_BLOCK = 146,
 736     VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147,
 737     VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148,
 738     VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149,
 739     VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150,
 740     VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151,
 741     VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152,
 742     VK_FORMAT_EAC_R11_UNORM_BLOCK = 153,
 743     VK_FORMAT_EAC_R11_SNORM_BLOCK = 154,
 744     VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155,
 745     VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156,
 746     VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157,
 747     VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158,
 748     VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159,
 749     VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160,
 750     VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161,
 751     VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162,
 752     VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163,
 753     VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164,
 754     VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165,
 755     VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166,
 756     VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167,
 757     VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168,
 758     VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169,
 759     VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170,
 760     VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171,
 761     VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172,
 762     VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173,
 763     VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174,
 764     VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175,
 765     VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176,
 766     VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177,
 767     VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178,
 768     VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179,
 769     VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180,
 770     VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181,
 771     VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182,
 772     VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183,
 773     VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184,
 774     VK_FORMAT_G8B8G8R8_422_UNORM = 1000156000,
 775     VK_FORMAT_B8G8R8G8_422_UNORM = 1000156001,
 776     VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM = 1000156002,
 777     VK_FORMAT_G8_B8R8_2PLANE_420_UNORM = 1000156003,
 778     VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM = 1000156004,
 779     VK_FORMAT_G8_B8R8_2PLANE_422_UNORM = 1000156005,
 780     VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM = 1000156006,
 781     VK_FORMAT_R10X6_UNORM_PACK16 = 1000156007,
 782     VK_FORMAT_R10X6G10X6_UNORM_2PACK16 = 1000156008,
 783     VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 = 1000156009,
 784     VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 = 1000156010,
 785     VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 = 1000156011,
 786     VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 = 1000156012,
 787     VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 = 1000156013,
 788     VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 = 1000156014,
 789     VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 = 1000156015,
 790     VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 = 1000156016,
 791     VK_FORMAT_R12X4_UNORM_PACK16 = 1000156017,
 792     VK_FORMAT_R12X4G12X4_UNORM_2PACK16 = 1000156018,
 793     VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 = 1000156019,
 794     VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 = 1000156020,
 795     VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 = 1000156021,
 796     VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 = 1000156022,
 797     VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 = 1000156023,
 798     VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 = 1000156024,
 799     VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 = 1000156025,
 800     VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 = 1000156026,
 801     VK_FORMAT_G16B16G16R16_422_UNORM = 1000156027,
 802     VK_FORMAT_B16G16R16G16_422_UNORM = 1000156028,
 803     VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM = 1000156029,
 804     VK_FORMAT_G16_B16R16_2PLANE_420_UNORM = 1000156030,
 805     VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM = 1000156031,
 806     VK_FORMAT_G16_B16R16_2PLANE_422_UNORM = 1000156032,
 807     VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM = 1000156033,
 808     VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000,
 809     VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001,
 810     VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002,
 811     VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003,
 812     VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004,
 813     VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005,
 814     VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006,
 815     VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007,
 816     VK_FORMAT_G8B8G8R8_422_UNORM_KHR = VK_FORMAT_G8B8G8R8_422_UNORM,
 817     VK_FORMAT_B8G8R8G8_422_UNORM_KHR = VK_FORMAT_B8G8R8G8_422_UNORM,
 818     VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM,
 819     VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM,
 820     VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM,
 821     VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM,
 822     VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM,
 823     VK_FORMAT_R10X6_UNORM_PACK16_KHR = VK_FORMAT_R10X6_UNORM_PACK16,
 824     VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR = VK_FORMAT_R10X6G10X6_UNORM_2PACK16,
 825     VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16,
 826     VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR = VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16,
 827     VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16,
 828     VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16,
 829     VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16,
 830     VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16,
 831     VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16,
 832     VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16,
 833     VK_FORMAT_R12X4_UNORM_PACK16_KHR = VK_FORMAT_R12X4_UNORM_PACK16,
 834     VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR = VK_FORMAT_R12X4G12X4_UNORM_2PACK16,
 835     VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR = VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16,
 836     VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR = VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16,
 837     VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR = VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16,
 838     VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16,
 839     VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16,
 840     VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16,
 841     VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16,
 842     VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16,
 843     VK_FORMAT_G16B16G16R16_422_UNORM_KHR = VK_FORMAT_G16B16G16R16_422_UNORM,
 844     VK_FORMAT_B16G16R16G16_422_UNORM_KHR = VK_FORMAT_B16G16R16G16_422_UNORM,
 845     VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM,
 846     VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM,
 847     VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM,
 848     VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM,
 849     VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM,
 850     VK_FORMAT_BEGIN_RANGE = VK_FORMAT_UNDEFINED,
 851     VK_FORMAT_END_RANGE = VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
 852     VK_FORMAT_RANGE_SIZE = (VK_FORMAT_ASTC_12x12_SRGB_BLOCK - VK_FORMAT_UNDEFINED + 1),
 853     VK_FORMAT_MAX_ENUM = 0x7FFFFFFF
 854 } VkFormat;
 855
 856 typedef enum VkImageType {
 857     VK_IMAGE_TYPE_1D = 0,
 858     VK_IMAGE_TYPE_2D = 1,
 859     VK_IMAGE_TYPE_3D = 2,
 860     VK_IMAGE_TYPE_BEGIN_RANGE = VK_IMAGE_TYPE_1D,
 861     VK_IMAGE_TYPE_END_RANGE = VK_IMAGE_TYPE_3D,
 862     VK_IMAGE_TYPE_RANGE_SIZE = (VK_IMAGE_TYPE_3D - VK_IMAGE_TYPE_1D + 1),
 863     VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF
 864 } VkImageType;
 865
 866 typedef enum VkImageTiling {
 867     VK_IMAGE_TILING_OPTIMAL = 0,
 868     VK_IMAGE_TILING_LINEAR = 1,
 869     VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT = 1000158000,
 870     VK_IMAGE_TILING_BEGIN_RANGE = VK_IMAGE_TILING_OPTIMAL,
 871     VK_IMAGE_TILING_END_RANGE = VK_IMAGE_TILING_LINEAR,
 872     VK_IMAGE_TILING_RANGE_SIZE = (VK_IMAGE_TILING_LINEAR - VK_IMAGE_TILING_OPTIMAL + 1),
 873     VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF
 874 } VkImageTiling;
 875
 876 typedef enum VkPhysicalDeviceType {
 877     VK_PHYSICAL_DEVICE_TYPE_OTHER = 0,
 878     VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1,
 879     VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2,
 880     VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3,
 881     VK_PHYSICAL_DEVICE_TYPE_CPU = 4,
 882     VK_PHYSICAL_DEVICE_TYPE_BEGIN_RANGE = VK_PHYSICAL_DEVICE_TYPE_OTHER,
 883     VK_PHYSICAL_DEVICE_TYPE_END_RANGE = VK_PHYSICAL_DEVICE_TYPE_CPU,
 884     VK_PHYSICAL_DEVICE_TYPE_RANGE_SIZE = (VK_PHYSICAL_DEVICE_TYPE_CPU - VK_PHYSICAL_DEVICE_TYPE_OTHER + 1),
 885     VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF
 886 } VkPhysicalDeviceType;
 887
 888 typedef enum VkQueryType {
 889     VK_QUERY_TYPE_OCCLUSION = 0,
 890     VK_QUERY_TYPE_PIPELINE_STATISTICS = 1,
 891     VK_QUERY_TYPE_TIMESTAMP = 2,
 892     VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT = 1000028004,
 893     VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV = 1000165000,
 894     VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION,
 895     VK_QUERY_TYPE_END_RANGE = VK_QUERY_TYPE_TIMESTAMP,
 896     VK_QUERY_TYPE_RANGE_SIZE = (VK_QUERY_TYPE_TIMESTAMP - VK_QUERY_TYPE_OCCLUSION + 1),
 897     VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF
 898 } VkQueryType;
 899
 900 typedef enum VkSharingMode {
 901     VK_SHARING_MODE_EXCLUSIVE = 0,
 902     VK_SHARING_MODE_CONCURRENT = 1,
 903     VK_SHARING_MODE_BEGIN_RANGE = VK_SHARING_MODE_EXCLUSIVE,
 904     VK_SHARING_MODE_END_RANGE = VK_SHARING_MODE_CONCURRENT,
 905     VK_SHARING_MODE_RANGE_SIZE = (VK_SHARING_MODE_CONCURRENT - VK_SHARING_MODE_EXCLUSIVE + 1),
 906     VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF
 907 } VkSharingMode;
 908
 909 typedef enum VkImageLayout {
 910     VK_IMAGE_LAYOUT_UNDEFINED = 0,
 911     VK_IMAGE_LAYOUT_GENERAL = 1,
 912     VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2,
 913     VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3,
 914     VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4,
 915     VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5,
 916     VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6,
 917     VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7,
 918     VK_IMAGE_LAYOUT_PREINITIALIZED = 8,
 919     VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL = 1000117000,
 920     VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL = 1000117001,
 921     VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002,
 922     VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000,
 923     VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV = 1000164003,
 924     VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT = 1000218000,
 925     VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL,
 926     VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL,
 927     VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED,
 928     VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_PREINITIALIZED,
 929     VK_IMAGE_LAYOUT_RANGE_SIZE = (VK_IMAGE_LAYOUT_PREINITIALIZED - VK_IMAGE_LAYOUT_UNDEFINED + 1),
 930     VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF
 931 } VkImageLayout;
 932
 933 typedef enum VkImageViewType {
 934     VK_IMAGE_VIEW_TYPE_1D = 0,
 935     VK_IMAGE_VIEW_TYPE_2D = 1,
 936     VK_IMAGE_VIEW_TYPE_3D = 2,
 937     VK_IMAGE_VIEW_TYPE_CUBE = 3,
 938     VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4,
 939     VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5,
 940     VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6,
 941     VK_IMAGE_VIEW_TYPE_BEGIN_RANGE = VK_IMAGE_VIEW_TYPE_1D,
 942     VK_IMAGE_VIEW_TYPE_END_RANGE = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY,
 943     VK_IMAGE_VIEW_TYPE_RANGE_SIZE = (VK_IMAGE_VIEW_TYPE_CUBE_ARRAY - VK_IMAGE_VIEW_TYPE_1D + 1),
 944     VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF
 945 } VkImageViewType;
 946
 947 typedef enum VkComponentSwizzle {
 948     VK_COMPONENT_SWIZZLE_IDENTITY = 0,
 949     VK_COMPONENT_SWIZZLE_ZERO = 1,
 950     VK_COMPONENT_SWIZZLE_ONE = 2,
 951     VK_COMPONENT_SWIZZLE_R = 3,
 952     VK_COMPONENT_SWIZZLE_G = 4,
 953     VK_COMPONENT_SWIZZLE_B = 5,
 954     VK_COMPONENT_SWIZZLE_A = 6,
 955     VK_COMPONENT_SWIZZLE_BEGIN_RANGE = VK_COMPONENT_SWIZZLE_IDENTITY,
 956     VK_COMPONENT_SWIZZLE_END_RANGE = VK_COMPONENT_SWIZZLE_A,
 957     VK_COMPONENT_SWIZZLE_RANGE_SIZE = (VK_COMPONENT_SWIZZLE_A - VK_COMPONENT_SWIZZLE_IDENTITY + 1),
 958     VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF
 959 } VkComponentSwizzle;
 960
 961 typedef enum VkVertexInputRate {
 962     VK_VERTEX_INPUT_RATE_VERTEX = 0,
 963     VK_VERTEX_INPUT_RATE_INSTANCE = 1,
 964     VK_VERTEX_INPUT_RATE_BEGIN_RANGE = VK_VERTEX_INPUT_RATE_VERTEX,
 965     VK_VERTEX_INPUT_RATE_END_RANGE = VK_VERTEX_INPUT_RATE_INSTANCE,
 966     VK_VERTEX_INPUT_RATE_RANGE_SIZE = (VK_VERTEX_INPUT_RATE_INSTANCE - VK_VERTEX_INPUT_RATE_VERTEX + 1),
 967     VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF
 968 } VkVertexInputRate;
 969
 970 typedef enum VkPrimitiveTopology {
 971     VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0,
 972     VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1,
 973     VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2,
 974     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3,
 975     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4,
 976     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5,
 977     VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6,
 978     VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7,
 979     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8,
 980     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9,
 981     VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10,
 982     VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = VK_PRIMITIVE_TOPOLOGY_POINT_LIST,
 983     VK_PRIMITIVE_TOPOLOGY_END_RANGE = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST,
 984     VK_PRIMITIVE_TOPOLOGY_RANGE_SIZE = (VK_PRIMITIVE_TOPOLOGY_PATCH_LIST - VK_PRIMITIVE_TOPOLOGY_POINT_LIST + 1),
 985     VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF
 986 } VkPrimitiveTopology;
 987
 988 typedef enum VkPolygonMode {
 989     VK_POLYGON_MODE_FILL = 0,
 990     VK_POLYGON_MODE_LINE = 1,
 991     VK_POLYGON_MODE_POINT = 2,
 992     VK_POLYGON_MODE_FILL_RECTANGLE_NV = 1000153000,
 993     VK_POLYGON_MODE_BEGIN_RANGE = VK_POLYGON_MODE_FILL,
 994     VK_POLYGON_MODE_END_RANGE = VK_POLYGON_MODE_POINT,
 995     VK_POLYGON_MODE_RANGE_SIZE = (VK_POLYGON_MODE_POINT - VK_POLYGON_MODE_FILL + 1),
 996     VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF
 997 } VkPolygonMode;
 998
 999 typedef enum VkFrontFace {
1000     VK_FRONT_FACE_COUNTER_CLOCKWISE = 0,
1001     VK_FRONT_FACE_CLOCKWISE = 1,
1002     VK_FRONT_FACE_BEGIN_RANGE = VK_FRONT_FACE_COUNTER_CLOCKWISE,
1003     VK_FRONT_FACE_END_RANGE = VK_FRONT_FACE_CLOCKWISE,
1004     VK_FRONT_FACE_RANGE_SIZE = (VK_FRONT_FACE_CLOCKWISE - VK_FRONT_FACE_COUNTER_CLOCKWISE + 1),
1005     VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF
1006 } VkFrontFace;
1007
1008 typedef enum VkCompareOp {
1009     VK_COMPARE_OP_NEVER = 0,
1010     VK_COMPARE_OP_LESS = 1,
1011     VK_COMPARE_OP_EQUAL = 2,
1012     VK_COMPARE_OP_LESS_OR_EQUAL = 3,
1013     VK_COMPARE_OP_GREATER = 4,
1014     VK_COMPARE_OP_NOT_EQUAL = 5,
1015     VK_COMPARE_OP_GREATER_OR_EQUAL = 6,
1016     VK_COMPARE_OP_ALWAYS = 7,
1017     VK_COMPARE_OP_BEGIN_RANGE = VK_COMPARE_OP_NEVER,
1018     VK_COMPARE_OP_END_RANGE = VK_COMPARE_OP_ALWAYS,
1019     VK_COMPARE_OP_RANGE_SIZE = (VK_COMPARE_OP_ALWAYS - VK_COMPARE_OP_NEVER + 1),
1020     VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF
1021 } VkCompareOp;
1022
1023 typedef enum VkStencilOp {
1024     VK_STENCIL_OP_KEEP = 0,
1025     VK_STENCIL_OP_ZERO = 1,
1026     VK_STENCIL_OP_REPLACE = 2,
1027     VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3,
1028     VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4,
1029     VK_STENCIL_OP_INVERT = 5,
1030     VK_STENCIL_OP_INCREMENT_AND_WRAP = 6,
1031     VK_STENCIL_OP_DECREMENT_AND_WRAP = 7,
1032     VK_STENCIL_OP_BEGIN_RANGE = VK_STENCIL_OP_KEEP,
1033     VK_STENCIL_OP_END_RANGE = VK_STENCIL_OP_DECREMENT_AND_WRAP,
1034     VK_STENCIL_OP_RANGE_SIZE = (VK_STENCIL_OP_DECREMENT_AND_WRAP - VK_STENCIL_OP_KEEP + 1),
1035     VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF
1036 } VkStencilOp;
1037
1038 typedef enum VkLogicOp {
1039     VK_LOGIC_OP_CLEAR = 0,
1040     VK_LOGIC_OP_AND = 1,
1041     VK_LOGIC_OP_AND_REVERSE = 2,
1042     VK_LOGIC_OP_COPY = 3,
1043     VK_LOGIC_OP_AND_INVERTED = 4,
1044     VK_LOGIC_OP_NO_OP = 5,
1045     VK_LOGIC_OP_XOR = 6,
1046     VK_LOGIC_OP_OR = 7,
1047     VK_LOGIC_OP_NOR = 8,
1048     VK_LOGIC_OP_EQUIVALENT = 9,
1049     VK_LOGIC_OP_INVERT = 10,
1050     VK_LOGIC_OP_OR_REVERSE = 11,
1051     VK_LOGIC_OP_COPY_INVERTED = 12,
1052     VK_LOGIC_OP_OR_INVERTED = 13,
1053     VK_LOGIC_OP_NAND = 14,
1054     VK_LOGIC_OP_SET = 15,
1055     VK_LOGIC_OP_BEGIN_RANGE = VK_LOGIC_OP_CLEAR,
1056     VK_LOGIC_OP_END_RANGE = VK_LOGIC_OP_SET,
1057     VK_LOGIC_OP_RANGE_SIZE = (VK_LOGIC_OP_SET - VK_LOGIC_OP_CLEAR + 1),
1058     VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF
1059 } VkLogicOp;
1060
1061 typedef enum VkBlendFactor {
1062     VK_BLEND_FACTOR_ZERO = 0,
1063     VK_BLEND_FACTOR_ONE = 1,
1064     VK_BLEND_FACTOR_SRC_COLOR = 2,
1065     VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3,
1066     VK_BLEND_FACTOR_DST_COLOR = 4,
1067     VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5,
1068     VK_BLEND_FACTOR_SRC_ALPHA = 6,
1069     VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7,
1070     VK_BLEND_FACTOR_DST_ALPHA = 8,
1071     VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9,
1072     VK_BLEND_FACTOR_CONSTANT_COLOR = 10,
1073     VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11,
1074     VK_BLEND_FACTOR_CONSTANT_ALPHA = 12,
1075     VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13,
1076     VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14,
1077     VK_BLEND_FACTOR_SRC1_COLOR = 15,
1078     VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16,
1079     VK_BLEND_FACTOR_SRC1_ALPHA = 17,
1080     VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18,
1081     VK_BLEND_FACTOR_BEGIN_RANGE = VK_BLEND_FACTOR_ZERO,
1082     VK_BLEND_FACTOR_END_RANGE = VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA,
1083     VK_BLEND_FACTOR_RANGE_SIZE = (VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA - VK_BLEND_FACTOR_ZERO + 1),
1084     VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF
1085 } VkBlendFactor;
1086
1087 typedef enum VkBlendOp {
1088     VK_BLEND_OP_ADD = 0,
1089     VK_BLEND_OP_SUBTRACT = 1,
1090     VK_BLEND_OP_REVERSE_SUBTRACT = 2,
1091     VK_BLEND_OP_MIN = 3,
1092     VK_BLEND_OP_MAX = 4,
1093     VK_BLEND_OP_ZERO_EXT = 1000148000,
1094     VK_BLEND_OP_SRC_EXT = 1000148001,
1095     VK_BLEND_OP_DST_EXT = 1000148002,
1096     VK_BLEND_OP_SRC_OVER_EXT = 1000148003,
1097     VK_BLEND_OP_DST_OVER_EXT = 1000148004,
1098     VK_BLEND_OP_SRC_IN_EXT = 1000148005,
1099     VK_BLEND_OP_DST_IN_EXT = 1000148006,
1100     VK_BLEND_OP_SRC_OUT_EXT = 1000148007,
1101     VK_BLEND_OP_DST_OUT_EXT = 1000148008,
1102     VK_BLEND_OP_SRC_ATOP_EXT = 1000148009,
1103     VK_BLEND_OP_DST_ATOP_EXT = 1000148010,
1104     VK_BLEND_OP_XOR_EXT = 1000148011,
1105     VK_BLEND_OP_MULTIPLY_EXT = 1000148012,
1106     VK_BLEND_OP_SCREEN_EXT = 1000148013,
1107     VK_BLEND_OP_OVERLAY_EXT = 1000148014,
1108     VK_BLEND_OP_DARKEN_EXT = 1000148015,
1109     VK_BLEND_OP_LIGHTEN_EXT = 1000148016,
1110     VK_BLEND_OP_COLORDODGE_EXT = 1000148017,
1111     VK_BLEND_OP_COLORBURN_EXT = 1000148018,
1112     VK_BLEND_OP_HARDLIGHT_EXT = 1000148019,
1113     VK_BLEND_OP_SOFTLIGHT_EXT = 1000148020,
1114     VK_BLEND_OP_DIFFERENCE_EXT = 1000148021,
1115     VK_BLEND_OP_EXCLUSION_EXT = 1000148022,
1116     VK_BLEND_OP_INVERT_EXT = 1000148023,
1117     VK_BLEND_OP_INVERT_RGB_EXT = 1000148024,
1118     VK_BLEND_OP_LINEARDODGE_EXT = 1000148025,
1119     VK_BLEND_OP_LINEARBURN_EXT = 1000148026,
1120     VK_BLEND_OP_VIVIDLIGHT_EXT = 1000148027,
1121     VK_BLEND_OP_LINEARLIGHT_EXT = 1000148028,
1122     VK_BLEND_OP_PINLIGHT_EXT = 1000148029,
1123     VK_BLEND_OP_HARDMIX_EXT = 1000148030,
1124     VK_BLEND_OP_HSL_HUE_EXT = 1000148031,
1125     VK_BLEND_OP_HSL_SATURATION_EXT = 1000148032,
1126     VK_BLEND_OP_HSL_COLOR_EXT = 1000148033,
1127     VK_BLEND_OP_HSL_LUMINOSITY_EXT = 1000148034,
1128     VK_BLEND_OP_PLUS_EXT = 1000148035,
1129     VK_BLEND_OP_PLUS_CLAMPED_EXT = 1000148036,
1130     VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT = 1000148037,
1131     VK_BLEND_OP_PLUS_DARKER_EXT = 1000148038,
1132     VK_BLEND_OP_MINUS_EXT = 1000148039,
1133     VK_BLEND_OP_MINUS_CLAMPED_EXT = 1000148040,
1134     VK_BLEND_OP_CONTRAST_EXT = 1000148041,
1135     VK_BLEND_OP_INVERT_OVG_EXT = 1000148042,
1136     VK_BLEND_OP_RED_EXT = 1000148043,
1137     VK_BLEND_OP_GREEN_EXT = 1000148044,
1138     VK_BLEND_OP_BLUE_EXT = 1000148045,
1139     VK_BLEND_OP_BEGIN_RANGE = VK_BLEND_OP_ADD,
1140     VK_BLEND_OP_END_RANGE = VK_BLEND_OP_MAX,
1141     VK_BLEND_OP_RANGE_SIZE = (VK_BLEND_OP_MAX - VK_BLEND_OP_ADD + 1),
1142     VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF
1143 } VkBlendOp;
1144
1145 typedef enum VkDynamicState {
1146     VK_DYNAMIC_STATE_VIEWPORT = 0,
1147     VK_DYNAMIC_STATE_SCISSOR = 1,
1148     VK_DYNAMIC_STATE_LINE_WIDTH = 2,
1149     VK_DYNAMIC_STATE_DEPTH_BIAS = 3,
1150     VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4,
1151     VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5,
1152     VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6,
1153     VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7,
1154     VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8,
1155     VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV = 1000087000,
1156     VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = 1000099000,
1157     VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT = 1000143000,
1158     VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV = 1000164004,
1159     VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV = 1000164006,
1160     VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV = 1000205001,
1161     VK_DYNAMIC_STATE_BEGIN_RANGE = VK_DYNAMIC_STATE_VIEWPORT,
1162     VK_DYNAMIC_STATE_END_RANGE = VK_DYNAMIC_STATE_STENCIL_REFERENCE,
1163     VK_DYNAMIC_STATE_RANGE_SIZE = (VK_DYNAMIC_STATE_STENCIL_REFERENCE - VK_DYNAMIC_STATE_VIEWPORT + 1),
1164     VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF
1165 } VkDynamicState;
1166
1167 typedef enum VkFilter {
1168     VK_FILTER_NEAREST = 0,
1169     VK_FILTER_LINEAR = 1,
1170     VK_FILTER_CUBIC_IMG = 1000015000,
1171     VK_FILTER_CUBIC_EXT = VK_FILTER_CUBIC_IMG,
1172     VK_FILTER_BEGIN_RANGE = VK_FILTER_NEAREST,
1173     VK_FILTER_END_RANGE = VK_FILTER_LINEAR,
1174     VK_FILTER_RANGE_SIZE = (VK_FILTER_LINEAR - VK_FILTER_NEAREST + 1),
1175     VK_FILTER_MAX_ENUM = 0x7FFFFFFF
1176 } VkFilter;
1177
1178 typedef enum VkSamplerMipmapMode {
1179     VK_SAMPLER_MIPMAP_MODE_NEAREST = 0,
1180     VK_SAMPLER_MIPMAP_MODE_LINEAR = 1,
1181     VK_SAMPLER_MIPMAP_MODE_BEGIN_RANGE = VK_SAMPLER_MIPMAP_MODE_NEAREST,
1182     VK_SAMPLER_MIPMAP_MODE_END_RANGE = VK_SAMPLER_MIPMAP_MODE_LINEAR,
1183     VK_SAMPLER_MIPMAP_MODE_RANGE_SIZE = (VK_SAMPLER_MIPMAP_MODE_LINEAR - VK_SAMPLER_MIPMAP_MODE_NEAREST + 1),
1184     VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF
1185 } VkSamplerMipmapMode;
1186
1187 typedef enum VkSamplerAddressMode {
1188     VK_SAMPLER_ADDRESS_MODE_REPEAT = 0,
1189     VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1,
1190     VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2,
1191     VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3,
1192     VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4,
1193     VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE = VK_SAMPLER_ADDRESS_MODE_REPEAT,
1194     VK_SAMPLER_ADDRESS_MODE_END_RANGE = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,
1195     VK_SAMPLER_ADDRESS_MODE_RANGE_SIZE = (VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER - VK_SAMPLER_ADDRESS_MODE_REPEAT + 1),
1196     VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF
1197 } VkSamplerAddressMode;
1198
1199 typedef enum VkBorderColor {
1200     VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0,
1201     VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1,
1202     VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2,
1203     VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3,
1204     VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4,
1205     VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5,
1206     VK_BORDER_COLOR_BEGIN_RANGE = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
1207     VK_BORDER_COLOR_END_RANGE = VK_BORDER_COLOR_INT_OPAQUE_WHITE,
1208     VK_BORDER_COLOR_RANGE_SIZE = (VK_BORDER_COLOR_INT_OPAQUE_WHITE - VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK + 1),
1209     VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF
1210 } VkBorderColor;
1211
1212 typedef enum VkDescriptorType {
1213     VK_DESCRIPTOR_TYPE_SAMPLER = 0,
1214     VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1,
1215     VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2,
1216     VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3,
1217     VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4,
1218     VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5,
1219     VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6,
1220     VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7,
1221     VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8,
1222     VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9,
1223     VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10,
1224     VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT = 1000138000,
1225     VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000,
1226     VK_DESCRIPTOR_TYPE_BEGIN_RANGE = VK_DESCRIPTOR_TYPE_SAMPLER,
1227     VK_DESCRIPTOR_TYPE_END_RANGE = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
1228     VK_DESCRIPTOR_TYPE_RANGE_SIZE = (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT - VK_DESCRIPTOR_TYPE_SAMPLER + 1),
1229     VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF
1230 } VkDescriptorType;
1231
1232 typedef enum VkAttachmentLoadOp {
1233     VK_ATTACHMENT_LOAD_OP_LOAD = 0,
1234     VK_ATTACHMENT_LOAD_OP_CLEAR = 1,
1235     VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2,
1236     VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE = VK_ATTACHMENT_LOAD_OP_LOAD,
1237     VK_ATTACHMENT_LOAD_OP_END_RANGE = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
1238     VK_ATTACHMENT_LOAD_OP_RANGE_SIZE = (VK_ATTACHMENT_LOAD_OP_DONT_CARE - VK_ATTACHMENT_LOAD_OP_LOAD + 1),
1239     VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF
1240 } VkAttachmentLoadOp;
1241
1242 typedef enum VkAttachmentStoreOp {
1243     VK_ATTACHMENT_STORE_OP_STORE = 0,
1244     VK_ATTACHMENT_STORE_OP_DONT_CARE = 1,
1245     VK_ATTACHMENT_STORE_OP_BEGIN_RANGE = VK_ATTACHMENT_STORE_OP_STORE,
1246     VK_ATTACHMENT_STORE_OP_END_RANGE = VK_ATTACHMENT_STORE_OP_DONT_CARE,
1247     VK_ATTACHMENT_STORE_OP_RANGE_SIZE = (VK_ATTACHMENT_STORE_OP_DONT_CARE - VK_ATTACHMENT_STORE_OP_STORE + 1),
1248     VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF
1249 } VkAttachmentStoreOp;
1250
1251 typedef enum VkPipelineBindPoint {
1252     VK_PIPELINE_BIND_POINT_GRAPHICS = 0,
1253     VK_PIPELINE_BIND_POINT_COMPUTE = 1,
1254     VK_PIPELINE_BIND_POINT_RAY_TRACING_NV = 1000165000,
1255     VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VK_PIPELINE_BIND_POINT_GRAPHICS,
1256     VK_PIPELINE_BIND_POINT_END_RANGE = VK_PIPELINE_BIND_POINT_COMPUTE,
1257     VK_PIPELINE_BIND_POINT_RANGE_SIZE = (VK_PIPELINE_BIND_POINT_COMPUTE - VK_PIPELINE_BIND_POINT_GRAPHICS + 1),
1258     VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF
1259 } VkPipelineBindPoint;
1260
1261 typedef enum VkCommandBufferLevel {
1262     VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0,
1263     VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1,
1264     VK_COMMAND_BUFFER_LEVEL_BEGIN_RANGE = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
1265     VK_COMMAND_BUFFER_LEVEL_END_RANGE = VK_COMMAND_BUFFER_LEVEL_SECONDARY,
1266     VK_COMMAND_BUFFER_LEVEL_RANGE_SIZE = (VK_COMMAND_BUFFER_LEVEL_SECONDARY - VK_COMMAND_BUFFER_LEVEL_PRIMARY + 1),
1267     VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF
1268 } VkCommandBufferLevel;
1269
1270 typedef enum VkIndexType {
1271     VK_INDEX_TYPE_UINT16 = 0,
1272     VK_INDEX_TYPE_UINT32 = 1,
1273     VK_INDEX_TYPE_NONE_NV = 1000165000,
1274     VK_INDEX_TYPE_BEGIN_RANGE = VK_INDEX_TYPE_UINT16,
1275     VK_INDEX_TYPE_END_RANGE = VK_INDEX_TYPE_UINT32,
1276     VK_INDEX_TYPE_RANGE_SIZE = (VK_INDEX_TYPE_UINT32 - VK_INDEX_TYPE_UINT16 + 1),
1277     VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF
1278 } VkIndexType;
1279
1280 typedef enum VkSubpassContents {
1281     VK_SUBPASS_CONTENTS_INLINE = 0,
1282     VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1,
1283     VK_SUBPASS_CONTENTS_BEGIN_RANGE = VK_SUBPASS_CONTENTS_INLINE,
1284     VK_SUBPASS_CONTENTS_END_RANGE = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS,
1285     VK_SUBPASS_CONTENTS_RANGE_SIZE = (VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS - VK_SUBPASS_CONTENTS_INLINE + 1),
1286     VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF
1287 } VkSubpassContents;
1288
1289 typedef enum VkObjectType {
1290     VK_OBJECT_TYPE_UNKNOWN = 0,
1291     VK_OBJECT_TYPE_INSTANCE = 1,
1292     VK_OBJECT_TYPE_PHYSICAL_DEVICE = 2,
1293     VK_OBJECT_TYPE_DEVICE = 3,
1294     VK_OBJECT_TYPE_QUEUE = 4,
1295     VK_OBJECT_TYPE_SEMAPHORE = 5,
1296     VK_OBJECT_TYPE_COMMAND_BUFFER = 6,
1297     VK_OBJECT_TYPE_FENCE = 7,
1298     VK_OBJECT_TYPE_DEVICE_MEMORY = 8,
1299     VK_OBJECT_TYPE_BUFFER = 9,
1300     VK_OBJECT_TYPE_IMAGE = 10,
1301     VK_OBJECT_TYPE_EVENT = 11,
1302     VK_OBJECT_TYPE_QUERY_POOL = 12,
1303     VK_OBJECT_TYPE_BUFFER_VIEW = 13,
1304     VK_OBJECT_TYPE_IMAGE_VIEW = 14,
1305     VK_OBJECT_TYPE_SHADER_MODULE = 15,
1306     VK_OBJECT_TYPE_PIPELINE_CACHE = 16,
1307     VK_OBJECT_TYPE_PIPELINE_LAYOUT = 17,
1308     VK_OBJECT_TYPE_RENDER_PASS = 18,
1309     VK_OBJECT_TYPE_PIPELINE = 19,
1310     VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 20,
1311     VK_OBJECT_TYPE_SAMPLER = 21,
1312     VK_OBJECT_TYPE_DESCRIPTOR_POOL = 22,
1313     VK_OBJECT_TYPE_DESCRIPTOR_SET = 23,
1314     VK_OBJECT_TYPE_FRAMEBUFFER = 24,
1315     VK_OBJECT_TYPE_COMMAND_POOL = 25,
1316     VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION = 1000156000,
1317     VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE = 1000085000,
1318     VK_OBJECT_TYPE_SURFACE_KHR = 1000000000,
1319     VK_OBJECT_TYPE_SWAPCHAIN_KHR = 1000001000,
1320     VK_OBJECT_TYPE_DISPLAY_KHR = 1000002000,
1321     VK_OBJECT_TYPE_DISPLAY_MODE_KHR = 1000002001,
1322     VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT = 1000011000,
1323     VK_OBJECT_TYPE_OBJECT_TABLE_NVX = 1000086000,
1324     VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX = 1000086001,
1325     VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT = 1000128000,
1326     VK_OBJECT_TYPE_VALIDATION_CACHE_EXT = 1000160000,
1327     VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000,
1328     VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE,
1329     VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION,
1330     VK_OBJECT_TYPE_BEGIN_RANGE = VK_OBJECT_TYPE_UNKNOWN,
1331     VK_OBJECT_TYPE_END_RANGE = VK_OBJECT_TYPE_COMMAND_POOL,
1332     VK_OBJECT_TYPE_RANGE_SIZE = (VK_OBJECT_TYPE_COMMAND_POOL - VK_OBJECT_TYPE_UNKNOWN + 1),
1333     VK_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF
1334 } VkObjectType;
1335
1336 typedef enum VkVendorId {
1337     VK_VENDOR_ID_VIV = 0x10001,
1338     VK_VENDOR_ID_VSI = 0x10002,
1339     VK_VENDOR_ID_KAZAN = 0x10003,
1340     VK_VENDOR_ID_BEGIN_RANGE = VK_VENDOR_ID_VIV,
1341     VK_VENDOR_ID_END_RANGE = VK_VENDOR_ID_KAZAN,
1342     VK_VENDOR_ID_RANGE_SIZE = (VK_VENDOR_ID_KAZAN - VK_VENDOR_ID_VIV + 1),
1343     VK_VENDOR_ID_MAX_ENUM = 0x7FFFFFFF
1344 } VkVendorId;
1345 typedef VkFlags VkInstanceCreateFlags;
1346
1347 typedef enum VkFormatFeatureFlagBits {
1348     VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001,
1349     VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002,
1350     VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004,
1351     VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008,
1352     VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010,
1353     VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020,
1354     VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040,
1355     VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080,
1356     VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100,
1357     VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200,
1358     VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400,
1359     VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800,
1360     VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000,
1361     VK_FORMAT_FEATURE_TRANSFER_SRC_BIT = 0x00004000,
1362     VK_FORMAT_FEATURE_TRANSFER_DST_BIT = 0x00008000,
1363     VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT = 0x00020000,
1364     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT = 0x00040000,
1365     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT = 0x00080000,
1366     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT = 0x00100000,
1367     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT = 0x00200000,
1368     VK_FORMAT_FEATURE_DISJOINT_BIT = 0x00400000,
1369     VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT = 0x00800000,
1370     VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = 0x00002000,
1371     VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT = 0x00010000,
1372     VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x01000000,
1373     VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT,
1374     VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_DST_BIT,
1375     VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT,
1376     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT,
1377     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT,
1378     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT,
1379     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,
1380     VK_FORMAT_FEATURE_DISJOINT_BIT_KHR = VK_FORMAT_FEATURE_DISJOINT_BIT,
1381     VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT,
1382     VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG,
1383     VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1384 } VkFormatFeatureFlagBits;
1385 typedef VkFlags VkFormatFeatureFlags;
1386
1387 typedef enum VkImageUsageFlagBits {
1388     VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001,
1389     VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002,
1390     VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004,
1391     VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008,
1392     VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010,
1393     VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020,
1394     VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040,
1395     VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080,
1396     VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV = 0x00000100,
1397     VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x00000200,
1398     VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1399 } VkImageUsageFlagBits;
1400 typedef VkFlags VkImageUsageFlags;
1401
1402 typedef enum VkImageCreateFlagBits {
1403     VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001,
1404     VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,
1405     VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
1406     VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008,
1407     VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010,
1408     VK_IMAGE_CREATE_ALIAS_BIT = 0x00000400,
1409     VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT = 0x00000040,
1410     VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT = 0x00000020,
1411     VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT = 0x00000080,
1412     VK_IMAGE_CREATE_EXTENDED_USAGE_BIT = 0x00000100,
1413     VK_IMAGE_CREATE_PROTECTED_BIT = 0x00000800,
1414     VK_IMAGE_CREATE_DISJOINT_BIT = 0x00000200,
1415     VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV = 0x00002000,
1416     VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = 0x00001000,
1417     VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT = 0x00004000,
1418     VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT,
1419     VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT,
1420     VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT,
1421     VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT,
1422     VK_IMAGE_CREATE_DISJOINT_BIT_KHR = VK_IMAGE_CREATE_DISJOINT_BIT,
1423     VK_IMAGE_CREATE_ALIAS_BIT_KHR = VK_IMAGE_CREATE_ALIAS_BIT,
1424     VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1425 } VkImageCreateFlagBits;
1426 typedef VkFlags VkImageCreateFlags;
1427
1428 typedef enum VkSampleCountFlagBits {
1429     VK_SAMPLE_COUNT_1_BIT = 0x00000001,
1430     VK_SAMPLE_COUNT_2_BIT = 0x00000002,
1431     VK_SAMPLE_COUNT_4_BIT = 0x00000004,
1432     VK_SAMPLE_COUNT_8_BIT = 0x00000008,
1433     VK_SAMPLE_COUNT_16_BIT = 0x00000010,
1434     VK_SAMPLE_COUNT_32_BIT = 0x00000020,
1435     VK_SAMPLE_COUNT_64_BIT = 0x00000040,
1436     VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1437 } VkSampleCountFlagBits;
1438 typedef VkFlags VkSampleCountFlags;
1439
1440 typedef enum VkQueueFlagBits {
1441     VK_QUEUE_GRAPHICS_BIT = 0x00000001,
1442     VK_QUEUE_COMPUTE_BIT = 0x00000002,
1443     VK_QUEUE_TRANSFER_BIT = 0x00000004,
1444     VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008,
1445     VK_QUEUE_PROTECTED_BIT = 0x00000010,
1446     VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1447 } VkQueueFlagBits;
1448 typedef VkFlags VkQueueFlags;
1449
1450 typedef enum VkMemoryPropertyFlagBits {
1451     VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001,
1452     VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002,
1453     VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004,
1454     VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008,
1455     VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010,
1456     VK_MEMORY_PROPERTY_PROTECTED_BIT = 0x00000020,
1457     VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1458 } VkMemoryPropertyFlagBits;
1459 typedef VkFlags VkMemoryPropertyFlags;
1460
1461 typedef enum VkMemoryHeapFlagBits {
1462     VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001,
1463     VK_MEMORY_HEAP_MULTI_INSTANCE_BIT = 0x00000002,
1464     VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT,
1465     VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1466 } VkMemoryHeapFlagBits;
1467 typedef VkFlags VkMemoryHeapFlags;
1468 typedef VkFlags VkDeviceCreateFlags;
1469
1470 typedef enum VkDeviceQueueCreateFlagBits {
1471     VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT = 0x00000001,
1472     VK_DEVICE_QUEUE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1473 } VkDeviceQueueCreateFlagBits;
1474 typedef VkFlags VkDeviceQueueCreateFlags;
1475
1476 typedef enum VkPipelineStageFlagBits {
1477     VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001,
1478     VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002,
1479     VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004,
1480     VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008,
1481     VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010,
1482     VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020,
1483     VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040,
1484     VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080,
1485     VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100,
1486     VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200,
1487     VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400,
1488     VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800,
1489     VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000,
1490     VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000,
1491     VK_PIPELINE_STAGE_HOST_BIT = 0x00004000,
1492     VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000,
1493     VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000,
1494     VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT = 0x01000000,
1495     VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00040000,
1496     VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX = 0x00020000,
1497     VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV = 0x00400000,
1498     VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV = 0x00200000,
1499     VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV = 0x02000000,
1500     VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV = 0x00080000,
1501     VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV = 0x00100000,
1502     VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT = 0x00800000,
1503     VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1504 } VkPipelineStageFlagBits;
1505 typedef VkFlags VkPipelineStageFlags;
1506 typedef VkFlags VkMemoryMapFlags;
1507
1508 typedef enum VkImageAspectFlagBits {
1509     VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001,
1510     VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002,
1511     VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004,
1512     VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008,
1513     VK_IMAGE_ASPECT_PLANE_0_BIT = 0x00000010,
1514     VK_IMAGE_ASPECT_PLANE_1_BIT = 0x00000020,
1515     VK_IMAGE_ASPECT_PLANE_2_BIT = 0x00000040,
1516     VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT = 0x00000080,
1517     VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT = 0x00000100,
1518     VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT = 0x00000200,
1519     VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT = 0x00000400,
1520     VK_IMAGE_ASPECT_PLANE_0_BIT_KHR = VK_IMAGE_ASPECT_PLANE_0_BIT,
1521     VK_IMAGE_ASPECT_PLANE_1_BIT_KHR = VK_IMAGE_ASPECT_PLANE_1_BIT,
1522     VK_IMAGE_ASPECT_PLANE_2_BIT_KHR = VK_IMAGE_ASPECT_PLANE_2_BIT,
1523     VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1524 } VkImageAspectFlagBits;
1525 typedef VkFlags VkImageAspectFlags;
1526
1527 typedef enum VkSparseImageFormatFlagBits {
1528     VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001,
1529     VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002,
1530     VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004,
1531     VK_SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1532 } VkSparseImageFormatFlagBits;
1533 typedef VkFlags VkSparseImageFormatFlags;
1534
1535 typedef enum VkSparseMemoryBindFlagBits {
1536     VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0x00000001,
1537     VK_SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1538 } VkSparseMemoryBindFlagBits;
1539 typedef VkFlags VkSparseMemoryBindFlags;
1540
1541 typedef enum VkFenceCreateFlagBits {
1542     VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001,
1543     VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1544 } VkFenceCreateFlagBits;
1545 typedef VkFlags VkFenceCreateFlags;
1546 typedef VkFlags VkSemaphoreCreateFlags;
1547 typedef VkFlags VkEventCreateFlags;
1548 typedef VkFlags VkQueryPoolCreateFlags;
1549
1550 typedef enum VkQueryPipelineStatisticFlagBits {
1551     VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001,
1552     VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002,
1553     VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004,
1554     VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008,
1555     VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0x00000010,
1556     VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0x00000020,
1557     VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0x00000040,
1558     VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0x00000080,
1559     VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x00000100,
1560     VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0x00000200,
1561     VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400,
1562     VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1563 } VkQueryPipelineStatisticFlagBits;
1564 typedef VkFlags VkQueryPipelineStatisticFlags;
1565
1566 typedef enum VkQueryResultFlagBits {
1567     VK_QUERY_RESULT_64_BIT = 0x00000001,
1568     VK_QUERY_RESULT_WAIT_BIT = 0x00000002,
1569     VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004,
1570     VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008,
1571     VK_QUERY_RESULT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1572 } VkQueryResultFlagBits;
1573 typedef VkFlags VkQueryResultFlags;
1574
1575 typedef enum VkBufferCreateFlagBits {
1576     VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001,
1577     VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,
1578     VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
1579     VK_BUFFER_CREATE_PROTECTED_BIT = 0x00000008,
1580     VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT = 0x00000010,
1581     VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1582 } VkBufferCreateFlagBits;
1583 typedef VkFlags VkBufferCreateFlags;
1584
1585 typedef enum VkBufferUsageFlagBits {
1586     VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001,
1587     VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002,
1588     VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004,
1589     VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008,
1590     VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010,
1591     VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020,
1592     VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040,
1593     VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080,
1594     VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100,
1595     VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT = 0x00000800,
1596     VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT = 0x00001000,
1597     VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00000200,
1598     VK_BUFFER_USAGE_RAY_TRACING_BIT_NV = 0x00000400,
1599     VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT = 0x00020000,
1600     VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1601 } VkBufferUsageFlagBits;
1602 typedef VkFlags VkBufferUsageFlags;
1603 typedef VkFlags VkBufferViewCreateFlags;
1604
1605 typedef enum VkImageViewCreateFlagBits {
1606     VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT = 0x00000001,
1607     VK_IMAGE_VIEW_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1608 } VkImageViewCreateFlagBits;
1609 typedef VkFlags VkImageViewCreateFlags;
1610 typedef VkFlags VkShaderModuleCreateFlags;
1611 typedef VkFlags VkPipelineCacheCreateFlags;
1612
1613 typedef enum VkPipelineCreateFlagBits {
1614     VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001,
1615     VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002,
1616     VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004,
1617     VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0x00000008,
1618     VK_PIPELINE_CREATE_DISPATCH_BASE = 0x00000010,
1619     VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV = 0x00000020,
1620     VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT,
1621     VK_PIPELINE_CREATE_DISPATCH_BASE_KHR = VK_PIPELINE_CREATE_DISPATCH_BASE,
1622     VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1623 } VkPipelineCreateFlagBits;
1624 typedef VkFlags VkPipelineCreateFlags;
1625 typedef VkFlags VkPipelineShaderStageCreateFlags;
1626
1627 typedef enum VkShaderStageFlagBits {
1628     VK_SHADER_STAGE_VERTEX_BIT = 0x00000001,
1629     VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002,
1630     VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004,
1631     VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008,
1632     VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010,
1633     VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020,
1634     VK_SHADER_STAGE_ALL_GRAPHICS = 0x0000001F,
1635     VK_SHADER_STAGE_ALL = 0x7FFFFFFF,
1636     VK_SHADER_STAGE_RAYGEN_BIT_NV = 0x00000100,
1637     VK_SHADER_STAGE_ANY_HIT_BIT_NV = 0x00000200,
1638     VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV = 0x00000400,
1639     VK_SHADER_STAGE_MISS_BIT_NV = 0x00000800,
1640     VK_SHADER_STAGE_INTERSECTION_BIT_NV = 0x00001000,
1641     VK_SHADER_STAGE_CALLABLE_BIT_NV = 0x00002000,
1642     VK_SHADER_STAGE_TASK_BIT_NV = 0x00000040,
1643     VK_SHADER_STAGE_MESH_BIT_NV = 0x00000080,
1644     VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1645 } VkShaderStageFlagBits;
1646 typedef VkFlags VkPipelineVertexInputStateCreateFlags;
1647 typedef VkFlags VkPipelineInputAssemblyStateCreateFlags;
1648 typedef VkFlags VkPipelineTessellationStateCreateFlags;
1649 typedef VkFlags VkPipelineViewportStateCreateFlags;
1650 typedef VkFlags VkPipelineRasterizationStateCreateFlags;
1651
1652 typedef enum VkCullModeFlagBits {
1653     VK_CULL_MODE_NONE = 0,
1654     VK_CULL_MODE_FRONT_BIT = 0x00000001,
1655     VK_CULL_MODE_BACK_BIT = 0x00000002,
1656     VK_CULL_MODE_FRONT_AND_BACK = 0x00000003,
1657     VK_CULL_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1658 } VkCullModeFlagBits;
1659 typedef VkFlags VkCullModeFlags;
1660 typedef VkFlags VkPipelineMultisampleStateCreateFlags;
1661 typedef VkFlags VkPipelineDepthStencilStateCreateFlags;
1662 typedef VkFlags VkPipelineColorBlendStateCreateFlags;
1663
1664 typedef enum VkColorComponentFlagBits {
1665     VK_COLOR_COMPONENT_R_BIT = 0x00000001,
1666     VK_COLOR_COMPONENT_G_BIT = 0x00000002,
1667     VK_COLOR_COMPONENT_B_BIT = 0x00000004,
1668     VK_COLOR_COMPONENT_A_BIT = 0x00000008,
1669     VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1670 } VkColorComponentFlagBits;
1671 typedef VkFlags VkColorComponentFlags;
1672 typedef VkFlags VkPipelineDynamicStateCreateFlags;
1673 typedef VkFlags VkPipelineLayoutCreateFlags;
1674 typedef VkFlags VkShaderStageFlags;
1675
1676 typedef enum VkSamplerCreateFlagBits {
1677     VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT = 0x00000001,
1678     VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT = 0x00000002,
1679     VK_SAMPLER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1680 } VkSamplerCreateFlagBits;
1681 typedef VkFlags VkSamplerCreateFlags;
1682
1683 typedef enum VkDescriptorSetLayoutCreateFlagBits {
1684     VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR = 0x00000001,
1685     VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT = 0x00000002,
1686     VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1687 } VkDescriptorSetLayoutCreateFlagBits;
1688 typedef VkFlags VkDescriptorSetLayoutCreateFlags;
1689
1690 typedef enum VkDescriptorPoolCreateFlagBits {
1691     VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001,
1692     VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT = 0x00000002,
1693     VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1694 } VkDescriptorPoolCreateFlagBits;
1695 typedef VkFlags VkDescriptorPoolCreateFlags;
1696 typedef VkFlags VkDescriptorPoolResetFlags;
1697 typedef VkFlags VkFramebufferCreateFlags;
1698 typedef VkFlags VkRenderPassCreateFlags;
1699
1700 typedef enum VkAttachmentDescriptionFlagBits {
1701     VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001,
1702     VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1703 } VkAttachmentDescriptionFlagBits;
1704 typedef VkFlags VkAttachmentDescriptionFlags;
1705
1706 typedef enum VkSubpassDescriptionFlagBits {
1707     VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX = 0x00000001,
1708     VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX = 0x00000002,
1709     VK_SUBPASS_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1710 } VkSubpassDescriptionFlagBits;
1711 typedef VkFlags VkSubpassDescriptionFlags;
1712
1713 typedef enum VkAccessFlagBits {
1714     VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001,
1715     VK_ACCESS_INDEX_READ_BIT = 0x00000002,
1716     VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004,
1717     VK_ACCESS_UNIFORM_READ_BIT = 0x00000008,
1718     VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0x00000010,
1719     VK_ACCESS_SHADER_READ_BIT = 0x00000020,
1720     VK_ACCESS_SHADER_WRITE_BIT = 0x00000040,
1721     VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0x00000080,
1722     VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100,
1723     VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200,
1724     VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400,
1725     VK_ACCESS_TRANSFER_READ_BIT = 0x00000800,
1726     VK_ACCESS_TRANSFER_WRITE_BIT = 0x00001000,
1727     VK_ACCESS_HOST_READ_BIT = 0x00002000,
1728     VK_ACCESS_HOST_WRITE_BIT = 0x00004000,
1729     VK_ACCESS_MEMORY_READ_BIT = 0x00008000,
1730     VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000,
1731     VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT = 0x02000000,
1732     VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT = 0x04000000,
1733     VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT = 0x08000000,
1734     VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT = 0x00100000,
1735     VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX = 0x00020000,
1736     VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX = 0x00040000,
1737     VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000,
1738     VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV = 0x00800000,
1739     VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV = 0x00200000,
1740     VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV = 0x00400000,
1741     VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT = 0x01000000,
1742     VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1743 } VkAccessFlagBits;
1744 typedef VkFlags VkAccessFlags;
1745
1746 typedef enum VkDependencyFlagBits {
1747     VK_DEPENDENCY_BY_REGION_BIT = 0x00000001,
1748     VK_DEPENDENCY_DEVICE_GROUP_BIT = 0x00000004,
1749     VK_DEPENDENCY_VIEW_LOCAL_BIT = 0x00000002,
1750     VK_DEPENDENCY_VIEW_LOCAL_BIT_KHR = VK_DEPENDENCY_VIEW_LOCAL_BIT,
1751     VK_DEPENDENCY_DEVICE_GROUP_BIT_KHR = VK_DEPENDENCY_DEVICE_GROUP_BIT,
1752     VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1753 } VkDependencyFlagBits;
1754 typedef VkFlags VkDependencyFlags;
1755
1756 typedef enum VkCommandPoolCreateFlagBits {
1757     VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001,
1758     VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002,
1759     VK_COMMAND_POOL_CREATE_PROTECTED_BIT = 0x00000004,
1760     VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1761 } VkCommandPoolCreateFlagBits;
1762 typedef VkFlags VkCommandPoolCreateFlags;
1763
1764 typedef enum VkCommandPoolResetFlagBits {
1765     VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
1766     VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1767 } VkCommandPoolResetFlagBits;
1768 typedef VkFlags VkCommandPoolResetFlags;
1769
1770 typedef enum VkCommandBufferUsageFlagBits {
1771     VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001,
1772     VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002,
1773     VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004,
1774     VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1775 } VkCommandBufferUsageFlagBits;
1776 typedef VkFlags VkCommandBufferUsageFlags;
1777
1778 typedef enum VkQueryControlFlagBits {
1779     VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001,
1780     VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1781 } VkQueryControlFlagBits;
1782 typedef VkFlags VkQueryControlFlags;
1783
1784 typedef enum VkCommandBufferResetFlagBits {
1785     VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
1786     VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1787 } VkCommandBufferResetFlagBits;
1788 typedef VkFlags VkCommandBufferResetFlags;
1789
1790 typedef enum VkStencilFaceFlagBits {
1791     VK_STENCIL_FACE_FRONT_BIT = 0x00000001,
1792     VK_STENCIL_FACE_BACK_BIT = 0x00000002,
1793     VK_STENCIL_FRONT_AND_BACK = 0x00000003,
1794     VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1795 } VkStencilFaceFlagBits;
1796 typedef VkFlags VkStencilFaceFlags;
1797 typedef struct VkApplicationInfo {
1798     VkStructureType    sType;
1799     const void*        pNext;
1800     const char*        pApplicationName;
1801     uint32_t           applicationVersion;
1802     const char*        pEngineName;
1803     uint32_t           engineVersion;
1804     uint32_t           apiVersion;
1805 } VkApplicationInfo;
1806
1807 typedef struct VkInstanceCreateInfo {
1808     VkStructureType             sType;
1809     const void*                 pNext;
1810     VkInstanceCreateFlags       flags;
1811     const VkApplicationInfo*    pApplicationInfo;
1812     uint32_t                    enabledLayerCount;
1813     const char* const*          ppEnabledLayerNames;
1814     uint32_t                    enabledExtensionCount;
1815     const char* const*          ppEnabledExtensionNames;
1816 } VkInstanceCreateInfo;
1817
1818 typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)(
1819     void*                                       pUserData,
1820     size_t                                      size,
1821     size_t                                      alignment,
1822     VkSystemAllocationScope                     allocationScope);
1823
1824 typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)(
1825     void*                                       pUserData,
1826     void*                                       pOriginal,
1827     size_t                                      size,
1828     size_t                                      alignment,
1829     VkSystemAllocationScope                     allocationScope);
1830
1831 typedef void (VKAPI_PTR *PFN_vkFreeFunction)(
1832     void*                                       pUserData,
1833     void*                                       pMemory);
1834
1835 typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)(
1836     void*                                       pUserData,
1837     size_t                                      size,
1838     VkInternalAllocationType                    allocationType,
1839     VkSystemAllocationScope                     allocationScope);
1840
1841 typedef void (VKAPI_PTR *PFN_vkInternalFreeNotification)(
1842     void*                                       pUserData,
1843     size_t                                      size,
1844     VkInternalAllocationType                    allocationType,
1845     VkSystemAllocationScope                     allocationScope);
1846
1847 typedef struct VkAllocationCallbacks {
1848     void*                                   pUserData;
1849     PFN_vkAllocationFunction                pfnAllocation;
1850     PFN_vkReallocationFunction              pfnReallocation;
1851     PFN_vkFreeFunction                      pfnFree;
1852     PFN_vkInternalAllocationNotification    pfnInternalAllocation;
1853     PFN_vkInternalFreeNotification          pfnInternalFree;
1854 } VkAllocationCallbacks;
1855
1856 typedef struct VkPhysicalDeviceFeatures {
1857     VkBool32    robustBufferAccess;
1858     VkBool32    fullDrawIndexUint32;
1859     VkBool32    imageCubeArray;
1860     VkBool32    independentBlend;
1861     VkBool32    geometryShader;
1862     VkBool32    tessellationShader;
1863     VkBool32    sampleRateShading;
1864     VkBool32    dualSrcBlend;
1865     VkBool32    logicOp;
1866     VkBool32    multiDrawIndirect;
1867     VkBool32    drawIndirectFirstInstance;
1868     VkBool32    depthClamp;
1869     VkBool32    depthBiasClamp;
1870     VkBool32    fillModeNonSolid;
1871     VkBool32    depthBounds;
1872     VkBool32    wideLines;
1873     VkBool32    largePoints;
1874     VkBool32    alphaToOne;
1875     VkBool32    multiViewport;
1876     VkBool32    samplerAnisotropy;
1877     VkBool32    textureCompressionETC2;
1878     VkBool32    textureCompressionASTC_LDR;
1879     VkBool32    textureCompressionBC;
1880     VkBool32    occlusionQueryPrecise;
1881     VkBool32    pipelineStatisticsQuery;
1882     VkBool32    vertexPipelineStoresAndAtomics;
1883     VkBool32    fragmentStoresAndAtomics;
1884     VkBool32    shaderTessellationAndGeometryPointSize;
1885     VkBool32    shaderImageGatherExtended;
1886     VkBool32    shaderStorageImageExtendedFormats;
1887     VkBool32    shaderStorageImageMultisample;
1888     VkBool32    shaderStorageImageReadWithoutFormat;
1889     VkBool32    shaderStorageImageWriteWithoutFormat;
1890     VkBool32    shaderUniformBufferArrayDynamicIndexing;
1891     VkBool32    shaderSampledImageArrayDynamicIndexing;
1892     VkBool32    shaderStorageBufferArrayDynamicIndexing;
1893     VkBool32    shaderStorageImageArrayDynamicIndexing;
1894     VkBool32    shaderClipDistance;
1895     VkBool32    shaderCullDistance;
1896     VkBool32    shaderFloat64;
1897     VkBool32    shaderInt64;
1898     VkBool32    shaderInt16;
1899     VkBool32    shaderResourceResidency;
1900     VkBool32    shaderResourceMinLod;
1901     VkBool32    sparseBinding;
1902     VkBool32    sparseResidencyBuffer;
1903     VkBool32    sparseResidencyImage2D;
1904     VkBool32    sparseResidencyImage3D;
1905     VkBool32    sparseResidency2Samples;
1906     VkBool32    sparseResidency4Samples;
1907     VkBool32    sparseResidency8Samples;
1908     VkBool32    sparseResidency16Samples;
1909     VkBool32    sparseResidencyAliased;
1910     VkBool32    variableMultisampleRate;
1911     VkBool32    inheritedQueries;
1912 } VkPhysicalDeviceFeatures;
1913
1914 typedef struct VkFormatProperties {
1915     VkFormatFeatureFlags    linearTilingFeatures;
1916     VkFormatFeatureFlags    optimalTilingFeatures;
1917     VkFormatFeatureFlags    bufferFeatures;
1918 } VkFormatProperties;
1919
1920 typedef struct VkExtent3D {
1921     uint32_t    width;
1922     uint32_t    height;
1923     uint32_t    depth;
1924 } VkExtent3D;
1925
1926 typedef struct VkImageFormatProperties {
1927     VkExtent3D            maxExtent;
1928     uint32_t              maxMipLevels;
1929     uint32_t              maxArrayLayers;
1930     VkSampleCountFlags    sampleCounts;
1931     VkDeviceSize          maxResourceSize;
1932 } VkImageFormatProperties;
1933
1934 typedef struct VkPhysicalDeviceLimits {
1935     uint32_t              maxImageDimension1D;
1936     uint32_t              maxImageDimension2D;
1937     uint32_t              maxImageDimension3D;
1938     uint32_t              maxImageDimensionCube;
1939     uint32_t              maxImageArrayLayers;
1940     uint32_t              maxTexelBufferElements;
1941     uint32_t              maxUniformBufferRange;
1942     uint32_t              maxStorageBufferRange;
1943     uint32_t              maxPushConstantsSize;
1944     uint32_t              maxMemoryAllocationCount;
1945     uint32_t              maxSamplerAllocationCount;
1946     VkDeviceSize          bufferImageGranularity;
1947     VkDeviceSize          sparseAddressSpaceSize;
1948     uint32_t              maxBoundDescriptorSets;
1949     uint32_t              maxPerStageDescriptorSamplers;
1950     uint32_t              maxPerStageDescriptorUniformBuffers;
1951     uint32_t              maxPerStageDescriptorStorageBuffers;
1952     uint32_t              maxPerStageDescriptorSampledImages;
1953     uint32_t              maxPerStageDescriptorStorageImages;
1954     uint32_t              maxPerStageDescriptorInputAttachments;
1955     uint32_t              maxPerStageResources;
1956     uint32_t              maxDescriptorSetSamplers;
1957     uint32_t              maxDescriptorSetUniformBuffers;
1958     uint32_t              maxDescriptorSetUniformBuffersDynamic;
1959     uint32_t              maxDescriptorSetStorageBuffers;
1960     uint32_t              maxDescriptorSetStorageBuffersDynamic;
1961     uint32_t              maxDescriptorSetSampledImages;
1962     uint32_t              maxDescriptorSetStorageImages;
1963     uint32_t              maxDescriptorSetInputAttachments;
1964     uint32_t              maxVertexInputAttributes;
1965     uint32_t              maxVertexInputBindings;
1966     uint32_t              maxVertexInputAttributeOffset;
1967     uint32_t              maxVertexInputBindingStride;
1968     uint32_t              maxVertexOutputComponents;
1969     uint32_t              maxTessellationGenerationLevel;
1970     uint32_t              maxTessellationPatchSize;
1971     uint32_t              maxTessellationControlPerVertexInputComponents;
1972     uint32_t              maxTessellationControlPerVertexOutputComponents;
1973     uint32_t              maxTessellationControlPerPatchOutputComponents;
1974     uint32_t              maxTessellationControlTotalOutputComponents;
1975     uint32_t              maxTessellationEvaluationInputComponents;
1976     uint32_t              maxTessellationEvaluationOutputComponents;
1977     uint32_t              maxGeometryShaderInvocations;
1978     uint32_t              maxGeometryInputComponents;
1979     uint32_t              maxGeometryOutputComponents;
1980     uint32_t              maxGeometryOutputVertices;
1981     uint32_t              maxGeometryTotalOutputComponents;
1982     uint32_t              maxFragmentInputComponents;
1983     uint32_t              maxFragmentOutputAttachments;
1984     uint32_t              maxFragmentDualSrcAttachments;
1985     uint32_t              maxFragmentCombinedOutputResources;
1986     uint32_t              maxComputeSharedMemorySize;
1987     uint32_t              maxComputeWorkGroupCount[3];
1988     uint32_t              maxComputeWorkGroupInvocations;
1989     uint32_t              maxComputeWorkGroupSize[3];
1990     uint32_t              subPixelPrecisionBits;
1991     uint32_t              subTexelPrecisionBits;
1992     uint32_t              mipmapPrecisionBits;
1993     uint32_t              maxDrawIndexedIndexValue;
1994     uint32_t              maxDrawIndirectCount;
1995     float                 maxSamplerLodBias;
1996     float                 maxSamplerAnisotropy;
1997     uint32_t              maxViewports;
1998     uint32_t              maxViewportDimensions[2];
1999     float                 viewportBoundsRange[2];
2000     uint32_t              viewportSubPixelBits;
2001     size_t                minMemoryMapAlignment;
2002     VkDeviceSize          minTexelBufferOffsetAlignment;
2003     VkDeviceSize          minUniformBufferOffsetAlignment;
2004     VkDeviceSize          minStorageBufferOffsetAlignment;
2005     int32_t               minTexelOffset;
2006     uint32_t              maxTexelOffset;
2007     int32_t               minTexelGatherOffset;
2008     uint32_t              maxTexelGatherOffset;
2009     float                 minInterpolationOffset;
2010     float                 maxInterpolationOffset;
2011     uint32_t              subPixelInterpolationOffsetBits;
2012     uint32_t              maxFramebufferWidth;
2013     uint32_t              maxFramebufferHeight;
2014     uint32_t              maxFramebufferLayers;
2015     VkSampleCountFlags    framebufferColorSampleCounts;
2016     VkSampleCountFlags    framebufferDepthSampleCounts;
2017     VkSampleCountFlags    framebufferStencilSampleCounts;
2018     VkSampleCountFlags    framebufferNoAttachmentsSampleCounts;
2019     uint32_t              maxColorAttachments;
2020     VkSampleCountFlags    sampledImageColorSampleCounts;
2021     VkSampleCountFlags    sampledImageIntegerSampleCounts;
2022     VkSampleCountFlags    sampledImageDepthSampleCounts;
2023     VkSampleCountFlags    sampledImageStencilSampleCounts;
2024     VkSampleCountFlags    storageImageSampleCounts;
2025     uint32_t              maxSampleMaskWords;
2026     VkBool32              timestampComputeAndGraphics;
2027     float                 timestampPeriod;
2028     uint32_t              maxClipDistances;
2029     uint32_t              maxCullDistances;
2030     uint32_t              maxCombinedClipAndCullDistances;
2031     uint32_t              discreteQueuePriorities;
2032     float                 pointSizeRange[2];
2033     float                 lineWidthRange[2];
2034     float                 pointSizeGranularity;
2035     float                 lineWidthGranularity;
2036     VkBool32              strictLines;
2037     VkBool32              standardSampleLocations;
2038     VkDeviceSize          optimalBufferCopyOffsetAlignment;
2039     VkDeviceSize          optimalBufferCopyRowPitchAlignment;
2040     VkDeviceSize          nonCoherentAtomSize;
2041 } VkPhysicalDeviceLimits;
2042
2043 typedef struct VkPhysicalDeviceSparseProperties {
2044     VkBool32    residencyStandard2DBlockShape;
2045     VkBool32    residencyStandard2DMultisampleBlockShape;
2046     VkBool32    residencyStandard3DBlockShape;
2047     VkBool32    residencyAlignedMipSize;
2048     VkBool32    residencyNonResidentStrict;
2049 } VkPhysicalDeviceSparseProperties;
2050
2051 typedef struct VkPhysicalDeviceProperties {
2052     uint32_t                            apiVersion;
2053     uint32_t                            driverVersion;
2054     uint32_t                            vendorID;
2055     uint32_t                            deviceID;
2056     VkPhysicalDeviceType                deviceType;
2057     char                                deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
2058     uint8_t                             pipelineCacheUUID[VK_UUID_SIZE];
2059     VkPhysicalDeviceLimits              limits;
2060     VkPhysicalDeviceSparseProperties    sparseProperties;
2061 } VkPhysicalDeviceProperties;
2062
2063 typedef struct VkQueueFamilyProperties {
2064     VkQueueFlags    queueFlags;
2065     uint32_t        queueCount;
2066     uint32_t        timestampValidBits;
2067     VkExtent3D      minImageTransferGranularity;
2068 } VkQueueFamilyProperties;
2069
2070 typedef struct VkMemoryType {
2071     VkMemoryPropertyFlags    propertyFlags;
2072     uint32_t                 heapIndex;
2073 } VkMemoryType;
2074
2075 typedef struct VkMemoryHeap {
2076     VkDeviceSize         size;
2077     VkMemoryHeapFlags    flags;
2078 } VkMemoryHeap;
2079
2080 typedef struct VkPhysicalDeviceMemoryProperties {
2081     uint32_t        memoryTypeCount;
2082     VkMemoryType    memoryTypes[VK_MAX_MEMORY_TYPES];
2083     uint32_t        memoryHeapCount;
2084     VkMemoryHeap    memoryHeaps[VK_MAX_MEMORY_HEAPS];
2085 } VkPhysicalDeviceMemoryProperties;
2086
2087 typedef void (VKAPI_PTR *PFN_vkVoidFunction)(void);
2088 typedef struct VkDeviceQueueCreateInfo {
2089     VkStructureType             sType;
2090     const void*                 pNext;
2091     VkDeviceQueueCreateFlags    flags;
2092     uint32_t                    queueFamilyIndex;
2093     uint32_t                    queueCount;
2094     const float*                pQueuePriorities;
2095 } VkDeviceQueueCreateInfo;
2096
2097 typedef struct VkDeviceCreateInfo {
2098     VkStructureType                    sType;
2099     const void*                        pNext;
2100     VkDeviceCreateFlags                flags;
2101     uint32_t                           queueCreateInfoCount;
2102     const VkDeviceQueueCreateInfo*     pQueueCreateInfos;
2103     uint32_t                           enabledLayerCount;
2104     const char* const*                 ppEnabledLayerNames;
2105     uint32_t                           enabledExtensionCount;
2106     const char* const*                 ppEnabledExtensionNames;
2107     const VkPhysicalDeviceFeatures*    pEnabledFeatures;
2108 } VkDeviceCreateInfo;
2109
2110 typedef struct VkExtensionProperties {
2111     char        extensionName[VK_MAX_EXTENSION_NAME_SIZE];
2112     uint32_t    specVersion;
2113 } VkExtensionProperties;
2114
2115 typedef struct VkLayerProperties {
2116     char        layerName[VK_MAX_EXTENSION_NAME_SIZE];
2117     uint32_t    specVersion;
2118     uint32_t    implementationVersion;
2119     char        description[VK_MAX_DESCRIPTION_SIZE];
2120 } VkLayerProperties;
2121
2122 typedef struct VkSubmitInfo {
2123     VkStructureType                sType;
2124     const void*                    pNext;
2125     uint32_t                       waitSemaphoreCount;
2126     const VkSemaphore*             pWaitSemaphores;
2127     const VkPipelineStageFlags*    pWaitDstStageMask;
2128     uint32_t                       commandBufferCount;
2129     const VkCommandBuffer*         pCommandBuffers;
2130     uint32_t                       signalSemaphoreCount;
2131     const VkSemaphore*             pSignalSemaphores;
2132 } VkSubmitInfo;
2133
2134 typedef struct VkMemoryAllocateInfo {
2135     VkStructureType    sType;
2136     const void*        pNext;
2137     VkDeviceSize       allocationSize;
2138     uint32_t           memoryTypeIndex;
2139 } VkMemoryAllocateInfo;
2140
2141 typedef struct VkMappedMemoryRange {
2142     VkStructureType    sType;
2143     const void*        pNext;
2144     VkDeviceMemory     memory;
2145     VkDeviceSize       offset;
2146     VkDeviceSize       size;
2147 } VkMappedMemoryRange;
2148
2149 typedef struct VkMemoryRequirements {
2150     VkDeviceSize    size;
2151     VkDeviceSize    alignment;
2152     uint32_t        memoryTypeBits;
2153 } VkMemoryRequirements;
2154
2155 typedef struct VkSparseImageFormatProperties {
2156     VkImageAspectFlags          aspectMask;
2157     VkExtent3D                  imageGranularity;
2158     VkSparseImageFormatFlags    flags;
2159 } VkSparseImageFormatProperties;
2160
2161 typedef struct VkSparseImageMemoryRequirements {
2162     VkSparseImageFormatProperties    formatProperties;
2163     uint32_t                         imageMipTailFirstLod;
2164     VkDeviceSize                     imageMipTailSize;
2165     VkDeviceSize                     imageMipTailOffset;
2166     VkDeviceSize                     imageMipTailStride;
2167 } VkSparseImageMemoryRequirements;
2168
2169 typedef struct VkSparseMemoryBind {
2170     VkDeviceSize               resourceOffset;
2171     VkDeviceSize               size;
2172     VkDeviceMemory             memory;
2173     VkDeviceSize               memoryOffset;
2174     VkSparseMemoryBindFlags    flags;
2175 } VkSparseMemoryBind;
2176
2177 typedef struct VkSparseBufferMemoryBindInfo {
2178     VkBuffer                     buffer;
2179     uint32_t                     bindCount;
2180     const VkSparseMemoryBind*    pBinds;
2181 } VkSparseBufferMemoryBindInfo;
2182
2183 typedef struct VkSparseImageOpaqueMemoryBindInfo {
2184     VkImage                      image;
2185     uint32_t                     bindCount;
2186     const VkSparseMemoryBind*    pBinds;
2187 } VkSparseImageOpaqueMemoryBindInfo;
2188
2189 typedef struct VkImageSubresource {
2190     VkImageAspectFlags    aspectMask;
2191     uint32_t              mipLevel;
2192     uint32_t              arrayLayer;
2193 } VkImageSubresource;
2194
2195 typedef struct VkOffset3D {
2196     int32_t    x;
2197     int32_t    y;
2198     int32_t    z;
2199 } VkOffset3D;
2200
2201 typedef struct VkSparseImageMemoryBind {
2202     VkImageSubresource         subresource;
2203     VkOffset3D                 offset;
2204     VkExtent3D                 extent;
2205     VkDeviceMemory             memory;
2206     VkDeviceSize               memoryOffset;
2207     VkSparseMemoryBindFlags    flags;
2208 } VkSparseImageMemoryBind;
2209
2210 typedef struct VkSparseImageMemoryBindInfo {
2211     VkImage                           image;
2212     uint32_t                          bindCount;
2213     const VkSparseImageMemoryBind*    pBinds;
2214 } VkSparseImageMemoryBindInfo;
2215
2216 typedef struct VkBindSparseInfo {
2217     VkStructureType                             sType;
2218     const void*                                 pNext;
2219     uint32_t                                    waitSemaphoreCount;
2220     const VkSemaphore*                          pWaitSemaphores;
2221     uint32_t                                    bufferBindCount;
2222     const VkSparseBufferMemoryBindInfo*         pBufferBinds;
2223     uint32_t                                    imageOpaqueBindCount;
2224     const VkSparseImageOpaqueMemoryBindInfo*    pImageOpaqueBinds;
2225     uint32_t                                    imageBindCount;
2226     const VkSparseImageMemoryBindInfo*          pImageBinds;
2227     uint32_t                                    signalSemaphoreCount;
2228     const VkSemaphore*                          pSignalSemaphores;
2229 } VkBindSparseInfo;
2230
2231 typedef struct VkFenceCreateInfo {
2232     VkStructureType       sType;
2233     const void*           pNext;
2234     VkFenceCreateFlags    flags;
2235 } VkFenceCreateInfo;
2236
2237 typedef struct VkSemaphoreCreateInfo {
2238     VkStructureType           sType;
2239     const void*               pNext;
2240     VkSemaphoreCreateFlags    flags;
2241 } VkSemaphoreCreateInfo;
2242
2243 typedef struct VkEventCreateInfo {
2244     VkStructureType       sType;
2245     const void*           pNext;
2246     VkEventCreateFlags    flags;
2247 } VkEventCreateInfo;
2248
2249 typedef struct VkQueryPoolCreateInfo {
2250     VkStructureType                  sType;
2251     const void*                      pNext;
2252     VkQueryPoolCreateFlags           flags;
2253     VkQueryType                      queryType;
2254     uint32_t                         queryCount;
2255     VkQueryPipelineStatisticFlags    pipelineStatistics;
2256 } VkQueryPoolCreateInfo;
2257
2258 typedef struct VkBufferCreateInfo {
2259     VkStructureType        sType;
2260     const void*            pNext;
2261     VkBufferCreateFlags    flags;
2262     VkDeviceSize           size;
2263     VkBufferUsageFlags     usage;
2264     VkSharingMode          sharingMode;
2265     uint32_t               queueFamilyIndexCount;
2266     const uint32_t*        pQueueFamilyIndices;
2267 } VkBufferCreateInfo;
2268
2269 typedef struct VkBufferViewCreateInfo {
2270     VkStructureType            sType;
2271     const void*                pNext;
2272     VkBufferViewCreateFlags    flags;
2273     VkBuffer                   buffer;
2274     VkFormat                   format;
2275     VkDeviceSize               offset;
2276     VkDeviceSize               range;
2277 } VkBufferViewCreateInfo;
2278
2279 typedef struct VkImageCreateInfo {
2280     VkStructureType          sType;
2281     const void*              pNext;
2282     VkImageCreateFlags       flags;
2283     VkImageType              imageType;
2284     VkFormat                 format;
2285     VkExtent3D               extent;
2286     uint32_t                 mipLevels;
2287     uint32_t                 arrayLayers;
2288     VkSampleCountFlagBits    samples;
2289     VkImageTiling            tiling;
2290     VkImageUsageFlags        usage;
2291     VkSharingMode            sharingMode;
2292     uint32_t                 queueFamilyIndexCount;
2293     const uint32_t*          pQueueFamilyIndices;
2294     VkImageLayout            initialLayout;
2295 } VkImageCreateInfo;
2296
2297 typedef struct VkSubresourceLayout {
2298     VkDeviceSize    offset;
2299     VkDeviceSize    size;
2300     VkDeviceSize    rowPitch;
2301     VkDeviceSize    arrayPitch;
2302     VkDeviceSize    depthPitch;
2303 } VkSubresourceLayout;
2304
2305 typedef struct VkComponentMapping {
2306     VkComponentSwizzle    r;
2307     VkComponentSwizzle    g;
2308     VkComponentSwizzle    b;
2309     VkComponentSwizzle    a;
2310 } VkComponentMapping;
2311
2312 typedef struct VkImageSubresourceRange {
2313     VkImageAspectFlags    aspectMask;
2314     uint32_t              baseMipLevel;
2315     uint32_t              levelCount;
2316     uint32_t              baseArrayLayer;
2317     uint32_t              layerCount;
2318 } VkImageSubresourceRange;
2319
2320 typedef struct VkImageViewCreateInfo {
2321     VkStructureType            sType;
2322     const void*                pNext;
2323     VkImageViewCreateFlags     flags;
2324     VkImage                    image;
2325     VkImageViewType            viewType;
2326     VkFormat                   format;
2327     VkComponentMapping         components;
2328     VkImageSubresourceRange    subresourceRange;
2329 } VkImageViewCreateInfo;
2330
2331 typedef struct VkShaderModuleCreateInfo {
2332     VkStructureType              sType;
2333     const void*                  pNext;
2334     VkShaderModuleCreateFlags    flags;
2335     size_t                       codeSize;
2336     const uint32_t*              pCode;
2337 } VkShaderModuleCreateInfo;
2338
2339 typedef struct VkPipelineCacheCreateInfo {
2340     VkStructureType               sType;
2341     const void*                   pNext;
2342     VkPipelineCacheCreateFlags    flags;
2343     size_t                        initialDataSize;
2344     const void*                   pInitialData;
2345 } VkPipelineCacheCreateInfo;
2346
2347 typedef struct VkSpecializationMapEntry {
2348     uint32_t    constantID;
2349     uint32_t    offset;
2350     size_t      size;
2351 } VkSpecializationMapEntry;
2352
2353 typedef struct VkSpecializationInfo {
2354     uint32_t                           mapEntryCount;
2355     const VkSpecializationMapEntry*    pMapEntries;
2356     size_t                             dataSize;
2357     const void*                        pData;
2358 } VkSpecializationInfo;
2359
2360 typedef struct VkPipelineShaderStageCreateInfo {
2361     VkStructureType                     sType;
2362     const void*                         pNext;
2363     VkPipelineShaderStageCreateFlags    flags;
2364     VkShaderStageFlagBits               stage;
2365     VkShaderModule                      module;
2366     const char*                         pName;
2367     const VkSpecializationInfo*         pSpecializationInfo;
2368 } VkPipelineShaderStageCreateInfo;
2369
2370 typedef struct VkVertexInputBindingDescription {
2371     uint32_t             binding;
2372     uint32_t             stride;
2373     VkVertexInputRate    inputRate;
2374 } VkVertexInputBindingDescription;
2375
2376 typedef struct VkVertexInputAttributeDescription {
2377     uint32_t    location;
2378     uint32_t    binding;
2379     VkFormat    format;
2380     uint32_t    offset;
2381 } VkVertexInputAttributeDescription;
2382
2383 typedef struct VkPipelineVertexInputStateCreateInfo {
2384     VkStructureType                             sType;
2385     const void*                                 pNext;
2386     VkPipelineVertexInputStateCreateFlags       flags;
2387     uint32_t                                    vertexBindingDescriptionCount;
2388     const VkVertexInputBindingDescription*      pVertexBindingDescriptions;
2389     uint32_t                                    vertexAttributeDescriptionCount;
2390     const VkVertexInputAttributeDescription*    pVertexAttributeDescriptions;
2391 } VkPipelineVertexInputStateCreateInfo;
2392
2393 typedef struct VkPipelineInputAssemblyStateCreateInfo {
2394     VkStructureType                            sType;
2395     const void*                                pNext;
2396     VkPipelineInputAssemblyStateCreateFlags    flags;
2397     VkPrimitiveTopology                        topology;
2398     VkBool32                                   primitiveRestartEnable;
2399 } VkPipelineInputAssemblyStateCreateInfo;
2400
2401 typedef struct VkPipelineTessellationStateCreateInfo {
2402     VkStructureType                           sType;
2403     const void*                               pNext;
2404     VkPipelineTessellationStateCreateFlags    flags;
2405     uint32_t                                  patchControlPoints;
2406 } VkPipelineTessellationStateCreateInfo;
2407
2408 typedef struct VkViewport {
2409     float    x;
2410     float    y;
2411     float    width;
2412     float    height;
2413     float    minDepth;
2414     float    maxDepth;
2415 } VkViewport;
2416
2417 typedef struct VkOffset2D {
2418     int32_t    x;
2419     int32_t    y;
2420 } VkOffset2D;
2421
2422 typedef struct VkExtent2D {
2423     uint32_t    width;
2424     uint32_t    height;
2425 } VkExtent2D;
2426
2427 typedef struct VkRect2D {
2428     VkOffset2D    offset;
2429     VkExtent2D    extent;
2430 } VkRect2D;
2431
2432 typedef struct VkPipelineViewportStateCreateInfo {
2433     VkStructureType                       sType;
2434     const void*                           pNext;
2435     VkPipelineViewportStateCreateFlags    flags;
2436     uint32_t                              viewportCount;
2437     const VkViewport*                     pViewports;
2438     uint32_t                              scissorCount;
2439     const VkRect2D*                       pScissors;
2440 } VkPipelineViewportStateCreateInfo;
2441
2442 typedef struct VkPipelineRasterizationStateCreateInfo {
2443     VkStructureType                            sType;
2444     const void*                                pNext;
2445     VkPipelineRasterizationStateCreateFlags    flags;
2446     VkBool32                                   depthClampEnable;
2447     VkBool32                                   rasterizerDiscardEnable;
2448     VkPolygonMode                              polygonMode;
2449     VkCullModeFlags                            cullMode;
2450     VkFrontFace                                frontFace;
2451     VkBool32                                   depthBiasEnable;
2452     float                                      depthBiasConstantFactor;
2453     float                                      depthBiasClamp;
2454     float                                      depthBiasSlopeFactor;
2455     float                                      lineWidth;
2456 } VkPipelineRasterizationStateCreateInfo;
2457
2458 typedef struct VkPipelineMultisampleStateCreateInfo {
2459     VkStructureType                          sType;
2460     const void*                              pNext;
2461     VkPipelineMultisampleStateCreateFlags    flags;
2462     VkSampleCountFlagBits                    rasterizationSamples;
2463     VkBool32                                 sampleShadingEnable;
2464     float                                    minSampleShading;
2465     const VkSampleMask*                      pSampleMask;
2466     VkBool32                                 alphaToCoverageEnable;
2467     VkBool32                                 alphaToOneEnable;
2468 } VkPipelineMultisampleStateCreateInfo;
2469
2470 typedef struct VkStencilOpState {
2471     VkStencilOp    failOp;
2472     VkStencilOp    passOp;
2473     VkStencilOp    depthFailOp;
2474     VkCompareOp    compareOp;
2475     uint32_t       compareMask;
2476     uint32_t       writeMask;
2477     uint32_t       reference;
2478 } VkStencilOpState;
2479
2480 typedef struct VkPipelineDepthStencilStateCreateInfo {
2481     VkStructureType                           sType;
2482     const void*                               pNext;
2483     VkPipelineDepthStencilStateCreateFlags    flags;
2484     VkBool32                                  depthTestEnable;
2485     VkBool32                                  depthWriteEnable;
2486     VkCompareOp                               depthCompareOp;
2487     VkBool32                                  depthBoundsTestEnable;
2488     VkBool32                                  stencilTestEnable;
2489     VkStencilOpState                          front;
2490     VkStencilOpState                          back;
2491     float                                     minDepthBounds;
2492     float                                     maxDepthBounds;
2493 } VkPipelineDepthStencilStateCreateInfo;
2494
2495 typedef struct VkPipelineColorBlendAttachmentState {
2496     VkBool32                 blendEnable;
2497     VkBlendFactor            srcColorBlendFactor;
2498     VkBlendFactor            dstColorBlendFactor;
2499     VkBlendOp                colorBlendOp;
2500     VkBlendFactor            srcAlphaBlendFactor;
2501     VkBlendFactor            dstAlphaBlendFactor;
2502     VkBlendOp                alphaBlendOp;
2503     VkColorComponentFlags    colorWriteMask;
2504 } VkPipelineColorBlendAttachmentState;
2505
2506 typedef struct VkPipelineColorBlendStateCreateInfo {
2507     VkStructureType                               sType;
2508     const void*                                   pNext;
2509     VkPipelineColorBlendStateCreateFlags          flags;
2510     VkBool32                                      logicOpEnable;
2511     VkLogicOp                                     logicOp;
2512     uint32_t                                      attachmentCount;
2513     const VkPipelineColorBlendAttachmentState*    pAttachments;
2514     float                                         blendConstants[4];
2515 } VkPipelineColorBlendStateCreateInfo;
2516
2517 typedef struct VkPipelineDynamicStateCreateInfo {
2518     VkStructureType                      sType;
2519     const void*                          pNext;
2520     VkPipelineDynamicStateCreateFlags    flags;
2521     uint32_t                             dynamicStateCount;
2522     const VkDynamicState*                pDynamicStates;
2523 } VkPipelineDynamicStateCreateInfo;
2524
2525 typedef struct VkGraphicsPipelineCreateInfo {
2526     VkStructureType                                  sType;
2527     const void*                                      pNext;
2528     VkPipelineCreateFlags                            flags;
2529     uint32_t                                         stageCount;
2530     const VkPipelineShaderStageCreateInfo*           pStages;
2531     const VkPipelineVertexInputStateCreateInfo*      pVertexInputState;
2532     const VkPipelineInputAssemblyStateCreateInfo*    pInputAssemblyState;
2533     const VkPipelineTessellationStateCreateInfo*     pTessellationState;
2534     const VkPipelineViewportStateCreateInfo*         pViewportState;
2535     const VkPipelineRasterizationStateCreateInfo*    pRasterizationState;
2536     const VkPipelineMultisampleStateCreateInfo*      pMultisampleState;
2537     const VkPipelineDepthStencilStateCreateInfo*     pDepthStencilState;
2538     const VkPipelineColorBlendStateCreateInfo*       pColorBlendState;
2539     const VkPipelineDynamicStateCreateInfo*          pDynamicState;
2540     VkPipelineLayout                                 layout;
2541     VkRenderPass                                     renderPass;
2542     uint32_t                                         subpass;
2543     VkPipeline                                       basePipelineHandle;
2544     int32_t                                          basePipelineIndex;
2545 } VkGraphicsPipelineCreateInfo;
2546
2547 typedef struct VkComputePipelineCreateInfo {
2548     VkStructureType                    sType;
2549     const void*                        pNext;
2550     VkPipelineCreateFlags              flags;
2551     VkPipelineShaderStageCreateInfo    stage;
2552     VkPipelineLayout                   layout;
2553     VkPipeline                         basePipelineHandle;
2554     int32_t                            basePipelineIndex;
2555 } VkComputePipelineCreateInfo;
2556
2557 typedef struct VkPushConstantRange {
2558     VkShaderStageFlags    stageFlags;
2559     uint32_t              offset;
2560     uint32_t              size;
2561 } VkPushConstantRange;
2562
2563 typedef struct VkPipelineLayoutCreateInfo {
2564     VkStructureType                 sType;
2565     const void*                     pNext;
2566     VkPipelineLayoutCreateFlags     flags;
2567     uint32_t                        setLayoutCount;
2568     const VkDescriptorSetLayout*    pSetLayouts;
2569     uint32_t                        pushConstantRangeCount;
2570     const VkPushConstantRange*      pPushConstantRanges;
2571 } VkPipelineLayoutCreateInfo;
2572
2573 typedef struct VkSamplerCreateInfo {
2574     VkStructureType         sType;
2575     const void*             pNext;
2576     VkSamplerCreateFlags    flags;
2577     VkFilter                magFilter;
2578     VkFilter                minFilter;
2579     VkSamplerMipmapMode     mipmapMode;
2580     VkSamplerAddressMode    addressModeU;
2581     VkSamplerAddressMode    addressModeV;
2582     VkSamplerAddressMode    addressModeW;
2583     float                   mipLodBias;
2584     VkBool32                anisotropyEnable;
2585     float                   maxAnisotropy;
2586     VkBool32                compareEnable;
2587     VkCompareOp             compareOp;
2588     float                   minLod;
2589     float                   maxLod;
2590     VkBorderColor           borderColor;
2591     VkBool32                unnormalizedCoordinates;
2592 } VkSamplerCreateInfo;
2593
2594 typedef struct VkDescriptorSetLayoutBinding {
2595     uint32_t              binding;
2596     VkDescriptorType      descriptorType;
2597     uint32_t              descriptorCount;
2598     VkShaderStageFlags    stageFlags;
2599     const VkSampler*      pImmutableSamplers;
2600 } VkDescriptorSetLayoutBinding;
2601
2602 typedef struct VkDescriptorSetLayoutCreateInfo {
2603     VkStructureType                        sType;
2604     const void*                            pNext;
2605     VkDescriptorSetLayoutCreateFlags       flags;
2606     uint32_t                               bindingCount;
2607     const VkDescriptorSetLayoutBinding*    pBindings;
2608 } VkDescriptorSetLayoutCreateInfo;
2609
2610 typedef struct VkDescriptorPoolSize {
2611     VkDescriptorType    type;
2612     uint32_t            descriptorCount;
2613 } VkDescriptorPoolSize;
2614
2615 typedef struct VkDescriptorPoolCreateInfo {
2616     VkStructureType                sType;
2617     const void*                    pNext;
2618     VkDescriptorPoolCreateFlags    flags;
2619     uint32_t                       maxSets;
2620     uint32_t                       poolSizeCount;
2621     const VkDescriptorPoolSize*    pPoolSizes;
2622 } VkDescriptorPoolCreateInfo;
2623
2624 typedef struct VkDescriptorSetAllocateInfo {
2625     VkStructureType                 sType;
2626     const void*                     pNext;
2627     VkDescriptorPool                descriptorPool;
2628     uint32_t                        descriptorSetCount;
2629     const VkDescriptorSetLayout*    pSetLayouts;
2630 } VkDescriptorSetAllocateInfo;
2631
2632 typedef struct VkDescriptorImageInfo {
2633     VkSampler        sampler;
2634     VkImageView      imageView;
2635     VkImageLayout    imageLayout;
2636 } VkDescriptorImageInfo;
2637
2638 typedef struct VkDescriptorBufferInfo {
2639     VkBuffer        buffer;
2640     VkDeviceSize    offset;
2641     VkDeviceSize    range;
2642 } VkDescriptorBufferInfo;
2643
2644 typedef struct VkWriteDescriptorSet {
2645     VkStructureType                  sType;
2646     const void*                      pNext;
2647     VkDescriptorSet                  dstSet;
2648     uint32_t                         dstBinding;
2649     uint32_t                         dstArrayElement;
2650     uint32_t                         descriptorCount;
2651     VkDescriptorType                 descriptorType;
2652     const VkDescriptorImageInfo*     pImageInfo;
2653     const VkDescriptorBufferInfo*    pBufferInfo;
2654     const VkBufferView*              pTexelBufferView;
2655 } VkWriteDescriptorSet;
2656
2657 typedef struct VkCopyDescriptorSet {
2658     VkStructureType    sType;
2659     const void*        pNext;
2660     VkDescriptorSet    srcSet;
2661     uint32_t           srcBinding;
2662     uint32_t           srcArrayElement;
2663     VkDescriptorSet    dstSet;
2664     uint32_t           dstBinding;
2665     uint32_t           dstArrayElement;
2666     uint32_t           descriptorCount;
2667 } VkCopyDescriptorSet;
2668
2669 typedef struct VkFramebufferCreateInfo {
2670     VkStructureType             sType;
2671     const void*                 pNext;
2672     VkFramebufferCreateFlags    flags;
2673     VkRenderPass                renderPass;
2674     uint32_t                    attachmentCount;
2675     const VkImageView*          pAttachments;
2676     uint32_t                    width;
2677     uint32_t                    height;
2678     uint32_t                    layers;
2679 } VkFramebufferCreateInfo;
2680
2681 typedef struct VkAttachmentDescription {
2682     VkAttachmentDescriptionFlags    flags;
2683     VkFormat                        format;
2684     VkSampleCountFlagBits           samples;
2685     VkAttachmentLoadOp              loadOp;
2686     VkAttachmentStoreOp             storeOp;
2687     VkAttachmentLoadOp              stencilLoadOp;
2688     VkAttachmentStoreOp             stencilStoreOp;
2689     VkImageLayout                   initialLayout;
2690     VkImageLayout                   finalLayout;
2691 } VkAttachmentDescription;
2692
2693 typedef struct VkAttachmentReference {
2694     uint32_t         attachment;
2695     VkImageLayout    layout;
2696 } VkAttachmentReference;
2697
2698 typedef struct VkSubpassDescription {
2699     VkSubpassDescriptionFlags       flags;
2700     VkPipelineBindPoint             pipelineBindPoint;
2701     uint32_t                        inputAttachmentCount;
2702     const VkAttachmentReference*    pInputAttachments;
2703     uint32_t                        colorAttachmentCount;
2704     const VkAttachmentReference*    pColorAttachments;
2705     const VkAttachmentReference*    pResolveAttachments;
2706     const VkAttachmentReference*    pDepthStencilAttachment;
2707     uint32_t                        preserveAttachmentCount;
2708     const uint32_t*                 pPreserveAttachments;
2709 } VkSubpassDescription;
2710
2711 typedef struct VkSubpassDependency {
2712     uint32_t                srcSubpass;
2713     uint32_t                dstSubpass;
2714     VkPipelineStageFlags    srcStageMask;
2715     VkPipelineStageFlags    dstStageMask;
2716     VkAccessFlags           srcAccessMask;
2717     VkAccessFlags           dstAccessMask;
2718     VkDependencyFlags       dependencyFlags;
2719 } VkSubpassDependency;
2720
2721 typedef struct VkRenderPassCreateInfo {
2722     VkStructureType                   sType;
2723     const void*                       pNext;
2724     VkRenderPassCreateFlags           flags;
2725     uint32_t                          attachmentCount;
2726     const VkAttachmentDescription*    pAttachments;
2727     uint32_t                          subpassCount;
2728     const VkSubpassDescription*       pSubpasses;
2729     uint32_t                          dependencyCount;
2730     const VkSubpassDependency*        pDependencies;
2731 } VkRenderPassCreateInfo;
2732
2733 typedef struct VkCommandPoolCreateInfo {
2734     VkStructureType             sType;
2735     const void*                 pNext;
2736     VkCommandPoolCreateFlags    flags;
2737     uint32_t                    queueFamilyIndex;
2738 } VkCommandPoolCreateInfo;
2739
2740 typedef struct VkCommandBufferAllocateInfo {
2741     VkStructureType         sType;
2742     const void*             pNext;
2743     VkCommandPool           commandPool;
2744     VkCommandBufferLevel    level;
2745     uint32_t                commandBufferCount;
2746 } VkCommandBufferAllocateInfo;
2747
2748 typedef struct VkCommandBufferInheritanceInfo {
2749     VkStructureType                  sType;
2750     const void*                      pNext;
2751     VkRenderPass                     renderPass;
2752     uint32_t                         subpass;
2753     VkFramebuffer                    framebuffer;
2754     VkBool32                         occlusionQueryEnable;
2755     VkQueryControlFlags              queryFlags;
2756     VkQueryPipelineStatisticFlags    pipelineStatistics;
2757 } VkCommandBufferInheritanceInfo;
2758
2759 typedef struct VkCommandBufferBeginInfo {
2760     VkStructureType                          sType;
2761     const void*                              pNext;
2762     VkCommandBufferUsageFlags                flags;
2763     const VkCommandBufferInheritanceInfo*    pInheritanceInfo;
2764 } VkCommandBufferBeginInfo;
2765
2766 typedef struct VkBufferCopy {
2767     VkDeviceSize    srcOffset;
2768     VkDeviceSize    dstOffset;
2769     VkDeviceSize    size;
2770 } VkBufferCopy;
2771
2772 typedef struct VkImageSubresourceLayers {
2773     VkImageAspectFlags    aspectMask;
2774     uint32_t              mipLevel;
2775     uint32_t              baseArrayLayer;
2776     uint32_t              layerCount;
2777 } VkImageSubresourceLayers;
2778
2779 typedef struct VkImageCopy {
2780     VkImageSubresourceLayers    srcSubresource;
2781     VkOffset3D                  srcOffset;
2782     VkImageSubresourceLayers    dstSubresource;
2783     VkOffset3D                  dstOffset;
2784     VkExtent3D                  extent;
2785 } VkImageCopy;
2786
2787 typedef struct VkImageBlit {
2788     VkImageSubresourceLayers    srcSubresource;
2789     VkOffset3D                  srcOffsets[2];
2790     VkImageSubresourceLayers    dstSubresource;
2791     VkOffset3D                  dstOffsets[2];
2792 } VkImageBlit;
2793
2794 typedef struct VkBufferImageCopy {
2795     VkDeviceSize                bufferOffset;
2796     uint32_t                    bufferRowLength;
2797     uint32_t                    bufferImageHeight;
2798     VkImageSubresourceLayers    imageSubresource;
2799     VkOffset3D                  imageOffset;
2800     VkExtent3D                  imageExtent;
2801 } VkBufferImageCopy;
2802
2803 typedef union VkClearColorValue {
2804     float       float32[4];
2805     int32_t     int32[4];
2806     uint32_t    uint32[4];
2807 } VkClearColorValue;
2808
2809 typedef struct VkClearDepthStencilValue {
2810     float       depth;
2811     uint32_t    stencil;
2812 } VkClearDepthStencilValue;
2813
2814 typedef union VkClearValue {
2815     VkClearColorValue           color;
2816     VkClearDepthStencilValue    depthStencil;
2817 } VkClearValue;
2818
2819 typedef struct VkClearAttachment {
2820     VkImageAspectFlags    aspectMask;
2821     uint32_t              colorAttachment;
2822     VkClearValue          clearValue;
2823 } VkClearAttachment;
2824
2825 typedef struct VkClearRect {
2826     VkRect2D    rect;
2827     uint32_t    baseArrayLayer;
2828     uint32_t    layerCount;
2829 } VkClearRect;
2830
2831 typedef struct VkImageResolve {
2832     VkImageSubresourceLayers    srcSubresource;
2833     VkOffset3D                  srcOffset;
2834     VkImageSubresourceLayers    dstSubresource;
2835     VkOffset3D                  dstOffset;
2836     VkExtent3D                  extent;
2837 } VkImageResolve;
2838
2839 typedef struct VkMemoryBarrier {
2840     VkStructureType    sType;
2841     const void*        pNext;
2842     VkAccessFlags      srcAccessMask;
2843     VkAccessFlags      dstAccessMask;
2844 } VkMemoryBarrier;
2845
2846 typedef struct VkBufferMemoryBarrier {
2847     VkStructureType    sType;
2848     const void*        pNext;
2849     VkAccessFlags      srcAccessMask;
2850     VkAccessFlags      dstAccessMask;
2851     uint32_t           srcQueueFamilyIndex;
2852     uint32_t           dstQueueFamilyIndex;
2853     VkBuffer           buffer;
2854     VkDeviceSize       offset;
2855     VkDeviceSize       size;
2856 } VkBufferMemoryBarrier;
2857
2858 typedef struct VkImageMemoryBarrier {
2859     VkStructureType            sType;
2860     const void*                pNext;
2861     VkAccessFlags              srcAccessMask;
2862     VkAccessFlags              dstAccessMask;
2863     VkImageLayout              oldLayout;
2864     VkImageLayout              newLayout;
2865     uint32_t                   srcQueueFamilyIndex;
2866     uint32_t                   dstQueueFamilyIndex;
2867     VkImage                    image;
2868     VkImageSubresourceRange    subresourceRange;
2869 } VkImageMemoryBarrier;
2870
2871 typedef struct VkRenderPassBeginInfo {
2872     VkStructureType        sType;
2873     const void*            pNext;
2874     VkRenderPass           renderPass;
2875     VkFramebuffer          framebuffer;
2876     VkRect2D               renderArea;
2877     uint32_t               clearValueCount;
2878     const VkClearValue*    pClearValues;
2879 } VkRenderPassBeginInfo;
2880
2881 typedef struct VkDispatchIndirectCommand {
2882     uint32_t    x;
2883     uint32_t    y;
2884     uint32_t    z;
2885 } VkDispatchIndirectCommand;
2886
2887 typedef struct VkDrawIndexedIndirectCommand {
2888     uint32_t    indexCount;
2889     uint32_t    instanceCount;
2890     uint32_t    firstIndex;
2891     int32_t     vertexOffset;
2892     uint32_t    firstInstance;
2893 } VkDrawIndexedIndirectCommand;
2894
2895 typedef struct VkDrawIndirectCommand {
2896     uint32_t    vertexCount;
2897     uint32_t    instanceCount;
2898     uint32_t    firstVertex;
2899     uint32_t    firstInstance;
2900 } VkDrawIndirectCommand;
2901
2902 typedef struct VkBaseOutStructure {
2903     VkStructureType               sType;
2904     struct VkBaseOutStructure*    pNext;
2905 } VkBaseOutStructure;
2906
2907 typedef struct VkBaseInStructure {
2908     VkStructureType                    sType;
2909     const struct VkBaseInStructure*    pNext;
2910 } VkBaseInStructure;
2911
2912 typedef VkResult (VKAPI_PTR *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance);
2913 typedef void (VKAPI_PTR *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks* pAllocator);
2914 typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
2915 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
2916 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
2917 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
2918 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
2919 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties);
2920 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
2921 typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName);
2922 typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName);
2923 typedef VkResult (VKAPI_PTR *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice);
2924 typedef void (VKAPI_PTR *PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks* pAllocator);
2925 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
2926 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
2927 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties);
2928 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties);
2929 typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
2930 typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence);
2931 typedef VkResult (VKAPI_PTR *PFN_vkQueueWaitIdle)(VkQueue queue);
2932 typedef VkResult (VKAPI_PTR *PFN_vkDeviceWaitIdle)(VkDevice device);
2933 typedef VkResult (VKAPI_PTR *PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory);
2934 typedef void (VKAPI_PTR *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator);
2935 typedef VkResult (VKAPI_PTR *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);
2936 typedef void (VKAPI_PTR *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory);
2937 typedef VkResult (VKAPI_PTR *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
2938 typedef VkResult (VKAPI_PTR *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
2939 typedef void (VKAPI_PTR *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);
2940 typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset);
2941 typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset);
2942 typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
2943 typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
2944 typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
2945 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties);
2946 typedef VkResult (VKAPI_PTR *PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence);
2947 typedef VkResult (VKAPI_PTR *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
2948 typedef void (VKAPI_PTR *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator);
2949 typedef VkResult (VKAPI_PTR *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences);
2950 typedef VkResult (VKAPI_PTR *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence);
2951 typedef VkResult (VKAPI_PTR *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout);
2952 typedef VkResult (VKAPI_PTR *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore);
2953 typedef void (VKAPI_PTR *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator);
2954 typedef VkResult (VKAPI_PTR *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent);
2955 typedef void (VKAPI_PTR *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator);
2956 typedef VkResult (VKAPI_PTR *PFN_vkGetEventStatus)(VkDevice device, VkEvent event);
2957 typedef VkResult (VKAPI_PTR *PFN_vkSetEvent)(VkDevice device, VkEvent event);
2958 typedef VkResult (VKAPI_PTR *PFN_vkResetEvent)(VkDevice device, VkEvent event);
2959 typedef VkResult (VKAPI_PTR *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool);
2960 typedef void (VKAPI_PTR *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator);
2961 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);
2962 typedef VkResult (VKAPI_PTR *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer);
2963 typedef void (VKAPI_PTR *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator);
2964 typedef VkResult (VKAPI_PTR *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView);
2965 typedef void (VKAPI_PTR *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator);
2966 typedef VkResult (VKAPI_PTR *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage);
2967 typedef void (VKAPI_PTR *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator);
2968 typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
2969 typedef VkResult (VKAPI_PTR *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView);
2970 typedef void (VKAPI_PTR *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator);
2971 typedef VkResult (VKAPI_PTR *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule);
2972 typedef void (VKAPI_PTR *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator);
2973 typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache);
2974 typedef void (VKAPI_PTR *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator);
2975 typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData);
2976 typedef VkResult (VKAPI_PTR *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
2977 typedef VkResult (VKAPI_PTR *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
2978 typedef VkResult (VKAPI_PTR *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
2979 typedef void (VKAPI_PTR *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator);
2980 typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout);
2981 typedef void (VKAPI_PTR *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator);
2982 typedef VkResult (VKAPI_PTR *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler);
2983 typedef void (VKAPI_PTR *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator);
2984 typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout);
2985 typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator);
2986 typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool);
2987 typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator);
2988 typedef VkResult (VKAPI_PTR *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);
2989 typedef VkResult (VKAPI_PTR *PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets);
2990 typedef VkResult (VKAPI_PTR *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets);
2991 typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies);
2992 typedef VkResult (VKAPI_PTR *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer);
2993 typedef void (VKAPI_PTR *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator);
2994 typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);
2995 typedef void (VKAPI_PTR *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator);
2996 typedef void (VKAPI_PTR *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
2997 typedef VkResult (VKAPI_PTR *PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool);
2998 typedef void (VKAPI_PTR *PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator);
2999 typedef VkResult (VKAPI_PTR *PFN_vkResetCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags);
3000 typedef VkResult (VKAPI_PTR *PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers);
3001 typedef void (VKAPI_PTR *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
3002 typedef VkResult (VKAPI_PTR *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo);
3003 typedef VkResult (VKAPI_PTR *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer);
3004 typedef VkResult (VKAPI_PTR *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags);
3005 typedef void (VKAPI_PTR *PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
3006 typedef void (VKAPI_PTR *PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports);
3007 typedef void (VKAPI_PTR *PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors);
3008 typedef void (VKAPI_PTR *PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth);
3009 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor);
3010 typedef void (VKAPI_PTR *PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4]);
3011 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds);
3012 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask);
3013 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask);
3014 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference);
3015 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);
3016 typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
3017 typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
3018 typedef void (VKAPI_PTR *PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
3019 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
3020 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
3021 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
3022 typedef void (VKAPI_PTR *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);
3023 typedef void (VKAPI_PTR *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset);
3024 typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions);
3025 typedef void (VKAPI_PTR *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions);
3026 typedef void (VKAPI_PTR *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter);
3027 typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);
3028 typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);
3029 typedef void (VKAPI_PTR *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData);
3030 typedef void (VKAPI_PTR *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data);
3031 typedef void (VKAPI_PTR *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
3032 typedef void (VKAPI_PTR *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
3033 typedef void (VKAPI_PTR *PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects);
3034 typedef void (VKAPI_PTR *PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
3035 typedef void (VKAPI_PTR *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
3036 typedef void (VKAPI_PTR *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
3037 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);
3038 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);
3039 typedef void (VKAPI_PTR *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags);
3040 typedef void (VKAPI_PTR *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query);
3041 typedef void (VKAPI_PTR *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);
3042 typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query);
3043 typedef void (VKAPI_PTR *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags);
3044 typedef void (VKAPI_PTR *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues);
3045 typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents);
3046 typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkSubpassContents contents);
3047 typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer);
3048 typedef void (VKAPI_PTR *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
3049
3050 #ifndef VK_NO_PROTOTYPES
3051 VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(
3052     const VkInstanceCreateInfo*                 pCreateInfo,
3053     const VkAllocationCallbacks*                pAllocator,
3054     VkInstance*                                 pInstance);
3055
3056 VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(
3057     VkInstance                                  instance,
3058     const VkAllocationCallbacks*                pAllocator);
3059
3060 VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices(
3061     VkInstance                                  instance,
3062     uint32_t*                                   pPhysicalDeviceCount,
3063     VkPhysicalDevice*                           pPhysicalDevices);
3064
3065 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures(
3066     VkPhysicalDevice                            physicalDevice,
3067     VkPhysicalDeviceFeatures*                   pFeatures);
3068
3069 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties(
3070     VkPhysicalDevice                            physicalDevice,
3071     VkFormat                                    format,
3072     VkFormatProperties*                         pFormatProperties);
3073
3074 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties(
3075     VkPhysicalDevice                            physicalDevice,
3076     VkFormat                                    format,
3077     VkImageType                                 type,
3078     VkImageTiling                               tiling,
3079     VkImageUsageFlags                           usage,
3080     VkImageCreateFlags                          flags,
3081     VkImageFormatProperties*                    pImageFormatProperties);
3082
3083 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties(
3084     VkPhysicalDevice                            physicalDevice,
3085     VkPhysicalDeviceProperties*                 pProperties);
3086
3087 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties(
3088     VkPhysicalDevice                            physicalDevice,
3089     uint32_t*                                   pQueueFamilyPropertyCount,
3090     VkQueueFamilyProperties*                    pQueueFamilyProperties);
3091
3092 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties(
3093     VkPhysicalDevice                            physicalDevice,
3094     VkPhysicalDeviceMemoryProperties*           pMemoryProperties);
3095
3096 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(
3097     VkInstance                                  instance,
3098     const char*                                 pName);
3099
3100 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(
3101     VkDevice                                    device,
3102     const char*                                 pName);
3103
3104 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(
3105     VkPhysicalDevice                            physicalDevice,
3106     const VkDeviceCreateInfo*                   pCreateInfo,
3107     const VkAllocationCallbacks*                pAllocator,
3108     VkDevice*                                   pDevice);
3109
3110 VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(
3111     VkDevice                                    device,
3112     const VkAllocationCallbacks*                pAllocator);
3113
3114 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(
3115     const char*                                 pLayerName,
3116     uint32_t*                                   pPropertyCount,
3117     VkExtensionProperties*                      pProperties);
3118
3119 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(
3120     VkPhysicalDevice                            physicalDevice,
3121     const char*                                 pLayerName,
3122     uint32_t*                                   pPropertyCount,
3123     VkExtensionProperties*                      pProperties);
3124
3125 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(
3126     uint32_t*                                   pPropertyCount,
3127     VkLayerProperties*                          pProperties);
3128
3129 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(
3130     VkPhysicalDevice                            physicalDevice,
3131     uint32_t*                                   pPropertyCount,
3132     VkLayerProperties*                          pProperties);
3133
3134 VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue(
3135     VkDevice                                    device,
3136     uint32_t                                    queueFamilyIndex,
3137     uint32_t                                    queueIndex,
3138     VkQueue*                                    pQueue);
3139
3140 VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit(
3141     VkQueue                                     queue,
3142     uint32_t                                    submitCount,
3143     const VkSubmitInfo*                         pSubmits,
3144     VkFence                                     fence);
3145
3146 VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle(
3147     VkQueue                                     queue);
3148
3149 VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle(
3150     VkDevice                                    device);
3151
3152 VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory(
3153     VkDevice                                    device,
3154     const VkMemoryAllocateInfo*                 pAllocateInfo,
3155     const VkAllocationCallbacks*                pAllocator,
3156     VkDeviceMemory*                             pMemory);
3157
3158 VKAPI_ATTR void VKAPI_CALL vkFreeMemory(
3159     VkDevice                                    device,
3160     VkDeviceMemory                              memory,
3161     const VkAllocationCallbacks*                pAllocator);
3162
3163 VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory(
3164     VkDevice                                    device,
3165     VkDeviceMemory                              memory,
3166     VkDeviceSize                                offset,
3167     VkDeviceSize                                size,
3168     VkMemoryMapFlags                            flags,
3169     void**                                      ppData);
3170
3171 VKAPI_ATTR void VKAPI_CALL vkUnmapMemory(
3172     VkDevice                                    device,
3173     VkDeviceMemory                              memory);
3174
3175 VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges(
3176     VkDevice                                    device,
3177     uint32_t                                    memoryRangeCount,
3178     const VkMappedMemoryRange*                  pMemoryRanges);
3179
3180 VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges(
3181     VkDevice                                    device,
3182     uint32_t                                    memoryRangeCount,
3183     const VkMappedMemoryRange*                  pMemoryRanges);
3184
3185 VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment(
3186     VkDevice                                    device,
3187     VkDeviceMemory                              memory,
3188     VkDeviceSize*                               pCommittedMemoryInBytes);
3189
3190 VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory(
3191     VkDevice                                    device,
3192     VkBuffer                                    buffer,
3193     VkDeviceMemory                              memory,
3194     VkDeviceSize                                memoryOffset);
3195
3196 VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory(
3197     VkDevice                                    device,
3198     VkImage                                     image,
3199     VkDeviceMemory                              memory,
3200     VkDeviceSize                                memoryOffset);
3201
3202 VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements(
3203     VkDevice                                    device,
3204     VkBuffer                                    buffer,
3205     VkMemoryRequirements*                       pMemoryRequirements);
3206
3207 VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements(
3208     VkDevice                                    device,
3209     VkImage                                     image,
3210     VkMemoryRequirements*                       pMemoryRequirements);
3211
3212 VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements(
3213     VkDevice                                    device,
3214     VkImage                                     image,
3215     uint32_t*                                   pSparseMemoryRequirementCount,
3216     VkSparseImageMemoryRequirements*            pSparseMemoryRequirements);
3217
3218 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties(
3219     VkPhysicalDevice                            physicalDevice,
3220     VkFormat                                    format,
3221     VkImageType                                 type,
3222     VkSampleCountFlagBits                       samples,
3223     VkImageUsageFlags                           usage,
3224     VkImageTiling                               tiling,
3225     uint32_t*                                   pPropertyCount,
3226     VkSparseImageFormatProperties*              pProperties);
3227
3228 VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse(
3229     VkQueue                                     queue,
3230     uint32_t                                    bindInfoCount,
3231     const VkBindSparseInfo*                     pBindInfo,
3232     VkFence                                     fence);
3233
3234 VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence(
3235     VkDevice                                    device,
3236     const VkFenceCreateInfo*                    pCreateInfo,
3237     const VkAllocationCallbacks*                pAllocator,
3238     VkFence*                                    pFence);
3239
3240 VKAPI_ATTR void VKAPI_CALL vkDestroyFence(
3241     VkDevice                                    device,
3242     VkFence                                     fence,
3243     const VkAllocationCallbacks*                pAllocator);
3244
3245 VKAPI_ATTR VkResult VKAPI_CALL vkResetFences(
3246     VkDevice                                    device,
3247     uint32_t                                    fenceCount,
3248     const VkFence*                              pFences);
3249
3250 VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus(
3251     VkDevice                                    device,
3252     VkFence                                     fence);
3253
3254 VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences(
3255     VkDevice                                    device,
3256     uint32_t                                    fenceCount,
3257     const VkFence*                              pFences,
3258     VkBool32                                    waitAll,
3259     uint64_t                                    timeout);
3260
3261 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore(
3262     VkDevice                                    device,
3263     const VkSemaphoreCreateInfo*                pCreateInfo,
3264     const VkAllocationCallbacks*                pAllocator,
3265     VkSemaphore*                                pSemaphore);
3266
3267 VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore(
3268     VkDevice                                    device,
3269     VkSemaphore                                 semaphore,
3270     const VkAllocationCallbacks*                pAllocator);
3271
3272 VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent(
3273     VkDevice                                    device,
3274     const VkEventCreateInfo*                    pCreateInfo,
3275     const VkAllocationCallbacks*                pAllocator,
3276     VkEvent*                                    pEvent);
3277
3278 VKAPI_ATTR void VKAPI_CALL vkDestroyEvent(
3279     VkDevice                                    device,
3280     VkEvent                                     event,
3281     const VkAllocationCallbacks*                pAllocator);
3282
3283 VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus(
3284     VkDevice                                    device,
3285     VkEvent                                     event);
3286
3287 VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent(
3288     VkDevice                                    device,
3289     VkEvent                                     event);
3290
3291 VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent(
3292     VkDevice                                    device,
3293     VkEvent                                     event);
3294
3295 VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool(
3296     VkDevice                                    device,
3297     const VkQueryPoolCreateInfo*                pCreateInfo,
3298     const VkAllocationCallbacks*                pAllocator,
3299     VkQueryPool*                                pQueryPool);
3300
3301 VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool(
3302     VkDevice                                    device,
3303     VkQueryPool                                 queryPool,
3304     const VkAllocationCallbacks*                pAllocator);
3305
3306 VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults(
3307     VkDevice                                    device,
3308     VkQueryPool                                 queryPool,
3309     uint32_t                                    firstQuery,
3310     uint32_t                                    queryCount,
3311     size_t                                      dataSize,
3312     void*                                       pData,
3313     VkDeviceSize                                stride,
3314     VkQueryResultFlags                          flags);
3315
3316 VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer(
3317     VkDevice                                    device,
3318     const VkBufferCreateInfo*                   pCreateInfo,
3319     const VkAllocationCallbacks*                pAllocator,
3320     VkBuffer*                                   pBuffer);
3321
3322 VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer(
3323     VkDevice                                    device,
3324     VkBuffer                                    buffer,
3325     const VkAllocationCallbacks*                pAllocator);
3326
3327 VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView(
3328     VkDevice                                    device,
3329     const VkBufferViewCreateInfo*               pCreateInfo,
3330     const VkAllocationCallbacks*                pAllocator,
3331     VkBufferView*                               pView);
3332
3333 VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView(
3334     VkDevice                                    device,
3335     VkBufferView                                bufferView,
3336     const VkAllocationCallbacks*                pAllocator);
3337
3338 VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(
3339     VkDevice                                    device,
3340     const VkImageCreateInfo*                    pCreateInfo,
3341     const VkAllocationCallbacks*                pAllocator,
3342     VkImage*                                    pImage);
3343
3344 VKAPI_ATTR void VKAPI_CALL vkDestroyImage(
3345     VkDevice                                    device,
3346     VkImage                                     image,
3347     const VkAllocationCallbacks*                pAllocator);
3348
3349 VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout(
3350     VkDevice                                    device,
3351     VkImage                                     image,
3352     const VkImageSubresource*                   pSubresource,
3353     VkSubresourceLayout*                        pLayout);
3354
3355 VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView(
3356     VkDevice                                    device,
3357     const VkImageViewCreateInfo*                pCreateInfo,
3358     const VkAllocationCallbacks*                pAllocator,
3359     VkImageView*                                pView);
3360
3361 VKAPI_ATTR void VKAPI_CALL vkDestroyImageView(
3362     VkDevice                                    device,
3363     VkImageView                                 imageView,
3364     const VkAllocationCallbacks*                pAllocator);
3365
3366 VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule(
3367     VkDevice                                    device,
3368     const VkShaderModuleCreateInfo*             pCreateInfo,
3369     const VkAllocationCallbacks*                pAllocator,
3370     VkShaderModule*                             pShaderModule);
3371
3372 VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule(
3373     VkDevice                                    device,
3374     VkShaderModule                              shaderModule,
3375     const VkAllocationCallbacks*                pAllocator);
3376
3377 VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache(
3378     VkDevice                                    device,
3379     const VkPipelineCacheCreateInfo*            pCreateInfo,
3380     const VkAllocationCallbacks*                pAllocator,
3381     VkPipelineCache*                            pPipelineCache);
3382
3383 VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache(
3384     VkDevice                                    device,
3385     VkPipelineCache                             pipelineCache,
3386     const VkAllocationCallbacks*                pAllocator);
3387
3388 VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData(
3389     VkDevice                                    device,
3390     VkPipelineCache                             pipelineCache,
3391     size_t*                                     pDataSize,
3392     void*                                       pData);
3393
3394 VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches(
3395     VkDevice                                    device,
3396     VkPipelineCache                             dstCache,
3397     uint32_t                                    srcCacheCount,
3398     const VkPipelineCache*                      pSrcCaches);
3399
3400 VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines(
3401     VkDevice                                    device,
3402     VkPipelineCache                             pipelineCache,
3403     uint32_t                                    createInfoCount,
3404     const VkGraphicsPipelineCreateInfo*         pCreateInfos,
3405     const VkAllocationCallbacks*                pAllocator,
3406     VkPipeline*                                 pPipelines);
3407
3408 VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines(
3409     VkDevice                                    device,
3410     VkPipelineCache                             pipelineCache,
3411     uint32_t                                    createInfoCount,
3412     const VkComputePipelineCreateInfo*          pCreateInfos,
3413     const VkAllocationCallbacks*                pAllocator,
3414     VkPipeline*                                 pPipelines);
3415
3416 VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline(
3417     VkDevice                                    device,
3418     VkPipeline                                  pipeline,
3419     const VkAllocationCallbacks*                pAllocator);
3420
3421 VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout(
3422     VkDevice                                    device,
3423     const VkPipelineLayoutCreateInfo*           pCreateInfo,
3424     const VkAllocationCallbacks*                pAllocator,
3425     VkPipelineLayout*                           pPipelineLayout);
3426
3427 VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout(
3428     VkDevice                                    device,
3429     VkPipelineLayout                            pipelineLayout,
3430     const VkAllocationCallbacks*                pAllocator);
3431
3432 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler(
3433     VkDevice                                    device,
3434     const VkSamplerCreateInfo*                  pCreateInfo,
3435     const VkAllocationCallbacks*                pAllocator,
3436     VkSampler*                                  pSampler);
3437
3438 VKAPI_ATTR void VKAPI_CALL vkDestroySampler(
3439     VkDevice                                    device,
3440     VkSampler                                   sampler,
3441     const VkAllocationCallbacks*                pAllocator);
3442
3443 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout(
3444     VkDevice                                    device,
3445     const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
3446     const VkAllocationCallbacks*                pAllocator,
3447     VkDescriptorSetLayout*                      pSetLayout);
3448
3449 VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout(
3450     VkDevice                                    device,
3451     VkDescriptorSetLayout                       descriptorSetLayout,
3452     const VkAllocationCallbacks*                pAllocator);
3453
3454 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool(
3455     VkDevice                                    device,
3456     const VkDescriptorPoolCreateInfo*           pCreateInfo,
3457     const VkAllocationCallbacks*                pAllocator,
3458     VkDescriptorPool*                           pDescriptorPool);
3459
3460 VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool(
3461     VkDevice                                    device,
3462     VkDescriptorPool                            descriptorPool,
3463     const VkAllocationCallbacks*                pAllocator);
3464
3465 VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool(
3466     VkDevice                                    device,
3467     VkDescriptorPool                            descriptorPool,
3468     VkDescriptorPoolResetFlags                  flags);
3469
3470 VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets(
3471     VkDevice                                    device,
3472     const VkDescriptorSetAllocateInfo*          pAllocateInfo,
3473     VkDescriptorSet*                            pDescriptorSets);
3474
3475 VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets(
3476     VkDevice                                    device,
3477     VkDescriptorPool                            descriptorPool,
3478     uint32_t                                    descriptorSetCount,
3479     const VkDescriptorSet*                      pDescriptorSets);
3480
3481 VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets(
3482     VkDevice                                    device,
3483     uint32_t                                    descriptorWriteCount,
3484     const VkWriteDescriptorSet*                 pDescriptorWrites,
3485     uint32_t                                    descriptorCopyCount,
3486     const VkCopyDescriptorSet*                  pDescriptorCopies);
3487
3488 VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer(
3489     VkDevice                                    device,
3490     const VkFramebufferCreateInfo*              pCreateInfo,
3491     const VkAllocationCallbacks*                pAllocator,
3492     VkFramebuffer*                              pFramebuffer);
3493
3494 VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer(
3495     VkDevice                                    device,
3496     VkFramebuffer                               framebuffer,
3497     const VkAllocationCallbacks*                pAllocator);
3498
3499 VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass(
3500     VkDevice                                    device,
3501     const VkRenderPassCreateInfo*               pCreateInfo,
3502     const VkAllocationCallbacks*                pAllocator,
3503     VkRenderPass*                               pRenderPass);
3504
3505 VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass(
3506     VkDevice                                    device,
3507     VkRenderPass                                renderPass,
3508     const VkAllocationCallbacks*                pAllocator);
3509
3510 VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity(
3511     VkDevice                                    device,
3512     VkRenderPass                                renderPass,
3513     VkExtent2D*                                 pGranularity);
3514
3515 VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool(
3516     VkDevice                                    device,
3517     const VkCommandPoolCreateInfo*              pCreateInfo,
3518     const VkAllocationCallbacks*                pAllocator,
3519     VkCommandPool*                              pCommandPool);
3520
3521 VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool(
3522     VkDevice                                    device,
3523     VkCommandPool                               commandPool,
3524     const VkAllocationCallbacks*                pAllocator);
3525
3526 VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool(
3527     VkDevice                                    device,
3528     VkCommandPool                               commandPool,
3529     VkCommandPoolResetFlags                     flags);
3530
3531 VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers(
3532     VkDevice                                    device,
3533     const VkCommandBufferAllocateInfo*          pAllocateInfo,
3534     VkCommandBuffer*                            pCommandBuffers);
3535
3536 VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers(
3537     VkDevice                                    device,
3538     VkCommandPool                               commandPool,
3539     uint32_t                                    commandBufferCount,
3540     const VkCommandBuffer*                      pCommandBuffers);
3541
3542 VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer(
3543     VkCommandBuffer                             commandBuffer,
3544     const VkCommandBufferBeginInfo*             pBeginInfo);
3545
3546 VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer(
3547     VkCommandBuffer                             commandBuffer);
3548
3549 VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer(
3550     VkCommandBuffer                             commandBuffer,
3551     VkCommandBufferResetFlags                   flags);
3552
3553 VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline(
3554     VkCommandBuffer                             commandBuffer,
3555     VkPipelineBindPoint                         pipelineBindPoint,
3556     VkPipeline                                  pipeline);
3557
3558 VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport(
3559     VkCommandBuffer                             commandBuffer,
3560     uint32_t                                    firstViewport,
3561     uint32_t                                    viewportCount,
3562     const VkViewport*                           pViewports);
3563
3564 VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor(
3565     VkCommandBuffer                             commandBuffer,
3566     uint32_t                                    firstScissor,
3567     uint32_t                                    scissorCount,
3568     const VkRect2D*                             pScissors);
3569
3570 VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth(
3571     VkCommandBuffer                             commandBuffer,
3572     float                                       lineWidth);
3573
3574 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias(
3575     VkCommandBuffer                             commandBuffer,
3576     float                                       depthBiasConstantFactor,
3577     float                                       depthBiasClamp,
3578     float                                       depthBiasSlopeFactor);
3579
3580 VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants(
3581     VkCommandBuffer                             commandBuffer,
3582     const float                                 blendConstants[4]);
3583
3584 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds(
3585     VkCommandBuffer                             commandBuffer,
3586     float                                       minDepthBounds,
3587     float                                       maxDepthBounds);
3588
3589 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask(
3590     VkCommandBuffer                             commandBuffer,
3591     VkStencilFaceFlags                          faceMask,
3592     uint32_t                                    compareMask);
3593
3594 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask(
3595     VkCommandBuffer                             commandBuffer,
3596     VkStencilFaceFlags                          faceMask,
3597     uint32_t                                    writeMask);
3598
3599 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference(
3600     VkCommandBuffer                             commandBuffer,
3601     VkStencilFaceFlags                          faceMask,
3602     uint32_t                                    reference);
3603
3604 VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets(
3605     VkCommandBuffer                             commandBuffer,
3606     VkPipelineBindPoint                         pipelineBindPoint,
3607     VkPipelineLayout                            layout,
3608     uint32_t                                    firstSet,
3609     uint32_t                                    descriptorSetCount,