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