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