external/vulkancts/framework/vulkan/vkVulkan_c.inl

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