vulkan.h revision 606a54e194a5884c628130ba2eda1b3bfbc157d7
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, 179, 0) 45 46 47#if defined(__cplusplus) && ((defined(_MSC_VER) && _MSC_VER >= 1800) || __cplusplus >= 201103L) 48 #define VK_NULL_HANDLE nullptr 49#else 50 #define VK_NULL_HANDLE 0 51#endif 52 53 54#define VK_DEFINE_HANDLE(obj) typedef struct obj##_T* obj; 55 56 57#if defined(__cplusplus) 58 #if ((defined(_MSC_VER) && _MSC_VER >= 1800) || __cplusplus >= 201103L) 59 // The bool operator only works if there are no implicit conversions from an obj to 60 // a bool-compatible type, which can then be used to unintentionally violate type safety. 61 // C++11 and above supports the "explicit" keyword on conversion operators to stop this 62 // from happening. Otherwise users of C++ below C++11 won't get direct access to evaluating 63 // the object handle as a bool in expressions like: 64 // if (obj) vkDestroy(obj); 65 #define VK_NONDISP_HANDLE_OPERATOR_BOOL() explicit operator bool() const { return handle != 0; } 66 #define VK_NONDISP_HANDLE_CONSTRUCTOR_FROM_UINT64(obj) \ 67 explicit obj(uint64_t x) : handle(x) { } \ 68 obj(decltype(nullptr)) : handle(0) { } 69 #else 70 #define VK_NONDISP_HANDLE_OPERATOR_BOOL() 71 #define VK_NONDISP_HANDLE_CONSTRUCTOR_FROM_UINT64(obj) \ 72 obj(uint64_t x) : handle(x) { } 73 #endif 74 #define VK_DEFINE_NONDISP_HANDLE(obj) \ 75 struct obj { \ 76 obj() : handle(0) { } \ 77 VK_NONDISP_HANDLE_CONSTRUCTOR_FROM_UINT64(obj) \ 78 obj& operator =(uint64_t x) { handle = x; return *this; } \ 79 bool operator==(const obj& other) const { return handle == other.handle; } \ 80 bool operator!=(const obj& other) const { return handle != other.handle; } \ 81 bool operator!() const { return !handle; } \ 82 VK_NONDISP_HANDLE_OPERATOR_BOOL() \ 83 uint64_t handle; \ 84 }; 85#else 86 #define VK_DEFINE_NONDISP_HANDLE(obj) typedef struct obj##_T { uint64_t handle; } obj; 87#endif 88 89 90 91typedef uint32_t VkBool32; 92typedef uint32_t VkFlags; 93typedef uint64_t VkDeviceSize; 94typedef uint32_t VkSampleMask; 95 96VK_DEFINE_HANDLE(VkInstance) 97VK_DEFINE_HANDLE(VkPhysicalDevice) 98VK_DEFINE_HANDLE(VkDevice) 99VK_DEFINE_HANDLE(VkQueue) 100VK_DEFINE_HANDLE(VkCmdBuffer) 101VK_DEFINE_NONDISP_HANDLE(VkFence) 102VK_DEFINE_NONDISP_HANDLE(VkDeviceMemory) 103VK_DEFINE_NONDISP_HANDLE(VkBuffer) 104VK_DEFINE_NONDISP_HANDLE(VkImage) 105VK_DEFINE_NONDISP_HANDLE(VkSemaphore) 106VK_DEFINE_NONDISP_HANDLE(VkEvent) 107VK_DEFINE_NONDISP_HANDLE(VkQueryPool) 108VK_DEFINE_NONDISP_HANDLE(VkBufferView) 109VK_DEFINE_NONDISP_HANDLE(VkImageView) 110VK_DEFINE_NONDISP_HANDLE(VkShaderModule) 111VK_DEFINE_NONDISP_HANDLE(VkShader) 112VK_DEFINE_NONDISP_HANDLE(VkPipelineCache) 113VK_DEFINE_NONDISP_HANDLE(VkPipelineLayout) 114VK_DEFINE_NONDISP_HANDLE(VkRenderPass) 115VK_DEFINE_NONDISP_HANDLE(VkPipeline) 116VK_DEFINE_NONDISP_HANDLE(VkDescriptorSetLayout) 117VK_DEFINE_NONDISP_HANDLE(VkSampler) 118VK_DEFINE_NONDISP_HANDLE(VkDescriptorPool) 119VK_DEFINE_NONDISP_HANDLE(VkDescriptorSet) 120VK_DEFINE_NONDISP_HANDLE(VkFramebuffer) 121VK_DEFINE_NONDISP_HANDLE(VkCmdPool) 122 123#define VK_LOD_CLAMP_NONE 1000.0f 124#define VK_REMAINING_MIP_LEVELS (~0U) 125#define VK_REMAINING_ARRAY_LAYERS (~0U) 126#define VK_WHOLE_SIZE (~0ULL) 127#define VK_ATTACHMENT_UNUSED (~0U) 128#define VK_TRUE 1 129#define VK_FALSE 0 130#define VK_QUEUE_FAMILY_IGNORED (~0U) 131#define VK_SUBPASS_EXTERNAL (~0U) 132#define VK_MAX_PHYSICAL_DEVICE_NAME 256 133#define VK_UUID_LENGTH 16 134#define VK_MAX_MEMORY_TYPES 32 135#define VK_MAX_MEMORY_HEAPS 16 136#define VK_MAX_EXTENSION_NAME 256 137#define VK_MAX_DESCRIPTION 256 138 139 140typedef enum { 141 VK_SUCCESS = 0, 142 VK_UNSUPPORTED = 1, 143 VK_NOT_READY = 2, 144 VK_TIMEOUT = 3, 145 VK_EVENT_SET = 4, 146 VK_EVENT_RESET = 5, 147 VK_INCOMPLETE = 6, 148 VK_ERROR_OUT_OF_HOST_MEMORY = -1, 149 VK_ERROR_OUT_OF_DEVICE_MEMORY = -2, 150 VK_ERROR_INITIALIZATION_FAILED = -3, 151 VK_ERROR_DEVICE_LOST = -4, 152 VK_ERROR_MEMORY_MAP_FAILED = -5, 153 VK_ERROR_LAYER_NOT_PRESENT = -6, 154 VK_ERROR_EXTENSION_NOT_PRESENT = -7, 155 VK_ERROR_FEATURE_NOT_PRESENT = -8, 156 VK_ERROR_INCOMPATIBLE_DRIVER = -9, 157 VK_RESULT_BEGIN_RANGE = VK_ERROR_INCOMPATIBLE_DRIVER, 158 VK_RESULT_END_RANGE = VK_INCOMPLETE, 159 VK_RESULT_NUM = (VK_INCOMPLETE - VK_ERROR_INCOMPATIBLE_DRIVER + 1), 160 VK_RESULT_MAX_ENUM = 0x7FFFFFFF 161} VkResult; 162 163typedef enum { 164 VK_STRUCTURE_TYPE_APPLICATION_INFO = 0, 165 VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 1, 166 VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO = 2, 167 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 3, 168 VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 4, 169 VK_STRUCTURE_TYPE_SHADER_CREATE_INFO = 5, 170 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 6, 171 VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 7, 172 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 8, 173 VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO = 9, 174 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10, 175 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 11, 176 VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 12, 177 VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 13, 178 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 14, 179 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 15, 180 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 16, 181 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 17, 182 VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 18, 183 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 19, 184 VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO = 20, 185 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 21, 186 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 22, 187 VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 23, 188 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 24, 189 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 25, 190 VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 26, 191 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 27, 192 VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO = 28, 193 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 29, 194 VK_STRUCTURE_TYPE_MEMORY_BARRIER = 30, 195 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 31, 196 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 32, 197 VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33, 198 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 34, 199 VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 35, 200 VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 36, 201 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 37, 202 VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 38, 203 VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 39, 204 VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION = 40, 205 VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION = 41, 206 VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY = 42, 207 VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43, 208 VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO = 44, 209 VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 45, 210 VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 46, 211 VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO, 212 VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, 213 VK_STRUCTURE_TYPE_NUM = (VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1), 214 VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF 215} VkStructureType; 216 217typedef enum { 218 VK_SYSTEM_ALLOC_TYPE_API_OBJECT = 0, 219 VK_SYSTEM_ALLOC_TYPE_INTERNAL = 1, 220 VK_SYSTEM_ALLOC_TYPE_INTERNAL_TEMP = 2, 221 VK_SYSTEM_ALLOC_TYPE_INTERNAL_SHADER = 3, 222 VK_SYSTEM_ALLOC_TYPE_DEBUG = 4, 223 VK_SYSTEM_ALLOC_TYPE_BEGIN_RANGE = VK_SYSTEM_ALLOC_TYPE_API_OBJECT, 224 VK_SYSTEM_ALLOC_TYPE_END_RANGE = VK_SYSTEM_ALLOC_TYPE_DEBUG, 225 VK_SYSTEM_ALLOC_TYPE_NUM = (VK_SYSTEM_ALLOC_TYPE_DEBUG - VK_SYSTEM_ALLOC_TYPE_API_OBJECT + 1), 226 VK_SYSTEM_ALLOC_TYPE_MAX_ENUM = 0x7FFFFFFF 227} VkSystemAllocType; 228 229typedef enum { 230 VK_FORMAT_UNDEFINED = 0, 231 VK_FORMAT_R4G4_UNORM = 1, 232 VK_FORMAT_R4G4_USCALED = 2, 233 VK_FORMAT_R4G4B4A4_UNORM = 3, 234 VK_FORMAT_R4G4B4A4_USCALED = 4, 235 VK_FORMAT_R5G6B5_UNORM = 5, 236 VK_FORMAT_R5G6B5_USCALED = 6, 237 VK_FORMAT_R5G5B5A1_UNORM = 7, 238 VK_FORMAT_R5G5B5A1_USCALED = 8, 239 VK_FORMAT_R8_UNORM = 9, 240 VK_FORMAT_R8_SNORM = 10, 241 VK_FORMAT_R8_USCALED = 11, 242 VK_FORMAT_R8_SSCALED = 12, 243 VK_FORMAT_R8_UINT = 13, 244 VK_FORMAT_R8_SINT = 14, 245 VK_FORMAT_R8_SRGB = 15, 246 VK_FORMAT_R8G8_UNORM = 16, 247 VK_FORMAT_R8G8_SNORM = 17, 248 VK_FORMAT_R8G8_USCALED = 18, 249 VK_FORMAT_R8G8_SSCALED = 19, 250 VK_FORMAT_R8G8_UINT = 20, 251 VK_FORMAT_R8G8_SINT = 21, 252 VK_FORMAT_R8G8_SRGB = 22, 253 VK_FORMAT_R8G8B8_UNORM = 23, 254 VK_FORMAT_R8G8B8_SNORM = 24, 255 VK_FORMAT_R8G8B8_USCALED = 25, 256 VK_FORMAT_R8G8B8_SSCALED = 26, 257 VK_FORMAT_R8G8B8_UINT = 27, 258 VK_FORMAT_R8G8B8_SINT = 28, 259 VK_FORMAT_R8G8B8_SRGB = 29, 260 VK_FORMAT_R8G8B8A8_UNORM = 30, 261 VK_FORMAT_R8G8B8A8_SNORM = 31, 262 VK_FORMAT_R8G8B8A8_USCALED = 32, 263 VK_FORMAT_R8G8B8A8_SSCALED = 33, 264 VK_FORMAT_R8G8B8A8_UINT = 34, 265 VK_FORMAT_R8G8B8A8_SINT = 35, 266 VK_FORMAT_R8G8B8A8_SRGB = 36, 267 VK_FORMAT_R10G10B10A2_UNORM = 37, 268 VK_FORMAT_R10G10B10A2_SNORM = 38, 269 VK_FORMAT_R10G10B10A2_USCALED = 39, 270 VK_FORMAT_R10G10B10A2_SSCALED = 40, 271 VK_FORMAT_R10G10B10A2_UINT = 41, 272 VK_FORMAT_R10G10B10A2_SINT = 42, 273 VK_FORMAT_R16_UNORM = 43, 274 VK_FORMAT_R16_SNORM = 44, 275 VK_FORMAT_R16_USCALED = 45, 276 VK_FORMAT_R16_SSCALED = 46, 277 VK_FORMAT_R16_UINT = 47, 278 VK_FORMAT_R16_SINT = 48, 279 VK_FORMAT_R16_SFLOAT = 49, 280 VK_FORMAT_R16G16_UNORM = 50, 281 VK_FORMAT_R16G16_SNORM = 51, 282 VK_FORMAT_R16G16_USCALED = 52, 283 VK_FORMAT_R16G16_SSCALED = 53, 284 VK_FORMAT_R16G16_UINT = 54, 285 VK_FORMAT_R16G16_SINT = 55, 286 VK_FORMAT_R16G16_SFLOAT = 56, 287 VK_FORMAT_R16G16B16_UNORM = 57, 288 VK_FORMAT_R16G16B16_SNORM = 58, 289 VK_FORMAT_R16G16B16_USCALED = 59, 290 VK_FORMAT_R16G16B16_SSCALED = 60, 291 VK_FORMAT_R16G16B16_UINT = 61, 292 VK_FORMAT_R16G16B16_SINT = 62, 293 VK_FORMAT_R16G16B16_SFLOAT = 63, 294 VK_FORMAT_R16G16B16A16_UNORM = 64, 295 VK_FORMAT_R16G16B16A16_SNORM = 65, 296 VK_FORMAT_R16G16B16A16_USCALED = 66, 297 VK_FORMAT_R16G16B16A16_SSCALED = 67, 298 VK_FORMAT_R16G16B16A16_UINT = 68, 299 VK_FORMAT_R16G16B16A16_SINT = 69, 300 VK_FORMAT_R16G16B16A16_SFLOAT = 70, 301 VK_FORMAT_R32_UINT = 71, 302 VK_FORMAT_R32_SINT = 72, 303 VK_FORMAT_R32_SFLOAT = 73, 304 VK_FORMAT_R32G32_UINT = 74, 305 VK_FORMAT_R32G32_SINT = 75, 306 VK_FORMAT_R32G32_SFLOAT = 76, 307 VK_FORMAT_R32G32B32_UINT = 77, 308 VK_FORMAT_R32G32B32_SINT = 78, 309 VK_FORMAT_R32G32B32_SFLOAT = 79, 310 VK_FORMAT_R32G32B32A32_UINT = 80, 311 VK_FORMAT_R32G32B32A32_SINT = 81, 312 VK_FORMAT_R32G32B32A32_SFLOAT = 82, 313 VK_FORMAT_R64_SFLOAT = 83, 314 VK_FORMAT_R64G64_SFLOAT = 84, 315 VK_FORMAT_R64G64B64_SFLOAT = 85, 316 VK_FORMAT_R64G64B64A64_SFLOAT = 86, 317 VK_FORMAT_R11G11B10_UFLOAT = 87, 318 VK_FORMAT_R9G9B9E5_UFLOAT = 88, 319 VK_FORMAT_D16_UNORM = 89, 320 VK_FORMAT_D24_UNORM_X8 = 90, 321 VK_FORMAT_D32_SFLOAT = 91, 322 VK_FORMAT_S8_UINT = 92, 323 VK_FORMAT_D16_UNORM_S8_UINT = 93, 324 VK_FORMAT_D24_UNORM_S8_UINT = 94, 325 VK_FORMAT_D32_SFLOAT_S8_UINT = 95, 326 VK_FORMAT_BC1_RGB_UNORM = 96, 327 VK_FORMAT_BC1_RGB_SRGB = 97, 328 VK_FORMAT_BC1_RGBA_UNORM = 98, 329 VK_FORMAT_BC1_RGBA_SRGB = 99, 330 VK_FORMAT_BC2_UNORM = 100, 331 VK_FORMAT_BC2_SRGB = 101, 332 VK_FORMAT_BC3_UNORM = 102, 333 VK_FORMAT_BC3_SRGB = 103, 334 VK_FORMAT_BC4_UNORM = 104, 335 VK_FORMAT_BC4_SNORM = 105, 336 VK_FORMAT_BC5_UNORM = 106, 337 VK_FORMAT_BC5_SNORM = 107, 338 VK_FORMAT_BC6H_UFLOAT = 108, 339 VK_FORMAT_BC6H_SFLOAT = 109, 340 VK_FORMAT_BC7_UNORM = 110, 341 VK_FORMAT_BC7_SRGB = 111, 342 VK_FORMAT_ETC2_R8G8B8_UNORM = 112, 343 VK_FORMAT_ETC2_R8G8B8_SRGB = 113, 344 VK_FORMAT_ETC2_R8G8B8A1_UNORM = 114, 345 VK_FORMAT_ETC2_R8G8B8A1_SRGB = 115, 346 VK_FORMAT_ETC2_R8G8B8A8_UNORM = 116, 347 VK_FORMAT_ETC2_R8G8B8A8_SRGB = 117, 348 VK_FORMAT_EAC_R11_UNORM = 118, 349 VK_FORMAT_EAC_R11_SNORM = 119, 350 VK_FORMAT_EAC_R11G11_UNORM = 120, 351 VK_FORMAT_EAC_R11G11_SNORM = 121, 352 VK_FORMAT_ASTC_4x4_UNORM = 122, 353 VK_FORMAT_ASTC_4x4_SRGB = 123, 354 VK_FORMAT_ASTC_5x4_UNORM = 124, 355 VK_FORMAT_ASTC_5x4_SRGB = 125, 356 VK_FORMAT_ASTC_5x5_UNORM = 126, 357 VK_FORMAT_ASTC_5x5_SRGB = 127, 358 VK_FORMAT_ASTC_6x5_UNORM = 128, 359 VK_FORMAT_ASTC_6x5_SRGB = 129, 360 VK_FORMAT_ASTC_6x6_UNORM = 130, 361 VK_FORMAT_ASTC_6x6_SRGB = 131, 362 VK_FORMAT_ASTC_8x5_UNORM = 132, 363 VK_FORMAT_ASTC_8x5_SRGB = 133, 364 VK_FORMAT_ASTC_8x6_UNORM = 134, 365 VK_FORMAT_ASTC_8x6_SRGB = 135, 366 VK_FORMAT_ASTC_8x8_UNORM = 136, 367 VK_FORMAT_ASTC_8x8_SRGB = 137, 368 VK_FORMAT_ASTC_10x5_UNORM = 138, 369 VK_FORMAT_ASTC_10x5_SRGB = 139, 370 VK_FORMAT_ASTC_10x6_UNORM = 140, 371 VK_FORMAT_ASTC_10x6_SRGB = 141, 372 VK_FORMAT_ASTC_10x8_UNORM = 142, 373 VK_FORMAT_ASTC_10x8_SRGB = 143, 374 VK_FORMAT_ASTC_10x10_UNORM = 144, 375 VK_FORMAT_ASTC_10x10_SRGB = 145, 376 VK_FORMAT_ASTC_12x10_UNORM = 146, 377 VK_FORMAT_ASTC_12x10_SRGB = 147, 378 VK_FORMAT_ASTC_12x12_UNORM = 148, 379 VK_FORMAT_ASTC_12x12_SRGB = 149, 380 VK_FORMAT_B4G4R4A4_UNORM = 150, 381 VK_FORMAT_B5G5R5A1_UNORM = 151, 382 VK_FORMAT_B5G6R5_UNORM = 152, 383 VK_FORMAT_B5G6R5_USCALED = 153, 384 VK_FORMAT_B8G8R8_UNORM = 154, 385 VK_FORMAT_B8G8R8_SNORM = 155, 386 VK_FORMAT_B8G8R8_USCALED = 156, 387 VK_FORMAT_B8G8R8_SSCALED = 157, 388 VK_FORMAT_B8G8R8_UINT = 158, 389 VK_FORMAT_B8G8R8_SINT = 159, 390 VK_FORMAT_B8G8R8_SRGB = 160, 391 VK_FORMAT_B8G8R8A8_UNORM = 161, 392 VK_FORMAT_B8G8R8A8_SNORM = 162, 393 VK_FORMAT_B8G8R8A8_USCALED = 163, 394 VK_FORMAT_B8G8R8A8_SSCALED = 164, 395 VK_FORMAT_B8G8R8A8_UINT = 165, 396 VK_FORMAT_B8G8R8A8_SINT = 166, 397 VK_FORMAT_B8G8R8A8_SRGB = 167, 398 VK_FORMAT_B10G10R10A2_UNORM = 168, 399 VK_FORMAT_B10G10R10A2_SNORM = 169, 400 VK_FORMAT_B10G10R10A2_USCALED = 170, 401 VK_FORMAT_B10G10R10A2_SSCALED = 171, 402 VK_FORMAT_B10G10R10A2_UINT = 172, 403 VK_FORMAT_B10G10R10A2_SINT = 173, 404 VK_FORMAT_BEGIN_RANGE = VK_FORMAT_UNDEFINED, 405 VK_FORMAT_END_RANGE = VK_FORMAT_B10G10R10A2_SINT, 406 VK_FORMAT_NUM = (VK_FORMAT_B10G10R10A2_SINT - VK_FORMAT_UNDEFINED + 1), 407 VK_FORMAT_MAX_ENUM = 0x7FFFFFFF 408} VkFormat; 409 410typedef enum { 411 VK_IMAGE_TYPE_1D = 0, 412 VK_IMAGE_TYPE_2D = 1, 413 VK_IMAGE_TYPE_3D = 2, 414 VK_IMAGE_TYPE_BEGIN_RANGE = VK_IMAGE_TYPE_1D, 415 VK_IMAGE_TYPE_END_RANGE = VK_IMAGE_TYPE_3D, 416 VK_IMAGE_TYPE_NUM = (VK_IMAGE_TYPE_3D - VK_IMAGE_TYPE_1D + 1), 417 VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF 418} VkImageType; 419 420typedef enum { 421 VK_IMAGE_TILING_LINEAR = 0, 422 VK_IMAGE_TILING_OPTIMAL = 1, 423 VK_IMAGE_TILING_BEGIN_RANGE = VK_IMAGE_TILING_LINEAR, 424 VK_IMAGE_TILING_END_RANGE = VK_IMAGE_TILING_OPTIMAL, 425 VK_IMAGE_TILING_NUM = (VK_IMAGE_TILING_OPTIMAL - VK_IMAGE_TILING_LINEAR + 1), 426 VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF 427} VkImageTiling; 428 429typedef enum { 430 VK_PHYSICAL_DEVICE_TYPE_OTHER = 0, 431 VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1, 432 VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2, 433 VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3, 434 VK_PHYSICAL_DEVICE_TYPE_CPU = 4, 435 VK_PHYSICAL_DEVICE_TYPE_BEGIN_RANGE = VK_PHYSICAL_DEVICE_TYPE_OTHER, 436 VK_PHYSICAL_DEVICE_TYPE_END_RANGE = VK_PHYSICAL_DEVICE_TYPE_CPU, 437 VK_PHYSICAL_DEVICE_TYPE_NUM = (VK_PHYSICAL_DEVICE_TYPE_CPU - VK_PHYSICAL_DEVICE_TYPE_OTHER + 1), 438 VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF 439} VkPhysicalDeviceType; 440 441typedef enum { 442 VK_IMAGE_ASPECT_COLOR = 0, 443 VK_IMAGE_ASPECT_DEPTH = 1, 444 VK_IMAGE_ASPECT_STENCIL = 2, 445 VK_IMAGE_ASPECT_METADATA = 3, 446 VK_IMAGE_ASPECT_BEGIN_RANGE = VK_IMAGE_ASPECT_COLOR, 447 VK_IMAGE_ASPECT_END_RANGE = VK_IMAGE_ASPECT_METADATA, 448 VK_IMAGE_ASPECT_NUM = (VK_IMAGE_ASPECT_METADATA - VK_IMAGE_ASPECT_COLOR + 1), 449 VK_IMAGE_ASPECT_MAX_ENUM = 0x7FFFFFFF 450} VkImageAspect; 451 452typedef enum { 453 VK_QUERY_TYPE_OCCLUSION = 0, 454 VK_QUERY_TYPE_PIPELINE_STATISTICS = 1, 455 VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION, 456 VK_QUERY_TYPE_END_RANGE = VK_QUERY_TYPE_PIPELINE_STATISTICS, 457 VK_QUERY_TYPE_NUM = (VK_QUERY_TYPE_PIPELINE_STATISTICS - VK_QUERY_TYPE_OCCLUSION + 1), 458 VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF 459} VkQueryType; 460 461typedef enum { 462 VK_SHARING_MODE_EXCLUSIVE = 0, 463 VK_SHARING_MODE_CONCURRENT = 1, 464 VK_SHARING_MODE_BEGIN_RANGE = VK_SHARING_MODE_EXCLUSIVE, 465 VK_SHARING_MODE_END_RANGE = VK_SHARING_MODE_CONCURRENT, 466 VK_SHARING_MODE_NUM = (VK_SHARING_MODE_CONCURRENT - VK_SHARING_MODE_EXCLUSIVE + 1), 467 VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF 468} VkSharingMode; 469 470typedef enum { 471 VK_IMAGE_LAYOUT_UNDEFINED = 0, 472 VK_IMAGE_LAYOUT_GENERAL = 1, 473 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2, 474 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3, 475 VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4, 476 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5, 477 VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL = 6, 478 VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL = 7, 479 VK_IMAGE_LAYOUT_PREINITIALIZED = 8, 480 VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED, 481 VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_PREINITIALIZED, 482 VK_IMAGE_LAYOUT_NUM = (VK_IMAGE_LAYOUT_PREINITIALIZED - VK_IMAGE_LAYOUT_UNDEFINED + 1), 483 VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF 484} VkImageLayout; 485 486typedef enum { 487 VK_IMAGE_VIEW_TYPE_1D = 0, 488 VK_IMAGE_VIEW_TYPE_2D = 1, 489 VK_IMAGE_VIEW_TYPE_3D = 2, 490 VK_IMAGE_VIEW_TYPE_CUBE = 3, 491 VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4, 492 VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5, 493 VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6, 494 VK_IMAGE_VIEW_TYPE_BEGIN_RANGE = VK_IMAGE_VIEW_TYPE_1D, 495 VK_IMAGE_VIEW_TYPE_END_RANGE = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, 496 VK_IMAGE_VIEW_TYPE_NUM = (VK_IMAGE_VIEW_TYPE_CUBE_ARRAY - VK_IMAGE_VIEW_TYPE_1D + 1), 497 VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF 498} VkImageViewType; 499 500typedef enum { 501 VK_CHANNEL_SWIZZLE_ZERO = 0, 502 VK_CHANNEL_SWIZZLE_ONE = 1, 503 VK_CHANNEL_SWIZZLE_R = 2, 504 VK_CHANNEL_SWIZZLE_G = 3, 505 VK_CHANNEL_SWIZZLE_B = 4, 506 VK_CHANNEL_SWIZZLE_A = 5, 507 VK_CHANNEL_SWIZZLE_BEGIN_RANGE = VK_CHANNEL_SWIZZLE_ZERO, 508 VK_CHANNEL_SWIZZLE_END_RANGE = VK_CHANNEL_SWIZZLE_A, 509 VK_CHANNEL_SWIZZLE_NUM = (VK_CHANNEL_SWIZZLE_A - VK_CHANNEL_SWIZZLE_ZERO + 1), 510 VK_CHANNEL_SWIZZLE_MAX_ENUM = 0x7FFFFFFF 511} VkChannelSwizzle; 512 513typedef enum { 514 VK_SHADER_STAGE_VERTEX = 0, 515 VK_SHADER_STAGE_TESSELLATION_CONTROL = 1, 516 VK_SHADER_STAGE_TESSELLATION_EVALUATION = 2, 517 VK_SHADER_STAGE_GEOMETRY = 3, 518 VK_SHADER_STAGE_FRAGMENT = 4, 519 VK_SHADER_STAGE_COMPUTE = 5, 520 VK_SHADER_STAGE_BEGIN_RANGE = VK_SHADER_STAGE_VERTEX, 521 VK_SHADER_STAGE_END_RANGE = VK_SHADER_STAGE_COMPUTE, 522 VK_SHADER_STAGE_NUM = (VK_SHADER_STAGE_COMPUTE - VK_SHADER_STAGE_VERTEX + 1), 523 VK_SHADER_STAGE_MAX_ENUM = 0x7FFFFFFF 524} VkShaderStage; 525 526typedef enum { 527 VK_VERTEX_INPUT_STEP_RATE_VERTEX = 0, 528 VK_VERTEX_INPUT_STEP_RATE_INSTANCE = 1, 529 VK_VERTEX_INPUT_STEP_RATE_BEGIN_RANGE = VK_VERTEX_INPUT_STEP_RATE_VERTEX, 530 VK_VERTEX_INPUT_STEP_RATE_END_RANGE = VK_VERTEX_INPUT_STEP_RATE_INSTANCE, 531 VK_VERTEX_INPUT_STEP_RATE_NUM = (VK_VERTEX_INPUT_STEP_RATE_INSTANCE - VK_VERTEX_INPUT_STEP_RATE_VERTEX + 1), 532 VK_VERTEX_INPUT_STEP_RATE_MAX_ENUM = 0x7FFFFFFF 533} VkVertexInputStepRate; 534 535typedef enum { 536 VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0, 537 VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1, 538 VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2, 539 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3, 540 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4, 541 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5, 542 VK_PRIMITIVE_TOPOLOGY_LINE_LIST_ADJ = 6, 543 VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_ADJ = 7, 544 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_ADJ = 8, 545 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_ADJ = 9, 546 VK_PRIMITIVE_TOPOLOGY_PATCH = 10, 547 VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = VK_PRIMITIVE_TOPOLOGY_POINT_LIST, 548 VK_PRIMITIVE_TOPOLOGY_END_RANGE = VK_PRIMITIVE_TOPOLOGY_PATCH, 549 VK_PRIMITIVE_TOPOLOGY_NUM = (VK_PRIMITIVE_TOPOLOGY_PATCH - VK_PRIMITIVE_TOPOLOGY_POINT_LIST + 1), 550 VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF 551} VkPrimitiveTopology; 552 553typedef enum { 554 VK_FILL_MODE_POINTS = 0, 555 VK_FILL_MODE_WIREFRAME = 1, 556 VK_FILL_MODE_SOLID = 2, 557 VK_FILL_MODE_BEGIN_RANGE = VK_FILL_MODE_POINTS, 558 VK_FILL_MODE_END_RANGE = VK_FILL_MODE_SOLID, 559 VK_FILL_MODE_NUM = (VK_FILL_MODE_SOLID - VK_FILL_MODE_POINTS + 1), 560 VK_FILL_MODE_MAX_ENUM = 0x7FFFFFFF 561} VkFillMode; 562 563typedef enum { 564 VK_CULL_MODE_NONE = 0, 565 VK_CULL_MODE_FRONT = 1, 566 VK_CULL_MODE_BACK = 2, 567 VK_CULL_MODE_FRONT_AND_BACK = 3, 568 VK_CULL_MODE_BEGIN_RANGE = VK_CULL_MODE_NONE, 569 VK_CULL_MODE_END_RANGE = VK_CULL_MODE_FRONT_AND_BACK, 570 VK_CULL_MODE_NUM = (VK_CULL_MODE_FRONT_AND_BACK - VK_CULL_MODE_NONE + 1), 571 VK_CULL_MODE_MAX_ENUM = 0x7FFFFFFF 572} VkCullMode; 573 574typedef enum { 575 VK_FRONT_FACE_CCW = 0, 576 VK_FRONT_FACE_CW = 1, 577 VK_FRONT_FACE_BEGIN_RANGE = VK_FRONT_FACE_CCW, 578 VK_FRONT_FACE_END_RANGE = VK_FRONT_FACE_CW, 579 VK_FRONT_FACE_NUM = (VK_FRONT_FACE_CW - VK_FRONT_FACE_CCW + 1), 580 VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF 581} VkFrontFace; 582 583typedef enum { 584 VK_COMPARE_OP_NEVER = 0, 585 VK_COMPARE_OP_LESS = 1, 586 VK_COMPARE_OP_EQUAL = 2, 587 VK_COMPARE_OP_LESS_EQUAL = 3, 588 VK_COMPARE_OP_GREATER = 4, 589 VK_COMPARE_OP_NOT_EQUAL = 5, 590 VK_COMPARE_OP_GREATER_EQUAL = 6, 591 VK_COMPARE_OP_ALWAYS = 7, 592 VK_COMPARE_OP_BEGIN_RANGE = VK_COMPARE_OP_NEVER, 593 VK_COMPARE_OP_END_RANGE = VK_COMPARE_OP_ALWAYS, 594 VK_COMPARE_OP_NUM = (VK_COMPARE_OP_ALWAYS - VK_COMPARE_OP_NEVER + 1), 595 VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF 596} VkCompareOp; 597 598typedef enum { 599 VK_STENCIL_OP_KEEP = 0, 600 VK_STENCIL_OP_ZERO = 1, 601 VK_STENCIL_OP_REPLACE = 2, 602 VK_STENCIL_OP_INC_CLAMP = 3, 603 VK_STENCIL_OP_DEC_CLAMP = 4, 604 VK_STENCIL_OP_INVERT = 5, 605 VK_STENCIL_OP_INC_WRAP = 6, 606 VK_STENCIL_OP_DEC_WRAP = 7, 607 VK_STENCIL_OP_BEGIN_RANGE = VK_STENCIL_OP_KEEP, 608 VK_STENCIL_OP_END_RANGE = VK_STENCIL_OP_DEC_WRAP, 609 VK_STENCIL_OP_NUM = (VK_STENCIL_OP_DEC_WRAP - VK_STENCIL_OP_KEEP + 1), 610 VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF 611} VkStencilOp; 612 613typedef enum { 614 VK_LOGIC_OP_CLEAR = 0, 615 VK_LOGIC_OP_AND = 1, 616 VK_LOGIC_OP_AND_REVERSE = 2, 617 VK_LOGIC_OP_COPY = 3, 618 VK_LOGIC_OP_AND_INVERTED = 4, 619 VK_LOGIC_OP_NOOP = 5, 620 VK_LOGIC_OP_XOR = 6, 621 VK_LOGIC_OP_OR = 7, 622 VK_LOGIC_OP_NOR = 8, 623 VK_LOGIC_OP_EQUIV = 9, 624 VK_LOGIC_OP_INVERT = 10, 625 VK_LOGIC_OP_OR_REVERSE = 11, 626 VK_LOGIC_OP_COPY_INVERTED = 12, 627 VK_LOGIC_OP_OR_INVERTED = 13, 628 VK_LOGIC_OP_NAND = 14, 629 VK_LOGIC_OP_SET = 15, 630 VK_LOGIC_OP_BEGIN_RANGE = VK_LOGIC_OP_CLEAR, 631 VK_LOGIC_OP_END_RANGE = VK_LOGIC_OP_SET, 632 VK_LOGIC_OP_NUM = (VK_LOGIC_OP_SET - VK_LOGIC_OP_CLEAR + 1), 633 VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF 634} VkLogicOp; 635 636typedef enum { 637 VK_BLEND_ZERO = 0, 638 VK_BLEND_ONE = 1, 639 VK_BLEND_SRC_COLOR = 2, 640 VK_BLEND_ONE_MINUS_SRC_COLOR = 3, 641 VK_BLEND_DEST_COLOR = 4, 642 VK_BLEND_ONE_MINUS_DEST_COLOR = 5, 643 VK_BLEND_SRC_ALPHA = 6, 644 VK_BLEND_ONE_MINUS_SRC_ALPHA = 7, 645 VK_BLEND_DEST_ALPHA = 8, 646 VK_BLEND_ONE_MINUS_DEST_ALPHA = 9, 647 VK_BLEND_CONSTANT_COLOR = 10, 648 VK_BLEND_ONE_MINUS_CONSTANT_COLOR = 11, 649 VK_BLEND_CONSTANT_ALPHA = 12, 650 VK_BLEND_ONE_MINUS_CONSTANT_ALPHA = 13, 651 VK_BLEND_SRC_ALPHA_SATURATE = 14, 652 VK_BLEND_SRC1_COLOR = 15, 653 VK_BLEND_ONE_MINUS_SRC1_COLOR = 16, 654 VK_BLEND_SRC1_ALPHA = 17, 655 VK_BLEND_ONE_MINUS_SRC1_ALPHA = 18, 656 VK_BLEND_BEGIN_RANGE = VK_BLEND_ZERO, 657 VK_BLEND_END_RANGE = VK_BLEND_ONE_MINUS_SRC1_ALPHA, 658 VK_BLEND_NUM = (VK_BLEND_ONE_MINUS_SRC1_ALPHA - VK_BLEND_ZERO + 1), 659 VK_BLEND_MAX_ENUM = 0x7FFFFFFF 660} VkBlend; 661 662typedef enum { 663 VK_BLEND_OP_ADD = 0, 664 VK_BLEND_OP_SUBTRACT = 1, 665 VK_BLEND_OP_REVERSE_SUBTRACT = 2, 666 VK_BLEND_OP_MIN = 3, 667 VK_BLEND_OP_MAX = 4, 668 VK_BLEND_OP_BEGIN_RANGE = VK_BLEND_OP_ADD, 669 VK_BLEND_OP_END_RANGE = VK_BLEND_OP_MAX, 670 VK_BLEND_OP_NUM = (VK_BLEND_OP_MAX - VK_BLEND_OP_ADD + 1), 671 VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF 672} VkBlendOp; 673 674typedef enum { 675 VK_DYNAMIC_STATE_VIEWPORT = 0, 676 VK_DYNAMIC_STATE_SCISSOR = 1, 677 VK_DYNAMIC_STATE_LINE_WIDTH = 2, 678 VK_DYNAMIC_STATE_DEPTH_BIAS = 3, 679 VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4, 680 VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5, 681 VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6, 682 VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7, 683 VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8, 684 VK_DYNAMIC_STATE_BEGIN_RANGE = VK_DYNAMIC_STATE_VIEWPORT, 685 VK_DYNAMIC_STATE_END_RANGE = VK_DYNAMIC_STATE_STENCIL_REFERENCE, 686 VK_DYNAMIC_STATE_NUM = (VK_DYNAMIC_STATE_STENCIL_REFERENCE - VK_DYNAMIC_STATE_VIEWPORT + 1), 687 VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF 688} VkDynamicState; 689 690typedef enum { 691 VK_TEX_FILTER_NEAREST = 0, 692 VK_TEX_FILTER_LINEAR = 1, 693 VK_TEX_FILTER_BEGIN_RANGE = VK_TEX_FILTER_NEAREST, 694 VK_TEX_FILTER_END_RANGE = VK_TEX_FILTER_LINEAR, 695 VK_TEX_FILTER_NUM = (VK_TEX_FILTER_LINEAR - VK_TEX_FILTER_NEAREST + 1), 696 VK_TEX_FILTER_MAX_ENUM = 0x7FFFFFFF 697} VkTexFilter; 698 699typedef enum { 700 VK_TEX_MIPMAP_MODE_BASE = 0, 701 VK_TEX_MIPMAP_MODE_NEAREST = 1, 702 VK_TEX_MIPMAP_MODE_LINEAR = 2, 703 VK_TEX_MIPMAP_MODE_BEGIN_RANGE = VK_TEX_MIPMAP_MODE_BASE, 704 VK_TEX_MIPMAP_MODE_END_RANGE = VK_TEX_MIPMAP_MODE_LINEAR, 705 VK_TEX_MIPMAP_MODE_NUM = (VK_TEX_MIPMAP_MODE_LINEAR - VK_TEX_MIPMAP_MODE_BASE + 1), 706 VK_TEX_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF 707} VkTexMipmapMode; 708 709typedef enum { 710 VK_TEX_ADDRESS_MODE_WRAP = 0, 711 VK_TEX_ADDRESS_MODE_MIRROR = 1, 712 VK_TEX_ADDRESS_MODE_CLAMP = 2, 713 VK_TEX_ADDRESS_MODE_MIRROR_ONCE = 3, 714 VK_TEX_ADDRESS_MODE_CLAMP_BORDER = 4, 715 VK_TEX_ADDRESS_MODE_BEGIN_RANGE = VK_TEX_ADDRESS_MODE_WRAP, 716 VK_TEX_ADDRESS_MODE_END_RANGE = VK_TEX_ADDRESS_MODE_CLAMP_BORDER, 717 VK_TEX_ADDRESS_MODE_NUM = (VK_TEX_ADDRESS_MODE_CLAMP_BORDER - VK_TEX_ADDRESS_MODE_WRAP + 1), 718 VK_TEX_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF 719} VkTexAddressMode; 720 721typedef enum { 722 VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0, 723 VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1, 724 VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2, 725 VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3, 726 VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4, 727 VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5, 728 VK_BORDER_COLOR_BEGIN_RANGE = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, 729 VK_BORDER_COLOR_END_RANGE = VK_BORDER_COLOR_INT_OPAQUE_WHITE, 730 VK_BORDER_COLOR_NUM = (VK_BORDER_COLOR_INT_OPAQUE_WHITE - VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK + 1), 731 VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF 732} VkBorderColor; 733 734typedef enum { 735 VK_DESCRIPTOR_TYPE_SAMPLER = 0, 736 VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1, 737 VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2, 738 VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3, 739 VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4, 740 VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5, 741 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6, 742 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7, 743 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8, 744 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9, 745 VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10, 746 VK_DESCRIPTOR_TYPE_BEGIN_RANGE = VK_DESCRIPTOR_TYPE_SAMPLER, 747 VK_DESCRIPTOR_TYPE_END_RANGE = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, 748 VK_DESCRIPTOR_TYPE_NUM = (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT - VK_DESCRIPTOR_TYPE_SAMPLER + 1), 749 VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF 750} VkDescriptorType; 751 752typedef enum { 753 VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT = 0, 754 VK_DESCRIPTOR_POOL_USAGE_DYNAMIC = 1, 755 VK_DESCRIPTOR_POOL_USAGE_BEGIN_RANGE = VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT, 756 VK_DESCRIPTOR_POOL_USAGE_END_RANGE = VK_DESCRIPTOR_POOL_USAGE_DYNAMIC, 757 VK_DESCRIPTOR_POOL_USAGE_NUM = (VK_DESCRIPTOR_POOL_USAGE_DYNAMIC - VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT + 1), 758 VK_DESCRIPTOR_POOL_USAGE_MAX_ENUM = 0x7FFFFFFF 759} VkDescriptorPoolUsage; 760 761typedef enum { 762 VK_DESCRIPTOR_SET_USAGE_ONE_SHOT = 0, 763 VK_DESCRIPTOR_SET_USAGE_STATIC = 1, 764 VK_DESCRIPTOR_SET_USAGE_BEGIN_RANGE = VK_DESCRIPTOR_SET_USAGE_ONE_SHOT, 765 VK_DESCRIPTOR_SET_USAGE_END_RANGE = VK_DESCRIPTOR_SET_USAGE_STATIC, 766 VK_DESCRIPTOR_SET_USAGE_NUM = (VK_DESCRIPTOR_SET_USAGE_STATIC - VK_DESCRIPTOR_SET_USAGE_ONE_SHOT + 1), 767 VK_DESCRIPTOR_SET_USAGE_MAX_ENUM = 0x7FFFFFFF 768} VkDescriptorSetUsage; 769 770typedef enum { 771 VK_ATTACHMENT_LOAD_OP_LOAD = 0, 772 VK_ATTACHMENT_LOAD_OP_CLEAR = 1, 773 VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2, 774 VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE = VK_ATTACHMENT_LOAD_OP_LOAD, 775 VK_ATTACHMENT_LOAD_OP_END_RANGE = VK_ATTACHMENT_LOAD_OP_DONT_CARE, 776 VK_ATTACHMENT_LOAD_OP_NUM = (VK_ATTACHMENT_LOAD_OP_DONT_CARE - VK_ATTACHMENT_LOAD_OP_LOAD + 1), 777 VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF 778} VkAttachmentLoadOp; 779 780typedef enum { 781 VK_ATTACHMENT_STORE_OP_STORE = 0, 782 VK_ATTACHMENT_STORE_OP_DONT_CARE = 1, 783 VK_ATTACHMENT_STORE_OP_BEGIN_RANGE = VK_ATTACHMENT_STORE_OP_STORE, 784 VK_ATTACHMENT_STORE_OP_END_RANGE = VK_ATTACHMENT_STORE_OP_DONT_CARE, 785 VK_ATTACHMENT_STORE_OP_NUM = (VK_ATTACHMENT_STORE_OP_DONT_CARE - VK_ATTACHMENT_STORE_OP_STORE + 1), 786 VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF 787} VkAttachmentStoreOp; 788 789typedef enum { 790 VK_PIPELINE_BIND_POINT_COMPUTE = 0, 791 VK_PIPELINE_BIND_POINT_GRAPHICS = 1, 792 VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VK_PIPELINE_BIND_POINT_COMPUTE, 793 VK_PIPELINE_BIND_POINT_END_RANGE = VK_PIPELINE_BIND_POINT_GRAPHICS, 794 VK_PIPELINE_BIND_POINT_NUM = (VK_PIPELINE_BIND_POINT_GRAPHICS - VK_PIPELINE_BIND_POINT_COMPUTE + 1), 795 VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF 796} VkPipelineBindPoint; 797 798typedef enum { 799 VK_CMD_BUFFER_LEVEL_PRIMARY = 0, 800 VK_CMD_BUFFER_LEVEL_SECONDARY = 1, 801 VK_CMD_BUFFER_LEVEL_BEGIN_RANGE = VK_CMD_BUFFER_LEVEL_PRIMARY, 802 VK_CMD_BUFFER_LEVEL_END_RANGE = VK_CMD_BUFFER_LEVEL_SECONDARY, 803 VK_CMD_BUFFER_LEVEL_NUM = (VK_CMD_BUFFER_LEVEL_SECONDARY - VK_CMD_BUFFER_LEVEL_PRIMARY + 1), 804 VK_CMD_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF 805} VkCmdBufferLevel; 806 807typedef enum { 808 VK_INDEX_TYPE_UINT16 = 0, 809 VK_INDEX_TYPE_UINT32 = 1, 810 VK_INDEX_TYPE_BEGIN_RANGE = VK_INDEX_TYPE_UINT16, 811 VK_INDEX_TYPE_END_RANGE = VK_INDEX_TYPE_UINT32, 812 VK_INDEX_TYPE_NUM = (VK_INDEX_TYPE_UINT32 - VK_INDEX_TYPE_UINT16 + 1), 813 VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF 814} VkIndexType; 815 816typedef enum { 817 VK_TIMESTAMP_TYPE_TOP = 0, 818 VK_TIMESTAMP_TYPE_BOTTOM = 1, 819 VK_TIMESTAMP_TYPE_BEGIN_RANGE = VK_TIMESTAMP_TYPE_TOP, 820 VK_TIMESTAMP_TYPE_END_RANGE = VK_TIMESTAMP_TYPE_BOTTOM, 821 VK_TIMESTAMP_TYPE_NUM = (VK_TIMESTAMP_TYPE_BOTTOM - VK_TIMESTAMP_TYPE_TOP + 1), 822 VK_TIMESTAMP_TYPE_MAX_ENUM = 0x7FFFFFFF 823} VkTimestampType; 824 825typedef enum { 826 VK_RENDER_PASS_CONTENTS_INLINE = 0, 827 VK_RENDER_PASS_CONTENTS_SECONDARY_CMD_BUFFERS = 1, 828 VK_RENDER_PASS_CONTENTS_BEGIN_RANGE = VK_RENDER_PASS_CONTENTS_INLINE, 829 VK_RENDER_PASS_CONTENTS_END_RANGE = VK_RENDER_PASS_CONTENTS_SECONDARY_CMD_BUFFERS, 830 VK_RENDER_PASS_CONTENTS_NUM = (VK_RENDER_PASS_CONTENTS_SECONDARY_CMD_BUFFERS - VK_RENDER_PASS_CONTENTS_INLINE + 1), 831 VK_RENDER_PASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF 832} VkRenderPassContents; 833 834 835typedef enum { 836 VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001, 837 VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002, 838 VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004, 839 VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008, 840 VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010, 841 VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020, 842 VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040, 843 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080, 844 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100, 845 VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200, 846 VK_FORMAT_FEATURE_BLIT_SOURCE_BIT = 0x00000400, 847 VK_FORMAT_FEATURE_BLIT_DESTINATION_BIT = 0x00000800, 848} VkFormatFeatureFlagBits; 849typedef VkFlags VkFormatFeatureFlags; 850 851typedef enum { 852 VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT = 0x00000001, 853 VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT = 0x00000002, 854 VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004, 855 VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008, 856 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010, 857 VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020, 858 VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040, 859 VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080, 860} VkImageUsageFlagBits; 861typedef VkFlags VkImageUsageFlags; 862 863typedef enum { 864 VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001, 865 VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, 866 VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004, 867 VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008, 868 VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010, 869} VkImageCreateFlagBits; 870typedef VkFlags VkImageCreateFlags; 871 872typedef enum { 873 VK_SAMPLE_COUNT_1_BIT = 0x00000001, 874 VK_SAMPLE_COUNT_2_BIT = 0x00000002, 875 VK_SAMPLE_COUNT_4_BIT = 0x00000004, 876 VK_SAMPLE_COUNT_8_BIT = 0x00000008, 877 VK_SAMPLE_COUNT_16_BIT = 0x00000010, 878 VK_SAMPLE_COUNT_32_BIT = 0x00000020, 879 VK_SAMPLE_COUNT_64_BIT = 0x00000040, 880} VkSampleCountFlagBits; 881typedef VkFlags VkSampleCountFlags; 882 883typedef enum { 884 VK_QUEUE_GRAPHICS_BIT = 0x00000001, 885 VK_QUEUE_COMPUTE_BIT = 0x00000002, 886 VK_QUEUE_DMA_BIT = 0x00000004, 887 VK_QUEUE_SPARSE_MEMMGR_BIT = 0x00000008, 888 VK_QUEUE_EXTENDED_BIT = 0x40000000, 889} VkQueueFlagBits; 890typedef VkFlags VkQueueFlags; 891 892typedef enum { 893 VK_MEMORY_PROPERTY_DEVICE_ONLY = 0, 894 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000001, 895 VK_MEMORY_PROPERTY_HOST_NON_COHERENT_BIT = 0x00000002, 896 VK_MEMORY_PROPERTY_HOST_UNCACHED_BIT = 0x00000004, 897 VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000008, 898} VkMemoryPropertyFlagBits; 899typedef VkFlags VkMemoryPropertyFlags; 900 901typedef enum { 902 VK_MEMORY_HEAP_HOST_LOCAL_BIT = 0x00000001, 903} VkMemoryHeapFlagBits; 904typedef VkFlags VkMemoryHeapFlags; 905typedef VkFlags VkMemoryMapFlags; 906 907typedef enum { 908 VK_SPARSE_IMAGE_FMT_SINGLE_MIPTAIL_BIT = 0x00000001, 909 VK_SPARSE_IMAGE_FMT_ALIGNED_MIP_SIZE_BIT = 0x00000002, 910 VK_SPARSE_IMAGE_FMT_NONSTD_BLOCK_SIZE_BIT = 0x00000004, 911} VkSparseImageFormatFlagBits; 912typedef VkFlags VkSparseImageFormatFlags; 913 914typedef enum { 915 VK_SPARSE_MEMORY_BIND_REPLICATE_64KIB_BLOCK_BIT = 0x00000001, 916} VkSparseMemoryBindFlagBits; 917typedef VkFlags VkSparseMemoryBindFlags; 918 919typedef enum { 920 VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001, 921} VkFenceCreateFlagBits; 922typedef VkFlags VkFenceCreateFlags; 923typedef VkFlags VkSemaphoreCreateFlags; 924typedef VkFlags VkEventCreateFlags; 925 926typedef enum { 927 VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001, 928 VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002, 929 VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004, 930 VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008, 931 VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0x00000010, 932 VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0x00000020, 933 VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0x00000040, 934 VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0x00000080, 935 VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x00000100, 936 VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0x00000200, 937 VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400, 938} VkQueryPipelineStatisticFlagBits; 939typedef VkFlags VkQueryPipelineStatisticFlags; 940 941typedef enum { 942 VK_QUERY_RESULT_DEFAULT = 0, 943 VK_QUERY_RESULT_64_BIT = 0x00000001, 944 VK_QUERY_RESULT_WAIT_BIT = 0x00000002, 945 VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004, 946 VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008, 947} VkQueryResultFlagBits; 948typedef VkFlags VkQueryResultFlags; 949 950typedef enum { 951 VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT = 0x00000001, 952 VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT = 0x00000002, 953 VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004, 954 VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008, 955 VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010, 956 VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020, 957 VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040, 958 VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080, 959 VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100, 960} VkBufferUsageFlagBits; 961typedef VkFlags VkBufferUsageFlags; 962 963typedef enum { 964 VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001, 965 VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, 966 VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004, 967} VkBufferCreateFlagBits; 968typedef VkFlags VkBufferCreateFlags; 969 970typedef enum { 971 VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001, 972 VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002, 973 VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004, 974 VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008, 975} VkImageAspectFlagBits; 976typedef VkFlags VkImageAspectFlags; 977 978typedef enum { 979 VK_IMAGE_VIEW_CREATE_READ_ONLY_DEPTH_BIT = 0x00000001, 980 VK_IMAGE_VIEW_CREATE_READ_ONLY_STENCIL_BIT = 0x00000002, 981} VkImageViewCreateFlagBits; 982typedef VkFlags VkImageViewCreateFlags; 983typedef VkFlags VkShaderModuleCreateFlags; 984typedef VkFlags VkShaderCreateFlags; 985 986typedef enum { 987 VK_CHANNEL_R_BIT = 0x00000001, 988 VK_CHANNEL_G_BIT = 0x00000002, 989 VK_CHANNEL_B_BIT = 0x00000004, 990 VK_CHANNEL_A_BIT = 0x00000008, 991} VkChannelFlagBits; 992typedef VkFlags VkChannelFlags; 993 994typedef enum { 995 VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001, 996 VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002, 997 VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004, 998} VkPipelineCreateFlagBits; 999typedef VkFlags VkPipelineCreateFlags; 1000 1001typedef enum { 1002 VK_SHADER_STAGE_VERTEX_BIT = 0x00000001, 1003 VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002, 1004 VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004, 1005 VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008, 1006 VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010, 1007 VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020, 1008 VK_SHADER_STAGE_ALL = 0x7FFFFFFF, 1009} VkShaderStageFlagBits; 1010typedef VkFlags VkShaderStageFlags; 1011 1012typedef enum { 1013 VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001, 1014} VkAttachmentDescriptionFlagBits; 1015typedef VkFlags VkAttachmentDescriptionFlags; 1016typedef VkFlags VkSubpassDescriptionFlags; 1017 1018typedef enum { 1019 VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001, 1020 VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002, 1021 VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004, 1022 VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008, 1023 VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010, 1024 VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020, 1025 VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040, 1026 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080, 1027 VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100, 1028 VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200, 1029 VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400, 1030 VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800, 1031 VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000, 1032 VK_PIPELINE_STAGE_HOST_BIT = 0x00002000, 1033 VK_PIPELINE_STAGE_ALL_GRAPHICS = 0x000007FF, 1034 VK_PIPELINE_STAGE_ALL_GPU_COMMANDS = 0x00001FFF, 1035} VkPipelineStageFlagBits; 1036typedef VkFlags VkPipelineStageFlags; 1037 1038typedef enum { 1039 VK_MEMORY_OUTPUT_HOST_WRITE_BIT = 0x00000001, 1040 VK_MEMORY_OUTPUT_SHADER_WRITE_BIT = 0x00000002, 1041 VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT = 0x00000004, 1042 VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000008, 1043 VK_MEMORY_OUTPUT_TRANSFER_BIT = 0x00000010, 1044} VkMemoryOutputFlagBits; 1045typedef VkFlags VkMemoryOutputFlags; 1046 1047typedef enum { 1048 VK_MEMORY_INPUT_HOST_READ_BIT = 0x00000001, 1049 VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT = 0x00000002, 1050 VK_MEMORY_INPUT_INDEX_FETCH_BIT = 0x00000004, 1051 VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT = 0x00000008, 1052 VK_MEMORY_INPUT_UNIFORM_READ_BIT = 0x00000010, 1053 VK_MEMORY_INPUT_SHADER_READ_BIT = 0x00000020, 1054 VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT = 0x00000040, 1055 VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000080, 1056 VK_MEMORY_INPUT_INPUT_ATTACHMENT_BIT = 0x00000100, 1057 VK_MEMORY_INPUT_TRANSFER_BIT = 0x00000200, 1058} VkMemoryInputFlagBits; 1059typedef VkFlags VkMemoryInputFlags; 1060 1061typedef enum { 1062 VK_CMD_POOL_CREATE_TRANSIENT_BIT = 0x00000001, 1063 VK_CMD_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002, 1064} VkCmdPoolCreateFlagBits; 1065typedef VkFlags VkCmdPoolCreateFlags; 1066 1067typedef enum { 1068 VK_CMD_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001, 1069} VkCmdPoolResetFlagBits; 1070typedef VkFlags VkCmdPoolResetFlags; 1071typedef VkFlags VkCmdBufferCreateFlags; 1072 1073typedef enum { 1074 VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT = 0x00000001, 1075 VK_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT = 0x00000002, 1076 VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT = 0x00000004, 1077 VK_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT = 0x00000008, 1078 VK_CMD_BUFFER_OPTIMIZE_NO_SIMULTANEOUS_USE_BIT = 0x00000010, 1079} VkCmdBufferOptimizeFlagBits; 1080typedef VkFlags VkCmdBufferOptimizeFlags; 1081 1082typedef enum { 1083 VK_CMD_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001, 1084} VkCmdBufferResetFlagBits; 1085typedef VkFlags VkCmdBufferResetFlags; 1086 1087typedef enum { 1088 VK_STENCIL_FACE_NONE = 0, 1089 VK_STENCIL_FACE_FRONT_BIT = 0x00000001, 1090 VK_STENCIL_FACE_BACK_BIT = 0x00000002, 1091} VkStencilFaceFlagBits; 1092typedef VkFlags VkStencilFaceFlags; 1093 1094typedef enum { 1095 VK_QUERY_CONTROL_CONSERVATIVE_BIT = 0x00000001, 1096} VkQueryControlFlagBits; 1097typedef VkFlags VkQueryControlFlags; 1098 1099typedef void* (VKAPI *PFN_vkAllocFunction)( 1100 void* pUserData, 1101 size_t size, 1102 size_t alignment, 1103 VkSystemAllocType allocType); 1104 1105typedef void (VKAPI *PFN_vkFreeFunction)( 1106 void* pUserData, 1107 void* pMem); 1108 1109typedef void (VKAPI *PFN_vkVoidFunction)(void); 1110 1111typedef struct { 1112 VkStructureType sType; 1113 const void* pNext; 1114 const char* pAppName; 1115 uint32_t appVersion; 1116 const char* pEngineName; 1117 uint32_t engineVersion; 1118 uint32_t apiVersion; 1119} VkApplicationInfo; 1120 1121typedef struct { 1122 void* pUserData; 1123 PFN_vkAllocFunction pfnAlloc; 1124 PFN_vkFreeFunction pfnFree; 1125} VkAllocCallbacks; 1126 1127typedef struct { 1128 VkStructureType sType; 1129 const void* pNext; 1130 const VkApplicationInfo* pAppInfo; 1131 const VkAllocCallbacks* pAllocCb; 1132 uint32_t layerCount; 1133 const char*const* ppEnabledLayerNames; 1134 uint32_t extensionCount; 1135 const char*const* ppEnabledExtensionNames; 1136} VkInstanceCreateInfo; 1137 1138typedef struct { 1139 VkBool32 robustBufferAccess; 1140 VkBool32 fullDrawIndexUint32; 1141 VkBool32 imageCubeArray; 1142 VkBool32 independentBlend; 1143 VkBool32 geometryShader; 1144 VkBool32 tessellationShader; 1145 VkBool32 sampleRateShading; 1146 VkBool32 dualSourceBlend; 1147 VkBool32 logicOp; 1148 VkBool32 multiDrawIndirect; 1149 VkBool32 depthClamp; 1150 VkBool32 depthBiasClamp; 1151 VkBool32 fillModeNonSolid; 1152 VkBool32 depthBounds; 1153 VkBool32 wideLines; 1154 VkBool32 largePoints; 1155 VkBool32 textureCompressionETC2; 1156 VkBool32 textureCompressionASTC_LDR; 1157 VkBool32 textureCompressionBC; 1158 VkBool32 occlusionQueryNonConservative; 1159 VkBool32 pipelineStatisticsQuery; 1160 VkBool32 vertexSideEffects; 1161 VkBool32 tessellationSideEffects; 1162 VkBool32 geometrySideEffects; 1163 VkBool32 fragmentSideEffects; 1164 VkBool32 shaderTessellationPointSize; 1165 VkBool32 shaderGeometryPointSize; 1166 VkBool32 shaderImageGatherExtended; 1167 VkBool32 shaderStorageImageExtendedFormats; 1168 VkBool32 shaderStorageImageMultisample; 1169 VkBool32 shaderUniformBufferArrayDynamicIndexing; 1170 VkBool32 shaderSampledImageArrayDynamicIndexing; 1171 VkBool32 shaderStorageBufferArrayDynamicIndexing; 1172 VkBool32 shaderStorageImageArrayDynamicIndexing; 1173 VkBool32 shaderClipDistance; 1174 VkBool32 shaderCullDistance; 1175 VkBool32 shaderFloat64; 1176 VkBool32 shaderInt64; 1177 VkBool32 shaderInt16; 1178 VkBool32 shaderResourceResidency; 1179 VkBool32 shaderResourceMinLOD; 1180 VkBool32 alphaToOne; 1181 VkBool32 sparseBinding; 1182 VkBool32 sparseResidencyBuffer; 1183 VkBool32 sparseResidencyImage2D; 1184 VkBool32 sparseResidencyImage3D; 1185 VkBool32 sparseResidency2Samples; 1186 VkBool32 sparseResidency4Samples; 1187 VkBool32 sparseResidency8Samples; 1188 VkBool32 sparseResidency16Samples; 1189 VkBool32 sparseResidencyAliased; 1190} VkPhysicalDeviceFeatures; 1191 1192typedef struct { 1193 VkFormatFeatureFlags linearTilingFeatures; 1194 VkFormatFeatureFlags optimalTilingFeatures; 1195 VkFormatFeatureFlags bufferFeatures; 1196} VkFormatProperties; 1197 1198typedef struct { 1199 int32_t width; 1200 int32_t height; 1201 int32_t depth; 1202} VkExtent3D; 1203 1204typedef struct { 1205 VkExtent3D maxExtent; 1206 uint32_t maxMipLevels; 1207 uint32_t maxArraySize; 1208 VkSampleCountFlags sampleCounts; 1209 VkDeviceSize maxResourceSize; 1210} VkImageFormatProperties; 1211 1212typedef struct { 1213 uint32_t maxImageDimension1D; 1214 uint32_t maxImageDimension2D; 1215 uint32_t maxImageDimension3D; 1216 uint32_t maxImageDimensionCube; 1217 uint32_t maxImageArrayLayers; 1218 VkSampleCountFlags sampleCounts; 1219 uint32_t maxTexelBufferSize; 1220 uint32_t maxUniformBufferSize; 1221 uint32_t maxStorageBufferSize; 1222 uint32_t maxPushConstantsSize; 1223 uint32_t maxMemoryAllocationCount; 1224 VkDeviceSize bufferImageGranularity; 1225 VkDeviceSize sparseAddressSpaceSize; 1226 uint32_t maxBoundDescriptorSets; 1227 uint32_t maxDescriptorSets; 1228 uint32_t maxPerStageDescriptorSamplers; 1229 uint32_t maxPerStageDescriptorUniformBuffers; 1230 uint32_t maxPerStageDescriptorStorageBuffers; 1231 uint32_t maxPerStageDescriptorSampledImages; 1232 uint32_t maxPerStageDescriptorStorageImages; 1233 uint32_t maxDescriptorSetSamplers; 1234 uint32_t maxDescriptorSetUniformBuffers; 1235 uint32_t maxDescriptorSetUniformBuffersDynamic; 1236 uint32_t maxDescriptorSetStorageBuffers; 1237 uint32_t maxDescriptorSetStorageBuffersDynamic; 1238 uint32_t maxDescriptorSetSampledImages; 1239 uint32_t maxDescriptorSetStorageImages; 1240 uint32_t maxVertexInputAttributes; 1241 uint32_t maxVertexInputBindings; 1242 uint32_t maxVertexInputAttributeOffset; 1243 uint32_t maxVertexInputBindingStride; 1244 uint32_t maxVertexOutputComponents; 1245 uint32_t maxTessellationGenLevel; 1246 uint32_t maxTessellationPatchSize; 1247 uint32_t maxTessellationControlPerVertexInputComponents; 1248 uint32_t maxTessellationControlPerVertexOutputComponents; 1249 uint32_t maxTessellationControlPerPatchOutputComponents; 1250 uint32_t maxTessellationControlTotalOutputComponents; 1251 uint32_t maxTessellationEvaluationInputComponents; 1252 uint32_t maxTessellationEvaluationOutputComponents; 1253 uint32_t maxGeometryShaderInvocations; 1254 uint32_t maxGeometryInputComponents; 1255 uint32_t maxGeometryOutputComponents; 1256 uint32_t maxGeometryOutputVertices; 1257 uint32_t maxGeometryTotalOutputComponents; 1258 uint32_t maxFragmentInputComponents; 1259 uint32_t maxFragmentOutputBuffers; 1260 uint32_t maxFragmentDualSourceBuffers; 1261 uint32_t maxFragmentCombinedOutputResources; 1262 uint32_t maxComputeSharedMemorySize; 1263 uint32_t maxComputeWorkGroupCount[3]; 1264 uint32_t maxComputeWorkGroupInvocations; 1265 uint32_t maxComputeWorkGroupSize[3]; 1266 uint32_t subPixelPrecisionBits; 1267 uint32_t subTexelPrecisionBits; 1268 uint32_t mipmapPrecisionBits; 1269 uint32_t maxDrawIndexedIndexValue; 1270 uint32_t maxDrawIndirectInstanceCount; 1271 VkBool32 primitiveRestartForPatches; 1272 float maxSamplerLodBias; 1273 float maxSamplerAnisotropy; 1274 uint32_t maxViewports; 1275 uint32_t maxViewportDimensions[2]; 1276 float viewportBoundsRange[2]; 1277 uint32_t viewportSubPixelBits; 1278 uint32_t minMemoryMapAlignment; 1279 uint32_t minTexelBufferOffsetAlignment; 1280 uint32_t minUniformBufferOffsetAlignment; 1281 uint32_t minStorageBufferOffsetAlignment; 1282 uint32_t minTexelOffset; 1283 uint32_t maxTexelOffset; 1284 uint32_t minTexelGatherOffset; 1285 uint32_t maxTexelGatherOffset; 1286 float minInterpolationOffset; 1287 float maxInterpolationOffset; 1288 uint32_t subPixelInterpolationOffsetBits; 1289 uint32_t maxFramebufferWidth; 1290 uint32_t maxFramebufferHeight; 1291 uint32_t maxFramebufferLayers; 1292 uint32_t maxFramebufferColorSamples; 1293 uint32_t maxFramebufferDepthSamples; 1294 uint32_t maxFramebufferStencilSamples; 1295 uint32_t maxColorAttachments; 1296 uint32_t maxSampledImageColorSamples; 1297 uint32_t maxSampledImageDepthSamples; 1298 uint32_t maxSampledImageIntegerSamples; 1299 uint32_t maxStorageImageSamples; 1300 uint32_t maxSampleMaskWords; 1301 uint64_t timestampFrequency; 1302 uint32_t maxClipDistances; 1303 uint32_t maxCullDistances; 1304 uint32_t maxCombinedClipAndCullDistances; 1305 float pointSizeRange[2]; 1306 float lineWidthRange[2]; 1307 float pointSizeGranularity; 1308 float lineWidthGranularity; 1309} VkPhysicalDeviceLimits; 1310 1311typedef struct { 1312 VkBool32 residencyStandard2DBlockShape; 1313 VkBool32 residencyStandard2DMSBlockShape; 1314 VkBool32 residencyStandard3DBlockShape; 1315 VkBool32 residencyAlignedMipSize; 1316 VkBool32 residencyNonResident; 1317 VkBool32 residencyNonResidentStrict; 1318} VkPhysicalDeviceSparseProperties; 1319 1320typedef struct { 1321 uint32_t apiVersion; 1322 uint32_t driverVersion; 1323 uint32_t vendorId; 1324 uint32_t deviceId; 1325 VkPhysicalDeviceType deviceType; 1326 char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME]; 1327 uint8_t pipelineCacheUUID[VK_UUID_LENGTH]; 1328 VkPhysicalDeviceLimits limits; 1329 VkPhysicalDeviceSparseProperties sparseProperties; 1330} VkPhysicalDeviceProperties; 1331 1332typedef struct { 1333 VkQueueFlags queueFlags; 1334 uint32_t queueCount; 1335 uint32_t timestampValidBits; 1336} VkQueueFamilyProperties; 1337 1338typedef struct { 1339 VkMemoryPropertyFlags propertyFlags; 1340 uint32_t heapIndex; 1341} VkMemoryType; 1342 1343typedef struct { 1344 VkDeviceSize size; 1345 VkMemoryHeapFlags flags; 1346} VkMemoryHeap; 1347 1348typedef struct { 1349 uint32_t memoryTypeCount; 1350 VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES]; 1351 uint32_t memoryHeapCount; 1352 VkMemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS]; 1353} VkPhysicalDeviceMemoryProperties; 1354 1355typedef struct { 1356 VkStructureType sType; 1357 const void* pNext; 1358 uint32_t queueFamilyIndex; 1359 uint32_t queueCount; 1360} VkDeviceQueueCreateInfo; 1361 1362typedef struct { 1363 VkStructureType sType; 1364 const void* pNext; 1365 uint32_t requestedQueueCount; 1366 const VkDeviceQueueCreateInfo* pRequestedQueues; 1367 uint32_t layerCount; 1368 const char*const* ppEnabledLayerNames; 1369 uint32_t extensionCount; 1370 const char*const* ppEnabledExtensionNames; 1371 const VkPhysicalDeviceFeatures* pEnabledFeatures; 1372} VkDeviceCreateInfo; 1373 1374typedef struct { 1375 char extName[VK_MAX_EXTENSION_NAME]; 1376 uint32_t specVersion; 1377} VkExtensionProperties; 1378 1379typedef struct { 1380 char layerName[VK_MAX_EXTENSION_NAME]; 1381 uint32_t specVersion; 1382 uint32_t implVersion; 1383 char description[VK_MAX_DESCRIPTION]; 1384} VkLayerProperties; 1385 1386typedef struct { 1387 VkStructureType sType; 1388 const void* pNext; 1389 VkDeviceSize allocationSize; 1390 uint32_t memoryTypeIndex; 1391} VkMemoryAllocInfo; 1392 1393typedef struct { 1394 VkStructureType sType; 1395 const void* pNext; 1396 VkDeviceMemory mem; 1397 VkDeviceSize offset; 1398 VkDeviceSize size; 1399} VkMappedMemoryRange; 1400 1401typedef struct { 1402 VkDeviceSize size; 1403 VkDeviceSize alignment; 1404 uint32_t memoryTypeBits; 1405} VkMemoryRequirements; 1406 1407typedef struct { 1408 VkImageAspect aspect; 1409 VkExtent3D imageGranularity; 1410 VkSparseImageFormatFlags flags; 1411} VkSparseImageFormatProperties; 1412 1413typedef struct { 1414 VkSparseImageFormatProperties formatProps; 1415 uint32_t imageMipTailStartLOD; 1416 VkDeviceSize imageMipTailSize; 1417 VkDeviceSize imageMipTailOffset; 1418 VkDeviceSize imageMipTailStride; 1419} VkSparseImageMemoryRequirements; 1420 1421typedef struct { 1422 VkDeviceSize rangeOffset; 1423 VkDeviceSize rangeSize; 1424 VkDeviceSize memOffset; 1425 VkDeviceMemory mem; 1426 VkSparseMemoryBindFlags flags; 1427} VkSparseMemoryBindInfo; 1428 1429typedef struct { 1430 VkImageAspect aspect; 1431 uint32_t mipLevel; 1432 uint32_t arrayLayer; 1433} VkImageSubresource; 1434 1435typedef struct { 1436 int32_t x; 1437 int32_t y; 1438 int32_t z; 1439} VkOffset3D; 1440 1441typedef struct { 1442 VkImageSubresource subresource; 1443 VkOffset3D offset; 1444 VkExtent3D extent; 1445 VkDeviceSize memOffset; 1446 VkDeviceMemory mem; 1447 VkSparseMemoryBindFlags flags; 1448} VkSparseImageMemoryBindInfo; 1449 1450typedef struct { 1451 VkStructureType sType; 1452 const void* pNext; 1453 VkFenceCreateFlags flags; 1454} VkFenceCreateInfo; 1455 1456typedef struct { 1457 VkStructureType sType; 1458 const void* pNext; 1459 VkSemaphoreCreateFlags flags; 1460} VkSemaphoreCreateInfo; 1461 1462typedef struct { 1463 VkStructureType sType; 1464 const void* pNext; 1465 VkEventCreateFlags flags; 1466} VkEventCreateInfo; 1467 1468typedef struct { 1469 VkStructureType sType; 1470 const void* pNext; 1471 VkQueryType queryType; 1472 uint32_t slots; 1473 VkQueryPipelineStatisticFlags pipelineStatistics; 1474} VkQueryPoolCreateInfo; 1475 1476typedef struct { 1477 VkStructureType sType; 1478 const void* pNext; 1479 VkDeviceSize size; 1480 VkBufferUsageFlags usage; 1481 VkBufferCreateFlags flags; 1482 VkSharingMode sharingMode; 1483 uint32_t queueFamilyCount; 1484 const uint32_t* pQueueFamilyIndices; 1485} VkBufferCreateInfo; 1486 1487typedef struct { 1488 VkStructureType sType; 1489 const void* pNext; 1490 VkBuffer buffer; 1491 VkFormat format; 1492 VkDeviceSize offset; 1493 VkDeviceSize range; 1494} VkBufferViewCreateInfo; 1495 1496typedef struct { 1497 VkStructureType sType; 1498 const void* pNext; 1499 VkImageType imageType; 1500 VkFormat format; 1501 VkExtent3D extent; 1502 uint32_t mipLevels; 1503 uint32_t arraySize; 1504 uint32_t samples; 1505 VkImageTiling tiling; 1506 VkImageUsageFlags usage; 1507 VkImageCreateFlags flags; 1508 VkSharingMode sharingMode; 1509 uint32_t queueFamilyCount; 1510 const uint32_t* pQueueFamilyIndices; 1511 VkImageLayout initialLayout; 1512} VkImageCreateInfo; 1513 1514typedef struct { 1515 VkDeviceSize offset; 1516 VkDeviceSize size; 1517 VkDeviceSize rowPitch; 1518 VkDeviceSize depthPitch; 1519} VkSubresourceLayout; 1520 1521typedef struct { 1522 VkChannelSwizzle r; 1523 VkChannelSwizzle g; 1524 VkChannelSwizzle b; 1525 VkChannelSwizzle a; 1526} VkChannelMapping; 1527 1528typedef struct { 1529 VkImageAspectFlags aspectMask; 1530 uint32_t baseMipLevel; 1531 uint32_t mipLevels; 1532 uint32_t baseArrayLayer; 1533 uint32_t arraySize; 1534} VkImageSubresourceRange; 1535 1536typedef struct { 1537 VkStructureType sType; 1538 const void* pNext; 1539 VkImage image; 1540 VkImageViewType viewType; 1541 VkFormat format; 1542 VkChannelMapping channels; 1543 VkImageSubresourceRange subresourceRange; 1544 VkImageViewCreateFlags flags; 1545} VkImageViewCreateInfo; 1546 1547typedef struct { 1548 VkStructureType sType; 1549 const void* pNext; 1550 size_t codeSize; 1551 const void* pCode; 1552 VkShaderModuleCreateFlags flags; 1553} VkShaderModuleCreateInfo; 1554 1555typedef struct { 1556 VkStructureType sType; 1557 const void* pNext; 1558 VkShaderModule module; 1559 const char* pName; 1560 VkShaderCreateFlags flags; 1561 VkShaderStage stage; 1562} VkShaderCreateInfo; 1563 1564typedef struct { 1565 VkStructureType sType; 1566 const void* pNext; 1567 size_t initialSize; 1568 const void* initialData; 1569 size_t maxSize; 1570} VkPipelineCacheCreateInfo; 1571 1572typedef struct { 1573 uint32_t constantId; 1574 size_t size; 1575 uint32_t offset; 1576} VkSpecializationMapEntry; 1577 1578typedef struct { 1579 uint32_t mapEntryCount; 1580 const VkSpecializationMapEntry* pMap; 1581 size_t dataSize; 1582 const void* pData; 1583} VkSpecializationInfo; 1584 1585typedef struct { 1586 VkStructureType sType; 1587 const void* pNext; 1588 VkShaderStage stage; 1589 VkShader shader; 1590 const VkSpecializationInfo* pSpecializationInfo; 1591} VkPipelineShaderStageCreateInfo; 1592 1593typedef struct { 1594 uint32_t binding; 1595 uint32_t strideInBytes; 1596 VkVertexInputStepRate stepRate; 1597} VkVertexInputBindingDescription; 1598 1599typedef struct { 1600 uint32_t location; 1601 uint32_t binding; 1602 VkFormat format; 1603 uint32_t offsetInBytes; 1604} VkVertexInputAttributeDescription; 1605 1606typedef struct { 1607 VkStructureType sType; 1608 const void* pNext; 1609 uint32_t bindingCount; 1610 const VkVertexInputBindingDescription* pVertexBindingDescriptions; 1611 uint32_t attributeCount; 1612 const VkVertexInputAttributeDescription* pVertexAttributeDescriptions; 1613} VkPipelineVertexInputStateCreateInfo; 1614 1615typedef struct { 1616 VkStructureType sType; 1617 const void* pNext; 1618 VkPrimitiveTopology topology; 1619 VkBool32 primitiveRestartEnable; 1620} VkPipelineInputAssemblyStateCreateInfo; 1621 1622typedef struct { 1623 VkStructureType sType; 1624 const void* pNext; 1625 uint32_t patchControlPoints; 1626} VkPipelineTessellationStateCreateInfo; 1627 1628typedef struct { 1629 float originX; 1630 float originY; 1631 float width; 1632 float height; 1633 float minDepth; 1634 float maxDepth; 1635} VkViewport; 1636 1637typedef struct { 1638 int32_t x; 1639 int32_t y; 1640} VkOffset2D; 1641 1642typedef struct { 1643 int32_t width; 1644 int32_t height; 1645} VkExtent2D; 1646 1647typedef struct { 1648 VkOffset2D offset; 1649 VkExtent2D extent; 1650} VkRect2D; 1651 1652typedef struct { 1653 VkStructureType sType; 1654 const void* pNext; 1655 uint32_t viewportCount; 1656 const VkViewport* pViewports; 1657 uint32_t scissorCount; 1658 const VkRect2D* pScissors; 1659} VkPipelineViewportStateCreateInfo; 1660 1661typedef struct { 1662 VkStructureType sType; 1663 const void* pNext; 1664 VkBool32 depthClampEnable; 1665 VkBool32 rasterizerDiscardEnable; 1666 VkFillMode fillMode; 1667 VkCullMode cullMode; 1668 VkFrontFace frontFace; 1669 VkBool32 depthBiasEnable; 1670 float depthBias; 1671 float depthBiasClamp; 1672 float slopeScaledDepthBias; 1673 float lineWidth; 1674} VkPipelineRasterStateCreateInfo; 1675 1676typedef struct { 1677 VkStructureType sType; 1678 const void* pNext; 1679 uint32_t rasterSamples; 1680 VkBool32 sampleShadingEnable; 1681 float minSampleShading; 1682 const VkSampleMask* pSampleMask; 1683 VkBool32 alphaToCoverageEnable; 1684 VkBool32 alphaToOneEnable; 1685} VkPipelineMultisampleStateCreateInfo; 1686 1687typedef struct { 1688 VkStencilOp stencilFailOp; 1689 VkStencilOp stencilPassOp; 1690 VkStencilOp stencilDepthFailOp; 1691 VkCompareOp stencilCompareOp; 1692 uint32_t stencilCompareMask; 1693 uint32_t stencilWriteMask; 1694 uint32_t stencilReference; 1695} VkStencilOpState; 1696 1697typedef struct { 1698 VkStructureType sType; 1699 const void* pNext; 1700 VkBool32 depthTestEnable; 1701 VkBool32 depthWriteEnable; 1702 VkCompareOp depthCompareOp; 1703 VkBool32 depthBoundsTestEnable; 1704 VkBool32 stencilTestEnable; 1705 VkStencilOpState front; 1706 VkStencilOpState back; 1707 float minDepthBounds; 1708 float maxDepthBounds; 1709} VkPipelineDepthStencilStateCreateInfo; 1710 1711typedef struct { 1712 VkBool32 blendEnable; 1713 VkBlend srcBlendColor; 1714 VkBlend destBlendColor; 1715 VkBlendOp blendOpColor; 1716 VkBlend srcBlendAlpha; 1717 VkBlend destBlendAlpha; 1718 VkBlendOp blendOpAlpha; 1719 VkChannelFlags channelWriteMask; 1720} VkPipelineColorBlendAttachmentState; 1721 1722typedef struct { 1723 VkStructureType sType; 1724 const void* pNext; 1725 VkBool32 logicOpEnable; 1726 VkLogicOp logicOp; 1727 uint32_t attachmentCount; 1728 const VkPipelineColorBlendAttachmentState* pAttachments; 1729 float blendConst[4]; 1730} VkPipelineColorBlendStateCreateInfo; 1731 1732typedef struct { 1733 VkStructureType sType; 1734 const void* pNext; 1735 uint32_t dynamicStateCount; 1736 const VkDynamicState* pDynamicStates; 1737} VkPipelineDynamicStateCreateInfo; 1738 1739typedef struct { 1740 VkStructureType sType; 1741 const void* pNext; 1742 uint32_t stageCount; 1743 const VkPipelineShaderStageCreateInfo* pStages; 1744 const VkPipelineVertexInputStateCreateInfo* pVertexInputState; 1745 const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState; 1746 const VkPipelineTessellationStateCreateInfo* pTessellationState; 1747 const VkPipelineViewportStateCreateInfo* pViewportState; 1748 const VkPipelineRasterStateCreateInfo* pRasterState; 1749 const VkPipelineMultisampleStateCreateInfo* pMultisampleState; 1750 const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState; 1751 const VkPipelineColorBlendStateCreateInfo* pColorBlendState; 1752 const VkPipelineDynamicStateCreateInfo* pDynamicState; 1753 VkPipelineCreateFlags flags; 1754 VkPipelineLayout layout; 1755 VkRenderPass renderPass; 1756 uint32_t subpass; 1757 VkPipeline basePipelineHandle; 1758 int32_t basePipelineIndex; 1759} VkGraphicsPipelineCreateInfo; 1760 1761typedef struct { 1762 VkStructureType sType; 1763 const void* pNext; 1764 VkPipelineShaderStageCreateInfo stage; 1765 VkPipelineCreateFlags flags; 1766 VkPipelineLayout layout; 1767 VkPipeline basePipelineHandle; 1768 int32_t basePipelineIndex; 1769} VkComputePipelineCreateInfo; 1770 1771typedef struct { 1772 VkShaderStageFlags stageFlags; 1773 uint32_t start; 1774 uint32_t length; 1775} VkPushConstantRange; 1776 1777typedef struct { 1778 VkStructureType sType; 1779 const void* pNext; 1780 uint32_t descriptorSetCount; 1781 const VkDescriptorSetLayout* pSetLayouts; 1782 uint32_t pushConstantRangeCount; 1783 const VkPushConstantRange* pPushConstantRanges; 1784} VkPipelineLayoutCreateInfo; 1785 1786typedef struct { 1787 VkStructureType sType; 1788 const void* pNext; 1789 VkTexFilter magFilter; 1790 VkTexFilter minFilter; 1791 VkTexMipmapMode mipMode; 1792 VkTexAddressMode addressModeU; 1793 VkTexAddressMode addressModeV; 1794 VkTexAddressMode addressModeW; 1795 float mipLodBias; 1796 float maxAnisotropy; 1797 VkBool32 compareEnable; 1798 VkCompareOp compareOp; 1799 float minLod; 1800 float maxLod; 1801 VkBorderColor borderColor; 1802 VkBool32 unnormalizedCoordinates; 1803} VkSamplerCreateInfo; 1804 1805typedef struct { 1806 VkDescriptorType descriptorType; 1807 uint32_t arraySize; 1808 VkShaderStageFlags stageFlags; 1809 const VkSampler* pImmutableSamplers; 1810} VkDescriptorSetLayoutBinding; 1811 1812typedef struct { 1813 VkStructureType sType; 1814 const void* pNext; 1815 uint32_t count; 1816 const VkDescriptorSetLayoutBinding* pBinding; 1817} VkDescriptorSetLayoutCreateInfo; 1818 1819typedef struct { 1820 VkDescriptorType type; 1821 uint32_t count; 1822} VkDescriptorTypeCount; 1823 1824typedef struct { 1825 VkStructureType sType; 1826 const void* pNext; 1827 VkDescriptorPoolUsage poolUsage; 1828 uint32_t maxSets; 1829 uint32_t count; 1830 const VkDescriptorTypeCount* pTypeCount; 1831} VkDescriptorPoolCreateInfo; 1832 1833typedef struct { 1834 VkBuffer buffer; 1835 VkDeviceSize offset; 1836 VkDeviceSize range; 1837} VkDescriptorBufferInfo; 1838 1839typedef struct { 1840 VkBufferView bufferView; 1841 VkSampler sampler; 1842 VkImageView imageView; 1843 VkImageLayout imageLayout; 1844 VkDescriptorBufferInfo bufferInfo; 1845} VkDescriptorInfo; 1846 1847typedef struct { 1848 VkStructureType sType; 1849 const void* pNext; 1850 VkDescriptorSet destSet; 1851 uint32_t destBinding; 1852 uint32_t destArrayElement; 1853 uint32_t count; 1854 VkDescriptorType descriptorType; 1855 const VkDescriptorInfo* pDescriptors; 1856} VkWriteDescriptorSet; 1857 1858typedef struct { 1859 VkStructureType sType; 1860 const void* pNext; 1861 VkDescriptorSet srcSet; 1862 uint32_t srcBinding; 1863 uint32_t srcArrayElement; 1864 VkDescriptorSet destSet; 1865 uint32_t destBinding; 1866 uint32_t destArrayElement; 1867 uint32_t count; 1868} VkCopyDescriptorSet; 1869 1870typedef struct { 1871 VkStructureType sType; 1872 const void* pNext; 1873 VkRenderPass renderPass; 1874 uint32_t attachmentCount; 1875 const VkImageView* pAttachments; 1876 uint32_t width; 1877 uint32_t height; 1878 uint32_t layers; 1879} VkFramebufferCreateInfo; 1880 1881typedef struct { 1882 VkStructureType sType; 1883 const void* pNext; 1884 VkFormat format; 1885 uint32_t samples; 1886 VkAttachmentLoadOp loadOp; 1887 VkAttachmentStoreOp storeOp; 1888 VkAttachmentLoadOp stencilLoadOp; 1889 VkAttachmentStoreOp stencilStoreOp; 1890 VkImageLayout initialLayout; 1891 VkImageLayout finalLayout; 1892 VkAttachmentDescriptionFlags flags; 1893} VkAttachmentDescription; 1894 1895typedef struct { 1896 uint32_t attachment; 1897 VkImageLayout layout; 1898} VkAttachmentReference; 1899 1900typedef struct { 1901 VkStructureType sType; 1902 const void* pNext; 1903 VkPipelineBindPoint pipelineBindPoint; 1904 VkSubpassDescriptionFlags flags; 1905 uint32_t inputCount; 1906 const VkAttachmentReference* pInputAttachments; 1907 uint32_t colorCount; 1908 const VkAttachmentReference* pColorAttachments; 1909 const VkAttachmentReference* pResolveAttachments; 1910 VkAttachmentReference depthStencilAttachment; 1911 uint32_t preserveCount; 1912 const VkAttachmentReference* pPreserveAttachments; 1913} VkSubpassDescription; 1914 1915typedef struct { 1916 VkStructureType sType; 1917 const void* pNext; 1918 uint32_t srcSubpass; 1919 uint32_t destSubpass; 1920 VkPipelineStageFlags srcStageMask; 1921 VkPipelineStageFlags destStageMask; 1922 VkMemoryOutputFlags outputMask; 1923 VkMemoryInputFlags inputMask; 1924 VkBool32 byRegion; 1925} VkSubpassDependency; 1926 1927typedef struct { 1928 VkStructureType sType; 1929 const void* pNext; 1930 uint32_t attachmentCount; 1931 const VkAttachmentDescription* pAttachments; 1932 uint32_t subpassCount; 1933 const VkSubpassDescription* pSubpasses; 1934 uint32_t dependencyCount; 1935 const VkSubpassDependency* pDependencies; 1936} VkRenderPassCreateInfo; 1937 1938typedef struct { 1939 VkStructureType sType; 1940 const void* pNext; 1941 uint32_t queueFamilyIndex; 1942 VkCmdPoolCreateFlags flags; 1943} VkCmdPoolCreateInfo; 1944 1945typedef struct { 1946 VkStructureType sType; 1947 const void* pNext; 1948 VkCmdPool cmdPool; 1949 VkCmdBufferLevel level; 1950 VkCmdBufferCreateFlags flags; 1951} VkCmdBufferCreateInfo; 1952 1953typedef struct { 1954 VkStructureType sType; 1955 const void* pNext; 1956 VkCmdBufferOptimizeFlags flags; 1957 VkRenderPass renderPass; 1958 uint32_t subpass; 1959 VkFramebuffer framebuffer; 1960} VkCmdBufferBeginInfo; 1961 1962typedef struct { 1963 VkDeviceSize srcOffset; 1964 VkDeviceSize destOffset; 1965 VkDeviceSize copySize; 1966} VkBufferCopy; 1967 1968typedef struct { 1969 VkImageAspect aspect; 1970 uint32_t mipLevel; 1971 uint32_t arrayLayer; 1972 uint32_t arraySize; 1973} VkImageSubresourceCopy; 1974 1975typedef struct { 1976 VkImageSubresourceCopy srcSubresource; 1977 VkOffset3D srcOffset; 1978 VkImageSubresourceCopy destSubresource; 1979 VkOffset3D destOffset; 1980 VkExtent3D extent; 1981} VkImageCopy; 1982 1983typedef struct { 1984 VkImageSubresourceCopy srcSubresource; 1985 VkOffset3D srcOffset; 1986 VkExtent3D srcExtent; 1987 VkImageSubresourceCopy destSubresource; 1988 VkOffset3D destOffset; 1989 VkExtent3D destExtent; 1990} VkImageBlit; 1991 1992typedef struct { 1993 VkDeviceSize bufferOffset; 1994 uint32_t bufferRowLength; 1995 uint32_t bufferImageHeight; 1996 VkImageSubresourceCopy imageSubresource; 1997 VkOffset3D imageOffset; 1998 VkExtent3D imageExtent; 1999} VkBufferImageCopy; 2000 2001typedef union { 2002 float float32[4]; 2003 int32_t int32[4]; 2004 uint32_t uint32[4]; 2005} VkClearColorValue; 2006 2007typedef struct { 2008 float depth; 2009 uint32_t stencil; 2010} VkClearDepthStencilValue; 2011 2012typedef union { 2013 VkClearColorValue color; 2014 VkClearDepthStencilValue depthStencil; 2015} VkClearValue; 2016 2017typedef struct { 2018 VkImageAspectFlags aspectMask; 2019 uint32_t colorAttachment; 2020 VkClearValue clearValue; 2021} VkClearAttachment; 2022 2023typedef struct { 2024 VkOffset3D offset; 2025 VkExtent3D extent; 2026} VkRect3D; 2027 2028typedef struct { 2029 VkImageSubresourceCopy srcSubresource; 2030 VkOffset3D srcOffset; 2031 VkImageSubresourceCopy destSubresource; 2032 VkOffset3D destOffset; 2033 VkExtent3D extent; 2034} VkImageResolve; 2035 2036typedef struct { 2037 VkStructureType sType; 2038 const void* pNext; 2039 VkRenderPass renderPass; 2040 VkFramebuffer framebuffer; 2041 VkRect2D renderArea; 2042 uint32_t clearValueCount; 2043 const VkClearValue* pClearValues; 2044} VkRenderPassBeginInfo; 2045 2046typedef struct { 2047 VkStructureType sType; 2048 const void* pNext; 2049 VkMemoryOutputFlags outputMask; 2050 VkMemoryInputFlags inputMask; 2051 uint32_t srcQueueFamilyIndex; 2052 uint32_t destQueueFamilyIndex; 2053 VkBuffer buffer; 2054 VkDeviceSize offset; 2055 VkDeviceSize size; 2056} VkBufferMemoryBarrier; 2057 2058typedef struct { 2059 uint32_t x; 2060 uint32_t y; 2061 uint32_t z; 2062} VkDispatchIndirectCmd; 2063 2064typedef struct { 2065 uint32_t indexCount; 2066 uint32_t instanceCount; 2067 uint32_t firstIndex; 2068 int32_t vertexOffset; 2069 uint32_t firstInstance; 2070} VkDrawIndexedIndirectCmd; 2071 2072typedef struct { 2073 uint32_t vertexCount; 2074 uint32_t instanceCount; 2075 uint32_t firstVertex; 2076 uint32_t firstInstance; 2077} VkDrawIndirectCmd; 2078 2079typedef struct { 2080 VkStructureType sType; 2081 const void* pNext; 2082 VkMemoryOutputFlags outputMask; 2083 VkMemoryInputFlags inputMask; 2084 VkImageLayout oldLayout; 2085 VkImageLayout newLayout; 2086 uint32_t srcQueueFamilyIndex; 2087 uint32_t destQueueFamilyIndex; 2088 VkImage image; 2089 VkImageSubresourceRange subresourceRange; 2090} VkImageMemoryBarrier; 2091 2092typedef struct { 2093 VkStructureType sType; 2094 const void* pNext; 2095 VkMemoryOutputFlags outputMask; 2096 VkMemoryInputFlags inputMask; 2097} VkMemoryBarrier; 2098 2099 2100typedef VkResult (VKAPI *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance); 2101typedef void (VKAPI *PFN_vkDestroyInstance)(VkInstance instance); 2102typedef VkResult (VKAPI *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); 2103typedef void (VKAPI *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures); 2104typedef void (VKAPI *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties); 2105typedef void (VKAPI *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties); 2106typedef void (VKAPI *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties); 2107typedef void (VKAPI *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkQueueFamilyProperties* pQueueFamilyProperties); 2108typedef void (VKAPI *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties); 2109typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName); 2110typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName); 2111typedef VkResult (VKAPI *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice); 2112typedef void (VKAPI *PFN_vkDestroyDevice)(VkDevice device); 2113typedef VkResult (VKAPI *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties); 2114typedef VkResult (VKAPI *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties); 2115typedef VkResult (VKAPI *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pCount, VkLayerProperties* pProperties); 2116typedef VkResult (VKAPI *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkLayerProperties* pProperties); 2117typedef void (VKAPI *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue); 2118typedef VkResult (VKAPI *PFN_vkQueueSubmit)(VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence); 2119typedef VkResult (VKAPI *PFN_vkQueueWaitIdle)(VkQueue queue); 2120typedef VkResult (VKAPI *PFN_vkDeviceWaitIdle)(VkDevice device); 2121typedef VkResult (VKAPI *PFN_vkAllocMemory)(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem); 2122typedef void (VKAPI *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory mem); 2123typedef VkResult (VKAPI *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData); 2124typedef void (VKAPI *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory mem); 2125typedef VkResult (VKAPI *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges); 2126typedef VkResult (VKAPI *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges); 2127typedef void (VKAPI *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes); 2128typedef VkResult (VKAPI *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memOffset); 2129typedef VkResult (VKAPI *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memOffset); 2130typedef void (VKAPI *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements); 2131typedef void (VKAPI *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements); 2132typedef void (VKAPI *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements); 2133typedef void (VKAPI *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties); 2134typedef VkResult (VKAPI *PFN_vkQueueBindSparseBufferMemory)(VkQueue queue, VkBuffer buffer, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo); 2135typedef VkResult (VKAPI *PFN_vkQueueBindSparseImageOpaqueMemory)(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo); 2136typedef VkResult (VKAPI *PFN_vkQueueBindSparseImageMemory)(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseImageMemoryBindInfo* pBindInfo); 2137typedef VkResult (VKAPI *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence); 2138typedef void (VKAPI *PFN_vkDestroyFence)(VkDevice device, VkFence fence); 2139typedef VkResult (VKAPI *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences); 2140typedef VkResult (VKAPI *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence); 2141typedef VkResult (VKAPI *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout); 2142typedef VkResult (VKAPI *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore); 2143typedef void (VKAPI *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore); 2144typedef VkResult (VKAPI *PFN_vkQueueSignalSemaphore)(VkQueue queue, VkSemaphore semaphore); 2145typedef VkResult (VKAPI *PFN_vkQueueWaitSemaphore)(VkQueue queue, VkSemaphore semaphore); 2146typedef VkResult (VKAPI *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent); 2147typedef void (VKAPI *PFN_vkDestroyEvent)(VkDevice device, VkEvent event); 2148typedef VkResult (VKAPI *PFN_vkGetEventStatus)(VkDevice device, VkEvent event); 2149typedef VkResult (VKAPI *PFN_vkSetEvent)(VkDevice device, VkEvent event); 2150typedef VkResult (VKAPI *PFN_vkResetEvent)(VkDevice device, VkEvent event); 2151typedef VkResult (VKAPI *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool); 2152typedef void (VKAPI *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool); 2153typedef VkResult (VKAPI *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData, VkQueryResultFlags flags); 2154typedef VkResult (VKAPI *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer); 2155typedef void (VKAPI *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer); 2156typedef VkResult (VKAPI *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView); 2157typedef void (VKAPI *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView); 2158typedef VkResult (VKAPI *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage); 2159typedef void (VKAPI *PFN_vkDestroyImage)(VkDevice device, VkImage image); 2160typedef void (VKAPI *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout); 2161typedef VkResult (VKAPI *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView); 2162typedef void (VKAPI *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView); 2163typedef VkResult (VKAPI *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShaderModule); 2164typedef void (VKAPI *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule); 2165typedef VkResult (VKAPI *PFN_vkCreateShader)(VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader); 2166typedef void (VKAPI *PFN_vkDestroyShader)(VkDevice device, VkShader shader); 2167typedef VkResult (VKAPI *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache); 2168typedef void (VKAPI *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache); 2169typedef size_t (VKAPI *PFN_vkGetPipelineCacheSize)(VkDevice device, VkPipelineCache pipelineCache); 2170typedef VkResult (VKAPI *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t dataSize, void* pData); 2171typedef VkResult (VKAPI *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches); 2172typedef VkResult (VKAPI *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines); 2173typedef VkResult (VKAPI *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines); 2174typedef void (VKAPI *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline); 2175typedef VkResult (VKAPI *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout); 2176typedef void (VKAPI *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout); 2177typedef VkResult (VKAPI *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler); 2178typedef void (VKAPI *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler); 2179typedef VkResult (VKAPI *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout); 2180typedef void (VKAPI *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout); 2181typedef VkResult (VKAPI *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool); 2182typedef void (VKAPI *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool); 2183typedef VkResult (VKAPI *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool); 2184typedef VkResult (VKAPI *PFN_vkAllocDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets); 2185typedef VkResult (VKAPI *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets); 2186typedef void (VKAPI *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies); 2187typedef VkResult (VKAPI *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer); 2188typedef void (VKAPI *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer); 2189typedef VkResult (VKAPI *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass); 2190typedef void (VKAPI *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass); 2191typedef void (VKAPI *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity); 2192typedef VkResult (VKAPI *PFN_vkCreateCommandPool)(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, VkCmdPool* pCmdPool); 2193typedef void (VKAPI *PFN_vkDestroyCommandPool)(VkDevice device, VkCmdPool cmdPool); 2194typedef VkResult (VKAPI *PFN_vkResetCommandPool)(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags); 2195typedef VkResult (VKAPI *PFN_vkCreateCommandBuffer)(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer); 2196typedef void (VKAPI *PFN_vkDestroyCommandBuffer)(VkDevice device, VkCmdBuffer commandBuffer); 2197typedef VkResult (VKAPI *PFN_vkBeginCommandBuffer)(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo); 2198typedef VkResult (VKAPI *PFN_vkEndCommandBuffer)(VkCmdBuffer cmdBuffer); 2199typedef VkResult (VKAPI *PFN_vkResetCommandBuffer)(VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags); 2200typedef void (VKAPI *PFN_vkCmdBindPipeline)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); 2201typedef void (VKAPI *PFN_vkCmdSetViewport)(VkCmdBuffer cmdBuffer, uint32_t viewportCount, const VkViewport* pViewports); 2202typedef void (VKAPI *PFN_vkCmdSetScissor)(VkCmdBuffer cmdBuffer, uint32_t scissorCount, const VkRect2D* pScissors); 2203typedef void (VKAPI *PFN_vkCmdSetLineWidth)(VkCmdBuffer cmdBuffer, float lineWidth); 2204typedef void (VKAPI *PFN_vkCmdSetDepthBias)(VkCmdBuffer cmdBuffer, float depthBias, float depthBiasClamp, float slopeScaledDepthBias); 2205typedef void (VKAPI *PFN_vkCmdSetBlendConstants)(VkCmdBuffer cmdBuffer, const float blendConst[4]); 2206typedef void (VKAPI *PFN_vkCmdSetDepthBounds)(VkCmdBuffer cmdBuffer, float minDepthBounds, float maxDepthBounds); 2207typedef void (VKAPI *PFN_vkCmdSetStencilCompareMask)(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask); 2208typedef void (VKAPI *PFN_vkCmdSetStencilWriteMask)(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask); 2209typedef void (VKAPI *PFN_vkCmdSetStencilReference)(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference); 2210typedef void (VKAPI *PFN_vkCmdBindDescriptorSets)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets); 2211typedef void (VKAPI *PFN_vkCmdBindIndexBuffer)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); 2212typedef void (VKAPI *PFN_vkCmdBindVertexBuffers)(VkCmdBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets); 2213typedef void (VKAPI *PFN_vkCmdDraw)(VkCmdBuffer cmdBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance); 2214typedef void (VKAPI *PFN_vkCmdDrawIndexed)(VkCmdBuffer cmdBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance); 2215typedef void (VKAPI *PFN_vkCmdDrawIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride); 2216typedef void (VKAPI *PFN_vkCmdDrawIndexedIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride); 2217typedef void (VKAPI *PFN_vkCmdDispatch)(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z); 2218typedef void (VKAPI *PFN_vkCmdDispatchIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset); 2219typedef void (VKAPI *PFN_vkCmdCopyBuffer)(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions); 2220typedef void (VKAPI *PFN_vkCmdCopyImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions); 2221typedef void (VKAPI *PFN_vkCmdBlitImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkTexFilter filter); 2222typedef void (VKAPI *PFN_vkCmdCopyBufferToImage)(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions); 2223typedef void (VKAPI *PFN_vkCmdCopyImageToBuffer)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions); 2224typedef void (VKAPI *PFN_vkCmdUpdateBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData); 2225typedef void (VKAPI *PFN_vkCmdFillBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data); 2226typedef void (VKAPI *PFN_vkCmdClearColorImage)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); 2227typedef void (VKAPI *PFN_vkCmdClearDepthStencilImage)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); 2228typedef void (VKAPI *PFN_vkCmdClearAttachments)(VkCmdBuffer cmdBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkRect3D* pRects); 2229typedef void (VKAPI *PFN_vkCmdResolveImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions); 2230typedef void (VKAPI *PFN_vkCmdSetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask); 2231typedef void (VKAPI *PFN_vkCmdResetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask); 2232typedef void (VKAPI *PFN_vkCmdWaitEvents)(VkCmdBuffer cmdBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, uint32_t memBarrierCount, const void* const* ppMemBarriers); 2233typedef void (VKAPI *PFN_vkCmdPipelineBarrier)(VkCmdBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkBool32 byRegion, uint32_t memBarrierCount, const void* const* ppMemBarriers); 2234typedef void (VKAPI *PFN_vkCmdBeginQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags); 2235typedef void (VKAPI *PFN_vkCmdEndQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot); 2236typedef void (VKAPI *PFN_vkCmdResetQueryPool)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount); 2237typedef void (VKAPI *PFN_vkCmdWriteTimestamp)(VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkDeviceSize destOffset); 2238typedef void (VKAPI *PFN_vkCmdCopyQueryPoolResults)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags); 2239typedef void (VKAPI *PFN_vkCmdPushConstants)(VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t start, uint32_t length, const void* values); 2240typedef void (VKAPI *PFN_vkCmdBeginRenderPass)(VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents); 2241typedef void (VKAPI *PFN_vkCmdNextSubpass)(VkCmdBuffer cmdBuffer, VkRenderPassContents contents); 2242typedef void (VKAPI *PFN_vkCmdEndRenderPass)(VkCmdBuffer cmdBuffer); 2243typedef void (VKAPI *PFN_vkCmdExecuteCommands)(VkCmdBuffer cmdBuffer, uint32_t cmdBuffersCount, const VkCmdBuffer* pCmdBuffers); 2244 2245#ifdef VK_PROTOTYPES 2246VkResult VKAPI vkCreateInstance( 2247 const VkInstanceCreateInfo* pCreateInfo, 2248 VkInstance* pInstance); 2249 2250void VKAPI vkDestroyInstance( 2251 VkInstance instance); 2252 2253VkResult VKAPI vkEnumeratePhysicalDevices( 2254 VkInstance instance, 2255 uint32_t* pPhysicalDeviceCount, 2256 VkPhysicalDevice* pPhysicalDevices); 2257 2258void VKAPI vkGetPhysicalDeviceFeatures( 2259 VkPhysicalDevice physicalDevice, 2260 VkPhysicalDeviceFeatures* pFeatures); 2261 2262void VKAPI vkGetPhysicalDeviceFormatProperties( 2263 VkPhysicalDevice physicalDevice, 2264 VkFormat format, 2265 VkFormatProperties* pFormatProperties); 2266 2267void VKAPI vkGetPhysicalDeviceImageFormatProperties( 2268 VkPhysicalDevice physicalDevice, 2269 VkFormat format, 2270 VkImageType type, 2271 VkImageTiling tiling, 2272 VkImageUsageFlags usage, 2273 VkImageCreateFlags flags, 2274 VkImageFormatProperties* pImageFormatProperties); 2275 2276void VKAPI vkGetPhysicalDeviceProperties( 2277 VkPhysicalDevice physicalDevice, 2278 VkPhysicalDeviceProperties* pProperties); 2279 2280void VKAPI vkGetPhysicalDeviceQueueFamilyProperties( 2281 VkPhysicalDevice physicalDevice, 2282 uint32_t* pCount, 2283 VkQueueFamilyProperties* pQueueFamilyProperties); 2284 2285void VKAPI vkGetPhysicalDeviceMemoryProperties( 2286 VkPhysicalDevice physicalDevice, 2287 VkPhysicalDeviceMemoryProperties* pMemoryProperties); 2288 2289PFN_vkVoidFunction VKAPI vkGetInstanceProcAddr( 2290 VkInstance instance, 2291 const char* pName); 2292 2293PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr( 2294 VkDevice device, 2295 const char* pName); 2296 2297VkResult VKAPI vkCreateDevice( 2298 VkPhysicalDevice physicalDevice, 2299 const VkDeviceCreateInfo* pCreateInfo, 2300 VkDevice* pDevice); 2301 2302void VKAPI vkDestroyDevice( 2303 VkDevice device); 2304 2305VkResult VKAPI vkEnumerateInstanceExtensionProperties( 2306 const char* pLayerName, 2307 uint32_t* pCount, 2308 VkExtensionProperties* pProperties); 2309 2310VkResult VKAPI vkEnumerateDeviceExtensionProperties( 2311 VkPhysicalDevice physicalDevice, 2312 const char* pLayerName, 2313 uint32_t* pCount, 2314 VkExtensionProperties* pProperties); 2315 2316VkResult VKAPI vkEnumerateInstanceLayerProperties( 2317 uint32_t* pCount, 2318 VkLayerProperties* pProperties); 2319 2320VkResult VKAPI vkEnumerateDeviceLayerProperties( 2321 VkPhysicalDevice physicalDevice, 2322 uint32_t* pCount, 2323 VkLayerProperties* pProperties); 2324 2325void VKAPI vkGetDeviceQueue( 2326 VkDevice device, 2327 uint32_t queueFamilyIndex, 2328 uint32_t queueIndex, 2329 VkQueue* pQueue); 2330 2331VkResult VKAPI vkQueueSubmit( 2332 VkQueue queue, 2333 uint32_t cmdBufferCount, 2334 const VkCmdBuffer* pCmdBuffers, 2335 VkFence fence); 2336 2337VkResult VKAPI vkQueueWaitIdle( 2338 VkQueue queue); 2339 2340VkResult VKAPI vkDeviceWaitIdle( 2341 VkDevice device); 2342 2343VkResult VKAPI vkAllocMemory( 2344 VkDevice device, 2345 const VkMemoryAllocInfo* pAllocInfo, 2346 VkDeviceMemory* pMem); 2347 2348void VKAPI vkFreeMemory( 2349 VkDevice device, 2350 VkDeviceMemory mem); 2351 2352VkResult VKAPI vkMapMemory( 2353 VkDevice device, 2354 VkDeviceMemory mem, 2355 VkDeviceSize offset, 2356 VkDeviceSize size, 2357 VkMemoryMapFlags flags, 2358 void** ppData); 2359 2360void VKAPI vkUnmapMemory( 2361 VkDevice device, 2362 VkDeviceMemory mem); 2363 2364VkResult VKAPI vkFlushMappedMemoryRanges( 2365 VkDevice device, 2366 uint32_t memRangeCount, 2367 const VkMappedMemoryRange* pMemRanges); 2368 2369VkResult VKAPI vkInvalidateMappedMemoryRanges( 2370 VkDevice device, 2371 uint32_t memRangeCount, 2372 const VkMappedMemoryRange* pMemRanges); 2373 2374void VKAPI vkGetDeviceMemoryCommitment( 2375 VkDevice device, 2376 VkDeviceMemory memory, 2377 VkDeviceSize* pCommittedMemoryInBytes); 2378 2379VkResult VKAPI vkBindBufferMemory( 2380 VkDevice device, 2381 VkBuffer buffer, 2382 VkDeviceMemory mem, 2383 VkDeviceSize memOffset); 2384 2385VkResult VKAPI vkBindImageMemory( 2386 VkDevice device, 2387 VkImage image, 2388 VkDeviceMemory mem, 2389 VkDeviceSize memOffset); 2390 2391void VKAPI vkGetBufferMemoryRequirements( 2392 VkDevice device, 2393 VkBuffer buffer, 2394 VkMemoryRequirements* pMemoryRequirements); 2395 2396void VKAPI vkGetImageMemoryRequirements( 2397 VkDevice device, 2398 VkImage image, 2399 VkMemoryRequirements* pMemoryRequirements); 2400 2401void VKAPI vkGetImageSparseMemoryRequirements( 2402 VkDevice device, 2403 VkImage image, 2404 uint32_t* pNumRequirements, 2405 VkSparseImageMemoryRequirements* pSparseMemoryRequirements); 2406 2407void VKAPI vkGetPhysicalDeviceSparseImageFormatProperties( 2408 VkPhysicalDevice physicalDevice, 2409 VkFormat format, 2410 VkImageType type, 2411 uint32_t samples, 2412 VkImageUsageFlags usage, 2413 VkImageTiling tiling, 2414 uint32_t* pNumProperties, 2415 VkSparseImageFormatProperties* pProperties); 2416 2417VkResult VKAPI vkQueueBindSparseBufferMemory( 2418 VkQueue queue, 2419 VkBuffer buffer, 2420 uint32_t numBindings, 2421 const VkSparseMemoryBindInfo* pBindInfo); 2422 2423VkResult VKAPI vkQueueBindSparseImageOpaqueMemory( 2424 VkQueue queue, 2425 VkImage image, 2426 uint32_t numBindings, 2427 const VkSparseMemoryBindInfo* pBindInfo); 2428 2429VkResult VKAPI vkQueueBindSparseImageMemory( 2430 VkQueue queue, 2431 VkImage image, 2432 uint32_t numBindings, 2433 const VkSparseImageMemoryBindInfo* pBindInfo); 2434 2435VkResult VKAPI vkCreateFence( 2436 VkDevice device, 2437 const VkFenceCreateInfo* pCreateInfo, 2438 VkFence* pFence); 2439 2440void VKAPI vkDestroyFence( 2441 VkDevice device, 2442 VkFence fence); 2443 2444VkResult VKAPI vkResetFences( 2445 VkDevice device, 2446 uint32_t fenceCount, 2447 const VkFence* pFences); 2448 2449VkResult VKAPI vkGetFenceStatus( 2450 VkDevice device, 2451 VkFence fence); 2452 2453VkResult VKAPI vkWaitForFences( 2454 VkDevice device, 2455 uint32_t fenceCount, 2456 const VkFence* pFences, 2457 VkBool32 waitAll, 2458 uint64_t timeout); 2459 2460VkResult VKAPI vkCreateSemaphore( 2461 VkDevice device, 2462 const VkSemaphoreCreateInfo* pCreateInfo, 2463 VkSemaphore* pSemaphore); 2464 2465void VKAPI vkDestroySemaphore( 2466 VkDevice device, 2467 VkSemaphore semaphore); 2468 2469VkResult VKAPI vkQueueSignalSemaphore( 2470 VkQueue queue, 2471 VkSemaphore semaphore); 2472 2473VkResult VKAPI vkQueueWaitSemaphore( 2474 VkQueue queue, 2475 VkSemaphore semaphore); 2476 2477VkResult VKAPI vkCreateEvent( 2478 VkDevice device, 2479 const VkEventCreateInfo* pCreateInfo, 2480 VkEvent* pEvent); 2481 2482void VKAPI vkDestroyEvent( 2483 VkDevice device, 2484 VkEvent event); 2485 2486VkResult VKAPI vkGetEventStatus( 2487 VkDevice device, 2488 VkEvent event); 2489 2490VkResult VKAPI vkSetEvent( 2491 VkDevice device, 2492 VkEvent event); 2493 2494VkResult VKAPI vkResetEvent( 2495 VkDevice device, 2496 VkEvent event); 2497 2498VkResult VKAPI vkCreateQueryPool( 2499 VkDevice device, 2500 const VkQueryPoolCreateInfo* pCreateInfo, 2501 VkQueryPool* pQueryPool); 2502 2503void VKAPI vkDestroyQueryPool( 2504 VkDevice device, 2505 VkQueryPool queryPool); 2506 2507VkResult VKAPI vkGetQueryPoolResults( 2508 VkDevice device, 2509 VkQueryPool queryPool, 2510 uint32_t startQuery, 2511 uint32_t queryCount, 2512 size_t* pDataSize, 2513 void* pData, 2514 VkQueryResultFlags flags); 2515 2516VkResult VKAPI vkCreateBuffer( 2517 VkDevice device, 2518 const VkBufferCreateInfo* pCreateInfo, 2519 VkBuffer* pBuffer); 2520 2521void VKAPI vkDestroyBuffer( 2522 VkDevice device, 2523 VkBuffer buffer); 2524 2525VkResult VKAPI vkCreateBufferView( 2526 VkDevice device, 2527 const VkBufferViewCreateInfo* pCreateInfo, 2528 VkBufferView* pView); 2529 2530void VKAPI vkDestroyBufferView( 2531 VkDevice device, 2532 VkBufferView bufferView); 2533 2534VkResult VKAPI vkCreateImage( 2535 VkDevice device, 2536 const VkImageCreateInfo* pCreateInfo, 2537 VkImage* pImage); 2538 2539void VKAPI vkDestroyImage( 2540 VkDevice device, 2541 VkImage image); 2542 2543void VKAPI vkGetImageSubresourceLayout( 2544 VkDevice device, 2545 VkImage image, 2546 const VkImageSubresource* pSubresource, 2547 VkSubresourceLayout* pLayout); 2548 2549VkResult VKAPI vkCreateImageView( 2550 VkDevice device, 2551 const VkImageViewCreateInfo* pCreateInfo, 2552 VkImageView* pView); 2553 2554void VKAPI vkDestroyImageView( 2555 VkDevice device, 2556 VkImageView imageView); 2557 2558VkResult VKAPI vkCreateShaderModule( 2559 VkDevice device, 2560 const VkShaderModuleCreateInfo* pCreateInfo, 2561 VkShaderModule* pShaderModule); 2562 2563void VKAPI vkDestroyShaderModule( 2564 VkDevice device, 2565 VkShaderModule shaderModule); 2566 2567VkResult VKAPI vkCreateShader( 2568 VkDevice device, 2569 const VkShaderCreateInfo* pCreateInfo, 2570 VkShader* pShader); 2571 2572void VKAPI vkDestroyShader( 2573 VkDevice device, 2574 VkShader shader); 2575 2576VkResult VKAPI vkCreatePipelineCache( 2577 VkDevice device, 2578 const VkPipelineCacheCreateInfo* pCreateInfo, 2579 VkPipelineCache* pPipelineCache); 2580 2581void VKAPI vkDestroyPipelineCache( 2582 VkDevice device, 2583 VkPipelineCache pipelineCache); 2584 2585size_t VKAPI vkGetPipelineCacheSize( 2586 VkDevice device, 2587 VkPipelineCache pipelineCache); 2588 2589VkResult VKAPI vkGetPipelineCacheData( 2590 VkDevice device, 2591 VkPipelineCache pipelineCache, 2592 size_t dataSize, 2593 void* pData); 2594 2595VkResult VKAPI vkMergePipelineCaches( 2596 VkDevice device, 2597 VkPipelineCache destCache, 2598 uint32_t srcCacheCount, 2599 const VkPipelineCache* pSrcCaches); 2600 2601VkResult VKAPI vkCreateGraphicsPipelines( 2602 VkDevice device, 2603 VkPipelineCache pipelineCache, 2604 uint32_t count, 2605 const VkGraphicsPipelineCreateInfo* pCreateInfos, 2606 VkPipeline* pPipelines); 2607 2608VkResult VKAPI vkCreateComputePipelines( 2609 VkDevice device, 2610 VkPipelineCache pipelineCache, 2611 uint32_t count, 2612 const VkComputePipelineCreateInfo* pCreateInfos, 2613 VkPipeline* pPipelines); 2614 2615void VKAPI vkDestroyPipeline( 2616 VkDevice device, 2617 VkPipeline pipeline); 2618 2619VkResult VKAPI vkCreatePipelineLayout( 2620 VkDevice device, 2621 const VkPipelineLayoutCreateInfo* pCreateInfo, 2622 VkPipelineLayout* pPipelineLayout); 2623 2624void VKAPI vkDestroyPipelineLayout( 2625 VkDevice device, 2626 VkPipelineLayout pipelineLayout); 2627 2628VkResult VKAPI vkCreateSampler( 2629 VkDevice device, 2630 const VkSamplerCreateInfo* pCreateInfo, 2631 VkSampler* pSampler); 2632 2633void VKAPI vkDestroySampler( 2634 VkDevice device, 2635 VkSampler sampler); 2636 2637VkResult VKAPI vkCreateDescriptorSetLayout( 2638 VkDevice device, 2639 const VkDescriptorSetLayoutCreateInfo* pCreateInfo, 2640 VkDescriptorSetLayout* pSetLayout); 2641 2642void VKAPI vkDestroyDescriptorSetLayout( 2643 VkDevice device, 2644 VkDescriptorSetLayout descriptorSetLayout); 2645 2646VkResult VKAPI vkCreateDescriptorPool( 2647 VkDevice device, 2648 const VkDescriptorPoolCreateInfo* pCreateInfo, 2649 VkDescriptorPool* pDescriptorPool); 2650 2651void VKAPI vkDestroyDescriptorPool( 2652 VkDevice device, 2653 VkDescriptorPool descriptorPool); 2654 2655VkResult VKAPI vkResetDescriptorPool( 2656 VkDevice device, 2657 VkDescriptorPool descriptorPool); 2658 2659VkResult VKAPI vkAllocDescriptorSets( 2660 VkDevice device, 2661 VkDescriptorPool descriptorPool, 2662 VkDescriptorSetUsage setUsage, 2663 uint32_t count, 2664 const VkDescriptorSetLayout* pSetLayouts, 2665 VkDescriptorSet* pDescriptorSets); 2666 2667VkResult VKAPI vkFreeDescriptorSets( 2668 VkDevice device, 2669 VkDescriptorPool descriptorPool, 2670 uint32_t count, 2671 const VkDescriptorSet* pDescriptorSets); 2672 2673void VKAPI vkUpdateDescriptorSets( 2674 VkDevice device, 2675 uint32_t writeCount, 2676 const VkWriteDescriptorSet* pDescriptorWrites, 2677 uint32_t copyCount, 2678 const VkCopyDescriptorSet* pDescriptorCopies); 2679 2680VkResult VKAPI vkCreateFramebuffer( 2681 VkDevice device, 2682 const VkFramebufferCreateInfo* pCreateInfo, 2683 VkFramebuffer* pFramebuffer); 2684 2685void VKAPI vkDestroyFramebuffer( 2686 VkDevice device, 2687 VkFramebuffer framebuffer); 2688 2689VkResult VKAPI vkCreateRenderPass( 2690 VkDevice device, 2691 const VkRenderPassCreateInfo* pCreateInfo, 2692 VkRenderPass* pRenderPass); 2693 2694void VKAPI vkDestroyRenderPass( 2695 VkDevice device, 2696 VkRenderPass renderPass); 2697 2698void VKAPI vkGetRenderAreaGranularity( 2699 VkDevice device, 2700 VkRenderPass renderPass, 2701 VkExtent2D* pGranularity); 2702 2703VkResult VKAPI vkCreateCommandPool( 2704 VkDevice device, 2705 const VkCmdPoolCreateInfo* pCreateInfo, 2706 VkCmdPool* pCmdPool); 2707 2708void VKAPI vkDestroyCommandPool( 2709 VkDevice device, 2710 VkCmdPool cmdPool); 2711 2712VkResult VKAPI vkResetCommandPool( 2713 VkDevice device, 2714 VkCmdPool cmdPool, 2715 VkCmdPoolResetFlags flags); 2716 2717VkResult VKAPI vkCreateCommandBuffer( 2718 VkDevice device, 2719 const VkCmdBufferCreateInfo* pCreateInfo, 2720 VkCmdBuffer* pCmdBuffer); 2721 2722void VKAPI vkDestroyCommandBuffer( 2723 VkDevice device, 2724 VkCmdBuffer commandBuffer); 2725 2726VkResult VKAPI vkBeginCommandBuffer( 2727 VkCmdBuffer cmdBuffer, 2728 const VkCmdBufferBeginInfo* pBeginInfo); 2729 2730VkResult VKAPI vkEndCommandBuffer( 2731 VkCmdBuffer cmdBuffer); 2732 2733VkResult VKAPI vkResetCommandBuffer( 2734 VkCmdBuffer cmdBuffer, 2735 VkCmdBufferResetFlags flags); 2736 2737void VKAPI vkCmdBindPipeline( 2738 VkCmdBuffer cmdBuffer, 2739 VkPipelineBindPoint pipelineBindPoint, 2740 VkPipeline pipeline); 2741 2742void VKAPI vkCmdSetViewport( 2743 VkCmdBuffer cmdBuffer, 2744 uint32_t viewportCount, 2745 const VkViewport* pViewports); 2746 2747void VKAPI vkCmdSetScissor( 2748 VkCmdBuffer cmdBuffer, 2749 uint32_t scissorCount, 2750 const VkRect2D* pScissors); 2751 2752void VKAPI vkCmdSetLineWidth( 2753 VkCmdBuffer cmdBuffer, 2754 float lineWidth); 2755 2756void VKAPI vkCmdSetDepthBias( 2757 VkCmdBuffer cmdBuffer, 2758 float depthBias, 2759 float depthBiasClamp, 2760 float slopeScaledDepthBias); 2761 2762void VKAPI vkCmdSetBlendConstants( 2763 VkCmdBuffer cmdBuffer, 2764 const float blendConst[4]); 2765 2766void VKAPI vkCmdSetDepthBounds( 2767 VkCmdBuffer cmdBuffer, 2768 float minDepthBounds, 2769 float maxDepthBounds); 2770 2771void VKAPI vkCmdSetStencilCompareMask( 2772 VkCmdBuffer cmdBuffer, 2773 VkStencilFaceFlags faceMask, 2774 uint32_t stencilCompareMask); 2775 2776void VKAPI vkCmdSetStencilWriteMask( 2777 VkCmdBuffer cmdBuffer, 2778 VkStencilFaceFlags faceMask, 2779 uint32_t stencilWriteMask); 2780 2781void VKAPI vkCmdSetStencilReference( 2782 VkCmdBuffer cmdBuffer, 2783 VkStencilFaceFlags faceMask, 2784 uint32_t stencilReference); 2785 2786void VKAPI vkCmdBindDescriptorSets( 2787 VkCmdBuffer cmdBuffer, 2788 VkPipelineBindPoint pipelineBindPoint, 2789 VkPipelineLayout layout, 2790 uint32_t firstSet, 2791 uint32_t setCount, 2792 const VkDescriptorSet* pDescriptorSets, 2793 uint32_t dynamicOffsetCount, 2794 const uint32_t* pDynamicOffsets); 2795 2796void VKAPI vkCmdBindIndexBuffer( 2797 VkCmdBuffer cmdBuffer, 2798 VkBuffer buffer, 2799 VkDeviceSize offset, 2800 VkIndexType indexType); 2801 2802void VKAPI vkCmdBindVertexBuffers( 2803 VkCmdBuffer cmdBuffer, 2804 uint32_t startBinding, 2805 uint32_t bindingCount, 2806 const VkBuffer* pBuffers, 2807 const VkDeviceSize* pOffsets); 2808 2809void VKAPI vkCmdDraw( 2810 VkCmdBuffer cmdBuffer, 2811 uint32_t vertexCount, 2812 uint32_t instanceCount, 2813 uint32_t firstVertex, 2814 uint32_t firstInstance); 2815 2816void VKAPI vkCmdDrawIndexed( 2817 VkCmdBuffer cmdBuffer, 2818 uint32_t indexCount, 2819 uint32_t instanceCount, 2820 uint32_t firstIndex, 2821 int32_t vertexOffset, 2822 uint32_t firstInstance); 2823 2824void VKAPI vkCmdDrawIndirect( 2825 VkCmdBuffer cmdBuffer, 2826 VkBuffer buffer, 2827 VkDeviceSize offset, 2828 uint32_t count, 2829 uint32_t stride); 2830 2831void VKAPI vkCmdDrawIndexedIndirect( 2832 VkCmdBuffer cmdBuffer, 2833 VkBuffer buffer, 2834 VkDeviceSize offset, 2835 uint32_t count, 2836 uint32_t stride); 2837 2838void VKAPI vkCmdDispatch( 2839 VkCmdBuffer cmdBuffer, 2840 uint32_t x, 2841 uint32_t y, 2842 uint32_t z); 2843 2844void VKAPI vkCmdDispatchIndirect( 2845 VkCmdBuffer cmdBuffer, 2846 VkBuffer buffer, 2847 VkDeviceSize offset); 2848 2849void VKAPI vkCmdCopyBuffer( 2850 VkCmdBuffer cmdBuffer, 2851 VkBuffer srcBuffer, 2852 VkBuffer destBuffer, 2853 uint32_t regionCount, 2854 const VkBufferCopy* pRegions); 2855 2856void VKAPI vkCmdCopyImage( 2857 VkCmdBuffer cmdBuffer, 2858 VkImage srcImage, 2859 VkImageLayout srcImageLayout, 2860 VkImage destImage, 2861 VkImageLayout destImageLayout, 2862 uint32_t regionCount, 2863 const VkImageCopy* pRegions); 2864 2865void VKAPI vkCmdBlitImage( 2866 VkCmdBuffer cmdBuffer, 2867 VkImage srcImage, 2868 VkImageLayout srcImageLayout, 2869 VkImage destImage, 2870 VkImageLayout destImageLayout, 2871 uint32_t regionCount, 2872 const VkImageBlit* pRegions, 2873 VkTexFilter filter); 2874 2875void VKAPI vkCmdCopyBufferToImage( 2876 VkCmdBuffer cmdBuffer, 2877 VkBuffer srcBuffer, 2878 VkImage destImage, 2879 VkImageLayout destImageLayout, 2880 uint32_t regionCount, 2881 const VkBufferImageCopy* pRegions); 2882 2883void VKAPI vkCmdCopyImageToBuffer( 2884 VkCmdBuffer cmdBuffer, 2885 VkImage srcImage, 2886 VkImageLayout srcImageLayout, 2887 VkBuffer destBuffer, 2888 uint32_t regionCount, 2889 const VkBufferImageCopy* pRegions); 2890 2891void VKAPI vkCmdUpdateBuffer( 2892 VkCmdBuffer cmdBuffer, 2893 VkBuffer destBuffer, 2894 VkDeviceSize destOffset, 2895 VkDeviceSize dataSize, 2896 const uint32_t* pData); 2897 2898void VKAPI vkCmdFillBuffer( 2899 VkCmdBuffer cmdBuffer, 2900 VkBuffer destBuffer, 2901 VkDeviceSize destOffset, 2902 VkDeviceSize fillSize, 2903 uint32_t data); 2904 2905void VKAPI vkCmdClearColorImage( 2906 VkCmdBuffer cmdBuffer, 2907 VkImage image, 2908 VkImageLayout imageLayout, 2909 const VkClearColorValue* pColor, 2910 uint32_t rangeCount, 2911 const VkImageSubresourceRange* pRanges); 2912 2913void VKAPI vkCmdClearDepthStencilImage( 2914 VkCmdBuffer cmdBuffer, 2915 VkImage image, 2916 VkImageLayout imageLayout, 2917 const VkClearDepthStencilValue* pDepthStencil, 2918 uint32_t rangeCount, 2919 const VkImageSubresourceRange* pRanges); 2920 2921void VKAPI vkCmdClearAttachments( 2922 VkCmdBuffer cmdBuffer, 2923 uint32_t attachmentCount, 2924 const VkClearAttachment* pAttachments, 2925 uint32_t rectCount, 2926 const VkRect3D* pRects); 2927 2928void VKAPI vkCmdResolveImage( 2929 VkCmdBuffer cmdBuffer, 2930 VkImage srcImage, 2931 VkImageLayout srcImageLayout, 2932 VkImage destImage, 2933 VkImageLayout destImageLayout, 2934 uint32_t regionCount, 2935 const VkImageResolve* pRegions); 2936 2937void VKAPI vkCmdSetEvent( 2938 VkCmdBuffer cmdBuffer, 2939 VkEvent event, 2940 VkPipelineStageFlags stageMask); 2941 2942void VKAPI vkCmdResetEvent( 2943 VkCmdBuffer cmdBuffer, 2944 VkEvent event, 2945 VkPipelineStageFlags stageMask); 2946 2947void VKAPI vkCmdWaitEvents( 2948 VkCmdBuffer cmdBuffer, 2949 uint32_t eventCount, 2950 const VkEvent* pEvents, 2951 VkPipelineStageFlags srcStageMask, 2952 VkPipelineStageFlags destStageMask, 2953 uint32_t memBarrierCount, 2954 const void* const* ppMemBarriers); 2955 2956void VKAPI vkCmdPipelineBarrier( 2957 VkCmdBuffer cmdBuffer, 2958 VkPipelineStageFlags srcStageMask, 2959 VkPipelineStageFlags destStageMask, 2960 VkBool32 byRegion, 2961 uint32_t memBarrierCount, 2962 const void* const* ppMemBarriers); 2963 2964void VKAPI vkCmdBeginQuery( 2965 VkCmdBuffer cmdBuffer, 2966 VkQueryPool queryPool, 2967 uint32_t slot, 2968 VkQueryControlFlags flags); 2969 2970void VKAPI vkCmdEndQuery( 2971 VkCmdBuffer cmdBuffer, 2972 VkQueryPool queryPool, 2973 uint32_t slot); 2974 2975void VKAPI vkCmdResetQueryPool( 2976 VkCmdBuffer cmdBuffer, 2977 VkQueryPool queryPool, 2978 uint32_t startQuery, 2979 uint32_t queryCount); 2980 2981void VKAPI vkCmdWriteTimestamp( 2982 VkCmdBuffer cmdBuffer, 2983 VkTimestampType timestampType, 2984 VkBuffer destBuffer, 2985 VkDeviceSize destOffset); 2986 2987void VKAPI vkCmdCopyQueryPoolResults( 2988 VkCmdBuffer cmdBuffer, 2989 VkQueryPool queryPool, 2990 uint32_t startQuery, 2991 uint32_t queryCount, 2992 VkBuffer destBuffer, 2993 VkDeviceSize destOffset, 2994 VkDeviceSize destStride, 2995 VkQueryResultFlags flags); 2996 2997void VKAPI vkCmdPushConstants( 2998 VkCmdBuffer cmdBuffer, 2999 VkPipelineLayout layout, 3000 VkShaderStageFlags stageFlags, 3001 uint32_t start, 3002 uint32_t length, 3003 const void* values); 3004 3005void VKAPI vkCmdBeginRenderPass( 3006 VkCmdBuffer cmdBuffer, 3007 const VkRenderPassBeginInfo* pRenderPassBegin, 3008 VkRenderPassContents contents); 3009 3010void VKAPI vkCmdNextSubpass( 3011 VkCmdBuffer cmdBuffer, 3012 VkRenderPassContents contents); 3013 3014void VKAPI vkCmdEndRenderPass( 3015 VkCmdBuffer cmdBuffer); 3016 3017void VKAPI vkCmdExecuteCommands( 3018 VkCmdBuffer cmdBuffer, 3019 uint32_t cmdBuffersCount, 3020 const VkCmdBuffer* pCmdBuffers); 3021#endif 3022 3023#ifdef __cplusplus 3024} 3025#endif 3026 3027#endif 3028