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