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