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