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