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