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