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