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