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