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