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