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