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