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