external/vulkancts/framework/vulkan/vkVulkan_c.inl

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