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