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