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