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