1 #ifndef VULKAN_SC_CORE_H_ 2 #define VULKAN_SC_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 #define VK_MAKE_API_VERSION(variant, major, minor, patch) \ 62 ((((uint32_t)(variant)) << 29U) | (((uint32_t)(major)) << 22U) | (((uint32_t)(minor)) << 12U) | ((uint32_t)(patch))) 63 64 // Vulkan 1.0 version number 65 #define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0 66 67 // Version of this file 68 #define VK_HEADER_VERSION 12 69 70 // Vulkan SC variant number 71 #define VKSC_API_VARIANT 1 72 73 // Complete version of this file 74 #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(VKSC_API_VARIANT, 1, 0, VK_HEADER_VERSION) 75 76 #define VK_API_VERSION_VARIANT(version) ((uint32_t)(version) >> 29U) 77 #define VK_API_VERSION_MAJOR(version) (((uint32_t)(version) >> 22U) & 0x7FU) 78 #define VK_API_VERSION_MINOR(version) (((uint32_t)(version) >> 12U) & 0x3FFU) 79 #define VK_API_VERSION_PATCH(version) ((uint32_t)(version) & 0xFFFU) 80 typedef uint32_t VkBool32; 81 typedef uint64_t VkDeviceAddress; 82 typedef uint64_t VkDeviceSize; 83 typedef uint32_t VkFlags; 84 typedef uint32_t VkSampleMask; 85 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer) 86 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage) 87 VK_DEFINE_HANDLE(VkInstance) 88 VK_DEFINE_HANDLE(VkPhysicalDevice) 89 VK_DEFINE_HANDLE(VkDevice) 90 VK_DEFINE_HANDLE(VkQueue) 91 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore) 92 VK_DEFINE_HANDLE(VkCommandBuffer) 93 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence) 94 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory) 95 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent) 96 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool) 97 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView) 98 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView) 99 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule) 100 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache) 101 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout) 102 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline) 103 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass) 104 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout) 105 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler) 106 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet) 107 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool) 108 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer) 109 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool) 110 #define VK_UUID_SIZE 16U 111 #define VK_ATTACHMENT_UNUSED (~0U) 112 #define VK_FALSE 0U 113 #define VK_LOD_CLAMP_NONE 1000.0F 114 #define VK_QUEUE_FAMILY_IGNORED (~0U) 115 #define VK_REMAINING_ARRAY_LAYERS (~0U) 116 #define VK_REMAINING_MIP_LEVELS (~0U) 117 #define VK_SUBPASS_EXTERNAL (~0U) 118 #define VK_TRUE 1U 119 #define VK_WHOLE_SIZE (~0ULL) 120 #define VK_MAX_MEMORY_TYPES 32U 121 #define VK_MAX_MEMORY_HEAPS 16U 122 #define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE 256U 123 #define VK_MAX_EXTENSION_NAME_SIZE 256U 124 #define VK_MAX_DESCRIPTION_SIZE 256U 125 126 typedef enum VkResult { 127 VK_SUCCESS = 0, 128 VK_NOT_READY = 1, 129 VK_TIMEOUT = 2, 130 VK_EVENT_SET = 3, 131 VK_EVENT_RESET = 4, 132 VK_INCOMPLETE = 5, 133 VK_ERROR_OUT_OF_HOST_MEMORY = -1, 134 VK_ERROR_OUT_OF_DEVICE_MEMORY = -2, 135 VK_ERROR_INITIALIZATION_FAILED = -3, 136 VK_ERROR_DEVICE_LOST = -4, 137 VK_ERROR_MEMORY_MAP_FAILED = -5, 138 VK_ERROR_LAYER_NOT_PRESENT = -6, 139 VK_ERROR_EXTENSION_NOT_PRESENT = -7, 140 VK_ERROR_FEATURE_NOT_PRESENT = -8, 141 VK_ERROR_INCOMPATIBLE_DRIVER = -9, 142 VK_ERROR_TOO_MANY_OBJECTS = -10, 143 VK_ERROR_FORMAT_NOT_SUPPORTED = -11, 144 VK_ERROR_FRAGMENTED_POOL = -12, 145 VK_ERROR_UNKNOWN = -13, 146 VK_ERROR_OUT_OF_POOL_MEMORY = -1000069000, 147 VK_ERROR_INVALID_EXTERNAL_HANDLE = -1000072003, 148 VK_ERROR_FRAGMENTATION = -1000161000, 149 VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS = -1000257000, 150 VK_ERROR_VALIDATION_FAILED = -1000011001, 151 VK_ERROR_INVALID_PIPELINE_CACHE_DATA = -1000298000, 152 VK_ERROR_NO_PIPELINE_MATCH = -1000298001, 153 VK_ERROR_SURFACE_LOST_KHR = -1000000000, 154 VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001, 155 VK_SUBOPTIMAL_KHR = 1000001003, 156 VK_ERROR_OUT_OF_DATE_KHR = -1000001004, 157 VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001, 158 VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT = -1000158000, 159 VK_ERROR_NOT_PERMITTED_EXT = -1000174001, 160 VK_RESULT_MAX_ENUM = 0x7FFFFFFF 161 } VkResult; 162 163 typedef enum VkStructureType { 164 VK_STRUCTURE_TYPE_APPLICATION_INFO = 0, 165 VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1, 166 VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2, 167 VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3, 168 VK_STRUCTURE_TYPE_SUBMIT_INFO = 4, 169 VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5, 170 VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6, 171 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8, 172 VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9, 173 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10, 174 VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11, 175 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12, 176 VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13, 177 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14, 178 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15, 179 VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17, 180 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18, 181 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19, 182 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20, 183 VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21, 184 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22, 185 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23, 186 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24, 187 VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25, 188 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26, 189 VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27, 190 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28, 191 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29, 192 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30, 193 VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31, 194 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32, 195 VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33, 196 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34, 197 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35, 198 VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36, 199 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37, 200 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38, 201 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39, 202 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40, 203 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41, 204 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42, 205 VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43, 206 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44, 207 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45, 208 VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46, 209 VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47, 210 VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48, 211 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES = 1000094000, 212 VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO = 1000157000, 213 VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO = 1000157001, 214 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES = 1000083000, 215 VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS = 1000127000, 216 VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO = 1000127001, 217 VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO = 1000060000, 218 VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO = 1000060003, 219 VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO = 1000060004, 220 VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO = 1000060005, 221 VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO = 1000060013, 222 VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO = 1000060014, 223 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES = 1000070000, 224 VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO = 1000070001, 225 VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2 = 1000146000, 226 VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2 = 1000146001, 227 VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 = 1000146003, 228 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 = 1000059000, 229 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 = 1000059001, 230 VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 = 1000059002, 231 VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 = 1000059003, 232 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 = 1000059004, 233 VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 = 1000059005, 234 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 = 1000059006, 235 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES = 1000117000, 236 VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO = 1000117001, 237 VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO = 1000117002, 238 VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO = 1000117003, 239 VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO = 1000053000, 240 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES = 1000053001, 241 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES = 1000053002, 242 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES = 1000120000, 243 VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO = 1000145000, 244 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES = 1000145001, 245 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES = 1000145002, 246 VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 = 1000145003, 247 VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO = 1000156000, 248 VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO = 1000156001, 249 VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO = 1000156002, 250 VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO = 1000156003, 251 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES = 1000156004, 252 VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES = 1000156005, 253 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO = 1000071000, 254 VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES = 1000071001, 255 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO = 1000071002, 256 VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES = 1000071003, 257 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES = 1000071004, 258 VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO = 1000072000, 259 VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO = 1000072001, 260 VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO = 1000072002, 261 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO = 1000112000, 262 VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES = 1000112001, 263 VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO = 1000113000, 264 VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO = 1000077000, 265 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO = 1000076000, 266 VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES = 1000076001, 267 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES = 1000168000, 268 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT = 1000168001, 269 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES = 1000063000, 270 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES = 49, 271 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES = 50, 272 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES = 51, 273 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES = 52, 274 VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO = 1000147000, 275 VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2 = 1000109000, 276 VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2 = 1000109001, 277 VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2 = 1000109002, 278 VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2 = 1000109003, 279 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2 = 1000109004, 280 VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO = 1000109005, 281 VK_STRUCTURE_TYPE_SUBPASS_END_INFO = 1000109006, 282 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES = 1000177000, 283 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES = 1000196000, 284 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES = 1000180000, 285 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES = 1000082000, 286 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES = 1000197000, 287 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO = 1000161000, 288 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES = 1000161001, 289 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES = 1000161002, 290 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO = 1000161003, 291 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT = 1000161004, 292 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES = 1000199000, 293 VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE = 1000199001, 294 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES = 1000221000, 295 VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO = 1000246000, 296 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES = 1000130000, 297 VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO = 1000130001, 298 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES = 1000211000, 299 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES = 1000108000, 300 VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO = 1000108001, 301 VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO = 1000108002, 302 VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO = 1000108003, 303 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES = 1000253000, 304 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES = 1000175000, 305 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES = 1000241000, 306 VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT = 1000241001, 307 VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT = 1000241002, 308 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES = 1000261000, 309 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES = 1000207000, 310 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES = 1000207001, 311 VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO = 1000207002, 312 VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO = 1000207003, 313 VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO = 1000207004, 314 VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO = 1000207005, 315 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES = 1000257000, 316 VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO = 1000244001, 317 VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO = 1000257002, 318 VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO = 1000257003, 319 VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO = 1000257004, 320 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_FEATURES = 1000298000, 321 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_PROPERTIES = 1000298001, 322 VK_STRUCTURE_TYPE_DEVICE_OBJECT_RESERVATION_CREATE_INFO = 1000298002, 323 VK_STRUCTURE_TYPE_COMMAND_POOL_MEMORY_RESERVATION_CREATE_INFO = 1000298003, 324 VK_STRUCTURE_TYPE_COMMAND_POOL_MEMORY_CONSUMPTION = 1000298004, 325 VK_STRUCTURE_TYPE_PIPELINE_POOL_SIZE = 1000298005, 326 VK_STRUCTURE_TYPE_FAULT_DATA = 1000298007, 327 VK_STRUCTURE_TYPE_FAULT_CALLBACK_INFO = 1000298008, 328 VK_STRUCTURE_TYPE_PIPELINE_OFFLINE_CREATE_INFO = 1000298010, 329 VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000, 330 VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001, 331 VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR = 1000060007, 332 VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR = 1000060008, 333 VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR = 1000060009, 334 VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR = 1000060010, 335 VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR = 1000060011, 336 VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR = 1000060012, 337 VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000, 338 VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001, 339 VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000, 340 VK_STRUCTURE_TYPE_PRIVATE_VENDOR_INFO_RESERVED_OFFSET_0_NV = 1000051000, 341 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT = 1000066000, 342 VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT = 1000067000, 343 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT = 1000067001, 344 VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR = 1000074000, 345 VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR = 1000074001, 346 VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR = 1000074002, 347 VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR = 1000079000, 348 VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR = 1000079001, 349 VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000, 350 VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT = 1000090000, 351 VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT = 1000091000, 352 VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT = 1000091001, 353 VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT = 1000091002, 354 VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT = 1000091003, 355 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT = 1000099000, 356 VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT = 1000099001, 357 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT = 1000101000, 358 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT = 1000101001, 359 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT = 1000102000, 360 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT = 1000102001, 361 VK_STRUCTURE_TYPE_HDR_METADATA_EXT = 1000105000, 362 VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000, 363 VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR = 1000115000, 364 VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR = 1000115001, 365 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR = 1000116000, 366 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR = 1000116001, 367 VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR = 1000116002, 368 VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR = 1000116003, 369 VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR = 1000116004, 370 VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR = 1000116005, 371 VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR = 1000116006, 372 VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR = 1000116007, 373 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000, 374 VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001, 375 VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002, 376 VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR = 1000121000, 377 VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR = 1000121001, 378 VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR = 1000121002, 379 VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR = 1000121003, 380 VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR = 1000121004, 381 VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT = 1000128000, 382 VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT = 1000128001, 383 VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT = 1000128002, 384 VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT = 1000128003, 385 VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT = 1000128004, 386 VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT = 1000143000, 387 VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT = 1000143001, 388 VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT = 1000143002, 389 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT = 1000143003, 390 VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT = 1000143004, 391 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT = 1000148000, 392 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT = 1000148001, 393 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT = 1000148002, 394 VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT = 1000158000, 395 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT = 1000158002, 396 VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT = 1000158003, 397 VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT = 1000158004, 398 VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT = 1000158005, 399 VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT = 1000158006, 400 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT = 1000170000, 401 VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT = 1000170001, 402 VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT = 1000174000, 403 VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT = 1000178000, 404 VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT = 1000178001, 405 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002, 406 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR = 1000181000, 407 VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT = 1000184000, 408 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT = 1000190000, 409 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT = 1000190001, 410 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT = 1000190002, 411 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT = 1000212000, 412 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR = 1000215000, 413 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT = 1000225000, 414 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT = 1000225001, 415 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT = 1000225002, 416 VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR = 1000226000, 417 VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR = 1000226001, 418 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR = 1000226002, 419 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR = 1000226003, 420 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR = 1000226004, 421 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT = 1000234000, 422 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT = 1000237000, 423 VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT = 1000247000, 424 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT = 1000251000, 425 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT = 1000252000, 426 VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT = 1000256000, 427 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT = 1000259000, 428 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT = 1000259001, 429 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT = 1000259002, 430 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT = 1000260000, 431 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT = 1000265000, 432 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT = 1000267000, 433 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT = 1000276000, 434 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT = 1000281000, 435 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT = 1000281001, 436 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT = 1000286000, 437 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT = 1000286001, 438 VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT = 1000287000, 439 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT = 1000287001, 440 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT = 1000287002, 441 VK_STRUCTURE_TYPE_REFRESH_OBJECT_LIST_KHR = 1000308000, 442 VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR = 1000314000, 443 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR = 1000314001, 444 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR = 1000314002, 445 VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR = 1000314003, 446 VK_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR = 1000314004, 447 VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR = 1000314005, 448 VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR = 1000314006, 449 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR = 1000314007, 450 VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV = 1000314008, 451 VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV = 1000314009, 452 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT = 1000330000, 453 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT = 1000335000, 454 VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR = 1000337000, 455 VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR = 1000337001, 456 VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR = 1000337002, 457 VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR = 1000337003, 458 VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR = 1000337004, 459 VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR = 1000337005, 460 VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR = 1000337006, 461 VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR = 1000337007, 462 VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR = 1000337008, 463 VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR = 1000337009, 464 VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR = 1000337010, 465 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT = 1000340000, 466 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT = 1000352000, 467 VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT = 1000352001, 468 VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT = 1000352002, 469 VK_STRUCTURE_TYPE_IMPORT_FENCE_SCI_SYNC_INFO_NV = 1000373000, 470 VK_STRUCTURE_TYPE_EXPORT_FENCE_SCI_SYNC_INFO_NV = 1000373001, 471 VK_STRUCTURE_TYPE_FENCE_GET_SCI_SYNC_INFO_NV = 1000373002, 472 VK_STRUCTURE_TYPE_SCI_SYNC_ATTRIBUTES_INFO_NV = 1000373003, 473 VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_SCI_SYNC_INFO_NV = 1000373004, 474 VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_SCI_SYNC_INFO_NV = 1000373005, 475 VK_STRUCTURE_TYPE_SEMAPHORE_GET_SCI_SYNC_INFO_NV = 1000373006, 476 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SCI_SYNC_FEATURES_NV = 1000373007, 477 VK_STRUCTURE_TYPE_IMPORT_MEMORY_SCI_BUF_INFO_NV = 1000374000, 478 VK_STRUCTURE_TYPE_EXPORT_MEMORY_SCI_BUF_INFO_NV = 1000374001, 479 VK_STRUCTURE_TYPE_MEMORY_GET_SCI_BUF_INFO_NV = 1000374002, 480 VK_STRUCTURE_TYPE_MEMORY_SCI_BUF_PROPERTIES_NV = 1000374003, 481 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCI_BUF_FEATURES_NV = 1000374004, 482 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT = 1000377000, 483 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT = 1000381000, 484 VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT = 1000381001, 485 VK_STRUCTURE_TYPE_APPLICATION_PARAMETERS_EXT = 1000435000, 486 VK_STRUCTURE_TYPE_SEMAPHORE_SCI_SYNC_POOL_CREATE_INFO_NV = 1000489000, 487 VK_STRUCTURE_TYPE_SEMAPHORE_SCI_SYNC_CREATE_INFO_NV = 1000489001, 488 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SCI_SYNC_2_FEATURES_NV = 1000489002, 489 VK_STRUCTURE_TYPE_DEVICE_SEMAPHORE_SCI_SYNC_POOL_RESERVATION_CREATE_INFO_NV = 1000489003, 490 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SCI_BUF_FEATURES_NV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCI_BUF_FEATURES_NV, 491 VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF 492 } VkStructureType; 493 494 typedef enum VkImageLayout { 495 VK_IMAGE_LAYOUT_UNDEFINED = 0, 496 VK_IMAGE_LAYOUT_GENERAL = 1, 497 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2, 498 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3, 499 VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4, 500 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5, 501 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6, 502 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7, 503 VK_IMAGE_LAYOUT_PREINITIALIZED = 8, 504 VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL = 1000117000, 505 VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL = 1000117001, 506 VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL = 1000241000, 507 VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL = 1000241001, 508 VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL = 1000241002, 509 VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL = 1000241003, 510 VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002, 511 VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000, 512 VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR = 1000164003, 513 VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR = 1000314000, 514 VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR = 1000314001, 515 VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF 516 } VkImageLayout; 517 518 typedef enum VkObjectType { 519 VK_OBJECT_TYPE_UNKNOWN = 0, 520 VK_OBJECT_TYPE_INSTANCE = 1, 521 VK_OBJECT_TYPE_PHYSICAL_DEVICE = 2, 522 VK_OBJECT_TYPE_DEVICE = 3, 523 VK_OBJECT_TYPE_QUEUE = 4, 524 VK_OBJECT_TYPE_SEMAPHORE = 5, 525 VK_OBJECT_TYPE_COMMAND_BUFFER = 6, 526 VK_OBJECT_TYPE_FENCE = 7, 527 VK_OBJECT_TYPE_DEVICE_MEMORY = 8, 528 VK_OBJECT_TYPE_BUFFER = 9, 529 VK_OBJECT_TYPE_IMAGE = 10, 530 VK_OBJECT_TYPE_EVENT = 11, 531 VK_OBJECT_TYPE_QUERY_POOL = 12, 532 VK_OBJECT_TYPE_BUFFER_VIEW = 13, 533 VK_OBJECT_TYPE_IMAGE_VIEW = 14, 534 VK_OBJECT_TYPE_SHADER_MODULE = 15, 535 VK_OBJECT_TYPE_PIPELINE_CACHE = 16, 536 VK_OBJECT_TYPE_PIPELINE_LAYOUT = 17, 537 VK_OBJECT_TYPE_RENDER_PASS = 18, 538 VK_OBJECT_TYPE_PIPELINE = 19, 539 VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 20, 540 VK_OBJECT_TYPE_SAMPLER = 21, 541 VK_OBJECT_TYPE_DESCRIPTOR_POOL = 22, 542 VK_OBJECT_TYPE_DESCRIPTOR_SET = 23, 543 VK_OBJECT_TYPE_FRAMEBUFFER = 24, 544 VK_OBJECT_TYPE_COMMAND_POOL = 25, 545 VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION = 1000156000, 546 VK_OBJECT_TYPE_SURFACE_KHR = 1000000000, 547 VK_OBJECT_TYPE_SWAPCHAIN_KHR = 1000001000, 548 VK_OBJECT_TYPE_DISPLAY_KHR = 1000002000, 549 VK_OBJECT_TYPE_DISPLAY_MODE_KHR = 1000002001, 550 VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT = 1000128000, 551 VK_OBJECT_TYPE_SEMAPHORE_SCI_SYNC_POOL_NV = 1000489000, 552 VK_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF 553 } VkObjectType; 554 555 typedef enum VkPipelineCacheHeaderVersion { 556 VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1, 557 VK_PIPELINE_CACHE_HEADER_VERSION_SAFETY_CRITICAL_ONE = 1000298001, 558 VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF 559 } VkPipelineCacheHeaderVersion; 560 561 typedef enum VkVendorId { 562 VK_VENDOR_ID_VIV = 0x10001, 563 VK_VENDOR_ID_VSI = 0x10002, 564 VK_VENDOR_ID_KAZAN = 0x10003, 565 VK_VENDOR_ID_CODEPLAY = 0x10004, 566 VK_VENDOR_ID_MESA = 0x10005, 567 VK_VENDOR_ID_POCL = 0x10006, 568 VK_VENDOR_ID_MAX_ENUM = 0x7FFFFFFF 569 } VkVendorId; 570 571 typedef enum VkSystemAllocationScope { 572 VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0, 573 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1, 574 VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2, 575 VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3, 576 VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4, 577 VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF 578 } VkSystemAllocationScope; 579 580 typedef enum VkInternalAllocationType { 581 VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0, 582 VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF 583 } VkInternalAllocationType; 584 585 typedef enum VkFormat { 586 VK_FORMAT_UNDEFINED = 0, 587 VK_FORMAT_R4G4_UNORM_PACK8 = 1, 588 VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2, 589 VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3, 590 VK_FORMAT_R5G6B5_UNORM_PACK16 = 4, 591 VK_FORMAT_B5G6R5_UNORM_PACK16 = 5, 592 VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6, 593 VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7, 594 VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8, 595 VK_FORMAT_R8_UNORM = 9, 596 VK_FORMAT_R8_SNORM = 10, 597 VK_FORMAT_R8_USCALED = 11, 598 VK_FORMAT_R8_SSCALED = 12, 599 VK_FORMAT_R8_UINT = 13, 600 VK_FORMAT_R8_SINT = 14, 601 VK_FORMAT_R8_SRGB = 15, 602 VK_FORMAT_R8G8_UNORM = 16, 603 VK_FORMAT_R8G8_SNORM = 17, 604 VK_FORMAT_R8G8_USCALED = 18, 605 VK_FORMAT_R8G8_SSCALED = 19, 606 VK_FORMAT_R8G8_UINT = 20, 607 VK_FORMAT_R8G8_SINT = 21, 608 VK_FORMAT_R8G8_SRGB = 22, 609 VK_FORMAT_R8G8B8_UNORM = 23, 610 VK_FORMAT_R8G8B8_SNORM = 24, 611 VK_FORMAT_R8G8B8_USCALED = 25, 612 VK_FORMAT_R8G8B8_SSCALED = 26, 613 VK_FORMAT_R8G8B8_UINT = 27, 614 VK_FORMAT_R8G8B8_SINT = 28, 615 VK_FORMAT_R8G8B8_SRGB = 29, 616 VK_FORMAT_B8G8R8_UNORM = 30, 617 VK_FORMAT_B8G8R8_SNORM = 31, 618 VK_FORMAT_B8G8R8_USCALED = 32, 619 VK_FORMAT_B8G8R8_SSCALED = 33, 620 VK_FORMAT_B8G8R8_UINT = 34, 621 VK_FORMAT_B8G8R8_SINT = 35, 622 VK_FORMAT_B8G8R8_SRGB = 36, 623 VK_FORMAT_R8G8B8A8_UNORM = 37, 624 VK_FORMAT_R8G8B8A8_SNORM = 38, 625 VK_FORMAT_R8G8B8A8_USCALED = 39, 626 VK_FORMAT_R8G8B8A8_SSCALED = 40, 627 VK_FORMAT_R8G8B8A8_UINT = 41, 628 VK_FORMAT_R8G8B8A8_SINT = 42, 629 VK_FORMAT_R8G8B8A8_SRGB = 43, 630 VK_FORMAT_B8G8R8A8_UNORM = 44, 631 VK_FORMAT_B8G8R8A8_SNORM = 45, 632 VK_FORMAT_B8G8R8A8_USCALED = 46, 633 VK_FORMAT_B8G8R8A8_SSCALED = 47, 634 VK_FORMAT_B8G8R8A8_UINT = 48, 635 VK_FORMAT_B8G8R8A8_SINT = 49, 636 VK_FORMAT_B8G8R8A8_SRGB = 50, 637 VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51, 638 VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52, 639 VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53, 640 VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54, 641 VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55, 642 VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56, 643 VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57, 644 VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58, 645 VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59, 646 VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60, 647 VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61, 648 VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62, 649 VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63, 650 VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64, 651 VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65, 652 VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66, 653 VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67, 654 VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68, 655 VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69, 656 VK_FORMAT_R16_UNORM = 70, 657 VK_FORMAT_R16_SNORM = 71, 658 VK_FORMAT_R16_USCALED = 72, 659 VK_FORMAT_R16_SSCALED = 73, 660 VK_FORMAT_R16_UINT = 74, 661 VK_FORMAT_R16_SINT = 75, 662 VK_FORMAT_R16_SFLOAT = 76, 663 VK_FORMAT_R16G16_UNORM = 77, 664 VK_FORMAT_R16G16_SNORM = 78, 665 VK_FORMAT_R16G16_USCALED = 79, 666 VK_FORMAT_R16G16_SSCALED = 80, 667 VK_FORMAT_R16G16_UINT = 81, 668 VK_FORMAT_R16G16_SINT = 82, 669 VK_FORMAT_R16G16_SFLOAT = 83, 670 VK_FORMAT_R16G16B16_UNORM = 84, 671 VK_FORMAT_R16G16B16_SNORM = 85, 672 VK_FORMAT_R16G16B16_USCALED = 86, 673 VK_FORMAT_R16G16B16_SSCALED = 87, 674 VK_FORMAT_R16G16B16_UINT = 88, 675 VK_FORMAT_R16G16B16_SINT = 89, 676 VK_FORMAT_R16G16B16_SFLOAT = 90, 677 VK_FORMAT_R16G16B16A16_UNORM = 91, 678 VK_FORMAT_R16G16B16A16_SNORM = 92, 679 VK_FORMAT_R16G16B16A16_USCALED = 93, 680 VK_FORMAT_R16G16B16A16_SSCALED = 94, 681 VK_FORMAT_R16G16B16A16_UINT = 95, 682 VK_FORMAT_R16G16B16A16_SINT = 96, 683 VK_FORMAT_R16G16B16A16_SFLOAT = 97, 684 VK_FORMAT_R32_UINT = 98, 685 VK_FORMAT_R32_SINT = 99, 686 VK_FORMAT_R32_SFLOAT = 100, 687 VK_FORMAT_R32G32_UINT = 101, 688 VK_FORMAT_R32G32_SINT = 102, 689 VK_FORMAT_R32G32_SFLOAT = 103, 690 VK_FORMAT_R32G32B32_UINT = 104, 691 VK_FORMAT_R32G32B32_SINT = 105, 692 VK_FORMAT_R32G32B32_SFLOAT = 106, 693 VK_FORMAT_R32G32B32A32_UINT = 107, 694 VK_FORMAT_R32G32B32A32_SINT = 108, 695 VK_FORMAT_R32G32B32A32_SFLOAT = 109, 696 VK_FORMAT_R64_UINT = 110, 697 VK_FORMAT_R64_SINT = 111, 698 VK_FORMAT_R64_SFLOAT = 112, 699 VK_FORMAT_R64G64_UINT = 113, 700 VK_FORMAT_R64G64_SINT = 114, 701 VK_FORMAT_R64G64_SFLOAT = 115, 702 VK_FORMAT_R64G64B64_UINT = 116, 703 VK_FORMAT_R64G64B64_SINT = 117, 704 VK_FORMAT_R64G64B64_SFLOAT = 118, 705 VK_FORMAT_R64G64B64A64_UINT = 119, 706 VK_FORMAT_R64G64B64A64_SINT = 120, 707 VK_FORMAT_R64G64B64A64_SFLOAT = 121, 708 VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122, 709 VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123, 710 VK_FORMAT_D16_UNORM = 124, 711 VK_FORMAT_X8_D24_UNORM_PACK32 = 125, 712 VK_FORMAT_D32_SFLOAT = 126, 713 VK_FORMAT_S8_UINT = 127, 714 VK_FORMAT_D16_UNORM_S8_UINT = 128, 715 VK_FORMAT_D24_UNORM_S8_UINT = 129, 716 VK_FORMAT_D32_SFLOAT_S8_UINT = 130, 717 VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131, 718 VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132, 719 VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133, 720 VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134, 721 VK_FORMAT_BC2_UNORM_BLOCK = 135, 722 VK_FORMAT_BC2_SRGB_BLOCK = 136, 723 VK_FORMAT_BC3_UNORM_BLOCK = 137, 724 VK_FORMAT_BC3_SRGB_BLOCK = 138, 725 VK_FORMAT_BC4_UNORM_BLOCK = 139, 726 VK_FORMAT_BC4_SNORM_BLOCK = 140, 727 VK_FORMAT_BC5_UNORM_BLOCK = 141, 728 VK_FORMAT_BC5_SNORM_BLOCK = 142, 729 VK_FORMAT_BC6H_UFLOAT_BLOCK = 143, 730 VK_FORMAT_BC6H_SFLOAT_BLOCK = 144, 731 VK_FORMAT_BC7_UNORM_BLOCK = 145, 732 VK_FORMAT_BC7_SRGB_BLOCK = 146, 733 VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147, 734 VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148, 735 VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149, 736 VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150, 737 VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151, 738 VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152, 739 VK_FORMAT_EAC_R11_UNORM_BLOCK = 153, 740 VK_FORMAT_EAC_R11_SNORM_BLOCK = 154, 741 VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155, 742 VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156, 743 VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157, 744 VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158, 745 VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159, 746 VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160, 747 VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161, 748 VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162, 749 VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163, 750 VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164, 751 VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165, 752 VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166, 753 VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167, 754 VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168, 755 VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169, 756 VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170, 757 VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171, 758 VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172, 759 VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173, 760 VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174, 761 VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175, 762 VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176, 763 VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177, 764 VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178, 765 VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179, 766 VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180, 767 VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181, 768 VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182, 769 VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183, 770 VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184, 771 VK_FORMAT_G8B8G8R8_422_UNORM = 1000156000, 772 VK_FORMAT_B8G8R8G8_422_UNORM = 1000156001, 773 VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM = 1000156002, 774 VK_FORMAT_G8_B8R8_2PLANE_420_UNORM = 1000156003, 775 VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM = 1000156004, 776 VK_FORMAT_G8_B8R8_2PLANE_422_UNORM = 1000156005, 777 VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM = 1000156006, 778 VK_FORMAT_R10X6_UNORM_PACK16 = 1000156007, 779 VK_FORMAT_R10X6G10X6_UNORM_2PACK16 = 1000156008, 780 VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 = 1000156009, 781 VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 = 1000156010, 782 VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 = 1000156011, 783 VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 = 1000156012, 784 VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 = 1000156013, 785 VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 = 1000156014, 786 VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 = 1000156015, 787 VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 = 1000156016, 788 VK_FORMAT_R12X4_UNORM_PACK16 = 1000156017, 789 VK_FORMAT_R12X4G12X4_UNORM_2PACK16 = 1000156018, 790 VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 = 1000156019, 791 VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 = 1000156020, 792 VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 = 1000156021, 793 VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 = 1000156022, 794 VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 = 1000156023, 795 VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 = 1000156024, 796 VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 = 1000156025, 797 VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 = 1000156026, 798 VK_FORMAT_G16B16G16R16_422_UNORM = 1000156027, 799 VK_FORMAT_B16G16R16G16_422_UNORM = 1000156028, 800 VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM = 1000156029, 801 VK_FORMAT_G16_B16R16_2PLANE_420_UNORM = 1000156030, 802 VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM = 1000156031, 803 VK_FORMAT_G16_B16R16_2PLANE_422_UNORM = 1000156032, 804 VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM = 1000156033, 805 VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT = 1000066000, 806 VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT = 1000066001, 807 VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT = 1000066002, 808 VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT = 1000066003, 809 VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT = 1000066004, 810 VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT = 1000066005, 811 VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT = 1000066006, 812 VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT = 1000066007, 813 VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT = 1000066008, 814 VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT = 1000066009, 815 VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT = 1000066010, 816 VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT = 1000066011, 817 VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT = 1000066012, 818 VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT = 1000066013, 819 VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT = 1000330000, 820 VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT = 1000330001, 821 VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT = 1000330002, 822 VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT = 1000330003, 823 VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT = 1000340000, 824 VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT = 1000340001, 825 VK_FORMAT_MAX_ENUM = 0x7FFFFFFF 826 } VkFormat; 827 828 typedef enum VkImageTiling { 829 VK_IMAGE_TILING_OPTIMAL = 0, 830 VK_IMAGE_TILING_LINEAR = 1, 831 VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT = 1000158000, 832 VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF 833 } VkImageTiling; 834 835 typedef enum VkImageType { 836 VK_IMAGE_TYPE_1D = 0, 837 VK_IMAGE_TYPE_2D = 1, 838 VK_IMAGE_TYPE_3D = 2, 839 VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF 840 } VkImageType; 841 842 typedef enum VkPhysicalDeviceType { 843 VK_PHYSICAL_DEVICE_TYPE_OTHER = 0, 844 VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1, 845 VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2, 846 VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3, 847 VK_PHYSICAL_DEVICE_TYPE_CPU = 4, 848 VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF 849 } VkPhysicalDeviceType; 850 851 typedef enum VkQueryType { 852 VK_QUERY_TYPE_OCCLUSION = 0, 853 VK_QUERY_TYPE_PIPELINE_STATISTICS = 1, 854 VK_QUERY_TYPE_TIMESTAMP = 2, 855 VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR = 1000116000, 856 VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF 857 } VkQueryType; 858 859 typedef enum VkSharingMode { 860 VK_SHARING_MODE_EXCLUSIVE = 0, 861 VK_SHARING_MODE_CONCURRENT = 1, 862 VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF 863 } VkSharingMode; 864 865 typedef enum VkComponentSwizzle { 866 VK_COMPONENT_SWIZZLE_IDENTITY = 0, 867 VK_COMPONENT_SWIZZLE_ZERO = 1, 868 VK_COMPONENT_SWIZZLE_ONE = 2, 869 VK_COMPONENT_SWIZZLE_R = 3, 870 VK_COMPONENT_SWIZZLE_G = 4, 871 VK_COMPONENT_SWIZZLE_B = 5, 872 VK_COMPONENT_SWIZZLE_A = 6, 873 VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF 874 } VkComponentSwizzle; 875 876 typedef enum VkImageViewType { 877 VK_IMAGE_VIEW_TYPE_1D = 0, 878 VK_IMAGE_VIEW_TYPE_2D = 1, 879 VK_IMAGE_VIEW_TYPE_3D = 2, 880 VK_IMAGE_VIEW_TYPE_CUBE = 3, 881 VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4, 882 VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5, 883 VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6, 884 VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF 885 } VkImageViewType; 886 887 typedef enum VkBlendFactor { 888 VK_BLEND_FACTOR_ZERO = 0, 889 VK_BLEND_FACTOR_ONE = 1, 890 VK_BLEND_FACTOR_SRC_COLOR = 2, 891 VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3, 892 VK_BLEND_FACTOR_DST_COLOR = 4, 893 VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5, 894 VK_BLEND_FACTOR_SRC_ALPHA = 6, 895 VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7, 896 VK_BLEND_FACTOR_DST_ALPHA = 8, 897 VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9, 898 VK_BLEND_FACTOR_CONSTANT_COLOR = 10, 899 VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11, 900 VK_BLEND_FACTOR_CONSTANT_ALPHA = 12, 901 VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13, 902 VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14, 903 VK_BLEND_FACTOR_SRC1_COLOR = 15, 904 VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16, 905 VK_BLEND_FACTOR_SRC1_ALPHA = 17, 906 VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18, 907 VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF 908 } VkBlendFactor; 909 910 typedef enum VkBlendOp { 911 VK_BLEND_OP_ADD = 0, 912 VK_BLEND_OP_SUBTRACT = 1, 913 VK_BLEND_OP_REVERSE_SUBTRACT = 2, 914 VK_BLEND_OP_MIN = 3, 915 VK_BLEND_OP_MAX = 4, 916 VK_BLEND_OP_ZERO_EXT = 1000148000, 917 VK_BLEND_OP_SRC_EXT = 1000148001, 918 VK_BLEND_OP_DST_EXT = 1000148002, 919 VK_BLEND_OP_SRC_OVER_EXT = 1000148003, 920 VK_BLEND_OP_DST_OVER_EXT = 1000148004, 921 VK_BLEND_OP_SRC_IN_EXT = 1000148005, 922 VK_BLEND_OP_DST_IN_EXT = 1000148006, 923 VK_BLEND_OP_SRC_OUT_EXT = 1000148007, 924 VK_BLEND_OP_DST_OUT_EXT = 1000148008, 925 VK_BLEND_OP_SRC_ATOP_EXT = 1000148009, 926 VK_BLEND_OP_DST_ATOP_EXT = 1000148010, 927 VK_BLEND_OP_XOR_EXT = 1000148011, 928 VK_BLEND_OP_MULTIPLY_EXT = 1000148012, 929 VK_BLEND_OP_SCREEN_EXT = 1000148013, 930 VK_BLEND_OP_OVERLAY_EXT = 1000148014, 931 VK_BLEND_OP_DARKEN_EXT = 1000148015, 932 VK_BLEND_OP_LIGHTEN_EXT = 1000148016, 933 VK_BLEND_OP_COLORDODGE_EXT = 1000148017, 934 VK_BLEND_OP_COLORBURN_EXT = 1000148018, 935 VK_BLEND_OP_HARDLIGHT_EXT = 1000148019, 936 VK_BLEND_OP_SOFTLIGHT_EXT = 1000148020, 937 VK_BLEND_OP_DIFFERENCE_EXT = 1000148021, 938 VK_BLEND_OP_EXCLUSION_EXT = 1000148022, 939 VK_BLEND_OP_INVERT_EXT = 1000148023, 940 VK_BLEND_OP_INVERT_RGB_EXT = 1000148024, 941 VK_BLEND_OP_LINEARDODGE_EXT = 1000148025, 942 VK_BLEND_OP_LINEARBURN_EXT = 1000148026, 943 VK_BLEND_OP_VIVIDLIGHT_EXT = 1000148027, 944 VK_BLEND_OP_LINEARLIGHT_EXT = 1000148028, 945 VK_BLEND_OP_PINLIGHT_EXT = 1000148029, 946 VK_BLEND_OP_HARDMIX_EXT = 1000148030, 947 VK_BLEND_OP_HSL_HUE_EXT = 1000148031, 948 VK_BLEND_OP_HSL_SATURATION_EXT = 1000148032, 949 VK_BLEND_OP_HSL_COLOR_EXT = 1000148033, 950 VK_BLEND_OP_HSL_LUMINOSITY_EXT = 1000148034, 951 VK_BLEND_OP_PLUS_EXT = 1000148035, 952 VK_BLEND_OP_PLUS_CLAMPED_EXT = 1000148036, 953 VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT = 1000148037, 954 VK_BLEND_OP_PLUS_DARKER_EXT = 1000148038, 955 VK_BLEND_OP_MINUS_EXT = 1000148039, 956 VK_BLEND_OP_MINUS_CLAMPED_EXT = 1000148040, 957 VK_BLEND_OP_CONTRAST_EXT = 1000148041, 958 VK_BLEND_OP_INVERT_OVG_EXT = 1000148042, 959 VK_BLEND_OP_RED_EXT = 1000148043, 960 VK_BLEND_OP_GREEN_EXT = 1000148044, 961 VK_BLEND_OP_BLUE_EXT = 1000148045, 962 VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF 963 } VkBlendOp; 964 965 typedef enum VkCompareOp { 966 VK_COMPARE_OP_NEVER = 0, 967 VK_COMPARE_OP_LESS = 1, 968 VK_COMPARE_OP_EQUAL = 2, 969 VK_COMPARE_OP_LESS_OR_EQUAL = 3, 970 VK_COMPARE_OP_GREATER = 4, 971 VK_COMPARE_OP_NOT_EQUAL = 5, 972 VK_COMPARE_OP_GREATER_OR_EQUAL = 6, 973 VK_COMPARE_OP_ALWAYS = 7, 974 VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF 975 } VkCompareOp; 976 977 typedef enum VkDynamicState { 978 VK_DYNAMIC_STATE_VIEWPORT = 0, 979 VK_DYNAMIC_STATE_SCISSOR = 1, 980 VK_DYNAMIC_STATE_LINE_WIDTH = 2, 981 VK_DYNAMIC_STATE_DEPTH_BIAS = 3, 982 VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4, 983 VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5, 984 VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6, 985 VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7, 986 VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8, 987 VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = 1000099000, 988 VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT = 1000143000, 989 VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR = 1000226000, 990 VK_DYNAMIC_STATE_LINE_STIPPLE_EXT = 1000259000, 991 VK_DYNAMIC_STATE_CULL_MODE_EXT = 1000267000, 992 VK_DYNAMIC_STATE_FRONT_FACE_EXT = 1000267001, 993 VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT = 1000267002, 994 VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT = 1000267003, 995 VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT = 1000267004, 996 VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT = 1000267005, 997 VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT = 1000267006, 998 VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT = 1000267007, 999 VK_DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT = 1000267008, 1000 VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT = 1000267009, 1001 VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT = 1000267010, 1002 VK_DYNAMIC_STATE_STENCIL_OP_EXT = 1000267011, 1003 VK_DYNAMIC_STATE_VERTEX_INPUT_EXT = 1000352000, 1004 VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT = 1000377000, 1005 VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT = 1000377001, 1006 VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT = 1000377002, 1007 VK_DYNAMIC_STATE_LOGIC_OP_EXT = 1000377003, 1008 VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT = 1000377004, 1009 VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT = 1000381000, 1010 VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF 1011 } VkDynamicState; 1012 1013 typedef enum VkFrontFace { 1014 VK_FRONT_FACE_COUNTER_CLOCKWISE = 0, 1015 VK_FRONT_FACE_CLOCKWISE = 1, 1016 VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF 1017 } VkFrontFace; 1018 1019 typedef enum VkVertexInputRate { 1020 VK_VERTEX_INPUT_RATE_VERTEX = 0, 1021 VK_VERTEX_INPUT_RATE_INSTANCE = 1, 1022 VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF 1023 } VkVertexInputRate; 1024 1025 typedef enum VkPrimitiveTopology { 1026 VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0, 1027 VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1, 1028 VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2, 1029 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3, 1030 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4, 1031 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5, 1032 VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6, 1033 VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7, 1034 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8, 1035 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9, 1036 VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10, 1037 VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF 1038 } VkPrimitiveTopology; 1039 1040 typedef enum VkPolygonMode { 1041 VK_POLYGON_MODE_FILL = 0, 1042 VK_POLYGON_MODE_LINE = 1, 1043 VK_POLYGON_MODE_POINT = 2, 1044 VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF 1045 } VkPolygonMode; 1046 1047 typedef enum VkStencilOp { 1048 VK_STENCIL_OP_KEEP = 0, 1049 VK_STENCIL_OP_ZERO = 1, 1050 VK_STENCIL_OP_REPLACE = 2, 1051 VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3, 1052 VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4, 1053 VK_STENCIL_OP_INVERT = 5, 1054 VK_STENCIL_OP_INCREMENT_AND_WRAP = 6, 1055 VK_STENCIL_OP_DECREMENT_AND_WRAP = 7, 1056 VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF 1057 } VkStencilOp; 1058 1059 typedef enum VkLogicOp { 1060 VK_LOGIC_OP_CLEAR = 0, 1061 VK_LOGIC_OP_AND = 1, 1062 VK_LOGIC_OP_AND_REVERSE = 2, 1063 VK_LOGIC_OP_COPY = 3, 1064 VK_LOGIC_OP_AND_INVERTED = 4, 1065 VK_LOGIC_OP_NO_OP = 5, 1066 VK_LOGIC_OP_XOR = 6, 1067 VK_LOGIC_OP_OR = 7, 1068 VK_LOGIC_OP_NOR = 8, 1069 VK_LOGIC_OP_EQUIVALENT = 9, 1070 VK_LOGIC_OP_INVERT = 10, 1071 VK_LOGIC_OP_OR_REVERSE = 11, 1072 VK_LOGIC_OP_COPY_INVERTED = 12, 1073 VK_LOGIC_OP_OR_INVERTED = 13, 1074 VK_LOGIC_OP_NAND = 14, 1075 VK_LOGIC_OP_SET = 15, 1076 VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF 1077 } VkLogicOp; 1078 1079 typedef enum VkBorderColor { 1080 VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0, 1081 VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1, 1082 VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2, 1083 VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3, 1084 VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4, 1085 VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5, 1086 VK_BORDER_COLOR_FLOAT_CUSTOM_EXT = 1000287003, 1087 VK_BORDER_COLOR_INT_CUSTOM_EXT = 1000287004, 1088 VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF 1089 } VkBorderColor; 1090 1091 typedef enum VkFilter { 1092 VK_FILTER_NEAREST = 0, 1093 VK_FILTER_LINEAR = 1, 1094 VK_FILTER_CUBIC_IMG = 1000015000, 1095 VK_FILTER_CUBIC_EXT = VK_FILTER_CUBIC_IMG, 1096 VK_FILTER_MAX_ENUM = 0x7FFFFFFF 1097 } VkFilter; 1098 1099 typedef enum VkSamplerAddressMode { 1100 VK_SAMPLER_ADDRESS_MODE_REPEAT = 0, 1101 VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1, 1102 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2, 1103 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3, 1104 VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4, 1105 VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF 1106 } VkSamplerAddressMode; 1107 1108 typedef enum VkSamplerMipmapMode { 1109 VK_SAMPLER_MIPMAP_MODE_NEAREST = 0, 1110 VK_SAMPLER_MIPMAP_MODE_LINEAR = 1, 1111 VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF 1112 } VkSamplerMipmapMode; 1113 1114 typedef enum VkDescriptorType { 1115 VK_DESCRIPTOR_TYPE_SAMPLER = 0, 1116 VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1, 1117 VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2, 1118 VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3, 1119 VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4, 1120 VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5, 1121 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6, 1122 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7, 1123 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8, 1124 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9, 1125 VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10, 1126 VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF 1127 } VkDescriptorType; 1128 1129 typedef enum VkAttachmentLoadOp { 1130 VK_ATTACHMENT_LOAD_OP_LOAD = 0, 1131 VK_ATTACHMENT_LOAD_OP_CLEAR = 1, 1132 VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2, 1133 VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF 1134 } VkAttachmentLoadOp; 1135 1136 typedef enum VkAttachmentStoreOp { 1137 VK_ATTACHMENT_STORE_OP_STORE = 0, 1138 VK_ATTACHMENT_STORE_OP_DONT_CARE = 1, 1139 VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF 1140 } VkAttachmentStoreOp; 1141 1142 typedef enum VkPipelineBindPoint { 1143 VK_PIPELINE_BIND_POINT_GRAPHICS = 0, 1144 VK_PIPELINE_BIND_POINT_COMPUTE = 1, 1145 VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF 1146 } VkPipelineBindPoint; 1147 1148 typedef enum VkCommandBufferLevel { 1149 VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0, 1150 VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1, 1151 VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF 1152 } VkCommandBufferLevel; 1153 1154 typedef enum VkIndexType { 1155 VK_INDEX_TYPE_UINT16 = 0, 1156 VK_INDEX_TYPE_UINT32 = 1, 1157 VK_INDEX_TYPE_UINT8_EXT = 1000265000, 1158 VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF 1159 } VkIndexType; 1160 1161 typedef enum VkSubpassContents { 1162 VK_SUBPASS_CONTENTS_INLINE = 0, 1163 VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1, 1164 VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF 1165 } VkSubpassContents; 1166 1167 typedef enum VkAccessFlagBits { 1168 VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001, 1169 VK_ACCESS_INDEX_READ_BIT = 0x00000002, 1170 VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004, 1171 VK_ACCESS_UNIFORM_READ_BIT = 0x00000008, 1172 VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0x00000010, 1173 VK_ACCESS_SHADER_READ_BIT = 0x00000020, 1174 VK_ACCESS_SHADER_WRITE_BIT = 0x00000040, 1175 VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0x00000080, 1176 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100, 1177 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200, 1178 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400, 1179 VK_ACCESS_TRANSFER_READ_BIT = 0x00000800, 1180 VK_ACCESS_TRANSFER_WRITE_BIT = 0x00001000, 1181 VK_ACCESS_HOST_READ_BIT = 0x00002000, 1182 VK_ACCESS_HOST_WRITE_BIT = 0x00004000, 1183 VK_ACCESS_MEMORY_READ_BIT = 0x00008000, 1184 VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000, 1185 VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000, 1186 VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR = 0x00800000, 1187 VK_ACCESS_NONE_KHR = 0, 1188 VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1189 } VkAccessFlagBits; 1190 typedef VkFlags VkAccessFlags; 1191 1192 typedef enum VkImageAspectFlagBits { 1193 VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001, 1194 VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002, 1195 VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004, 1196 VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008, 1197 VK_IMAGE_ASPECT_PLANE_0_BIT = 0x00000010, 1198 VK_IMAGE_ASPECT_PLANE_1_BIT = 0x00000020, 1199 VK_IMAGE_ASPECT_PLANE_2_BIT = 0x00000040, 1200 VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT = 0x00000080, 1201 VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT = 0x00000100, 1202 VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT = 0x00000200, 1203 VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT = 0x00000400, 1204 VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1205 } VkImageAspectFlagBits; 1206 typedef VkFlags VkImageAspectFlags; 1207 1208 typedef enum VkFormatFeatureFlagBits { 1209 VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001, 1210 VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002, 1211 VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004, 1212 VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008, 1213 VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010, 1214 VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020, 1215 VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040, 1216 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080, 1217 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100, 1218 VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200, 1219 VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400, 1220 VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800, 1221 VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000, 1222 VK_FORMAT_FEATURE_TRANSFER_SRC_BIT = 0x00004000, 1223 VK_FORMAT_FEATURE_TRANSFER_DST_BIT = 0x00008000, 1224 VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT = 0x00020000, 1225 VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT = 0x00040000, 1226 VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT = 0x00080000, 1227 VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT = 0x00100000, 1228 VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT = 0x00200000, 1229 VK_FORMAT_FEATURE_DISJOINT_BIT = 0x00400000, 1230 VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT = 0x00800000, 1231 VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT = 0x00010000, 1232 VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = 0x00002000, 1233 VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x40000000, 1234 VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG, 1235 VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1236 } VkFormatFeatureFlagBits; 1237 typedef VkFlags VkFormatFeatureFlags; 1238 1239 typedef enum VkImageCreateFlagBits { 1240 VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001, 1241 VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, 1242 VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004, 1243 VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008, 1244 VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010, 1245 VK_IMAGE_CREATE_ALIAS_BIT = 0x00000400, 1246 VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT = 0x00000040, 1247 VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT = 0x00000020, 1248 VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT = 0x00000080, 1249 VK_IMAGE_CREATE_EXTENDED_USAGE_BIT = 0x00000100, 1250 VK_IMAGE_CREATE_PROTECTED_BIT = 0x00000800, 1251 VK_IMAGE_CREATE_DISJOINT_BIT = 0x00000200, 1252 VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = 0x00001000, 1253 VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1254 } VkImageCreateFlagBits; 1255 typedef VkFlags VkImageCreateFlags; 1256 1257 typedef enum VkSampleCountFlagBits { 1258 VK_SAMPLE_COUNT_1_BIT = 0x00000001, 1259 VK_SAMPLE_COUNT_2_BIT = 0x00000002, 1260 VK_SAMPLE_COUNT_4_BIT = 0x00000004, 1261 VK_SAMPLE_COUNT_8_BIT = 0x00000008, 1262 VK_SAMPLE_COUNT_16_BIT = 0x00000010, 1263 VK_SAMPLE_COUNT_32_BIT = 0x00000020, 1264 VK_SAMPLE_COUNT_64_BIT = 0x00000040, 1265 VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1266 } VkSampleCountFlagBits; 1267 typedef VkFlags VkSampleCountFlags; 1268 1269 typedef enum VkImageUsageFlagBits { 1270 VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001, 1271 VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002, 1272 VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004, 1273 VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008, 1274 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010, 1275 VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020, 1276 VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040, 1277 VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080, 1278 VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00000100, 1279 VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1280 } VkImageUsageFlagBits; 1281 typedef VkFlags VkImageUsageFlags; 1282 typedef VkFlags VkInstanceCreateFlags; 1283 1284 typedef enum VkMemoryHeapFlagBits { 1285 VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001, 1286 VK_MEMORY_HEAP_MULTI_INSTANCE_BIT = 0x00000002, 1287 VK_MEMORY_HEAP_SEU_SAFE_BIT = 0x00000004, 1288 VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1289 } VkMemoryHeapFlagBits; 1290 typedef VkFlags VkMemoryHeapFlags; 1291 1292 typedef enum VkMemoryPropertyFlagBits { 1293 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001, 1294 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002, 1295 VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004, 1296 VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008, 1297 VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010, 1298 VK_MEMORY_PROPERTY_PROTECTED_BIT = 0x00000020, 1299 VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1300 } VkMemoryPropertyFlagBits; 1301 typedef VkFlags VkMemoryPropertyFlags; 1302 1303 typedef enum VkQueueFlagBits { 1304 VK_QUEUE_GRAPHICS_BIT = 0x00000001, 1305 VK_QUEUE_COMPUTE_BIT = 0x00000002, 1306 VK_QUEUE_TRANSFER_BIT = 0x00000004, 1307 VK_QUEUE_PROTECTED_BIT = 0x00000010, 1308 VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1309 } VkQueueFlagBits; 1310 typedef VkFlags VkQueueFlags; 1311 typedef VkFlags VkDeviceCreateFlags; 1312 1313 typedef enum VkDeviceQueueCreateFlagBits { 1314 VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT = 0x00000001, 1315 VK_DEVICE_QUEUE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1316 } VkDeviceQueueCreateFlagBits; 1317 typedef VkFlags VkDeviceQueueCreateFlags; 1318 1319 typedef enum VkPipelineStageFlagBits { 1320 VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001, 1321 VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002, 1322 VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004, 1323 VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008, 1324 VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010, 1325 VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020, 1326 VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040, 1327 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080, 1328 VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100, 1329 VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200, 1330 VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400, 1331 VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800, 1332 VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000, 1333 VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000, 1334 VK_PIPELINE_STAGE_HOST_BIT = 0x00004000, 1335 VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000, 1336 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000, 1337 VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00400000, 1338 VK_PIPELINE_STAGE_NONE_KHR = 0, 1339 VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1340 } VkPipelineStageFlagBits; 1341 typedef VkFlags VkPipelineStageFlags; 1342 typedef VkFlags VkMemoryMapFlags; 1343 1344 typedef enum VkFenceCreateFlagBits { 1345 VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001, 1346 VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1347 } VkFenceCreateFlagBits; 1348 typedef VkFlags VkFenceCreateFlags; 1349 typedef VkFlags VkSemaphoreCreateFlags; 1350 1351 typedef enum VkEventCreateFlagBits { 1352 VK_EVENT_CREATE_DEVICE_ONLY_BIT_KHR = 0x00000001, 1353 VK_EVENT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1354 } VkEventCreateFlagBits; 1355 typedef VkFlags VkEventCreateFlags; 1356 1357 typedef enum VkQueryPipelineStatisticFlagBits { 1358 VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001, 1359 VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002, 1360 VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004, 1361 VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008, 1362 VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0x00000010, 1363 VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0x00000020, 1364 VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0x00000040, 1365 VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0x00000080, 1366 VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x00000100, 1367 VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0x00000200, 1368 VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400, 1369 VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1370 } VkQueryPipelineStatisticFlagBits; 1371 typedef VkFlags VkQueryPipelineStatisticFlags; 1372 typedef VkFlags VkQueryPoolCreateFlags; 1373 1374 typedef enum VkQueryResultFlagBits { 1375 VK_QUERY_RESULT_64_BIT = 0x00000001, 1376 VK_QUERY_RESULT_WAIT_BIT = 0x00000002, 1377 VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004, 1378 VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008, 1379 VK_QUERY_RESULT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1380 } VkQueryResultFlagBits; 1381 typedef VkFlags VkQueryResultFlags; 1382 1383 typedef enum VkBufferCreateFlagBits { 1384 VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001, 1385 VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, 1386 VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004, 1387 VK_BUFFER_CREATE_PROTECTED_BIT = 0x00000008, 1388 VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 0x00000010, 1389 VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1390 } VkBufferCreateFlagBits; 1391 typedef VkFlags VkBufferCreateFlags; 1392 1393 typedef enum VkBufferUsageFlagBits { 1394 VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001, 1395 VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002, 1396 VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004, 1397 VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008, 1398 VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010, 1399 VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020, 1400 VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040, 1401 VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080, 1402 VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100, 1403 VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT = 0x00020000, 1404 VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1405 } VkBufferUsageFlagBits; 1406 typedef VkFlags VkBufferUsageFlags; 1407 typedef VkFlags VkBufferViewCreateFlags; 1408 1409 typedef enum VkImageViewCreateFlagBits { 1410 VK_IMAGE_VIEW_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1411 } VkImageViewCreateFlagBits; 1412 typedef VkFlags VkImageViewCreateFlags; 1413 1414 typedef enum VkPipelineCacheCreateFlagBits { 1415 VK_PIPELINE_CACHE_CREATE_USE_APPLICATION_STORAGE_BIT = 0x00000004, 1416 VK_PIPELINE_CACHE_CREATE_RESERVED_1_BIT_EXT = 0x00000002, 1417 VK_PIPELINE_CACHE_CREATE_READ_ONLY_BIT = VK_PIPELINE_CACHE_CREATE_RESERVED_1_BIT_EXT, 1418 VK_PIPELINE_CACHE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1419 } VkPipelineCacheCreateFlagBits; 1420 typedef VkFlags VkPipelineCacheCreateFlags; 1421 1422 typedef enum VkColorComponentFlagBits { 1423 VK_COLOR_COMPONENT_R_BIT = 0x00000001, 1424 VK_COLOR_COMPONENT_G_BIT = 0x00000002, 1425 VK_COLOR_COMPONENT_B_BIT = 0x00000004, 1426 VK_COLOR_COMPONENT_A_BIT = 0x00000008, 1427 VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1428 } VkColorComponentFlagBits; 1429 typedef VkFlags VkColorComponentFlags; 1430 1431 typedef enum VkPipelineCreateFlagBits { 1432 VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001, 1433 VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0x00000008, 1434 VK_PIPELINE_CREATE_DISPATCH_BASE_BIT = 0x00000010, 1435 VK_PIPELINE_CREATE_DISPATCH_BASE = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT, 1436 VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1437 } VkPipelineCreateFlagBits; 1438 typedef VkFlags VkPipelineCreateFlags; 1439 1440 typedef enum VkPipelineShaderStageCreateFlagBits { 1441 VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT = 0x00000001, 1442 VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT = 0x00000002, 1443 VK_PIPELINE_SHADER_STAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1444 } VkPipelineShaderStageCreateFlagBits; 1445 typedef VkFlags VkPipelineShaderStageCreateFlags; 1446 1447 typedef enum VkShaderStageFlagBits { 1448 VK_SHADER_STAGE_VERTEX_BIT = 0x00000001, 1449 VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002, 1450 VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004, 1451 VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008, 1452 VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010, 1453 VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020, 1454 VK_SHADER_STAGE_ALL_GRAPHICS = 0x0000001F, 1455 VK_SHADER_STAGE_ALL = 0x7FFFFFFF, 1456 VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1457 } VkShaderStageFlagBits; 1458 1459 typedef enum VkCullModeFlagBits { 1460 VK_CULL_MODE_NONE = 0, 1461 VK_CULL_MODE_FRONT_BIT = 0x00000001, 1462 VK_CULL_MODE_BACK_BIT = 0x00000002, 1463 VK_CULL_MODE_FRONT_AND_BACK = 0x00000003, 1464 VK_CULL_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1465 } VkCullModeFlagBits; 1466 typedef VkFlags VkCullModeFlags; 1467 typedef VkFlags VkPipelineVertexInputStateCreateFlags; 1468 typedef VkFlags VkPipelineInputAssemblyStateCreateFlags; 1469 typedef VkFlags VkPipelineTessellationStateCreateFlags; 1470 typedef VkFlags VkPipelineViewportStateCreateFlags; 1471 typedef VkFlags VkPipelineRasterizationStateCreateFlags; 1472 typedef VkFlags VkPipelineMultisampleStateCreateFlags; 1473 typedef VkFlags VkPipelineDepthStencilStateCreateFlags; 1474 typedef VkFlags VkPipelineColorBlendStateCreateFlags; 1475 typedef VkFlags VkPipelineDynamicStateCreateFlags; 1476 typedef VkFlags VkPipelineLayoutCreateFlags; 1477 typedef VkFlags VkShaderStageFlags; 1478 1479 typedef enum VkSamplerCreateFlagBits { 1480 VK_SAMPLER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1481 } VkSamplerCreateFlagBits; 1482 typedef VkFlags VkSamplerCreateFlags; 1483 1484 typedef enum VkDescriptorPoolCreateFlagBits { 1485 VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001, 1486 VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT = 0x00000002, 1487 VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1488 } VkDescriptorPoolCreateFlagBits; 1489 typedef VkFlags VkDescriptorPoolCreateFlags; 1490 typedef VkFlags VkDescriptorPoolResetFlags; 1491 1492 typedef enum VkDescriptorSetLayoutCreateFlagBits { 1493 VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT = 0x00000002, 1494 VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1495 } VkDescriptorSetLayoutCreateFlagBits; 1496 typedef VkFlags VkDescriptorSetLayoutCreateFlags; 1497 1498 typedef enum VkAttachmentDescriptionFlagBits { 1499 VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001, 1500 VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1501 } VkAttachmentDescriptionFlagBits; 1502 typedef VkFlags VkAttachmentDescriptionFlags; 1503 1504 typedef enum VkDependencyFlagBits { 1505 VK_DEPENDENCY_BY_REGION_BIT = 0x00000001, 1506 VK_DEPENDENCY_DEVICE_GROUP_BIT = 0x00000004, 1507 VK_DEPENDENCY_VIEW_LOCAL_BIT = 0x00000002, 1508 VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1509 } VkDependencyFlagBits; 1510 typedef VkFlags VkDependencyFlags; 1511 1512 typedef enum VkFramebufferCreateFlagBits { 1513 VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT = 0x00000001, 1514 VK_FRAMEBUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1515 } VkFramebufferCreateFlagBits; 1516 typedef VkFlags VkFramebufferCreateFlags; 1517 1518 typedef enum VkRenderPassCreateFlagBits { 1519 VK_RENDER_PASS_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1520 } VkRenderPassCreateFlagBits; 1521 typedef VkFlags VkRenderPassCreateFlags; 1522 1523 typedef enum VkSubpassDescriptionFlagBits { 1524 VK_SUBPASS_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1525 } VkSubpassDescriptionFlagBits; 1526 typedef VkFlags VkSubpassDescriptionFlags; 1527 1528 typedef enum VkCommandPoolCreateFlagBits { 1529 VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001, 1530 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002, 1531 VK_COMMAND_POOL_CREATE_PROTECTED_BIT = 0x00000004, 1532 VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1533 } VkCommandPoolCreateFlagBits; 1534 typedef VkFlags VkCommandPoolCreateFlags; 1535 1536 typedef enum VkCommandPoolResetFlagBits { 1537 VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1538 } VkCommandPoolResetFlagBits; 1539 typedef VkFlags VkCommandPoolResetFlags; 1540 1541 typedef enum VkCommandBufferUsageFlagBits { 1542 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001, 1543 VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002, 1544 VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004, 1545 VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1546 } VkCommandBufferUsageFlagBits; 1547 typedef VkFlags VkCommandBufferUsageFlags; 1548 1549 typedef enum VkQueryControlFlagBits { 1550 VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001, 1551 VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1552 } VkQueryControlFlagBits; 1553 typedef VkFlags VkQueryControlFlags; 1554 1555 typedef enum VkCommandBufferResetFlagBits { 1556 VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001, 1557 VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1558 } VkCommandBufferResetFlagBits; 1559 typedef VkFlags VkCommandBufferResetFlags; 1560 1561 typedef enum VkStencilFaceFlagBits { 1562 VK_STENCIL_FACE_FRONT_BIT = 0x00000001, 1563 VK_STENCIL_FACE_BACK_BIT = 0x00000002, 1564 VK_STENCIL_FACE_FRONT_AND_BACK = 0x00000003, 1565 VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1566 } VkStencilFaceFlagBits; 1567 typedef VkFlags VkStencilFaceFlags; 1568 typedef struct VkExtent2D { 1569 uint32_t width; 1570 uint32_t height; 1571 } VkExtent2D; 1572 1573 typedef struct VkExtent3D { 1574 uint32_t width; 1575 uint32_t height; 1576 uint32_t depth; 1577 } VkExtent3D; 1578 1579 typedef struct VkOffset2D { 1580 int32_t x; 1581 int32_t y; 1582 } VkOffset2D; 1583 1584 typedef struct VkOffset3D { 1585 int32_t x; 1586 int32_t y; 1587 int32_t z; 1588 } VkOffset3D; 1589 1590 typedef struct VkRect2D { 1591 VkOffset2D offset; 1592 VkExtent2D extent; 1593 } VkRect2D; 1594 1595 typedef struct VkBaseInStructure { 1596 VkStructureType sType; 1597 const struct VkBaseInStructure* pNext; 1598 } VkBaseInStructure; 1599 1600 typedef struct VkBaseOutStructure { 1601 VkStructureType sType; 1602 struct VkBaseOutStructure* pNext; 1603 } VkBaseOutStructure; 1604 1605 typedef struct VkBufferMemoryBarrier { 1606 VkStructureType sType; 1607 const void* pNext; 1608 VkAccessFlags srcAccessMask; 1609 VkAccessFlags dstAccessMask; 1610 uint32_t srcQueueFamilyIndex; 1611 uint32_t dstQueueFamilyIndex; 1612 VkBuffer buffer; 1613 VkDeviceSize offset; 1614 VkDeviceSize size; 1615 } VkBufferMemoryBarrier; 1616 1617 typedef struct VkDispatchIndirectCommand { 1618 uint32_t x; 1619 uint32_t y; 1620 uint32_t z; 1621 } VkDispatchIndirectCommand; 1622 1623 typedef struct VkDrawIndexedIndirectCommand { 1624 uint32_t indexCount; 1625 uint32_t instanceCount; 1626 uint32_t firstIndex; 1627 int32_t vertexOffset; 1628 uint32_t firstInstance; 1629 } VkDrawIndexedIndirectCommand; 1630 1631 typedef struct VkDrawIndirectCommand { 1632 uint32_t vertexCount; 1633 uint32_t instanceCount; 1634 uint32_t firstVertex; 1635 uint32_t firstInstance; 1636 } VkDrawIndirectCommand; 1637 1638 typedef struct VkImageSubresourceRange { 1639 VkImageAspectFlags aspectMask; 1640 uint32_t baseMipLevel; 1641 uint32_t levelCount; 1642 uint32_t baseArrayLayer; 1643 uint32_t layerCount; 1644 } VkImageSubresourceRange; 1645 1646 typedef struct VkImageMemoryBarrier { 1647 VkStructureType sType; 1648 const void* pNext; 1649 VkAccessFlags srcAccessMask; 1650 VkAccessFlags dstAccessMask; 1651 VkImageLayout oldLayout; 1652 VkImageLayout newLayout; 1653 uint32_t srcQueueFamilyIndex; 1654 uint32_t dstQueueFamilyIndex; 1655 VkImage image; 1656 VkImageSubresourceRange subresourceRange; 1657 } VkImageMemoryBarrier; 1658 1659 typedef struct VkMemoryBarrier { 1660 VkStructureType sType; 1661 const void* pNext; 1662 VkAccessFlags srcAccessMask; 1663 VkAccessFlags dstAccessMask; 1664 } VkMemoryBarrier; 1665 1666 typedef struct VkPipelineCacheHeaderVersionOne { 1667 uint32_t headerSize; 1668 VkPipelineCacheHeaderVersion headerVersion; 1669 uint32_t vendorID; 1670 uint32_t deviceID; 1671 uint8_t pipelineCacheUUID[VK_UUID_SIZE]; 1672 } VkPipelineCacheHeaderVersionOne; 1673 1674 typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)( 1675 void* pUserData, 1676 size_t size, 1677 size_t alignment, 1678 VkSystemAllocationScope allocationScope); 1679 1680 typedef void (VKAPI_PTR *PFN_vkFreeFunction)( 1681 void* pUserData, 1682 void* pMemory); 1683 1684 typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)( 1685 void* pUserData, 1686 size_t size, 1687 VkInternalAllocationType allocationType, 1688 VkSystemAllocationScope allocationScope); 1689 1690 typedef void (VKAPI_PTR *PFN_vkInternalFreeNotification)( 1691 void* pUserData, 1692 size_t size, 1693 VkInternalAllocationType allocationType, 1694 VkSystemAllocationScope allocationScope); 1695 1696 typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)( 1697 void* pUserData, 1698 void* pOriginal, 1699 size_t size, 1700 size_t alignment, 1701 VkSystemAllocationScope allocationScope); 1702 1703 typedef void (VKAPI_PTR *PFN_vkVoidFunction)(void); 1704 typedef struct VkAllocationCallbacks { 1705 void* pUserData; 1706 PFN_vkAllocationFunction pfnAllocation; 1707 PFN_vkReallocationFunction pfnReallocation; 1708 PFN_vkFreeFunction pfnFree; 1709 PFN_vkInternalAllocationNotification pfnInternalAllocation; 1710 PFN_vkInternalFreeNotification pfnInternalFree; 1711 } VkAllocationCallbacks; 1712 1713 typedef struct VkApplicationInfo { 1714 VkStructureType sType; 1715 const void* pNext; 1716 const char* pApplicationName; 1717 uint32_t applicationVersion; 1718 const char* pEngineName; 1719 uint32_t engineVersion; 1720 uint32_t apiVersion; 1721 } VkApplicationInfo; 1722 1723 typedef struct VkFormatProperties { 1724 VkFormatFeatureFlags linearTilingFeatures; 1725 VkFormatFeatureFlags optimalTilingFeatures; 1726 VkFormatFeatureFlags bufferFeatures; 1727 } VkFormatProperties; 1728 1729 typedef struct VkImageFormatProperties { 1730 VkExtent3D maxExtent; 1731 uint32_t maxMipLevels; 1732 uint32_t maxArrayLayers; 1733 VkSampleCountFlags sampleCounts; 1734 VkDeviceSize maxResourceSize; 1735 } VkImageFormatProperties; 1736 1737 typedef struct VkInstanceCreateInfo { 1738 VkStructureType sType; 1739 const void* pNext; 1740 VkInstanceCreateFlags flags; 1741 const VkApplicationInfo* pApplicationInfo; 1742 uint32_t enabledLayerCount; 1743 const char* const* ppEnabledLayerNames; 1744 uint32_t enabledExtensionCount; 1745 const char* const* ppEnabledExtensionNames; 1746 } VkInstanceCreateInfo; 1747 1748 typedef struct VkMemoryHeap { 1749 VkDeviceSize size; 1750 VkMemoryHeapFlags flags; 1751 } VkMemoryHeap; 1752 1753 typedef struct VkMemoryType { 1754 VkMemoryPropertyFlags propertyFlags; 1755 uint32_t heapIndex; 1756 } VkMemoryType; 1757 1758 typedef struct VkPhysicalDeviceFeatures { 1759 VkBool32 robustBufferAccess; 1760 VkBool32 fullDrawIndexUint32; 1761 VkBool32 imageCubeArray; 1762 VkBool32 independentBlend; 1763 VkBool32 geometryShader; 1764 VkBool32 tessellationShader; 1765 VkBool32 sampleRateShading; 1766 VkBool32 dualSrcBlend; 1767 VkBool32 logicOp; 1768 VkBool32 multiDrawIndirect; 1769 VkBool32 drawIndirectFirstInstance; 1770 VkBool32 depthClamp; 1771 VkBool32 depthBiasClamp; 1772 VkBool32 fillModeNonSolid; 1773 VkBool32 depthBounds; 1774 VkBool32 wideLines; 1775 VkBool32 largePoints; 1776 VkBool32 alphaToOne; 1777 VkBool32 multiViewport; 1778 VkBool32 samplerAnisotropy; 1779 VkBool32 textureCompressionETC2; 1780 VkBool32 textureCompressionASTC_LDR; 1781 VkBool32 textureCompressionBC; 1782 VkBool32 occlusionQueryPrecise; 1783 VkBool32 pipelineStatisticsQuery; 1784 VkBool32 vertexPipelineStoresAndAtomics; 1785 VkBool32 fragmentStoresAndAtomics; 1786 VkBool32 shaderTessellationAndGeometryPointSize; 1787 VkBool32 shaderImageGatherExtended; 1788 VkBool32 shaderStorageImageExtendedFormats; 1789 VkBool32 shaderStorageImageMultisample; 1790 VkBool32 shaderStorageImageReadWithoutFormat; 1791 VkBool32 shaderStorageImageWriteWithoutFormat; 1792 VkBool32 shaderUniformBufferArrayDynamicIndexing; 1793 VkBool32 shaderSampledImageArrayDynamicIndexing; 1794 VkBool32 shaderStorageBufferArrayDynamicIndexing; 1795 VkBool32 shaderStorageImageArrayDynamicIndexing; 1796 VkBool32 shaderClipDistance; 1797 VkBool32 shaderCullDistance; 1798 VkBool32 shaderFloat64; 1799 VkBool32 shaderInt64; 1800 VkBool32 shaderInt16; 1801 VkBool32 shaderResourceResidency; 1802 VkBool32 shaderResourceMinLod; 1803 VkBool32 sparseBinding; 1804 VkBool32 sparseResidencyBuffer; 1805 VkBool32 sparseResidencyImage2D; 1806 VkBool32 sparseResidencyImage3D; 1807 VkBool32 sparseResidency2Samples; 1808 VkBool32 sparseResidency4Samples; 1809 VkBool32 sparseResidency8Samples; 1810 VkBool32 sparseResidency16Samples; 1811 VkBool32 sparseResidencyAliased; 1812 VkBool32 variableMultisampleRate; 1813 VkBool32 inheritedQueries; 1814 } VkPhysicalDeviceFeatures; 1815 1816 typedef struct VkPhysicalDeviceLimits { 1817 uint32_t maxImageDimension1D; 1818 uint32_t maxImageDimension2D; 1819 uint32_t maxImageDimension3D; 1820 uint32_t maxImageDimensionCube; 1821 uint32_t maxImageArrayLayers; 1822 uint32_t maxTexelBufferElements; 1823 uint32_t maxUniformBufferRange; 1824 uint32_t maxStorageBufferRange; 1825 uint32_t maxPushConstantsSize; 1826 uint32_t maxMemoryAllocationCount; 1827 uint32_t maxSamplerAllocationCount; 1828 VkDeviceSize bufferImageGranularity; 1829 VkDeviceSize sparseAddressSpaceSize; 1830 uint32_t maxBoundDescriptorSets; 1831 uint32_t maxPerStageDescriptorSamplers; 1832 uint32_t maxPerStageDescriptorUniformBuffers; 1833 uint32_t maxPerStageDescriptorStorageBuffers; 1834 uint32_t maxPerStageDescriptorSampledImages; 1835 uint32_t maxPerStageDescriptorStorageImages; 1836 uint32_t maxPerStageDescriptorInputAttachments; 1837 uint32_t maxPerStageResources; 1838 uint32_t maxDescriptorSetSamplers; 1839 uint32_t maxDescriptorSetUniformBuffers; 1840 uint32_t maxDescriptorSetUniformBuffersDynamic; 1841 uint32_t maxDescriptorSetStorageBuffers; 1842 uint32_t maxDescriptorSetStorageBuffersDynamic; 1843 uint32_t maxDescriptorSetSampledImages; 1844 uint32_t maxDescriptorSetStorageImages; 1845 uint32_t maxDescriptorSetInputAttachments; 1846 uint32_t maxVertexInputAttributes; 1847 uint32_t maxVertexInputBindings; 1848 uint32_t maxVertexInputAttributeOffset; 1849 uint32_t maxVertexInputBindingStride; 1850 uint32_t maxVertexOutputComponents; 1851 uint32_t maxTessellationGenerationLevel; 1852 uint32_t maxTessellationPatchSize; 1853 uint32_t maxTessellationControlPerVertexInputComponents; 1854 uint32_t maxTessellationControlPerVertexOutputComponents; 1855 uint32_t maxTessellationControlPerPatchOutputComponents; 1856 uint32_t maxTessellationControlTotalOutputComponents; 1857 uint32_t maxTessellationEvaluationInputComponents; 1858 uint32_t maxTessellationEvaluationOutputComponents; 1859 uint32_t maxGeometryShaderInvocations; 1860 uint32_t maxGeometryInputComponents; 1861 uint32_t maxGeometryOutputComponents; 1862 uint32_t maxGeometryOutputVertices; 1863 uint32_t maxGeometryTotalOutputComponents; 1864 uint32_t maxFragmentInputComponents; 1865 uint32_t maxFragmentOutputAttachments; 1866 uint32_t maxFragmentDualSrcAttachments; 1867 uint32_t maxFragmentCombinedOutputResources; 1868 uint32_t maxComputeSharedMemorySize; 1869 uint32_t maxComputeWorkGroupCount[3]; 1870 uint32_t maxComputeWorkGroupInvocations; 1871 uint32_t maxComputeWorkGroupSize[3]; 1872 uint32_t subPixelPrecisionBits; 1873 uint32_t subTexelPrecisionBits; 1874 uint32_t mipmapPrecisionBits; 1875 uint32_t maxDrawIndexedIndexValue; 1876 uint32_t maxDrawIndirectCount; 1877 float maxSamplerLodBias; 1878 float maxSamplerAnisotropy; 1879 uint32_t maxViewports; 1880 uint32_t maxViewportDimensions[2]; 1881 float viewportBoundsRange[2]; 1882 uint32_t viewportSubPixelBits; 1883 size_t minMemoryMapAlignment; 1884 VkDeviceSize minTexelBufferOffsetAlignment; 1885 VkDeviceSize minUniformBufferOffsetAlignment; 1886 VkDeviceSize minStorageBufferOffsetAlignment; 1887 int32_t minTexelOffset; 1888 uint32_t maxTexelOffset; 1889 int32_t minTexelGatherOffset; 1890 uint32_t maxTexelGatherOffset; 1891 float minInterpolationOffset; 1892 float maxInterpolationOffset; 1893 uint32_t subPixelInterpolationOffsetBits; 1894 uint32_t maxFramebufferWidth; 1895 uint32_t maxFramebufferHeight; 1896 uint32_t maxFramebufferLayers; 1897 VkSampleCountFlags framebufferColorSampleCounts; 1898 VkSampleCountFlags framebufferDepthSampleCounts; 1899 VkSampleCountFlags framebufferStencilSampleCounts; 1900 VkSampleCountFlags framebufferNoAttachmentsSampleCounts; 1901 uint32_t maxColorAttachments; 1902 VkSampleCountFlags sampledImageColorSampleCounts; 1903 VkSampleCountFlags sampledImageIntegerSampleCounts; 1904 VkSampleCountFlags sampledImageDepthSampleCounts; 1905 VkSampleCountFlags sampledImageStencilSampleCounts; 1906 VkSampleCountFlags storageImageSampleCounts; 1907 uint32_t maxSampleMaskWords; 1908 VkBool32 timestampComputeAndGraphics; 1909 float timestampPeriod; 1910 uint32_t maxClipDistances; 1911 uint32_t maxCullDistances; 1912 uint32_t maxCombinedClipAndCullDistances; 1913 uint32_t discreteQueuePriorities; 1914 float pointSizeRange[2]; 1915 float lineWidthRange[2]; 1916 float pointSizeGranularity; 1917 float lineWidthGranularity; 1918 VkBool32 strictLines; 1919 VkBool32 standardSampleLocations; 1920 VkDeviceSize optimalBufferCopyOffsetAlignment; 1921 VkDeviceSize optimalBufferCopyRowPitchAlignment; 1922 VkDeviceSize nonCoherentAtomSize; 1923 } VkPhysicalDeviceLimits; 1924 1925 typedef struct VkPhysicalDeviceMemoryProperties { 1926 uint32_t memoryTypeCount; 1927 VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES]; 1928 uint32_t memoryHeapCount; 1929 VkMemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS]; 1930 } VkPhysicalDeviceMemoryProperties; 1931 1932 typedef struct VkPhysicalDeviceSparseProperties { 1933 VkBool32 residencyStandard2DBlockShape; 1934 VkBool32 residencyStandard2DMultisampleBlockShape; 1935 VkBool32 residencyStandard3DBlockShape; 1936 VkBool32 residencyAlignedMipSize; 1937 VkBool32 residencyNonResidentStrict; 1938 } VkPhysicalDeviceSparseProperties; 1939 1940 typedef struct VkPhysicalDeviceProperties { 1941 uint32_t apiVersion; 1942 uint32_t driverVersion; 1943 uint32_t vendorID; 1944 uint32_t deviceID; 1945 VkPhysicalDeviceType deviceType; 1946 char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]; 1947 uint8_t pipelineCacheUUID[VK_UUID_SIZE]; 1948 VkPhysicalDeviceLimits limits; 1949 VkPhysicalDeviceSparseProperties sparseProperties; 1950 } VkPhysicalDeviceProperties; 1951 1952 typedef struct VkQueueFamilyProperties { 1953 VkQueueFlags queueFlags; 1954 uint32_t queueCount; 1955 uint32_t timestampValidBits; 1956 VkExtent3D minImageTransferGranularity; 1957 } VkQueueFamilyProperties; 1958 1959 typedef struct VkDeviceQueueCreateInfo { 1960 VkStructureType sType; 1961 const void* pNext; 1962 VkDeviceQueueCreateFlags flags; 1963 uint32_t queueFamilyIndex; 1964 uint32_t queueCount; 1965 const float* pQueuePriorities; 1966 } VkDeviceQueueCreateInfo; 1967 1968 typedef struct VkDeviceCreateInfo { 1969 VkStructureType sType; 1970 const void* pNext; 1971 VkDeviceCreateFlags flags; 1972 uint32_t queueCreateInfoCount; 1973 const VkDeviceQueueCreateInfo* pQueueCreateInfos; 1974 uint32_t enabledLayerCount; 1975 const char* const* ppEnabledLayerNames; 1976 uint32_t enabledExtensionCount; 1977 const char* const* ppEnabledExtensionNames; 1978 const VkPhysicalDeviceFeatures* pEnabledFeatures; 1979 } VkDeviceCreateInfo; 1980 1981 typedef struct VkExtensionProperties { 1982 char extensionName[VK_MAX_EXTENSION_NAME_SIZE]; 1983 uint32_t specVersion; 1984 } VkExtensionProperties; 1985 1986 typedef struct VkLayerProperties { 1987 char layerName[VK_MAX_EXTENSION_NAME_SIZE]; 1988 uint32_t specVersion; 1989 uint32_t implementationVersion; 1990 char description[VK_MAX_DESCRIPTION_SIZE]; 1991 } VkLayerProperties; 1992 1993 typedef struct VkSubmitInfo { 1994 VkStructureType sType; 1995 const void* pNext; 1996 uint32_t waitSemaphoreCount; 1997 const VkSemaphore* pWaitSemaphores; 1998 const VkPipelineStageFlags* pWaitDstStageMask; 1999 uint32_t commandBufferCount; 2000 const VkCommandBuffer* pCommandBuffers; 2001 uint32_t signalSemaphoreCount; 2002 const VkSemaphore* pSignalSemaphores; 2003 } VkSubmitInfo; 2004 2005 typedef struct VkMappedMemoryRange { 2006 VkStructureType sType; 2007 const void* pNext; 2008 VkDeviceMemory memory; 2009 VkDeviceSize offset; 2010 VkDeviceSize size; 2011 } VkMappedMemoryRange; 2012 2013 typedef struct VkMemoryAllocateInfo { 2014 VkStructureType sType; 2015 const void* pNext; 2016 VkDeviceSize allocationSize; 2017 uint32_t memoryTypeIndex; 2018 } VkMemoryAllocateInfo; 2019 2020 typedef struct VkMemoryRequirements { 2021 VkDeviceSize size; 2022 VkDeviceSize alignment; 2023 uint32_t memoryTypeBits; 2024 } VkMemoryRequirements; 2025 2026 typedef struct VkImageSubresource { 2027 VkImageAspectFlags aspectMask; 2028 uint32_t mipLevel; 2029 uint32_t arrayLayer; 2030 } VkImageSubresource; 2031 2032 typedef struct VkFenceCreateInfo { 2033 VkStructureType sType; 2034 const void* pNext; 2035 VkFenceCreateFlags flags; 2036 } VkFenceCreateInfo; 2037 2038 typedef struct VkSemaphoreCreateInfo { 2039 VkStructureType sType; 2040 const void* pNext; 2041 VkSemaphoreCreateFlags flags; 2042 } VkSemaphoreCreateInfo; 2043 2044 typedef struct VkEventCreateInfo { 2045 VkStructureType sType; 2046 const void* pNext; 2047 VkEventCreateFlags flags; 2048 } VkEventCreateInfo; 2049 2050 typedef struct VkQueryPoolCreateInfo { 2051 VkStructureType sType; 2052 const void* pNext; 2053 VkQueryPoolCreateFlags flags; 2054 VkQueryType queryType; 2055 uint32_t queryCount; 2056 VkQueryPipelineStatisticFlags pipelineStatistics; 2057 } VkQueryPoolCreateInfo; 2058 2059 typedef struct VkBufferCreateInfo { 2060 VkStructureType sType; 2061 const void* pNext; 2062 VkBufferCreateFlags flags; 2063 VkDeviceSize size; 2064 VkBufferUsageFlags usage; 2065 VkSharingMode sharingMode; 2066 uint32_t queueFamilyIndexCount; 2067 const uint32_t* pQueueFamilyIndices; 2068 } VkBufferCreateInfo; 2069 2070 typedef struct VkBufferViewCreateInfo { 2071 VkStructureType sType; 2072 const void* pNext; 2073 VkBufferViewCreateFlags flags; 2074 VkBuffer buffer; 2075 VkFormat format; 2076 VkDeviceSize offset; 2077 VkDeviceSize range; 2078 } VkBufferViewCreateInfo; 2079 2080 typedef struct VkImageCreateInfo { 2081 VkStructureType sType; 2082 const void* pNext; 2083 VkImageCreateFlags flags; 2084 VkImageType imageType; 2085 VkFormat format; 2086 VkExtent3D extent; 2087 uint32_t mipLevels; 2088 uint32_t arrayLayers; 2089 VkSampleCountFlagBits samples; 2090 VkImageTiling tiling; 2091 VkImageUsageFlags usage; 2092 VkSharingMode sharingMode; 2093 uint32_t queueFamilyIndexCount; 2094 const uint32_t* pQueueFamilyIndices; 2095 VkImageLayout initialLayout; 2096 } VkImageCreateInfo; 2097 2098 typedef struct VkSubresourceLayout { 2099 VkDeviceSize offset; 2100 VkDeviceSize size; 2101 VkDeviceSize rowPitch; 2102 VkDeviceSize arrayPitch; 2103 VkDeviceSize depthPitch; 2104 } VkSubresourceLayout; 2105 2106 typedef struct VkComponentMapping { 2107 VkComponentSwizzle r; 2108 VkComponentSwizzle g; 2109 VkComponentSwizzle b; 2110 VkComponentSwizzle a; 2111 } VkComponentMapping; 2112 2113 typedef struct VkImageViewCreateInfo { 2114 VkStructureType sType; 2115 const void* pNext; 2116 VkImageViewCreateFlags flags; 2117 VkImage image; 2118 VkImageViewType viewType; 2119 VkFormat format; 2120 VkComponentMapping components; 2121 VkImageSubresourceRange subresourceRange; 2122 } VkImageViewCreateInfo; 2123 2124 typedef struct VkPipelineCacheCreateInfo { 2125 VkStructureType sType; 2126 const void* pNext; 2127 VkPipelineCacheCreateFlags flags; 2128 size_t initialDataSize; 2129 const void* pInitialData; 2130 } VkPipelineCacheCreateInfo; 2131 2132 typedef struct VkSpecializationMapEntry { 2133 uint32_t constantID; 2134 uint32_t offset; 2135 size_t size; 2136 } VkSpecializationMapEntry; 2137 2138 typedef struct VkSpecializationInfo { 2139 uint32_t mapEntryCount; 2140 const VkSpecializationMapEntry* pMapEntries; 2141 size_t dataSize; 2142 const void* pData; 2143 } VkSpecializationInfo; 2144 2145 typedef struct VkPipelineShaderStageCreateInfo { 2146 VkStructureType sType; 2147 const void* pNext; 2148 VkPipelineShaderStageCreateFlags flags; 2149 VkShaderStageFlagBits stage; 2150 VkShaderModule module; 2151 const char* pName; 2152 const VkSpecializationInfo* pSpecializationInfo; 2153 } VkPipelineShaderStageCreateInfo; 2154 2155 typedef struct VkComputePipelineCreateInfo { 2156 VkStructureType sType; 2157 const void* pNext; 2158 VkPipelineCreateFlags flags; 2159 VkPipelineShaderStageCreateInfo stage; 2160 VkPipelineLayout layout; 2161 VkPipeline basePipelineHandle; 2162 int32_t basePipelineIndex; 2163 } VkComputePipelineCreateInfo; 2164 2165 typedef struct VkVertexInputBindingDescription { 2166 uint32_t binding; 2167 uint32_t stride; 2168 VkVertexInputRate inputRate; 2169 } VkVertexInputBindingDescription; 2170 2171 typedef struct VkVertexInputAttributeDescription { 2172 uint32_t location; 2173 uint32_t binding; 2174 VkFormat format; 2175 uint32_t offset; 2176 } VkVertexInputAttributeDescription; 2177 2178 typedef struct VkPipelineVertexInputStateCreateInfo { 2179 VkStructureType sType; 2180 const void* pNext; 2181 VkPipelineVertexInputStateCreateFlags flags; 2182 uint32_t vertexBindingDescriptionCount; 2183 const VkVertexInputBindingDescription* pVertexBindingDescriptions; 2184 uint32_t vertexAttributeDescriptionCount; 2185 const VkVertexInputAttributeDescription* pVertexAttributeDescriptions; 2186 } VkPipelineVertexInputStateCreateInfo; 2187 2188 typedef struct VkPipelineInputAssemblyStateCreateInfo { 2189 VkStructureType sType; 2190 const void* pNext; 2191 VkPipelineInputAssemblyStateCreateFlags flags; 2192 VkPrimitiveTopology topology; 2193 VkBool32 primitiveRestartEnable; 2194 } VkPipelineInputAssemblyStateCreateInfo; 2195 2196 typedef struct VkPipelineTessellationStateCreateInfo { 2197 VkStructureType sType; 2198 const void* pNext; 2199 VkPipelineTessellationStateCreateFlags flags; 2200 uint32_t patchControlPoints; 2201 } VkPipelineTessellationStateCreateInfo; 2202 2203 typedef struct VkViewport { 2204 float x; 2205 float y; 2206 float width; 2207 float height; 2208 float minDepth; 2209 float maxDepth; 2210 } VkViewport; 2211 2212 typedef struct VkPipelineViewportStateCreateInfo { 2213 VkStructureType sType; 2214 const void* pNext; 2215 VkPipelineViewportStateCreateFlags flags; 2216 uint32_t viewportCount; 2217 const VkViewport* pViewports; 2218 uint32_t scissorCount; 2219 const VkRect2D* pScissors; 2220 } VkPipelineViewportStateCreateInfo; 2221 2222 typedef struct VkPipelineRasterizationStateCreateInfo { 2223 VkStructureType sType; 2224 const void* pNext; 2225 VkPipelineRasterizationStateCreateFlags flags; 2226 VkBool32 depthClampEnable; 2227 VkBool32 rasterizerDiscardEnable; 2228 VkPolygonMode polygonMode; 2229 VkCullModeFlags cullMode; 2230 VkFrontFace frontFace; 2231 VkBool32 depthBiasEnable; 2232 float depthBiasConstantFactor; 2233 float depthBiasClamp; 2234 float depthBiasSlopeFactor; 2235 float lineWidth; 2236 } VkPipelineRasterizationStateCreateInfo; 2237 2238 typedef struct VkPipelineMultisampleStateCreateInfo { 2239 VkStructureType sType; 2240 const void* pNext; 2241 VkPipelineMultisampleStateCreateFlags flags; 2242 VkSampleCountFlagBits rasterizationSamples; 2243 VkBool32 sampleShadingEnable; 2244 float minSampleShading; 2245 const VkSampleMask* pSampleMask; 2246 VkBool32 alphaToCoverageEnable; 2247 VkBool32 alphaToOneEnable; 2248 } VkPipelineMultisampleStateCreateInfo; 2249 2250 typedef struct VkStencilOpState { 2251 VkStencilOp failOp; 2252 VkStencilOp passOp; 2253 VkStencilOp depthFailOp; 2254 VkCompareOp compareOp; 2255 uint32_t compareMask; 2256 uint32_t writeMask; 2257 uint32_t reference; 2258 } VkStencilOpState; 2259 2260 typedef struct VkPipelineDepthStencilStateCreateInfo { 2261 VkStructureType sType; 2262 const void* pNext; 2263 VkPipelineDepthStencilStateCreateFlags flags; 2264 VkBool32 depthTestEnable; 2265 VkBool32 depthWriteEnable; 2266 VkCompareOp depthCompareOp; 2267 VkBool32 depthBoundsTestEnable; 2268 VkBool32 stencilTestEnable; 2269 VkStencilOpState front; 2270 VkStencilOpState back; 2271 float minDepthBounds; 2272 float maxDepthBounds; 2273 } VkPipelineDepthStencilStateCreateInfo; 2274 2275 typedef struct VkPipelineColorBlendAttachmentState { 2276 VkBool32 blendEnable; 2277 VkBlendFactor srcColorBlendFactor; 2278 VkBlendFactor dstColorBlendFactor; 2279 VkBlendOp colorBlendOp; 2280 VkBlendFactor srcAlphaBlendFactor; 2281 VkBlendFactor dstAlphaBlendFactor; 2282 VkBlendOp alphaBlendOp; 2283 VkColorComponentFlags colorWriteMask; 2284 } VkPipelineColorBlendAttachmentState; 2285 2286 typedef struct VkPipelineColorBlendStateCreateInfo { 2287 VkStructureType sType; 2288 const void* pNext; 2289 VkPipelineColorBlendStateCreateFlags flags; 2290 VkBool32 logicOpEnable; 2291 VkLogicOp logicOp; 2292 uint32_t attachmentCount; 2293 const VkPipelineColorBlendAttachmentState* pAttachments; 2294 float blendConstants[4]; 2295 } VkPipelineColorBlendStateCreateInfo; 2296 2297 typedef struct VkPipelineDynamicStateCreateInfo { 2298 VkStructureType sType; 2299 const void* pNext; 2300 VkPipelineDynamicStateCreateFlags flags; 2301 uint32_t dynamicStateCount; 2302 const VkDynamicState* pDynamicStates; 2303 } VkPipelineDynamicStateCreateInfo; 2304 2305 typedef struct VkGraphicsPipelineCreateInfo { 2306 VkStructureType sType; 2307 const void* pNext; 2308 VkPipelineCreateFlags flags; 2309 uint32_t stageCount; 2310 const VkPipelineShaderStageCreateInfo* pStages; 2311 const VkPipelineVertexInputStateCreateInfo* pVertexInputState; 2312 const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState; 2313 const VkPipelineTessellationStateCreateInfo* pTessellationState; 2314 const VkPipelineViewportStateCreateInfo* pViewportState; 2315 const VkPipelineRasterizationStateCreateInfo* pRasterizationState; 2316 const VkPipelineMultisampleStateCreateInfo* pMultisampleState; 2317 const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState; 2318 const VkPipelineColorBlendStateCreateInfo* pColorBlendState; 2319 const VkPipelineDynamicStateCreateInfo* pDynamicState; 2320 VkPipelineLayout layout; 2321 VkRenderPass renderPass; 2322 uint32_t subpass; 2323 VkPipeline basePipelineHandle; 2324 int32_t basePipelineIndex; 2325 } VkGraphicsPipelineCreateInfo; 2326 2327 typedef struct VkPushConstantRange { 2328 VkShaderStageFlags stageFlags; 2329 uint32_t offset; 2330 uint32_t size; 2331 } VkPushConstantRange; 2332 2333 typedef struct VkPipelineLayoutCreateInfo { 2334 VkStructureType sType; 2335 const void* pNext; 2336 VkPipelineLayoutCreateFlags flags; 2337 uint32_t setLayoutCount; 2338 const VkDescriptorSetLayout* pSetLayouts; 2339 uint32_t pushConstantRangeCount; 2340 const VkPushConstantRange* pPushConstantRanges; 2341 } VkPipelineLayoutCreateInfo; 2342 2343 typedef struct VkSamplerCreateInfo { 2344 VkStructureType sType; 2345 const void* pNext; 2346 VkSamplerCreateFlags flags; 2347 VkFilter magFilter; 2348 VkFilter minFilter; 2349 VkSamplerMipmapMode mipmapMode; 2350 VkSamplerAddressMode addressModeU; 2351 VkSamplerAddressMode addressModeV; 2352 VkSamplerAddressMode addressModeW; 2353 float mipLodBias; 2354 VkBool32 anisotropyEnable; 2355 float maxAnisotropy; 2356 VkBool32 compareEnable; 2357 VkCompareOp compareOp; 2358 float minLod; 2359 float maxLod; 2360 VkBorderColor borderColor; 2361 VkBool32 unnormalizedCoordinates; 2362 } VkSamplerCreateInfo; 2363 2364 typedef struct VkCopyDescriptorSet { 2365 VkStructureType sType; 2366 const void* pNext; 2367 VkDescriptorSet srcSet; 2368 uint32_t srcBinding; 2369 uint32_t srcArrayElement; 2370 VkDescriptorSet dstSet; 2371 uint32_t dstBinding; 2372 uint32_t dstArrayElement; 2373 uint32_t descriptorCount; 2374 } VkCopyDescriptorSet; 2375 2376 typedef struct VkDescriptorBufferInfo { 2377 VkBuffer buffer; 2378 VkDeviceSize offset; 2379 VkDeviceSize range; 2380 } VkDescriptorBufferInfo; 2381 2382 typedef struct VkDescriptorImageInfo { 2383 VkSampler sampler; 2384 VkImageView imageView; 2385 VkImageLayout imageLayout; 2386 } VkDescriptorImageInfo; 2387 2388 typedef struct VkDescriptorPoolSize { 2389 VkDescriptorType type; 2390 uint32_t descriptorCount; 2391 } VkDescriptorPoolSize; 2392 2393 typedef struct VkDescriptorPoolCreateInfo { 2394 VkStructureType sType; 2395 const void* pNext; 2396 VkDescriptorPoolCreateFlags flags; 2397 uint32_t maxSets; 2398 uint32_t poolSizeCount; 2399 const VkDescriptorPoolSize* pPoolSizes; 2400 } VkDescriptorPoolCreateInfo; 2401 2402 typedef struct VkDescriptorSetAllocateInfo { 2403 VkStructureType sType; 2404 const void* pNext; 2405 VkDescriptorPool descriptorPool; 2406 uint32_t descriptorSetCount; 2407 const VkDescriptorSetLayout* pSetLayouts; 2408 } VkDescriptorSetAllocateInfo; 2409 2410 typedef struct VkDescriptorSetLayoutBinding { 2411 uint32_t binding; 2412 VkDescriptorType descriptorType; 2413 uint32_t descriptorCount; 2414 VkShaderStageFlags stageFlags; 2415 const VkSampler* pImmutableSamplers; 2416 } VkDescriptorSetLayoutBinding; 2417 2418 typedef struct VkDescriptorSetLayoutCreateInfo { 2419 VkStructureType sType; 2420 const void* pNext; 2421 VkDescriptorSetLayoutCreateFlags flags; 2422 uint32_t bindingCount; 2423 const VkDescriptorSetLayoutBinding* pBindings; 2424 } VkDescriptorSetLayoutCreateInfo; 2425 2426 typedef struct VkWriteDescriptorSet { 2427 VkStructureType sType; 2428 const void* pNext; 2429 VkDescriptorSet dstSet; 2430 uint32_t dstBinding; 2431 uint32_t dstArrayElement; 2432 uint32_t descriptorCount; 2433 VkDescriptorType descriptorType; 2434 const VkDescriptorImageInfo* pImageInfo; 2435 const VkDescriptorBufferInfo* pBufferInfo; 2436 const VkBufferView* pTexelBufferView; 2437 } VkWriteDescriptorSet; 2438 2439 typedef struct VkAttachmentDescription { 2440 VkAttachmentDescriptionFlags flags; 2441 VkFormat format; 2442 VkSampleCountFlagBits samples; 2443 VkAttachmentLoadOp loadOp; 2444 VkAttachmentStoreOp storeOp; 2445 VkAttachmentLoadOp stencilLoadOp; 2446 VkAttachmentStoreOp stencilStoreOp; 2447 VkImageLayout initialLayout; 2448 VkImageLayout finalLayout; 2449 } VkAttachmentDescription; 2450 2451 typedef struct VkAttachmentReference { 2452 uint32_t attachment; 2453 VkImageLayout layout; 2454 } VkAttachmentReference; 2455 2456 typedef struct VkFramebufferCreateInfo { 2457 VkStructureType sType; 2458 const void* pNext; 2459 VkFramebufferCreateFlags flags; 2460 VkRenderPass renderPass; 2461 uint32_t attachmentCount; 2462 const VkImageView* pAttachments; 2463 uint32_t width; 2464 uint32_t height; 2465 uint32_t layers; 2466 } VkFramebufferCreateInfo; 2467 2468 typedef struct VkSubpassDescription { 2469 VkSubpassDescriptionFlags flags; 2470 VkPipelineBindPoint pipelineBindPoint; 2471 uint32_t inputAttachmentCount; 2472 const VkAttachmentReference* pInputAttachments; 2473 uint32_t colorAttachmentCount; 2474 const VkAttachmentReference* pColorAttachments; 2475 const VkAttachmentReference* pResolveAttachments; 2476 const VkAttachmentReference* pDepthStencilAttachment; 2477 uint32_t preserveAttachmentCount; 2478 const uint32_t* pPreserveAttachments; 2479 } VkSubpassDescription; 2480 2481 typedef struct VkSubpassDependency { 2482 uint32_t srcSubpass; 2483 uint32_t dstSubpass; 2484 VkPipelineStageFlags srcStageMask; 2485 VkPipelineStageFlags dstStageMask; 2486 VkAccessFlags srcAccessMask; 2487 VkAccessFlags dstAccessMask; 2488 VkDependencyFlags dependencyFlags; 2489 } VkSubpassDependency; 2490 2491 typedef struct VkRenderPassCreateInfo { 2492 VkStructureType sType; 2493 const void* pNext; 2494 VkRenderPassCreateFlags flags; 2495 uint32_t attachmentCount; 2496 const VkAttachmentDescription* pAttachments; 2497 uint32_t subpassCount; 2498 const VkSubpassDescription* pSubpasses; 2499 uint32_t dependencyCount; 2500 const VkSubpassDependency* pDependencies; 2501 } VkRenderPassCreateInfo; 2502 2503 typedef struct VkCommandPoolCreateInfo { 2504 VkStructureType sType; 2505 const void* pNext; 2506 VkCommandPoolCreateFlags flags; 2507 uint32_t queueFamilyIndex; 2508 } VkCommandPoolCreateInfo; 2509 2510 typedef struct VkCommandBufferAllocateInfo { 2511 VkStructureType sType; 2512 const void* pNext; 2513 VkCommandPool commandPool; 2514 VkCommandBufferLevel level; 2515 uint32_t commandBufferCount; 2516 } VkCommandBufferAllocateInfo; 2517 2518 typedef struct VkCommandBufferInheritanceInfo { 2519 VkStructureType sType; 2520 const void* pNext; 2521 VkRenderPass renderPass; 2522 uint32_t subpass; 2523 VkFramebuffer framebuffer; 2524 VkBool32 occlusionQueryEnable; 2525 VkQueryControlFlags queryFlags; 2526 VkQueryPipelineStatisticFlags pipelineStatistics; 2527 } VkCommandBufferInheritanceInfo; 2528 2529 typedef struct VkCommandBufferBeginInfo { 2530 VkStructureType sType; 2531 const void* pNext; 2532 VkCommandBufferUsageFlags flags; 2533 const VkCommandBufferInheritanceInfo* pInheritanceInfo; 2534 } VkCommandBufferBeginInfo; 2535 2536 typedef struct VkBufferCopy { 2537 VkDeviceSize srcOffset; 2538 VkDeviceSize dstOffset; 2539 VkDeviceSize size; 2540 } VkBufferCopy; 2541 2542 typedef struct VkImageSubresourceLayers { 2543 VkImageAspectFlags aspectMask; 2544 uint32_t mipLevel; 2545 uint32_t baseArrayLayer; 2546 uint32_t layerCount; 2547 } VkImageSubresourceLayers; 2548 2549 typedef struct VkBufferImageCopy { 2550 VkDeviceSize bufferOffset; 2551 uint32_t bufferRowLength; 2552 uint32_t bufferImageHeight; 2553 VkImageSubresourceLayers imageSubresource; 2554 VkOffset3D imageOffset; 2555 VkExtent3D imageExtent; 2556 } VkBufferImageCopy; 2557 2558 typedef union VkClearColorValue { 2559 float float32[4]; 2560 int32_t int32[4]; 2561 uint32_t uint32[4]; 2562 } VkClearColorValue; 2563 2564 typedef struct VkClearDepthStencilValue { 2565 float depth; 2566 uint32_t stencil; 2567 } VkClearDepthStencilValue; 2568 2569 typedef union VkClearValue { 2570 VkClearColorValue color; 2571 VkClearDepthStencilValue depthStencil; 2572 } VkClearValue; 2573 2574 typedef struct VkClearAttachment { 2575 VkImageAspectFlags aspectMask; 2576 uint32_t colorAttachment; 2577 VkClearValue clearValue; 2578 } VkClearAttachment; 2579 2580 typedef struct VkClearRect { 2581 VkRect2D rect; 2582 uint32_t baseArrayLayer; 2583 uint32_t layerCount; 2584 } VkClearRect; 2585 2586 typedef struct VkImageBlit { 2587 VkImageSubresourceLayers srcSubresource; 2588 VkOffset3D srcOffsets[2]; 2589 VkImageSubresourceLayers dstSubresource; 2590 VkOffset3D dstOffsets[2]; 2591 } VkImageBlit; 2592 2593 typedef struct VkImageCopy { 2594 VkImageSubresourceLayers srcSubresource; 2595 VkOffset3D srcOffset; 2596 VkImageSubresourceLayers dstSubresource; 2597 VkOffset3D dstOffset; 2598 VkExtent3D extent; 2599 } VkImageCopy; 2600 2601 typedef struct VkImageResolve { 2602 VkImageSubresourceLayers srcSubresource; 2603 VkOffset3D srcOffset; 2604 VkImageSubresourceLayers dstSubresource; 2605 VkOffset3D dstOffset; 2606 VkExtent3D extent; 2607 } VkImageResolve; 2608 2609 typedef struct VkRenderPassBeginInfo { 2610 VkStructureType sType; 2611 const void* pNext; 2612 VkRenderPass renderPass; 2613 VkFramebuffer framebuffer; 2614 VkRect2D renderArea; 2615 uint32_t clearValueCount; 2616 const VkClearValue* pClearValues; 2617 } VkRenderPassBeginInfo; 2618 2619 typedef VkResult (VKAPI_PTR *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance); 2620 typedef void (VKAPI_PTR *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks* pAllocator); 2621 typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); 2622 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures); 2623 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties); 2624 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties); 2625 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties); 2626 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties); 2627 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties); 2628 typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName); 2629 typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName); 2630 typedef VkResult (VKAPI_PTR *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice); 2631 typedef void (VKAPI_PTR *PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks* pAllocator); 2632 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); 2633 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); 2634 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties); 2635 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties); 2636 typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue); 2637 typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence); 2638 typedef VkResult (VKAPI_PTR *PFN_vkQueueWaitIdle)(VkQueue queue); 2639 typedef VkResult (VKAPI_PTR *PFN_vkDeviceWaitIdle)(VkDevice device); 2640 typedef VkResult (VKAPI_PTR *PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory); 2641 typedef VkResult (VKAPI_PTR *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData); 2642 typedef void (VKAPI_PTR *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory); 2643 typedef VkResult (VKAPI_PTR *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); 2644 typedef VkResult (VKAPI_PTR *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); 2645 typedef void (VKAPI_PTR *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes); 2646 typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset); 2647 typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset); 2648 typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements); 2649 typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements); 2650 typedef VkResult (VKAPI_PTR *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); 2651 typedef void (VKAPI_PTR *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator); 2652 typedef VkResult (VKAPI_PTR *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences); 2653 typedef VkResult (VKAPI_PTR *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence); 2654 typedef VkResult (VKAPI_PTR *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout); 2655 typedef VkResult (VKAPI_PTR *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore); 2656 typedef void (VKAPI_PTR *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator); 2657 typedef VkResult (VKAPI_PTR *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent); 2658 typedef void (VKAPI_PTR *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator); 2659 typedef VkResult (VKAPI_PTR *PFN_vkGetEventStatus)(VkDevice device, VkEvent event); 2660 typedef VkResult (VKAPI_PTR *PFN_vkSetEvent)(VkDevice device, VkEvent event); 2661 typedef VkResult (VKAPI_PTR *PFN_vkResetEvent)(VkDevice device, VkEvent event); 2662 typedef VkResult (VKAPI_PTR *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool); 2663 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); 2664 typedef VkResult (VKAPI_PTR *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer); 2665 typedef void (VKAPI_PTR *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator); 2666 typedef VkResult (VKAPI_PTR *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView); 2667 typedef void (VKAPI_PTR *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator); 2668 typedef VkResult (VKAPI_PTR *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage); 2669 typedef void (VKAPI_PTR *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator); 2670 typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout); 2671 typedef VkResult (VKAPI_PTR *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView); 2672 typedef void (VKAPI_PTR *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator); 2673 typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache); 2674 typedef void (VKAPI_PTR *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator); 2675 typedef VkResult (VKAPI_PTR *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); 2676 typedef VkResult (VKAPI_PTR *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); 2677 typedef void (VKAPI_PTR *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator); 2678 typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout); 2679 typedef void (VKAPI_PTR *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator); 2680 typedef VkResult (VKAPI_PTR *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler); 2681 typedef void (VKAPI_PTR *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator); 2682 typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout); 2683 typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator); 2684 typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool); 2685 typedef VkResult (VKAPI_PTR *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags); 2686 typedef VkResult (VKAPI_PTR *PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets); 2687 typedef VkResult (VKAPI_PTR *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets); 2688 typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies); 2689 typedef VkResult (VKAPI_PTR *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer); 2690 typedef void (VKAPI_PTR *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator); 2691 typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); 2692 typedef void (VKAPI_PTR *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator); 2693 typedef void (VKAPI_PTR *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity); 2694 typedef VkResult (VKAPI_PTR *PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool); 2695 typedef VkResult (VKAPI_PTR *PFN_vkResetCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags); 2696 typedef VkResult (VKAPI_PTR *PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers); 2697 typedef void (VKAPI_PTR *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); 2698 typedef VkResult (VKAPI_PTR *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo); 2699 typedef VkResult (VKAPI_PTR *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer); 2700 typedef VkResult (VKAPI_PTR *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags); 2701 typedef void (VKAPI_PTR *PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); 2702 typedef void (VKAPI_PTR *PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports); 2703 typedef void (VKAPI_PTR *PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors); 2704 typedef void (VKAPI_PTR *PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth); 2705 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor); 2706 typedef void (VKAPI_PTR *PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4]); 2707 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds); 2708 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask); 2709 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask); 2710 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference); 2711 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); 2712 typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); 2713 typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets); 2714 typedef void (VKAPI_PTR *PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance); 2715 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance); 2716 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); 2717 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); 2718 typedef void (VKAPI_PTR *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); 2719 typedef void (VKAPI_PTR *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); 2720 typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions); 2721 typedef void (VKAPI_PTR *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions); 2722 typedef void (VKAPI_PTR *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter); 2723 typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions); 2724 typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions); 2725 typedef void (VKAPI_PTR *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData); 2726 typedef void (VKAPI_PTR *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data); 2727 typedef void (VKAPI_PTR *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); 2728 typedef void (VKAPI_PTR *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); 2729 typedef void (VKAPI_PTR *PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects); 2730 typedef void (VKAPI_PTR *PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions); 2731 typedef void (VKAPI_PTR *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); 2732 typedef void (VKAPI_PTR *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); 2733 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); 2734 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); 2735 typedef void (VKAPI_PTR *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags); 2736 typedef void (VKAPI_PTR *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query); 2737 typedef void (VKAPI_PTR *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); 2738 typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query); 2739 typedef void (VKAPI_PTR *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags); 2740 typedef void (VKAPI_PTR *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues); 2741 typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents); 2742 typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkSubpassContents contents); 2743 typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer); 2744 typedef void (VKAPI_PTR *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); 2745 2746 #ifndef VK_NO_PROTOTYPES 2747 VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance( 2748 const VkInstanceCreateInfo* pCreateInfo, 2749 const VkAllocationCallbacks* pAllocator, 2750 VkInstance* pInstance); 2751 2752 VKAPI_ATTR void VKAPI_CALL vkDestroyInstance( 2753 VkInstance instance, 2754 const VkAllocationCallbacks* pAllocator); 2755 2756 VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices( 2757 VkInstance instance, 2758 uint32_t* pPhysicalDeviceCount, 2759 VkPhysicalDevice* pPhysicalDevices); 2760 2761 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures( 2762 VkPhysicalDevice physicalDevice, 2763 VkPhysicalDeviceFeatures* pFeatures); 2764 2765 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties( 2766 VkPhysicalDevice physicalDevice, 2767 VkFormat format, 2768 VkFormatProperties* pFormatProperties); 2769 2770 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties( 2771 VkPhysicalDevice physicalDevice, 2772 VkFormat format, 2773 VkImageType type, 2774 VkImageTiling tiling, 2775 VkImageUsageFlags usage, 2776 VkImageCreateFlags flags, 2777 VkImageFormatProperties* pImageFormatProperties); 2778 2779 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties( 2780 VkPhysicalDevice physicalDevice, 2781 VkPhysicalDeviceProperties* pProperties); 2782 2783 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties( 2784 VkPhysicalDevice physicalDevice, 2785 uint32_t* pQueueFamilyPropertyCount, 2786 VkQueueFamilyProperties* pQueueFamilyProperties); 2787 2788 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties( 2789 VkPhysicalDevice physicalDevice, 2790 VkPhysicalDeviceMemoryProperties* pMemoryProperties); 2791 2792 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr( 2793 VkInstance instance, 2794 const char* pName); 2795 2796 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr( 2797 VkDevice device, 2798 const char* pName); 2799 2800 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice( 2801 VkPhysicalDevice physicalDevice, 2802 const VkDeviceCreateInfo* pCreateInfo, 2803 const VkAllocationCallbacks* pAllocator, 2804 VkDevice* pDevice); 2805 2806 VKAPI_ATTR void VKAPI_CALL vkDestroyDevice( 2807 VkDevice device, 2808 const VkAllocationCallbacks* pAllocator); 2809 2810 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties( 2811 const char* pLayerName, 2812 uint32_t* pPropertyCount, 2813 VkExtensionProperties* pProperties); 2814 2815 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties( 2816 VkPhysicalDevice physicalDevice, 2817 const char* pLayerName, 2818 uint32_t* pPropertyCount, 2819 VkExtensionProperties* pProperties); 2820 2821 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties( 2822 uint32_t* pPropertyCount, 2823 VkLayerProperties* pProperties); 2824 2825 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties( 2826 VkPhysicalDevice physicalDevice, 2827 uint32_t* pPropertyCount, 2828 VkLayerProperties* pProperties); 2829 2830 VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue( 2831 VkDevice device, 2832 uint32_t queueFamilyIndex, 2833 uint32_t queueIndex, 2834 VkQueue* pQueue); 2835 2836 VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit( 2837 VkQueue queue, 2838 uint32_t submitCount, 2839 const VkSubmitInfo* pSubmits, 2840 VkFence fence); 2841 2842 VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle( 2843 VkQueue queue); 2844 2845 VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle( 2846 VkDevice device); 2847 2848 VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory( 2849 VkDevice device, 2850 const VkMemoryAllocateInfo* pAllocateInfo, 2851 const VkAllocationCallbacks* pAllocator, 2852 VkDeviceMemory* pMemory); 2853 2854 VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory( 2855 VkDevice device, 2856 VkDeviceMemory memory, 2857 VkDeviceSize offset, 2858 VkDeviceSize size, 2859 VkMemoryMapFlags flags, 2860 void** ppData); 2861 2862 VKAPI_ATTR void VKAPI_CALL vkUnmapMemory( 2863 VkDevice device, 2864 VkDeviceMemory memory); 2865 2866 VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges( 2867 VkDevice device, 2868 uint32_t memoryRangeCount, 2869 const VkMappedMemoryRange* pMemoryRanges); 2870 2871 VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges( 2872 VkDevice device, 2873 uint32_t memoryRangeCount, 2874 const VkMappedMemoryRange* pMemoryRanges); 2875 2876 VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment( 2877 VkDevice device, 2878 VkDeviceMemory memory, 2879 VkDeviceSize* pCommittedMemoryInBytes); 2880 2881 VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory( 2882 VkDevice device, 2883 VkBuffer buffer, 2884 VkDeviceMemory memory, 2885 VkDeviceSize memoryOffset); 2886 2887 VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory( 2888 VkDevice device, 2889 VkImage image, 2890 VkDeviceMemory memory, 2891 VkDeviceSize memoryOffset); 2892 2893 VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements( 2894 VkDevice device, 2895 VkBuffer buffer, 2896 VkMemoryRequirements* pMemoryRequirements); 2897 2898 VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements( 2899 VkDevice device, 2900 VkImage image, 2901 VkMemoryRequirements* pMemoryRequirements); 2902 2903 VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence( 2904 VkDevice device, 2905 const VkFenceCreateInfo* pCreateInfo, 2906 const VkAllocationCallbacks* pAllocator, 2907 VkFence* pFence); 2908 2909 VKAPI_ATTR void VKAPI_CALL vkDestroyFence( 2910 VkDevice device, 2911 VkFence fence, 2912 const VkAllocationCallbacks* pAllocator); 2913 2914 VKAPI_ATTR VkResult VKAPI_CALL vkResetFences( 2915 VkDevice device, 2916 uint32_t fenceCount, 2917 const VkFence* pFences); 2918 2919 VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus( 2920 VkDevice device, 2921 VkFence fence); 2922 2923 VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences( 2924 VkDevice device, 2925 uint32_t fenceCount, 2926 const VkFence* pFences, 2927 VkBool32 waitAll, 2928 uint64_t timeout); 2929 2930 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore( 2931 VkDevice device, 2932 const VkSemaphoreCreateInfo* pCreateInfo, 2933 const VkAllocationCallbacks* pAllocator, 2934 VkSemaphore* pSemaphore); 2935 2936 VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore( 2937 VkDevice device, 2938 VkSemaphore semaphore, 2939 const VkAllocationCallbacks* pAllocator); 2940 2941 VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent( 2942 VkDevice device, 2943 const VkEventCreateInfo* pCreateInfo, 2944 const VkAllocationCallbacks* pAllocator, 2945 VkEvent* pEvent); 2946 2947 VKAPI_ATTR void VKAPI_CALL vkDestroyEvent( 2948 VkDevice device, 2949 VkEvent event, 2950 const VkAllocationCallbacks* pAllocator); 2951 2952 VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus( 2953 VkDevice device, 2954 VkEvent event); 2955 2956 VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent( 2957 VkDevice device, 2958 VkEvent event); 2959 2960 VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent( 2961 VkDevice device, 2962 VkEvent event); 2963 2964 VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool( 2965 VkDevice device, 2966 const VkQueryPoolCreateInfo* pCreateInfo, 2967 const VkAllocationCallbacks* pAllocator, 2968 VkQueryPool* pQueryPool); 2969 2970 VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults( 2971 VkDevice device, 2972 VkQueryPool queryPool, 2973 uint32_t firstQuery, 2974 uint32_t queryCount, 2975 size_t dataSize, 2976 void* pData, 2977 VkDeviceSize stride, 2978 VkQueryResultFlags flags); 2979 2980 VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer( 2981 VkDevice device, 2982 const VkBufferCreateInfo* pCreateInfo, 2983 const VkAllocationCallbacks* pAllocator, 2984 VkBuffer* pBuffer); 2985 2986 VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer( 2987 VkDevice device, 2988 VkBuffer buffer, 2989 const VkAllocationCallbacks* pAllocator); 2990 2991 VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView( 2992 VkDevice device, 2993 const VkBufferViewCreateInfo* pCreateInfo, 2994 const VkAllocationCallbacks* pAllocator, 2995 VkBufferView* pView); 2996 2997 VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView( 2998 VkDevice device, 2999 VkBufferView bufferView, 3000 const VkAllocationCallbacks* pAllocator); 3001 3002 VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage( 3003 VkDevice device, 3004 const VkImageCreateInfo* pCreateInfo, 3005 const VkAllocationCallbacks* pAllocator, 3006 VkImage* pImage); 3007 3008 VKAPI_ATTR void VKAPI_CALL vkDestroyImage( 3009 VkDevice device, 3010 VkImage image, 3011 const VkAllocationCallbacks* pAllocator); 3012 3013 VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout( 3014 VkDevice device, 3015 VkImage image, 3016 const VkImageSubresource* pSubresource, 3017 VkSubresourceLayout* pLayout); 3018 3019 VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView( 3020 VkDevice device, 3021 const VkImageViewCreateInfo* pCreateInfo, 3022 const VkAllocationCallbacks* pAllocator, 3023 VkImageView* pView); 3024 3025 VKAPI_ATTR void VKAPI_CALL vkDestroyImageView( 3026 VkDevice device, 3027 VkImageView imageView, 3028 const VkAllocationCallbacks* pAllocator); 3029 3030 VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache( 3031 VkDevice device, 3032 const VkPipelineCacheCreateInfo* pCreateInfo, 3033 const VkAllocationCallbacks* pAllocator, 3034 VkPipelineCache* pPipelineCache); 3035 3036 VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache( 3037 VkDevice device, 3038 VkPipelineCache pipelineCache, 3039 const VkAllocationCallbacks* pAllocator); 3040 3041 VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines( 3042 VkDevice device, 3043 VkPipelineCache pipelineCache, 3044 uint32_t createInfoCount, 3045 const VkGraphicsPipelineCreateInfo* pCreateInfos, 3046 const VkAllocationCallbacks* pAllocator, 3047 VkPipeline* pPipelines); 3048 3049 VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines( 3050 VkDevice device, 3051 VkPipelineCache pipelineCache, 3052 uint32_t createInfoCount, 3053 const VkComputePipelineCreateInfo* pCreateInfos, 3054 const VkAllocationCallbacks* pAllocator, 3055 VkPipeline* pPipelines); 3056 3057 VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline( 3058 VkDevice device, 3059 VkPipeline pipeline, 3060 const VkAllocationCallbacks* pAllocator); 3061 3062 VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout( 3063 VkDevice device, 3064 const VkPipelineLayoutCreateInfo* pCreateInfo, 3065 const VkAllocationCallbacks* pAllocator, 3066 VkPipelineLayout* pPipelineLayout); 3067 3068 VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout( 3069 VkDevice device, 3070 VkPipelineLayout pipelineLayout, 3071 const VkAllocationCallbacks* pAllocator); 3072 3073 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler( 3074 VkDevice device, 3075 const VkSamplerCreateInfo* pCreateInfo, 3076 const VkAllocationCallbacks* pAllocator, 3077 VkSampler* pSampler); 3078 3079 VKAPI_ATTR void VKAPI_CALL vkDestroySampler( 3080 VkDevice device, 3081 VkSampler sampler, 3082 const VkAllocationCallbacks* pAllocator); 3083 3084 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout( 3085 VkDevice device, 3086 const VkDescriptorSetLayoutCreateInfo* pCreateInfo, 3087 const VkAllocationCallbacks* pAllocator, 3088 VkDescriptorSetLayout* pSetLayout); 3089 3090 VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout( 3091 VkDevice device, 3092 VkDescriptorSetLayout descriptorSetLayout, 3093 const VkAllocationCallbacks* pAllocator); 3094 3095 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool( 3096 VkDevice device, 3097 const VkDescriptorPoolCreateInfo* pCreateInfo, 3098 const VkAllocationCallbacks* pAllocator, 3099 VkDescriptorPool* pDescriptorPool); 3100 3101 VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool( 3102 VkDevice device, 3103 VkDescriptorPool descriptorPool, 3104 VkDescriptorPoolResetFlags flags); 3105 3106 VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets( 3107 VkDevice device, 3108 const VkDescriptorSetAllocateInfo* pAllocateInfo, 3109 VkDescriptorSet* pDescriptorSets); 3110 3111 VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets( 3112 VkDevice device, 3113 VkDescriptorPool descriptorPool, 3114 uint32_t descriptorSetCount, 3115 const VkDescriptorSet* pDescriptorSets); 3116 3117 VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets( 3118 VkDevice device, 3119 uint32_t descriptorWriteCount, 3120 const VkWriteDescriptorSet* pDescriptorWrites, 3121 uint32_t descriptorCopyCount, 3122 const VkCopyDescriptorSet* pDescriptorCopies); 3123 3124 VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer( 3125 VkDevice device, 3126 const VkFramebufferCreateInfo* pCreateInfo, 3127 const VkAllocationCallbacks* pAllocator, 3128 VkFramebuffer* pFramebuffer); 3129 3130 VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer( 3131 VkDevice device, 3132 VkFramebuffer framebuffer, 3133 const VkAllocationCallbacks* pAllocator); 3134 3135 VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass( 3136 VkDevice device, 3137 const VkRenderPassCreateInfo* pCreateInfo, 3138 const VkAllocationCallbacks* pAllocator, 3139 VkRenderPass* pRenderPass); 3140 3141 VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass( 3142 VkDevice device, 3143 VkRenderPass renderPass, 3144 const VkAllocationCallbacks* pAllocator); 3145 3146 VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity( 3147 VkDevice device, 3148 VkRenderPass renderPass, 3149 VkExtent2D* pGranularity); 3150 3151 VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool( 3152 VkDevice device, 3153 const VkCommandPoolCreateInfo* pCreateInfo, 3154 const VkAllocationCallbacks* pAllocator, 3155 VkCommandPool* pCommandPool); 3156 3157 VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool( 3158 VkDevice device, 3159 VkCommandPool commandPool, 3160 VkCommandPoolResetFlags flags); 3161 3162 VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers( 3163 VkDevice device, 3164 const VkCommandBufferAllocateInfo* pAllocateInfo, 3165 VkCommandBuffer* pCommandBuffers); 3166 3167 VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers( 3168 VkDevice device, 3169 VkCommandPool commandPool, 3170 uint32_t commandBufferCount, 3171 const VkCommandBuffer* pCommandBuffers); 3172 3173 VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer( 3174 VkCommandBuffer commandBuffer, 3175 const VkCommandBufferBeginInfo* pBeginInfo); 3176 3177 VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer( 3178 VkCommandBuffer commandBuffer); 3179 3180 VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer( 3181 VkCommandBuffer commandBuffer, 3182 VkCommandBufferResetFlags flags); 3183 3184 VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline( 3185 VkCommandBuffer commandBuffer, 3186 VkPipelineBindPoint pipelineBindPoint, 3187 VkPipeline pipeline); 3188 3189 VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport( 3190 VkCommandBuffer commandBuffer, 3191 uint32_t firstViewport, 3192 uint32_t viewportCount, 3193 const VkViewport* pViewports); 3194 3195 VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor( 3196 VkCommandBuffer commandBuffer, 3197 uint32_t firstScissor, 3198 uint32_t scissorCount, 3199 const VkRect2D* pScissors); 3200 3201 VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth( 3202 VkCommandBuffer commandBuffer, 3203 float lineWidth); 3204 3205 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias( 3206 VkCommandBuffer commandBuffer, 3207 float depthBiasConstantFactor, 3208 float depthBiasClamp, 3209 float depthBiasSlopeFactor); 3210 3211 VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants( 3212 VkCommandBuffer commandBuffer, 3213 const float blendConstants[4]); 3214 3215 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds( 3216 VkCommandBuffer commandBuffer, 3217 float minDepthBounds, 3218 float maxDepthBounds); 3219 3220 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask( 3221 VkCommandBuffer commandBuffer, 3222 VkStencilFaceFlags faceMask, 3223 uint32_t compareMask); 3224 3225 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask( 3226 VkCommandBuffer commandBuffer, 3227 VkStencilFaceFlags faceMask, 3228 uint32_t writeMask); 3229 3230 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference( 3231 VkCommandBuffer commandBuffer, 3232 VkStencilFaceFlags faceMask, 3233 uint32_t reference); 3234 3235 VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets( 3236 VkCommandBuffer commandBuffer, 3237 VkPipelineBindPoint pipelineBindPoint, 3238 VkPipelineLayout layout, 3239 uint32_t firstSet, 3240 uint32_t descriptorSetCount, 3241 const VkDescriptorSet* pDescriptorSets, 3242 uint32_t dynamicOffsetCount, 3243 const uint32_t* pDynamicOffsets); 3244 3245 VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer( 3246 VkCommandBuffer commandBuffer, 3247 VkBuffer buffer, 3248 VkDeviceSize offset, 3249 VkIndexType indexType); 3250 3251 VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers( 3252 VkCommandBuffer commandBuffer, 3253 uint32_t firstBinding, 3254 uint32_t bindingCount, 3255 const VkBuffer* pBuffers, 3256 const VkDeviceSize* pOffsets); 3257 3258 VKAPI_ATTR void VKAPI_CALL vkCmdDraw( 3259 VkCommandBuffer commandBuffer, 3260 uint32_t vertexCount, 3261 uint32_t instanceCount, 3262 uint32_t firstVertex, 3263 uint32_t firstInstance); 3264 3265 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed( 3266 VkCommandBuffer commandBuffer, 3267 uint32_t indexCount, 3268 uint32_t instanceCount, 3269 uint32_t firstIndex, 3270 int32_t vertexOffset, 3271 uint32_t firstInstance); 3272 3273 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect( 3274 VkCommandBuffer commandBuffer, 3275 VkBuffer buffer, 3276 VkDeviceSize offset, 3277 uint32_t drawCount, 3278 uint32_t stride); 3279 3280 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect( 3281 VkCommandBuffer commandBuffer, 3282 VkBuffer buffer, 3283 VkDeviceSize offset, 3284 uint32_t drawCount, 3285 uint32_t stride); 3286 3287 VKAPI_ATTR void VKAPI_CALL vkCmdDispatch( 3288 VkCommandBuffer commandBuffer, 3289 uint32_t groupCountX, 3290 uint32_t groupCountY, 3291 uint32_t groupCountZ); 3292 3293 VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect( 3294 VkCommandBuffer commandBuffer, 3295 VkBuffer buffer, 3296 VkDeviceSize offset); 3297 3298 VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer( 3299 VkCommandBuffer commandBuffer, 3300 VkBuffer srcBuffer, 3301 VkBuffer dstBuffer, 3302 uint32_t regionCount, 3303 const VkBufferCopy* pRegions); 3304 3305 VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage( 3306 VkCommandBuffer commandBuffer, 3307 VkImage srcImage, 3308 VkImageLayout srcImageLayout, 3309 VkImage dstImage, 3310 VkImageLayout dstImageLayout, 3311 uint32_t regionCount, 3312 const VkImageCopy* pRegions); 3313 3314 VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage( 3315 VkCommandBuffer commandBuffer, 3316 VkImage srcImage, 3317 VkImageLayout srcImageLayout, 3318 VkImage dstImage, 3319 VkImageLayout dstImageLayout, 3320 uint32_t regionCount, 3321 const VkImageBlit* pRegions, 3322 VkFilter filter); 3323 3324 VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage( 3325 VkCommandBuffer commandBuffer, 3326 VkBuffer srcBuffer, 3327 VkImage dstImage, 3328 VkImageLayout dstImageLayout, 3329 uint32_t regionCount, 3330 const VkBufferImageCopy* pRegions); 3331 3332 VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer( 3333 VkCommandBuffer commandBuffer, 3334 VkImage srcImage, 3335 VkImageLayout srcImageLayout, 3336 VkBuffer dstBuffer, 3337 uint32_t regionCount, 3338 const VkBufferImageCopy* pRegions); 3339 3340 VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer( 3341 VkCommandBuffer commandBuffer, 3342 VkBuffer dstBuffer, 3343 VkDeviceSize dstOffset, 3344 VkDeviceSize dataSize, 3345 const void* pData); 3346 3347 VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer( 3348 VkCommandBuffer commandBuffer, 3349 VkBuffer dstBuffer, 3350 VkDeviceSize dstOffset, 3351 VkDeviceSize size, 3352 uint32_t data); 3353 3354 VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage( 3355 VkCommandBuffer commandBuffer, 3356 VkImage image, 3357 VkImageLayout imageLayout, 3358 const VkClearColorValue* pColor, 3359 uint32_t rangeCount, 3360 const VkImageSubresourceRange* pRanges); 3361 3362 VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage( 3363 VkCommandBuffer commandBuffer, 3364 VkImage image, 3365 VkImageLayout imageLayout, 3366 const VkClearDepthStencilValue* pDepthStencil, 3367 uint32_t rangeCount, 3368 const VkImageSubresourceRange* pRanges); 3369 3370 VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments( 3371 VkCommandBuffer commandBuffer, 3372 uint32_t attachmentCount, 3373 const VkClearAttachment* pAttachments, 3374 uint32_t rectCount, 3375 const VkClearRect* pRects); 3376 3377 VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage( 3378 VkCommandBuffer commandBuffer, 3379 VkImage srcImage, 3380 VkImageLayout srcImageLayout, 3381 VkImage dstImage, 3382 VkImageLayout dstImageLayout, 3383 uint32_t regionCount, 3384 const VkImageResolve* pRegions); 3385 3386 VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent( 3387 VkCommandBuffer commandBuffer, 3388 VkEvent event, 3389 VkPipelineStageFlags stageMask); 3390 3391 VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent( 3392 VkCommandBuffer commandBuffer, 3393 VkEvent event, 3394 VkPipelineStageFlags stageMask); 3395 3396 VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents( 3397 VkCommandBuffer commandBuffer, 3398 uint32_t eventCount, 3399 const VkEvent* pEvents, 3400 VkPipelineStageFlags srcStageMask, 3401 VkPipelineStageFlags dstStageMask, 3402 uint32_t memoryBarrierCount, 3403 const VkMemoryBarrier* pMemoryBarriers, 3404 uint32_t bufferMemoryBarrierCount, 3405 const VkBufferMemoryBarrier* pBufferMemoryBarriers, 3406 uint32_t imageMemoryBarrierCount, 3407 const VkImageMemoryBarrier* pImageMemoryBarriers); 3408 3409 VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier( 3410 VkCommandBuffer commandBuffer, 3411 VkPipelineStageFlags srcStageMask, 3412 VkPipelineStageFlags dstStageMask, 3413 VkDependencyFlags dependencyFlags, 3414 uint32_t memoryBarrierCount, 3415 const VkMemoryBarrier* pMemoryBarriers, 3416 uint32_t bufferMemoryBarrierCount, 3417 const VkBufferMemoryBarrier* pBufferMemoryBarriers, 3418 uint32_t imageMemoryBarrierCount, 3419 const VkImageMemoryBarrier* pImageMemoryBarriers); 3420 3421 VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery( 3422 VkCommandBuffer commandBuffer, 3423 VkQueryPool queryPool, 3424 uint32_t query, 3425 VkQueryControlFlags flags); 3426 3427 VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery( 3428 VkCommandBuffer commandBuffer, 3429 VkQueryPool queryPool, 3430 uint32_t query); 3431 3432 VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool( 3433 VkCommandBuffer commandBuffer, 3434 VkQueryPool queryPool, 3435 uint32_t firstQuery, 3436 uint32_t queryCount); 3437 3438 VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp( 3439 VkCommandBuffer commandBuffer, 3440 VkPipelineStageFlagBits pipelineStage, 3441 VkQueryPool queryPool, 3442 uint32_t query); 3443 3444 VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults( 3445 VkCommandBuffer commandBuffer, 3446 VkQueryPool queryPool, 3447 uint32_t firstQuery, 3448 uint32_t queryCount, 3449 VkBuffer dstBuffer, 3450 VkDeviceSize dstOffset, 3451 VkDeviceSize stride, 3452 VkQueryResultFlags flags); 3453 3454 VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants( 3455 VkCommandBuffer commandBuffer, 3456 VkPipelineLayout layout, 3457 VkShaderStageFlags stageFlags, 3458 uint32_t offset, 3459 uint32_t size, 3460 const void* pValues); 3461 3462 VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass( 3463 VkCommandBuffer commandBuffer, 3464 const VkRenderPassBeginInfo* pRenderPassBegin, 3465 VkSubpassContents contents); 3466 3467 VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass( 3468 VkCommandBuffer commandBuffer, 3469 VkSubpassContents contents); 3470 3471 VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass( 3472 VkCommandBuffer commandBuffer); 3473 3474 VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands( 3475 VkCommandBuffer commandBuffer, 3476 uint32_t commandBufferCount, 3477 const VkCommandBuffer* pCommandBuffers); 3478 #endif 3479 3480 3481 #define VK_VERSION_1_1 1 3482 // Vulkan 1.1 version number 3483 #define VK_API_VERSION_1_1 VK_MAKE_API_VERSION(0, 1, 1, 0)// Patch version should always be set to 0 3484 3485 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSamplerYcbcrConversion) 3486 #define VK_MAX_DEVICE_GROUP_SIZE 32U 3487 #define VK_LUID_SIZE 8U 3488 #define VK_QUEUE_FAMILY_EXTERNAL (~1U) 3489 3490 typedef enum VkPointClippingBehavior { 3491 VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES = 0, 3492 VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY = 1, 3493 VK_POINT_CLIPPING_BEHAVIOR_MAX_ENUM = 0x7FFFFFFF 3494 } VkPointClippingBehavior; 3495 3496 typedef enum VkTessellationDomainOrigin { 3497 VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT = 0, 3498 VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT = 1, 3499 VK_TESSELLATION_DOMAIN_ORIGIN_MAX_ENUM = 0x7FFFFFFF 3500 } VkTessellationDomainOrigin; 3501 3502 typedef enum VkSamplerYcbcrModelConversion { 3503 VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY = 0, 3504 VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY = 1, 3505 VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709 = 2, 3506 VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601 = 3, 3507 VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 = 4, 3508 VK_SAMPLER_YCBCR_MODEL_CONVERSION_MAX_ENUM = 0x7FFFFFFF 3509 } VkSamplerYcbcrModelConversion; 3510 3511 typedef enum VkSamplerYcbcrRange { 3512 VK_SAMPLER_YCBCR_RANGE_ITU_FULL = 0, 3513 VK_SAMPLER_YCBCR_RANGE_ITU_NARROW = 1, 3514 VK_SAMPLER_YCBCR_RANGE_MAX_ENUM = 0x7FFFFFFF 3515 } VkSamplerYcbcrRange; 3516 3517 typedef enum VkChromaLocation { 3518 VK_CHROMA_LOCATION_COSITED_EVEN = 0, 3519 VK_CHROMA_LOCATION_MIDPOINT = 1, 3520 VK_CHROMA_LOCATION_MAX_ENUM = 0x7FFFFFFF 3521 } VkChromaLocation; 3522 3523 typedef enum VkSubgroupFeatureFlagBits { 3524 VK_SUBGROUP_FEATURE_BASIC_BIT = 0x00000001, 3525 VK_SUBGROUP_FEATURE_VOTE_BIT = 0x00000002, 3526 VK_SUBGROUP_FEATURE_ARITHMETIC_BIT = 0x00000004, 3527 VK_SUBGROUP_FEATURE_BALLOT_BIT = 0x00000008, 3528 VK_SUBGROUP_FEATURE_SHUFFLE_BIT = 0x00000010, 3529 VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT = 0x00000020, 3530 VK_SUBGROUP_FEATURE_CLUSTERED_BIT = 0x00000040, 3531 VK_SUBGROUP_FEATURE_QUAD_BIT = 0x00000080, 3532 VK_SUBGROUP_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 3533 } VkSubgroupFeatureFlagBits; 3534 typedef VkFlags VkSubgroupFeatureFlags; 3535 3536 typedef enum VkPeerMemoryFeatureFlagBits { 3537 VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT = 0x00000001, 3538 VK_PEER_MEMORY_FEATURE_COPY_DST_BIT = 0x00000002, 3539 VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT = 0x00000004, 3540 VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT = 0x00000008, 3541 VK_PEER_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 3542 } VkPeerMemoryFeatureFlagBits; 3543 typedef VkFlags VkPeerMemoryFeatureFlags; 3544 3545 typedef enum VkMemoryAllocateFlagBits { 3546 VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT = 0x00000001, 3547 VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT = 0x00000002, 3548 VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 0x00000004, 3549 VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 3550 } VkMemoryAllocateFlagBits; 3551 typedef VkFlags VkMemoryAllocateFlags; 3552 3553 typedef enum VkExternalMemoryHandleTypeFlagBits { 3554 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001, 3555 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002, 3556 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004, 3557 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT = 0x00000008, 3558 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT = 0x00000010, 3559 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT = 0x00000020, 3560 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT = 0x00000040, 3561 VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT = 0x00000200, 3562 VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT = 0x00000080, 3563 VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT = 0x00000100, 3564 VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCI_BUF_BIT_NV = 0x00002000, 3565 VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 3566 } VkExternalMemoryHandleTypeFlagBits; 3567 typedef VkFlags VkExternalMemoryHandleTypeFlags; 3568 3569 typedef enum VkExternalMemoryFeatureFlagBits { 3570 VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT = 0x00000001, 3571 VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT = 0x00000002, 3572 VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT = 0x00000004, 3573 VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 3574 } VkExternalMemoryFeatureFlagBits; 3575 typedef VkFlags VkExternalMemoryFeatureFlags; 3576 3577 typedef enum VkExternalFenceHandleTypeFlagBits { 3578 VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001, 3579 VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002, 3580 VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004, 3581 VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000008, 3582 VK_EXTERNAL_FENCE_HANDLE_TYPE_SCI_SYNC_OBJ_BIT_NV = 0x00000010, 3583 VK_EXTERNAL_FENCE_HANDLE_TYPE_SCI_SYNC_FENCE_BIT_NV = 0x00000020, 3584 VK_EXTERNAL_FENCE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 3585 } VkExternalFenceHandleTypeFlagBits; 3586 typedef VkFlags VkExternalFenceHandleTypeFlags; 3587 3588 typedef enum VkExternalFenceFeatureFlagBits { 3589 VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT = 0x00000001, 3590 VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT = 0x00000002, 3591 VK_EXTERNAL_FENCE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 3592 } VkExternalFenceFeatureFlagBits; 3593 typedef VkFlags VkExternalFenceFeatureFlags; 3594 3595 typedef enum VkFenceImportFlagBits { 3596 VK_FENCE_IMPORT_TEMPORARY_BIT = 0x00000001, 3597 VK_FENCE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 3598 } VkFenceImportFlagBits; 3599 typedef VkFlags VkFenceImportFlags; 3600 3601 typedef enum VkSemaphoreImportFlagBits { 3602 VK_SEMAPHORE_IMPORT_TEMPORARY_BIT = 0x00000001, 3603 VK_SEMAPHORE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 3604 } VkSemaphoreImportFlagBits; 3605 typedef VkFlags VkSemaphoreImportFlags; 3606 3607 typedef enum VkExternalSemaphoreHandleTypeFlagBits { 3608 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001, 3609 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002, 3610 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004, 3611 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT = 0x00000008, 3612 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000010, 3613 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SCI_SYNC_OBJ_BIT_NV = 0x00000020, 3614 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE_BIT = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT, 3615 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 3616 } VkExternalSemaphoreHandleTypeFlagBits; 3617 typedef VkFlags VkExternalSemaphoreHandleTypeFlags; 3618 3619 typedef enum VkExternalSemaphoreFeatureFlagBits { 3620 VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT = 0x00000001, 3621 VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT = 0x00000002, 3622 VK_EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 3623 } VkExternalSemaphoreFeatureFlagBits; 3624 typedef VkFlags VkExternalSemaphoreFeatureFlags; 3625 typedef struct VkPhysicalDeviceSubgroupProperties { 3626 VkStructureType sType; 3627 void* pNext; 3628 uint32_t subgroupSize; 3629 VkShaderStageFlags supportedStages; 3630 VkSubgroupFeatureFlags supportedOperations; 3631 VkBool32 quadOperationsInAllStages; 3632 } VkPhysicalDeviceSubgroupProperties; 3633 3634 typedef struct VkBindBufferMemoryInfo { 3635 VkStructureType sType; 3636 const void* pNext; 3637 VkBuffer buffer; 3638 VkDeviceMemory memory; 3639 VkDeviceSize memoryOffset; 3640 } VkBindBufferMemoryInfo; 3641 3642 typedef struct VkBindImageMemoryInfo { 3643 VkStructureType sType; 3644 const void* pNext; 3645 VkImage image; 3646 VkDeviceMemory memory; 3647 VkDeviceSize memoryOffset; 3648 } VkBindImageMemoryInfo; 3649 3650 typedef struct VkPhysicalDevice16BitStorageFeatures { 3651 VkStructureType sType; 3652 void* pNext; 3653 VkBool32 storageBuffer16BitAccess; 3654 VkBool32 uniformAndStorageBuffer16BitAccess; 3655 VkBool32 storagePushConstant16; 3656 VkBool32 storageInputOutput16; 3657 } VkPhysicalDevice16BitStorageFeatures; 3658 3659 typedef struct VkMemoryDedicatedRequirements { 3660 VkStructureType sType; 3661 void* pNext; 3662 VkBool32 prefersDedicatedAllocation; 3663 VkBool32 requiresDedicatedAllocation; 3664 } VkMemoryDedicatedRequirements; 3665 3666 typedef struct VkMemoryDedicatedAllocateInfo { 3667 VkStructureType sType; 3668 const void* pNext; 3669 VkImage image; 3670 VkBuffer buffer; 3671 } VkMemoryDedicatedAllocateInfo; 3672 3673 typedef struct VkMemoryAllocateFlagsInfo { 3674 VkStructureType sType; 3675 const void* pNext; 3676 VkMemoryAllocateFlags flags; 3677 uint32_t deviceMask; 3678 } VkMemoryAllocateFlagsInfo; 3679 3680 typedef struct VkDeviceGroupRenderPassBeginInfo { 3681 VkStructureType sType; 3682 const void* pNext; 3683 uint32_t deviceMask; 3684 uint32_t deviceRenderAreaCount; 3685 const VkRect2D* pDeviceRenderAreas; 3686 } VkDeviceGroupRenderPassBeginInfo; 3687 3688 typedef struct VkDeviceGroupCommandBufferBeginInfo { 3689 VkStructureType sType; 3690 const void* pNext; 3691 uint32_t deviceMask; 3692 } VkDeviceGroupCommandBufferBeginInfo; 3693 3694 typedef struct VkDeviceGroupSubmitInfo { 3695 VkStructureType sType; 3696 const void* pNext; 3697 uint32_t waitSemaphoreCount; 3698 const uint32_t* pWaitSemaphoreDeviceIndices; 3699 uint32_t commandBufferCount; 3700 const uint32_t* pCommandBufferDeviceMasks; 3701 uint32_t signalSemaphoreCount; 3702 const uint32_t* pSignalSemaphoreDeviceIndices; 3703 } VkDeviceGroupSubmitInfo; 3704 3705 typedef struct VkBindBufferMemoryDeviceGroupInfo { 3706 VkStructureType sType; 3707 const void* pNext; 3708 uint32_t deviceIndexCount; 3709 const uint32_t* pDeviceIndices; 3710 } VkBindBufferMemoryDeviceGroupInfo; 3711 3712 typedef struct VkBindImageMemoryDeviceGroupInfo { 3713 VkStructureType sType; 3714 const void* pNext; 3715 uint32_t deviceIndexCount; 3716 const uint32_t* pDeviceIndices; 3717 uint32_t splitInstanceBindRegionCount; 3718 const VkRect2D* pSplitInstanceBindRegions; 3719 } VkBindImageMemoryDeviceGroupInfo; 3720 3721 typedef struct VkPhysicalDeviceGroupProperties { 3722 VkStructureType sType; 3723 void* pNext; 3724 uint32_t physicalDeviceCount; 3725 VkPhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE]; 3726 VkBool32 subsetAllocation; 3727 } VkPhysicalDeviceGroupProperties; 3728 3729 typedef struct VkDeviceGroupDeviceCreateInfo { 3730 VkStructureType sType; 3731 const void* pNext; 3732 uint32_t physicalDeviceCount; 3733 const VkPhysicalDevice* pPhysicalDevices; 3734 } VkDeviceGroupDeviceCreateInfo; 3735 3736 typedef struct VkBufferMemoryRequirementsInfo2 { 3737 VkStructureType sType; 3738 const void* pNext; 3739 VkBuffer buffer; 3740 } VkBufferMemoryRequirementsInfo2; 3741 3742 typedef struct VkImageMemoryRequirementsInfo2 { 3743 VkStructureType sType; 3744 const void* pNext; 3745 VkImage image; 3746 } VkImageMemoryRequirementsInfo2; 3747 3748 typedef struct VkMemoryRequirements2 { 3749 VkStructureType sType; 3750 void* pNext; 3751 VkMemoryRequirements memoryRequirements; 3752 } VkMemoryRequirements2; 3753 3754 typedef struct VkPhysicalDeviceFeatures2 { 3755 VkStructureType sType; 3756 void* pNext; 3757 VkPhysicalDeviceFeatures features; 3758 } VkPhysicalDeviceFeatures2; 3759 3760 typedef struct VkPhysicalDeviceProperties2 { 3761 VkStructureType sType; 3762 void* pNext; 3763 VkPhysicalDeviceProperties properties; 3764 } VkPhysicalDeviceProperties2; 3765 3766 typedef struct VkFormatProperties2 { 3767 VkStructureType sType; 3768 void* pNext; 3769 VkFormatProperties formatProperties; 3770 } VkFormatProperties2; 3771 3772 typedef struct VkImageFormatProperties2 { 3773 VkStructureType sType; 3774 void* pNext; 3775 VkImageFormatProperties imageFormatProperties; 3776 } VkImageFormatProperties2; 3777 3778 typedef struct VkPhysicalDeviceImageFormatInfo2 { 3779 VkStructureType sType; 3780 const void* pNext; 3781 VkFormat format; 3782 VkImageType type; 3783 VkImageTiling tiling; 3784 VkImageUsageFlags usage; 3785 VkImageCreateFlags flags; 3786 } VkPhysicalDeviceImageFormatInfo2; 3787 3788 typedef struct VkQueueFamilyProperties2 { 3789 VkStructureType sType; 3790 void* pNext; 3791 VkQueueFamilyProperties queueFamilyProperties; 3792 } VkQueueFamilyProperties2; 3793 3794 typedef struct VkPhysicalDeviceMemoryProperties2 { 3795 VkStructureType sType; 3796 void* pNext; 3797 VkPhysicalDeviceMemoryProperties memoryProperties; 3798 } VkPhysicalDeviceMemoryProperties2; 3799 3800 typedef struct VkPhysicalDevicePointClippingProperties { 3801 VkStructureType sType; 3802 void* pNext; 3803 VkPointClippingBehavior pointClippingBehavior; 3804 } VkPhysicalDevicePointClippingProperties; 3805 3806 typedef struct VkInputAttachmentAspectReference { 3807 uint32_t subpass; 3808 uint32_t inputAttachmentIndex; 3809 VkImageAspectFlags aspectMask; 3810 } VkInputAttachmentAspectReference; 3811 3812 typedef struct VkRenderPassInputAttachmentAspectCreateInfo { 3813 VkStructureType sType; 3814 const void* pNext; 3815 uint32_t aspectReferenceCount; 3816 const VkInputAttachmentAspectReference* pAspectReferences; 3817 } VkRenderPassInputAttachmentAspectCreateInfo; 3818 3819 typedef struct VkImageViewUsageCreateInfo { 3820 VkStructureType sType; 3821 const void* pNext; 3822 VkImageUsageFlags usage; 3823 } VkImageViewUsageCreateInfo; 3824 3825 typedef struct VkPipelineTessellationDomainOriginStateCreateInfo { 3826 VkStructureType sType; 3827 const void* pNext; 3828 VkTessellationDomainOrigin domainOrigin; 3829 } VkPipelineTessellationDomainOriginStateCreateInfo; 3830 3831 typedef struct VkRenderPassMultiviewCreateInfo { 3832 VkStructureType sType; 3833 const void* pNext; 3834 uint32_t subpassCount; 3835 const uint32_t* pViewMasks; 3836 uint32_t dependencyCount; 3837 const int32_t* pViewOffsets; 3838 uint32_t correlationMaskCount; 3839 const uint32_t* pCorrelationMasks; 3840 } VkRenderPassMultiviewCreateInfo; 3841 3842 typedef struct VkPhysicalDeviceMultiviewFeatures { 3843 VkStructureType sType; 3844 void* pNext; 3845 VkBool32 multiview; 3846 VkBool32 multiviewGeometryShader; 3847 VkBool32 multiviewTessellationShader; 3848 } VkPhysicalDeviceMultiviewFeatures; 3849 3850 typedef struct VkPhysicalDeviceMultiviewProperties { 3851 VkStructureType sType; 3852 void* pNext; 3853 uint32_t maxMultiviewViewCount; 3854 uint32_t maxMultiviewInstanceIndex; 3855 } VkPhysicalDeviceMultiviewProperties; 3856 3857 typedef struct VkPhysicalDeviceVariablePointersFeatures { 3858 VkStructureType sType; 3859 void* pNext; 3860 VkBool32 variablePointersStorageBuffer; 3861 VkBool32 variablePointers; 3862 } VkPhysicalDeviceVariablePointersFeatures; 3863 3864 typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointerFeatures; 3865 3866 typedef struct VkPhysicalDeviceProtectedMemoryFeatures { 3867 VkStructureType sType; 3868 void* pNext; 3869 VkBool32 protectedMemory; 3870 } VkPhysicalDeviceProtectedMemoryFeatures; 3871 3872 typedef struct VkPhysicalDeviceProtectedMemoryProperties { 3873 VkStructureType sType; 3874 void* pNext; 3875 VkBool32 protectedNoFault; 3876 } VkPhysicalDeviceProtectedMemoryProperties; 3877 3878 typedef struct VkDeviceQueueInfo2 { 3879 VkStructureType sType; 3880 const void* pNext; 3881 VkDeviceQueueCreateFlags flags; 3882 uint32_t queueFamilyIndex; 3883 uint32_t queueIndex; 3884 } VkDeviceQueueInfo2; 3885 3886 typedef struct VkProtectedSubmitInfo { 3887 VkStructureType sType; 3888 const void* pNext; 3889 VkBool32 protectedSubmit; 3890 } VkProtectedSubmitInfo; 3891 3892 typedef struct VkSamplerYcbcrConversionCreateInfo { 3893 VkStructureType sType; 3894 const void* pNext; 3895 VkFormat format; 3896 VkSamplerYcbcrModelConversion ycbcrModel; 3897 VkSamplerYcbcrRange ycbcrRange; 3898 VkComponentMapping components; 3899 VkChromaLocation xChromaOffset; 3900 VkChromaLocation yChromaOffset; 3901 VkFilter chromaFilter; 3902 VkBool32 forceExplicitReconstruction; 3903 } VkSamplerYcbcrConversionCreateInfo; 3904 3905 typedef struct VkSamplerYcbcrConversionInfo { 3906 VkStructureType sType; 3907 const void* pNext; 3908 VkSamplerYcbcrConversion conversion; 3909 } VkSamplerYcbcrConversionInfo; 3910 3911 typedef struct VkBindImagePlaneMemoryInfo { 3912 VkStructureType sType; 3913 const void* pNext; 3914 VkImageAspectFlagBits planeAspect; 3915 } VkBindImagePlaneMemoryInfo; 3916 3917 typedef struct VkImagePlaneMemoryRequirementsInfo { 3918 VkStructureType sType; 3919 const void* pNext; 3920 VkImageAspectFlagBits planeAspect; 3921 } VkImagePlaneMemoryRequirementsInfo; 3922 3923 typedef struct VkPhysicalDeviceSamplerYcbcrConversionFeatures { 3924 VkStructureType sType; 3925 void* pNext; 3926 VkBool32 samplerYcbcrConversion; 3927 } VkPhysicalDeviceSamplerYcbcrConversionFeatures; 3928 3929 typedef struct VkSamplerYcbcrConversionImageFormatProperties { 3930 VkStructureType sType; 3931 void* pNext; 3932 uint32_t combinedImageSamplerDescriptorCount; 3933 } VkSamplerYcbcrConversionImageFormatProperties; 3934 3935 typedef struct VkExternalMemoryProperties { 3936 VkExternalMemoryFeatureFlags externalMemoryFeatures; 3937 VkExternalMemoryHandleTypeFlags exportFromImportedHandleTypes; 3938 VkExternalMemoryHandleTypeFlags compatibleHandleTypes; 3939 } VkExternalMemoryProperties; 3940 3941 typedef struct VkPhysicalDeviceExternalImageFormatInfo { 3942 VkStructureType sType; 3943 const void* pNext; 3944 VkExternalMemoryHandleTypeFlagBits handleType; 3945 } VkPhysicalDeviceExternalImageFormatInfo; 3946 3947 typedef struct VkExternalImageFormatProperties { 3948 VkStructureType sType; 3949 void* pNext; 3950 VkExternalMemoryProperties externalMemoryProperties; 3951 } VkExternalImageFormatProperties; 3952 3953 typedef struct VkPhysicalDeviceExternalBufferInfo { 3954 VkStructureType sType; 3955 const void* pNext; 3956 VkBufferCreateFlags flags; 3957 VkBufferUsageFlags usage; 3958 VkExternalMemoryHandleTypeFlagBits handleType; 3959 } VkPhysicalDeviceExternalBufferInfo; 3960 3961 typedef struct VkExternalBufferProperties { 3962 VkStructureType sType; 3963 void* pNext; 3964 VkExternalMemoryProperties externalMemoryProperties; 3965 } VkExternalBufferProperties; 3966 3967 typedef struct VkPhysicalDeviceIDProperties { 3968 VkStructureType sType; 3969 void* pNext; 3970 uint8_t deviceUUID[VK_UUID_SIZE]; 3971 uint8_t driverUUID[VK_UUID_SIZE]; 3972 uint8_t deviceLUID[VK_LUID_SIZE]; 3973 uint32_t deviceNodeMask; 3974 VkBool32 deviceLUIDValid; 3975 } VkPhysicalDeviceIDProperties; 3976 3977 typedef struct VkExternalMemoryImageCreateInfo { 3978 VkStructureType sType; 3979 const void* pNext; 3980 VkExternalMemoryHandleTypeFlags handleTypes; 3981 } VkExternalMemoryImageCreateInfo; 3982 3983 typedef struct VkExternalMemoryBufferCreateInfo { 3984 VkStructureType sType; 3985 const void* pNext; 3986 VkExternalMemoryHandleTypeFlags handleTypes; 3987 } VkExternalMemoryBufferCreateInfo; 3988 3989 typedef struct VkExportMemoryAllocateInfo { 3990 VkStructureType sType; 3991 const void* pNext; 3992 VkExternalMemoryHandleTypeFlags handleTypes; 3993 } VkExportMemoryAllocateInfo; 3994 3995 typedef struct VkPhysicalDeviceExternalFenceInfo { 3996 VkStructureType sType; 3997 const void* pNext; 3998 VkExternalFenceHandleTypeFlagBits handleType; 3999 } VkPhysicalDeviceExternalFenceInfo; 4000 4001 typedef struct VkExternalFenceProperties { 4002 VkStructureType sType; 4003 void* pNext; 4004 VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes; 4005 VkExternalFenceHandleTypeFlags compatibleHandleTypes; 4006 VkExternalFenceFeatureFlags externalFenceFeatures; 4007 } VkExternalFenceProperties; 4008 4009 typedef struct VkExportFenceCreateInfo { 4010 VkStructureType sType; 4011 const void* pNext; 4012 VkExternalFenceHandleTypeFlags handleTypes; 4013 } VkExportFenceCreateInfo; 4014 4015 typedef struct VkExportSemaphoreCreateInfo { 4016 VkStructureType sType; 4017 const void* pNext; 4018 VkExternalSemaphoreHandleTypeFlags handleTypes; 4019 } VkExportSemaphoreCreateInfo; 4020 4021 typedef struct VkPhysicalDeviceExternalSemaphoreInfo { 4022 VkStructureType sType; 4023 const void* pNext; 4024 VkExternalSemaphoreHandleTypeFlagBits handleType; 4025 } VkPhysicalDeviceExternalSemaphoreInfo; 4026 4027 typedef struct VkExternalSemaphoreProperties { 4028 VkStructureType sType; 4029 void* pNext; 4030 VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes; 4031 VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes; 4032 VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures; 4033 } VkExternalSemaphoreProperties; 4034 4035 typedef struct VkPhysicalDeviceMaintenance3Properties { 4036 VkStructureType sType; 4037 void* pNext; 4038 uint32_t maxPerSetDescriptors; 4039 VkDeviceSize maxMemoryAllocationSize; 4040 } VkPhysicalDeviceMaintenance3Properties; 4041 4042 typedef struct VkDescriptorSetLayoutSupport { 4043 VkStructureType sType; 4044 void* pNext; 4045 VkBool32 supported; 4046 } VkDescriptorSetLayoutSupport; 4047 4048 typedef struct VkPhysicalDeviceShaderDrawParametersFeatures { 4049 VkStructureType sType; 4050 void* pNext; 4051 VkBool32 shaderDrawParameters; 4052 } VkPhysicalDeviceShaderDrawParametersFeatures; 4053 4054 typedef VkPhysicalDeviceShaderDrawParametersFeatures VkPhysicalDeviceShaderDrawParameterFeatures; 4055 4056 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceVersion)(uint32_t* pApiVersion); 4057 typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos); 4058 typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos); 4059 typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeatures)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); 4060 typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMask)(VkCommandBuffer commandBuffer, uint32_t deviceMask); 4061 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); 4062 typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroups)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); 4063 typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2)(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); 4064 typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2)(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); 4065 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures); 4066 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties); 4067 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties); 4068 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties); 4069 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties); 4070 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties); 4071 typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue2)(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue); 4072 typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversion)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion); 4073 typedef void (VKAPI_PTR *PFN_vkDestroySamplerYcbcrConversion)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator); 4074 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties); 4075 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFenceProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties); 4076 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphoreProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties); 4077 typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutSupport)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport); 4078 4079 #ifndef VK_NO_PROTOTYPES 4080 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceVersion( 4081 uint32_t* pApiVersion); 4082 4083 VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2( 4084 VkDevice device, 4085 uint32_t bindInfoCount, 4086 const VkBindBufferMemoryInfo* pBindInfos); 4087 4088 VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2( 4089 VkDevice device, 4090 uint32_t bindInfoCount, 4091 const VkBindImageMemoryInfo* pBindInfos); 4092 4093 VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeatures( 4094 VkDevice device, 4095 uint32_t heapIndex, 4096 uint32_t localDeviceIndex, 4097 uint32_t remoteDeviceIndex, 4098 VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); 4099 4100 VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMask( 4101 VkCommandBuffer commandBuffer, 4102 uint32_t deviceMask); 4103 4104 VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBase( 4105 VkCommandBuffer commandBuffer, 4106 uint32_t baseGroupX, 4107 uint32_t baseGroupY, 4108 uint32_t baseGroupZ, 4109 uint32_t groupCountX, 4110 uint32_t groupCountY, 4111 uint32_t groupCountZ); 4112 4113 VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroups( 4114 VkInstance instance, 4115 uint32_t* pPhysicalDeviceGroupCount, 4116 VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); 4117 4118 VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2( 4119 VkDevice device, 4120 const VkImageMemoryRequirementsInfo2* pInfo, 4121 VkMemoryRequirements2* pMemoryRequirements); 4122 4123 VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2( 4124 VkDevice device, 4125 const VkBufferMemoryRequirementsInfo2* pInfo, 4126 VkMemoryRequirements2* pMemoryRequirements); 4127 4128 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2( 4129 VkPhysicalDevice physicalDevice, 4130 VkPhysicalDeviceFeatures2* pFeatures); 4131 4132 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2( 4133 VkPhysicalDevice physicalDevice, 4134 VkPhysicalDeviceProperties2* pProperties); 4135 4136 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2( 4137 VkPhysicalDevice physicalDevice, 4138 VkFormat format, 4139 VkFormatProperties2* pFormatProperties); 4140 4141 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2( 4142 VkPhysicalDevice physicalDevice, 4143 const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, 4144 VkImageFormatProperties2* pImageFormatProperties); 4145 4146 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2( 4147 VkPhysicalDevice physicalDevice, 4148 uint32_t* pQueueFamilyPropertyCount, 4149 VkQueueFamilyProperties2* pQueueFamilyProperties); 4150 4151 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2( 4152 VkPhysicalDevice physicalDevice, 4153 VkPhysicalDeviceMemoryProperties2* pMemoryProperties); 4154 4155 VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue2( 4156 VkDevice device, 4157 const VkDeviceQueueInfo2* pQueueInfo, 4158 VkQueue* pQueue); 4159 4160 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversion( 4161 VkDevice device, 4162 const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, 4163 const VkAllocationCallbacks* pAllocator, 4164 VkSamplerYcbcrConversion* pYcbcrConversion); 4165 4166 VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversion( 4167 VkDevice device, 4168 VkSamplerYcbcrConversion ycbcrConversion, 4169 const VkAllocationCallbacks* pAllocator); 4170 4171 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferProperties( 4172 VkPhysicalDevice physicalDevice, 4173 const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, 4174 VkExternalBufferProperties* pExternalBufferProperties); 4175 4176 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFenceProperties( 4177 VkPhysicalDevice physicalDevice, 4178 const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, 4179 VkExternalFenceProperties* pExternalFenceProperties); 4180 4181 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphoreProperties( 4182 VkPhysicalDevice physicalDevice, 4183 const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, 4184 VkExternalSemaphoreProperties* pExternalSemaphoreProperties); 4185 4186 VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupport( 4187 VkDevice device, 4188 const VkDescriptorSetLayoutCreateInfo* pCreateInfo, 4189 VkDescriptorSetLayoutSupport* pSupport); 4190 #endif 4191 4192 4193 #define VK_VERSION_1_2 1 4194 // Vulkan 1.2 version number 4195 #define VK_API_VERSION_1_2 VK_MAKE_API_VERSION(0, 1, 2, 0)// Patch version should always be set to 0 4196 4197 #define VK_MAX_DRIVER_NAME_SIZE 256U 4198 #define VK_MAX_DRIVER_INFO_SIZE 256U 4199 4200 typedef enum VkDriverId { 4201 VK_DRIVER_ID_AMD_PROPRIETARY = 1, 4202 VK_DRIVER_ID_AMD_OPEN_SOURCE = 2, 4203 VK_DRIVER_ID_MESA_RADV = 3, 4204 VK_DRIVER_ID_NVIDIA_PROPRIETARY = 4, 4205 VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS = 5, 4206 VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA = 6, 4207 VK_DRIVER_ID_IMAGINATION_PROPRIETARY = 7, 4208 VK_DRIVER_ID_QUALCOMM_PROPRIETARY = 8, 4209 VK_DRIVER_ID_ARM_PROPRIETARY = 9, 4210 VK_DRIVER_ID_GOOGLE_SWIFTSHADER = 10, 4211 VK_DRIVER_ID_GGP_PROPRIETARY = 11, 4212 VK_DRIVER_ID_BROADCOM_PROPRIETARY = 12, 4213 VK_DRIVER_ID_MESA_LLVMPIPE = 13, 4214 VK_DRIVER_ID_MOLTENVK = 14, 4215 VK_DRIVER_ID_COREAVI_PROPRIETARY = 15, 4216 VK_DRIVER_ID_JUICE_PROPRIETARY = 16, 4217 VK_DRIVER_ID_VERISILICON_PROPRIETARY = 17, 4218 VK_DRIVER_ID_MESA_TURNIP = 18, 4219 VK_DRIVER_ID_MESA_V3DV = 19, 4220 VK_DRIVER_ID_MESA_PANVK = 20, 4221 VK_DRIVER_ID_SAMSUNG_PROPRIETARY = 21, 4222 VK_DRIVER_ID_MAX_ENUM = 0x7FFFFFFF 4223 } VkDriverId; 4224 4225 typedef enum VkShaderFloatControlsIndependence { 4226 VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY = 0, 4227 VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL = 1, 4228 VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE = 2, 4229 VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_MAX_ENUM = 0x7FFFFFFF 4230 } VkShaderFloatControlsIndependence; 4231 4232 typedef enum VkSamplerReductionMode { 4233 VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE = 0, 4234 VK_SAMPLER_REDUCTION_MODE_MIN = 1, 4235 VK_SAMPLER_REDUCTION_MODE_MAX = 2, 4236 VK_SAMPLER_REDUCTION_MODE_MAX_ENUM = 0x7FFFFFFF 4237 } VkSamplerReductionMode; 4238 4239 typedef enum VkSemaphoreType { 4240 VK_SEMAPHORE_TYPE_BINARY = 0, 4241 VK_SEMAPHORE_TYPE_TIMELINE = 1, 4242 VK_SEMAPHORE_TYPE_MAX_ENUM = 0x7FFFFFFF 4243 } VkSemaphoreType; 4244 4245 typedef enum VkResolveModeFlagBits { 4246 VK_RESOLVE_MODE_NONE = 0, 4247 VK_RESOLVE_MODE_SAMPLE_ZERO_BIT = 0x00000001, 4248 VK_RESOLVE_MODE_AVERAGE_BIT = 0x00000002, 4249 VK_RESOLVE_MODE_MIN_BIT = 0x00000004, 4250 VK_RESOLVE_MODE_MAX_BIT = 0x00000008, 4251 VK_RESOLVE_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 4252 } VkResolveModeFlagBits; 4253 typedef VkFlags VkResolveModeFlags; 4254 4255 typedef enum VkDescriptorBindingFlagBits { 4256 VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT = 0x00000001, 4257 VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT = 0x00000002, 4258 VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT = 0x00000004, 4259 VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT = 0x00000008, 4260 VK_DESCRIPTOR_BINDING_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 4261 } VkDescriptorBindingFlagBits; 4262 typedef VkFlags VkDescriptorBindingFlags; 4263 4264 typedef enum VkSemaphoreWaitFlagBits { 4265 VK_SEMAPHORE_WAIT_ANY_BIT = 0x00000001, 4266 VK_SEMAPHORE_WAIT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 4267 } VkSemaphoreWaitFlagBits; 4268 typedef VkFlags VkSemaphoreWaitFlags; 4269 typedef struct VkPhysicalDeviceVulkan11Features { 4270 VkStructureType sType; 4271 void* pNext; 4272 VkBool32 storageBuffer16BitAccess; 4273 VkBool32 uniformAndStorageBuffer16BitAccess; 4274 VkBool32 storagePushConstant16; 4275 VkBool32 storageInputOutput16; 4276 VkBool32 multiview; 4277 VkBool32 multiviewGeometryShader; 4278 VkBool32 multiviewTessellationShader; 4279 VkBool32 variablePointersStorageBuffer; 4280 VkBool32 variablePointers; 4281 VkBool32 protectedMemory; 4282 VkBool32 samplerYcbcrConversion; 4283 VkBool32 shaderDrawParameters; 4284 } VkPhysicalDeviceVulkan11Features; 4285 4286 typedef struct VkPhysicalDeviceVulkan11Properties { 4287 VkStructureType sType; 4288 void* pNext; 4289 uint8_t deviceUUID[VK_UUID_SIZE]; 4290 uint8_t driverUUID[VK_UUID_SIZE]; 4291 uint8_t deviceLUID[VK_LUID_SIZE]; 4292 uint32_t deviceNodeMask; 4293 VkBool32 deviceLUIDValid; 4294 uint32_t subgroupSize; 4295 VkShaderStageFlags subgroupSupportedStages; 4296 VkSubgroupFeatureFlags subgroupSupportedOperations; 4297 VkBool32 subgroupQuadOperationsInAllStages; 4298 VkPointClippingBehavior pointClippingBehavior; 4299 uint32_t maxMultiviewViewCount; 4300 uint32_t maxMultiviewInstanceIndex; 4301 VkBool32 protectedNoFault; 4302 uint32_t maxPerSetDescriptors; 4303 VkDeviceSize maxMemoryAllocationSize; 4304 } VkPhysicalDeviceVulkan11Properties; 4305 4306 typedef struct VkPhysicalDeviceVulkan12Features { 4307 VkStructureType sType; 4308 void* pNext; 4309 VkBool32 samplerMirrorClampToEdge; 4310 VkBool32 drawIndirectCount; 4311 VkBool32 storageBuffer8BitAccess; 4312 VkBool32 uniformAndStorageBuffer8BitAccess; 4313 VkBool32 storagePushConstant8; 4314 VkBool32 shaderBufferInt64Atomics; 4315 VkBool32 shaderSharedInt64Atomics; 4316 VkBool32 shaderFloat16; 4317 VkBool32 shaderInt8; 4318 VkBool32 descriptorIndexing; 4319 VkBool32 shaderInputAttachmentArrayDynamicIndexing; 4320 VkBool32 shaderUniformTexelBufferArrayDynamicIndexing; 4321 VkBool32 shaderStorageTexelBufferArrayDynamicIndexing; 4322 VkBool32 shaderUniformBufferArrayNonUniformIndexing; 4323 VkBool32 shaderSampledImageArrayNonUniformIndexing; 4324 VkBool32 shaderStorageBufferArrayNonUniformIndexing; 4325 VkBool32 shaderStorageImageArrayNonUniformIndexing; 4326 VkBool32 shaderInputAttachmentArrayNonUniformIndexing; 4327 VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing; 4328 VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing; 4329 VkBool32 descriptorBindingUniformBufferUpdateAfterBind; 4330 VkBool32 descriptorBindingSampledImageUpdateAfterBind; 4331 VkBool32 descriptorBindingStorageImageUpdateAfterBind; 4332 VkBool32 descriptorBindingStorageBufferUpdateAfterBind; 4333 VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind; 4334 VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind; 4335 VkBool32 descriptorBindingUpdateUnusedWhilePending; 4336 VkBool32 descriptorBindingPartiallyBound; 4337 VkBool32 descriptorBindingVariableDescriptorCount; 4338 VkBool32 runtimeDescriptorArray; 4339 VkBool32 samplerFilterMinmax; 4340 VkBool32 scalarBlockLayout; 4341 VkBool32 imagelessFramebuffer; 4342 VkBool32 uniformBufferStandardLayout; 4343 VkBool32 shaderSubgroupExtendedTypes; 4344 VkBool32 separateDepthStencilLayouts; 4345 VkBool32 hostQueryReset; 4346 VkBool32 timelineSemaphore; 4347 VkBool32 bufferDeviceAddress; 4348 VkBool32 bufferDeviceAddressCaptureReplay; 4349 VkBool32 bufferDeviceAddressMultiDevice; 4350 VkBool32 vulkanMemoryModel; 4351 VkBool32 vulkanMemoryModelDeviceScope; 4352 VkBool32 vulkanMemoryModelAvailabilityVisibilityChains; 4353 VkBool32 shaderOutputViewportIndex; 4354 VkBool32 shaderOutputLayer; 4355 VkBool32 subgroupBroadcastDynamicId; 4356 } VkPhysicalDeviceVulkan12Features; 4357 4358 typedef struct VkConformanceVersion { 4359 uint8_t major; 4360 uint8_t minor; 4361 uint8_t subminor; 4362 uint8_t patch; 4363 } VkConformanceVersion; 4364 4365 typedef struct VkPhysicalDeviceVulkan12Properties { 4366 VkStructureType sType; 4367 void* pNext; 4368 VkDriverId driverID; 4369 char driverName[VK_MAX_DRIVER_NAME_SIZE]; 4370 char driverInfo[VK_MAX_DRIVER_INFO_SIZE]; 4371 VkConformanceVersion conformanceVersion; 4372 VkShaderFloatControlsIndependence denormBehaviorIndependence; 4373 VkShaderFloatControlsIndependence roundingModeIndependence; 4374 VkBool32 shaderSignedZeroInfNanPreserveFloat16; 4375 VkBool32 shaderSignedZeroInfNanPreserveFloat32; 4376 VkBool32 shaderSignedZeroInfNanPreserveFloat64; 4377 VkBool32 shaderDenormPreserveFloat16; 4378 VkBool32 shaderDenormPreserveFloat32; 4379 VkBool32 shaderDenormPreserveFloat64; 4380 VkBool32 shaderDenormFlushToZeroFloat16; 4381 VkBool32 shaderDenormFlushToZeroFloat32; 4382 VkBool32 shaderDenormFlushToZeroFloat64; 4383 VkBool32 shaderRoundingModeRTEFloat16; 4384 VkBool32 shaderRoundingModeRTEFloat32; 4385 VkBool32 shaderRoundingModeRTEFloat64; 4386 VkBool32 shaderRoundingModeRTZFloat16; 4387 VkBool32 shaderRoundingModeRTZFloat32; 4388 VkBool32 shaderRoundingModeRTZFloat64; 4389 uint32_t maxUpdateAfterBindDescriptorsInAllPools; 4390 VkBool32 shaderUniformBufferArrayNonUniformIndexingNative; 4391 VkBool32 shaderSampledImageArrayNonUniformIndexingNative; 4392 VkBool32 shaderStorageBufferArrayNonUniformIndexingNative; 4393 VkBool32 shaderStorageImageArrayNonUniformIndexingNative; 4394 VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative; 4395 VkBool32 robustBufferAccessUpdateAfterBind; 4396 VkBool32 quadDivergentImplicitLod; 4397 uint32_t maxPerStageDescriptorUpdateAfterBindSamplers; 4398 uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers; 4399 uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers; 4400 uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages; 4401 uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages; 4402 uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments; 4403 uint32_t maxPerStageUpdateAfterBindResources; 4404 uint32_t maxDescriptorSetUpdateAfterBindSamplers; 4405 uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers; 4406 uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; 4407 uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers; 4408 uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; 4409 uint32_t maxDescriptorSetUpdateAfterBindSampledImages; 4410 uint32_t maxDescriptorSetUpdateAfterBindStorageImages; 4411 uint32_t maxDescriptorSetUpdateAfterBindInputAttachments; 4412 VkResolveModeFlags supportedDepthResolveModes; 4413 VkResolveModeFlags supportedStencilResolveModes; 4414 VkBool32 independentResolveNone; 4415 VkBool32 independentResolve; 4416 VkBool32 filterMinmaxSingleComponentFormats; 4417 VkBool32 filterMinmaxImageComponentMapping; 4418 uint64_t maxTimelineSemaphoreValueDifference; 4419 VkSampleCountFlags framebufferIntegerColorSampleCounts; 4420 } VkPhysicalDeviceVulkan12Properties; 4421 4422 typedef struct VkImageFormatListCreateInfo { 4423 VkStructureType sType; 4424 const void* pNext; 4425 uint32_t viewFormatCount; 4426 const VkFormat* pViewFormats; 4427 } VkImageFormatListCreateInfo; 4428 4429 typedef struct VkAttachmentDescription2 { 4430 VkStructureType sType; 4431 const void* pNext; 4432 VkAttachmentDescriptionFlags flags; 4433 VkFormat format; 4434 VkSampleCountFlagBits samples; 4435 VkAttachmentLoadOp loadOp; 4436 VkAttachmentStoreOp storeOp; 4437 VkAttachmentLoadOp stencilLoadOp; 4438 VkAttachmentStoreOp stencilStoreOp; 4439 VkImageLayout initialLayout; 4440 VkImageLayout finalLayout; 4441 } VkAttachmentDescription2; 4442 4443 typedef struct VkAttachmentReference2 { 4444 VkStructureType sType; 4445 const void* pNext; 4446 uint32_t attachment; 4447 VkImageLayout layout; 4448 VkImageAspectFlags aspectMask; 4449 } VkAttachmentReference2; 4450 4451 typedef struct VkSubpassDescription2 { 4452 VkStructureType sType; 4453 const void* pNext; 4454 VkSubpassDescriptionFlags flags; 4455 VkPipelineBindPoint pipelineBindPoint; 4456 uint32_t viewMask; 4457 uint32_t inputAttachmentCount; 4458 const VkAttachmentReference2* pInputAttachments; 4459 uint32_t colorAttachmentCount; 4460 const VkAttachmentReference2* pColorAttachments; 4461 const VkAttachmentReference2* pResolveAttachments; 4462 const VkAttachmentReference2* pDepthStencilAttachment; 4463 uint32_t preserveAttachmentCount; 4464 const uint32_t* pPreserveAttachments; 4465 } VkSubpassDescription2; 4466 4467 typedef struct VkSubpassDependency2 { 4468 VkStructureType sType; 4469 const void* pNext; 4470 uint32_t srcSubpass; 4471 uint32_t dstSubpass; 4472 VkPipelineStageFlags srcStageMask; 4473 VkPipelineStageFlags dstStageMask; 4474 VkAccessFlags srcAccessMask; 4475 VkAccessFlags dstAccessMask; 4476 VkDependencyFlags dependencyFlags; 4477 int32_t viewOffset; 4478 } VkSubpassDependency2; 4479 4480 typedef struct VkRenderPassCreateInfo2 { 4481 VkStructureType sType; 4482 const void* pNext; 4483 VkRenderPassCreateFlags flags; 4484 uint32_t attachmentCount; 4485 const VkAttachmentDescription2* pAttachments; 4486 uint32_t subpassCount; 4487 const VkSubpassDescription2* pSubpasses; 4488 uint32_t dependencyCount; 4489 const VkSubpassDependency2* pDependencies; 4490 uint32_t correlatedViewMaskCount; 4491 const uint32_t* pCorrelatedViewMasks; 4492 } VkRenderPassCreateInfo2; 4493 4494 typedef struct VkSubpassBeginInfo { 4495 VkStructureType sType; 4496 const void* pNext; 4497 VkSubpassContents contents; 4498 } VkSubpassBeginInfo; 4499 4500 typedef struct VkSubpassEndInfo { 4501 VkStructureType sType; 4502 const void* pNext; 4503 } VkSubpassEndInfo; 4504 4505 typedef struct VkPhysicalDevice8BitStorageFeatures { 4506 VkStructureType sType; 4507 void* pNext; 4508 VkBool32 storageBuffer8BitAccess; 4509 VkBool32 uniformAndStorageBuffer8BitAccess; 4510 VkBool32 storagePushConstant8; 4511 } VkPhysicalDevice8BitStorageFeatures; 4512 4513 typedef struct VkPhysicalDeviceDriverProperties { 4514 VkStructureType sType; 4515 void* pNext; 4516 VkDriverId driverID; 4517 char driverName[VK_MAX_DRIVER_NAME_SIZE]; 4518 char driverInfo[VK_MAX_DRIVER_INFO_SIZE]; 4519 VkConformanceVersion conformanceVersion; 4520 } VkPhysicalDeviceDriverProperties; 4521 4522 typedef struct VkPhysicalDeviceShaderAtomicInt64Features { 4523 VkStructureType sType; 4524 void* pNext; 4525 VkBool32 shaderBufferInt64Atomics; 4526 VkBool32 shaderSharedInt64Atomics; 4527 } VkPhysicalDeviceShaderAtomicInt64Features; 4528 4529 typedef struct VkPhysicalDeviceShaderFloat16Int8Features { 4530 VkStructureType sType; 4531 void* pNext; 4532 VkBool32 shaderFloat16; 4533 VkBool32 shaderInt8; 4534 } VkPhysicalDeviceShaderFloat16Int8Features; 4535 4536 typedef struct VkPhysicalDeviceFloatControlsProperties { 4537 VkStructureType sType; 4538 void* pNext; 4539 VkShaderFloatControlsIndependence denormBehaviorIndependence; 4540 VkShaderFloatControlsIndependence roundingModeIndependence; 4541 VkBool32 shaderSignedZeroInfNanPreserveFloat16; 4542 VkBool32 shaderSignedZeroInfNanPreserveFloat32; 4543 VkBool32 shaderSignedZeroInfNanPreserveFloat64; 4544 VkBool32 shaderDenormPreserveFloat16; 4545 VkBool32 shaderDenormPreserveFloat32; 4546 VkBool32 shaderDenormPreserveFloat64; 4547 VkBool32 shaderDenormFlushToZeroFloat16; 4548 VkBool32 shaderDenormFlushToZeroFloat32; 4549 VkBool32 shaderDenormFlushToZeroFloat64; 4550 VkBool32 shaderRoundingModeRTEFloat16; 4551 VkBool32 shaderRoundingModeRTEFloat32; 4552 VkBool32 shaderRoundingModeRTEFloat64; 4553 VkBool32 shaderRoundingModeRTZFloat16; 4554 VkBool32 shaderRoundingModeRTZFloat32; 4555 VkBool32 shaderRoundingModeRTZFloat64; 4556 } VkPhysicalDeviceFloatControlsProperties; 4557 4558 typedef struct VkDescriptorSetLayoutBindingFlagsCreateInfo { 4559 VkStructureType sType; 4560 const void* pNext; 4561 uint32_t bindingCount; 4562 const VkDescriptorBindingFlags* pBindingFlags; 4563 } VkDescriptorSetLayoutBindingFlagsCreateInfo; 4564 4565 typedef struct VkPhysicalDeviceDescriptorIndexingFeatures { 4566 VkStructureType sType; 4567 void* pNext; 4568 VkBool32 shaderInputAttachmentArrayDynamicIndexing; 4569 VkBool32 shaderUniformTexelBufferArrayDynamicIndexing; 4570 VkBool32 shaderStorageTexelBufferArrayDynamicIndexing; 4571 VkBool32 shaderUniformBufferArrayNonUniformIndexing; 4572 VkBool32 shaderSampledImageArrayNonUniformIndexing; 4573 VkBool32 shaderStorageBufferArrayNonUniformIndexing; 4574 VkBool32 shaderStorageImageArrayNonUniformIndexing; 4575 VkBool32 shaderInputAttachmentArrayNonUniformIndexing; 4576 VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing; 4577 VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing; 4578 VkBool32 descriptorBindingUniformBufferUpdateAfterBind; 4579 VkBool32 descriptorBindingSampledImageUpdateAfterBind; 4580 VkBool32 descriptorBindingStorageImageUpdateAfterBind; 4581 VkBool32 descriptorBindingStorageBufferUpdateAfterBind; 4582 VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind; 4583 VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind; 4584 VkBool32 descriptorBindingUpdateUnusedWhilePending; 4585 VkBool32 descriptorBindingPartiallyBound; 4586 VkBool32 descriptorBindingVariableDescriptorCount; 4587 VkBool32 runtimeDescriptorArray; 4588 } VkPhysicalDeviceDescriptorIndexingFeatures; 4589 4590 typedef struct VkPhysicalDeviceDescriptorIndexingProperties { 4591 VkStructureType sType; 4592 void* pNext; 4593 uint32_t maxUpdateAfterBindDescriptorsInAllPools; 4594 VkBool32 shaderUniformBufferArrayNonUniformIndexingNative; 4595 VkBool32 shaderSampledImageArrayNonUniformIndexingNative; 4596 VkBool32 shaderStorageBufferArrayNonUniformIndexingNative; 4597 VkBool32 shaderStorageImageArrayNonUniformIndexingNative; 4598 VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative; 4599 VkBool32 robustBufferAccessUpdateAfterBind; 4600 VkBool32 quadDivergentImplicitLod; 4601 uint32_t maxPerStageDescriptorUpdateAfterBindSamplers; 4602 uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers; 4603 uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers; 4604 uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages; 4605 uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages; 4606 uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments; 4607 uint32_t maxPerStageUpdateAfterBindResources; 4608 uint32_t maxDescriptorSetUpdateAfterBindSamplers; 4609 uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers; 4610 uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; 4611 uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers; 4612 uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; 4613 uint32_t maxDescriptorSetUpdateAfterBindSampledImages; 4614 uint32_t maxDescriptorSetUpdateAfterBindStorageImages; 4615 uint32_t maxDescriptorSetUpdateAfterBindInputAttachments; 4616 } VkPhysicalDeviceDescriptorIndexingProperties; 4617 4618 typedef struct VkDescriptorSetVariableDescriptorCountAllocateInfo { 4619 VkStructureType sType; 4620 const void* pNext; 4621 uint32_t descriptorSetCount; 4622 const uint32_t* pDescriptorCounts; 4623 } VkDescriptorSetVariableDescriptorCountAllocateInfo; 4624 4625 typedef struct VkDescriptorSetVariableDescriptorCountLayoutSupport { 4626 VkStructureType sType; 4627 void* pNext; 4628 uint32_t maxVariableDescriptorCount; 4629 } VkDescriptorSetVariableDescriptorCountLayoutSupport; 4630 4631 typedef struct VkSubpassDescriptionDepthStencilResolve { 4632 VkStructureType sType; 4633 const void* pNext; 4634 VkResolveModeFlagBits depthResolveMode; 4635 VkResolveModeFlagBits stencilResolveMode; 4636 const VkAttachmentReference2* pDepthStencilResolveAttachment; 4637 } VkSubpassDescriptionDepthStencilResolve; 4638 4639 typedef struct VkPhysicalDeviceDepthStencilResolveProperties { 4640 VkStructureType sType; 4641 void* pNext; 4642 VkResolveModeFlags supportedDepthResolveModes; 4643 VkResolveModeFlags supportedStencilResolveModes; 4644 VkBool32 independentResolveNone; 4645 VkBool32 independentResolve; 4646 } VkPhysicalDeviceDepthStencilResolveProperties; 4647 4648 typedef struct VkPhysicalDeviceScalarBlockLayoutFeatures { 4649 VkStructureType sType; 4650 void* pNext; 4651 VkBool32 scalarBlockLayout; 4652 } VkPhysicalDeviceScalarBlockLayoutFeatures; 4653 4654 typedef struct VkImageStencilUsageCreateInfo { 4655 VkStructureType sType; 4656 const void* pNext; 4657 VkImageUsageFlags stencilUsage; 4658 } VkImageStencilUsageCreateInfo; 4659 4660 typedef struct VkSamplerReductionModeCreateInfo { 4661 VkStructureType sType; 4662 const void* pNext; 4663 VkSamplerReductionMode reductionMode; 4664 } VkSamplerReductionModeCreateInfo; 4665 4666 typedef struct VkPhysicalDeviceSamplerFilterMinmaxProperties { 4667 VkStructureType sType; 4668 void* pNext; 4669 VkBool32 filterMinmaxSingleComponentFormats; 4670 VkBool32 filterMinmaxImageComponentMapping; 4671 } VkPhysicalDeviceSamplerFilterMinmaxProperties; 4672 4673 typedef struct VkPhysicalDeviceVulkanMemoryModelFeatures { 4674 VkStructureType sType; 4675 void* pNext; 4676 VkBool32 vulkanMemoryModel; 4677 VkBool32 vulkanMemoryModelDeviceScope; 4678 VkBool32 vulkanMemoryModelAvailabilityVisibilityChains; 4679 } VkPhysicalDeviceVulkanMemoryModelFeatures; 4680 4681 typedef struct VkPhysicalDeviceImagelessFramebufferFeatures { 4682 VkStructureType sType; 4683 void* pNext; 4684 VkBool32 imagelessFramebuffer; 4685 } VkPhysicalDeviceImagelessFramebufferFeatures; 4686 4687 typedef struct VkFramebufferAttachmentImageInfo { 4688 VkStructureType sType; 4689 const void* pNext; 4690 VkImageCreateFlags flags; 4691 VkImageUsageFlags usage; 4692 uint32_t width; 4693 uint32_t height; 4694 uint32_t layerCount; 4695 uint32_t viewFormatCount; 4696 const VkFormat* pViewFormats; 4697 } VkFramebufferAttachmentImageInfo; 4698 4699 typedef struct VkFramebufferAttachmentsCreateInfo { 4700 VkStructureType sType; 4701 const void* pNext; 4702 uint32_t attachmentImageInfoCount; 4703 const VkFramebufferAttachmentImageInfo* pAttachmentImageInfos; 4704 } VkFramebufferAttachmentsCreateInfo; 4705 4706 typedef struct VkRenderPassAttachmentBeginInfo { 4707 VkStructureType sType; 4708 const void* pNext; 4709 uint32_t attachmentCount; 4710 const VkImageView* pAttachments; 4711 } VkRenderPassAttachmentBeginInfo; 4712 4713 typedef struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures { 4714 VkStructureType sType; 4715 void* pNext; 4716 VkBool32 uniformBufferStandardLayout; 4717 } VkPhysicalDeviceUniformBufferStandardLayoutFeatures; 4718 4719 typedef struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures { 4720 VkStructureType sType; 4721 void* pNext; 4722 VkBool32 shaderSubgroupExtendedTypes; 4723 } VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures; 4724 4725 typedef struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures { 4726 VkStructureType sType; 4727 void* pNext; 4728 VkBool32 separateDepthStencilLayouts; 4729 } VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures; 4730 4731 typedef struct VkAttachmentReferenceStencilLayout { 4732 VkStructureType sType; 4733 void* pNext; 4734 VkImageLayout stencilLayout; 4735 } VkAttachmentReferenceStencilLayout; 4736 4737 typedef struct VkAttachmentDescriptionStencilLayout { 4738 VkStructureType sType; 4739 void* pNext; 4740 VkImageLayout stencilInitialLayout; 4741 VkImageLayout stencilFinalLayout; 4742 } VkAttachmentDescriptionStencilLayout; 4743 4744 typedef struct VkPhysicalDeviceHostQueryResetFeatures { 4745 VkStructureType sType; 4746 void* pNext; 4747 VkBool32 hostQueryReset; 4748 } VkPhysicalDeviceHostQueryResetFeatures; 4749 4750 typedef struct VkPhysicalDeviceTimelineSemaphoreFeatures { 4751 VkStructureType sType; 4752 void* pNext; 4753 VkBool32 timelineSemaphore; 4754 } VkPhysicalDeviceTimelineSemaphoreFeatures; 4755 4756 typedef struct VkPhysicalDeviceTimelineSemaphoreProperties { 4757 VkStructureType sType; 4758 void* pNext; 4759 uint64_t maxTimelineSemaphoreValueDifference; 4760 } VkPhysicalDeviceTimelineSemaphoreProperties; 4761 4762 typedef struct VkSemaphoreTypeCreateInfo { 4763 VkStructureType sType; 4764 const void* pNext; 4765 VkSemaphoreType semaphoreType; 4766 uint64_t initialValue; 4767 } VkSemaphoreTypeCreateInfo; 4768 4769 typedef struct VkTimelineSemaphoreSubmitInfo { 4770 VkStructureType sType; 4771 const void* pNext; 4772 uint32_t waitSemaphoreValueCount; 4773 const uint64_t* pWaitSemaphoreValues; 4774 uint32_t signalSemaphoreValueCount; 4775 const uint64_t* pSignalSemaphoreValues; 4776 } VkTimelineSemaphoreSubmitInfo; 4777 4778 typedef struct VkSemaphoreWaitInfo { 4779 VkStructureType sType; 4780 const void* pNext; 4781 VkSemaphoreWaitFlags flags; 4782 uint32_t semaphoreCount; 4783 const VkSemaphore* pSemaphores; 4784 const uint64_t* pValues; 4785 } VkSemaphoreWaitInfo; 4786 4787 typedef struct VkSemaphoreSignalInfo { 4788 VkStructureType sType; 4789 const void* pNext; 4790 VkSemaphore semaphore; 4791 uint64_t value; 4792 } VkSemaphoreSignalInfo; 4793 4794 typedef struct VkPhysicalDeviceBufferDeviceAddressFeatures { 4795 VkStructureType sType; 4796 void* pNext; 4797 VkBool32 bufferDeviceAddress; 4798 VkBool32 bufferDeviceAddressCaptureReplay; 4799 VkBool32 bufferDeviceAddressMultiDevice; 4800 } VkPhysicalDeviceBufferDeviceAddressFeatures; 4801 4802 typedef struct VkBufferDeviceAddressInfo { 4803 VkStructureType sType; 4804 const void* pNext; 4805 VkBuffer buffer; 4806 } VkBufferDeviceAddressInfo; 4807 4808 typedef struct VkBufferOpaqueCaptureAddressCreateInfo { 4809 VkStructureType sType; 4810 const void* pNext; 4811 uint64_t opaqueCaptureAddress; 4812 } VkBufferOpaqueCaptureAddressCreateInfo; 4813 4814 typedef struct VkMemoryOpaqueCaptureAddressAllocateInfo { 4815 VkStructureType sType; 4816 const void* pNext; 4817 uint64_t opaqueCaptureAddress; 4818 } VkMemoryOpaqueCaptureAddressAllocateInfo; 4819 4820 typedef struct VkDeviceMemoryOpaqueCaptureAddressInfo { 4821 VkStructureType sType; 4822 const void* pNext; 4823 VkDeviceMemory memory; 4824 } VkDeviceMemoryOpaqueCaptureAddressInfo; 4825 4826 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCount)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); 4827 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCount)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); 4828 typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass2)(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); 4829 typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass2)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo); 4830 typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass2)(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo); 4831 typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass2)(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo); 4832 typedef void (VKAPI_PTR *PFN_vkResetQueryPool)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); 4833 typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreCounterValue)(VkDevice device, VkSemaphore semaphore, uint64_t* pValue); 4834 typedef VkResult (VKAPI_PTR *PFN_vkWaitSemaphores)(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout); 4835 typedef VkResult (VKAPI_PTR *PFN_vkSignalSemaphore)(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo); 4836 typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddress)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); 4837 typedef uint64_t (VKAPI_PTR *PFN_vkGetBufferOpaqueCaptureAddress)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); 4838 typedef uint64_t (VKAPI_PTR *PFN_vkGetDeviceMemoryOpaqueCaptureAddress)(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo); 4839 4840 #ifndef VK_NO_PROTOTYPES 4841 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCount( 4842 VkCommandBuffer commandBuffer, 4843 VkBuffer buffer, 4844 VkDeviceSize offset, 4845 VkBuffer countBuffer, 4846 VkDeviceSize countBufferOffset, 4847 uint32_t maxDrawCount, 4848 uint32_t stride); 4849 4850 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCount( 4851 VkCommandBuffer commandBuffer, 4852 VkBuffer buffer, 4853 VkDeviceSize offset, 4854 VkBuffer countBuffer, 4855 VkDeviceSize countBufferOffset, 4856 uint32_t maxDrawCount, 4857 uint32_t stride); 4858 4859 VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass2( 4860 VkDevice device, 4861 const VkRenderPassCreateInfo2* pCreateInfo, 4862 const VkAllocationCallbacks* pAllocator, 4863 VkRenderPass* pRenderPass); 4864 4865 VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass2( 4866 VkCommandBuffer commandBuffer, 4867 const VkRenderPassBeginInfo* pRenderPassBegin, 4868 const VkSubpassBeginInfo* pSubpassBeginInfo); 4869 4870 VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass2( 4871 VkCommandBuffer commandBuffer, 4872 const VkSubpassBeginInfo* pSubpassBeginInfo, 4873 const VkSubpassEndInfo* pSubpassEndInfo); 4874 4875 VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass2( 4876 VkCommandBuffer commandBuffer, 4877 const VkSubpassEndInfo* pSubpassEndInfo); 4878 4879 VKAPI_ATTR void VKAPI_CALL vkResetQueryPool( 4880 VkDevice device, 4881 VkQueryPool queryPool, 4882 uint32_t firstQuery, 4883 uint32_t queryCount); 4884 4885 VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreCounterValue( 4886 VkDevice device, 4887 VkSemaphore semaphore, 4888 uint64_t* pValue); 4889 4890 VKAPI_ATTR VkResult VKAPI_CALL vkWaitSemaphores( 4891 VkDevice device, 4892 const VkSemaphoreWaitInfo* pWaitInfo, 4893 uint64_t timeout); 4894 4895 VKAPI_ATTR VkResult VKAPI_CALL vkSignalSemaphore( 4896 VkDevice device, 4897 const VkSemaphoreSignalInfo* pSignalInfo); 4898 4899 VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddress( 4900 VkDevice device, 4901 const VkBufferDeviceAddressInfo* pInfo); 4902 4903 VKAPI_ATTR uint64_t VKAPI_CALL vkGetBufferOpaqueCaptureAddress( 4904 VkDevice device, 4905 const VkBufferDeviceAddressInfo* pInfo); 4906 4907 VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceMemoryOpaqueCaptureAddress( 4908 VkDevice device, 4909 const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo); 4910 #endif 4911 4912 4913 #define VKSC_VERSION_1_0 1 4914 // Vulkan SC 1.0 version number 4915 #define VKSC_API_VERSION_1_0 VK_MAKE_API_VERSION(VKSC_API_VARIANT, 1, 0, 0)// Patch version should always be set to 0 4916 4917 4918 typedef enum VkFaultLevel { 4919 VK_FAULT_LEVEL_UNASSIGNED = 0, 4920 VK_FAULT_LEVEL_CRITICAL = 1, 4921 VK_FAULT_LEVEL_RECOVERABLE = 2, 4922 VK_FAULT_LEVEL_WARNING = 3, 4923 VK_FAULT_LEVEL_MAX_ENUM = 0x7FFFFFFF 4924 } VkFaultLevel; 4925 4926 typedef enum VkFaultType { 4927 VK_FAULT_TYPE_INVALID = 0, 4928 VK_FAULT_TYPE_UNASSIGNED = 1, 4929 VK_FAULT_TYPE_IMPLEMENTATION = 2, 4930 VK_FAULT_TYPE_SYSTEM = 3, 4931 VK_FAULT_TYPE_PHYSICAL_DEVICE = 4, 4932 VK_FAULT_TYPE_COMMAND_BUFFER_FULL = 5, 4933 VK_FAULT_TYPE_INVALID_API_USAGE = 6, 4934 VK_FAULT_TYPE_MAX_ENUM = 0x7FFFFFFF 4935 } VkFaultType; 4936 4937 typedef enum VkFaultQueryBehavior { 4938 VK_FAULT_QUERY_BEHAVIOR_GET_AND_CLEAR_ALL_FAULTS = 0, 4939 VK_FAULT_QUERY_BEHAVIOR_MAX_ENUM = 0x7FFFFFFF 4940 } VkFaultQueryBehavior; 4941 4942 typedef enum VkPipelineMatchControl { 4943 VK_PIPELINE_MATCH_CONTROL_APPLICATION_UUID_EXACT_MATCH = 0, 4944 VK_PIPELINE_MATCH_CONTROL_MAX_ENUM = 0x7FFFFFFF 4945 } VkPipelineMatchControl; 4946 4947 typedef enum VkPipelineCacheValidationVersion { 4948 VK_PIPELINE_CACHE_VALIDATION_VERSION_SAFETY_CRITICAL_ONE = 1, 4949 VK_PIPELINE_CACHE_VALIDATION_VERSION_MAX_ENUM = 0x7FFFFFFF 4950 } VkPipelineCacheValidationVersion; 4951 typedef struct VkPhysicalDeviceVulkanSC10Features { 4952 VkStructureType sType; 4953 void* pNext; 4954 VkBool32 shaderAtomicInstructions; 4955 } VkPhysicalDeviceVulkanSC10Features; 4956 4957 typedef struct VkPhysicalDeviceVulkanSC10Properties { 4958 VkStructureType sType; 4959 void* pNext; 4960 VkBool32 deviceNoDynamicHostAllocations; 4961 VkBool32 deviceDestroyFreesMemory; 4962 VkBool32 commandPoolMultipleCommandBuffersRecording; 4963 VkBool32 commandPoolResetCommandBuffer; 4964 VkBool32 commandBufferSimultaneousUse; 4965 VkBool32 secondaryCommandBufferNullOrImagelessFramebuffer; 4966 VkBool32 recycleDescriptorSetMemory; 4967 VkBool32 recyclePipelineMemory; 4968 uint32_t maxRenderPassSubpasses; 4969 uint32_t maxRenderPassDependencies; 4970 uint32_t maxSubpassInputAttachments; 4971 uint32_t maxSubpassPreserveAttachments; 4972 uint32_t maxFramebufferAttachments; 4973 uint32_t maxDescriptorSetLayoutBindings; 4974 uint32_t maxQueryFaultCount; 4975 uint32_t maxCallbackFaultCount; 4976 uint32_t maxCommandPoolCommandBuffers; 4977 VkDeviceSize maxCommandBufferSize; 4978 } VkPhysicalDeviceVulkanSC10Properties; 4979 4980 typedef struct VkPipelinePoolSize { 4981 VkStructureType sType; 4982 const void* pNext; 4983 VkDeviceSize poolEntrySize; 4984 uint32_t poolEntryCount; 4985 } VkPipelinePoolSize; 4986 4987 typedef struct VkDeviceObjectReservationCreateInfo { 4988 VkStructureType sType; 4989 const void* pNext; 4990 uint32_t pipelineCacheCreateInfoCount; 4991 const VkPipelineCacheCreateInfo* pPipelineCacheCreateInfos; 4992 uint32_t pipelinePoolSizeCount; 4993 const VkPipelinePoolSize* pPipelinePoolSizes; 4994 uint32_t semaphoreRequestCount; 4995 uint32_t commandBufferRequestCount; 4996 uint32_t fenceRequestCount; 4997 uint32_t deviceMemoryRequestCount; 4998 uint32_t bufferRequestCount; 4999 uint32_t imageRequestCount; 5000 uint32_t eventRequestCount; 5001 uint32_t queryPoolRequestCount; 5002 uint32_t bufferViewRequestCount; 5003 uint32_t imageViewRequestCount; 5004 uint32_t layeredImageViewRequestCount; 5005 uint32_t pipelineCacheRequestCount; 5006 uint32_t pipelineLayoutRequestCount; 5007 uint32_t renderPassRequestCount; 5008 uint32_t graphicsPipelineRequestCount; 5009 uint32_t computePipelineRequestCount; 5010 uint32_t descriptorSetLayoutRequestCount; 5011 uint32_t samplerRequestCount; 5012 uint32_t descriptorPoolRequestCount; 5013 uint32_t descriptorSetRequestCount; 5014 uint32_t framebufferRequestCount; 5015 uint32_t commandPoolRequestCount; 5016 uint32_t samplerYcbcrConversionRequestCount; 5017 uint32_t surfaceRequestCount; 5018 uint32_t swapchainRequestCount; 5019 uint32_t displayModeRequestCount; 5020 uint32_t subpassDescriptionRequestCount; 5021 uint32_t attachmentDescriptionRequestCount; 5022 uint32_t descriptorSetLayoutBindingRequestCount; 5023 uint32_t descriptorSetLayoutBindingLimit; 5024 uint32_t maxImageViewMipLevels; 5025 uint32_t maxImageViewArrayLayers; 5026 uint32_t maxLayeredImageViewMipLevels; 5027 uint32_t maxOcclusionQueriesPerPool; 5028 uint32_t maxPipelineStatisticsQueriesPerPool; 5029 uint32_t maxTimestampQueriesPerPool; 5030 uint32_t maxImmutableSamplersPerDescriptorSetLayout; 5031 } VkDeviceObjectReservationCreateInfo; 5032 5033 typedef struct VkCommandPoolMemoryReservationCreateInfo { 5034 VkStructureType sType; 5035 const void* pNext; 5036 VkDeviceSize commandPoolReservedSize; 5037 uint32_t commandPoolMaxCommandBuffers; 5038 } VkCommandPoolMemoryReservationCreateInfo; 5039 5040 typedef struct VkCommandPoolMemoryConsumption { 5041 VkStructureType sType; 5042 void* pNext; 5043 VkDeviceSize commandPoolAllocated; 5044 VkDeviceSize commandPoolReservedSize; 5045 VkDeviceSize commandBufferAllocated; 5046 } VkCommandPoolMemoryConsumption; 5047 5048 typedef struct VkFaultData { 5049 VkStructureType sType; 5050 void* pNext; 5051 VkFaultLevel faultLevel; 5052 VkFaultType faultType; 5053 } VkFaultData; 5054 5055 typedef void (VKAPI_PTR *PFN_vkFaultCallbackFunction)( 5056 VkBool32 unrecordedFaults, 5057 uint32_t faultCount, 5058 const VkFaultData* pFaults); 5059 5060 typedef struct VkFaultCallbackInfo { 5061 VkStructureType sType; 5062 void* pNext; 5063 uint32_t faultCount; 5064 VkFaultData* pFaults; 5065 PFN_vkFaultCallbackFunction pfnFaultCallback; 5066 } VkFaultCallbackInfo; 5067 5068 typedef struct VkPipelineOfflineCreateInfo { 5069 VkStructureType sType; 5070 const void* pNext; 5071 uint8_t pipelineIdentifier[VK_UUID_SIZE]; 5072 VkPipelineMatchControl matchControl; 5073 VkDeviceSize poolEntrySize; 5074 } VkPipelineOfflineCreateInfo; 5075 5076 typedef struct VkPipelineCacheStageValidationIndexEntry { 5077 uint64_t codeSize; 5078 uint64_t codeOffset; 5079 } VkPipelineCacheStageValidationIndexEntry; 5080 5081 typedef struct VkPipelineCacheSafetyCriticalIndexEntry { 5082 uint8_t pipelineIdentifier[VK_UUID_SIZE]; 5083 uint64_t pipelineMemorySize; 5084 uint64_t jsonSize; 5085 uint64_t jsonOffset; 5086 uint32_t stageIndexCount; 5087 uint32_t stageIndexStride; 5088 uint64_t stageIndexOffset; 5089 } VkPipelineCacheSafetyCriticalIndexEntry; 5090 5091 typedef struct VkPipelineCacheHeaderVersionSafetyCriticalOne { 5092 VkPipelineCacheHeaderVersionOne headerVersionOne; 5093 VkPipelineCacheValidationVersion validationVersion; 5094 uint32_t implementationData; 5095 uint32_t pipelineIndexCount; 5096 uint32_t pipelineIndexStride; 5097 uint64_t pipelineIndexOffset; 5098 } VkPipelineCacheHeaderVersionSafetyCriticalOne; 5099 5100 typedef void (VKAPI_PTR *PFN_vkGetCommandPoolMemoryConsumption)(VkDevice device, VkCommandPool commandPool, VkCommandBuffer commandBuffer, VkCommandPoolMemoryConsumption* pConsumption); 5101 typedef VkResult (VKAPI_PTR *PFN_vkGetFaultData)(VkDevice device, VkFaultQueryBehavior faultQueryBehavior, VkBool32* pUnrecordedFaults, uint32_t* pFaultCount, VkFaultData* pFaults); 5102 5103 #ifndef VK_NO_PROTOTYPES 5104 VKAPI_ATTR void VKAPI_CALL vkGetCommandPoolMemoryConsumption( 5105 VkDevice device, 5106 VkCommandPool commandPool, 5107 VkCommandBuffer commandBuffer, 5108 VkCommandPoolMemoryConsumption* pConsumption); 5109 5110 VKAPI_ATTR VkResult VKAPI_CALL vkGetFaultData( 5111 VkDevice device, 5112 VkFaultQueryBehavior faultQueryBehavior, 5113 VkBool32* pUnrecordedFaults, 5114 uint32_t* pFaultCount, 5115 VkFaultData* pFaults); 5116 #endif 5117 5118 5119 #define VK_KHR_surface 1 5120 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR) 5121 #define VK_KHR_SURFACE_SPEC_VERSION 25 5122 #define VK_KHR_SURFACE_EXTENSION_NAME "VK_KHR_surface" 5123 5124 typedef enum VkPresentModeKHR { 5125 VK_PRESENT_MODE_IMMEDIATE_KHR = 0, 5126 VK_PRESENT_MODE_MAILBOX_KHR = 1, 5127 VK_PRESENT_MODE_FIFO_KHR = 2, 5128 VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3, 5129 VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR = 1000111000, 5130 VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR = 1000111001, 5131 VK_PRESENT_MODE_MAX_ENUM_KHR = 0x7FFFFFFF 5132 } VkPresentModeKHR; 5133 5134 typedef enum VkColorSpaceKHR { 5135 VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0, 5136 VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT = 1000104001, 5137 VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT = 1000104002, 5138 VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT = 1000104003, 5139 VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT = 1000104004, 5140 VK_COLOR_SPACE_BT709_LINEAR_EXT = 1000104005, 5141 VK_COLOR_SPACE_BT709_NONLINEAR_EXT = 1000104006, 5142 VK_COLOR_SPACE_BT2020_LINEAR_EXT = 1000104007, 5143 VK_COLOR_SPACE_HDR10_ST2084_EXT = 1000104008, 5144 VK_COLOR_SPACE_DOLBYVISION_EXT = 1000104009, 5145 VK_COLOR_SPACE_HDR10_HLG_EXT = 1000104010, 5146 VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT = 1000104011, 5147 VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT = 1000104012, 5148 VK_COLOR_SPACE_PASS_THROUGH_EXT = 1000104013, 5149 VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT = 1000104014, 5150 VK_COLOR_SPACE_MAX_ENUM_KHR = 0x7FFFFFFF 5151 } VkColorSpaceKHR; 5152 5153 typedef enum VkSurfaceTransformFlagBitsKHR { 5154 VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 0x00000001, 5155 VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 0x00000002, 5156 VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 0x00000004, 5157 VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 0x00000008, 5158 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 0x00000010, 5159 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 0x00000020, 5160 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 0x00000040, 5161 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 0x00000080, 5162 VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100, 5163 VK_SURFACE_TRANSFORM_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 5164 } VkSurfaceTransformFlagBitsKHR; 5165 5166 typedef enum VkCompositeAlphaFlagBitsKHR { 5167 VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, 5168 VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002, 5169 VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004, 5170 VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008, 5171 VK_COMPOSITE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 5172 } VkCompositeAlphaFlagBitsKHR; 5173 typedef VkFlags VkCompositeAlphaFlagsKHR; 5174 typedef VkFlags VkSurfaceTransformFlagsKHR; 5175 typedef struct VkSurfaceCapabilitiesKHR { 5176 uint32_t minImageCount; 5177 uint32_t maxImageCount; 5178 VkExtent2D currentExtent; 5179 VkExtent2D minImageExtent; 5180 VkExtent2D maxImageExtent; 5181 uint32_t maxImageArrayLayers; 5182 VkSurfaceTransformFlagsKHR supportedTransforms; 5183 VkSurfaceTransformFlagBitsKHR currentTransform; 5184 VkCompositeAlphaFlagsKHR supportedCompositeAlpha; 5185 VkImageUsageFlags supportedUsageFlags; 5186 } VkSurfaceCapabilitiesKHR; 5187 5188 typedef struct VkSurfaceFormatKHR { 5189 VkFormat format; 5190 VkColorSpaceKHR colorSpace; 5191 } VkSurfaceFormatKHR; 5192 5193 typedef void (VKAPI_PTR *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator); 5194 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported); 5195 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); 5196 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats); 5197 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes); 5198 5199 #ifndef VK_NO_PROTOTYPES 5200 VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR( 5201 VkInstance instance, 5202 VkSurfaceKHR surface, 5203 const VkAllocationCallbacks* pAllocator); 5204 5205 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR( 5206 VkPhysicalDevice physicalDevice, 5207 uint32_t queueFamilyIndex, 5208 VkSurfaceKHR surface, 5209 VkBool32* pSupported); 5210 5211 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR( 5212 VkPhysicalDevice physicalDevice, 5213 VkSurfaceKHR surface, 5214 VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); 5215 5216 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR( 5217 VkPhysicalDevice physicalDevice, 5218 VkSurfaceKHR surface, 5219 uint32_t* pSurfaceFormatCount, 5220 VkSurfaceFormatKHR* pSurfaceFormats); 5221 5222 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR( 5223 VkPhysicalDevice physicalDevice, 5224 VkSurfaceKHR surface, 5225 uint32_t* pPresentModeCount, 5226 VkPresentModeKHR* pPresentModes); 5227 #endif 5228 5229 5230 #define VK_KHR_swapchain 1 5231 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR) 5232 #define VK_KHR_SWAPCHAIN_SPEC_VERSION 70 5233 #define VK_KHR_SWAPCHAIN_EXTENSION_NAME "VK_KHR_swapchain" 5234 5235 typedef enum VkSwapchainCreateFlagBitsKHR { 5236 VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = 0x00000001, 5237 VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR = 0x00000002, 5238 VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR = 0x00000004, 5239 VK_SWAPCHAIN_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 5240 } VkSwapchainCreateFlagBitsKHR; 5241 typedef VkFlags VkSwapchainCreateFlagsKHR; 5242 5243 typedef enum VkDeviceGroupPresentModeFlagBitsKHR { 5244 VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR = 0x00000001, 5245 VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR = 0x00000002, 5246 VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR = 0x00000004, 5247 VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR = 0x00000008, 5248 VK_DEVICE_GROUP_PRESENT_MODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 5249 } VkDeviceGroupPresentModeFlagBitsKHR; 5250 typedef VkFlags VkDeviceGroupPresentModeFlagsKHR; 5251 typedef struct VkSwapchainCreateInfoKHR { 5252 VkStructureType sType; 5253 const void* pNext; 5254 VkSwapchainCreateFlagsKHR flags; 5255 VkSurfaceKHR surface; 5256 uint32_t minImageCount; 5257 VkFormat imageFormat; 5258 VkColorSpaceKHR imageColorSpace; 5259 VkExtent2D imageExtent; 5260 uint32_t imageArrayLayers; 5261 VkImageUsageFlags imageUsage; 5262 VkSharingMode imageSharingMode; 5263 uint32_t queueFamilyIndexCount; 5264 const uint32_t* pQueueFamilyIndices; 5265 VkSurfaceTransformFlagBitsKHR preTransform; 5266 VkCompositeAlphaFlagBitsKHR compositeAlpha; 5267 VkPresentModeKHR presentMode; 5268 VkBool32 clipped; 5269 VkSwapchainKHR oldSwapchain; 5270 } VkSwapchainCreateInfoKHR; 5271 5272 typedef struct VkPresentInfoKHR { 5273 VkStructureType sType; 5274 const void* pNext; 5275 uint32_t waitSemaphoreCount; 5276 const VkSemaphore* pWaitSemaphores; 5277 uint32_t swapchainCount; 5278 const VkSwapchainKHR* pSwapchains; 5279 const uint32_t* pImageIndices; 5280 VkResult* pResults; 5281 } VkPresentInfoKHR; 5282 5283 typedef struct VkImageSwapchainCreateInfoKHR { 5284 VkStructureType sType; 5285 const void* pNext; 5286 VkSwapchainKHR swapchain; 5287 } VkImageSwapchainCreateInfoKHR; 5288 5289 typedef struct VkBindImageMemorySwapchainInfoKHR { 5290 VkStructureType sType; 5291 const void* pNext; 5292 VkSwapchainKHR swapchain; 5293 uint32_t imageIndex; 5294 } VkBindImageMemorySwapchainInfoKHR; 5295 5296 typedef struct VkAcquireNextImageInfoKHR { 5297 VkStructureType sType; 5298 const void* pNext; 5299 VkSwapchainKHR swapchain; 5300 uint64_t timeout; 5301 VkSemaphore semaphore; 5302 VkFence fence; 5303 uint32_t deviceMask; 5304 } VkAcquireNextImageInfoKHR; 5305 5306 typedef struct VkDeviceGroupPresentCapabilitiesKHR { 5307 VkStructureType sType; 5308 void* pNext; 5309 uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE]; 5310 VkDeviceGroupPresentModeFlagsKHR modes; 5311 } VkDeviceGroupPresentCapabilitiesKHR; 5312 5313 typedef struct VkDeviceGroupPresentInfoKHR { 5314 VkStructureType sType; 5315 const void* pNext; 5316 uint32_t swapchainCount; 5317 const uint32_t* pDeviceMasks; 5318 VkDeviceGroupPresentModeFlagBitsKHR mode; 5319 } VkDeviceGroupPresentInfoKHR; 5320 5321 typedef struct VkDeviceGroupSwapchainCreateInfoKHR { 5322 VkStructureType sType; 5323 const void* pNext; 5324 VkDeviceGroupPresentModeFlagsKHR modes; 5325 } VkDeviceGroupSwapchainCreateInfoKHR; 5326 5327 typedef VkResult (VKAPI_PTR *PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain); 5328 typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages); 5329 typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex); 5330 typedef VkResult (VKAPI_PTR *PFN_vkQueuePresentKHR)(VkQueue queue, const VkPresentInfoKHR* pPresentInfo); 5331 typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupPresentCapabilitiesKHR)(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities); 5332 typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupSurfacePresentModesKHR)(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes); 5333 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDevicePresentRectanglesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects); 5334 typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImage2KHR)(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex); 5335 5336 #ifndef VK_NO_PROTOTYPES 5337 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR( 5338 VkDevice device, 5339 const VkSwapchainCreateInfoKHR* pCreateInfo, 5340 const VkAllocationCallbacks* pAllocator, 5341 VkSwapchainKHR* pSwapchain); 5342 5343 VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR( 5344 VkDevice device, 5345 VkSwapchainKHR swapchain, 5346 uint32_t* pSwapchainImageCount, 5347 VkImage* pSwapchainImages); 5348 5349 VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR( 5350 VkDevice device, 5351 VkSwapchainKHR swapchain, 5352 uint64_t timeout, 5353 VkSemaphore semaphore, 5354 VkFence fence, 5355 uint32_t* pImageIndex); 5356 5357 VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR( 5358 VkQueue queue, 5359 const VkPresentInfoKHR* pPresentInfo); 5360 5361 VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupPresentCapabilitiesKHR( 5362 VkDevice device, 5363 VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities); 5364 5365 VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModesKHR( 5366 VkDevice device, 5367 VkSurfaceKHR surface, 5368 VkDeviceGroupPresentModeFlagsKHR* pModes); 5369 5370 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDevicePresentRectanglesKHR( 5371 VkPhysicalDevice physicalDevice, 5372 VkSurfaceKHR surface, 5373 uint32_t* pRectCount, 5374 VkRect2D* pRects); 5375 5376 VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImage2KHR( 5377 VkDevice device, 5378 const VkAcquireNextImageInfoKHR* pAcquireInfo, 5379 uint32_t* pImageIndex); 5380 #endif 5381 5382 5383 #define VK_KHR_display 1 5384 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR) 5385 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR) 5386 #define VK_KHR_DISPLAY_SPEC_VERSION 23 5387 #define VK_KHR_DISPLAY_EXTENSION_NAME "VK_KHR_display" 5388 typedef VkFlags VkDisplayModeCreateFlagsKHR; 5389 5390 typedef enum VkDisplayPlaneAlphaFlagBitsKHR { 5391 VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, 5392 VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000002, 5393 VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000004, 5394 VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000008, 5395 VK_DISPLAY_PLANE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 5396 } VkDisplayPlaneAlphaFlagBitsKHR; 5397 typedef VkFlags VkDisplayPlaneAlphaFlagsKHR; 5398 typedef VkFlags VkDisplaySurfaceCreateFlagsKHR; 5399 typedef struct VkDisplayModeParametersKHR { 5400 VkExtent2D visibleRegion; 5401 uint32_t refreshRate; 5402 } VkDisplayModeParametersKHR; 5403 5404 typedef struct VkDisplayModeCreateInfoKHR { 5405 VkStructureType sType; 5406 const void* pNext; 5407 VkDisplayModeCreateFlagsKHR flags; 5408 VkDisplayModeParametersKHR parameters; 5409 } VkDisplayModeCreateInfoKHR; 5410 5411 typedef struct VkDisplayModePropertiesKHR { 5412 VkDisplayModeKHR displayMode; 5413 VkDisplayModeParametersKHR parameters; 5414 } VkDisplayModePropertiesKHR; 5415 5416 typedef struct VkDisplayPlaneCapabilitiesKHR { 5417 VkDisplayPlaneAlphaFlagsKHR supportedAlpha; 5418 VkOffset2D minSrcPosition; 5419 VkOffset2D maxSrcPosition; 5420 VkExtent2D minSrcExtent; 5421 VkExtent2D maxSrcExtent; 5422 VkOffset2D minDstPosition; 5423 VkOffset2D maxDstPosition; 5424 VkExtent2D minDstExtent; 5425 VkExtent2D maxDstExtent; 5426 } VkDisplayPlaneCapabilitiesKHR; 5427 5428 typedef struct VkDisplayPlanePropertiesKHR { 5429 VkDisplayKHR currentDisplay; 5430 uint32_t currentStackIndex; 5431 } VkDisplayPlanePropertiesKHR; 5432 5433 typedef struct VkDisplayPropertiesKHR { 5434 VkDisplayKHR display; 5435 const char* displayName; 5436 VkExtent2D physicalDimensions; 5437 VkExtent2D physicalResolution; 5438 VkSurfaceTransformFlagsKHR supportedTransforms; 5439 VkBool32 planeReorderPossible; 5440 VkBool32 persistentContent; 5441 } VkDisplayPropertiesKHR; 5442 5443 typedef struct VkDisplaySurfaceCreateInfoKHR { 5444 VkStructureType sType; 5445 const void* pNext; 5446 VkDisplaySurfaceCreateFlagsKHR flags; 5447 VkDisplayModeKHR displayMode; 5448 uint32_t planeIndex; 5449 uint32_t planeStackIndex; 5450 VkSurfaceTransformFlagBitsKHR transform; 5451 float globalAlpha; 5452 VkDisplayPlaneAlphaFlagBitsKHR alphaMode; 5453 VkExtent2D imageExtent; 5454 } VkDisplaySurfaceCreateInfoKHR; 5455 5456 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties); 5457 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties); 5458 typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays); 5459 typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties); 5460 typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode); 5461 typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities); 5462 typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); 5463 5464 #ifndef VK_NO_PROTOTYPES 5465 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR( 5466 VkPhysicalDevice physicalDevice, 5467 uint32_t* pPropertyCount, 5468 VkDisplayPropertiesKHR* pProperties); 5469 5470 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR( 5471 VkPhysicalDevice physicalDevice, 5472 uint32_t* pPropertyCount, 5473 VkDisplayPlanePropertiesKHR* pProperties); 5474 5475 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR( 5476 VkPhysicalDevice physicalDevice, 5477 uint32_t planeIndex, 5478 uint32_t* pDisplayCount, 5479 VkDisplayKHR* pDisplays); 5480 5481 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR( 5482 VkPhysicalDevice physicalDevice, 5483 VkDisplayKHR display, 5484 uint32_t* pPropertyCount, 5485 VkDisplayModePropertiesKHR* pProperties); 5486 5487 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR( 5488 VkPhysicalDevice physicalDevice, 5489 VkDisplayKHR display, 5490 const VkDisplayModeCreateInfoKHR* pCreateInfo, 5491 const VkAllocationCallbacks* pAllocator, 5492 VkDisplayModeKHR* pMode); 5493 5494 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR( 5495 VkPhysicalDevice physicalDevice, 5496 VkDisplayModeKHR mode, 5497 uint32_t planeIndex, 5498 VkDisplayPlaneCapabilitiesKHR* pCapabilities); 5499 5500 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR( 5501 VkInstance instance, 5502 const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, 5503 const VkAllocationCallbacks* pAllocator, 5504 VkSurfaceKHR* pSurface); 5505 #endif 5506 5507 5508 #define VK_KHR_display_swapchain 1 5509 #define VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION 10 5510 #define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain" 5511 typedef struct VkDisplayPresentInfoKHR { 5512 VkStructureType sType; 5513 const void* pNext; 5514 VkRect2D srcRect; 5515 VkRect2D dstRect; 5516 VkBool32 persistent; 5517 } VkDisplayPresentInfoKHR; 5518 5519 typedef VkResult (VKAPI_PTR *PFN_vkCreateSharedSwapchainsKHR)(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains); 5520 5521 #ifndef VK_NO_PROTOTYPES 5522 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR( 5523 VkDevice device, 5524 uint32_t swapchainCount, 5525 const VkSwapchainCreateInfoKHR* pCreateInfos, 5526 const VkAllocationCallbacks* pAllocator, 5527 VkSwapchainKHR* pSwapchains); 5528 #endif 5529 5530 5531 #define VK_KHR_external_memory_fd 1 5532 #define VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION 1 5533 #define VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME "VK_KHR_external_memory_fd" 5534 typedef struct VkImportMemoryFdInfoKHR { 5535 VkStructureType sType; 5536 const void* pNext; 5537 VkExternalMemoryHandleTypeFlagBits handleType; 5538 int fd; 5539 } VkImportMemoryFdInfoKHR; 5540 5541 typedef struct VkMemoryFdPropertiesKHR { 5542 VkStructureType sType; 5543 void* pNext; 5544 uint32_t memoryTypeBits; 5545 } VkMemoryFdPropertiesKHR; 5546 5547 typedef struct VkMemoryGetFdInfoKHR { 5548 VkStructureType sType; 5549 const void* pNext; 5550 VkDeviceMemory memory; 5551 VkExternalMemoryHandleTypeFlagBits handleType; 5552 } VkMemoryGetFdInfoKHR; 5553 5554 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdKHR)(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd); 5555 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdPropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties); 5556 5557 #ifndef VK_NO_PROTOTYPES 5558 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdKHR( 5559 VkDevice device, 5560 const VkMemoryGetFdInfoKHR* pGetFdInfo, 5561 int* pFd); 5562 5563 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdPropertiesKHR( 5564 VkDevice device, 5565 VkExternalMemoryHandleTypeFlagBits handleType, 5566 int fd, 5567 VkMemoryFdPropertiesKHR* pMemoryFdProperties); 5568 #endif 5569 5570 5571 #define VK_KHR_external_semaphore_fd 1 5572 #define VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION 1 5573 #define VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME "VK_KHR_external_semaphore_fd" 5574 typedef struct VkImportSemaphoreFdInfoKHR { 5575 VkStructureType sType; 5576 const void* pNext; 5577 VkSemaphore semaphore; 5578 VkSemaphoreImportFlags flags; 5579 VkExternalSemaphoreHandleTypeFlagBits handleType; 5580 int fd; 5581 } VkImportSemaphoreFdInfoKHR; 5582 5583 typedef struct VkSemaphoreGetFdInfoKHR { 5584 VkStructureType sType; 5585 const void* pNext; 5586 VkSemaphore semaphore; 5587 VkExternalSemaphoreHandleTypeFlagBits handleType; 5588 } VkSemaphoreGetFdInfoKHR; 5589 5590 typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreFdKHR)(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo); 5591 typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreFdKHR)(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd); 5592 5593 #ifndef VK_NO_PROTOTYPES 5594 VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreFdKHR( 5595 VkDevice device, 5596 const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo); 5597 5598 VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreFdKHR( 5599 VkDevice device, 5600 const VkSemaphoreGetFdInfoKHR* pGetFdInfo, 5601 int* pFd); 5602 #endif 5603 5604 5605 #define VK_KHR_incremental_present 1 5606 #define VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION 2 5607 #define VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME "VK_KHR_incremental_present" 5608 typedef struct VkRectLayerKHR { 5609 VkOffset2D offset; 5610 VkExtent2D extent; 5611 uint32_t layer; 5612 } VkRectLayerKHR; 5613 5614 typedef struct VkPresentRegionKHR { 5615 uint32_t rectangleCount; 5616 const VkRectLayerKHR* pRectangles; 5617 } VkPresentRegionKHR; 5618 5619 typedef struct VkPresentRegionsKHR { 5620 VkStructureType sType; 5621 const void* pNext; 5622 uint32_t swapchainCount; 5623 const VkPresentRegionKHR* pRegions; 5624 } VkPresentRegionsKHR; 5625 5626 5627 5628 #define VK_KHR_shared_presentable_image 1 5629 #define VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION 1 5630 #define VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME "VK_KHR_shared_presentable_image" 5631 typedef struct VkSharedPresentSurfaceCapabilitiesKHR { 5632 VkStructureType sType; 5633 void* pNext; 5634 VkImageUsageFlags sharedPresentSupportedUsageFlags; 5635 } VkSharedPresentSurfaceCapabilitiesKHR; 5636 5637 typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainStatusKHR)(VkDevice device, VkSwapchainKHR swapchain); 5638 5639 #ifndef VK_NO_PROTOTYPES 5640 VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainStatusKHR( 5641 VkDevice device, 5642 VkSwapchainKHR swapchain); 5643 #endif 5644 5645 5646 #define VK_KHR_external_fence_fd 1 5647 #define VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION 1 5648 #define VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME "VK_KHR_external_fence_fd" 5649 typedef struct VkImportFenceFdInfoKHR { 5650 VkStructureType sType; 5651 const void* pNext; 5652 VkFence fence; 5653 VkFenceImportFlags flags; 5654 VkExternalFenceHandleTypeFlagBits handleType; 5655 int fd; 5656 } VkImportFenceFdInfoKHR; 5657 5658 typedef struct VkFenceGetFdInfoKHR { 5659 VkStructureType sType; 5660 const void* pNext; 5661 VkFence fence; 5662 VkExternalFenceHandleTypeFlagBits handleType; 5663 } VkFenceGetFdInfoKHR; 5664 5665 typedef VkResult (VKAPI_PTR *PFN_vkImportFenceFdKHR)(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo); 5666 typedef VkResult (VKAPI_PTR *PFN_vkGetFenceFdKHR)(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd); 5667 5668 #ifndef VK_NO_PROTOTYPES 5669 VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceFdKHR( 5670 VkDevice device, 5671 const VkImportFenceFdInfoKHR* pImportFenceFdInfo); 5672 5673 VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceFdKHR( 5674 VkDevice device, 5675 const VkFenceGetFdInfoKHR* pGetFdInfo, 5676 int* pFd); 5677 #endif 5678 5679 5680 #define VK_KHR_performance_query 1 5681 #define VK_KHR_PERFORMANCE_QUERY_SPEC_VERSION 1 5682 #define VK_KHR_PERFORMANCE_QUERY_EXTENSION_NAME "VK_KHR_performance_query" 5683 5684 typedef enum VkPerformanceCounterUnitKHR { 5685 VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR = 0, 5686 VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR = 1, 5687 VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR = 2, 5688 VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR = 3, 5689 VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR = 4, 5690 VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR = 5, 5691 VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR = 6, 5692 VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR = 7, 5693 VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR = 8, 5694 VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR = 9, 5695 VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR = 10, 5696 VK_PERFORMANCE_COUNTER_UNIT_MAX_ENUM_KHR = 0x7FFFFFFF 5697 } VkPerformanceCounterUnitKHR; 5698 5699 typedef enum VkPerformanceCounterScopeKHR { 5700 VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR = 0, 5701 VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR = 1, 5702 VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR = 2, 5703 VK_QUERY_SCOPE_COMMAND_BUFFER_KHR = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR, 5704 VK_QUERY_SCOPE_RENDER_PASS_KHR = VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR, 5705 VK_QUERY_SCOPE_COMMAND_KHR = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR, 5706 VK_PERFORMANCE_COUNTER_SCOPE_MAX_ENUM_KHR = 0x7FFFFFFF 5707 } VkPerformanceCounterScopeKHR; 5708 5709 typedef enum VkPerformanceCounterStorageKHR { 5710 VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR = 0, 5711 VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR = 1, 5712 VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR = 2, 5713 VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR = 3, 5714 VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR = 4, 5715 VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR = 5, 5716 VK_PERFORMANCE_COUNTER_STORAGE_MAX_ENUM_KHR = 0x7FFFFFFF 5717 } VkPerformanceCounterStorageKHR; 5718 5719 typedef enum VkPerformanceCounterDescriptionFlagBitsKHR { 5720 VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR = 0x00000001, 5721 VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR = 0x00000002, 5722 VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR = VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR, 5723 VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR = VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR, 5724 VK_PERFORMANCE_COUNTER_DESCRIPTION_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 5725 } VkPerformanceCounterDescriptionFlagBitsKHR; 5726 typedef VkFlags VkPerformanceCounterDescriptionFlagsKHR; 5727 5728 typedef enum VkAcquireProfilingLockFlagBitsKHR { 5729 VK_ACQUIRE_PROFILING_LOCK_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 5730 } VkAcquireProfilingLockFlagBitsKHR; 5731 typedef VkFlags VkAcquireProfilingLockFlagsKHR; 5732 typedef struct VkPhysicalDevicePerformanceQueryFeaturesKHR { 5733 VkStructureType sType; 5734 void* pNext; 5735 VkBool32 performanceCounterQueryPools; 5736 VkBool32 performanceCounterMultipleQueryPools; 5737 } VkPhysicalDevicePerformanceQueryFeaturesKHR; 5738 5739 typedef struct VkPhysicalDevicePerformanceQueryPropertiesKHR { 5740 VkStructureType sType; 5741 void* pNext; 5742 VkBool32 allowCommandBufferQueryCopies; 5743 } VkPhysicalDevicePerformanceQueryPropertiesKHR; 5744 5745 typedef struct VkPerformanceCounterKHR { 5746 VkStructureType sType; 5747 void* pNext; 5748 VkPerformanceCounterUnitKHR unit; 5749 VkPerformanceCounterScopeKHR scope; 5750 VkPerformanceCounterStorageKHR storage; 5751 uint8_t uuid[VK_UUID_SIZE]; 5752 } VkPerformanceCounterKHR; 5753 5754 typedef struct VkPerformanceCounterDescriptionKHR { 5755 VkStructureType sType; 5756 void* pNext; 5757 VkPerformanceCounterDescriptionFlagsKHR flags; 5758 char name[VK_MAX_DESCRIPTION_SIZE]; 5759 char category[VK_MAX_DESCRIPTION_SIZE]; 5760 char description[VK_MAX_DESCRIPTION_SIZE]; 5761 } VkPerformanceCounterDescriptionKHR; 5762 5763 typedef struct VkQueryPoolPerformanceCreateInfoKHR { 5764 VkStructureType sType; 5765 const void* pNext; 5766 uint32_t queueFamilyIndex; 5767 uint32_t counterIndexCount; 5768 const uint32_t* pCounterIndices; 5769 } VkQueryPoolPerformanceCreateInfoKHR; 5770 5771 typedef union VkPerformanceCounterResultKHR { 5772 int32_t int32; 5773 int64_t int64; 5774 uint32_t uint32; 5775 uint64_t uint64; 5776 float float32; 5777 double float64; 5778 } VkPerformanceCounterResultKHR; 5779 5780 typedef struct VkAcquireProfilingLockInfoKHR { 5781 VkStructureType sType; 5782 const void* pNext; 5783 VkAcquireProfilingLockFlagsKHR flags; 5784 uint64_t timeout; 5785 } VkAcquireProfilingLockInfoKHR; 5786 5787 typedef struct VkPerformanceQuerySubmitInfoKHR { 5788 VkStructureType sType; 5789 const void* pNext; 5790 uint32_t counterPassIndex; 5791 } VkPerformanceQuerySubmitInfoKHR; 5792 5793 typedef struct VkPerformanceQueryReservationInfoKHR { 5794 VkStructureType sType; 5795 const void* pNext; 5796 uint32_t maxPerformanceQueriesPerPool; 5797 } VkPerformanceQueryReservationInfoKHR; 5798 5799 typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions); 5800 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR)(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses); 5801 typedef VkResult (VKAPI_PTR *PFN_vkAcquireProfilingLockKHR)(VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo); 5802 typedef void (VKAPI_PTR *PFN_vkReleaseProfilingLockKHR)(VkDevice device); 5803 5804 #ifndef VK_NO_PROTOTYPES 5805 VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( 5806 VkPhysicalDevice physicalDevice, 5807 uint32_t queueFamilyIndex, 5808 uint32_t* pCounterCount, 5809 VkPerformanceCounterKHR* pCounters, 5810 VkPerformanceCounterDescriptionKHR* pCounterDescriptions); 5811 5812 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( 5813 VkPhysicalDevice physicalDevice, 5814 const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, 5815 uint32_t* pNumPasses); 5816 5817 VKAPI_ATTR VkResult VKAPI_CALL vkAcquireProfilingLockKHR( 5818 VkDevice device, 5819 const VkAcquireProfilingLockInfoKHR* pInfo); 5820 5821 VKAPI_ATTR void VKAPI_CALL vkReleaseProfilingLockKHR( 5822 VkDevice device); 5823 #endif 5824 5825 5826 #define VK_KHR_get_surface_capabilities2 1 5827 #define VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION 1 5828 #define VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME "VK_KHR_get_surface_capabilities2" 5829 typedef struct VkPhysicalDeviceSurfaceInfo2KHR { 5830 VkStructureType sType; 5831 const void* pNext; 5832 VkSurfaceKHR surface; 5833 } VkPhysicalDeviceSurfaceInfo2KHR; 5834 5835 typedef struct VkSurfaceCapabilities2KHR { 5836 VkStructureType sType; 5837 void* pNext; 5838 VkSurfaceCapabilitiesKHR surfaceCapabilities; 5839 } VkSurfaceCapabilities2KHR; 5840 5841 typedef struct VkSurfaceFormat2KHR { 5842 VkStructureType sType; 5843 void* pNext; 5844 VkSurfaceFormatKHR surfaceFormat; 5845 } VkSurfaceFormat2KHR; 5846 5847 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities); 5848 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormats2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats); 5849 5850 #ifndef VK_NO_PROTOTYPES 5851 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2KHR( 5852 VkPhysicalDevice physicalDevice, 5853 const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, 5854 VkSurfaceCapabilities2KHR* pSurfaceCapabilities); 5855 5856 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormats2KHR( 5857 VkPhysicalDevice physicalDevice, 5858 const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, 5859 uint32_t* pSurfaceFormatCount, 5860 VkSurfaceFormat2KHR* pSurfaceFormats); 5861 #endif 5862 5863 5864 #define VK_KHR_get_display_properties2 1 5865 #define VK_KHR_GET_DISPLAY_PROPERTIES_2_SPEC_VERSION 1 5866 #define VK_KHR_GET_DISPLAY_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_display_properties2" 5867 typedef struct VkDisplayProperties2KHR { 5868 VkStructureType sType; 5869 void* pNext; 5870 VkDisplayPropertiesKHR displayProperties; 5871 } VkDisplayProperties2KHR; 5872 5873 typedef struct VkDisplayPlaneProperties2KHR { 5874 VkStructureType sType; 5875 void* pNext; 5876 VkDisplayPlanePropertiesKHR displayPlaneProperties; 5877 } VkDisplayPlaneProperties2KHR; 5878 5879 typedef struct VkDisplayModeProperties2KHR { 5880 VkStructureType sType; 5881 void* pNext; 5882 VkDisplayModePropertiesKHR displayModeProperties; 5883 } VkDisplayModeProperties2KHR; 5884 5885 typedef struct VkDisplayPlaneInfo2KHR { 5886 VkStructureType sType; 5887 const void* pNext; 5888 VkDisplayModeKHR mode; 5889 uint32_t planeIndex; 5890 } VkDisplayPlaneInfo2KHR; 5891 5892 typedef struct VkDisplayPlaneCapabilities2KHR { 5893 VkStructureType sType; 5894 void* pNext; 5895 VkDisplayPlaneCapabilitiesKHR capabilities; 5896 } VkDisplayPlaneCapabilities2KHR; 5897 5898 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties); 5899 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties); 5900 typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModeProperties2KHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties); 5901 typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities); 5902 5903 #ifndef VK_NO_PROTOTYPES 5904 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayProperties2KHR( 5905 VkPhysicalDevice physicalDevice, 5906 uint32_t* pPropertyCount, 5907 VkDisplayProperties2KHR* pProperties); 5908 5909 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlaneProperties2KHR( 5910 VkPhysicalDevice physicalDevice, 5911 uint32_t* pPropertyCount, 5912 VkDisplayPlaneProperties2KHR* pProperties); 5913 5914 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModeProperties2KHR( 5915 VkPhysicalDevice physicalDevice, 5916 VkDisplayKHR display, 5917 uint32_t* pPropertyCount, 5918 VkDisplayModeProperties2KHR* pProperties); 5919 5920 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilities2KHR( 5921 VkPhysicalDevice physicalDevice, 5922 const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, 5923 VkDisplayPlaneCapabilities2KHR* pCapabilities); 5924 #endif 5925 5926 5927 #define VK_KHR_shader_clock 1 5928 #define VK_KHR_SHADER_CLOCK_SPEC_VERSION 1 5929 #define VK_KHR_SHADER_CLOCK_EXTENSION_NAME "VK_KHR_shader_clock" 5930 typedef struct VkPhysicalDeviceShaderClockFeaturesKHR { 5931 VkStructureType sType; 5932 void* pNext; 5933 VkBool32 shaderSubgroupClock; 5934 VkBool32 shaderDeviceClock; 5935 } VkPhysicalDeviceShaderClockFeaturesKHR; 5936 5937 5938 5939 #define VK_KHR_swapchain_mutable_format 1 5940 #define VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_SPEC_VERSION 1 5941 #define VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME "VK_KHR_swapchain_mutable_format" 5942 5943 5944 #define VK_KHR_shader_terminate_invocation 1 5945 #define VK_KHR_SHADER_TERMINATE_INVOCATION_SPEC_VERSION 1 5946 #define VK_KHR_SHADER_TERMINATE_INVOCATION_EXTENSION_NAME "VK_KHR_shader_terminate_invocation" 5947 typedef struct VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR { 5948 VkStructureType sType; 5949 void* pNext; 5950 VkBool32 shaderTerminateInvocation; 5951 } VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR; 5952 5953 5954 5955 #define VK_KHR_fragment_shading_rate 1 5956 #define VK_KHR_FRAGMENT_SHADING_RATE_SPEC_VERSION 2 5957 #define VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME "VK_KHR_fragment_shading_rate" 5958 5959 typedef enum VkFragmentShadingRateCombinerOpKHR { 5960 VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR = 0, 5961 VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR = 1, 5962 VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR = 2, 5963 VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR = 3, 5964 VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR = 4, 5965 VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_ENUM_KHR = 0x7FFFFFFF 5966 } VkFragmentShadingRateCombinerOpKHR; 5967 typedef struct VkFragmentShadingRateAttachmentInfoKHR { 5968 VkStructureType sType; 5969 const void* pNext; 5970 const VkAttachmentReference2* pFragmentShadingRateAttachment; 5971 VkExtent2D shadingRateAttachmentTexelSize; 5972 } VkFragmentShadingRateAttachmentInfoKHR; 5973 5974 typedef struct VkPipelineFragmentShadingRateStateCreateInfoKHR { 5975 VkStructureType sType; 5976 const void* pNext; 5977 VkExtent2D fragmentSize; 5978 VkFragmentShadingRateCombinerOpKHR combinerOps[2]; 5979 } VkPipelineFragmentShadingRateStateCreateInfoKHR; 5980 5981 typedef struct VkPhysicalDeviceFragmentShadingRateFeaturesKHR { 5982 VkStructureType sType; 5983 void* pNext; 5984 VkBool32 pipelineFragmentShadingRate; 5985 VkBool32 primitiveFragmentShadingRate; 5986 VkBool32 attachmentFragmentShadingRate; 5987 } VkPhysicalDeviceFragmentShadingRateFeaturesKHR; 5988 5989 typedef struct VkPhysicalDeviceFragmentShadingRatePropertiesKHR { 5990 VkStructureType sType; 5991 void* pNext; 5992 VkExtent2D minFragmentShadingRateAttachmentTexelSize; 5993 VkExtent2D maxFragmentShadingRateAttachmentTexelSize; 5994 uint32_t maxFragmentShadingRateAttachmentTexelSizeAspectRatio; 5995 VkBool32 primitiveFragmentShadingRateWithMultipleViewports; 5996 VkBool32 layeredShadingRateAttachments; 5997 VkBool32 fragmentShadingRateNonTrivialCombinerOps; 5998 VkExtent2D maxFragmentSize; 5999 uint32_t maxFragmentSizeAspectRatio; 6000 uint32_t maxFragmentShadingRateCoverageSamples; 6001 VkSampleCountFlagBits maxFragmentShadingRateRasterizationSamples; 6002 VkBool32 fragmentShadingRateWithShaderDepthStencilWrites; 6003 VkBool32 fragmentShadingRateWithSampleMask; 6004 VkBool32 fragmentShadingRateWithShaderSampleMask; 6005 VkBool32 fragmentShadingRateWithConservativeRasterization; 6006 VkBool32 fragmentShadingRateWithFragmentShaderInterlock; 6007 VkBool32 fragmentShadingRateWithCustomSampleLocations; 6008 VkBool32 fragmentShadingRateStrictMultiplyCombiner; 6009 } VkPhysicalDeviceFragmentShadingRatePropertiesKHR; 6010 6011 typedef struct VkPhysicalDeviceFragmentShadingRateKHR { 6012 VkStructureType sType; 6013 void* pNext; 6014 VkSampleCountFlags sampleCounts; 6015 VkExtent2D fragmentSize; 6016 } VkPhysicalDeviceFragmentShadingRateKHR; 6017 6018 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates); 6019 typedef void (VKAPI_PTR *PFN_vkCmdSetFragmentShadingRateKHR)(VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]); 6020 6021 #ifndef VK_NO_PROTOTYPES 6022 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceFragmentShadingRatesKHR( 6023 VkPhysicalDevice physicalDevice, 6024 uint32_t* pFragmentShadingRateCount, 6025 VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates); 6026 6027 VKAPI_ATTR void VKAPI_CALL vkCmdSetFragmentShadingRateKHR( 6028 VkCommandBuffer commandBuffer, 6029 const VkExtent2D* pFragmentSize, 6030 const VkFragmentShadingRateCombinerOpKHR combinerOps[2]); 6031 #endif 6032 6033 6034 #define VK_KHR_object_refresh 1 6035 #define VK_KHR_OBJECT_REFRESH_SPEC_VERSION 1 6036 #define VK_KHR_OBJECT_REFRESH_EXTENSION_NAME "VK_KHR_object_refresh" 6037 6038 typedef enum VkRefreshObjectFlagBitsKHR { 6039 VK_REFRESH_OBJECT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 6040 } VkRefreshObjectFlagBitsKHR; 6041 typedef VkFlags VkRefreshObjectFlagsKHR; 6042 typedef struct VkRefreshObjectKHR { 6043 VkObjectType objectType; 6044 uint64_t objectHandle; 6045 VkRefreshObjectFlagsKHR flags; 6046 } VkRefreshObjectKHR; 6047 6048 typedef struct VkRefreshObjectListKHR { 6049 VkStructureType sType; 6050 const void* pNext; 6051 uint32_t objectCount; 6052 const VkRefreshObjectKHR* pObjects; 6053 } VkRefreshObjectListKHR; 6054 6055 typedef void (VKAPI_PTR *PFN_vkCmdRefreshObjectsKHR)(VkCommandBuffer commandBuffer, const VkRefreshObjectListKHR* pRefreshObjects); 6056 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceRefreshableObjectTypesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pRefreshableObjectTypeCount, VkObjectType* pRefreshableObjectTypes); 6057 6058 #ifndef VK_NO_PROTOTYPES 6059 VKAPI_ATTR void VKAPI_CALL vkCmdRefreshObjectsKHR( 6060 VkCommandBuffer commandBuffer, 6061 const VkRefreshObjectListKHR* pRefreshObjects); 6062 6063 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceRefreshableObjectTypesKHR( 6064 VkPhysicalDevice physicalDevice, 6065 uint32_t* pRefreshableObjectTypeCount, 6066 VkObjectType* pRefreshableObjectTypes); 6067 #endif 6068 6069 6070 #define VK_KHR_synchronization2 1 6071 typedef uint64_t VkFlags64; 6072 #define VK_KHR_SYNCHRONIZATION_2_SPEC_VERSION 1 6073 #define VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME "VK_KHR_synchronization2" 6074 typedef VkFlags64 VkPipelineStageFlags2KHR; 6075 6076 // Flag bits for VkPipelineStageFlagBits2KHR 6077 typedef VkFlags64 VkPipelineStageFlagBits2KHR; 6078 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_NONE_KHR = 0ULL; 6079 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR = 0x00000001ULL; 6080 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR = 0x00000002ULL; 6081 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR = 0x00000004ULL; 6082 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT_KHR = 0x00000008ULL; 6083 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR = 0x00000010ULL; 6084 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR = 0x00000020ULL; 6085 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR = 0x00000040ULL; 6086 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR = 0x00000080ULL; 6087 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR = 0x00000100ULL; 6088 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR = 0x00000200ULL; 6089 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR = 0x00000400ULL; 6090 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT_KHR = 0x00000800ULL; 6091 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR = 0x00001000ULL; 6092 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR = 0x00001000ULL; 6093 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR = 0x00002000ULL; 6094 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_HOST_BIT_KHR = 0x00004000ULL; 6095 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR = 0x00008000ULL; 6096 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR = 0x00010000ULL; 6097 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_COPY_BIT_KHR = 0x100000000ULL; 6098 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR = 0x200000000ULL; 6099 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_BLIT_BIT_KHR = 0x400000000ULL; 6100 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR = 0x800000000ULL; 6101 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR = 0x1000000000ULL; 6102 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR = 0x2000000000ULL; 6103 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR = 0x4000000000ULL; 6104 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT = 0x01000000ULL; 6105 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT = 0x00040000ULL; 6106 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV = 0x00020000ULL; 6107 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00400000ULL; 6108 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV = 0x00400000ULL; 6109 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR = 0x02000000ULL; 6110 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR = 0x00200000ULL; 6111 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_NV = 0x00200000ULL; 6112 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_NV = 0x02000000ULL; 6113 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT = 0x00800000ULL; 6114 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV = 0x00080000ULL; 6115 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV = 0x00100000ULL; 6116 6117 typedef VkFlags64 VkAccessFlags2KHR; 6118 6119 // Flag bits for VkAccessFlagBits2KHR 6120 typedef VkFlags64 VkAccessFlagBits2KHR; 6121 static const VkAccessFlagBits2KHR VK_ACCESS_2_NONE_KHR = 0ULL; 6122 static const VkAccessFlagBits2KHR VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR = 0x00000001ULL; 6123 static const VkAccessFlagBits2KHR VK_ACCESS_2_INDEX_READ_BIT_KHR = 0x00000002ULL; 6124 static const VkAccessFlagBits2KHR VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR = 0x00000004ULL; 6125 static const VkAccessFlagBits2KHR VK_ACCESS_2_UNIFORM_READ_BIT_KHR = 0x00000008ULL; 6126 static const VkAccessFlagBits2KHR VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR = 0x00000010ULL; 6127 static const VkAccessFlagBits2KHR VK_ACCESS_2_SHADER_READ_BIT_KHR = 0x00000020ULL; 6128 static const VkAccessFlagBits2KHR VK_ACCESS_2_SHADER_WRITE_BIT_KHR = 0x00000040ULL; 6129 static const VkAccessFlagBits2KHR VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR = 0x00000080ULL; 6130 static const VkAccessFlagBits2KHR VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR = 0x00000100ULL; 6131 static const VkAccessFlagBits2KHR VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR = 0x00000200ULL; 6132 static const VkAccessFlagBits2KHR VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR = 0x00000400ULL; 6133 static const VkAccessFlagBits2KHR VK_ACCESS_2_TRANSFER_READ_BIT_KHR = 0x00000800ULL; 6134 static const VkAccessFlagBits2KHR VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR = 0x00001000ULL; 6135 static const VkAccessFlagBits2KHR VK_ACCESS_2_HOST_READ_BIT_KHR = 0x00002000ULL; 6136 static const VkAccessFlagBits2KHR VK_ACCESS_2_HOST_WRITE_BIT_KHR = 0x00004000ULL; 6137 static const VkAccessFlagBits2KHR VK_ACCESS_2_MEMORY_READ_BIT_KHR = 0x00008000ULL; 6138 static const VkAccessFlagBits2KHR VK_ACCESS_2_MEMORY_WRITE_BIT_KHR = 0x00010000ULL; 6139 static const VkAccessFlagBits2KHR VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR = 0x100000000ULL; 6140 static const VkAccessFlagBits2KHR VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR = 0x200000000ULL; 6141 static const VkAccessFlagBits2KHR VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR = 0x400000000ULL; 6142 static const VkAccessFlagBits2KHR VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT = 0x02000000ULL; 6143 static const VkAccessFlagBits2KHR VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT = 0x04000000ULL; 6144 static const VkAccessFlagBits2KHR VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT = 0x08000000ULL; 6145 static const VkAccessFlagBits2KHR VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT = 0x00100000ULL; 6146 static const VkAccessFlagBits2KHR VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV = 0x00020000ULL; 6147 static const VkAccessFlagBits2KHR VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV = 0x00040000ULL; 6148 static const VkAccessFlagBits2KHR VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR = 0x00800000ULL; 6149 static const VkAccessFlagBits2KHR VK_ACCESS_2_SHADING_RATE_IMAGE_READ_BIT_NV = 0x00800000ULL; 6150 static const VkAccessFlagBits2KHR VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR = 0x00200000ULL; 6151 static const VkAccessFlagBits2KHR VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR = 0x00400000ULL; 6152 static const VkAccessFlagBits2KHR VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_NV = 0x00200000ULL; 6153 static const VkAccessFlagBits2KHR VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_NV = 0x00400000ULL; 6154 static const VkAccessFlagBits2KHR VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT = 0x01000000ULL; 6155 static const VkAccessFlagBits2KHR VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000ULL; 6156 6157 6158 typedef enum VkSubmitFlagBitsKHR { 6159 VK_SUBMIT_PROTECTED_BIT_KHR = 0x00000001, 6160 VK_SUBMIT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 6161 } VkSubmitFlagBitsKHR; 6162 typedef VkFlags VkSubmitFlagsKHR; 6163 typedef struct VkMemoryBarrier2KHR { 6164 VkStructureType sType; 6165 const void* pNext; 6166 VkPipelineStageFlags2KHR srcStageMask; 6167 VkAccessFlags2KHR srcAccessMask; 6168 VkPipelineStageFlags2KHR dstStageMask; 6169 VkAccessFlags2KHR dstAccessMask; 6170 } VkMemoryBarrier2KHR; 6171 6172 typedef struct VkBufferMemoryBarrier2KHR { 6173 VkStructureType sType; 6174 const void* pNext; 6175 VkPipelineStageFlags2KHR srcStageMask; 6176 VkAccessFlags2KHR srcAccessMask; 6177 VkPipelineStageFlags2KHR dstStageMask; 6178 VkAccessFlags2KHR dstAccessMask; 6179 uint32_t srcQueueFamilyIndex; 6180 uint32_t dstQueueFamilyIndex; 6181 VkBuffer buffer; 6182 VkDeviceSize offset; 6183 VkDeviceSize size; 6184 } VkBufferMemoryBarrier2KHR; 6185 6186 typedef struct VkImageMemoryBarrier2KHR { 6187 VkStructureType sType; 6188 const void* pNext; 6189 VkPipelineStageFlags2KHR srcStageMask; 6190 VkAccessFlags2KHR srcAccessMask; 6191 VkPipelineStageFlags2KHR dstStageMask; 6192 VkAccessFlags2KHR dstAccessMask; 6193 VkImageLayout oldLayout; 6194 VkImageLayout newLayout; 6195 uint32_t srcQueueFamilyIndex; 6196 uint32_t dstQueueFamilyIndex; 6197 VkImage image; 6198 VkImageSubresourceRange subresourceRange; 6199 } VkImageMemoryBarrier2KHR; 6200 6201 typedef struct VkDependencyInfoKHR { 6202 VkStructureType sType; 6203 const void* pNext; 6204 VkDependencyFlags dependencyFlags; 6205 uint32_t memoryBarrierCount; 6206 const VkMemoryBarrier2KHR* pMemoryBarriers; 6207 uint32_t bufferMemoryBarrierCount; 6208 const VkBufferMemoryBarrier2KHR* pBufferMemoryBarriers; 6209 uint32_t imageMemoryBarrierCount; 6210 const VkImageMemoryBarrier2KHR* pImageMemoryBarriers; 6211 } VkDependencyInfoKHR; 6212 6213 typedef struct VkSemaphoreSubmitInfoKHR { 6214 VkStructureType sType; 6215 const void* pNext; 6216 VkSemaphore semaphore; 6217 uint64_t value; 6218 VkPipelineStageFlags2KHR stageMask; 6219 uint32_t deviceIndex; 6220 } VkSemaphoreSubmitInfoKHR; 6221 6222 typedef struct VkCommandBufferSubmitInfoKHR { 6223 VkStructureType sType; 6224 const void* pNext; 6225 VkCommandBuffer commandBuffer; 6226 uint32_t deviceMask; 6227 } VkCommandBufferSubmitInfoKHR; 6228 6229 typedef struct VkSubmitInfo2KHR { 6230 VkStructureType sType; 6231 const void* pNext; 6232 VkSubmitFlagsKHR flags; 6233 uint32_t waitSemaphoreInfoCount; 6234 const VkSemaphoreSubmitInfoKHR* pWaitSemaphoreInfos; 6235 uint32_t commandBufferInfoCount; 6236 const VkCommandBufferSubmitInfoKHR* pCommandBufferInfos; 6237 uint32_t signalSemaphoreInfoCount; 6238 const VkSemaphoreSubmitInfoKHR* pSignalSemaphoreInfos; 6239 } VkSubmitInfo2KHR; 6240 6241 typedef struct VkPhysicalDeviceSynchronization2FeaturesKHR { 6242 VkStructureType sType; 6243 void* pNext; 6244 VkBool32 synchronization2; 6245 } VkPhysicalDeviceSynchronization2FeaturesKHR; 6246 6247 typedef struct VkQueueFamilyCheckpointProperties2NV { 6248 VkStructureType sType; 6249 void* pNext; 6250 VkPipelineStageFlags2KHR checkpointExecutionStageMask; 6251 } VkQueueFamilyCheckpointProperties2NV; 6252 6253 typedef struct VkCheckpointData2NV { 6254 VkStructureType sType; 6255 void* pNext; 6256 VkPipelineStageFlags2KHR stage; 6257 void* pCheckpointMarker; 6258 } VkCheckpointData2NV; 6259 6260 typedef void (VKAPI_PTR *PFN_vkCmdSetEvent2KHR)(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfoKHR* pDependencyInfo); 6261 typedef void (VKAPI_PTR *PFN_vkCmdResetEvent2KHR)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2KHR stageMask); 6262 typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents2KHR)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfoKHR* pDependencyInfos); 6263 typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier2KHR)(VkCommandBuffer commandBuffer, const VkDependencyInfoKHR* pDependencyInfo); 6264 typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp2KHR)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2KHR stage, VkQueryPool queryPool, uint32_t query); 6265 typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit2KHR)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2KHR* pSubmits, VkFence fence); 6266 typedef void (VKAPI_PTR *PFN_vkCmdWriteBufferMarker2AMD)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2KHR stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker); 6267 typedef void (VKAPI_PTR *PFN_vkGetQueueCheckpointData2NV)(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointData2NV* pCheckpointData); 6268 6269 #ifndef VK_NO_PROTOTYPES 6270 VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent2KHR( 6271 VkCommandBuffer commandBuffer, 6272 VkEvent event, 6273 const VkDependencyInfoKHR* pDependencyInfo); 6274 6275 VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent2KHR( 6276 VkCommandBuffer commandBuffer, 6277 VkEvent event, 6278 VkPipelineStageFlags2KHR stageMask); 6279 6280 VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents2KHR( 6281 VkCommandBuffer commandBuffer, 6282 uint32_t eventCount, 6283 const VkEvent* pEvents, 6284 const VkDependencyInfoKHR* pDependencyInfos); 6285 6286 VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier2KHR( 6287 VkCommandBuffer commandBuffer, 6288 const VkDependencyInfoKHR* pDependencyInfo); 6289 6290 VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp2KHR( 6291 VkCommandBuffer commandBuffer, 6292 VkPipelineStageFlags2KHR stage, 6293 VkQueryPool queryPool, 6294 uint32_t query); 6295 6296 VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit2KHR( 6297 VkQueue queue, 6298 uint32_t submitCount, 6299 const VkSubmitInfo2KHR* pSubmits, 6300 VkFence fence); 6301 6302 VKAPI_ATTR void VKAPI_CALL vkCmdWriteBufferMarker2AMD( 6303 VkCommandBuffer commandBuffer, 6304 VkPipelineStageFlags2KHR stage, 6305 VkBuffer dstBuffer, 6306 VkDeviceSize dstOffset, 6307 uint32_t marker); 6308 6309 VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointData2NV( 6310 VkQueue queue, 6311 uint32_t* pCheckpointDataCount, 6312 VkCheckpointData2NV* pCheckpointData); 6313 #endif 6314 6315 6316 #define VK_KHR_copy_commands2 1 6317 #define VK_KHR_COPY_COMMANDS_2_SPEC_VERSION 1 6318 #define VK_KHR_COPY_COMMANDS_2_EXTENSION_NAME "VK_KHR_copy_commands2" 6319 typedef struct VkBufferCopy2KHR { 6320 VkStructureType sType; 6321 const void* pNext; 6322 VkDeviceSize srcOffset; 6323 VkDeviceSize dstOffset; 6324 VkDeviceSize size; 6325 } VkBufferCopy2KHR; 6326 6327 typedef struct VkCopyBufferInfo2KHR { 6328 VkStructureType sType; 6329 const void* pNext; 6330 VkBuffer srcBuffer; 6331 VkBuffer dstBuffer; 6332 uint32_t regionCount; 6333 const VkBufferCopy2KHR* pRegions; 6334 } VkCopyBufferInfo2KHR; 6335 6336 typedef struct VkImageCopy2KHR { 6337 VkStructureType sType; 6338 const void* pNext; 6339 VkImageSubresourceLayers srcSubresource; 6340 VkOffset3D srcOffset; 6341 VkImageSubresourceLayers dstSubresource; 6342 VkOffset3D dstOffset; 6343 VkExtent3D extent; 6344 } VkImageCopy2KHR; 6345 6346 typedef struct VkCopyImageInfo2KHR { 6347 VkStructureType sType; 6348 const void* pNext; 6349 VkImage srcImage; 6350 VkImageLayout srcImageLayout; 6351 VkImage dstImage; 6352 VkImageLayout dstImageLayout; 6353 uint32_t regionCount; 6354 const VkImageCopy2KHR* pRegions; 6355 } VkCopyImageInfo2KHR; 6356 6357 typedef struct VkBufferImageCopy2KHR { 6358 VkStructureType sType; 6359 const void* pNext; 6360 VkDeviceSize bufferOffset; 6361 uint32_t bufferRowLength; 6362 uint32_t bufferImageHeight; 6363 VkImageSubresourceLayers imageSubresource; 6364 VkOffset3D imageOffset; 6365 VkExtent3D imageExtent; 6366 } VkBufferImageCopy2KHR; 6367 6368 typedef struct VkCopyBufferToImageInfo2KHR { 6369 VkStructureType sType; 6370 const void* pNext; 6371 VkBuffer srcBuffer; 6372 VkImage dstImage; 6373 VkImageLayout dstImageLayout; 6374 uint32_t regionCount; 6375 const VkBufferImageCopy2KHR* pRegions; 6376 } VkCopyBufferToImageInfo2KHR; 6377 6378 typedef struct VkCopyImageToBufferInfo2KHR { 6379 VkStructureType sType; 6380 const void* pNext; 6381 VkImage srcImage; 6382 VkImageLayout srcImageLayout; 6383 VkBuffer dstBuffer; 6384 uint32_t regionCount; 6385 const VkBufferImageCopy2KHR* pRegions; 6386 } VkCopyImageToBufferInfo2KHR; 6387 6388 typedef struct VkImageBlit2KHR { 6389 VkStructureType sType; 6390 const void* pNext; 6391 VkImageSubresourceLayers srcSubresource; 6392 VkOffset3D srcOffsets[2]; 6393 VkImageSubresourceLayers dstSubresource; 6394 VkOffset3D dstOffsets[2]; 6395 } VkImageBlit2KHR; 6396 6397 typedef struct VkBlitImageInfo2KHR { 6398 VkStructureType sType; 6399 const void* pNext; 6400 VkImage srcImage; 6401 VkImageLayout srcImageLayout; 6402 VkImage dstImage; 6403 VkImageLayout dstImageLayout; 6404 uint32_t regionCount; 6405 const VkImageBlit2KHR* pRegions; 6406 VkFilter filter; 6407 } VkBlitImageInfo2KHR; 6408 6409 typedef struct VkImageResolve2KHR { 6410 VkStructureType sType; 6411 const void* pNext; 6412 VkImageSubresourceLayers srcSubresource; 6413 VkOffset3D srcOffset; 6414 VkImageSubresourceLayers dstSubresource; 6415 VkOffset3D dstOffset; 6416 VkExtent3D extent; 6417 } VkImageResolve2KHR; 6418 6419 typedef struct VkResolveImageInfo2KHR { 6420 VkStructureType sType; 6421 const void* pNext; 6422 VkImage srcImage; 6423 VkImageLayout srcImageLayout; 6424 VkImage dstImage; 6425 VkImageLayout dstImageLayout; 6426 uint32_t regionCount; 6427 const VkImageResolve2KHR* pRegions; 6428 } VkResolveImageInfo2KHR; 6429 6430 typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer2KHR)(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2KHR* pCopyBufferInfo); 6431 typedef void (VKAPI_PTR *PFN_vkCmdCopyImage2KHR)(VkCommandBuffer commandBuffer, const VkCopyImageInfo2KHR* pCopyImageInfo); 6432 typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage2KHR)(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2KHR* pCopyBufferToImageInfo); 6433 typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer2KHR)(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2KHR* pCopyImageToBufferInfo); 6434 typedef void (VKAPI_PTR *PFN_vkCmdBlitImage2KHR)(VkCommandBuffer commandBuffer, const VkBlitImageInfo2KHR* pBlitImageInfo); 6435 typedef void (VKAPI_PTR *PFN_vkCmdResolveImage2KHR)(VkCommandBuffer commandBuffer, const VkResolveImageInfo2KHR* pResolveImageInfo); 6436 6437 #ifndef VK_NO_PROTOTYPES 6438 VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer2KHR( 6439 VkCommandBuffer commandBuffer, 6440 const VkCopyBufferInfo2KHR* pCopyBufferInfo); 6441 6442 VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage2KHR( 6443 VkCommandBuffer commandBuffer, 6444 const VkCopyImageInfo2KHR* pCopyImageInfo); 6445 6446 VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage2KHR( 6447 VkCommandBuffer commandBuffer, 6448 const VkCopyBufferToImageInfo2KHR* pCopyBufferToImageInfo); 6449 6450 VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer2KHR( 6451 VkCommandBuffer commandBuffer, 6452 const VkCopyImageToBufferInfo2KHR* pCopyImageToBufferInfo); 6453 6454 VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage2KHR( 6455 VkCommandBuffer commandBuffer, 6456 const VkBlitImageInfo2KHR* pBlitImageInfo); 6457 6458 VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage2KHR( 6459 VkCommandBuffer commandBuffer, 6460 const VkResolveImageInfo2KHR* pResolveImageInfo); 6461 #endif 6462 6463 6464 #define VK_EXT_depth_range_unrestricted 1 6465 #define VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION 1 6466 #define VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME "VK_EXT_depth_range_unrestricted" 6467 6468 6469 #define VK_NV_private_vendor_info 1 6470 #define VK_NV_PRIVATE_VENDOR_INFO_SPEC_VERSION 2 6471 #define VK_NV_PRIVATE_VENDOR_INFO_EXTENSION_NAME "VK_NV_private_vendor_info" 6472 6473 6474 #define VK_EXT_texture_compression_astc_hdr 1 6475 #define VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_SPEC_VERSION 1 6476 #define VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME "VK_EXT_texture_compression_astc_hdr" 6477 typedef struct VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT { 6478 VkStructureType sType; 6479 void* pNext; 6480 VkBool32 textureCompressionASTC_HDR; 6481 } VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT; 6482 6483 6484 6485 #define VK_EXT_astc_decode_mode 1 6486 #define VK_EXT_ASTC_DECODE_MODE_SPEC_VERSION 1 6487 #define VK_EXT_ASTC_DECODE_MODE_EXTENSION_NAME "VK_EXT_astc_decode_mode" 6488 typedef struct VkImageViewASTCDecodeModeEXT { 6489 VkStructureType sType; 6490 const void* pNext; 6491 VkFormat decodeMode; 6492 } VkImageViewASTCDecodeModeEXT; 6493 6494 typedef struct VkPhysicalDeviceASTCDecodeFeaturesEXT { 6495 VkStructureType sType; 6496 void* pNext; 6497 VkBool32 decodeModeSharedExponent; 6498 } VkPhysicalDeviceASTCDecodeFeaturesEXT; 6499 6500 6501 6502 #define VK_EXT_direct_mode_display 1 6503 #define VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION 1 6504 #define VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME "VK_EXT_direct_mode_display" 6505 typedef VkResult (VKAPI_PTR *PFN_vkReleaseDisplayEXT)(VkPhysicalDevice physicalDevice, VkDisplayKHR display); 6506 6507 #ifndef VK_NO_PROTOTYPES 6508 VKAPI_ATTR VkResult VKAPI_CALL vkReleaseDisplayEXT( 6509 VkPhysicalDevice physicalDevice, 6510 VkDisplayKHR display); 6511 #endif 6512 6513 6514 #define VK_EXT_display_surface_counter 1 6515 #define VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION 1 6516 #define VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME "VK_EXT_display_surface_counter" 6517 6518 typedef enum VkSurfaceCounterFlagBitsEXT { 6519 VK_SURFACE_COUNTER_VBLANK_BIT_EXT = 0x00000001, 6520 VK_SURFACE_COUNTER_VBLANK_EXT = VK_SURFACE_COUNTER_VBLANK_BIT_EXT, 6521 VK_SURFACE_COUNTER_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF 6522 } VkSurfaceCounterFlagBitsEXT; 6523 typedef VkFlags VkSurfaceCounterFlagsEXT; 6524 typedef struct VkSurfaceCapabilities2EXT { 6525 VkStructureType sType; 6526 void* pNext; 6527 uint32_t minImageCount; 6528 uint32_t maxImageCount; 6529 VkExtent2D currentExtent; 6530 VkExtent2D minImageExtent; 6531 VkExtent2D maxImageExtent; 6532 uint32_t maxImageArrayLayers; 6533 VkSurfaceTransformFlagsKHR supportedTransforms; 6534 VkSurfaceTransformFlagBitsKHR currentTransform; 6535 VkCompositeAlphaFlagsKHR supportedCompositeAlpha; 6536 VkImageUsageFlags supportedUsageFlags; 6537 VkSurfaceCounterFlagsEXT supportedSurfaceCounters; 6538 } VkSurfaceCapabilities2EXT; 6539 6540 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities); 6541 6542 #ifndef VK_NO_PROTOTYPES 6543 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2EXT( 6544 VkPhysicalDevice physicalDevice, 6545 VkSurfaceKHR surface, 6546 VkSurfaceCapabilities2EXT* pSurfaceCapabilities); 6547 #endif 6548 6549 6550 #define VK_EXT_display_control 1 6551 #define VK_EXT_DISPLAY_CONTROL_SPEC_VERSION 1 6552 #define VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME "VK_EXT_display_control" 6553 6554 typedef enum VkDisplayPowerStateEXT { 6555 VK_DISPLAY_POWER_STATE_OFF_EXT = 0, 6556 VK_DISPLAY_POWER_STATE_SUSPEND_EXT = 1, 6557 VK_DISPLAY_POWER_STATE_ON_EXT = 2, 6558 VK_DISPLAY_POWER_STATE_MAX_ENUM_EXT = 0x7FFFFFFF 6559 } VkDisplayPowerStateEXT; 6560 6561 typedef enum VkDeviceEventTypeEXT { 6562 VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT = 0, 6563 VK_DEVICE_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF 6564 } VkDeviceEventTypeEXT; 6565 6566 typedef enum VkDisplayEventTypeEXT { 6567 VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT = 0, 6568 VK_DISPLAY_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF 6569 } VkDisplayEventTypeEXT; 6570 typedef struct VkDisplayPowerInfoEXT { 6571 VkStructureType sType; 6572 const void* pNext; 6573 VkDisplayPowerStateEXT powerState; 6574 } VkDisplayPowerInfoEXT; 6575 6576 typedef struct VkDeviceEventInfoEXT { 6577 VkStructureType sType; 6578 const void* pNext; 6579 VkDeviceEventTypeEXT deviceEvent; 6580 } VkDeviceEventInfoEXT; 6581 6582 typedef struct VkDisplayEventInfoEXT { 6583 VkStructureType sType; 6584 const void* pNext; 6585 VkDisplayEventTypeEXT displayEvent; 6586 } VkDisplayEventInfoEXT; 6587 6588 typedef struct VkSwapchainCounterCreateInfoEXT { 6589 VkStructureType sType; 6590 const void* pNext; 6591 VkSurfaceCounterFlagsEXT surfaceCounters; 6592 } VkSwapchainCounterCreateInfoEXT; 6593 6594 typedef VkResult (VKAPI_PTR *PFN_vkDisplayPowerControlEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo); 6595 typedef VkResult (VKAPI_PTR *PFN_vkRegisterDeviceEventEXT)(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); 6596 typedef VkResult (VKAPI_PTR *PFN_vkRegisterDisplayEventEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); 6597 typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainCounterEXT)(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue); 6598 6599 #ifndef VK_NO_PROTOTYPES 6600 VKAPI_ATTR VkResult VKAPI_CALL vkDisplayPowerControlEXT( 6601 VkDevice device, 6602 VkDisplayKHR display, 6603 const VkDisplayPowerInfoEXT* pDisplayPowerInfo); 6604 6605 VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDeviceEventEXT( 6606 VkDevice device, 6607 const VkDeviceEventInfoEXT* pDeviceEventInfo, 6608 const VkAllocationCallbacks* pAllocator, 6609 VkFence* pFence); 6610 6611 VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDisplayEventEXT( 6612 VkDevice device, 6613 VkDisplayKHR display, 6614 const VkDisplayEventInfoEXT* pDisplayEventInfo, 6615 const VkAllocationCallbacks* pAllocator, 6616 VkFence* pFence); 6617 6618 VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainCounterEXT( 6619 VkDevice device, 6620 VkSwapchainKHR swapchain, 6621 VkSurfaceCounterFlagBitsEXT counter, 6622 uint64_t* pCounterValue); 6623 #endif 6624 6625 6626 #define VK_EXT_discard_rectangles 1 6627 #define VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION 1 6628 #define VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME "VK_EXT_discard_rectangles" 6629 6630 typedef enum VkDiscardRectangleModeEXT { 6631 VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = 0, 6632 VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = 1, 6633 VK_DISCARD_RECTANGLE_MODE_MAX_ENUM_EXT = 0x7FFFFFFF 6634 } VkDiscardRectangleModeEXT; 6635 typedef VkFlags VkPipelineDiscardRectangleStateCreateFlagsEXT; 6636 typedef struct VkPhysicalDeviceDiscardRectanglePropertiesEXT { 6637 VkStructureType sType; 6638 void* pNext; 6639 uint32_t maxDiscardRectangles; 6640 } VkPhysicalDeviceDiscardRectanglePropertiesEXT; 6641 6642 typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT { 6643 VkStructureType sType; 6644 const void* pNext; 6645 VkPipelineDiscardRectangleStateCreateFlagsEXT flags; 6646 VkDiscardRectangleModeEXT discardRectangleMode; 6647 uint32_t discardRectangleCount; 6648 const VkRect2D* pDiscardRectangles; 6649 } VkPipelineDiscardRectangleStateCreateInfoEXT; 6650 6651 typedef void (VKAPI_PTR *PFN_vkCmdSetDiscardRectangleEXT)(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles); 6652 6653 #ifndef VK_NO_PROTOTYPES 6654 VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEXT( 6655 VkCommandBuffer commandBuffer, 6656 uint32_t firstDiscardRectangle, 6657 uint32_t discardRectangleCount, 6658 const VkRect2D* pDiscardRectangles); 6659 #endif 6660 6661 6662 #define VK_EXT_conservative_rasterization 1 6663 #define VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION 1 6664 #define VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME "VK_EXT_conservative_rasterization" 6665 6666 typedef enum VkConservativeRasterizationModeEXT { 6667 VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT = 0, 6668 VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT = 1, 6669 VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT = 2, 6670 VK_CONSERVATIVE_RASTERIZATION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF 6671 } VkConservativeRasterizationModeEXT; 6672 typedef VkFlags VkPipelineRasterizationConservativeStateCreateFlagsEXT; 6673 typedef struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT { 6674 VkStructureType sType; 6675 void* pNext; 6676 float primitiveOverestimationSize; 6677 float maxExtraPrimitiveOverestimationSize; 6678 float extraPrimitiveOverestimationSizeGranularity; 6679 VkBool32 primitiveUnderestimation; 6680 VkBool32 conservativePointAndLineRasterization; 6681 VkBool32 degenerateTrianglesRasterized; 6682 VkBool32 degenerateLinesRasterized; 6683 VkBool32 fullyCoveredFragmentShaderInputVariable; 6684 VkBool32 conservativeRasterizationPostDepthCoverage; 6685 } VkPhysicalDeviceConservativeRasterizationPropertiesEXT; 6686 6687 typedef struct VkPipelineRasterizationConservativeStateCreateInfoEXT { 6688 VkStructureType sType; 6689 const void* pNext; 6690 VkPipelineRasterizationConservativeStateCreateFlagsEXT flags; 6691 VkConservativeRasterizationModeEXT conservativeRasterizationMode; 6692 float extraPrimitiveOverestimationSize; 6693 } VkPipelineRasterizationConservativeStateCreateInfoEXT; 6694 6695 6696 6697 #define VK_EXT_depth_clip_enable 1 6698 #define VK_EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION 1 6699 #define VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME "VK_EXT_depth_clip_enable" 6700 typedef VkFlags VkPipelineRasterizationDepthClipStateCreateFlagsEXT; 6701 typedef struct VkPhysicalDeviceDepthClipEnableFeaturesEXT { 6702 VkStructureType sType; 6703 void* pNext; 6704 VkBool32 depthClipEnable; 6705 } VkPhysicalDeviceDepthClipEnableFeaturesEXT; 6706 6707 typedef struct VkPipelineRasterizationDepthClipStateCreateInfoEXT { 6708 VkStructureType sType; 6709 const void* pNext; 6710 VkPipelineRasterizationDepthClipStateCreateFlagsEXT flags; 6711 VkBool32 depthClipEnable; 6712 } VkPipelineRasterizationDepthClipStateCreateInfoEXT; 6713 6714 6715 6716 #define VK_EXT_swapchain_colorspace 1 6717 #define VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION 4 6718 #define VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME "VK_EXT_swapchain_colorspace" 6719 6720 6721 #define VK_EXT_hdr_metadata 1 6722 #define VK_EXT_HDR_METADATA_SPEC_VERSION 2 6723 #define VK_EXT_HDR_METADATA_EXTENSION_NAME "VK_EXT_hdr_metadata" 6724 typedef struct VkXYColorEXT { 6725 float x; 6726 float y; 6727 } VkXYColorEXT; 6728 6729 typedef struct VkHdrMetadataEXT { 6730 VkStructureType sType; 6731 const void* pNext; 6732 VkXYColorEXT displayPrimaryRed; 6733 VkXYColorEXT displayPrimaryGreen; 6734 VkXYColorEXT displayPrimaryBlue; 6735 VkXYColorEXT whitePoint; 6736 float maxLuminance; 6737 float minLuminance; 6738 float maxContentLightLevel; 6739 float maxFrameAverageLightLevel; 6740 } VkHdrMetadataEXT; 6741 6742 typedef void (VKAPI_PTR *PFN_vkSetHdrMetadataEXT)(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata); 6743 6744 #ifndef VK_NO_PROTOTYPES 6745 VKAPI_ATTR void VKAPI_CALL vkSetHdrMetadataEXT( 6746 VkDevice device, 6747 uint32_t swapchainCount, 6748 const VkSwapchainKHR* pSwapchains, 6749 const VkHdrMetadataEXT* pMetadata); 6750 #endif 6751 6752 6753 #define VK_EXT_external_memory_dma_buf 1 6754 #define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION 1 6755 #define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME "VK_EXT_external_memory_dma_buf" 6756 6757 6758 #define VK_EXT_queue_family_foreign 1 6759 #define VK_EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION 1 6760 #define VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME "VK_EXT_queue_family_foreign" 6761 #define VK_QUEUE_FAMILY_FOREIGN_EXT (~2U) 6762 6763 6764 #define VK_EXT_debug_utils 1 6765 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugUtilsMessengerEXT) 6766 #define VK_EXT_DEBUG_UTILS_SPEC_VERSION 2 6767 #define VK_EXT_DEBUG_UTILS_EXTENSION_NAME "VK_EXT_debug_utils" 6768 typedef VkFlags VkDebugUtilsMessengerCallbackDataFlagsEXT; 6769 6770 typedef enum VkDebugUtilsMessageSeverityFlagBitsEXT { 6771 VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT = 0x00000001, 6772 VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT = 0x00000010, 6773 VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT = 0x00000100, 6774 VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT = 0x00001000, 6775 VK_DEBUG_UTILS_MESSAGE_SEVERITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF 6776 } VkDebugUtilsMessageSeverityFlagBitsEXT; 6777 6778 typedef enum VkDebugUtilsMessageTypeFlagBitsEXT { 6779 VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT = 0x00000001, 6780 VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT = 0x00000002, 6781 VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT = 0x00000004, 6782 VK_DEBUG_UTILS_MESSAGE_TYPE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF 6783 } VkDebugUtilsMessageTypeFlagBitsEXT; 6784 typedef VkFlags VkDebugUtilsMessageTypeFlagsEXT; 6785 typedef VkFlags VkDebugUtilsMessageSeverityFlagsEXT; 6786 typedef VkFlags VkDebugUtilsMessengerCreateFlagsEXT; 6787 typedef struct VkDebugUtilsLabelEXT { 6788 VkStructureType sType; 6789 const void* pNext; 6790 const char* pLabelName; 6791 float color[4]; 6792 } VkDebugUtilsLabelEXT; 6793 6794 typedef struct VkDebugUtilsObjectNameInfoEXT { 6795 VkStructureType sType; 6796 const void* pNext; 6797 VkObjectType objectType; 6798 uint64_t objectHandle; 6799 const char* pObjectName; 6800 } VkDebugUtilsObjectNameInfoEXT; 6801 6802 typedef struct VkDebugUtilsMessengerCallbackDataEXT { 6803 VkStructureType sType; 6804 const void* pNext; 6805 VkDebugUtilsMessengerCallbackDataFlagsEXT flags; 6806 const char* pMessageIdName; 6807 int32_t messageIdNumber; 6808 const char* pMessage; 6809 uint32_t queueLabelCount; 6810 const VkDebugUtilsLabelEXT* pQueueLabels; 6811 uint32_t cmdBufLabelCount; 6812 const VkDebugUtilsLabelEXT* pCmdBufLabels; 6813 uint32_t objectCount; 6814 const VkDebugUtilsObjectNameInfoEXT* pObjects; 6815 } VkDebugUtilsMessengerCallbackDataEXT; 6816 6817 typedef VkBool32 (VKAPI_PTR *PFN_vkDebugUtilsMessengerCallbackEXT)( 6818 VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, 6819 VkDebugUtilsMessageTypeFlagsEXT messageTypes, 6820 const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, 6821 void* pUserData); 6822 6823 typedef struct VkDebugUtilsMessengerCreateInfoEXT { 6824 VkStructureType sType; 6825 const void* pNext; 6826 VkDebugUtilsMessengerCreateFlagsEXT flags; 6827 VkDebugUtilsMessageSeverityFlagsEXT messageSeverity; 6828 VkDebugUtilsMessageTypeFlagsEXT messageType; 6829 PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback; 6830 void* pUserData; 6831 } VkDebugUtilsMessengerCreateInfoEXT; 6832 6833 typedef struct VkDebugUtilsObjectTagInfoEXT { 6834 VkStructureType sType; 6835 const void* pNext; 6836 VkObjectType objectType; 6837 uint64_t objectHandle; 6838 uint64_t tagName; 6839 size_t tagSize; 6840 const void* pTag; 6841 } VkDebugUtilsObjectTagInfoEXT; 6842 6843 typedef VkResult (VKAPI_PTR *PFN_vkSetDebugUtilsObjectNameEXT)(VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo); 6844 typedef VkResult (VKAPI_PTR *PFN_vkSetDebugUtilsObjectTagEXT)(VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo); 6845 typedef void (VKAPI_PTR *PFN_vkQueueBeginDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo); 6846 typedef void (VKAPI_PTR *PFN_vkQueueEndDebugUtilsLabelEXT)(VkQueue queue); 6847 typedef void (VKAPI_PTR *PFN_vkQueueInsertDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo); 6848 typedef void (VKAPI_PTR *PFN_vkCmdBeginDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo); 6849 typedef void (VKAPI_PTR *PFN_vkCmdEndDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer); 6850 typedef void (VKAPI_PTR *PFN_vkCmdInsertDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo); 6851 typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugUtilsMessengerEXT)(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger); 6852 typedef void (VKAPI_PTR *PFN_vkDestroyDebugUtilsMessengerEXT)(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator); 6853 typedef void (VKAPI_PTR *PFN_vkSubmitDebugUtilsMessageEXT)(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData); 6854 6855 #ifndef VK_NO_PROTOTYPES 6856 VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectNameEXT( 6857 VkDevice device, 6858 const VkDebugUtilsObjectNameInfoEXT* pNameInfo); 6859 6860 VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectTagEXT( 6861 VkDevice device, 6862 const VkDebugUtilsObjectTagInfoEXT* pTagInfo); 6863 6864 VKAPI_ATTR void VKAPI_CALL vkQueueBeginDebugUtilsLabelEXT( 6865 VkQueue queue, 6866 const VkDebugUtilsLabelEXT* pLabelInfo); 6867 6868 VKAPI_ATTR void VKAPI_CALL vkQueueEndDebugUtilsLabelEXT( 6869 VkQueue queue); 6870 6871 VKAPI_ATTR void VKAPI_CALL vkQueueInsertDebugUtilsLabelEXT( 6872 VkQueue queue, 6873 const VkDebugUtilsLabelEXT* pLabelInfo); 6874 6875 VKAPI_ATTR void VKAPI_CALL vkCmdBeginDebugUtilsLabelEXT( 6876 VkCommandBuffer commandBuffer, 6877 const VkDebugUtilsLabelEXT* pLabelInfo); 6878 6879 VKAPI_ATTR void VKAPI_CALL vkCmdEndDebugUtilsLabelEXT( 6880 VkCommandBuffer commandBuffer); 6881 6882 VKAPI_ATTR void VKAPI_CALL vkCmdInsertDebugUtilsLabelEXT( 6883 VkCommandBuffer commandBuffer, 6884 const VkDebugUtilsLabelEXT* pLabelInfo); 6885 6886 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugUtilsMessengerEXT( 6887 VkInstance instance, 6888 const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, 6889 const VkAllocationCallbacks* pAllocator, 6890 VkDebugUtilsMessengerEXT* pMessenger); 6891 6892 VKAPI_ATTR void VKAPI_CALL vkDestroyDebugUtilsMessengerEXT( 6893 VkInstance instance, 6894 VkDebugUtilsMessengerEXT messenger, 6895 const VkAllocationCallbacks* pAllocator); 6896 6897 VKAPI_ATTR void VKAPI_CALL vkSubmitDebugUtilsMessageEXT( 6898 VkInstance instance, 6899 VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, 6900 VkDebugUtilsMessageTypeFlagsEXT messageTypes, 6901 const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData); 6902 #endif 6903 6904 6905 #define VK_EXT_shader_stencil_export 1 6906 #define VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION 1 6907 #define VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME "VK_EXT_shader_stencil_export" 6908 6909 6910 #define VK_EXT_sample_locations 1 6911 #define VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION 1 6912 #define VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME "VK_EXT_sample_locations" 6913 typedef struct VkSampleLocationEXT { 6914 float x; 6915 float y; 6916 } VkSampleLocationEXT; 6917 6918 typedef struct VkSampleLocationsInfoEXT { 6919 VkStructureType sType; 6920 const void* pNext; 6921 VkSampleCountFlagBits sampleLocationsPerPixel; 6922 VkExtent2D sampleLocationGridSize; 6923 uint32_t sampleLocationsCount; 6924 const VkSampleLocationEXT* pSampleLocations; 6925 } VkSampleLocationsInfoEXT; 6926 6927 typedef struct VkAttachmentSampleLocationsEXT { 6928 uint32_t attachmentIndex; 6929 VkSampleLocationsInfoEXT sampleLocationsInfo; 6930 } VkAttachmentSampleLocationsEXT; 6931 6932 typedef struct VkSubpassSampleLocationsEXT { 6933 uint32_t subpassIndex; 6934 VkSampleLocationsInfoEXT sampleLocationsInfo; 6935 } VkSubpassSampleLocationsEXT; 6936 6937 typedef struct VkRenderPassSampleLocationsBeginInfoEXT { 6938 VkStructureType sType; 6939 const void* pNext; 6940 uint32_t attachmentInitialSampleLocationsCount; 6941 const VkAttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations; 6942 uint32_t postSubpassSampleLocationsCount; 6943 const VkSubpassSampleLocationsEXT* pPostSubpassSampleLocations; 6944 } VkRenderPassSampleLocationsBeginInfoEXT; 6945 6946 typedef struct VkPipelineSampleLocationsStateCreateInfoEXT { 6947 VkStructureType sType; 6948 const void* pNext; 6949 VkBool32 sampleLocationsEnable; 6950 VkSampleLocationsInfoEXT sampleLocationsInfo; 6951 } VkPipelineSampleLocationsStateCreateInfoEXT; 6952 6953 typedef struct VkPhysicalDeviceSampleLocationsPropertiesEXT { 6954 VkStructureType sType; 6955 void* pNext; 6956 VkSampleCountFlags sampleLocationSampleCounts; 6957 VkExtent2D maxSampleLocationGridSize; 6958 float sampleLocationCoordinateRange[2]; 6959 uint32_t sampleLocationSubPixelBits; 6960 VkBool32 variableSampleLocations; 6961 } VkPhysicalDeviceSampleLocationsPropertiesEXT; 6962 6963 typedef struct VkMultisamplePropertiesEXT { 6964 VkStructureType sType; 6965 void* pNext; 6966 VkExtent2D maxSampleLocationGridSize; 6967 } VkMultisamplePropertiesEXT; 6968 6969 typedef void (VKAPI_PTR *PFN_vkCmdSetSampleLocationsEXT)(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo); 6970 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT)(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties); 6971 6972 #ifndef VK_NO_PROTOTYPES 6973 VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleLocationsEXT( 6974 VkCommandBuffer commandBuffer, 6975 const VkSampleLocationsInfoEXT* pSampleLocationsInfo); 6976 6977 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMultisamplePropertiesEXT( 6978 VkPhysicalDevice physicalDevice, 6979 VkSampleCountFlagBits samples, 6980 VkMultisamplePropertiesEXT* pMultisampleProperties); 6981 #endif 6982 6983 6984 #define VK_EXT_blend_operation_advanced 1 6985 #define VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION 2 6986 #define VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME "VK_EXT_blend_operation_advanced" 6987 6988 typedef enum VkBlendOverlapEXT { 6989 VK_BLEND_OVERLAP_UNCORRELATED_EXT = 0, 6990 VK_BLEND_OVERLAP_DISJOINT_EXT = 1, 6991 VK_BLEND_OVERLAP_CONJOINT_EXT = 2, 6992 VK_BLEND_OVERLAP_MAX_ENUM_EXT = 0x7FFFFFFF 6993 } VkBlendOverlapEXT; 6994 typedef struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT { 6995 VkStructureType sType; 6996 void* pNext; 6997 VkBool32 advancedBlendCoherentOperations; 6998 } VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT; 6999 7000 typedef struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT { 7001 VkStructureType sType; 7002 void* pNext; 7003 uint32_t advancedBlendMaxColorAttachments; 7004 VkBool32 advancedBlendIndependentBlend; 7005 VkBool32 advancedBlendNonPremultipliedSrcColor; 7006 VkBool32 advancedBlendNonPremultipliedDstColor; 7007 VkBool32 advancedBlendCorrelatedOverlap; 7008 VkBool32 advancedBlendAllOperations; 7009 } VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT; 7010 7011 typedef struct VkPipelineColorBlendAdvancedStateCreateInfoEXT { 7012 VkStructureType sType; 7013 const void* pNext; 7014 VkBool32 srcPremultiplied; 7015 VkBool32 dstPremultiplied; 7016 VkBlendOverlapEXT blendOverlap; 7017 } VkPipelineColorBlendAdvancedStateCreateInfoEXT; 7018 7019 7020 7021 #define VK_EXT_post_depth_coverage 1 7022 #define VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION 1 7023 #define VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME "VK_EXT_post_depth_coverage" 7024 7025 7026 #define VK_EXT_image_drm_format_modifier 1 7027 #define VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION 2 7028 #define VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME "VK_EXT_image_drm_format_modifier" 7029 typedef VkFlags64 VkFormatFeatureFlags2KHR; 7030 7031 // Flag bits for VkFormatFeatureFlagBits2KHR 7032 typedef VkFlags64 VkFormatFeatureFlagBits2KHR; 7033 static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT_KHR = 0x00000001ULL; 7034 static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT_KHR = 0x00000002ULL; 7035 static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT_KHR = 0x00000004ULL; 7036 static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR = 0x00000008ULL; 7037 static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT_KHR = 0x00000010ULL; 7038 static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT_KHR = 0x00000020ULL; 7039 static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT_KHR = 0x00000040ULL; 7040 static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT_KHR = 0x00000080ULL; 7041 static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT_KHR = 0x00000100ULL; 7042 static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT_KHR = 0x00000200ULL; 7043 static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_BLIT_SRC_BIT_KHR = 0x00000400ULL; 7044 static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_BLIT_DST_BIT_KHR = 0x00000800ULL; 7045 static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT_KHR = 0x00001000ULL; 7046 static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT = 0x00002000ULL; 7047 static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT_KHR = 0x00004000ULL; 7048 static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT_KHR = 0x00008000ULL; 7049 static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT_KHR = 0x00010000ULL; 7050 static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT_KHR = 0x00020000ULL; 7051 static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR = 0x00040000ULL; 7052 static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR = 0x00080000ULL; 7053 static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR = 0x00100000ULL; 7054 static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR = 0x00200000ULL; 7055 static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_DISJOINT_BIT_KHR = 0x00400000ULL; 7056 static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT_KHR = 0x00800000ULL; 7057 static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR = 0x80000000ULL; 7058 static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR = 0x100000000ULL; 7059 static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR = 0x200000000ULL; 7060 static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x40000000ULL; 7061 7062 typedef struct VkDrmFormatModifierPropertiesEXT { 7063 uint64_t drmFormatModifier; 7064 uint32_t drmFormatModifierPlaneCount; 7065 VkFormatFeatureFlags drmFormatModifierTilingFeatures; 7066 } VkDrmFormatModifierPropertiesEXT; 7067 7068 typedef struct VkDrmFormatModifierPropertiesListEXT { 7069 VkStructureType sType; 7070 void* pNext; 7071 uint32_t drmFormatModifierCount; 7072 VkDrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties; 7073 } VkDrmFormatModifierPropertiesListEXT; 7074 7075 typedef struct VkPhysicalDeviceImageDrmFormatModifierInfoEXT { 7076 VkStructureType sType; 7077 const void* pNext; 7078 uint64_t drmFormatModifier; 7079 VkSharingMode sharingMode; 7080 uint32_t queueFamilyIndexCount; 7081 const uint32_t* pQueueFamilyIndices; 7082 } VkPhysicalDeviceImageDrmFormatModifierInfoEXT; 7083 7084 typedef struct VkImageDrmFormatModifierListCreateInfoEXT { 7085 VkStructureType sType; 7086 const void* pNext; 7087 uint32_t drmFormatModifierCount; 7088 const uint64_t* pDrmFormatModifiers; 7089 } VkImageDrmFormatModifierListCreateInfoEXT; 7090 7091 typedef struct VkImageDrmFormatModifierExplicitCreateInfoEXT { 7092 VkStructureType sType; 7093 const void* pNext; 7094 uint64_t drmFormatModifier; 7095 uint32_t drmFormatModifierPlaneCount; 7096 const VkSubresourceLayout* pPlaneLayouts; 7097 } VkImageDrmFormatModifierExplicitCreateInfoEXT; 7098 7099 typedef struct VkImageDrmFormatModifierPropertiesEXT { 7100 VkStructureType sType; 7101 void* pNext; 7102 uint64_t drmFormatModifier; 7103 } VkImageDrmFormatModifierPropertiesEXT; 7104 7105 typedef struct VkDrmFormatModifierProperties2EXT { 7106 uint64_t drmFormatModifier; 7107 uint32_t drmFormatModifierPlaneCount; 7108 VkFormatFeatureFlags2KHR drmFormatModifierTilingFeatures; 7109 } VkDrmFormatModifierProperties2EXT; 7110 7111 typedef struct VkDrmFormatModifierPropertiesList2EXT { 7112 VkStructureType sType; 7113 void* pNext; 7114 uint32_t drmFormatModifierCount; 7115 VkDrmFormatModifierProperties2EXT* pDrmFormatModifierProperties; 7116 } VkDrmFormatModifierPropertiesList2EXT; 7117 7118 typedef VkResult (VKAPI_PTR *PFN_vkGetImageDrmFormatModifierPropertiesEXT)(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties); 7119 7120 #ifndef VK_NO_PROTOTYPES 7121 VKAPI_ATTR VkResult VKAPI_CALL vkGetImageDrmFormatModifierPropertiesEXT( 7122 VkDevice device, 7123 VkImage image, 7124 VkImageDrmFormatModifierPropertiesEXT* pProperties); 7125 #endif 7126 7127 7128 #define VK_EXT_filter_cubic 1 7129 #define VK_EXT_FILTER_CUBIC_SPEC_VERSION 3 7130 #define VK_EXT_FILTER_CUBIC_EXTENSION_NAME "VK_EXT_filter_cubic" 7131 typedef struct VkPhysicalDeviceImageViewImageFormatInfoEXT { 7132 VkStructureType sType; 7133 void* pNext; 7134 VkImageViewType imageViewType; 7135 } VkPhysicalDeviceImageViewImageFormatInfoEXT; 7136 7137 typedef struct VkFilterCubicImageViewImageFormatPropertiesEXT { 7138 VkStructureType sType; 7139 void* pNext; 7140 VkBool32 filterCubic; 7141 VkBool32 filterCubicMinmax; 7142 } VkFilterCubicImageViewImageFormatPropertiesEXT; 7143 7144 7145 7146 #define VK_EXT_global_priority 1 7147 #define VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION 2 7148 #define VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME "VK_EXT_global_priority" 7149 7150 typedef enum VkQueueGlobalPriorityEXT { 7151 VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT = 128, 7152 VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT = 256, 7153 VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT = 512, 7154 VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT = 1024, 7155 VK_QUEUE_GLOBAL_PRIORITY_MAX_ENUM_EXT = 0x7FFFFFFF 7156 } VkQueueGlobalPriorityEXT; 7157 typedef struct VkDeviceQueueGlobalPriorityCreateInfoEXT { 7158 VkStructureType sType; 7159 const void* pNext; 7160 VkQueueGlobalPriorityEXT globalPriority; 7161 } VkDeviceQueueGlobalPriorityCreateInfoEXT; 7162 7163 7164 7165 #define VK_EXT_external_memory_host 1 7166 #define VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION 1 7167 #define VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME "VK_EXT_external_memory_host" 7168 typedef struct VkImportMemoryHostPointerInfoEXT { 7169 VkStructureType sType; 7170 const void* pNext; 7171 VkExternalMemoryHandleTypeFlagBits handleType; 7172 void* pHostPointer; 7173 } VkImportMemoryHostPointerInfoEXT; 7174 7175 typedef struct VkMemoryHostPointerPropertiesEXT { 7176 VkStructureType sType; 7177 void* pNext; 7178 uint32_t memoryTypeBits; 7179 } VkMemoryHostPointerPropertiesEXT; 7180 7181 typedef struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT { 7182 VkStructureType sType; 7183 void* pNext; 7184 VkDeviceSize minImportedHostPointerAlignment; 7185 } VkPhysicalDeviceExternalMemoryHostPropertiesEXT; 7186 7187 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryHostPointerPropertiesEXT)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties); 7188 7189 #ifndef VK_NO_PROTOTYPES 7190 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryHostPointerPropertiesEXT( 7191 VkDevice device, 7192 VkExternalMemoryHandleTypeFlagBits handleType, 7193 const void* pHostPointer, 7194 VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties); 7195 #endif 7196 7197 7198 #define VK_EXT_calibrated_timestamps 1 7199 #define VK_EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION 2 7200 #define VK_EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME "VK_EXT_calibrated_timestamps" 7201 7202 typedef enum VkTimeDomainEXT { 7203 VK_TIME_DOMAIN_DEVICE_EXT = 0, 7204 VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT = 1, 7205 VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT = 2, 7206 VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT = 3, 7207 VK_TIME_DOMAIN_MAX_ENUM_EXT = 0x7FFFFFFF 7208 } VkTimeDomainEXT; 7209 typedef struct VkCalibratedTimestampInfoEXT { 7210 VkStructureType sType; 7211 const void* pNext; 7212 VkTimeDomainEXT timeDomain; 7213 } VkCalibratedTimestampInfoEXT; 7214 7215 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains); 7216 typedef VkResult (VKAPI_PTR *PFN_vkGetCalibratedTimestampsEXT)(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation); 7217 7218 #ifndef VK_NO_PROTOTYPES 7219 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( 7220 VkPhysicalDevice physicalDevice, 7221 uint32_t* pTimeDomainCount, 7222 VkTimeDomainEXT* pTimeDomains); 7223 7224 VKAPI_ATTR VkResult VKAPI_CALL vkGetCalibratedTimestampsEXT( 7225 VkDevice device, 7226 uint32_t timestampCount, 7227 const VkCalibratedTimestampInfoEXT* pTimestampInfos, 7228 uint64_t* pTimestamps, 7229 uint64_t* pMaxDeviation); 7230 #endif 7231 7232 7233 #define VK_EXT_vertex_attribute_divisor 1 7234 #define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION 3 7235 #define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME "VK_EXT_vertex_attribute_divisor" 7236 typedef struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT { 7237 VkStructureType sType; 7238 void* pNext; 7239 uint32_t maxVertexAttribDivisor; 7240 } VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT; 7241 7242 typedef struct VkVertexInputBindingDivisorDescriptionEXT { 7243 uint32_t binding; 7244 uint32_t divisor; 7245 } VkVertexInputBindingDivisorDescriptionEXT; 7246 7247 typedef struct VkPipelineVertexInputDivisorStateCreateInfoEXT { 7248 VkStructureType sType; 7249 const void* pNext; 7250 uint32_t vertexBindingDivisorCount; 7251 const VkVertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors; 7252 } VkPipelineVertexInputDivisorStateCreateInfoEXT; 7253 7254 typedef struct VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT { 7255 VkStructureType sType; 7256 void* pNext; 7257 VkBool32 vertexAttributeInstanceRateDivisor; 7258 VkBool32 vertexAttributeInstanceRateZeroDivisor; 7259 } VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT; 7260 7261 7262 7263 #define VK_EXT_pci_bus_info 1 7264 #define VK_EXT_PCI_BUS_INFO_SPEC_VERSION 2 7265 #define VK_EXT_PCI_BUS_INFO_EXTENSION_NAME "VK_EXT_pci_bus_info" 7266 typedef struct VkPhysicalDevicePCIBusInfoPropertiesEXT { 7267 VkStructureType sType; 7268 void* pNext; 7269 uint32_t pciDomain; 7270 uint32_t pciBus; 7271 uint32_t pciDevice; 7272 uint32_t pciFunction; 7273 } VkPhysicalDevicePCIBusInfoPropertiesEXT; 7274 7275 7276 7277 #define VK_EXT_subgroup_size_control 1 7278 #define VK_EXT_SUBGROUP_SIZE_CONTROL_SPEC_VERSION 2 7279 #define VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME "VK_EXT_subgroup_size_control" 7280 typedef struct VkPhysicalDeviceSubgroupSizeControlFeaturesEXT { 7281 VkStructureType sType; 7282 void* pNext; 7283 VkBool32 subgroupSizeControl; 7284 VkBool32 computeFullSubgroups; 7285 } VkPhysicalDeviceSubgroupSizeControlFeaturesEXT; 7286 7287 typedef struct VkPhysicalDeviceSubgroupSizeControlPropertiesEXT { 7288 VkStructureType sType; 7289 void* pNext; 7290 uint32_t minSubgroupSize; 7291 uint32_t maxSubgroupSize; 7292 uint32_t maxComputeWorkgroupSubgroups; 7293 VkShaderStageFlags requiredSubgroupSizeStages; 7294 } VkPhysicalDeviceSubgroupSizeControlPropertiesEXT; 7295 7296 typedef struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT { 7297 VkStructureType sType; 7298 void* pNext; 7299 uint32_t requiredSubgroupSize; 7300 } VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT; 7301 7302 7303 7304 #define VK_EXT_shader_image_atomic_int64 1 7305 #define VK_EXT_SHADER_IMAGE_ATOMIC_INT64_SPEC_VERSION 1 7306 #define VK_EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME "VK_EXT_shader_image_atomic_int64" 7307 typedef struct VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT { 7308 VkStructureType sType; 7309 void* pNext; 7310 VkBool32 shaderImageInt64Atomics; 7311 VkBool32 sparseImageInt64Atomics; 7312 } VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT; 7313 7314 7315 7316 #define VK_EXT_memory_budget 1 7317 #define VK_EXT_MEMORY_BUDGET_SPEC_VERSION 1 7318 #define VK_EXT_MEMORY_BUDGET_EXTENSION_NAME "VK_EXT_memory_budget" 7319 typedef struct VkPhysicalDeviceMemoryBudgetPropertiesEXT { 7320 VkStructureType sType; 7321 void* pNext; 7322 VkDeviceSize heapBudget[VK_MAX_MEMORY_HEAPS]; 7323 VkDeviceSize heapUsage[VK_MAX_MEMORY_HEAPS]; 7324 } VkPhysicalDeviceMemoryBudgetPropertiesEXT; 7325 7326 7327 7328 #define VK_EXT_validation_features 1 7329 #define VK_EXT_VALIDATION_FEATURES_SPEC_VERSION 5 7330 #define VK_EXT_VALIDATION_FEATURES_EXTENSION_NAME "VK_EXT_validation_features" 7331 7332 typedef enum VkValidationFeatureEnableEXT { 7333 VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT = 0, 7334 VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT = 1, 7335 VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT = 2, 7336 VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT = 3, 7337 VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT = 4, 7338 VK_VALIDATION_FEATURE_ENABLE_MAX_ENUM_EXT = 0x7FFFFFFF 7339 } VkValidationFeatureEnableEXT; 7340 7341 typedef enum VkValidationFeatureDisableEXT { 7342 VK_VALIDATION_FEATURE_DISABLE_ALL_EXT = 0, 7343 VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT = 1, 7344 VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT = 2, 7345 VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT = 3, 7346 VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT = 4, 7347 VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT = 5, 7348 VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT = 6, 7349 VK_VALIDATION_FEATURE_DISABLE_SHADER_VALIDATION_CACHE_EXT = 7, 7350 VK_VALIDATION_FEATURE_DISABLE_MAX_ENUM_EXT = 0x7FFFFFFF 7351 } VkValidationFeatureDisableEXT; 7352 typedef struct VkValidationFeaturesEXT { 7353 VkStructureType sType; 7354 const void* pNext; 7355 uint32_t enabledValidationFeatureCount; 7356 const VkValidationFeatureEnableEXT* pEnabledValidationFeatures; 7357 uint32_t disabledValidationFeatureCount; 7358 const VkValidationFeatureDisableEXT* pDisabledValidationFeatures; 7359 } VkValidationFeaturesEXT; 7360 7361 7362 7363 #define VK_EXT_fragment_shader_interlock 1 7364 #define VK_EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION 1 7365 #define VK_EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME "VK_EXT_fragment_shader_interlock" 7366 typedef struct VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT { 7367 VkStructureType sType; 7368 void* pNext; 7369 VkBool32 fragmentShaderSampleInterlock; 7370 VkBool32 fragmentShaderPixelInterlock; 7371 VkBool32 fragmentShaderShadingRateInterlock; 7372 } VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT; 7373 7374 7375 7376 #define VK_EXT_ycbcr_image_arrays 1 7377 #define VK_EXT_YCBCR_IMAGE_ARRAYS_SPEC_VERSION 1 7378 #define VK_EXT_YCBCR_IMAGE_ARRAYS_EXTENSION_NAME "VK_EXT_ycbcr_image_arrays" 7379 typedef struct VkPhysicalDeviceYcbcrImageArraysFeaturesEXT { 7380 VkStructureType sType; 7381 void* pNext; 7382 VkBool32 ycbcrImageArrays; 7383 } VkPhysicalDeviceYcbcrImageArraysFeaturesEXT; 7384 7385 7386 7387 #define VK_EXT_headless_surface 1 7388 #define VK_EXT_HEADLESS_SURFACE_SPEC_VERSION 1 7389 #define VK_EXT_HEADLESS_SURFACE_EXTENSION_NAME "VK_EXT_headless_surface" 7390 typedef VkFlags VkHeadlessSurfaceCreateFlagsEXT; 7391 typedef struct VkHeadlessSurfaceCreateInfoEXT { 7392 VkStructureType sType; 7393 const void* pNext; 7394 VkHeadlessSurfaceCreateFlagsEXT flags; 7395 } VkHeadlessSurfaceCreateInfoEXT; 7396 7397 typedef VkResult (VKAPI_PTR *PFN_vkCreateHeadlessSurfaceEXT)(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); 7398 7399 #ifndef VK_NO_PROTOTYPES 7400 VKAPI_ATTR VkResult VKAPI_CALL vkCreateHeadlessSurfaceEXT( 7401 VkInstance instance, 7402 const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, 7403 const VkAllocationCallbacks* pAllocator, 7404 VkSurfaceKHR* pSurface); 7405 #endif 7406 7407 7408 #define VK_EXT_line_rasterization 1 7409 #define VK_EXT_LINE_RASTERIZATION_SPEC_VERSION 1 7410 #define VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME "VK_EXT_line_rasterization" 7411 7412 typedef enum VkLineRasterizationModeEXT { 7413 VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT = 0, 7414 VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT = 1, 7415 VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT = 2, 7416 VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT = 3, 7417 VK_LINE_RASTERIZATION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF 7418 } VkLineRasterizationModeEXT; 7419 typedef struct VkPhysicalDeviceLineRasterizationFeaturesEXT { 7420 VkStructureType sType; 7421 void* pNext; 7422 VkBool32 rectangularLines; 7423 VkBool32 bresenhamLines; 7424 VkBool32 smoothLines; 7425 VkBool32 stippledRectangularLines; 7426 VkBool32 stippledBresenhamLines; 7427 VkBool32 stippledSmoothLines; 7428 } VkPhysicalDeviceLineRasterizationFeaturesEXT; 7429 7430 typedef struct VkPhysicalDeviceLineRasterizationPropertiesEXT { 7431 VkStructureType sType; 7432 void* pNext; 7433 uint32_t lineSubPixelPrecisionBits; 7434 } VkPhysicalDeviceLineRasterizationPropertiesEXT; 7435 7436 typedef struct VkPipelineRasterizationLineStateCreateInfoEXT { 7437 VkStructureType sType; 7438 const void* pNext; 7439 VkLineRasterizationModeEXT lineRasterizationMode; 7440 VkBool32 stippledLineEnable; 7441 uint32_t lineStippleFactor; 7442 uint16_t lineStipplePattern; 7443 } VkPipelineRasterizationLineStateCreateInfoEXT; 7444 7445 typedef void (VKAPI_PTR *PFN_vkCmdSetLineStippleEXT)(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern); 7446 7447 #ifndef VK_NO_PROTOTYPES 7448 VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleEXT( 7449 VkCommandBuffer commandBuffer, 7450 uint32_t lineStippleFactor, 7451 uint16_t lineStipplePattern); 7452 #endif 7453 7454 7455 #define VK_EXT_shader_atomic_float 1 7456 #define VK_EXT_SHADER_ATOMIC_FLOAT_SPEC_VERSION 1 7457 #define VK_EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME "VK_EXT_shader_atomic_float" 7458 typedef struct VkPhysicalDeviceShaderAtomicFloatFeaturesEXT { 7459 VkStructureType sType; 7460 void* pNext; 7461 VkBool32 shaderBufferFloat32Atomics; 7462 VkBool32 shaderBufferFloat32AtomicAdd; 7463 VkBool32 shaderBufferFloat64Atomics; 7464 VkBool32 shaderBufferFloat64AtomicAdd; 7465 VkBool32 shaderSharedFloat32Atomics; 7466 VkBool32 shaderSharedFloat32AtomicAdd; 7467 VkBool32 shaderSharedFloat64Atomics; 7468 VkBool32 shaderSharedFloat64AtomicAdd; 7469 VkBool32 shaderImageFloat32Atomics; 7470 VkBool32 shaderImageFloat32AtomicAdd; 7471 VkBool32 sparseImageFloat32Atomics; 7472 VkBool32 sparseImageFloat32AtomicAdd; 7473 } VkPhysicalDeviceShaderAtomicFloatFeaturesEXT; 7474 7475 7476 7477 #define VK_EXT_index_type_uint8 1 7478 #define VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION 1 7479 #define VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME "VK_EXT_index_type_uint8" 7480 typedef struct VkPhysicalDeviceIndexTypeUint8FeaturesEXT { 7481 VkStructureType sType; 7482 void* pNext; 7483 VkBool32 indexTypeUint8; 7484 } VkPhysicalDeviceIndexTypeUint8FeaturesEXT; 7485 7486 7487 7488 #define VK_EXT_extended_dynamic_state 1 7489 #define VK_EXT_EXTENDED_DYNAMIC_STATE_SPEC_VERSION 1 7490 #define VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME "VK_EXT_extended_dynamic_state" 7491 typedef struct VkPhysicalDeviceExtendedDynamicStateFeaturesEXT { 7492 VkStructureType sType; 7493 void* pNext; 7494 VkBool32 extendedDynamicState; 7495 } VkPhysicalDeviceExtendedDynamicStateFeaturesEXT; 7496 7497 typedef void (VKAPI_PTR *PFN_vkCmdSetCullModeEXT)(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode); 7498 typedef void (VKAPI_PTR *PFN_vkCmdSetFrontFaceEXT)(VkCommandBuffer commandBuffer, VkFrontFace frontFace); 7499 typedef void (VKAPI_PTR *PFN_vkCmdSetPrimitiveTopologyEXT)(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology); 7500 typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWithCountEXT)(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports); 7501 typedef void (VKAPI_PTR *PFN_vkCmdSetScissorWithCountEXT)(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors); 7502 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); 7503 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable); 7504 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthWriteEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable); 7505 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthCompareOpEXT)(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp); 7506 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBoundsTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable); 7507 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable); 7508 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilOpEXT)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp); 7509 7510 #ifndef VK_NO_PROTOTYPES 7511 VKAPI_ATTR void VKAPI_CALL vkCmdSetCullModeEXT( 7512 VkCommandBuffer commandBuffer, 7513 VkCullModeFlags cullMode); 7514 7515 VKAPI_ATTR void VKAPI_CALL vkCmdSetFrontFaceEXT( 7516 VkCommandBuffer commandBuffer, 7517 VkFrontFace frontFace); 7518 7519 VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveTopologyEXT( 7520 VkCommandBuffer commandBuffer, 7521 VkPrimitiveTopology primitiveTopology); 7522 7523 VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWithCountEXT( 7524 VkCommandBuffer commandBuffer, 7525 uint32_t viewportCount, 7526 const VkViewport* pViewports); 7527 7528 VKAPI_ATTR void VKAPI_CALL vkCmdSetScissorWithCountEXT( 7529 VkCommandBuffer commandBuffer, 7530 uint32_t scissorCount, 7531 const VkRect2D* pScissors); 7532 7533 VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers2EXT( 7534 VkCommandBuffer commandBuffer, 7535 uint32_t firstBinding, 7536 uint32_t bindingCount, 7537 const VkBuffer* pBuffers, 7538 const VkDeviceSize* pOffsets, 7539 const VkDeviceSize* pSizes, 7540 const VkDeviceSize* pStrides); 7541 7542 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthTestEnableEXT( 7543 VkCommandBuffer commandBuffer, 7544 VkBool32 depthTestEnable); 7545 7546 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthWriteEnableEXT( 7547 VkCommandBuffer commandBuffer, 7548 VkBool32 depthWriteEnable); 7549 7550 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthCompareOpEXT( 7551 VkCommandBuffer commandBuffer, 7552 VkCompareOp depthCompareOp); 7553 7554 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBoundsTestEnableEXT( 7555 VkCommandBuffer commandBuffer, 7556 VkBool32 depthBoundsTestEnable); 7557 7558 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilTestEnableEXT( 7559 VkCommandBuffer commandBuffer, 7560 VkBool32 stencilTestEnable); 7561 7562 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilOpEXT( 7563 VkCommandBuffer commandBuffer, 7564 VkStencilFaceFlags faceMask, 7565 VkStencilOp failOp, 7566 VkStencilOp passOp, 7567 VkStencilOp depthFailOp, 7568 VkCompareOp compareOp); 7569 #endif 7570 7571 7572 #define VK_EXT_shader_demote_to_helper_invocation 1 7573 #define VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_SPEC_VERSION 1 7574 #define VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME "VK_EXT_shader_demote_to_helper_invocation" 7575 typedef struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT { 7576 VkStructureType sType; 7577 void* pNext; 7578 VkBool32 shaderDemoteToHelperInvocation; 7579 } VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT; 7580 7581 7582 7583 #define VK_EXT_texel_buffer_alignment 1 7584 #define VK_EXT_TEXEL_BUFFER_ALIGNMENT_SPEC_VERSION 1 7585 #define VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME "VK_EXT_texel_buffer_alignment" 7586 typedef struct VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT { 7587 VkStructureType sType; 7588 void* pNext; 7589 VkBool32 texelBufferAlignment; 7590 } VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT; 7591 7592 typedef struct VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT { 7593 VkStructureType sType; 7594 void* pNext; 7595 VkDeviceSize storageTexelBufferOffsetAlignmentBytes; 7596 VkBool32 storageTexelBufferOffsetSingleTexelAlignment; 7597 VkDeviceSize uniformTexelBufferOffsetAlignmentBytes; 7598 VkBool32 uniformTexelBufferOffsetSingleTexelAlignment; 7599 } VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT; 7600 7601 7602 7603 #define VK_EXT_robustness2 1 7604 #define VK_EXT_ROBUSTNESS_2_SPEC_VERSION 1 7605 #define VK_EXT_ROBUSTNESS_2_EXTENSION_NAME "VK_EXT_robustness2" 7606 typedef struct VkPhysicalDeviceRobustness2FeaturesEXT { 7607 VkStructureType sType; 7608 void* pNext; 7609 VkBool32 robustBufferAccess2; 7610 VkBool32 robustImageAccess2; 7611 VkBool32 nullDescriptor; 7612 } VkPhysicalDeviceRobustness2FeaturesEXT; 7613 7614 typedef struct VkPhysicalDeviceRobustness2PropertiesEXT { 7615 VkStructureType sType; 7616 void* pNext; 7617 VkDeviceSize robustStorageBufferAccessSizeAlignment; 7618 VkDeviceSize robustUniformBufferAccessSizeAlignment; 7619 } VkPhysicalDeviceRobustness2PropertiesEXT; 7620 7621 7622 7623 #define VK_EXT_custom_border_color 1 7624 #define VK_EXT_CUSTOM_BORDER_COLOR_SPEC_VERSION 12 7625 #define VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME "VK_EXT_custom_border_color" 7626 typedef struct VkSamplerCustomBorderColorCreateInfoEXT { 7627 VkStructureType sType; 7628 const void* pNext; 7629 VkClearColorValue customBorderColor; 7630 VkFormat format; 7631 } VkSamplerCustomBorderColorCreateInfoEXT; 7632 7633 typedef struct VkPhysicalDeviceCustomBorderColorPropertiesEXT { 7634 VkStructureType sType; 7635 void* pNext; 7636 uint32_t maxCustomBorderColorSamplers; 7637 } VkPhysicalDeviceCustomBorderColorPropertiesEXT; 7638 7639 typedef struct VkPhysicalDeviceCustomBorderColorFeaturesEXT { 7640 VkStructureType sType; 7641 void* pNext; 7642 VkBool32 customBorderColors; 7643 VkBool32 customBorderColorWithoutFormat; 7644 } VkPhysicalDeviceCustomBorderColorFeaturesEXT; 7645 7646 7647 7648 #define VK_EXT_ycbcr_2plane_444_formats 1 7649 #define VK_EXT_YCBCR_2PLANE_444_FORMATS_SPEC_VERSION 1 7650 #define VK_EXT_YCBCR_2PLANE_444_FORMATS_EXTENSION_NAME "VK_EXT_ycbcr_2plane_444_formats" 7651 typedef struct VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT { 7652 VkStructureType sType; 7653 void* pNext; 7654 VkBool32 ycbcr2plane444Formats; 7655 } VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT; 7656 7657 7658 7659 #define VK_EXT_image_robustness 1 7660 #define VK_EXT_IMAGE_ROBUSTNESS_SPEC_VERSION 1 7661 #define VK_EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME "VK_EXT_image_robustness" 7662 typedef struct VkPhysicalDeviceImageRobustnessFeaturesEXT { 7663 VkStructureType sType; 7664 void* pNext; 7665 VkBool32 robustImageAccess; 7666 } VkPhysicalDeviceImageRobustnessFeaturesEXT; 7667 7668 7669 7670 #define VK_EXT_4444_formats 1 7671 #define VK_EXT_4444_FORMATS_SPEC_VERSION 1 7672 #define VK_EXT_4444_FORMATS_EXTENSION_NAME "VK_EXT_4444_formats" 7673 typedef struct VkPhysicalDevice4444FormatsFeaturesEXT { 7674 VkStructureType sType; 7675 void* pNext; 7676 VkBool32 formatA4R4G4B4; 7677 VkBool32 formatA4B4G4R4; 7678 } VkPhysicalDevice4444FormatsFeaturesEXT; 7679 7680 7681 7682 #define VK_EXT_vertex_input_dynamic_state 1 7683 #define VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_SPEC_VERSION 2 7684 #define VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME "VK_EXT_vertex_input_dynamic_state" 7685 typedef struct VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT { 7686 VkStructureType sType; 7687 void* pNext; 7688 VkBool32 vertexInputDynamicState; 7689 } VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT; 7690 7691 typedef struct VkVertexInputBindingDescription2EXT { 7692 VkStructureType sType; 7693 void* pNext; 7694 uint32_t binding; 7695 uint32_t stride; 7696 VkVertexInputRate inputRate; 7697 uint32_t divisor; 7698 } VkVertexInputBindingDescription2EXT; 7699 7700 typedef struct VkVertexInputAttributeDescription2EXT { 7701 VkStructureType sType; 7702 void* pNext; 7703 uint32_t location; 7704 uint32_t binding; 7705 VkFormat format; 7706 uint32_t offset; 7707 } VkVertexInputAttributeDescription2EXT; 7708 7709 typedef void (VKAPI_PTR *PFN_vkCmdSetVertexInputEXT)(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions); 7710 7711 #ifndef VK_NO_PROTOTYPES 7712 VKAPI_ATTR void VKAPI_CALL vkCmdSetVertexInputEXT( 7713 VkCommandBuffer commandBuffer, 7714 uint32_t vertexBindingDescriptionCount, 7715 const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, 7716 uint32_t vertexAttributeDescriptionCount, 7717 const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions); 7718 #endif 7719 7720 7721 #define VK_EXT_extended_dynamic_state2 1 7722 #define VK_EXT_EXTENDED_DYNAMIC_STATE_2_SPEC_VERSION 1 7723 #define VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME "VK_EXT_extended_dynamic_state2" 7724 typedef struct VkPhysicalDeviceExtendedDynamicState2FeaturesEXT { 7725 VkStructureType sType; 7726 void* pNext; 7727 VkBool32 extendedDynamicState2; 7728 VkBool32 extendedDynamicState2LogicOp; 7729 VkBool32 extendedDynamicState2PatchControlPoints; 7730 } VkPhysicalDeviceExtendedDynamicState2FeaturesEXT; 7731 7732 typedef void (VKAPI_PTR *PFN_vkCmdSetPatchControlPointsEXT)(VkCommandBuffer commandBuffer, uint32_t patchControlPoints); 7733 typedef void (VKAPI_PTR *PFN_vkCmdSetRasterizerDiscardEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable); 7734 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBiasEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable); 7735 typedef void (VKAPI_PTR *PFN_vkCmdSetLogicOpEXT)(VkCommandBuffer commandBuffer, VkLogicOp logicOp); 7736 typedef void (VKAPI_PTR *PFN_vkCmdSetPrimitiveRestartEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable); 7737 7738 #ifndef VK_NO_PROTOTYPES 7739 VKAPI_ATTR void VKAPI_CALL vkCmdSetPatchControlPointsEXT( 7740 VkCommandBuffer commandBuffer, 7741 uint32_t patchControlPoints); 7742 7743 VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizerDiscardEnableEXT( 7744 VkCommandBuffer commandBuffer, 7745 VkBool32 rasterizerDiscardEnable); 7746 7747 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBiasEnableEXT( 7748 VkCommandBuffer commandBuffer, 7749 VkBool32 depthBiasEnable); 7750 7751 VKAPI_ATTR void VKAPI_CALL vkCmdSetLogicOpEXT( 7752 VkCommandBuffer commandBuffer, 7753 VkLogicOp logicOp); 7754 7755 VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveRestartEnableEXT( 7756 VkCommandBuffer commandBuffer, 7757 VkBool32 primitiveRestartEnable); 7758 #endif 7759 7760 7761 #define VK_EXT_color_write_enable 1 7762 #define VK_EXT_COLOR_WRITE_ENABLE_SPEC_VERSION 1 7763 #define VK_EXT_COLOR_WRITE_ENABLE_EXTENSION_NAME "VK_EXT_color_write_enable" 7764 typedef struct VkPhysicalDeviceColorWriteEnableFeaturesEXT { 7765 VkStructureType sType; 7766 void* pNext; 7767 VkBool32 colorWriteEnable; 7768 } VkPhysicalDeviceColorWriteEnableFeaturesEXT; 7769 7770 typedef struct VkPipelineColorWriteCreateInfoEXT { 7771 VkStructureType sType; 7772 const void* pNext; 7773 uint32_t attachmentCount; 7774 const VkBool32* pColorWriteEnables; 7775 } VkPipelineColorWriteCreateInfoEXT; 7776 7777 typedef void (VKAPI_PTR *PFN_vkCmdSetColorWriteEnableEXT)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32* pColorWriteEnables); 7778 7779 #ifndef VK_NO_PROTOTYPES 7780 VKAPI_ATTR void VKAPI_CALL vkCmdSetColorWriteEnableEXT( 7781 VkCommandBuffer commandBuffer, 7782 uint32_t attachmentCount, 7783 const VkBool32* pColorWriteEnables); 7784 #endif 7785 7786 7787 #define VK_EXT_application_parameters 1 7788 #define VK_EXT_APPLICATION_PARAMETERS_SPEC_VERSION 1 7789 #define VK_EXT_APPLICATION_PARAMETERS_EXTENSION_NAME "VK_EXT_application_parameters" 7790 typedef struct VkApplicationParametersEXT { 7791 VkStructureType sType; 7792 const void* pNext; 7793 uint32_t vendorID; 7794 uint32_t deviceID; 7795 uint32_t key; 7796 uint64_t value; 7797 } VkApplicationParametersEXT; 7798 7799 7800 #ifdef __cplusplus 7801 } 7802 #endif 7803 7804 #endif 7805