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