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