vulkan.h revision 33faaad096afbd0b103bd1284ce5b78cce74aa01
1#ifndef __vulkan_h_ 2#define __vulkan_h_ 1 3 4#ifdef __cplusplus 5extern "C" { 6#endif 7 8/* 9** Copyright (c) 2015 The Khronos Group Inc. 10** 11** Permission is hereby granted, free of charge, to any person obtaining a 12** copy of this software and/or associated documentation files (the 13** "Materials"), to deal in the Materials without restriction, including 14** without limitation the rights to use, copy, modify, merge, publish, 15** distribute, sublicense, and/or sell copies of the Materials, and to 16** permit persons to whom the Materials are furnished to do so, subject to 17** the following conditions: 18** 19** The above copyright notice and this permission notice shall be included 20** in all copies or substantial portions of the Materials. 21** 22** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 23** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 24** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 25** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY 26** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 27** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 28** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. 29*/ 30 31/* 32** This header is generated from the Khronos Vulkan XML API Registry. 33** 34*/ 35 36 37#define VK_VERSION_1_0 1 38#include "vk_platform.h" 39 40#define VK_MAKE_VERSION(major, minor, patch) \ 41 ((major << 22) | (minor << 12) | patch) 42 43// Vulkan API version supported by this file 44#define VK_API_VERSION VK_MAKE_VERSION(1, 0, 2) 45 46 47#define VK_NULL_HANDLE 0 48 49 50 51#define VK_DEFINE_HANDLE(object) typedef struct object##_T* object; 52 53 54#if defined(__LP64__) || defined(_WIN64) || defined(__x86_64__) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__) 55 #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object; 56#else 57 #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object; 58#endif 59 60 61 62typedef uint32_t VkFlags; 63typedef uint32_t VkBool32; 64typedef uint64_t VkDeviceSize; 65typedef uint32_t VkSampleMask; 66 67VK_DEFINE_HANDLE(VkInstance) 68VK_DEFINE_HANDLE(VkPhysicalDevice) 69VK_DEFINE_HANDLE(VkDevice) 70VK_DEFINE_HANDLE(VkQueue) 71VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore) 72VK_DEFINE_HANDLE(VkCommandBuffer) 73VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence) 74VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory) 75VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer) 76VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage) 77VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent) 78VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool) 79VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView) 80VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView) 81VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule) 82VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache) 83VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout) 84VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass) 85VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline) 86VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout) 87VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler) 88VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool) 89VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet) 90VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer) 91VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool) 92 93#define VK_LOD_CLAMP_NONE 1000.0f 94#define VK_REMAINING_MIP_LEVELS (~0U) 95#define VK_REMAINING_ARRAY_LAYERS (~0U) 96#define VK_WHOLE_SIZE (~0ULL) 97#define VK_ATTACHMENT_UNUSED (~0U) 98#define VK_TRUE 1 99#define VK_FALSE 0 100#define VK_QUEUE_FAMILY_IGNORED (~0U) 101#define VK_SUBPASS_EXTERNAL (~0U) 102#define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE 256 103#define VK_UUID_SIZE 16 104#define VK_MAX_MEMORY_TYPES 32 105#define VK_MAX_MEMORY_HEAPS 16 106#define VK_MAX_EXTENSION_NAME_SIZE 256 107#define VK_MAX_DESCRIPTION_SIZE 256 108 109 110typedef enum VkPipelineCacheHeaderVersion { 111 VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1, 112 VK_PIPELINE_CACHE_HEADER_VERSION_BEGIN_RANGE = VK_PIPELINE_CACHE_HEADER_VERSION_ONE, 113 VK_PIPELINE_CACHE_HEADER_VERSION_END_RANGE = VK_PIPELINE_CACHE_HEADER_VERSION_ONE, 114 VK_PIPELINE_CACHE_HEADER_VERSION_RANGE_SIZE = (VK_PIPELINE_CACHE_HEADER_VERSION_ONE - VK_PIPELINE_CACHE_HEADER_VERSION_ONE + 1), 115 VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF 116} VkPipelineCacheHeaderVersion; 117 118typedef enum VkResult { 119 VK_SUCCESS = 0, 120 VK_NOT_READY = 1, 121 VK_TIMEOUT = 2, 122 VK_EVENT_SET = 3, 123 VK_EVENT_RESET = 4, 124 VK_INCOMPLETE = 5, 125 VK_ERROR_OUT_OF_HOST_MEMORY = -1, 126 VK_ERROR_OUT_OF_DEVICE_MEMORY = -2, 127 VK_ERROR_INITIALIZATION_FAILED = -3, 128 VK_ERROR_DEVICE_LOST = -4, 129 VK_ERROR_MEMORY_MAP_FAILED = -5, 130 VK_ERROR_LAYER_NOT_PRESENT = -6, 131 VK_ERROR_EXTENSION_NOT_PRESENT = -7, 132 VK_ERROR_FEATURE_NOT_PRESENT = -8, 133 VK_ERROR_INCOMPATIBLE_DRIVER = -9, 134 VK_ERROR_TOO_MANY_OBJECTS = -10, 135 VK_ERROR_FORMAT_NOT_SUPPORTED = -11, 136 VK_ERROR_SURFACE_LOST_KHR = -1000000000, 137 VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001, 138 VK_SUBOPTIMAL_KHR = 1000001003, 139 VK_ERROR_OUT_OF_DATE_KHR = -1000001004, 140 VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001, 141 VK_ERROR_VALIDATION_FAILED_EXT = -1000011001, 142 VK_RESULT_BEGIN_RANGE = VK_ERROR_FORMAT_NOT_SUPPORTED, 143 VK_RESULT_END_RANGE = VK_INCOMPLETE, 144 VK_RESULT_RANGE_SIZE = (VK_INCOMPLETE - VK_ERROR_FORMAT_NOT_SUPPORTED + 1), 145 VK_RESULT_MAX_ENUM = 0x7FFFFFFF 146} VkResult; 147 148typedef enum VkStructureType { 149 VK_STRUCTURE_TYPE_APPLICATION_INFO = 0, 150 VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1, 151 VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2, 152 VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3, 153 VK_STRUCTURE_TYPE_SUBMIT_INFO = 4, 154 VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5, 155 VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6, 156 VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7, 157 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8, 158 VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9, 159 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10, 160 VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11, 161 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12, 162 VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13, 163 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14, 164 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15, 165 VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16, 166 VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17, 167 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18, 168 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19, 169 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20, 170 VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21, 171 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22, 172 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23, 173 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24, 174 VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25, 175 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26, 176 VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27, 177 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28, 178 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29, 179 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30, 180 VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31, 181 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32, 182 VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33, 183 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34, 184 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35, 185 VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36, 186 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37, 187 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38, 188 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39, 189 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40, 190 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41, 191 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42, 192 VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43, 193 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44, 194 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45, 195 VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46, 196 VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47, 197 VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48, 198 VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000, 199 VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001, 200 VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000, 201 VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001, 202 VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000, 203 VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000, 204 VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000, 205 VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000, 206 VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR = 1000007000, 207 VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000, 208 VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000, 209 VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = 1000011000, 210 VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO, 211 VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO, 212 VK_STRUCTURE_TYPE_RANGE_SIZE = (VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1), 213 VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF 214} VkStructureType; 215 216typedef enum VkSystemAllocationScope { 217 VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0, 218 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1, 219 VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2, 220 VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3, 221 VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4, 222 VK_SYSTEM_ALLOCATION_SCOPE_BEGIN_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_COMMAND, 223 VK_SYSTEM_ALLOCATION_SCOPE_END_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE, 224 VK_SYSTEM_ALLOCATION_SCOPE_RANGE_SIZE = (VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE - VK_SYSTEM_ALLOCATION_SCOPE_COMMAND + 1), 225 VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF 226} VkSystemAllocationScope; 227 228typedef enum VkInternalAllocationType { 229 VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0, 230 VK_INTERNAL_ALLOCATION_TYPE_BEGIN_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE, 231 VK_INTERNAL_ALLOCATION_TYPE_END_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE, 232 VK_INTERNAL_ALLOCATION_TYPE_RANGE_SIZE = (VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE - VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE + 1), 233 VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF 234} VkInternalAllocationType; 235 236typedef enum VkFormat { 237 VK_FORMAT_UNDEFINED = 0, 238 VK_FORMAT_R4G4_UNORM_PACK8 = 1, 239 VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2, 240 VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3, 241 VK_FORMAT_R5G6B5_UNORM_PACK16 = 4, 242 VK_FORMAT_B5G6R5_UNORM_PACK16 = 5, 243 VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6, 244 VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7, 245 VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8, 246 VK_FORMAT_R8_UNORM = 9, 247 VK_FORMAT_R8_SNORM = 10, 248 VK_FORMAT_R8_USCALED = 11, 249 VK_FORMAT_R8_SSCALED = 12, 250 VK_FORMAT_R8_UINT = 13, 251 VK_FORMAT_R8_SINT = 14, 252 VK_FORMAT_R8_SRGB = 15, 253 VK_FORMAT_R8G8_UNORM = 16, 254 VK_FORMAT_R8G8_SNORM = 17, 255 VK_FORMAT_R8G8_USCALED = 18, 256 VK_FORMAT_R8G8_SSCALED = 19, 257 VK_FORMAT_R8G8_UINT = 20, 258 VK_FORMAT_R8G8_SINT = 21, 259 VK_FORMAT_R8G8_SRGB = 22, 260 VK_FORMAT_R8G8B8_UNORM = 23, 261 VK_FORMAT_R8G8B8_SNORM = 24, 262 VK_FORMAT_R8G8B8_USCALED = 25, 263 VK_FORMAT_R8G8B8_SSCALED = 26, 264 VK_FORMAT_R8G8B8_UINT = 27, 265 VK_FORMAT_R8G8B8_SINT = 28, 266 VK_FORMAT_R8G8B8_SRGB = 29, 267 VK_FORMAT_B8G8R8_UNORM = 30, 268 VK_FORMAT_B8G8R8_SNORM = 31, 269 VK_FORMAT_B8G8R8_USCALED = 32, 270 VK_FORMAT_B8G8R8_SSCALED = 33, 271 VK_FORMAT_B8G8R8_UINT = 34, 272 VK_FORMAT_B8G8R8_SINT = 35, 273 VK_FORMAT_B8G8R8_SRGB = 36, 274 VK_FORMAT_R8G8B8A8_UNORM = 37, 275 VK_FORMAT_R8G8B8A8_SNORM = 38, 276 VK_FORMAT_R8G8B8A8_USCALED = 39, 277 VK_FORMAT_R8G8B8A8_SSCALED = 40, 278 VK_FORMAT_R8G8B8A8_UINT = 41, 279 VK_FORMAT_R8G8B8A8_SINT = 42, 280 VK_FORMAT_R8G8B8A8_SRGB = 43, 281 VK_FORMAT_B8G8R8A8_UNORM = 44, 282 VK_FORMAT_B8G8R8A8_SNORM = 45, 283 VK_FORMAT_B8G8R8A8_USCALED = 46, 284 VK_FORMAT_B8G8R8A8_SSCALED = 47, 285 VK_FORMAT_B8G8R8A8_UINT = 48, 286 VK_FORMAT_B8G8R8A8_SINT = 49, 287 VK_FORMAT_B8G8R8A8_SRGB = 50, 288 VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51, 289 VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52, 290 VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53, 291 VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54, 292 VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55, 293 VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56, 294 VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57, 295 VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58, 296 VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59, 297 VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60, 298 VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61, 299 VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62, 300 VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63, 301 VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64, 302 VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65, 303 VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66, 304 VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67, 305 VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68, 306 VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69, 307 VK_FORMAT_R16_UNORM = 70, 308 VK_FORMAT_R16_SNORM = 71, 309 VK_FORMAT_R16_USCALED = 72, 310 VK_FORMAT_R16_SSCALED = 73, 311 VK_FORMAT_R16_UINT = 74, 312 VK_FORMAT_R16_SINT = 75, 313 VK_FORMAT_R16_SFLOAT = 76, 314 VK_FORMAT_R16G16_UNORM = 77, 315 VK_FORMAT_R16G16_SNORM = 78, 316 VK_FORMAT_R16G16_USCALED = 79, 317 VK_FORMAT_R16G16_SSCALED = 80, 318 VK_FORMAT_R16G16_UINT = 81, 319 VK_FORMAT_R16G16_SINT = 82, 320 VK_FORMAT_R16G16_SFLOAT = 83, 321 VK_FORMAT_R16G16B16_UNORM = 84, 322 VK_FORMAT_R16G16B16_SNORM = 85, 323 VK_FORMAT_R16G16B16_USCALED = 86, 324 VK_FORMAT_R16G16B16_SSCALED = 87, 325 VK_FORMAT_R16G16B16_UINT = 88, 326 VK_FORMAT_R16G16B16_SINT = 89, 327 VK_FORMAT_R16G16B16_SFLOAT = 90, 328 VK_FORMAT_R16G16B16A16_UNORM = 91, 329 VK_FORMAT_R16G16B16A16_SNORM = 92, 330 VK_FORMAT_R16G16B16A16_USCALED = 93, 331 VK_FORMAT_R16G16B16A16_SSCALED = 94, 332 VK_FORMAT_R16G16B16A16_UINT = 95, 333 VK_FORMAT_R16G16B16A16_SINT = 96, 334 VK_FORMAT_R16G16B16A16_SFLOAT = 97, 335 VK_FORMAT_R32_UINT = 98, 336 VK_FORMAT_R32_SINT = 99, 337 VK_FORMAT_R32_SFLOAT = 100, 338 VK_FORMAT_R32G32_UINT = 101, 339 VK_FORMAT_R32G32_SINT = 102, 340 VK_FORMAT_R32G32_SFLOAT = 103, 341 VK_FORMAT_R32G32B32_UINT = 104, 342 VK_FORMAT_R32G32B32_SINT = 105, 343 VK_FORMAT_R32G32B32_SFLOAT = 106, 344 VK_FORMAT_R32G32B32A32_UINT = 107, 345 VK_FORMAT_R32G32B32A32_SINT = 108, 346 VK_FORMAT_R32G32B32A32_SFLOAT = 109, 347 VK_FORMAT_R64_UINT = 110, 348 VK_FORMAT_R64_SINT = 111, 349 VK_FORMAT_R64_SFLOAT = 112, 350 VK_FORMAT_R64G64_UINT = 113, 351 VK_FORMAT_R64G64_SINT = 114, 352 VK_FORMAT_R64G64_SFLOAT = 115, 353 VK_FORMAT_R64G64B64_UINT = 116, 354 VK_FORMAT_R64G64B64_SINT = 117, 355 VK_FORMAT_R64G64B64_SFLOAT = 118, 356 VK_FORMAT_R64G64B64A64_UINT = 119, 357 VK_FORMAT_R64G64B64A64_SINT = 120, 358 VK_FORMAT_R64G64B64A64_SFLOAT = 121, 359 VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122, 360 VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123, 361 VK_FORMAT_D16_UNORM = 124, 362 VK_FORMAT_X8_D24_UNORM_PACK32 = 125, 363 VK_FORMAT_D32_SFLOAT = 126, 364 VK_FORMAT_S8_UINT = 127, 365 VK_FORMAT_D16_UNORM_S8_UINT = 128, 366 VK_FORMAT_D24_UNORM_S8_UINT = 129, 367 VK_FORMAT_D32_SFLOAT_S8_UINT = 130, 368 VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131, 369 VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132, 370 VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133, 371 VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134, 372 VK_FORMAT_BC2_UNORM_BLOCK = 135, 373 VK_FORMAT_BC2_SRGB_BLOCK = 136, 374 VK_FORMAT_BC3_UNORM_BLOCK = 137, 375 VK_FORMAT_BC3_SRGB_BLOCK = 138, 376 VK_FORMAT_BC4_UNORM_BLOCK = 139, 377 VK_FORMAT_BC4_SNORM_BLOCK = 140, 378 VK_FORMAT_BC5_UNORM_BLOCK = 141, 379 VK_FORMAT_BC5_SNORM_BLOCK = 142, 380 VK_FORMAT_BC6H_UFLOAT_BLOCK = 143, 381 VK_FORMAT_BC6H_SFLOAT_BLOCK = 144, 382 VK_FORMAT_BC7_UNORM_BLOCK = 145, 383 VK_FORMAT_BC7_SRGB_BLOCK = 146, 384 VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147, 385 VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148, 386 VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149, 387 VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150, 388 VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151, 389 VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152, 390 VK_FORMAT_EAC_R11_UNORM_BLOCK = 153, 391 VK_FORMAT_EAC_R11_SNORM_BLOCK = 154, 392 VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155, 393 VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156, 394 VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157, 395 VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158, 396 VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159, 397 VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160, 398 VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161, 399 VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162, 400 VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163, 401 VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164, 402 VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165, 403 VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166, 404 VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167, 405 VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168, 406 VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169, 407 VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170, 408 VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171, 409 VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172, 410 VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173, 411 VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174, 412 VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175, 413 VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176, 414 VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177, 415 VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178, 416 VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179, 417 VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180, 418 VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181, 419 VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182, 420 VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183, 421 VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184, 422 VK_FORMAT_BEGIN_RANGE = VK_FORMAT_UNDEFINED, 423 VK_FORMAT_END_RANGE = VK_FORMAT_ASTC_12x12_SRGB_BLOCK, 424 VK_FORMAT_RANGE_SIZE = (VK_FORMAT_ASTC_12x12_SRGB_BLOCK - VK_FORMAT_UNDEFINED + 1), 425 VK_FORMAT_MAX_ENUM = 0x7FFFFFFF 426} VkFormat; 427 428typedef enum VkImageType { 429 VK_IMAGE_TYPE_1D = 0, 430 VK_IMAGE_TYPE_2D = 1, 431 VK_IMAGE_TYPE_3D = 2, 432 VK_IMAGE_TYPE_BEGIN_RANGE = VK_IMAGE_TYPE_1D, 433 VK_IMAGE_TYPE_END_RANGE = VK_IMAGE_TYPE_3D, 434 VK_IMAGE_TYPE_RANGE_SIZE = (VK_IMAGE_TYPE_3D - VK_IMAGE_TYPE_1D + 1), 435 VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF 436} VkImageType; 437 438typedef enum VkImageTiling { 439 VK_IMAGE_TILING_OPTIMAL = 0, 440 VK_IMAGE_TILING_LINEAR = 1, 441 VK_IMAGE_TILING_BEGIN_RANGE = VK_IMAGE_TILING_OPTIMAL, 442 VK_IMAGE_TILING_END_RANGE = VK_IMAGE_TILING_LINEAR, 443 VK_IMAGE_TILING_RANGE_SIZE = (VK_IMAGE_TILING_LINEAR - VK_IMAGE_TILING_OPTIMAL + 1), 444 VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF 445} VkImageTiling; 446 447typedef enum VkPhysicalDeviceType { 448 VK_PHYSICAL_DEVICE_TYPE_OTHER = 0, 449 VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1, 450 VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2, 451 VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3, 452 VK_PHYSICAL_DEVICE_TYPE_CPU = 4, 453 VK_PHYSICAL_DEVICE_TYPE_BEGIN_RANGE = VK_PHYSICAL_DEVICE_TYPE_OTHER, 454 VK_PHYSICAL_DEVICE_TYPE_END_RANGE = VK_PHYSICAL_DEVICE_TYPE_CPU, 455 VK_PHYSICAL_DEVICE_TYPE_RANGE_SIZE = (VK_PHYSICAL_DEVICE_TYPE_CPU - VK_PHYSICAL_DEVICE_TYPE_OTHER + 1), 456 VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF 457} VkPhysicalDeviceType; 458 459typedef enum VkQueryType { 460 VK_QUERY_TYPE_OCCLUSION = 0, 461 VK_QUERY_TYPE_PIPELINE_STATISTICS = 1, 462 VK_QUERY_TYPE_TIMESTAMP = 2, 463 VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION, 464 VK_QUERY_TYPE_END_RANGE = VK_QUERY_TYPE_TIMESTAMP, 465 VK_QUERY_TYPE_RANGE_SIZE = (VK_QUERY_TYPE_TIMESTAMP - VK_QUERY_TYPE_OCCLUSION + 1), 466 VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF 467} VkQueryType; 468 469typedef enum VkSharingMode { 470 VK_SHARING_MODE_EXCLUSIVE = 0, 471 VK_SHARING_MODE_CONCURRENT = 1, 472 VK_SHARING_MODE_BEGIN_RANGE = VK_SHARING_MODE_EXCLUSIVE, 473 VK_SHARING_MODE_END_RANGE = VK_SHARING_MODE_CONCURRENT, 474 VK_SHARING_MODE_RANGE_SIZE = (VK_SHARING_MODE_CONCURRENT - VK_SHARING_MODE_EXCLUSIVE + 1), 475 VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF 476} VkSharingMode; 477 478typedef enum VkImageLayout { 479 VK_IMAGE_LAYOUT_UNDEFINED = 0, 480 VK_IMAGE_LAYOUT_GENERAL = 1, 481 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2, 482 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3, 483 VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4, 484 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5, 485 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6, 486 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7, 487 VK_IMAGE_LAYOUT_PREINITIALIZED = 8, 488 VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002, 489 VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED, 490 VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_PREINITIALIZED, 491 VK_IMAGE_LAYOUT_RANGE_SIZE = (VK_IMAGE_LAYOUT_PREINITIALIZED - VK_IMAGE_LAYOUT_UNDEFINED + 1), 492 VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF 493} VkImageLayout; 494 495typedef enum VkImageViewType { 496 VK_IMAGE_VIEW_TYPE_1D = 0, 497 VK_IMAGE_VIEW_TYPE_2D = 1, 498 VK_IMAGE_VIEW_TYPE_3D = 2, 499 VK_IMAGE_VIEW_TYPE_CUBE = 3, 500 VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4, 501 VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5, 502 VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6, 503 VK_IMAGE_VIEW_TYPE_BEGIN_RANGE = VK_IMAGE_VIEW_TYPE_1D, 504 VK_IMAGE_VIEW_TYPE_END_RANGE = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, 505 VK_IMAGE_VIEW_TYPE_RANGE_SIZE = (VK_IMAGE_VIEW_TYPE_CUBE_ARRAY - VK_IMAGE_VIEW_TYPE_1D + 1), 506 VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF 507} VkImageViewType; 508 509typedef enum VkComponentSwizzle { 510 VK_COMPONENT_SWIZZLE_IDENTITY = 0, 511 VK_COMPONENT_SWIZZLE_ZERO = 1, 512 VK_COMPONENT_SWIZZLE_ONE = 2, 513 VK_COMPONENT_SWIZZLE_R = 3, 514 VK_COMPONENT_SWIZZLE_G = 4, 515 VK_COMPONENT_SWIZZLE_B = 5, 516 VK_COMPONENT_SWIZZLE_A = 6, 517 VK_COMPONENT_SWIZZLE_BEGIN_RANGE = VK_COMPONENT_SWIZZLE_IDENTITY, 518 VK_COMPONENT_SWIZZLE_END_RANGE = VK_COMPONENT_SWIZZLE_A, 519 VK_COMPONENT_SWIZZLE_RANGE_SIZE = (VK_COMPONENT_SWIZZLE_A - VK_COMPONENT_SWIZZLE_IDENTITY + 1), 520 VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF 521} VkComponentSwizzle; 522 523typedef enum VkVertexInputRate { 524 VK_VERTEX_INPUT_RATE_VERTEX = 0, 525 VK_VERTEX_INPUT_RATE_INSTANCE = 1, 526 VK_VERTEX_INPUT_RATE_BEGIN_RANGE = VK_VERTEX_INPUT_RATE_VERTEX, 527 VK_VERTEX_INPUT_RATE_END_RANGE = VK_VERTEX_INPUT_RATE_INSTANCE, 528 VK_VERTEX_INPUT_RATE_RANGE_SIZE = (VK_VERTEX_INPUT_RATE_INSTANCE - VK_VERTEX_INPUT_RATE_VERTEX + 1), 529 VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF 530} VkVertexInputRate; 531 532typedef enum VkPrimitiveTopology { 533 VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0, 534 VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1, 535 VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2, 536 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3, 537 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4, 538 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5, 539 VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6, 540 VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7, 541 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8, 542 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9, 543 VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10, 544 VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = VK_PRIMITIVE_TOPOLOGY_POINT_LIST, 545 VK_PRIMITIVE_TOPOLOGY_END_RANGE = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, 546 VK_PRIMITIVE_TOPOLOGY_RANGE_SIZE = (VK_PRIMITIVE_TOPOLOGY_PATCH_LIST - VK_PRIMITIVE_TOPOLOGY_POINT_LIST + 1), 547 VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF 548} VkPrimitiveTopology; 549 550typedef enum VkPolygonMode { 551 VK_POLYGON_MODE_FILL = 0, 552 VK_POLYGON_MODE_LINE = 1, 553 VK_POLYGON_MODE_POINT = 2, 554 VK_POLYGON_MODE_BEGIN_RANGE = VK_POLYGON_MODE_FILL, 555 VK_POLYGON_MODE_END_RANGE = VK_POLYGON_MODE_POINT, 556 VK_POLYGON_MODE_RANGE_SIZE = (VK_POLYGON_MODE_POINT - VK_POLYGON_MODE_FILL + 1), 557 VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF 558} VkPolygonMode; 559 560typedef enum VkFrontFace { 561 VK_FRONT_FACE_COUNTER_CLOCKWISE = 0, 562 VK_FRONT_FACE_CLOCKWISE = 1, 563 VK_FRONT_FACE_BEGIN_RANGE = VK_FRONT_FACE_COUNTER_CLOCKWISE, 564 VK_FRONT_FACE_END_RANGE = VK_FRONT_FACE_CLOCKWISE, 565 VK_FRONT_FACE_RANGE_SIZE = (VK_FRONT_FACE_CLOCKWISE - VK_FRONT_FACE_COUNTER_CLOCKWISE + 1), 566 VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF 567} VkFrontFace; 568 569typedef enum VkCompareOp { 570 VK_COMPARE_OP_NEVER = 0, 571 VK_COMPARE_OP_LESS = 1, 572 VK_COMPARE_OP_EQUAL = 2, 573 VK_COMPARE_OP_LESS_OR_EQUAL = 3, 574 VK_COMPARE_OP_GREATER = 4, 575 VK_COMPARE_OP_NOT_EQUAL = 5, 576 VK_COMPARE_OP_GREATER_OR_EQUAL = 6, 577 VK_COMPARE_OP_ALWAYS = 7, 578 VK_COMPARE_OP_BEGIN_RANGE = VK_COMPARE_OP_NEVER, 579 VK_COMPARE_OP_END_RANGE = VK_COMPARE_OP_ALWAYS, 580 VK_COMPARE_OP_RANGE_SIZE = (VK_COMPARE_OP_ALWAYS - VK_COMPARE_OP_NEVER + 1), 581 VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF 582} VkCompareOp; 583 584typedef enum VkStencilOp { 585 VK_STENCIL_OP_KEEP = 0, 586 VK_STENCIL_OP_ZERO = 1, 587 VK_STENCIL_OP_REPLACE = 2, 588 VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3, 589 VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4, 590 VK_STENCIL_OP_INVERT = 5, 591 VK_STENCIL_OP_INCREMENT_AND_WRAP = 6, 592 VK_STENCIL_OP_DECREMENT_AND_WRAP = 7, 593 VK_STENCIL_OP_BEGIN_RANGE = VK_STENCIL_OP_KEEP, 594 VK_STENCIL_OP_END_RANGE = VK_STENCIL_OP_DECREMENT_AND_WRAP, 595 VK_STENCIL_OP_RANGE_SIZE = (VK_STENCIL_OP_DECREMENT_AND_WRAP - VK_STENCIL_OP_KEEP + 1), 596 VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF 597} VkStencilOp; 598 599typedef enum VkLogicOp { 600 VK_LOGIC_OP_CLEAR = 0, 601 VK_LOGIC_OP_AND = 1, 602 VK_LOGIC_OP_AND_REVERSE = 2, 603 VK_LOGIC_OP_COPY = 3, 604 VK_LOGIC_OP_AND_INVERTED = 4, 605 VK_LOGIC_OP_NO_OP = 5, 606 VK_LOGIC_OP_XOR = 6, 607 VK_LOGIC_OP_OR = 7, 608 VK_LOGIC_OP_NOR = 8, 609 VK_LOGIC_OP_EQUIVALENT = 9, 610 VK_LOGIC_OP_INVERT = 10, 611 VK_LOGIC_OP_OR_REVERSE = 11, 612 VK_LOGIC_OP_COPY_INVERTED = 12, 613 VK_LOGIC_OP_OR_INVERTED = 13, 614 VK_LOGIC_OP_NAND = 14, 615 VK_LOGIC_OP_SET = 15, 616 VK_LOGIC_OP_BEGIN_RANGE = VK_LOGIC_OP_CLEAR, 617 VK_LOGIC_OP_END_RANGE = VK_LOGIC_OP_SET, 618 VK_LOGIC_OP_RANGE_SIZE = (VK_LOGIC_OP_SET - VK_LOGIC_OP_CLEAR + 1), 619 VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF 620} VkLogicOp; 621 622typedef enum VkBlendFactor { 623 VK_BLEND_FACTOR_ZERO = 0, 624 VK_BLEND_FACTOR_ONE = 1, 625 VK_BLEND_FACTOR_SRC_COLOR = 2, 626 VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3, 627 VK_BLEND_FACTOR_DST_COLOR = 4, 628 VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5, 629 VK_BLEND_FACTOR_SRC_ALPHA = 6, 630 VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7, 631 VK_BLEND_FACTOR_DST_ALPHA = 8, 632 VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9, 633 VK_BLEND_FACTOR_CONSTANT_COLOR = 10, 634 VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11, 635 VK_BLEND_FACTOR_CONSTANT_ALPHA = 12, 636 VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13, 637 VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14, 638 VK_BLEND_FACTOR_SRC1_COLOR = 15, 639 VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16, 640 VK_BLEND_FACTOR_SRC1_ALPHA = 17, 641 VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18, 642 VK_BLEND_FACTOR_BEGIN_RANGE = VK_BLEND_FACTOR_ZERO, 643 VK_BLEND_FACTOR_END_RANGE = VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA, 644 VK_BLEND_FACTOR_RANGE_SIZE = (VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA - VK_BLEND_FACTOR_ZERO + 1), 645 VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF 646} VkBlendFactor; 647 648typedef enum VkBlendOp { 649 VK_BLEND_OP_ADD = 0, 650 VK_BLEND_OP_SUBTRACT = 1, 651 VK_BLEND_OP_REVERSE_SUBTRACT = 2, 652 VK_BLEND_OP_MIN = 3, 653 VK_BLEND_OP_MAX = 4, 654 VK_BLEND_OP_BEGIN_RANGE = VK_BLEND_OP_ADD, 655 VK_BLEND_OP_END_RANGE = VK_BLEND_OP_MAX, 656 VK_BLEND_OP_RANGE_SIZE = (VK_BLEND_OP_MAX - VK_BLEND_OP_ADD + 1), 657 VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF 658} VkBlendOp; 659 660typedef enum VkDynamicState { 661 VK_DYNAMIC_STATE_VIEWPORT = 0, 662 VK_DYNAMIC_STATE_SCISSOR = 1, 663 VK_DYNAMIC_STATE_LINE_WIDTH = 2, 664 VK_DYNAMIC_STATE_DEPTH_BIAS = 3, 665 VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4, 666 VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5, 667 VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6, 668 VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7, 669 VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8, 670 VK_DYNAMIC_STATE_BEGIN_RANGE = VK_DYNAMIC_STATE_VIEWPORT, 671 VK_DYNAMIC_STATE_END_RANGE = VK_DYNAMIC_STATE_STENCIL_REFERENCE, 672 VK_DYNAMIC_STATE_RANGE_SIZE = (VK_DYNAMIC_STATE_STENCIL_REFERENCE - VK_DYNAMIC_STATE_VIEWPORT + 1), 673 VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF 674} VkDynamicState; 675 676typedef enum VkFilter { 677 VK_FILTER_NEAREST = 0, 678 VK_FILTER_LINEAR = 1, 679 VK_FILTER_BEGIN_RANGE = VK_FILTER_NEAREST, 680 VK_FILTER_END_RANGE = VK_FILTER_LINEAR, 681 VK_FILTER_RANGE_SIZE = (VK_FILTER_LINEAR - VK_FILTER_NEAREST + 1), 682 VK_FILTER_MAX_ENUM = 0x7FFFFFFF 683} VkFilter; 684 685typedef enum VkSamplerMipmapMode { 686 VK_SAMPLER_MIPMAP_MODE_NEAREST = 0, 687 VK_SAMPLER_MIPMAP_MODE_LINEAR = 1, 688 VK_SAMPLER_MIPMAP_MODE_BEGIN_RANGE = VK_SAMPLER_MIPMAP_MODE_NEAREST, 689 VK_SAMPLER_MIPMAP_MODE_END_RANGE = VK_SAMPLER_MIPMAP_MODE_LINEAR, 690 VK_SAMPLER_MIPMAP_MODE_RANGE_SIZE = (VK_SAMPLER_MIPMAP_MODE_LINEAR - VK_SAMPLER_MIPMAP_MODE_NEAREST + 1), 691 VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF 692} VkSamplerMipmapMode; 693 694typedef enum VkSamplerAddressMode { 695 VK_SAMPLER_ADDRESS_MODE_REPEAT = 0, 696 VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1, 697 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2, 698 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3, 699 VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4, 700 VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE = VK_SAMPLER_ADDRESS_MODE_REPEAT, 701 VK_SAMPLER_ADDRESS_MODE_END_RANGE = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE, 702 VK_SAMPLER_ADDRESS_MODE_RANGE_SIZE = (VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE - VK_SAMPLER_ADDRESS_MODE_REPEAT + 1), 703 VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF 704} VkSamplerAddressMode; 705 706typedef enum VkBorderColor { 707 VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0, 708 VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1, 709 VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2, 710 VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3, 711 VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4, 712 VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5, 713 VK_BORDER_COLOR_BEGIN_RANGE = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, 714 VK_BORDER_COLOR_END_RANGE = VK_BORDER_COLOR_INT_OPAQUE_WHITE, 715 VK_BORDER_COLOR_RANGE_SIZE = (VK_BORDER_COLOR_INT_OPAQUE_WHITE - VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK + 1), 716 VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF 717} VkBorderColor; 718 719typedef enum VkDescriptorType { 720 VK_DESCRIPTOR_TYPE_SAMPLER = 0, 721 VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1, 722 VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2, 723 VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3, 724 VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4, 725 VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5, 726 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6, 727 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7, 728 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8, 729 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9, 730 VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10, 731 VK_DESCRIPTOR_TYPE_BEGIN_RANGE = VK_DESCRIPTOR_TYPE_SAMPLER, 732 VK_DESCRIPTOR_TYPE_END_RANGE = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, 733 VK_DESCRIPTOR_TYPE_RANGE_SIZE = (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT - VK_DESCRIPTOR_TYPE_SAMPLER + 1), 734 VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF 735} VkDescriptorType; 736 737typedef enum VkAttachmentLoadOp { 738 VK_ATTACHMENT_LOAD_OP_LOAD = 0, 739 VK_ATTACHMENT_LOAD_OP_CLEAR = 1, 740 VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2, 741 VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE = VK_ATTACHMENT_LOAD_OP_LOAD, 742 VK_ATTACHMENT_LOAD_OP_END_RANGE = VK_ATTACHMENT_LOAD_OP_DONT_CARE, 743 VK_ATTACHMENT_LOAD_OP_RANGE_SIZE = (VK_ATTACHMENT_LOAD_OP_DONT_CARE - VK_ATTACHMENT_LOAD_OP_LOAD + 1), 744 VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF 745} VkAttachmentLoadOp; 746 747typedef enum VkAttachmentStoreOp { 748 VK_ATTACHMENT_STORE_OP_STORE = 0, 749 VK_ATTACHMENT_STORE_OP_DONT_CARE = 1, 750 VK_ATTACHMENT_STORE_OP_BEGIN_RANGE = VK_ATTACHMENT_STORE_OP_STORE, 751 VK_ATTACHMENT_STORE_OP_END_RANGE = VK_ATTACHMENT_STORE_OP_DONT_CARE, 752 VK_ATTACHMENT_STORE_OP_RANGE_SIZE = (VK_ATTACHMENT_STORE_OP_DONT_CARE - VK_ATTACHMENT_STORE_OP_STORE + 1), 753 VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF 754} VkAttachmentStoreOp; 755 756typedef enum VkPipelineBindPoint { 757 VK_PIPELINE_BIND_POINT_GRAPHICS = 0, 758 VK_PIPELINE_BIND_POINT_COMPUTE = 1, 759 VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VK_PIPELINE_BIND_POINT_GRAPHICS, 760 VK_PIPELINE_BIND_POINT_END_RANGE = VK_PIPELINE_BIND_POINT_COMPUTE, 761 VK_PIPELINE_BIND_POINT_RANGE_SIZE = (VK_PIPELINE_BIND_POINT_COMPUTE - VK_PIPELINE_BIND_POINT_GRAPHICS + 1), 762 VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF 763} VkPipelineBindPoint; 764 765typedef enum VkCommandBufferLevel { 766 VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0, 767 VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1, 768 VK_COMMAND_BUFFER_LEVEL_BEGIN_RANGE = VK_COMMAND_BUFFER_LEVEL_PRIMARY, 769 VK_COMMAND_BUFFER_LEVEL_END_RANGE = VK_COMMAND_BUFFER_LEVEL_SECONDARY, 770 VK_COMMAND_BUFFER_LEVEL_RANGE_SIZE = (VK_COMMAND_BUFFER_LEVEL_SECONDARY - VK_COMMAND_BUFFER_LEVEL_PRIMARY + 1), 771 VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF 772} VkCommandBufferLevel; 773 774typedef enum VkIndexType { 775 VK_INDEX_TYPE_UINT16 = 0, 776 VK_INDEX_TYPE_UINT32 = 1, 777 VK_INDEX_TYPE_BEGIN_RANGE = VK_INDEX_TYPE_UINT16, 778 VK_INDEX_TYPE_END_RANGE = VK_INDEX_TYPE_UINT32, 779 VK_INDEX_TYPE_RANGE_SIZE = (VK_INDEX_TYPE_UINT32 - VK_INDEX_TYPE_UINT16 + 1), 780 VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF 781} VkIndexType; 782 783typedef enum VkSubpassContents { 784 VK_SUBPASS_CONTENTS_INLINE = 0, 785 VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1, 786 VK_SUBPASS_CONTENTS_BEGIN_RANGE = VK_SUBPASS_CONTENTS_INLINE, 787 VK_SUBPASS_CONTENTS_END_RANGE = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS, 788 VK_SUBPASS_CONTENTS_RANGE_SIZE = (VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS - VK_SUBPASS_CONTENTS_INLINE + 1), 789 VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF 790} VkSubpassContents; 791 792typedef VkFlags VkInstanceCreateFlags; 793 794typedef enum VkFormatFeatureFlagBits { 795 VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001, 796 VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002, 797 VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004, 798 VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008, 799 VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010, 800 VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020, 801 VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040, 802 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080, 803 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100, 804 VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200, 805 VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400, 806 VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800, 807 VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000, 808} VkFormatFeatureFlagBits; 809typedef VkFlags VkFormatFeatureFlags; 810 811typedef enum VkImageUsageFlagBits { 812 VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001, 813 VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002, 814 VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004, 815 VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008, 816 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010, 817 VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020, 818 VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040, 819 VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080, 820} VkImageUsageFlagBits; 821typedef VkFlags VkImageUsageFlags; 822 823typedef enum VkImageCreateFlagBits { 824 VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001, 825 VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, 826 VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004, 827 VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008, 828 VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010, 829} VkImageCreateFlagBits; 830typedef VkFlags VkImageCreateFlags; 831 832typedef enum VkSampleCountFlagBits { 833 VK_SAMPLE_COUNT_1_BIT = 0x00000001, 834 VK_SAMPLE_COUNT_2_BIT = 0x00000002, 835 VK_SAMPLE_COUNT_4_BIT = 0x00000004, 836 VK_SAMPLE_COUNT_8_BIT = 0x00000008, 837 VK_SAMPLE_COUNT_16_BIT = 0x00000010, 838 VK_SAMPLE_COUNT_32_BIT = 0x00000020, 839 VK_SAMPLE_COUNT_64_BIT = 0x00000040, 840} VkSampleCountFlagBits; 841typedef VkFlags VkSampleCountFlags; 842 843typedef enum VkQueueFlagBits { 844 VK_QUEUE_GRAPHICS_BIT = 0x00000001, 845 VK_QUEUE_COMPUTE_BIT = 0x00000002, 846 VK_QUEUE_TRANSFER_BIT = 0x00000004, 847 VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008, 848} VkQueueFlagBits; 849typedef VkFlags VkQueueFlags; 850 851typedef enum VkMemoryPropertyFlagBits { 852 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001, 853 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002, 854 VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004, 855 VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008, 856 VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010, 857} VkMemoryPropertyFlagBits; 858typedef VkFlags VkMemoryPropertyFlags; 859 860typedef enum VkMemoryHeapFlagBits { 861 VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001, 862} VkMemoryHeapFlagBits; 863typedef VkFlags VkMemoryHeapFlags; 864typedef VkFlags VkDeviceCreateFlags; 865typedef VkFlags VkDeviceQueueCreateFlags; 866 867typedef enum VkPipelineStageFlagBits { 868 VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001, 869 VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002, 870 VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004, 871 VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008, 872 VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010, 873 VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020, 874 VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040, 875 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080, 876 VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100, 877 VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200, 878 VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400, 879 VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800, 880 VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000, 881 VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000, 882 VK_PIPELINE_STAGE_HOST_BIT = 0x00004000, 883 VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000, 884 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000, 885} VkPipelineStageFlagBits; 886typedef VkFlags VkPipelineStageFlags; 887typedef VkFlags VkMemoryMapFlags; 888 889typedef enum VkImageAspectFlagBits { 890 VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001, 891 VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002, 892 VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004, 893 VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008, 894} VkImageAspectFlagBits; 895typedef VkFlags VkImageAspectFlags; 896 897typedef enum VkSparseImageFormatFlagBits { 898 VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001, 899 VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002, 900 VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004, 901} VkSparseImageFormatFlagBits; 902typedef VkFlags VkSparseImageFormatFlags; 903 904typedef enum VkSparseMemoryBindFlagBits { 905 VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0x00000001, 906} VkSparseMemoryBindFlagBits; 907typedef VkFlags VkSparseMemoryBindFlags; 908 909typedef enum VkFenceCreateFlagBits { 910 VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001, 911} VkFenceCreateFlagBits; 912typedef VkFlags VkFenceCreateFlags; 913typedef VkFlags VkSemaphoreCreateFlags; 914typedef VkFlags VkEventCreateFlags; 915typedef VkFlags VkQueryPoolCreateFlags; 916 917typedef enum VkQueryPipelineStatisticFlagBits { 918 VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001, 919 VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002, 920 VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004, 921 VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008, 922 VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0x00000010, 923 VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0x00000020, 924 VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0x00000040, 925 VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0x00000080, 926 VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x00000100, 927 VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0x00000200, 928 VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400, 929} VkQueryPipelineStatisticFlagBits; 930typedef VkFlags VkQueryPipelineStatisticFlags; 931 932typedef enum VkQueryResultFlagBits { 933 VK_QUERY_RESULT_64_BIT = 0x00000001, 934 VK_QUERY_RESULT_WAIT_BIT = 0x00000002, 935 VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004, 936 VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008, 937} VkQueryResultFlagBits; 938typedef VkFlags VkQueryResultFlags; 939 940typedef enum VkBufferCreateFlagBits { 941 VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001, 942 VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, 943 VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004, 944} VkBufferCreateFlagBits; 945typedef VkFlags VkBufferCreateFlags; 946 947typedef enum VkBufferUsageFlagBits { 948 VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001, 949 VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002, 950 VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004, 951 VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008, 952 VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010, 953 VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020, 954 VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040, 955 VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080, 956 VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100, 957} VkBufferUsageFlagBits; 958typedef VkFlags VkBufferUsageFlags; 959typedef VkFlags VkBufferViewCreateFlags; 960typedef VkFlags VkImageViewCreateFlags; 961typedef VkFlags VkShaderModuleCreateFlags; 962typedef VkFlags VkPipelineCacheCreateFlags; 963 964typedef enum VkPipelineCreateFlagBits { 965 VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001, 966 VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002, 967 VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004, 968} VkPipelineCreateFlagBits; 969typedef VkFlags VkPipelineCreateFlags; 970typedef VkFlags VkPipelineShaderStageCreateFlags; 971 972typedef enum VkShaderStageFlagBits { 973 VK_SHADER_STAGE_VERTEX_BIT = 0x00000001, 974 VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002, 975 VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004, 976 VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008, 977 VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010, 978 VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020, 979 VK_SHADER_STAGE_ALL_GRAPHICS = 0x1F, 980 VK_SHADER_STAGE_ALL = 0x7FFFFFFF, 981} VkShaderStageFlagBits; 982typedef VkFlags VkPipelineVertexInputStateCreateFlags; 983typedef VkFlags VkPipelineInputAssemblyStateCreateFlags; 984typedef VkFlags VkPipelineTessellationStateCreateFlags; 985typedef VkFlags VkPipelineViewportStateCreateFlags; 986typedef VkFlags VkPipelineRasterizationStateCreateFlags; 987 988typedef enum VkCullModeFlagBits { 989 VK_CULL_MODE_NONE = 0, 990 VK_CULL_MODE_FRONT_BIT = 0x00000001, 991 VK_CULL_MODE_BACK_BIT = 0x00000002, 992 VK_CULL_MODE_FRONT_AND_BACK = 0x3, 993} VkCullModeFlagBits; 994typedef VkFlags VkCullModeFlags; 995typedef VkFlags VkPipelineMultisampleStateCreateFlags; 996typedef VkFlags VkPipelineDepthStencilStateCreateFlags; 997typedef VkFlags VkPipelineColorBlendStateCreateFlags; 998 999typedef enum VkColorComponentFlagBits { 1000 VK_COLOR_COMPONENT_R_BIT = 0x00000001, 1001 VK_COLOR_COMPONENT_G_BIT = 0x00000002, 1002 VK_COLOR_COMPONENT_B_BIT = 0x00000004, 1003 VK_COLOR_COMPONENT_A_BIT = 0x00000008, 1004} VkColorComponentFlagBits; 1005typedef VkFlags VkColorComponentFlags; 1006typedef VkFlags VkPipelineDynamicStateCreateFlags; 1007typedef VkFlags VkPipelineLayoutCreateFlags; 1008typedef VkFlags VkShaderStageFlags; 1009typedef VkFlags VkSamplerCreateFlags; 1010typedef VkFlags VkDescriptorSetLayoutCreateFlags; 1011 1012typedef enum VkDescriptorPoolCreateFlagBits { 1013 VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001, 1014} VkDescriptorPoolCreateFlagBits; 1015typedef VkFlags VkDescriptorPoolCreateFlags; 1016typedef VkFlags VkDescriptorPoolResetFlags; 1017typedef VkFlags VkFramebufferCreateFlags; 1018typedef VkFlags VkRenderPassCreateFlags; 1019 1020typedef enum VkAttachmentDescriptionFlagBits { 1021 VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001, 1022} VkAttachmentDescriptionFlagBits; 1023typedef VkFlags VkAttachmentDescriptionFlags; 1024typedef VkFlags VkSubpassDescriptionFlags; 1025 1026typedef enum VkAccessFlagBits { 1027 VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001, 1028 VK_ACCESS_INDEX_READ_BIT = 0x00000002, 1029 VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004, 1030 VK_ACCESS_UNIFORM_READ_BIT = 0x00000008, 1031 VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0x00000010, 1032 VK_ACCESS_SHADER_READ_BIT = 0x00000020, 1033 VK_ACCESS_SHADER_WRITE_BIT = 0x00000040, 1034 VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0x00000080, 1035 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100, 1036 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200, 1037 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400, 1038 VK_ACCESS_TRANSFER_READ_BIT = 0x00000800, 1039 VK_ACCESS_TRANSFER_WRITE_BIT = 0x00001000, 1040 VK_ACCESS_HOST_READ_BIT = 0x00002000, 1041 VK_ACCESS_HOST_WRITE_BIT = 0x00004000, 1042 VK_ACCESS_MEMORY_READ_BIT = 0x00008000, 1043 VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000, 1044} VkAccessFlagBits; 1045typedef VkFlags VkAccessFlags; 1046 1047typedef enum VkDependencyFlagBits { 1048 VK_DEPENDENCY_BY_REGION_BIT = 0x00000001, 1049} VkDependencyFlagBits; 1050typedef VkFlags VkDependencyFlags; 1051 1052typedef enum VkCommandPoolCreateFlagBits { 1053 VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001, 1054 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002, 1055} VkCommandPoolCreateFlagBits; 1056typedef VkFlags VkCommandPoolCreateFlags; 1057 1058typedef enum VkCommandPoolResetFlagBits { 1059 VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001, 1060} VkCommandPoolResetFlagBits; 1061typedef VkFlags VkCommandPoolResetFlags; 1062 1063typedef enum VkCommandBufferUsageFlagBits { 1064 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001, 1065 VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002, 1066 VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004, 1067} VkCommandBufferUsageFlagBits; 1068typedef VkFlags VkCommandBufferUsageFlags; 1069 1070typedef enum VkQueryControlFlagBits { 1071 VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001, 1072} VkQueryControlFlagBits; 1073typedef VkFlags VkQueryControlFlags; 1074 1075typedef enum VkCommandBufferResetFlagBits { 1076 VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001, 1077} VkCommandBufferResetFlagBits; 1078typedef VkFlags VkCommandBufferResetFlags; 1079 1080typedef enum VkStencilFaceFlagBits { 1081 VK_STENCIL_FACE_FRONT_BIT = 0x00000001, 1082 VK_STENCIL_FACE_BACK_BIT = 0x00000002, 1083 VK_STENCIL_FRONT_AND_BACK = 0x3, 1084} VkStencilFaceFlagBits; 1085typedef VkFlags VkStencilFaceFlags; 1086 1087typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)( 1088 void* pUserData, 1089 size_t size, 1090 size_t alignment, 1091 VkSystemAllocationScope allocationScope); 1092 1093typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)( 1094 void* pUserData, 1095 void* pOriginal, 1096 size_t size, 1097 size_t alignment, 1098 VkSystemAllocationScope allocationScope); 1099 1100typedef void (VKAPI_PTR *PFN_vkFreeFunction)( 1101 void* pUserData, 1102 void* pMemory); 1103 1104typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)( 1105 void* pUserData, 1106 size_t size, 1107 VkInternalAllocationType allocationType, 1108 VkSystemAllocationScope allocationScope); 1109 1110typedef void (VKAPI_PTR *PFN_vkInternalFreeNotification)( 1111 void* pUserData, 1112 size_t size, 1113 VkInternalAllocationType allocationType, 1114 VkSystemAllocationScope allocationScope); 1115 1116typedef void (VKAPI_PTR *PFN_vkVoidFunction)(void); 1117 1118typedef struct VkApplicationInfo { 1119 VkStructureType sType; 1120 const void* pNext; 1121 const char* pApplicationName; 1122 uint32_t applicationVersion; 1123 const char* pEngineName; 1124 uint32_t engineVersion; 1125 uint32_t apiVersion; 1126} VkApplicationInfo; 1127 1128typedef struct VkInstanceCreateInfo { 1129 VkStructureType sType; 1130 const void* pNext; 1131 VkInstanceCreateFlags flags; 1132 const VkApplicationInfo* pApplicationInfo; 1133 uint32_t enabledLayerCount; 1134 const char* const* ppEnabledLayerNames; 1135 uint32_t enabledExtensionCount; 1136 const char* const* ppEnabledExtensionNames; 1137} VkInstanceCreateInfo; 1138 1139typedef struct VkAllocationCallbacks { 1140 void* pUserData; 1141 PFN_vkAllocationFunction pfnAllocation; 1142 PFN_vkReallocationFunction pfnReallocation; 1143 PFN_vkFreeFunction pfnFree; 1144 PFN_vkInternalAllocationNotification pfnInternalAllocation; 1145 PFN_vkInternalFreeNotification pfnInternalFree; 1146} VkAllocationCallbacks; 1147 1148typedef struct VkPhysicalDeviceFeatures { 1149 VkBool32 robustBufferAccess; 1150 VkBool32 fullDrawIndexUint32; 1151 VkBool32 imageCubeArray; 1152 VkBool32 independentBlend; 1153 VkBool32 geometryShader; 1154 VkBool32 tessellationShader; 1155 VkBool32 sampleRateShading; 1156 VkBool32 dualSrcBlend; 1157 VkBool32 logicOp; 1158 VkBool32 multiDrawIndirect; 1159 VkBool32 drawIndirectFirstInstance; 1160 VkBool32 depthClamp; 1161 VkBool32 depthBiasClamp; 1162 VkBool32 fillModeNonSolid; 1163 VkBool32 depthBounds; 1164 VkBool32 wideLines; 1165 VkBool32 largePoints; 1166 VkBool32 alphaToOne; 1167 VkBool32 multiViewport; 1168 VkBool32 samplerAnisotropy; 1169 VkBool32 textureCompressionETC2; 1170 VkBool32 textureCompressionASTC_LDR; 1171 VkBool32 textureCompressionBC; 1172 VkBool32 occlusionQueryPrecise; 1173 VkBool32 pipelineStatisticsQuery; 1174 VkBool32 vertexPipelineStoresAndAtomics; 1175 VkBool32 fragmentStoresAndAtomics; 1176 VkBool32 shaderTessellationAndGeometryPointSize; 1177 VkBool32 shaderImageGatherExtended; 1178 VkBool32 shaderStorageImageExtendedFormats; 1179 VkBool32 shaderStorageImageMultisample; 1180 VkBool32 shaderStorageImageReadWithoutFormat; 1181 VkBool32 shaderStorageImageWriteWithoutFormat; 1182 VkBool32 shaderUniformBufferArrayDynamicIndexing; 1183 VkBool32 shaderSampledImageArrayDynamicIndexing; 1184 VkBool32 shaderStorageBufferArrayDynamicIndexing; 1185 VkBool32 shaderStorageImageArrayDynamicIndexing; 1186 VkBool32 shaderClipDistance; 1187 VkBool32 shaderCullDistance; 1188 VkBool32 shaderFloat64; 1189 VkBool32 shaderInt64; 1190 VkBool32 shaderInt16; 1191 VkBool32 shaderResourceResidency; 1192 VkBool32 shaderResourceMinLod; 1193 VkBool32 sparseBinding; 1194 VkBool32 sparseResidencyBuffer; 1195 VkBool32 sparseResidencyImage2D; 1196 VkBool32 sparseResidencyImage3D; 1197 VkBool32 sparseResidency2Samples; 1198 VkBool32 sparseResidency4Samples; 1199 VkBool32 sparseResidency8Samples; 1200 VkBool32 sparseResidency16Samples; 1201 VkBool32 sparseResidencyAliased; 1202 VkBool32 variableMultisampleRate; 1203 VkBool32 inheritedQueries; 1204} VkPhysicalDeviceFeatures; 1205 1206typedef struct VkFormatProperties { 1207 VkFormatFeatureFlags linearTilingFeatures; 1208 VkFormatFeatureFlags optimalTilingFeatures; 1209 VkFormatFeatureFlags bufferFeatures; 1210} VkFormatProperties; 1211 1212typedef struct VkExtent3D { 1213 uint32_t width; 1214 uint32_t height; 1215 uint32_t depth; 1216} VkExtent3D; 1217 1218typedef struct VkImageFormatProperties { 1219 VkExtent3D maxExtent; 1220 uint32_t maxMipLevels; 1221 uint32_t maxArrayLayers; 1222 VkSampleCountFlags sampleCounts; 1223 VkDeviceSize maxResourceSize; 1224} VkImageFormatProperties; 1225 1226typedef struct VkPhysicalDeviceLimits { 1227 uint32_t maxImageDimension1D; 1228 uint32_t maxImageDimension2D; 1229 uint32_t maxImageDimension3D; 1230 uint32_t maxImageDimensionCube; 1231 uint32_t maxImageArrayLayers; 1232 uint32_t maxTexelBufferElements; 1233 uint32_t maxUniformBufferRange; 1234 uint32_t maxStorageBufferRange; 1235 uint32_t maxPushConstantsSize; 1236 uint32_t maxMemoryAllocationCount; 1237 uint32_t maxSamplerAllocationCount; 1238 VkDeviceSize bufferImageGranularity; 1239 VkDeviceSize sparseAddressSpaceSize; 1240 uint32_t maxBoundDescriptorSets; 1241 uint32_t maxPerStageDescriptorSamplers; 1242 uint32_t maxPerStageDescriptorUniformBuffers; 1243 uint32_t maxPerStageDescriptorStorageBuffers; 1244 uint32_t maxPerStageDescriptorSampledImages; 1245 uint32_t maxPerStageDescriptorStorageImages; 1246 uint32_t maxPerStageDescriptorInputAttachments; 1247 uint32_t maxPerStageResources; 1248 uint32_t maxDescriptorSetSamplers; 1249 uint32_t maxDescriptorSetUniformBuffers; 1250 uint32_t maxDescriptorSetUniformBuffersDynamic; 1251 uint32_t maxDescriptorSetStorageBuffers; 1252 uint32_t maxDescriptorSetStorageBuffersDynamic; 1253 uint32_t maxDescriptorSetSampledImages; 1254 uint32_t maxDescriptorSetStorageImages; 1255 uint32_t maxDescriptorSetInputAttachments; 1256 uint32_t maxVertexInputAttributes; 1257 uint32_t maxVertexInputBindings; 1258 uint32_t maxVertexInputAttributeOffset; 1259 uint32_t maxVertexInputBindingStride; 1260 uint32_t maxVertexOutputComponents; 1261 uint32_t maxTessellationGenerationLevel; 1262 uint32_t maxTessellationPatchSize; 1263 uint32_t maxTessellationControlPerVertexInputComponents; 1264 uint32_t maxTessellationControlPerVertexOutputComponents; 1265 uint32_t maxTessellationControlPerPatchOutputComponents; 1266 uint32_t maxTessellationControlTotalOutputComponents; 1267 uint32_t maxTessellationEvaluationInputComponents; 1268 uint32_t maxTessellationEvaluationOutputComponents; 1269 uint32_t maxGeometryShaderInvocations; 1270 uint32_t maxGeometryInputComponents; 1271 uint32_t maxGeometryOutputComponents; 1272 uint32_t maxGeometryOutputVertices; 1273 uint32_t maxGeometryTotalOutputComponents; 1274 uint32_t maxFragmentInputComponents; 1275 uint32_t maxFragmentOutputAttachments; 1276 uint32_t maxFragmentDualSrcAttachments; 1277 uint32_t maxFragmentCombinedOutputResources; 1278 uint32_t maxComputeSharedMemorySize; 1279 uint32_t maxComputeWorkGroupCount[3]; 1280 uint32_t maxComputeWorkGroupInvocations; 1281 uint32_t maxComputeWorkGroupSize[3]; 1282 uint32_t subPixelPrecisionBits; 1283 uint32_t subTexelPrecisionBits; 1284 uint32_t mipmapPrecisionBits; 1285 uint32_t maxDrawIndexedIndexValue; 1286 uint32_t maxDrawIndirectCount; 1287 float maxSamplerLodBias; 1288 float maxSamplerAnisotropy; 1289 uint32_t maxViewports; 1290 uint32_t maxViewportDimensions[2]; 1291 float viewportBoundsRange[2]; 1292 uint32_t viewportSubPixelBits; 1293 size_t minMemoryMapAlignment; 1294 VkDeviceSize minTexelBufferOffsetAlignment; 1295 VkDeviceSize minUniformBufferOffsetAlignment; 1296 VkDeviceSize minStorageBufferOffsetAlignment; 1297 int32_t minTexelOffset; 1298 uint32_t maxTexelOffset; 1299 int32_t minTexelGatherOffset; 1300 uint32_t maxTexelGatherOffset; 1301 float minInterpolationOffset; 1302 float maxInterpolationOffset; 1303 uint32_t subPixelInterpolationOffsetBits; 1304 uint32_t maxFramebufferWidth; 1305 uint32_t maxFramebufferHeight; 1306 uint32_t maxFramebufferLayers; 1307 VkSampleCountFlags framebufferColorSampleCounts; 1308 VkSampleCountFlags framebufferDepthSampleCounts; 1309 VkSampleCountFlags framebufferStencilSampleCounts; 1310 VkSampleCountFlags framebufferNoAttachmentsSampleCounts; 1311 uint32_t maxColorAttachments; 1312 VkSampleCountFlags sampledImageColorSampleCounts; 1313 VkSampleCountFlags sampledImageIntegerSampleCounts; 1314 VkSampleCountFlags sampledImageDepthSampleCounts; 1315 VkSampleCountFlags sampledImageStencilSampleCounts; 1316 VkSampleCountFlags storageImageSampleCounts; 1317 uint32_t maxSampleMaskWords; 1318 VkBool32 timestampComputeAndGraphics; 1319 float timestampPeriod; 1320 uint32_t maxClipDistances; 1321 uint32_t maxCullDistances; 1322 uint32_t maxCombinedClipAndCullDistances; 1323 uint32_t discreteQueuePriorities; 1324 float pointSizeRange[2]; 1325 float lineWidthRange[2]; 1326 float pointSizeGranularity; 1327 float lineWidthGranularity; 1328 VkBool32 strictLines; 1329 VkBool32 standardSampleLocations; 1330 VkDeviceSize optimalBufferCopyOffsetAlignment; 1331 VkDeviceSize optimalBufferCopyRowPitchAlignment; 1332 VkDeviceSize nonCoherentAtomSize; 1333} VkPhysicalDeviceLimits; 1334 1335typedef struct VkPhysicalDeviceSparseProperties { 1336 VkBool32 residencyStandard2DBlockShape; 1337 VkBool32 residencyStandard2DMultisampleBlockShape; 1338 VkBool32 residencyStandard3DBlockShape; 1339 VkBool32 residencyAlignedMipSize; 1340 VkBool32 residencyNonResidentStrict; 1341} VkPhysicalDeviceSparseProperties; 1342 1343typedef struct VkPhysicalDeviceProperties { 1344 uint32_t apiVersion; 1345 uint32_t driverVersion; 1346 uint32_t vendorID; 1347 uint32_t deviceID; 1348 VkPhysicalDeviceType deviceType; 1349 char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]; 1350 uint8_t pipelineCacheUUID[VK_UUID_SIZE]; 1351 VkPhysicalDeviceLimits limits; 1352 VkPhysicalDeviceSparseProperties sparseProperties; 1353} VkPhysicalDeviceProperties; 1354 1355typedef struct VkQueueFamilyProperties { 1356 VkQueueFlags queueFlags; 1357 uint32_t queueCount; 1358 uint32_t timestampValidBits; 1359 VkExtent3D minImageTransferGranularity; 1360} VkQueueFamilyProperties; 1361 1362typedef struct VkMemoryType { 1363 VkMemoryPropertyFlags propertyFlags; 1364 uint32_t heapIndex; 1365} VkMemoryType; 1366 1367typedef struct VkMemoryHeap { 1368 VkDeviceSize size; 1369 VkMemoryHeapFlags flags; 1370} VkMemoryHeap; 1371 1372typedef struct VkPhysicalDeviceMemoryProperties { 1373 uint32_t memoryTypeCount; 1374 VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES]; 1375 uint32_t memoryHeapCount; 1376 VkMemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS]; 1377} VkPhysicalDeviceMemoryProperties; 1378 1379typedef struct VkDeviceQueueCreateInfo { 1380 VkStructureType sType; 1381 const void* pNext; 1382 VkDeviceQueueCreateFlags flags; 1383 uint32_t queueFamilyIndex; 1384 uint32_t queueCount; 1385 const float* pQueuePriorities; 1386} VkDeviceQueueCreateInfo; 1387 1388typedef struct VkDeviceCreateInfo { 1389 VkStructureType sType; 1390 const void* pNext; 1391 VkDeviceCreateFlags flags; 1392 uint32_t queueCreateInfoCount; 1393 const VkDeviceQueueCreateInfo* pQueueCreateInfos; 1394 uint32_t enabledLayerCount; 1395 const char* const* ppEnabledLayerNames; 1396 uint32_t enabledExtensionCount; 1397 const char* const* ppEnabledExtensionNames; 1398 const VkPhysicalDeviceFeatures* pEnabledFeatures; 1399} VkDeviceCreateInfo; 1400 1401typedef struct VkExtensionProperties { 1402 char extensionName[VK_MAX_EXTENSION_NAME_SIZE]; 1403 uint32_t specVersion; 1404} VkExtensionProperties; 1405 1406typedef struct VkLayerProperties { 1407 char layerName[VK_MAX_EXTENSION_NAME_SIZE]; 1408 uint32_t specVersion; 1409 uint32_t implementationVersion; 1410 char description[VK_MAX_DESCRIPTION_SIZE]; 1411} VkLayerProperties; 1412 1413typedef struct VkSubmitInfo { 1414 VkStructureType sType; 1415 const void* pNext; 1416 uint32_t waitSemaphoreCount; 1417 const VkSemaphore* pWaitSemaphores; 1418 const VkPipelineStageFlags* pWaitDstStageMask; 1419 uint32_t commandBufferCount; 1420 const VkCommandBuffer* pCommandBuffers; 1421 uint32_t signalSemaphoreCount; 1422 const VkSemaphore* pSignalSemaphores; 1423} VkSubmitInfo; 1424 1425typedef struct VkMemoryAllocateInfo { 1426 VkStructureType sType; 1427 const void* pNext; 1428 VkDeviceSize allocationSize; 1429 uint32_t memoryTypeIndex; 1430} VkMemoryAllocateInfo; 1431 1432typedef struct VkMappedMemoryRange { 1433 VkStructureType sType; 1434 const void* pNext; 1435 VkDeviceMemory memory; 1436 VkDeviceSize offset; 1437 VkDeviceSize size; 1438} VkMappedMemoryRange; 1439 1440typedef struct VkMemoryRequirements { 1441 VkDeviceSize size; 1442 VkDeviceSize alignment; 1443 uint32_t memoryTypeBits; 1444} VkMemoryRequirements; 1445 1446typedef struct VkSparseImageFormatProperties { 1447 VkImageAspectFlags aspectMask; 1448 VkExtent3D imageGranularity; 1449 VkSparseImageFormatFlags flags; 1450} VkSparseImageFormatProperties; 1451 1452typedef struct VkSparseImageMemoryRequirements { 1453 VkSparseImageFormatProperties formatProperties; 1454 uint32_t imageMipTailFirstLod; 1455 VkDeviceSize imageMipTailSize; 1456 VkDeviceSize imageMipTailOffset; 1457 VkDeviceSize imageMipTailStride; 1458} VkSparseImageMemoryRequirements; 1459 1460typedef struct VkSparseMemoryBind { 1461 VkDeviceSize resourceOffset; 1462 VkDeviceSize size; 1463 VkDeviceMemory memory; 1464 VkDeviceSize memoryOffset; 1465 VkSparseMemoryBindFlags flags; 1466} VkSparseMemoryBind; 1467 1468typedef struct VkSparseBufferMemoryBindInfo { 1469 VkBuffer buffer; 1470 uint32_t bindCount; 1471 const VkSparseMemoryBind* pBinds; 1472} VkSparseBufferMemoryBindInfo; 1473 1474typedef struct VkSparseImageOpaqueMemoryBindInfo { 1475 VkImage image; 1476 uint32_t bindCount; 1477 const VkSparseMemoryBind* pBinds; 1478} VkSparseImageOpaqueMemoryBindInfo; 1479 1480typedef struct VkImageSubresource { 1481 VkImageAspectFlags aspectMask; 1482 uint32_t mipLevel; 1483 uint32_t arrayLayer; 1484} VkImageSubresource; 1485 1486typedef struct VkOffset3D { 1487 int32_t x; 1488 int32_t y; 1489 int32_t z; 1490} VkOffset3D; 1491 1492typedef struct VkSparseImageMemoryBind { 1493 VkImageSubresource subresource; 1494 VkOffset3D offset; 1495 VkExtent3D extent; 1496 VkDeviceMemory memory; 1497 VkDeviceSize memoryOffset; 1498 VkSparseMemoryBindFlags flags; 1499} VkSparseImageMemoryBind; 1500 1501typedef struct VkSparseImageMemoryBindInfo { 1502 VkImage image; 1503 uint32_t bindCount; 1504 const VkSparseImageMemoryBind* pBinds; 1505} VkSparseImageMemoryBindInfo; 1506 1507typedef struct VkBindSparseInfo { 1508 VkStructureType sType; 1509 const void* pNext; 1510 uint32_t waitSemaphoreCount; 1511 const VkSemaphore* pWaitSemaphores; 1512 uint32_t bufferBindCount; 1513 const VkSparseBufferMemoryBindInfo* pBufferBinds; 1514 uint32_t imageOpaqueBindCount; 1515 const VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds; 1516 uint32_t imageBindCount; 1517 const VkSparseImageMemoryBindInfo* pImageBinds; 1518 uint32_t signalSemaphoreCount; 1519 const VkSemaphore* pSignalSemaphores; 1520} VkBindSparseInfo; 1521 1522typedef struct VkFenceCreateInfo { 1523 VkStructureType sType; 1524 const void* pNext; 1525 VkFenceCreateFlags flags; 1526} VkFenceCreateInfo; 1527 1528typedef struct VkSemaphoreCreateInfo { 1529 VkStructureType sType; 1530 const void* pNext; 1531 VkSemaphoreCreateFlags flags; 1532} VkSemaphoreCreateInfo; 1533 1534typedef struct VkEventCreateInfo { 1535 VkStructureType sType; 1536 const void* pNext; 1537 VkEventCreateFlags flags; 1538} VkEventCreateInfo; 1539 1540typedef struct VkQueryPoolCreateInfo { 1541 VkStructureType sType; 1542 const void* pNext; 1543 VkQueryPoolCreateFlags flags; 1544 VkQueryType queryType; 1545 uint32_t queryCount; 1546 VkQueryPipelineStatisticFlags pipelineStatistics; 1547} VkQueryPoolCreateInfo; 1548 1549typedef struct VkBufferCreateInfo { 1550 VkStructureType sType; 1551 const void* pNext; 1552 VkBufferCreateFlags flags; 1553 VkDeviceSize size; 1554 VkBufferUsageFlags usage; 1555 VkSharingMode sharingMode; 1556 uint32_t queueFamilyIndexCount; 1557 const uint32_t* pQueueFamilyIndices; 1558} VkBufferCreateInfo; 1559 1560typedef struct VkBufferViewCreateInfo { 1561 VkStructureType sType; 1562 const void* pNext; 1563 VkBufferViewCreateFlags flags; 1564 VkBuffer buffer; 1565 VkFormat format; 1566 VkDeviceSize offset; 1567 VkDeviceSize range; 1568} VkBufferViewCreateInfo; 1569 1570typedef struct VkImageCreateInfo { 1571 VkStructureType sType; 1572 const void* pNext; 1573 VkImageCreateFlags flags; 1574 VkImageType imageType; 1575 VkFormat format; 1576 VkExtent3D extent; 1577 uint32_t mipLevels; 1578 uint32_t arrayLayers; 1579 VkSampleCountFlagBits samples; 1580 VkImageTiling tiling; 1581 VkImageUsageFlags usage; 1582 VkSharingMode sharingMode; 1583 uint32_t queueFamilyIndexCount; 1584 const uint32_t* pQueueFamilyIndices; 1585 VkImageLayout initialLayout; 1586} VkImageCreateInfo; 1587 1588typedef struct VkSubresourceLayout { 1589 VkDeviceSize offset; 1590 VkDeviceSize size; 1591 VkDeviceSize rowPitch; 1592 VkDeviceSize arrayPitch; 1593 VkDeviceSize depthPitch; 1594} VkSubresourceLayout; 1595 1596typedef struct VkComponentMapping { 1597 VkComponentSwizzle r; 1598 VkComponentSwizzle g; 1599 VkComponentSwizzle b; 1600 VkComponentSwizzle a; 1601} VkComponentMapping; 1602 1603typedef struct VkImageSubresourceRange { 1604 VkImageAspectFlags aspectMask; 1605 uint32_t baseMipLevel; 1606 uint32_t levelCount; 1607 uint32_t baseArrayLayer; 1608 uint32_t layerCount; 1609} VkImageSubresourceRange; 1610 1611typedef struct VkImageViewCreateInfo { 1612 VkStructureType sType; 1613 const void* pNext; 1614 VkImageViewCreateFlags flags; 1615 VkImage image; 1616 VkImageViewType viewType; 1617 VkFormat format; 1618 VkComponentMapping components; 1619 VkImageSubresourceRange subresourceRange; 1620} VkImageViewCreateInfo; 1621 1622typedef struct VkShaderModuleCreateInfo { 1623 VkStructureType sType; 1624 const void* pNext; 1625 VkShaderModuleCreateFlags flags; 1626 size_t codeSize; 1627 const uint32_t* pCode; 1628} VkShaderModuleCreateInfo; 1629 1630typedef struct VkPipelineCacheCreateInfo { 1631 VkStructureType sType; 1632 const void* pNext; 1633 VkPipelineCacheCreateFlags flags; 1634 size_t initialDataSize; 1635 const void* pInitialData; 1636} VkPipelineCacheCreateInfo; 1637 1638typedef struct VkSpecializationMapEntry { 1639 uint32_t constantID; 1640 uint32_t offset; 1641 size_t size; 1642} VkSpecializationMapEntry; 1643 1644typedef struct VkSpecializationInfo { 1645 uint32_t mapEntryCount; 1646 const VkSpecializationMapEntry* pMapEntries; 1647 size_t dataSize; 1648 const void* pData; 1649} VkSpecializationInfo; 1650 1651typedef struct VkPipelineShaderStageCreateInfo { 1652 VkStructureType sType; 1653 const void* pNext; 1654 VkPipelineShaderStageCreateFlags flags; 1655 VkShaderStageFlagBits stage; 1656 VkShaderModule module; 1657 const char* pName; 1658 const VkSpecializationInfo* pSpecializationInfo; 1659} VkPipelineShaderStageCreateInfo; 1660 1661typedef struct VkVertexInputBindingDescription { 1662 uint32_t binding; 1663 uint32_t stride; 1664 VkVertexInputRate inputRate; 1665} VkVertexInputBindingDescription; 1666 1667typedef struct VkVertexInputAttributeDescription { 1668 uint32_t location; 1669 uint32_t binding; 1670 VkFormat format; 1671 uint32_t offset; 1672} VkVertexInputAttributeDescription; 1673 1674typedef struct VkPipelineVertexInputStateCreateInfo { 1675 VkStructureType sType; 1676 const void* pNext; 1677 VkPipelineVertexInputStateCreateFlags flags; 1678 uint32_t vertexBindingDescriptionCount; 1679 const VkVertexInputBindingDescription* pVertexBindingDescriptions; 1680 uint32_t vertexAttributeDescriptionCount; 1681 const VkVertexInputAttributeDescription* pVertexAttributeDescriptions; 1682} VkPipelineVertexInputStateCreateInfo; 1683 1684typedef struct VkPipelineInputAssemblyStateCreateInfo { 1685 VkStructureType sType; 1686 const void* pNext; 1687 VkPipelineInputAssemblyStateCreateFlags flags; 1688 VkPrimitiveTopology topology; 1689 VkBool32 primitiveRestartEnable; 1690} VkPipelineInputAssemblyStateCreateInfo; 1691 1692typedef struct VkPipelineTessellationStateCreateInfo { 1693 VkStructureType sType; 1694 const void* pNext; 1695 VkPipelineTessellationStateCreateFlags flags; 1696 uint32_t patchControlPoints; 1697} VkPipelineTessellationStateCreateInfo; 1698 1699typedef struct VkViewport { 1700 float x; 1701 float y; 1702 float width; 1703 float height; 1704 float minDepth; 1705 float maxDepth; 1706} VkViewport; 1707 1708typedef struct VkOffset2D { 1709 int32_t x; 1710 int32_t y; 1711} VkOffset2D; 1712 1713typedef struct VkExtent2D { 1714 uint32_t width; 1715 uint32_t height; 1716} VkExtent2D; 1717 1718typedef struct VkRect2D { 1719 VkOffset2D offset; 1720 VkExtent2D extent; 1721} VkRect2D; 1722 1723typedef struct VkPipelineViewportStateCreateInfo { 1724 VkStructureType sType; 1725 const void* pNext; 1726 VkPipelineViewportStateCreateFlags flags; 1727 uint32_t viewportCount; 1728 const VkViewport* pViewports; 1729 uint32_t scissorCount; 1730 const VkRect2D* pScissors; 1731} VkPipelineViewportStateCreateInfo; 1732 1733typedef struct VkPipelineRasterizationStateCreateInfo { 1734 VkStructureType sType; 1735 const void* pNext; 1736 VkPipelineRasterizationStateCreateFlags flags; 1737 VkBool32 depthClampEnable; 1738 VkBool32 rasterizerDiscardEnable; 1739 VkPolygonMode polygonMode; 1740 VkCullModeFlags cullMode; 1741 VkFrontFace frontFace; 1742 VkBool32 depthBiasEnable; 1743 float depthBiasConstantFactor; 1744 float depthBiasClamp; 1745 float depthBiasSlopeFactor; 1746 float lineWidth; 1747} VkPipelineRasterizationStateCreateInfo; 1748 1749typedef struct VkPipelineMultisampleStateCreateInfo { 1750 VkStructureType sType; 1751 const void* pNext; 1752 VkPipelineMultisampleStateCreateFlags flags; 1753 VkSampleCountFlagBits rasterizationSamples; 1754 VkBool32 sampleShadingEnable; 1755 float minSampleShading; 1756 const VkSampleMask* pSampleMask; 1757 VkBool32 alphaToCoverageEnable; 1758 VkBool32 alphaToOneEnable; 1759} VkPipelineMultisampleStateCreateInfo; 1760 1761typedef struct VkStencilOpState { 1762 VkStencilOp failOp; 1763 VkStencilOp passOp; 1764 VkStencilOp depthFailOp; 1765 VkCompareOp compareOp; 1766 uint32_t compareMask; 1767 uint32_t writeMask; 1768 uint32_t reference; 1769} VkStencilOpState; 1770 1771typedef struct VkPipelineDepthStencilStateCreateInfo { 1772 VkStructureType sType; 1773 const void* pNext; 1774 VkPipelineDepthStencilStateCreateFlags flags; 1775 VkBool32 depthTestEnable; 1776 VkBool32 depthWriteEnable; 1777 VkCompareOp depthCompareOp; 1778 VkBool32 depthBoundsTestEnable; 1779 VkBool32 stencilTestEnable; 1780 VkStencilOpState front; 1781 VkStencilOpState back; 1782 float minDepthBounds; 1783 float maxDepthBounds; 1784} VkPipelineDepthStencilStateCreateInfo; 1785 1786typedef struct VkPipelineColorBlendAttachmentState { 1787 VkBool32 blendEnable; 1788 VkBlendFactor srcColorBlendFactor; 1789 VkBlendFactor dstColorBlendFactor; 1790 VkBlendOp colorBlendOp; 1791 VkBlendFactor srcAlphaBlendFactor; 1792 VkBlendFactor dstAlphaBlendFactor; 1793 VkBlendOp alphaBlendOp; 1794 VkColorComponentFlags colorWriteMask; 1795} VkPipelineColorBlendAttachmentState; 1796 1797typedef struct VkPipelineColorBlendStateCreateInfo { 1798 VkStructureType sType; 1799 const void* pNext; 1800 VkPipelineColorBlendStateCreateFlags flags; 1801 VkBool32 logicOpEnable; 1802 VkLogicOp logicOp; 1803 uint32_t attachmentCount; 1804 const VkPipelineColorBlendAttachmentState* pAttachments; 1805 float blendConstants[4]; 1806} VkPipelineColorBlendStateCreateInfo; 1807 1808typedef struct VkPipelineDynamicStateCreateInfo { 1809 VkStructureType sType; 1810 const void* pNext; 1811 VkPipelineDynamicStateCreateFlags flags; 1812 uint32_t dynamicStateCount; 1813 const VkDynamicState* pDynamicStates; 1814} VkPipelineDynamicStateCreateInfo; 1815 1816typedef struct VkGraphicsPipelineCreateInfo { 1817 VkStructureType sType; 1818 const void* pNext; 1819 VkPipelineCreateFlags flags; 1820 uint32_t stageCount; 1821 const VkPipelineShaderStageCreateInfo* pStages; 1822 const VkPipelineVertexInputStateCreateInfo* pVertexInputState; 1823 const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState; 1824 const VkPipelineTessellationStateCreateInfo* pTessellationState; 1825 const VkPipelineViewportStateCreateInfo* pViewportState; 1826 const VkPipelineRasterizationStateCreateInfo* pRasterizationState; 1827 const VkPipelineMultisampleStateCreateInfo* pMultisampleState; 1828 const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState; 1829 const VkPipelineColorBlendStateCreateInfo* pColorBlendState; 1830 const VkPipelineDynamicStateCreateInfo* pDynamicState; 1831 VkPipelineLayout layout; 1832 VkRenderPass renderPass; 1833 uint32_t subpass; 1834 VkPipeline basePipelineHandle; 1835 int32_t basePipelineIndex; 1836} VkGraphicsPipelineCreateInfo; 1837 1838typedef struct VkComputePipelineCreateInfo { 1839 VkStructureType sType; 1840 const void* pNext; 1841 VkPipelineCreateFlags flags; 1842 VkPipelineShaderStageCreateInfo stage; 1843 VkPipelineLayout layout; 1844 VkPipeline basePipelineHandle; 1845 int32_t basePipelineIndex; 1846} VkComputePipelineCreateInfo; 1847 1848typedef struct VkPushConstantRange { 1849 VkShaderStageFlags stageFlags; 1850 uint32_t offset; 1851 uint32_t size; 1852} VkPushConstantRange; 1853 1854typedef struct VkPipelineLayoutCreateInfo { 1855 VkStructureType sType; 1856 const void* pNext; 1857 VkPipelineLayoutCreateFlags flags; 1858 uint32_t setLayoutCount; 1859 const VkDescriptorSetLayout* pSetLayouts; 1860 uint32_t pushConstantRangeCount; 1861 const VkPushConstantRange* pPushConstantRanges; 1862} VkPipelineLayoutCreateInfo; 1863 1864typedef struct VkSamplerCreateInfo { 1865 VkStructureType sType; 1866 const void* pNext; 1867 VkSamplerCreateFlags flags; 1868 VkFilter magFilter; 1869 VkFilter minFilter; 1870 VkSamplerMipmapMode mipmapMode; 1871 VkSamplerAddressMode addressModeU; 1872 VkSamplerAddressMode addressModeV; 1873 VkSamplerAddressMode addressModeW; 1874 float mipLodBias; 1875 VkBool32 anisotropyEnable; 1876 float maxAnisotropy; 1877 VkBool32 compareEnable; 1878 VkCompareOp compareOp; 1879 float minLod; 1880 float maxLod; 1881 VkBorderColor borderColor; 1882 VkBool32 unnormalizedCoordinates; 1883} VkSamplerCreateInfo; 1884 1885typedef struct VkDescriptorSetLayoutBinding { 1886 uint32_t binding; 1887 VkDescriptorType descriptorType; 1888 uint32_t descriptorCount; 1889 VkShaderStageFlags stageFlags; 1890 const VkSampler* pImmutableSamplers; 1891} VkDescriptorSetLayoutBinding; 1892 1893typedef struct VkDescriptorSetLayoutCreateInfo { 1894 VkStructureType sType; 1895 const void* pNext; 1896 VkDescriptorSetLayoutCreateFlags flags; 1897 uint32_t bindingCount; 1898 const VkDescriptorSetLayoutBinding* pBindings; 1899} VkDescriptorSetLayoutCreateInfo; 1900 1901typedef struct VkDescriptorPoolSize { 1902 VkDescriptorType type; 1903 uint32_t descriptorCount; 1904} VkDescriptorPoolSize; 1905 1906typedef struct VkDescriptorPoolCreateInfo { 1907 VkStructureType sType; 1908 const void* pNext; 1909 VkDescriptorPoolCreateFlags flags; 1910 uint32_t maxSets; 1911 uint32_t poolSizeCount; 1912 const VkDescriptorPoolSize* pPoolSizes; 1913} VkDescriptorPoolCreateInfo; 1914 1915typedef struct VkDescriptorSetAllocateInfo { 1916 VkStructureType sType; 1917 const void* pNext; 1918 VkDescriptorPool descriptorPool; 1919 uint32_t descriptorSetCount; 1920 const VkDescriptorSetLayout* pSetLayouts; 1921} VkDescriptorSetAllocateInfo; 1922 1923typedef struct VkDescriptorImageInfo { 1924 VkSampler sampler; 1925 VkImageView imageView; 1926 VkImageLayout imageLayout; 1927} VkDescriptorImageInfo; 1928 1929typedef struct VkDescriptorBufferInfo { 1930 VkBuffer buffer; 1931 VkDeviceSize offset; 1932 VkDeviceSize range; 1933} VkDescriptorBufferInfo; 1934 1935typedef struct VkWriteDescriptorSet { 1936 VkStructureType sType; 1937 const void* pNext; 1938 VkDescriptorSet dstSet; 1939 uint32_t dstBinding; 1940 uint32_t dstArrayElement; 1941 uint32_t descriptorCount; 1942 VkDescriptorType descriptorType; 1943 const VkDescriptorImageInfo* pImageInfo; 1944 const VkDescriptorBufferInfo* pBufferInfo; 1945 const VkBufferView* pTexelBufferView; 1946} VkWriteDescriptorSet; 1947 1948typedef struct VkCopyDescriptorSet { 1949 VkStructureType sType; 1950 const void* pNext; 1951 VkDescriptorSet srcSet; 1952 uint32_t srcBinding; 1953 uint32_t srcArrayElement; 1954 VkDescriptorSet dstSet; 1955 uint32_t dstBinding; 1956 uint32_t dstArrayElement; 1957 uint32_t descriptorCount; 1958} VkCopyDescriptorSet; 1959 1960typedef struct VkFramebufferCreateInfo { 1961 VkStructureType sType; 1962 const void* pNext; 1963 VkFramebufferCreateFlags flags; 1964 VkRenderPass renderPass; 1965 uint32_t attachmentCount; 1966 const VkImageView* pAttachments; 1967 uint32_t width; 1968 uint32_t height; 1969 uint32_t layers; 1970} VkFramebufferCreateInfo; 1971 1972typedef struct VkAttachmentDescription { 1973 VkAttachmentDescriptionFlags flags; 1974 VkFormat format; 1975 VkSampleCountFlagBits samples; 1976 VkAttachmentLoadOp loadOp; 1977 VkAttachmentStoreOp storeOp; 1978 VkAttachmentLoadOp stencilLoadOp; 1979 VkAttachmentStoreOp stencilStoreOp; 1980 VkImageLayout initialLayout; 1981 VkImageLayout finalLayout; 1982} VkAttachmentDescription; 1983 1984typedef struct VkAttachmentReference { 1985 uint32_t attachment; 1986 VkImageLayout layout; 1987} VkAttachmentReference; 1988 1989typedef struct VkSubpassDescription { 1990 VkSubpassDescriptionFlags flags; 1991 VkPipelineBindPoint pipelineBindPoint; 1992 uint32_t inputAttachmentCount; 1993 const VkAttachmentReference* pInputAttachments; 1994 uint32_t colorAttachmentCount; 1995 const VkAttachmentReference* pColorAttachments; 1996 const VkAttachmentReference* pResolveAttachments; 1997 const VkAttachmentReference* pDepthStencilAttachment; 1998 uint32_t preserveAttachmentCount; 1999 const uint32_t* pPreserveAttachments; 2000} VkSubpassDescription; 2001 2002typedef struct VkSubpassDependency { 2003 uint32_t srcSubpass; 2004 uint32_t dstSubpass; 2005 VkPipelineStageFlags srcStageMask; 2006 VkPipelineStageFlags dstStageMask; 2007 VkAccessFlags srcAccessMask; 2008 VkAccessFlags dstAccessMask; 2009 VkDependencyFlags dependencyFlags; 2010} VkSubpassDependency; 2011 2012typedef struct VkRenderPassCreateInfo { 2013 VkStructureType sType; 2014 const void* pNext; 2015 VkRenderPassCreateFlags flags; 2016 uint32_t attachmentCount; 2017 const VkAttachmentDescription* pAttachments; 2018 uint32_t subpassCount; 2019 const VkSubpassDescription* pSubpasses; 2020 uint32_t dependencyCount; 2021 const VkSubpassDependency* pDependencies; 2022} VkRenderPassCreateInfo; 2023 2024typedef struct VkCommandPoolCreateInfo { 2025 VkStructureType sType; 2026 const void* pNext; 2027 VkCommandPoolCreateFlags flags; 2028 uint32_t queueFamilyIndex; 2029} VkCommandPoolCreateInfo; 2030 2031typedef struct VkCommandBufferAllocateInfo { 2032 VkStructureType sType; 2033 const void* pNext; 2034 VkCommandPool commandPool; 2035 VkCommandBufferLevel level; 2036 uint32_t commandBufferCount; 2037} VkCommandBufferAllocateInfo; 2038 2039typedef struct VkCommandBufferInheritanceInfo { 2040 VkStructureType sType; 2041 const void* pNext; 2042 VkRenderPass renderPass; 2043 uint32_t subpass; 2044 VkFramebuffer framebuffer; 2045 VkBool32 occlusionQueryEnable; 2046 VkQueryControlFlags queryFlags; 2047 VkQueryPipelineStatisticFlags pipelineStatistics; 2048} VkCommandBufferInheritanceInfo; 2049 2050typedef struct VkCommandBufferBeginInfo { 2051 VkStructureType sType; 2052 const void* pNext; 2053 VkCommandBufferUsageFlags flags; 2054 const VkCommandBufferInheritanceInfo* pInheritanceInfo; 2055} VkCommandBufferBeginInfo; 2056 2057typedef struct VkBufferCopy { 2058 VkDeviceSize srcOffset; 2059 VkDeviceSize dstOffset; 2060 VkDeviceSize size; 2061} VkBufferCopy; 2062 2063typedef struct VkImageSubresourceLayers { 2064 VkImageAspectFlags aspectMask; 2065 uint32_t mipLevel; 2066 uint32_t baseArrayLayer; 2067 uint32_t layerCount; 2068} VkImageSubresourceLayers; 2069 2070typedef struct VkImageCopy { 2071 VkImageSubresourceLayers srcSubresource; 2072 VkOffset3D srcOffset; 2073 VkImageSubresourceLayers dstSubresource; 2074 VkOffset3D dstOffset; 2075 VkExtent3D extent; 2076} VkImageCopy; 2077 2078typedef struct VkImageBlit { 2079 VkImageSubresourceLayers srcSubresource; 2080 VkOffset3D srcOffsets[2]; 2081 VkImageSubresourceLayers dstSubresource; 2082 VkOffset3D dstOffsets[2]; 2083} VkImageBlit; 2084 2085typedef struct VkBufferImageCopy { 2086 VkDeviceSize bufferOffset; 2087 uint32_t bufferRowLength; 2088 uint32_t bufferImageHeight; 2089 VkImageSubresourceLayers imageSubresource; 2090 VkOffset3D imageOffset; 2091 VkExtent3D imageExtent; 2092} VkBufferImageCopy; 2093 2094typedef union VkClearColorValue { 2095 float float32[4]; 2096 int32_t int32[4]; 2097 uint32_t uint32[4]; 2098} VkClearColorValue; 2099 2100typedef struct VkClearDepthStencilValue { 2101 float depth; 2102 uint32_t stencil; 2103} VkClearDepthStencilValue; 2104 2105typedef union VkClearValue { 2106 VkClearColorValue color; 2107 VkClearDepthStencilValue depthStencil; 2108} VkClearValue; 2109 2110typedef struct VkClearAttachment { 2111 VkImageAspectFlags aspectMask; 2112 uint32_t colorAttachment; 2113 VkClearValue clearValue; 2114} VkClearAttachment; 2115 2116typedef struct VkClearRect { 2117 VkRect2D rect; 2118 uint32_t baseArrayLayer; 2119 uint32_t layerCount; 2120} VkClearRect; 2121 2122typedef struct VkImageResolve { 2123 VkImageSubresourceLayers srcSubresource; 2124 VkOffset3D srcOffset; 2125 VkImageSubresourceLayers dstSubresource; 2126 VkOffset3D dstOffset; 2127 VkExtent3D extent; 2128} VkImageResolve; 2129 2130typedef struct VkMemoryBarrier { 2131 VkStructureType sType; 2132 const void* pNext; 2133 VkAccessFlags srcAccessMask; 2134 VkAccessFlags dstAccessMask; 2135} VkMemoryBarrier; 2136 2137typedef struct VkBufferMemoryBarrier { 2138 VkStructureType sType; 2139 const void* pNext; 2140 VkAccessFlags srcAccessMask; 2141 VkAccessFlags dstAccessMask; 2142 uint32_t srcQueueFamilyIndex; 2143 uint32_t dstQueueFamilyIndex; 2144 VkBuffer buffer; 2145 VkDeviceSize offset; 2146 VkDeviceSize size; 2147} VkBufferMemoryBarrier; 2148 2149typedef struct VkImageMemoryBarrier { 2150 VkStructureType sType; 2151 const void* pNext; 2152 VkAccessFlags srcAccessMask; 2153 VkAccessFlags dstAccessMask; 2154 VkImageLayout oldLayout; 2155 VkImageLayout newLayout; 2156 uint32_t srcQueueFamilyIndex; 2157 uint32_t dstQueueFamilyIndex; 2158 VkImage image; 2159 VkImageSubresourceRange subresourceRange; 2160} VkImageMemoryBarrier; 2161 2162typedef struct VkRenderPassBeginInfo { 2163 VkStructureType sType; 2164 const void* pNext; 2165 VkRenderPass renderPass; 2166 VkFramebuffer framebuffer; 2167 VkRect2D renderArea; 2168 uint32_t clearValueCount; 2169 const VkClearValue* pClearValues; 2170} VkRenderPassBeginInfo; 2171 2172typedef struct VkDispatchIndirectCommand { 2173 uint32_t x; 2174 uint32_t y; 2175 uint32_t z; 2176} VkDispatchIndirectCommand; 2177 2178typedef struct VkDrawIndexedIndirectCommand { 2179 uint32_t indexCount; 2180 uint32_t instanceCount; 2181 uint32_t firstIndex; 2182 int32_t vertexOffset; 2183 uint32_t firstInstance; 2184} VkDrawIndexedIndirectCommand; 2185 2186typedef struct VkDrawIndirectCommand { 2187 uint32_t vertexCount; 2188 uint32_t instanceCount; 2189 uint32_t firstVertex; 2190 uint32_t firstInstance; 2191} VkDrawIndirectCommand; 2192 2193 2194typedef VkResult (VKAPI_PTR *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance); 2195typedef void (VKAPI_PTR *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks* pAllocator); 2196typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); 2197typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures); 2198typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties); 2199typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties); 2200typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties); 2201typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties); 2202typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties); 2203typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName); 2204typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName); 2205typedef VkResult (VKAPI_PTR *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice); 2206typedef void (VKAPI_PTR *PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks* pAllocator); 2207typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); 2208typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); 2209typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties); 2210typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties); 2211typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue); 2212typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence); 2213typedef VkResult (VKAPI_PTR *PFN_vkQueueWaitIdle)(VkQueue queue); 2214typedef VkResult (VKAPI_PTR *PFN_vkDeviceWaitIdle)(VkDevice device); 2215typedef VkResult (VKAPI_PTR *PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory); 2216typedef void (VKAPI_PTR *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator); 2217typedef VkResult (VKAPI_PTR *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData); 2218typedef void (VKAPI_PTR *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory); 2219typedef VkResult (VKAPI_PTR *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); 2220typedef VkResult (VKAPI_PTR *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); 2221typedef void (VKAPI_PTR *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes); 2222typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset); 2223typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset); 2224typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements); 2225typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements); 2226typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements); 2227typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties); 2228typedef VkResult (VKAPI_PTR *PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence); 2229typedef VkResult (VKAPI_PTR *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); 2230typedef void (VKAPI_PTR *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator); 2231typedef VkResult (VKAPI_PTR *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences); 2232typedef VkResult (VKAPI_PTR *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence); 2233typedef VkResult (VKAPI_PTR *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout); 2234typedef VkResult (VKAPI_PTR *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore); 2235typedef void (VKAPI_PTR *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator); 2236typedef VkResult (VKAPI_PTR *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent); 2237typedef void (VKAPI_PTR *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator); 2238typedef VkResult (VKAPI_PTR *PFN_vkGetEventStatus)(VkDevice device, VkEvent event); 2239typedef VkResult (VKAPI_PTR *PFN_vkSetEvent)(VkDevice device, VkEvent event); 2240typedef VkResult (VKAPI_PTR *PFN_vkResetEvent)(VkDevice device, VkEvent event); 2241typedef VkResult (VKAPI_PTR *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool); 2242typedef void (VKAPI_PTR *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator); 2243typedef VkResult (VKAPI_PTR *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags); 2244typedef VkResult (VKAPI_PTR *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer); 2245typedef void (VKAPI_PTR *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator); 2246typedef VkResult (VKAPI_PTR *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView); 2247typedef void (VKAPI_PTR *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator); 2248typedef VkResult (VKAPI_PTR *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage); 2249typedef void (VKAPI_PTR *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator); 2250typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout); 2251typedef VkResult (VKAPI_PTR *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView); 2252typedef void (VKAPI_PTR *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator); 2253typedef VkResult (VKAPI_PTR *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule); 2254typedef void (VKAPI_PTR *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator); 2255typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache); 2256typedef void (VKAPI_PTR *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator); 2257typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData); 2258typedef VkResult (VKAPI_PTR *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches); 2259typedef VkResult (VKAPI_PTR *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); 2260typedef VkResult (VKAPI_PTR *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); 2261typedef void (VKAPI_PTR *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator); 2262typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout); 2263typedef void (VKAPI_PTR *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator); 2264typedef VkResult (VKAPI_PTR *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler); 2265typedef void (VKAPI_PTR *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator); 2266typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout); 2267typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator); 2268typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool); 2269typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator); 2270typedef VkResult (VKAPI_PTR *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags); 2271typedef VkResult (VKAPI_PTR *PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets); 2272typedef VkResult (VKAPI_PTR *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets); 2273typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies); 2274typedef VkResult (VKAPI_PTR *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer); 2275typedef void (VKAPI_PTR *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator); 2276typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); 2277typedef void (VKAPI_PTR *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator); 2278typedef void (VKAPI_PTR *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity); 2279typedef VkResult (VKAPI_PTR *PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool); 2280typedef void (VKAPI_PTR *PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator); 2281typedef VkResult (VKAPI_PTR *PFN_vkResetCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags); 2282typedef VkResult (VKAPI_PTR *PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers); 2283typedef void (VKAPI_PTR *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); 2284typedef VkResult (VKAPI_PTR *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo); 2285typedef VkResult (VKAPI_PTR *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer); 2286typedef VkResult (VKAPI_PTR *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags); 2287typedef void (VKAPI_PTR *PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); 2288typedef void (VKAPI_PTR *PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports); 2289typedef void (VKAPI_PTR *PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors); 2290typedef void (VKAPI_PTR *PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth); 2291typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor); 2292typedef void (VKAPI_PTR *PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4]); 2293typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds); 2294typedef void (VKAPI_PTR *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask); 2295typedef void (VKAPI_PTR *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask); 2296typedef void (VKAPI_PTR *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference); 2297typedef 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); 2298typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); 2299typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets); 2300typedef void (VKAPI_PTR *PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance); 2301typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance); 2302typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); 2303typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); 2304typedef void (VKAPI_PTR *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z); 2305typedef void (VKAPI_PTR *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); 2306typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions); 2307typedef void (VKAPI_PTR *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions); 2308typedef void (VKAPI_PTR *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter); 2309typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions); 2310typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions); 2311typedef void (VKAPI_PTR *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint32_t* pData); 2312typedef void (VKAPI_PTR *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data); 2313typedef void (VKAPI_PTR *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); 2314typedef void (VKAPI_PTR *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); 2315typedef void (VKAPI_PTR *PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects); 2316typedef void (VKAPI_PTR *PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions); 2317typedef void (VKAPI_PTR *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); 2318typedef void (VKAPI_PTR *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); 2319typedef 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); 2320typedef 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); 2321typedef void (VKAPI_PTR *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags); 2322typedef void (VKAPI_PTR *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query); 2323typedef void (VKAPI_PTR *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); 2324typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query); 2325typedef void (VKAPI_PTR *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags); 2326typedef void (VKAPI_PTR *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues); 2327typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents); 2328typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkSubpassContents contents); 2329typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer); 2330typedef void (VKAPI_PTR *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); 2331 2332#ifndef VK_NO_PROTOTYPES 2333VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance( 2334 const VkInstanceCreateInfo* pCreateInfo, 2335 const VkAllocationCallbacks* pAllocator, 2336 VkInstance* pInstance); 2337 2338VKAPI_ATTR void VKAPI_CALL vkDestroyInstance( 2339 VkInstance instance, 2340 const VkAllocationCallbacks* pAllocator); 2341 2342VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices( 2343 VkInstance instance, 2344 uint32_t* pPhysicalDeviceCount, 2345 VkPhysicalDevice* pPhysicalDevices); 2346 2347VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures( 2348 VkPhysicalDevice physicalDevice, 2349 VkPhysicalDeviceFeatures* pFeatures); 2350 2351VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties( 2352 VkPhysicalDevice physicalDevice, 2353 VkFormat format, 2354 VkFormatProperties* pFormatProperties); 2355 2356VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties( 2357 VkPhysicalDevice physicalDevice, 2358 VkFormat format, 2359 VkImageType type, 2360 VkImageTiling tiling, 2361 VkImageUsageFlags usage, 2362 VkImageCreateFlags flags, 2363 VkImageFormatProperties* pImageFormatProperties); 2364 2365VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties( 2366 VkPhysicalDevice physicalDevice, 2367 VkPhysicalDeviceProperties* pProperties); 2368 2369VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties( 2370 VkPhysicalDevice physicalDevice, 2371 uint32_t* pQueueFamilyPropertyCount, 2372 VkQueueFamilyProperties* pQueueFamilyProperties); 2373 2374VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties( 2375 VkPhysicalDevice physicalDevice, 2376 VkPhysicalDeviceMemoryProperties* pMemoryProperties); 2377 2378VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr( 2379 VkInstance instance, 2380 const char* pName); 2381 2382VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr( 2383 VkDevice device, 2384 const char* pName); 2385 2386VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice( 2387 VkPhysicalDevice physicalDevice, 2388 const VkDeviceCreateInfo* pCreateInfo, 2389 const VkAllocationCallbacks* pAllocator, 2390 VkDevice* pDevice); 2391 2392VKAPI_ATTR void VKAPI_CALL vkDestroyDevice( 2393 VkDevice device, 2394 const VkAllocationCallbacks* pAllocator); 2395 2396VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties( 2397 const char* pLayerName, 2398 uint32_t* pPropertyCount, 2399 VkExtensionProperties* pProperties); 2400 2401VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties( 2402 VkPhysicalDevice physicalDevice, 2403 const char* pLayerName, 2404 uint32_t* pPropertyCount, 2405 VkExtensionProperties* pProperties); 2406 2407VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties( 2408 uint32_t* pPropertyCount, 2409 VkLayerProperties* pProperties); 2410 2411VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties( 2412 VkPhysicalDevice physicalDevice, 2413 uint32_t* pPropertyCount, 2414 VkLayerProperties* pProperties); 2415 2416VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue( 2417 VkDevice device, 2418 uint32_t queueFamilyIndex, 2419 uint32_t queueIndex, 2420 VkQueue* pQueue); 2421 2422VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit( 2423 VkQueue queue, 2424 uint32_t submitCount, 2425 const VkSubmitInfo* pSubmits, 2426 VkFence fence); 2427 2428VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle( 2429 VkQueue queue); 2430 2431VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle( 2432 VkDevice device); 2433 2434VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory( 2435 VkDevice device, 2436 const VkMemoryAllocateInfo* pAllocateInfo, 2437 const VkAllocationCallbacks* pAllocator, 2438 VkDeviceMemory* pMemory); 2439 2440VKAPI_ATTR void VKAPI_CALL vkFreeMemory( 2441 VkDevice device, 2442 VkDeviceMemory memory, 2443 const VkAllocationCallbacks* pAllocator); 2444 2445VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory( 2446 VkDevice device, 2447 VkDeviceMemory memory, 2448 VkDeviceSize offset, 2449 VkDeviceSize size, 2450 VkMemoryMapFlags flags, 2451 void** ppData); 2452 2453VKAPI_ATTR void VKAPI_CALL vkUnmapMemory( 2454 VkDevice device, 2455 VkDeviceMemory memory); 2456 2457VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges( 2458 VkDevice device, 2459 uint32_t memoryRangeCount, 2460 const VkMappedMemoryRange* pMemoryRanges); 2461 2462VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges( 2463 VkDevice device, 2464 uint32_t memoryRangeCount, 2465 const VkMappedMemoryRange* pMemoryRanges); 2466 2467VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment( 2468 VkDevice device, 2469 VkDeviceMemory memory, 2470 VkDeviceSize* pCommittedMemoryInBytes); 2471 2472VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory( 2473 VkDevice device, 2474 VkBuffer buffer, 2475 VkDeviceMemory memory, 2476 VkDeviceSize memoryOffset); 2477 2478VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory( 2479 VkDevice device, 2480 VkImage image, 2481 VkDeviceMemory memory, 2482 VkDeviceSize memoryOffset); 2483 2484VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements( 2485 VkDevice device, 2486 VkBuffer buffer, 2487 VkMemoryRequirements* pMemoryRequirements); 2488 2489VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements( 2490 VkDevice device, 2491 VkImage image, 2492 VkMemoryRequirements* pMemoryRequirements); 2493 2494VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements( 2495 VkDevice device, 2496 VkImage image, 2497 uint32_t* pSparseMemoryRequirementCount, 2498 VkSparseImageMemoryRequirements* pSparseMemoryRequirements); 2499 2500VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties( 2501 VkPhysicalDevice physicalDevice, 2502 VkFormat format, 2503 VkImageType type, 2504 VkSampleCountFlagBits samples, 2505 VkImageUsageFlags usage, 2506 VkImageTiling tiling, 2507 uint32_t* pPropertyCount, 2508 VkSparseImageFormatProperties* pProperties); 2509 2510VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse( 2511 VkQueue queue, 2512 uint32_t bindInfoCount, 2513 const VkBindSparseInfo* pBindInfo, 2514 VkFence fence); 2515 2516VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence( 2517 VkDevice device, 2518 const VkFenceCreateInfo* pCreateInfo, 2519 const VkAllocationCallbacks* pAllocator, 2520 VkFence* pFence); 2521 2522VKAPI_ATTR void VKAPI_CALL vkDestroyFence( 2523 VkDevice device, 2524 VkFence fence, 2525 const VkAllocationCallbacks* pAllocator); 2526 2527VKAPI_ATTR VkResult VKAPI_CALL vkResetFences( 2528 VkDevice device, 2529 uint32_t fenceCount, 2530 const VkFence* pFences); 2531 2532VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus( 2533 VkDevice device, 2534 VkFence fence); 2535 2536VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences( 2537 VkDevice device, 2538 uint32_t fenceCount, 2539 const VkFence* pFences, 2540 VkBool32 waitAll, 2541 uint64_t timeout); 2542 2543VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore( 2544 VkDevice device, 2545 const VkSemaphoreCreateInfo* pCreateInfo, 2546 const VkAllocationCallbacks* pAllocator, 2547 VkSemaphore* pSemaphore); 2548 2549VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore( 2550 VkDevice device, 2551 VkSemaphore semaphore, 2552 const VkAllocationCallbacks* pAllocator); 2553 2554VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent( 2555 VkDevice device, 2556 const VkEventCreateInfo* pCreateInfo, 2557 const VkAllocationCallbacks* pAllocator, 2558 VkEvent* pEvent); 2559 2560VKAPI_ATTR void VKAPI_CALL vkDestroyEvent( 2561 VkDevice device, 2562 VkEvent event, 2563 const VkAllocationCallbacks* pAllocator); 2564 2565VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus( 2566 VkDevice device, 2567 VkEvent event); 2568 2569VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent( 2570 VkDevice device, 2571 VkEvent event); 2572 2573VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent( 2574 VkDevice device, 2575 VkEvent event); 2576 2577VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool( 2578 VkDevice device, 2579 const VkQueryPoolCreateInfo* pCreateInfo, 2580 const VkAllocationCallbacks* pAllocator, 2581 VkQueryPool* pQueryPool); 2582 2583VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool( 2584 VkDevice device, 2585 VkQueryPool queryPool, 2586 const VkAllocationCallbacks* pAllocator); 2587 2588VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults( 2589 VkDevice device, 2590 VkQueryPool queryPool, 2591 uint32_t firstQuery, 2592 uint32_t queryCount, 2593 size_t dataSize, 2594 void* pData, 2595 VkDeviceSize stride, 2596 VkQueryResultFlags flags); 2597 2598VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer( 2599 VkDevice device, 2600 const VkBufferCreateInfo* pCreateInfo, 2601 const VkAllocationCallbacks* pAllocator, 2602 VkBuffer* pBuffer); 2603 2604VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer( 2605 VkDevice device, 2606 VkBuffer buffer, 2607 const VkAllocationCallbacks* pAllocator); 2608 2609VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView( 2610 VkDevice device, 2611 const VkBufferViewCreateInfo* pCreateInfo, 2612 const VkAllocationCallbacks* pAllocator, 2613 VkBufferView* pView); 2614 2615VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView( 2616 VkDevice device, 2617 VkBufferView bufferView, 2618 const VkAllocationCallbacks* pAllocator); 2619 2620VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage( 2621 VkDevice device, 2622 const VkImageCreateInfo* pCreateInfo, 2623 const VkAllocationCallbacks* pAllocator, 2624 VkImage* pImage); 2625 2626VKAPI_ATTR void VKAPI_CALL vkDestroyImage( 2627 VkDevice device, 2628 VkImage image, 2629 const VkAllocationCallbacks* pAllocator); 2630 2631VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout( 2632 VkDevice device, 2633 VkImage image, 2634 const VkImageSubresource* pSubresource, 2635 VkSubresourceLayout* pLayout); 2636 2637VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView( 2638 VkDevice device, 2639 const VkImageViewCreateInfo* pCreateInfo, 2640 const VkAllocationCallbacks* pAllocator, 2641 VkImageView* pView); 2642 2643VKAPI_ATTR void VKAPI_CALL vkDestroyImageView( 2644 VkDevice device, 2645 VkImageView imageView, 2646 const VkAllocationCallbacks* pAllocator); 2647 2648VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule( 2649 VkDevice device, 2650 const VkShaderModuleCreateInfo* pCreateInfo, 2651 const VkAllocationCallbacks* pAllocator, 2652 VkShaderModule* pShaderModule); 2653 2654VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule( 2655 VkDevice device, 2656 VkShaderModule shaderModule, 2657 const VkAllocationCallbacks* pAllocator); 2658 2659VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache( 2660 VkDevice device, 2661 const VkPipelineCacheCreateInfo* pCreateInfo, 2662 const VkAllocationCallbacks* pAllocator, 2663 VkPipelineCache* pPipelineCache); 2664 2665VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache( 2666 VkDevice device, 2667 VkPipelineCache pipelineCache, 2668 const VkAllocationCallbacks* pAllocator); 2669 2670VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData( 2671 VkDevice device, 2672 VkPipelineCache pipelineCache, 2673 size_t* pDataSize, 2674 void* pData); 2675 2676VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches( 2677 VkDevice device, 2678 VkPipelineCache dstCache, 2679 uint32_t srcCacheCount, 2680 const VkPipelineCache* pSrcCaches); 2681 2682VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines( 2683 VkDevice device, 2684 VkPipelineCache pipelineCache, 2685 uint32_t createInfoCount, 2686 const VkGraphicsPipelineCreateInfo* pCreateInfos, 2687 const VkAllocationCallbacks* pAllocator, 2688 VkPipeline* pPipelines); 2689 2690VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines( 2691 VkDevice device, 2692 VkPipelineCache pipelineCache, 2693 uint32_t createInfoCount, 2694 const VkComputePipelineCreateInfo* pCreateInfos, 2695 const VkAllocationCallbacks* pAllocator, 2696 VkPipeline* pPipelines); 2697 2698VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline( 2699 VkDevice device, 2700 VkPipeline pipeline, 2701 const VkAllocationCallbacks* pAllocator); 2702 2703VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout( 2704 VkDevice device, 2705 const VkPipelineLayoutCreateInfo* pCreateInfo, 2706 const VkAllocationCallbacks* pAllocator, 2707 VkPipelineLayout* pPipelineLayout); 2708 2709VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout( 2710 VkDevice device, 2711 VkPipelineLayout pipelineLayout, 2712 const VkAllocationCallbacks* pAllocator); 2713 2714VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler( 2715 VkDevice device, 2716 const VkSamplerCreateInfo* pCreateInfo, 2717 const VkAllocationCallbacks* pAllocator, 2718 VkSampler* pSampler); 2719 2720VKAPI_ATTR void VKAPI_CALL vkDestroySampler( 2721 VkDevice device, 2722 VkSampler sampler, 2723 const VkAllocationCallbacks* pAllocator); 2724 2725VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout( 2726 VkDevice device, 2727 const VkDescriptorSetLayoutCreateInfo* pCreateInfo, 2728 const VkAllocationCallbacks* pAllocator, 2729 VkDescriptorSetLayout* pSetLayout); 2730 2731VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout( 2732 VkDevice device, 2733 VkDescriptorSetLayout descriptorSetLayout, 2734 const VkAllocationCallbacks* pAllocator); 2735 2736VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool( 2737 VkDevice device, 2738 const VkDescriptorPoolCreateInfo* pCreateInfo, 2739 const VkAllocationCallbacks* pAllocator, 2740 VkDescriptorPool* pDescriptorPool); 2741 2742VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool( 2743 VkDevice device, 2744 VkDescriptorPool descriptorPool, 2745 const VkAllocationCallbacks* pAllocator); 2746 2747VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool( 2748 VkDevice device, 2749 VkDescriptorPool descriptorPool, 2750 VkDescriptorPoolResetFlags flags); 2751 2752VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets( 2753 VkDevice device, 2754 const VkDescriptorSetAllocateInfo* pAllocateInfo, 2755 VkDescriptorSet* pDescriptorSets); 2756 2757VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets( 2758 VkDevice device, 2759 VkDescriptorPool descriptorPool, 2760 uint32_t descriptorSetCount, 2761 const VkDescriptorSet* pDescriptorSets); 2762 2763VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets( 2764 VkDevice device, 2765 uint32_t descriptorWriteCount, 2766 const VkWriteDescriptorSet* pDescriptorWrites, 2767 uint32_t descriptorCopyCount, 2768 const VkCopyDescriptorSet* pDescriptorCopies); 2769 2770VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer( 2771 VkDevice device, 2772 const VkFramebufferCreateInfo* pCreateInfo, 2773 const VkAllocationCallbacks* pAllocator, 2774 VkFramebuffer* pFramebuffer); 2775 2776VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer( 2777 VkDevice device, 2778 VkFramebuffer framebuffer, 2779 const VkAllocationCallbacks* pAllocator); 2780 2781VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass( 2782 VkDevice device, 2783 const VkRenderPassCreateInfo* pCreateInfo, 2784 const VkAllocationCallbacks* pAllocator, 2785 VkRenderPass* pRenderPass); 2786 2787VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass( 2788 VkDevice device, 2789 VkRenderPass renderPass, 2790 const VkAllocationCallbacks* pAllocator); 2791 2792VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity( 2793 VkDevice device, 2794 VkRenderPass renderPass, 2795 VkExtent2D* pGranularity); 2796 2797VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool( 2798 VkDevice device, 2799 const VkCommandPoolCreateInfo* pCreateInfo, 2800 const VkAllocationCallbacks* pAllocator, 2801 VkCommandPool* pCommandPool); 2802 2803VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool( 2804 VkDevice device, 2805 VkCommandPool commandPool, 2806 const VkAllocationCallbacks* pAllocator); 2807 2808VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool( 2809 VkDevice device, 2810 VkCommandPool commandPool, 2811 VkCommandPoolResetFlags flags); 2812 2813VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers( 2814 VkDevice device, 2815 const VkCommandBufferAllocateInfo* pAllocateInfo, 2816 VkCommandBuffer* pCommandBuffers); 2817 2818VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers( 2819 VkDevice device, 2820 VkCommandPool commandPool, 2821 uint32_t commandBufferCount, 2822 const VkCommandBuffer* pCommandBuffers); 2823 2824VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer( 2825 VkCommandBuffer commandBuffer, 2826 const VkCommandBufferBeginInfo* pBeginInfo); 2827 2828VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer( 2829 VkCommandBuffer commandBuffer); 2830 2831VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer( 2832 VkCommandBuffer commandBuffer, 2833 VkCommandBufferResetFlags flags); 2834 2835VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline( 2836 VkCommandBuffer commandBuffer, 2837 VkPipelineBindPoint pipelineBindPoint, 2838 VkPipeline pipeline); 2839 2840VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport( 2841 VkCommandBuffer commandBuffer, 2842 uint32_t firstViewport, 2843 uint32_t viewportCount, 2844 const VkViewport* pViewports); 2845 2846VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor( 2847 VkCommandBuffer commandBuffer, 2848 uint32_t firstScissor, 2849 uint32_t scissorCount, 2850 const VkRect2D* pScissors); 2851 2852VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth( 2853 VkCommandBuffer commandBuffer, 2854 float lineWidth); 2855 2856VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias( 2857 VkCommandBuffer commandBuffer, 2858 float depthBiasConstantFactor, 2859 float depthBiasClamp, 2860 float depthBiasSlopeFactor); 2861 2862VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants( 2863 VkCommandBuffer commandBuffer, 2864 const float blendConstants[4]); 2865 2866VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds( 2867 VkCommandBuffer commandBuffer, 2868 float minDepthBounds, 2869 float maxDepthBounds); 2870 2871VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask( 2872 VkCommandBuffer commandBuffer, 2873 VkStencilFaceFlags faceMask, 2874 uint32_t compareMask); 2875 2876VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask( 2877 VkCommandBuffer commandBuffer, 2878 VkStencilFaceFlags faceMask, 2879 uint32_t writeMask); 2880 2881VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference( 2882 VkCommandBuffer commandBuffer, 2883 VkStencilFaceFlags faceMask, 2884 uint32_t reference); 2885 2886VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets( 2887 VkCommandBuffer commandBuffer, 2888 VkPipelineBindPoint pipelineBindPoint, 2889 VkPipelineLayout layout, 2890 uint32_t firstSet, 2891 uint32_t descriptorSetCount, 2892 const VkDescriptorSet* pDescriptorSets, 2893 uint32_t dynamicOffsetCount, 2894 const uint32_t* pDynamicOffsets); 2895 2896VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer( 2897 VkCommandBuffer commandBuffer, 2898 VkBuffer buffer, 2899 VkDeviceSize offset, 2900 VkIndexType indexType); 2901 2902VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers( 2903 VkCommandBuffer commandBuffer, 2904 uint32_t firstBinding, 2905 uint32_t bindingCount, 2906 const VkBuffer* pBuffers, 2907 const VkDeviceSize* pOffsets); 2908 2909VKAPI_ATTR void VKAPI_CALL vkCmdDraw( 2910 VkCommandBuffer commandBuffer, 2911 uint32_t vertexCount, 2912 uint32_t instanceCount, 2913 uint32_t firstVertex, 2914 uint32_t firstInstance); 2915 2916VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed( 2917 VkCommandBuffer commandBuffer, 2918 uint32_t indexCount, 2919 uint32_t instanceCount, 2920 uint32_t firstIndex, 2921 int32_t vertexOffset, 2922 uint32_t firstInstance); 2923 2924VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect( 2925 VkCommandBuffer commandBuffer, 2926 VkBuffer buffer, 2927 VkDeviceSize offset, 2928 uint32_t drawCount, 2929 uint32_t stride); 2930 2931VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect( 2932 VkCommandBuffer commandBuffer, 2933 VkBuffer buffer, 2934 VkDeviceSize offset, 2935 uint32_t drawCount, 2936 uint32_t stride); 2937 2938VKAPI_ATTR void VKAPI_CALL vkCmdDispatch( 2939 VkCommandBuffer commandBuffer, 2940 uint32_t x, 2941 uint32_t y, 2942 uint32_t z); 2943 2944VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect( 2945 VkCommandBuffer commandBuffer, 2946 VkBuffer buffer, 2947 VkDeviceSize offset); 2948 2949VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer( 2950 VkCommandBuffer commandBuffer, 2951 VkBuffer srcBuffer, 2952 VkBuffer dstBuffer, 2953 uint32_t regionCount, 2954 const VkBufferCopy* pRegions); 2955 2956VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage( 2957 VkCommandBuffer commandBuffer, 2958 VkImage srcImage, 2959 VkImageLayout srcImageLayout, 2960 VkImage dstImage, 2961 VkImageLayout dstImageLayout, 2962 uint32_t regionCount, 2963 const VkImageCopy* pRegions); 2964 2965VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage( 2966 VkCommandBuffer commandBuffer, 2967 VkImage srcImage, 2968 VkImageLayout srcImageLayout, 2969 VkImage dstImage, 2970 VkImageLayout dstImageLayout, 2971 uint32_t regionCount, 2972 const VkImageBlit* pRegions, 2973 VkFilter filter); 2974 2975VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage( 2976 VkCommandBuffer commandBuffer, 2977 VkBuffer srcBuffer, 2978 VkImage dstImage, 2979 VkImageLayout dstImageLayout, 2980 uint32_t regionCount, 2981 const VkBufferImageCopy* pRegions); 2982 2983VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer( 2984 VkCommandBuffer commandBuffer, 2985 VkImage srcImage, 2986 VkImageLayout srcImageLayout, 2987 VkBuffer dstBuffer, 2988 uint32_t regionCount, 2989 const VkBufferImageCopy* pRegions); 2990 2991VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer( 2992 VkCommandBuffer commandBuffer, 2993 VkBuffer dstBuffer, 2994 VkDeviceSize dstOffset, 2995 VkDeviceSize dataSize, 2996 const uint32_t* pData); 2997 2998VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer( 2999 VkCommandBuffer commandBuffer, 3000 VkBuffer dstBuffer, 3001 VkDeviceSize dstOffset, 3002 VkDeviceSize size, 3003 uint32_t data); 3004 3005VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage( 3006 VkCommandBuffer commandBuffer, 3007 VkImage image, 3008 VkImageLayout imageLayout, 3009 const VkClearColorValue* pColor, 3010 uint32_t rangeCount, 3011 const VkImageSubresourceRange* pRanges); 3012 3013VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage( 3014 VkCommandBuffer commandBuffer, 3015 VkImage image, 3016 VkImageLayout imageLayout, 3017 const VkClearDepthStencilValue* pDepthStencil, 3018 uint32_t rangeCount, 3019 const VkImageSubresourceRange* pRanges); 3020 3021VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments( 3022 VkCommandBuffer commandBuffer, 3023 uint32_t attachmentCount, 3024 const VkClearAttachment* pAttachments, 3025 uint32_t rectCount, 3026 const VkClearRect* pRects); 3027 3028VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage( 3029 VkCommandBuffer commandBuffer, 3030 VkImage srcImage, 3031 VkImageLayout srcImageLayout, 3032 VkImage dstImage, 3033 VkImageLayout dstImageLayout, 3034 uint32_t regionCount, 3035 const VkImageResolve* pRegions); 3036 3037VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent( 3038 VkCommandBuffer commandBuffer, 3039 VkEvent event, 3040 VkPipelineStageFlags stageMask); 3041 3042VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent( 3043 VkCommandBuffer commandBuffer, 3044 VkEvent event, 3045 VkPipelineStageFlags stageMask); 3046 3047VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents( 3048 VkCommandBuffer commandBuffer, 3049 uint32_t eventCount, 3050 const VkEvent* pEvents, 3051 VkPipelineStageFlags srcStageMask, 3052 VkPipelineStageFlags dstStageMask, 3053 uint32_t memoryBarrierCount, 3054 const VkMemoryBarrier* pMemoryBarriers, 3055 uint32_t bufferMemoryBarrierCount, 3056 const VkBufferMemoryBarrier* pBufferMemoryBarriers, 3057 uint32_t imageMemoryBarrierCount, 3058 const VkImageMemoryBarrier* pImageMemoryBarriers); 3059 3060VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier( 3061 VkCommandBuffer commandBuffer, 3062 VkPipelineStageFlags srcStageMask, 3063 VkPipelineStageFlags dstStageMask, 3064 VkDependencyFlags dependencyFlags, 3065 uint32_t memoryBarrierCount, 3066 const VkMemoryBarrier* pMemoryBarriers, 3067 uint32_t bufferMemoryBarrierCount, 3068 const VkBufferMemoryBarrier* pBufferMemoryBarriers, 3069 uint32_t imageMemoryBarrierCount, 3070 const VkImageMemoryBarrier* pImageMemoryBarriers); 3071 3072VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery( 3073 VkCommandBuffer commandBuffer, 3074 VkQueryPool queryPool, 3075 uint32_t query, 3076 VkQueryControlFlags flags); 3077 3078VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery( 3079 VkCommandBuffer commandBuffer, 3080 VkQueryPool queryPool, 3081 uint32_t query); 3082 3083VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool( 3084 VkCommandBuffer commandBuffer, 3085 VkQueryPool queryPool, 3086 uint32_t firstQuery, 3087 uint32_t queryCount); 3088 3089VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp( 3090 VkCommandBuffer commandBuffer, 3091 VkPipelineStageFlagBits pipelineStage, 3092 VkQueryPool queryPool, 3093 uint32_t query); 3094 3095VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults( 3096 VkCommandBuffer commandBuffer, 3097 VkQueryPool queryPool, 3098 uint32_t firstQuery, 3099 uint32_t queryCount, 3100 VkBuffer dstBuffer, 3101 VkDeviceSize dstOffset, 3102 VkDeviceSize stride, 3103 VkQueryResultFlags flags); 3104 3105VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants( 3106 VkCommandBuffer commandBuffer, 3107 VkPipelineLayout layout, 3108 VkShaderStageFlags stageFlags, 3109 uint32_t offset, 3110 uint32_t size, 3111 const void* pValues); 3112 3113VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass( 3114 VkCommandBuffer commandBuffer, 3115 const VkRenderPassBeginInfo* pRenderPassBegin, 3116 VkSubpassContents contents); 3117 3118VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass( 3119 VkCommandBuffer commandBuffer, 3120 VkSubpassContents contents); 3121 3122VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass( 3123 VkCommandBuffer commandBuffer); 3124 3125VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands( 3126 VkCommandBuffer commandBuffer, 3127 uint32_t commandBufferCount, 3128 const VkCommandBuffer* pCommandBuffers); 3129#endif 3130 3131#define VK_KHR_surface 1 3132VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR) 3133 3134#define VK_KHR_SURFACE_SPEC_VERSION 25 3135#define VK_KHR_SURFACE_EXTENSION_NAME "VK_KHR_surface" 3136 3137 3138typedef enum VkColorSpaceKHR { 3139 VK_COLORSPACE_SRGB_NONLINEAR_KHR = 0, 3140 VK_COLORSPACE_BEGIN_RANGE = VK_COLORSPACE_SRGB_NONLINEAR_KHR, 3141 VK_COLORSPACE_END_RANGE = VK_COLORSPACE_SRGB_NONLINEAR_KHR, 3142 VK_COLORSPACE_RANGE_SIZE = (VK_COLORSPACE_SRGB_NONLINEAR_KHR - VK_COLORSPACE_SRGB_NONLINEAR_KHR + 1), 3143 VK_COLORSPACE_MAX_ENUM = 0x7FFFFFFF 3144} VkColorSpaceKHR; 3145 3146typedef enum VkPresentModeKHR { 3147 VK_PRESENT_MODE_IMMEDIATE_KHR = 0, 3148 VK_PRESENT_MODE_MAILBOX_KHR = 1, 3149 VK_PRESENT_MODE_FIFO_KHR = 2, 3150 VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3, 3151 VK_PRESENT_MODE_BEGIN_RANGE = VK_PRESENT_MODE_IMMEDIATE_KHR, 3152 VK_PRESENT_MODE_END_RANGE = VK_PRESENT_MODE_FIFO_RELAXED_KHR, 3153 VK_PRESENT_MODE_RANGE_SIZE = (VK_PRESENT_MODE_FIFO_RELAXED_KHR - VK_PRESENT_MODE_IMMEDIATE_KHR + 1), 3154 VK_PRESENT_MODE_MAX_ENUM = 0x7FFFFFFF 3155} VkPresentModeKHR; 3156 3157 3158typedef enum VkSurfaceTransformFlagBitsKHR { 3159 VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 0x00000001, 3160 VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 0x00000002, 3161 VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 0x00000004, 3162 VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 0x00000008, 3163 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 0x00000010, 3164 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 0x00000020, 3165 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 0x00000040, 3166 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 0x00000080, 3167 VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100, 3168} VkSurfaceTransformFlagBitsKHR; 3169typedef VkFlags VkSurfaceTransformFlagsKHR; 3170 3171typedef enum VkCompositeAlphaFlagBitsKHR { 3172 VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, 3173 VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002, 3174 VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004, 3175 VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008, 3176} VkCompositeAlphaFlagBitsKHR; 3177typedef VkFlags VkCompositeAlphaFlagsKHR; 3178 3179typedef struct VkSurfaceCapabilitiesKHR { 3180 uint32_t minImageCount; 3181 uint32_t maxImageCount; 3182 VkExtent2D currentExtent; 3183 VkExtent2D minImageExtent; 3184 VkExtent2D maxImageExtent; 3185 uint32_t maxImageArrayLayers; 3186 VkSurfaceTransformFlagsKHR supportedTransforms; 3187 VkSurfaceTransformFlagBitsKHR currentTransform; 3188 VkCompositeAlphaFlagsKHR supportedCompositeAlpha; 3189 VkImageUsageFlags supportedUsageFlags; 3190} VkSurfaceCapabilitiesKHR; 3191 3192typedef struct VkSurfaceFormatKHR { 3193 VkFormat format; 3194 VkColorSpaceKHR colorSpace; 3195} VkSurfaceFormatKHR; 3196 3197 3198typedef void (VKAPI_PTR *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator); 3199typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported); 3200typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); 3201typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats); 3202typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes); 3203 3204#ifndef VK_NO_PROTOTYPES 3205VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR( 3206 VkInstance instance, 3207 VkSurfaceKHR surface, 3208 const VkAllocationCallbacks* pAllocator); 3209 3210VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR( 3211 VkPhysicalDevice physicalDevice, 3212 uint32_t queueFamilyIndex, 3213 VkSurfaceKHR surface, 3214 VkBool32* pSupported); 3215 3216VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR( 3217 VkPhysicalDevice physicalDevice, 3218 VkSurfaceKHR surface, 3219 VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); 3220 3221VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR( 3222 VkPhysicalDevice physicalDevice, 3223 VkSurfaceKHR surface, 3224 uint32_t* pSurfaceFormatCount, 3225 VkSurfaceFormatKHR* pSurfaceFormats); 3226 3227VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR( 3228 VkPhysicalDevice physicalDevice, 3229 VkSurfaceKHR surface, 3230 uint32_t* pPresentModeCount, 3231 VkPresentModeKHR* pPresentModes); 3232#endif 3233 3234#define VK_KHR_swapchain 1 3235VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR) 3236 3237#define VK_KHR_SWAPCHAIN_SPEC_VERSION 67 3238#define VK_KHR_SWAPCHAIN_EXTENSION_NAME "VK_KHR_swapchain" 3239 3240typedef VkFlags VkSwapchainCreateFlagsKHR; 3241 3242typedef struct VkSwapchainCreateInfoKHR { 3243 VkStructureType sType; 3244 const void* pNext; 3245 VkSwapchainCreateFlagsKHR flags; 3246 VkSurfaceKHR surface; 3247 uint32_t minImageCount; 3248 VkFormat imageFormat; 3249 VkColorSpaceKHR imageColorSpace; 3250 VkExtent2D imageExtent; 3251 uint32_t imageArrayLayers; 3252 VkImageUsageFlags imageUsage; 3253 VkSharingMode imageSharingMode; 3254 uint32_t queueFamilyIndexCount; 3255 const uint32_t* pQueueFamilyIndices; 3256 VkSurfaceTransformFlagBitsKHR preTransform; 3257 VkCompositeAlphaFlagBitsKHR compositeAlpha; 3258 VkPresentModeKHR presentMode; 3259 VkBool32 clipped; 3260 VkSwapchainKHR oldSwapchain; 3261} VkSwapchainCreateInfoKHR; 3262 3263typedef struct VkPresentInfoKHR { 3264 VkStructureType sType; 3265 const void* pNext; 3266 uint32_t waitSemaphoreCount; 3267 const VkSemaphore* pWaitSemaphores; 3268 uint32_t swapchainCount; 3269 const VkSwapchainKHR* pSwapchains; 3270 const uint32_t* pImageIndices; 3271 VkResult* pResults; 3272} VkPresentInfoKHR; 3273 3274 3275typedef VkResult (VKAPI_PTR *PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain); 3276typedef void (VKAPI_PTR *PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator); 3277typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages); 3278typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex); 3279typedef VkResult (VKAPI_PTR *PFN_vkQueuePresentKHR)(VkQueue queue, const VkPresentInfoKHR* pPresentInfo); 3280 3281#ifndef VK_NO_PROTOTYPES 3282VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR( 3283 VkDevice device, 3284 const VkSwapchainCreateInfoKHR* pCreateInfo, 3285 const VkAllocationCallbacks* pAllocator, 3286 VkSwapchainKHR* pSwapchain); 3287 3288VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR( 3289 VkDevice device, 3290 VkSwapchainKHR swapchain, 3291 const VkAllocationCallbacks* pAllocator); 3292 3293VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR( 3294 VkDevice device, 3295 VkSwapchainKHR swapchain, 3296 uint32_t* pSwapchainImageCount, 3297 VkImage* pSwapchainImages); 3298 3299VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR( 3300 VkDevice device, 3301 VkSwapchainKHR swapchain, 3302 uint64_t timeout, 3303 VkSemaphore semaphore, 3304 VkFence fence, 3305 uint32_t* pImageIndex); 3306 3307VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR( 3308 VkQueue queue, 3309 const VkPresentInfoKHR* pPresentInfo); 3310#endif 3311 3312#define VK_KHR_display 1 3313VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR) 3314VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR) 3315 3316#define VK_KHR_DISPLAY_SPEC_VERSION 21 3317#define VK_KHR_DISPLAY_EXTENSION_NAME "VK_KHR_display" 3318 3319 3320typedef enum VkDisplayPlaneAlphaFlagBitsKHR { 3321 VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, 3322 VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000002, 3323 VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000004, 3324 VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000008, 3325} VkDisplayPlaneAlphaFlagBitsKHR; 3326typedef VkFlags VkDisplayModeCreateFlagsKHR; 3327typedef VkFlags VkDisplayPlaneAlphaFlagsKHR; 3328typedef VkFlags VkDisplaySurfaceCreateFlagsKHR; 3329 3330typedef struct VkDisplayPropertiesKHR { 3331 VkDisplayKHR display; 3332 const char* displayName; 3333 VkExtent2D physicalDimensions; 3334 VkExtent2D physicalResolution; 3335 VkSurfaceTransformFlagsKHR supportedTransforms; 3336 VkBool32 planeReorderPossible; 3337 VkBool32 persistentContent; 3338} VkDisplayPropertiesKHR; 3339 3340typedef struct VkDisplayModeParametersKHR { 3341 VkExtent2D visibleRegion; 3342 uint32_t refreshRate; 3343} VkDisplayModeParametersKHR; 3344 3345typedef struct VkDisplayModePropertiesKHR { 3346 VkDisplayModeKHR displayMode; 3347 VkDisplayModeParametersKHR parameters; 3348} VkDisplayModePropertiesKHR; 3349 3350typedef struct VkDisplayModeCreateInfoKHR { 3351 VkStructureType sType; 3352 const void* pNext; 3353 VkDisplayModeCreateFlagsKHR flags; 3354 VkDisplayModeParametersKHR parameters; 3355} VkDisplayModeCreateInfoKHR; 3356 3357typedef struct VkDisplayPlaneCapabilitiesKHR { 3358 VkDisplayPlaneAlphaFlagsKHR supportedAlpha; 3359 VkOffset2D minSrcPosition; 3360 VkOffset2D maxSrcPosition; 3361 VkExtent2D minSrcExtent; 3362 VkExtent2D maxSrcExtent; 3363 VkOffset2D minDstPosition; 3364 VkOffset2D maxDstPosition; 3365 VkExtent2D minDstExtent; 3366 VkExtent2D maxDstExtent; 3367} VkDisplayPlaneCapabilitiesKHR; 3368 3369typedef struct VkDisplayPlanePropertiesKHR { 3370 VkDisplayKHR currentDisplay; 3371 uint32_t currentStackIndex; 3372} VkDisplayPlanePropertiesKHR; 3373 3374typedef struct VkDisplaySurfaceCreateInfoKHR { 3375 VkStructureType sType; 3376 const void* pNext; 3377 VkDisplaySurfaceCreateFlagsKHR flags; 3378 VkDisplayModeKHR displayMode; 3379 uint32_t planeIndex; 3380 uint32_t planeStackIndex; 3381 VkSurfaceTransformFlagBitsKHR transform; 3382 float globalAlpha; 3383 VkDisplayPlaneAlphaFlagBitsKHR alphaMode; 3384 VkExtent2D imageExtent; 3385} VkDisplaySurfaceCreateInfoKHR; 3386 3387 3388typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties); 3389typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties); 3390typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays); 3391typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties); 3392typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR*pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode); 3393typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities); 3394typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); 3395 3396#ifndef VK_NO_PROTOTYPES 3397VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR( 3398 VkPhysicalDevice physicalDevice, 3399 uint32_t* pPropertyCount, 3400 VkDisplayPropertiesKHR* pProperties); 3401 3402VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR( 3403 VkPhysicalDevice physicalDevice, 3404 uint32_t* pPropertyCount, 3405 VkDisplayPlanePropertiesKHR* pProperties); 3406 3407VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR( 3408 VkPhysicalDevice physicalDevice, 3409 uint32_t planeIndex, 3410 uint32_t* pDisplayCount, 3411 VkDisplayKHR* pDisplays); 3412 3413VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR( 3414 VkPhysicalDevice physicalDevice, 3415 VkDisplayKHR display, 3416 uint32_t* pPropertyCount, 3417 VkDisplayModePropertiesKHR* pProperties); 3418 3419VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR( 3420 VkPhysicalDevice physicalDevice, 3421 VkDisplayKHR display, 3422 const VkDisplayModeCreateInfoKHR* pCreateInfo, 3423 const VkAllocationCallbacks* pAllocator, 3424 VkDisplayModeKHR* pMode); 3425 3426VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR( 3427 VkPhysicalDevice physicalDevice, 3428 VkDisplayModeKHR mode, 3429 uint32_t planeIndex, 3430 VkDisplayPlaneCapabilitiesKHR* pCapabilities); 3431 3432VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR( 3433 VkInstance instance, 3434 const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, 3435 const VkAllocationCallbacks* pAllocator, 3436 VkSurfaceKHR* pSurface); 3437#endif 3438 3439#define VK_KHR_display_swapchain 1 3440#define VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION 9 3441#define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain" 3442 3443typedef struct VkDisplayPresentInfoKHR { 3444 VkStructureType sType; 3445 const void* pNext; 3446 VkRect2D srcRect; 3447 VkRect2D dstRect; 3448 VkBool32 persistent; 3449} VkDisplayPresentInfoKHR; 3450 3451 3452typedef VkResult (VKAPI_PTR *PFN_vkCreateSharedSwapchainsKHR)(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains); 3453 3454#ifndef VK_NO_PROTOTYPES 3455VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR( 3456 VkDevice device, 3457 uint32_t swapchainCount, 3458 const VkSwapchainCreateInfoKHR* pCreateInfos, 3459 const VkAllocationCallbacks* pAllocator, 3460 VkSwapchainKHR* pSwapchains); 3461#endif 3462 3463#ifdef VK_USE_PLATFORM_XLIB_KHR 3464#define VK_KHR_xlib_surface 1 3465#include <X11/Xlib.h> 3466 3467#define VK_KHR_XLIB_SURFACE_SPEC_VERSION 6 3468#define VK_KHR_XLIB_SURFACE_EXTENSION_NAME "VK_KHR_xlib_surface" 3469 3470typedef VkFlags VkXlibSurfaceCreateFlagsKHR; 3471 3472typedef struct VkXlibSurfaceCreateInfoKHR { 3473 VkStructureType sType; 3474 const void* pNext; 3475 VkXlibSurfaceCreateFlagsKHR flags; 3476 Display* dpy; 3477 Window window; 3478} VkXlibSurfaceCreateInfoKHR; 3479 3480 3481typedef VkResult (VKAPI_PTR *PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); 3482typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID); 3483 3484#ifndef VK_NO_PROTOTYPES 3485VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR( 3486 VkInstance instance, 3487 const VkXlibSurfaceCreateInfoKHR* pCreateInfo, 3488 const VkAllocationCallbacks* pAllocator, 3489 VkSurfaceKHR* pSurface); 3490 3491VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR( 3492 VkPhysicalDevice physicalDevice, 3493 uint32_t queueFamilyIndex, 3494 Display* dpy, 3495 VisualID visualID); 3496#endif 3497#endif /* VK_USE_PLATFORM_XLIB_KHR */ 3498 3499#ifdef VK_USE_PLATFORM_XCB_KHR 3500#define VK_KHR_xcb_surface 1 3501#include <xcb/xcb.h> 3502 3503#define VK_KHR_XCB_SURFACE_SPEC_VERSION 6 3504#define VK_KHR_XCB_SURFACE_EXTENSION_NAME "VK_KHR_xcb_surface" 3505 3506typedef VkFlags VkXcbSurfaceCreateFlagsKHR; 3507 3508typedef struct VkXcbSurfaceCreateInfoKHR { 3509 VkStructureType sType; 3510 const void* pNext; 3511 VkXcbSurfaceCreateFlagsKHR flags; 3512 xcb_connection_t* connection; 3513 xcb_window_t window; 3514} VkXcbSurfaceCreateInfoKHR; 3515 3516 3517typedef VkResult (VKAPI_PTR *PFN_vkCreateXcbSurfaceKHR)(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); 3518typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id); 3519 3520#ifndef VK_NO_PROTOTYPES 3521VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR( 3522 VkInstance instance, 3523 const VkXcbSurfaceCreateInfoKHR* pCreateInfo, 3524 const VkAllocationCallbacks* pAllocator, 3525 VkSurfaceKHR* pSurface); 3526 3527VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR( 3528 VkPhysicalDevice physicalDevice, 3529 uint32_t queueFamilyIndex, 3530 xcb_connection_t* connection, 3531 xcb_visualid_t visual_id); 3532#endif 3533#endif /* VK_USE_PLATFORM_XCB_KHR */ 3534 3535#ifdef VK_USE_PLATFORM_WAYLAND_KHR 3536#define VK_KHR_wayland_surface 1 3537#include <wayland-client.h> 3538 3539#define VK_KHR_WAYLAND_SURFACE_SPEC_VERSION 5 3540#define VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME "VK_KHR_wayland_surface" 3541 3542typedef VkFlags VkWaylandSurfaceCreateFlagsKHR; 3543 3544typedef struct VkWaylandSurfaceCreateInfoKHR { 3545 VkStructureType sType; 3546 const void* pNext; 3547 VkWaylandSurfaceCreateFlagsKHR flags; 3548 struct wl_display* display; 3549 struct wl_surface* surface; 3550} VkWaylandSurfaceCreateInfoKHR; 3551 3552 3553typedef VkResult (VKAPI_PTR *PFN_vkCreateWaylandSurfaceKHR)(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); 3554typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display); 3555 3556#ifndef VK_NO_PROTOTYPES 3557VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR( 3558 VkInstance instance, 3559 const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, 3560 const VkAllocationCallbacks* pAllocator, 3561 VkSurfaceKHR* pSurface); 3562 3563VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR( 3564 VkPhysicalDevice physicalDevice, 3565 uint32_t queueFamilyIndex, 3566 struct wl_display* display); 3567#endif 3568#endif /* VK_USE_PLATFORM_WAYLAND_KHR */ 3569 3570#ifdef VK_USE_PLATFORM_MIR_KHR 3571#define VK_KHR_mir_surface 1 3572#include <mir_toolkit/client_types.h> 3573 3574#define VK_KHR_MIR_SURFACE_SPEC_VERSION 4 3575#define VK_KHR_MIR_SURFACE_EXTENSION_NAME "VK_KHR_mir_surface" 3576 3577typedef VkFlags VkMirSurfaceCreateFlagsKHR; 3578 3579typedef struct VkMirSurfaceCreateInfoKHR { 3580 VkStructureType sType; 3581 const void* pNext; 3582 VkMirSurfaceCreateFlagsKHR flags; 3583 MirConnection* connection; 3584 MirSurface* mirSurface; 3585} VkMirSurfaceCreateInfoKHR; 3586 3587 3588typedef VkResult (VKAPI_PTR *PFN_vkCreateMirSurfaceKHR)(VkInstance instance, const VkMirSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); 3589typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceMirPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, MirConnection* connection); 3590 3591#ifndef VK_NO_PROTOTYPES 3592VKAPI_ATTR VkResult VKAPI_CALL vkCreateMirSurfaceKHR( 3593 VkInstance instance, 3594 const VkMirSurfaceCreateInfoKHR* pCreateInfo, 3595 const VkAllocationCallbacks* pAllocator, 3596 VkSurfaceKHR* pSurface); 3597 3598VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceMirPresentationSupportKHR( 3599 VkPhysicalDevice physicalDevice, 3600 uint32_t queueFamilyIndex, 3601 MirConnection* connection); 3602#endif 3603#endif /* VK_USE_PLATFORM_MIR_KHR */ 3604 3605#ifdef VK_USE_PLATFORM_ANDROID_KHR 3606#define VK_KHR_android_surface 1 3607#include <android/native_window.h> 3608 3609#define VK_KHR_ANDROID_SURFACE_SPEC_VERSION 6 3610#define VK_KHR_ANDROID_SURFACE_EXTENSION_NAME "VK_KHR_android_surface" 3611 3612typedef VkFlags VkAndroidSurfaceCreateFlagsKHR; 3613 3614typedef struct VkAndroidSurfaceCreateInfoKHR { 3615 VkStructureType sType; 3616 const void* pNext; 3617 VkAndroidSurfaceCreateFlagsKHR flags; 3618 ANativeWindow* window; 3619} VkAndroidSurfaceCreateInfoKHR; 3620 3621 3622typedef VkResult (VKAPI_PTR *PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); 3623 3624#ifndef VK_NO_PROTOTYPES 3625VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR( 3626 VkInstance instance, 3627 const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, 3628 const VkAllocationCallbacks* pAllocator, 3629 VkSurfaceKHR* pSurface); 3630#endif 3631#endif /* VK_USE_PLATFORM_ANDROID_KHR */ 3632 3633#ifdef VK_USE_PLATFORM_WIN32_KHR 3634#define VK_KHR_win32_surface 1 3635#include <windows.h> 3636 3637#define VK_KHR_WIN32_SURFACE_SPEC_VERSION 5 3638#define VK_KHR_WIN32_SURFACE_EXTENSION_NAME "VK_KHR_win32_surface" 3639 3640typedef VkFlags VkWin32SurfaceCreateFlagsKHR; 3641 3642typedef struct VkWin32SurfaceCreateInfoKHR { 3643 VkStructureType sType; 3644 const void* pNext; 3645 VkWin32SurfaceCreateFlagsKHR flags; 3646 HINSTANCE hinstance; 3647 HWND hwnd; 3648} VkWin32SurfaceCreateInfoKHR; 3649 3650 3651typedef VkResult (VKAPI_PTR *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); 3652typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex); 3653 3654#ifndef VK_NO_PROTOTYPES 3655VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR( 3656 VkInstance instance, 3657 const VkWin32SurfaceCreateInfoKHR* pCreateInfo, 3658 const VkAllocationCallbacks* pAllocator, 3659 VkSurfaceKHR* pSurface); 3660 3661VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR( 3662 VkPhysicalDevice physicalDevice, 3663 uint32_t queueFamilyIndex); 3664#endif 3665#endif /* VK_USE_PLATFORM_WIN32_KHR */ 3666 3667#ifdef __cplusplus 3668} 3669#endif 3670 3671#endif 3672