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