vulkan.h revision 3fbc856120217247c72fb5ed88500000f3881c45
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, 196, 0) 45 46 47#define VK_NULL_HANDLE 0 48 49 50 51#define VK_DEFINE_HANDLE(object) typedef struct object##_T* object; 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_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object; 56#else 57 #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object; 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_NON_DISPATCHABLE_HANDLE(VkSemaphore) 72VK_DEFINE_HANDLE(VkCommandBuffer) 73VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence) 74VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory) 75VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer) 76VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage) 77VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent) 78VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool) 79VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView) 80VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView) 81VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule) 82VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShader) 83VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache) 84VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout) 85VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass) 86VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline) 87VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout) 88VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler) 89VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool) 90VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet) 91VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer) 92VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool) 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_RANGE_SIZE = (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_COMMAND_POOL_CREATE_INFO = 40, 175 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOC_INFO = 41, 176 VK_STRUCTURE_TYPE_COMMAND_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_RANGE_SIZE = (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_ALLOCATION_SCOPE_FUNCTION = 0, 191 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1, 192 VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2, 193 VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3, 194 VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4, 195 VK_SYSTEM_ALLOCATION_SCOPE_BEGIN_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_FUNCTION, 196 VK_SYSTEM_ALLOCATION_SCOPE_END_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE, 197 VK_SYSTEM_ALLOCATION_SCOPE_RANGE_SIZE = (VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE - VK_SYSTEM_ALLOCATION_SCOPE_FUNCTION + 1), 198 VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF 199} VkSystemAllocationScope; 200 201typedef enum { 202 VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0, 203 VK_INTERNAL_ALLOCATION_TYPE_BEGIN_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE, 204 VK_INTERNAL_ALLOCATION_TYPE_END_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE, 205 VK_INTERNAL_ALLOCATION_TYPE_RANGE_SIZE = (VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE - VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE + 1), 206 VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF 207} VkInternalAllocationType; 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_RANGE_SIZE = (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_RANGE_SIZE = (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_RANGE_SIZE = (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_RANGE_SIZE = (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_RANGE_SIZE = (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_RANGE_SIZE = (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_SRC_OPTIMAL = 6, 448 VK_IMAGE_LAYOUT_TRANSFER_DST_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_RANGE_SIZE = (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_RANGE_SIZE = (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_RANGE_SIZE = (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_RANGE_SIZE = (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_WITH_ADJACENCY = 6, 501 VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7, 502 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8, 503 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 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_RANGE_SIZE = (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_RANGE_SIZE = (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_COUNTER_CLOCKWISE = 0, 523 VK_FRONT_FACE_CLOCKWISE = 1, 524 VK_FRONT_FACE_BEGIN_RANGE = VK_FRONT_FACE_COUNTER_CLOCKWISE, 525 VK_FRONT_FACE_END_RANGE = VK_FRONT_FACE_CLOCKWISE, 526 VK_FRONT_FACE_RANGE_SIZE = (VK_FRONT_FACE_CLOCKWISE - VK_FRONT_FACE_COUNTER_CLOCKWISE + 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_OR_EQUAL = 3, 535 VK_COMPARE_OP_GREATER = 4, 536 VK_COMPARE_OP_NOT_EQUAL = 5, 537 VK_COMPARE_OP_GREATER_OR_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_RANGE_SIZE = (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_INCREMENT_AND_CLAMP = 3, 550 VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4, 551 VK_STENCIL_OP_INVERT = 5, 552 VK_STENCIL_OP_INCREMENT_AND_WRAP = 6, 553 VK_STENCIL_OP_DECREMENT_AND_WRAP = 7, 554 VK_STENCIL_OP_BEGIN_RANGE = VK_STENCIL_OP_KEEP, 555 VK_STENCIL_OP_END_RANGE = VK_STENCIL_OP_DECREMENT_AND_WRAP, 556 VK_STENCIL_OP_RANGE_SIZE = (VK_STENCIL_OP_DECREMENT_AND_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_NO_OP = 5, 567 VK_LOGIC_OP_XOR = 6, 568 VK_LOGIC_OP_OR = 7, 569 VK_LOGIC_OP_NOR = 8, 570 VK_LOGIC_OP_EQUIVALENT = 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_RANGE_SIZE = (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_DST_COLOR = 4, 589 VK_BLEND_ONE_MINUS_DST_COLOR = 5, 590 VK_BLEND_SRC_ALPHA = 6, 591 VK_BLEND_ONE_MINUS_SRC_ALPHA = 7, 592 VK_BLEND_DST_ALPHA = 8, 593 VK_BLEND_ONE_MINUS_DST_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_RANGE_SIZE = (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_RANGE_SIZE = (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_RANGE_SIZE = (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_RANGE_SIZE = (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_RANGE_SIZE = (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_RANGE_SIZE = (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_RANGE_SIZE = (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_RANGE_SIZE = (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_RANGE_SIZE = (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_RANGE_SIZE = (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_RANGE_SIZE = (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_COMMAND_BUFFER_LEVEL_PRIMARY = 0, 729 VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1, 730 VK_COMMAND_BUFFER_LEVEL_BEGIN_RANGE = VK_COMMAND_BUFFER_LEVEL_PRIMARY, 731 VK_COMMAND_BUFFER_LEVEL_END_RANGE = VK_COMMAND_BUFFER_LEVEL_SECONDARY, 732 VK_COMMAND_BUFFER_LEVEL_RANGE_SIZE = (VK_COMMAND_BUFFER_LEVEL_SECONDARY - VK_COMMAND_BUFFER_LEVEL_PRIMARY + 1), 733 VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF 734} VkCommandBufferLevel; 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_RANGE_SIZE = (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_COMMAND_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_COMMAND_BUFFERS, 750 VK_RENDER_PASS_CONTENTS_RANGE_SIZE = (VK_RENDER_PASS_CONTENTS_SECONDARY_COMMAND_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_SRC_BIT = 0x00000400, 768 VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800, 769} VkFormatFeatureFlagBits; 770typedef VkFlags VkFormatFeatureFlags; 771 772typedef enum { 773 VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001, 774 VK_IMAGE_USAGE_TRANSFER_DST_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_SRC_BIT = 0x00000001, 889 VK_BUFFER_USAGE_TRANSFER_DST_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 VkPipelineRasterizationStateCreateFlags; 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_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001, 1018 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002, 1019} VkCommandPoolCreateFlagBits; 1020typedef VkFlags VkCommandPoolCreateFlags; 1021 1022typedef enum { 1023 VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001, 1024} VkCommandPoolResetFlagBits; 1025typedef VkFlags VkCommandPoolResetFlags; 1026 1027typedef enum { 1028 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001, 1029 VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002, 1030 VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004, 1031} VkCommandBufferUsageFlagBits; 1032typedef VkFlags VkCommandBufferUsageFlags; 1033 1034typedef enum { 1035 VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001, 1036} VkCommandBufferResetFlagBits; 1037typedef VkFlags VkCommandBufferResetFlags; 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_vkAllocationFunction)( 1053 void* pUserData, 1054 size_t size, 1055 size_t alignment, 1056 VkSystemAllocationScope allocationScope); 1057 1058typedef void* (VKAPI *PFN_vkReallocationFunction)( 1059 void* pUserData, 1060 void* pOriginal, 1061 size_t size, 1062 size_t alignment, 1063 VkSystemAllocationScope allocationScope); 1064 1065typedef void (VKAPI *PFN_vkFreeFunction)( 1066 void* pUserData, 1067 void* pMemory); 1068 1069typedef void (VKAPI *PFN_vkInternalAllocationNotification)( 1070 void* pUserData, 1071 size_t size, 1072 VkInternalAllocationType allocationType, 1073 VkSystemAllocationScope allocationScope); 1074 1075typedef void (VKAPI *PFN_vkInternalFreeNotification)( 1076 void* pUserData, 1077 size_t size, 1078 VkInternalAllocationType allocationType, 1079 VkSystemAllocationScope allocationScope); 1080 1081typedef void (VKAPI *PFN_vkVoidFunction)(void); 1082 1083typedef struct { 1084 VkStructureType sType; 1085 const void* pNext; 1086 const char* pApplicationName; 1087 uint32_t applicationVersion; 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* pApplicationInfo; 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_vkAllocationFunction pfnAllocation; 1107 PFN_vkReallocationFunction pfnReallocation; 1108 PFN_vkFreeFunction pfnFree; 1109 PFN_vkInternalAllocationNotification pfnInternalAllocation; 1110 PFN_vkInternalFreeNotification pfnInternalFree; 1111} VkAllocationCallbacks; 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 dualSrcBlend; 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 maxTessellationGenerationLevel; 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 maxFragmentDualSrcAttachments; 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 extensionName[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 implementationVersion; 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 VkCommandBuffer* 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} VkMemoryAllocateInfo; 1383 1384typedef struct { 1385 VkStructureType sType; 1386 const void* pNext; 1387 VkDeviceMemory memory; 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 memory; 1416 VkDeviceSize memoryOffset; 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 memory; 1449 VkDeviceSize memoryOffset; 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 levelCount; 1558 uint32_t baseArrayLayer; 1559 uint32_t layerCount; 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} VkPipelineCacheCreateInfo; 1597 1598typedef struct { 1599 uint32_t constantId; 1600 uint32_t offset; 1601 size_t size; 1602} VkSpecializationMapEntry; 1603 1604typedef struct { 1605 uint32_t mapEntryCount; 1606 const VkSpecializationMapEntry* pMapEntries; 1607 size_t dataSize; 1608 const void* pData; 1609} VkSpecializationInfo; 1610 1611typedef struct { 1612 VkStructureType sType; 1613 const void* pNext; 1614 VkPipelineShaderStageCreateFlags flags; 1615 VkShader shader; 1616 const VkSpecializationInfo* pSpecializationInfo; 1617} VkPipelineShaderStageCreateInfo; 1618 1619typedef struct { 1620 uint32_t binding; 1621 uint32_t stride; 1622 VkVertexInputStepRate stepRate; 1623} VkVertexInputBindingDescription; 1624 1625typedef struct { 1626 uint32_t location; 1627 uint32_t binding; 1628 VkFormat format; 1629 uint32_t offset; 1630} VkVertexInputAttributeDescription; 1631 1632typedef struct { 1633 VkStructureType sType; 1634 const void* pNext; 1635 VkPipelineVertexInputStateCreateFlags flags; 1636 uint32_t vertexBindingDescriptionCount; 1637 const VkVertexInputBindingDescription* pVertexBindingDescriptions; 1638 uint32_t vertexAttributeDescriptionCount; 1639 const VkVertexInputAttributeDescription* pVertexAttributeDescriptions; 1640} VkPipelineVertexInputStateCreateInfo; 1641 1642typedef struct { 1643 VkStructureType sType; 1644 const void* pNext; 1645 VkPipelineInputAssemblyStateCreateFlags flags; 1646 VkPrimitiveTopology topology; 1647 VkBool32 primitiveRestartEnable; 1648} VkPipelineInputAssemblyStateCreateInfo; 1649 1650typedef struct { 1651 VkStructureType sType; 1652 const void* pNext; 1653 VkPipelineTesselationStateCreateFlags flags; 1654 uint32_t patchControlPoints; 1655} VkPipelineTessellationStateCreateInfo; 1656 1657typedef struct { 1658 float originX; 1659 float originY; 1660 float width; 1661 float height; 1662 float minDepth; 1663 float maxDepth; 1664} VkViewport; 1665 1666typedef struct { 1667 int32_t x; 1668 int32_t y; 1669} VkOffset2D; 1670 1671typedef struct { 1672 int32_t width; 1673 int32_t height; 1674} VkExtent2D; 1675 1676typedef struct { 1677 VkOffset2D offset; 1678 VkExtent2D extent; 1679} VkRect2D; 1680 1681typedef struct { 1682 VkStructureType sType; 1683 const void* pNext; 1684 VkPipelineViewportStateCreateFlags flags; 1685 uint32_t viewportCount; 1686 const VkViewport* pViewports; 1687 uint32_t scissorCount; 1688 const VkRect2D* pScissors; 1689} VkPipelineViewportStateCreateInfo; 1690 1691typedef struct { 1692 VkStructureType sType; 1693 const void* pNext; 1694 VkPipelineRasterizationStateCreateFlags flags; 1695 VkBool32 depthClampEnable; 1696 VkBool32 rasterizerDiscardEnable; 1697 VkFillMode fillMode; 1698 VkCullModeFlags cullMode; 1699 VkFrontFace frontFace; 1700 VkBool32 depthBiasEnable; 1701 float depthBiasConstantFactor; 1702 float depthBiasClamp; 1703 float depthBiasSlopeFactor; 1704 float lineWidth; 1705} VkPipelineRasterizationStateCreateInfo; 1706 1707typedef struct { 1708 VkStructureType sType; 1709 const void* pNext; 1710 VkPipelineMultisampleStateCreateFlags flags; 1711 uint32_t rasterizationSamples; 1712 VkBool32 sampleShadingEnable; 1713 float minSampleShading; 1714 const VkSampleMask* pSampleMask; 1715 VkBool32 alphaToCoverageEnable; 1716 VkBool32 alphaToOneEnable; 1717} VkPipelineMultisampleStateCreateInfo; 1718 1719typedef struct { 1720 VkStencilOp stencilFailOp; 1721 VkStencilOp stencilPassOp; 1722 VkStencilOp stencilDepthFailOp; 1723 VkCompareOp stencilCompareOp; 1724 uint32_t stencilCompareMask; 1725 uint32_t stencilWriteMask; 1726 uint32_t stencilReference; 1727} VkStencilOpState; 1728 1729typedef struct { 1730 VkStructureType sType; 1731 const void* pNext; 1732 VkPipelineDepthStencilStateCreateFlags flags; 1733 VkBool32 depthTestEnable; 1734 VkBool32 depthWriteEnable; 1735 VkCompareOp depthCompareOp; 1736 VkBool32 depthBoundsTestEnable; 1737 VkBool32 stencilTestEnable; 1738 VkStencilOpState front; 1739 VkStencilOpState back; 1740 float minDepthBounds; 1741 float maxDepthBounds; 1742} VkPipelineDepthStencilStateCreateInfo; 1743 1744typedef struct { 1745 VkBool32 blendEnable; 1746 VkBlend srcBlendColor; 1747 VkBlend dstBlendColor; 1748 VkBlendOp blendOpColor; 1749 VkBlend srcBlendAlpha; 1750 VkBlend dstBlendAlpha; 1751 VkBlendOp blendOpAlpha; 1752 VkChannelFlags channelWriteMask; 1753} VkPipelineColorBlendAttachmentState; 1754 1755typedef struct { 1756 VkStructureType sType; 1757 const void* pNext; 1758 VkPipelineColorBlendStateCreateFlags flags; 1759 VkBool32 logicOpEnable; 1760 VkLogicOp logicOp; 1761 uint32_t attachmentCount; 1762 const VkPipelineColorBlendAttachmentState* pAttachments; 1763 float blendConstants[4]; 1764} VkPipelineColorBlendStateCreateInfo; 1765 1766typedef struct { 1767 VkStructureType sType; 1768 const void* pNext; 1769 VkPipelineDynamicStateCreateFlags flags; 1770 uint32_t dynamicStateCount; 1771 const VkDynamicState* pDynamicStates; 1772} VkPipelineDynamicStateCreateInfo; 1773 1774typedef struct { 1775 VkStructureType sType; 1776 const void* pNext; 1777 VkPipelineCreateFlags flags; 1778 uint32_t stageCount; 1779 const VkPipelineShaderStageCreateInfo* pStages; 1780 const VkPipelineVertexInputStateCreateInfo* pVertexInputState; 1781 const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState; 1782 const VkPipelineTessellationStateCreateInfo* pTessellationState; 1783 const VkPipelineViewportStateCreateInfo* pViewportState; 1784 const VkPipelineRasterizationStateCreateInfo* pRasterizationState; 1785 const VkPipelineMultisampleStateCreateInfo* pMultisampleState; 1786 const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState; 1787 const VkPipelineColorBlendStateCreateInfo* pColorBlendState; 1788 const VkPipelineDynamicStateCreateInfo* pDynamicState; 1789 VkPipelineLayout layout; 1790 VkRenderPass renderPass; 1791 uint32_t subpass; 1792 VkPipeline basePipelineHandle; 1793 int32_t basePipelineIndex; 1794} VkGraphicsPipelineCreateInfo; 1795 1796typedef struct { 1797 VkStructureType sType; 1798 const void* pNext; 1799 VkPipelineCreateFlags flags; 1800 VkPipelineShaderStageCreateInfo stage; 1801 VkPipelineLayout layout; 1802 VkPipeline basePipelineHandle; 1803 int32_t basePipelineIndex; 1804} VkComputePipelineCreateInfo; 1805 1806typedef struct { 1807 VkShaderStageFlags stageFlags; 1808 uint32_t offset; 1809 uint32_t size; 1810} VkPushConstantRange; 1811 1812typedef struct { 1813 VkStructureType sType; 1814 const void* pNext; 1815 VkPipelineLayoutCreateFlags flags; 1816 uint32_t setLayoutCount; 1817 const VkDescriptorSetLayout* pSetLayouts; 1818 uint32_t pushConstantRangeCount; 1819 const VkPushConstantRange* pPushConstantRanges; 1820} VkPipelineLayoutCreateInfo; 1821 1822typedef struct { 1823 VkStructureType sType; 1824 const void* pNext; 1825 VkSamplerCreateFlags flags; 1826 VkFilter magFilter; 1827 VkFilter minFilter; 1828 VkSamplerMipmapMode mipmapMode; 1829 VkSamplerAddressMode addressModeU; 1830 VkSamplerAddressMode addressModeV; 1831 VkSamplerAddressMode addressModeW; 1832 float mipLodBias; 1833 float maxAnisotropy; 1834 VkBool32 compareEnable; 1835 VkCompareOp compareOp; 1836 float minLod; 1837 float maxLod; 1838 VkBorderColor borderColor; 1839 VkBool32 unnormalizedCoordinates; 1840} VkSamplerCreateInfo; 1841 1842typedef struct { 1843 VkDescriptorType descriptorType; 1844 uint32_t arraySize; 1845 VkShaderStageFlags stageFlags; 1846 const VkSampler* pImmutableSamplers; 1847} VkDescriptorSetLayoutBinding; 1848 1849typedef struct { 1850 VkStructureType sType; 1851 const void* pNext; 1852 VkDescriptorSetLayoutCreateFlags flags; 1853 uint32_t bindingCount; 1854 const VkDescriptorSetLayoutBinding* pBindings; 1855} VkDescriptorSetLayoutCreateInfo; 1856 1857typedef struct { 1858 VkDescriptorType type; 1859 uint32_t descriptorCount; 1860} VkDescriptorTypeCount; 1861 1862typedef struct { 1863 VkStructureType sType; 1864 const void* pNext; 1865 VkDescriptorPoolCreateFlags flags; 1866 uint32_t maxSets; 1867 uint32_t typeCount; 1868 const VkDescriptorTypeCount* pTypeCounts; 1869} VkDescriptorPoolCreateInfo; 1870 1871typedef struct { 1872 VkStructureType sType; 1873 const void* pNext; 1874 VkDescriptorPool descriptorPool; 1875 uint32_t setLayoutCount; 1876 const VkDescriptorSetLayout* pSetLayouts; 1877} VkDescriptorSetAllocateInfo; 1878 1879typedef struct { 1880 VkSampler sampler; 1881 VkImageView imageView; 1882 VkImageLayout imageLayout; 1883} VkDescriptorImageInfo; 1884 1885typedef struct { 1886 VkBuffer buffer; 1887 VkDeviceSize offset; 1888 VkDeviceSize range; 1889} VkDescriptorBufferInfo; 1890 1891typedef struct { 1892 VkStructureType sType; 1893 const void* pNext; 1894 VkDescriptorSet dstSet; 1895 uint32_t dstBinding; 1896 uint32_t dstArrayElement; 1897 uint32_t descriptorCount; 1898 VkDescriptorType descriptorType; 1899 const VkDescriptorImageInfo* pImageInfo; 1900 const VkDescriptorBufferInfo* pBufferInfo; 1901 const VkBufferView* pTexelBufferView; 1902} VkWriteDescriptorSet; 1903 1904typedef struct { 1905 VkStructureType sType; 1906 const void* pNext; 1907 VkDescriptorSet srcSet; 1908 uint32_t srcBinding; 1909 uint32_t srcArrayElement; 1910 VkDescriptorSet dstSet; 1911 uint32_t dstBinding; 1912 uint32_t dstArrayElement; 1913 uint32_t descriptorCount; 1914} VkCopyDescriptorSet; 1915 1916typedef struct { 1917 VkStructureType sType; 1918 const void* pNext; 1919 VkFramebufferCreateFlags flags; 1920 VkRenderPass renderPass; 1921 uint32_t attachmentCount; 1922 const VkImageView* pAttachments; 1923 uint32_t width; 1924 uint32_t height; 1925 uint32_t layers; 1926} VkFramebufferCreateInfo; 1927 1928typedef struct { 1929 VkAttachmentDescriptionFlags flags; 1930 VkFormat format; 1931 uint32_t samples; 1932 VkAttachmentLoadOp loadOp; 1933 VkAttachmentStoreOp storeOp; 1934 VkAttachmentLoadOp stencilLoadOp; 1935 VkAttachmentStoreOp stencilStoreOp; 1936 VkImageLayout initialLayout; 1937 VkImageLayout finalLayout; 1938} VkAttachmentDescription; 1939 1940typedef struct { 1941 uint32_t attachment; 1942 VkImageLayout layout; 1943} VkAttachmentReference; 1944 1945typedef struct { 1946 VkSubpassDescriptionFlags flags; 1947 VkPipelineBindPoint pipelineBindPoint; 1948 uint32_t inputAttachmentCount; 1949 const VkAttachmentReference* pInputAttachments; 1950 uint32_t colorAttachmentCount; 1951 const VkAttachmentReference* pColorAttachments; 1952 const VkAttachmentReference* pResolveAttachments; 1953 const VkAttachmentReference* pDepthStencilAttachment; 1954 uint32_t preserveAttachmentCount; 1955 const VkAttachmentReference* pPreserveAttachments; 1956} VkSubpassDescription; 1957 1958typedef struct { 1959 uint32_t srcSubpass; 1960 uint32_t dstSubpass; 1961 VkPipelineStageFlags srcStageMask; 1962 VkPipelineStageFlags dstStageMask; 1963 VkMemoryOutputFlags outputMask; 1964 VkMemoryInputFlags inputMask; 1965 VkDependencyFlags dependencyFlags; 1966} VkSubpassDependency; 1967 1968typedef struct { 1969 VkStructureType sType; 1970 const void* pNext; 1971 VkRenderPassCreateFlags flags; 1972 uint32_t attachmentCount; 1973 const VkAttachmentDescription* pAttachments; 1974 uint32_t subpassCount; 1975 const VkSubpassDescription* pSubpasses; 1976 uint32_t dependencyCount; 1977 const VkSubpassDependency* pDependencies; 1978} VkRenderPassCreateInfo; 1979 1980typedef struct { 1981 VkStructureType sType; 1982 const void* pNext; 1983 VkCommandPoolCreateFlags flags; 1984 uint32_t queueFamilyIndex; 1985} VkCommandPoolCreateInfo; 1986 1987typedef struct { 1988 VkStructureType sType; 1989 const void* pNext; 1990 VkCommandPool commandPool; 1991 VkCommandBufferLevel level; 1992 uint32_t bufferCount; 1993} VkCommandBufferAllocateInfo; 1994 1995typedef struct { 1996 VkStructureType sType; 1997 const void* pNext; 1998 VkCommandBufferUsageFlags flags; 1999 VkRenderPass renderPass; 2000 uint32_t subpass; 2001 VkFramebuffer framebuffer; 2002} VkCommandBufferBeginInfo; 2003 2004typedef struct { 2005 VkDeviceSize srcOffset; 2006 VkDeviceSize dstOffset; 2007 VkDeviceSize size; 2008} VkBufferCopy; 2009 2010typedef struct { 2011 VkImageAspectFlags aspect; 2012 uint32_t mipLevel; 2013 uint32_t baseArrayLayer; 2014 uint32_t layerCount; 2015} VkImageSubresourceCopy; 2016 2017typedef struct { 2018 VkImageSubresourceCopy srcSubresource; 2019 VkOffset3D srcOffset; 2020 VkImageSubresourceCopy dstSubresource; 2021 VkOffset3D dstOffset; 2022 VkExtent3D extent; 2023} VkImageCopy; 2024 2025typedef struct { 2026 VkImageSubresourceCopy srcSubresource; 2027 VkOffset3D srcOffset; 2028 VkExtent3D srcExtent; 2029 VkImageSubresourceCopy dstSubresource; 2030 VkOffset3D dstOffset; 2031 VkExtent3D dstExtent; 2032} VkImageBlit; 2033 2034typedef struct { 2035 VkDeviceSize bufferOffset; 2036 uint32_t bufferRowLength; 2037 uint32_t bufferImageHeight; 2038 VkImageSubresourceCopy imageSubresource; 2039 VkOffset3D imageOffset; 2040 VkExtent3D imageExtent; 2041} VkBufferImageCopy; 2042 2043typedef union { 2044 float float32[4]; 2045 int32_t int32[4]; 2046 uint32_t uint32[4]; 2047} VkClearColorValue; 2048 2049typedef struct { 2050 float depth; 2051 uint32_t stencil; 2052} VkClearDepthStencilValue; 2053 2054typedef union { 2055 VkClearColorValue color; 2056 VkClearDepthStencilValue depthStencil; 2057} VkClearValue; 2058 2059typedef struct { 2060 VkImageAspectFlags aspectMask; 2061 uint32_t colorAttachment; 2062 VkClearValue clearValue; 2063} VkClearAttachment; 2064 2065typedef struct { 2066 VkRect2D rect; 2067 uint32_t baseArrayLayer; 2068 uint32_t layerCount; 2069} VkClearRect; 2070 2071typedef struct { 2072 VkImageSubresourceCopy srcSubresource; 2073 VkOffset3D srcOffset; 2074 VkImageSubresourceCopy dstSubresource; 2075 VkOffset3D dstOffset; 2076 VkExtent3D extent; 2077} VkImageResolve; 2078 2079typedef struct { 2080 VkStructureType sType; 2081 const void* pNext; 2082 VkRenderPass renderPass; 2083 VkFramebuffer framebuffer; 2084 VkRect2D renderArea; 2085 uint32_t clearValueCount; 2086 const VkClearValue* pClearValues; 2087} VkRenderPassBeginInfo; 2088 2089typedef struct { 2090 VkStructureType sType; 2091 const void* pNext; 2092 VkMemoryOutputFlags outputMask; 2093 VkMemoryInputFlags inputMask; 2094 uint32_t srcQueueFamilyIndex; 2095 uint32_t dstQueueFamilyIndex; 2096 VkBuffer buffer; 2097 VkDeviceSize offset; 2098 VkDeviceSize size; 2099} VkBufferMemoryBarrier; 2100 2101typedef struct { 2102 uint32_t x; 2103 uint32_t y; 2104 uint32_t z; 2105} VkDispatchIndirectCommand; 2106 2107typedef struct { 2108 uint32_t indexCount; 2109 uint32_t instanceCount; 2110 uint32_t firstIndex; 2111 int32_t vertexOffset; 2112 uint32_t firstInstance; 2113} VkDrawIndexedIndirectCommand; 2114 2115typedef struct { 2116 uint32_t vertexCount; 2117 uint32_t instanceCount; 2118 uint32_t firstVertex; 2119 uint32_t firstInstance; 2120} VkDrawIndirectCommand; 2121 2122typedef struct { 2123 VkStructureType sType; 2124 const void* pNext; 2125 VkMemoryOutputFlags outputMask; 2126 VkMemoryInputFlags inputMask; 2127 VkImageLayout oldLayout; 2128 VkImageLayout newLayout; 2129 uint32_t srcQueueFamilyIndex; 2130 uint32_t dstQueueFamilyIndex; 2131 VkImage image; 2132 VkImageSubresourceRange subresourceRange; 2133} VkImageMemoryBarrier; 2134 2135typedef struct { 2136 VkStructureType sType; 2137 const void* pNext; 2138 VkMemoryOutputFlags outputMask; 2139 VkMemoryInputFlags inputMask; 2140} VkMemoryBarrier; 2141 2142 2143typedef VkResult (VKAPI *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance); 2144typedef void (VKAPI *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks* pAllocator); 2145typedef VkResult (VKAPI *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); 2146typedef void (VKAPI *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures); 2147typedef void (VKAPI *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties); 2148typedef void (VKAPI *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties); 2149typedef void (VKAPI *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties); 2150typedef void (VKAPI *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties); 2151typedef void (VKAPI *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties); 2152typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName); 2153typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName); 2154typedef VkResult (VKAPI *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice); 2155typedef void (VKAPI *PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks* pAllocator); 2156typedef VkResult (VKAPI *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); 2157typedef VkResult (VKAPI *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); 2158typedef VkResult (VKAPI *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties); 2159typedef VkResult (VKAPI *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties); 2160typedef void (VKAPI *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue); 2161typedef VkResult (VKAPI *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence); 2162typedef VkResult (VKAPI *PFN_vkQueueWaitIdle)(VkQueue queue); 2163typedef VkResult (VKAPI *PFN_vkDeviceWaitIdle)(VkDevice device); 2164typedef VkResult (VKAPI *PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory); 2165typedef void (VKAPI *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator); 2166typedef VkResult (VKAPI *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData); 2167typedef void (VKAPI *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory); 2168typedef VkResult (VKAPI *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); 2169typedef VkResult (VKAPI *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); 2170typedef void (VKAPI *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes); 2171typedef VkResult (VKAPI *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset); 2172typedef VkResult (VKAPI *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset); 2173typedef void (VKAPI *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements); 2174typedef void (VKAPI *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements); 2175typedef void (VKAPI *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements); 2176typedef void (VKAPI *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties); 2177typedef VkResult (VKAPI *PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence); 2178typedef VkResult (VKAPI *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); 2179typedef void (VKAPI *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator); 2180typedef VkResult (VKAPI *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences); 2181typedef VkResult (VKAPI *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence); 2182typedef VkResult (VKAPI *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout); 2183typedef VkResult (VKAPI *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore); 2184typedef void (VKAPI *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator); 2185typedef VkResult (VKAPI *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent); 2186typedef void (VKAPI *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator); 2187typedef VkResult (VKAPI *PFN_vkGetEventStatus)(VkDevice device, VkEvent event); 2188typedef VkResult (VKAPI *PFN_vkSetEvent)(VkDevice device, VkEvent event); 2189typedef VkResult (VKAPI *PFN_vkResetEvent)(VkDevice device, VkEvent event); 2190typedef VkResult (VKAPI *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool); 2191typedef void (VKAPI *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator); 2192typedef VkResult (VKAPI *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags); 2193typedef VkResult (VKAPI *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer); 2194typedef void (VKAPI *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator); 2195typedef VkResult (VKAPI *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView); 2196typedef void (VKAPI *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator); 2197typedef VkResult (VKAPI *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage); 2198typedef void (VKAPI *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator); 2199typedef void (VKAPI *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout); 2200typedef VkResult (VKAPI *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView); 2201typedef void (VKAPI *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator); 2202typedef VkResult (VKAPI *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule); 2203typedef void (VKAPI *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator); 2204typedef VkResult (VKAPI *PFN_vkCreateShader)(VkDevice device, const VkShaderCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShader* pShader); 2205typedef void (VKAPI *PFN_vkDestroyShader)(VkDevice device, VkShader shader, const VkAllocationCallbacks* pAllocator); 2206typedef VkResult (VKAPI *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache); 2207typedef void (VKAPI *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator); 2208typedef VkResult (VKAPI *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData); 2209typedef VkResult (VKAPI *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches); 2210typedef VkResult (VKAPI *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); 2211typedef VkResult (VKAPI *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); 2212typedef void (VKAPI *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator); 2213typedef VkResult (VKAPI *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout); 2214typedef void (VKAPI *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator); 2215typedef VkResult (VKAPI *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler); 2216typedef void (VKAPI *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator); 2217typedef VkResult (VKAPI *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout); 2218typedef void (VKAPI *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator); 2219typedef VkResult (VKAPI *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool); 2220typedef void (VKAPI *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator); 2221typedef VkResult (VKAPI *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags); 2222typedef VkResult (VKAPI *PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets); 2223typedef VkResult (VKAPI *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets); 2224typedef void (VKAPI *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies); 2225typedef VkResult (VKAPI *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer); 2226typedef void (VKAPI *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator); 2227typedef VkResult (VKAPI *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); 2228typedef void (VKAPI *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator); 2229typedef void (VKAPI *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity); 2230typedef VkResult (VKAPI *PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool); 2231typedef void (VKAPI *PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool CommandPool, const VkAllocationCallbacks* pAllocator); 2232typedef VkResult (VKAPI *PFN_vkResetCommandPool)(VkDevice device, VkCommandPool CommandPool, VkCommandPoolResetFlags flags); 2233typedef VkResult (VKAPI *PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers); 2234typedef void (VKAPI *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool CommandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); 2235typedef VkResult (VKAPI *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo); 2236typedef VkResult (VKAPI *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer); 2237typedef VkResult (VKAPI *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags); 2238typedef void (VKAPI *PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); 2239typedef void (VKAPI *PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports); 2240typedef void (VKAPI *PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors); 2241typedef void (VKAPI *PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth); 2242typedef void (VKAPI *PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor); 2243typedef void (VKAPI *PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4]); 2244typedef void (VKAPI *PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds); 2245typedef void (VKAPI *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask); 2246typedef void (VKAPI *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask); 2247typedef void (VKAPI *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference); 2248typedef void (VKAPI *PFN_vkCmdBindDescriptorSets)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets); 2249typedef void (VKAPI *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); 2250typedef void (VKAPI *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets); 2251typedef void (VKAPI *PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance); 2252typedef void (VKAPI *PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance); 2253typedef void (VKAPI *PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); 2254typedef void (VKAPI *PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); 2255typedef void (VKAPI *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z); 2256typedef void (VKAPI *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); 2257typedef void (VKAPI *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions); 2258typedef void (VKAPI *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions); 2259typedef void (VKAPI *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter); 2260typedef void (VKAPI *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions); 2261typedef void (VKAPI *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions); 2262typedef void (VKAPI *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint32_t* pData); 2263typedef void (VKAPI *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data); 2264typedef void (VKAPI *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); 2265typedef void (VKAPI *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); 2266typedef void (VKAPI *PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects); 2267typedef void (VKAPI *PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions); 2268typedef void (VKAPI *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); 2269typedef void (VKAPI *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); 2270typedef void (VKAPI *PFN_vkCmdWaitEvents)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers); 2271typedef void (VKAPI *PFN_vkCmdPipelineBarrier)(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers); 2272typedef void (VKAPI *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags); 2273typedef void (VKAPI *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot); 2274typedef void (VKAPI *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount); 2275typedef void (VKAPI *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot); 2276typedef void (VKAPI *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags); 2277typedef void (VKAPI *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* values); 2278typedef void (VKAPI *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents); 2279typedef void (VKAPI *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkRenderPassContents contents); 2280typedef void (VKAPI *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer); 2281typedef void (VKAPI *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount, const VkCommandBuffer* pCommandBuffers); 2282 2283#ifdef VK_PROTOTYPES 2284VkResult VKAPI vkCreateInstance( 2285 const VkInstanceCreateInfo* pCreateInfo, 2286 const VkAllocationCallbacks* pAllocator, 2287 VkInstance* pInstance); 2288 2289void VKAPI vkDestroyInstance( 2290 VkInstance instance, 2291 const VkAllocationCallbacks* pAllocator); 2292 2293VkResult VKAPI vkEnumeratePhysicalDevices( 2294 VkInstance instance, 2295 uint32_t* pPhysicalDeviceCount, 2296 VkPhysicalDevice* pPhysicalDevices); 2297 2298void VKAPI vkGetPhysicalDeviceFeatures( 2299 VkPhysicalDevice physicalDevice, 2300 VkPhysicalDeviceFeatures* pFeatures); 2301 2302void VKAPI vkGetPhysicalDeviceFormatProperties( 2303 VkPhysicalDevice physicalDevice, 2304 VkFormat format, 2305 VkFormatProperties* pFormatProperties); 2306 2307void VKAPI vkGetPhysicalDeviceImageFormatProperties( 2308 VkPhysicalDevice physicalDevice, 2309 VkFormat format, 2310 VkImageType type, 2311 VkImageTiling tiling, 2312 VkImageUsageFlags usage, 2313 VkImageCreateFlags flags, 2314 VkImageFormatProperties* pImageFormatProperties); 2315 2316void VKAPI vkGetPhysicalDeviceProperties( 2317 VkPhysicalDevice physicalDevice, 2318 VkPhysicalDeviceProperties* pProperties); 2319 2320void VKAPI vkGetPhysicalDeviceQueueFamilyProperties( 2321 VkPhysicalDevice physicalDevice, 2322 uint32_t* pQueueFamilyPropertyCount, 2323 VkQueueFamilyProperties* pQueueFamilyProperties); 2324 2325void VKAPI vkGetPhysicalDeviceMemoryProperties( 2326 VkPhysicalDevice physicalDevice, 2327 VkPhysicalDeviceMemoryProperties* pMemoryProperties); 2328 2329PFN_vkVoidFunction VKAPI vkGetInstanceProcAddr( 2330 VkInstance instance, 2331 const char* pName); 2332 2333PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr( 2334 VkDevice device, 2335 const char* pName); 2336 2337VkResult VKAPI vkCreateDevice( 2338 VkPhysicalDevice physicalDevice, 2339 const VkDeviceCreateInfo* pCreateInfo, 2340 const VkAllocationCallbacks* pAllocator, 2341 VkDevice* pDevice); 2342 2343void VKAPI vkDestroyDevice( 2344 VkDevice device, 2345 const VkAllocationCallbacks* pAllocator); 2346 2347VkResult VKAPI vkEnumerateInstanceExtensionProperties( 2348 const char* pLayerName, 2349 uint32_t* pPropertyCount, 2350 VkExtensionProperties* pProperties); 2351 2352VkResult VKAPI vkEnumerateDeviceExtensionProperties( 2353 VkPhysicalDevice physicalDevice, 2354 const char* pLayerName, 2355 uint32_t* pPropertyCount, 2356 VkExtensionProperties* pProperties); 2357 2358VkResult VKAPI vkEnumerateInstanceLayerProperties( 2359 uint32_t* pPropertyCount, 2360 VkLayerProperties* pProperties); 2361 2362VkResult VKAPI vkEnumerateDeviceLayerProperties( 2363 VkPhysicalDevice physicalDevice, 2364 uint32_t* pPropertyCount, 2365 VkLayerProperties* pProperties); 2366 2367void VKAPI vkGetDeviceQueue( 2368 VkDevice device, 2369 uint32_t queueFamilyIndex, 2370 uint32_t queueIndex, 2371 VkQueue* pQueue); 2372 2373VkResult VKAPI vkQueueSubmit( 2374 VkQueue queue, 2375 uint32_t submitCount, 2376 const VkSubmitInfo* pSubmits, 2377 VkFence fence); 2378 2379VkResult VKAPI vkQueueWaitIdle( 2380 VkQueue queue); 2381 2382VkResult VKAPI vkDeviceWaitIdle( 2383 VkDevice device); 2384 2385VkResult VKAPI vkAllocateMemory( 2386 VkDevice device, 2387 const VkMemoryAllocateInfo* pAllocateInfo, 2388 const VkAllocationCallbacks* pAllocator, 2389 VkDeviceMemory* pMemory); 2390 2391void VKAPI vkFreeMemory( 2392 VkDevice device, 2393 VkDeviceMemory memory, 2394 const VkAllocationCallbacks* pAllocator); 2395 2396VkResult VKAPI vkMapMemory( 2397 VkDevice device, 2398 VkDeviceMemory memory, 2399 VkDeviceSize offset, 2400 VkDeviceSize size, 2401 VkMemoryMapFlags flags, 2402 void** ppData); 2403 2404void VKAPI vkUnmapMemory( 2405 VkDevice device, 2406 VkDeviceMemory memory); 2407 2408VkResult VKAPI vkFlushMappedMemoryRanges( 2409 VkDevice device, 2410 uint32_t memoryRangeCount, 2411 const VkMappedMemoryRange* pMemoryRanges); 2412 2413VkResult VKAPI vkInvalidateMappedMemoryRanges( 2414 VkDevice device, 2415 uint32_t memoryRangeCount, 2416 const VkMappedMemoryRange* pMemoryRanges); 2417 2418void VKAPI vkGetDeviceMemoryCommitment( 2419 VkDevice device, 2420 VkDeviceMemory memory, 2421 VkDeviceSize* pCommittedMemoryInBytes); 2422 2423VkResult VKAPI vkBindBufferMemory( 2424 VkDevice device, 2425 VkBuffer buffer, 2426 VkDeviceMemory memory, 2427 VkDeviceSize memoryOffset); 2428 2429VkResult VKAPI vkBindImageMemory( 2430 VkDevice device, 2431 VkImage image, 2432 VkDeviceMemory memory, 2433 VkDeviceSize memoryOffset); 2434 2435void VKAPI vkGetBufferMemoryRequirements( 2436 VkDevice device, 2437 VkBuffer buffer, 2438 VkMemoryRequirements* pMemoryRequirements); 2439 2440void VKAPI vkGetImageMemoryRequirements( 2441 VkDevice device, 2442 VkImage image, 2443 VkMemoryRequirements* pMemoryRequirements); 2444 2445void VKAPI vkGetImageSparseMemoryRequirements( 2446 VkDevice device, 2447 VkImage image, 2448 uint32_t* pSparseMemoryRequirementCount, 2449 VkSparseImageMemoryRequirements* pSparseMemoryRequirements); 2450 2451void VKAPI vkGetPhysicalDeviceSparseImageFormatProperties( 2452 VkPhysicalDevice physicalDevice, 2453 VkFormat format, 2454 VkImageType type, 2455 uint32_t samples, 2456 VkImageUsageFlags usage, 2457 VkImageTiling tiling, 2458 uint32_t* pPropertyCount, 2459 VkSparseImageFormatProperties* pProperties); 2460 2461VkResult VKAPI vkQueueBindSparse( 2462 VkQueue queue, 2463 uint32_t bindInfoCount, 2464 const VkBindSparseInfo* pBindInfo, 2465 VkFence fence); 2466 2467VkResult VKAPI vkCreateFence( 2468 VkDevice device, 2469 const VkFenceCreateInfo* pCreateInfo, 2470 const VkAllocationCallbacks* pAllocator, 2471 VkFence* pFence); 2472 2473void VKAPI vkDestroyFence( 2474 VkDevice device, 2475 VkFence fence, 2476 const VkAllocationCallbacks* pAllocator); 2477 2478VkResult VKAPI vkResetFences( 2479 VkDevice device, 2480 uint32_t fenceCount, 2481 const VkFence* pFences); 2482 2483VkResult VKAPI vkGetFenceStatus( 2484 VkDevice device, 2485 VkFence fence); 2486 2487VkResult VKAPI vkWaitForFences( 2488 VkDevice device, 2489 uint32_t fenceCount, 2490 const VkFence* pFences, 2491 VkBool32 waitAll, 2492 uint64_t timeout); 2493 2494VkResult VKAPI vkCreateSemaphore( 2495 VkDevice device, 2496 const VkSemaphoreCreateInfo* pCreateInfo, 2497 const VkAllocationCallbacks* pAllocator, 2498 VkSemaphore* pSemaphore); 2499 2500void VKAPI vkDestroySemaphore( 2501 VkDevice device, 2502 VkSemaphore semaphore, 2503 const VkAllocationCallbacks* pAllocator); 2504 2505VkResult VKAPI vkCreateEvent( 2506 VkDevice device, 2507 const VkEventCreateInfo* pCreateInfo, 2508 const VkAllocationCallbacks* pAllocator, 2509 VkEvent* pEvent); 2510 2511void VKAPI vkDestroyEvent( 2512 VkDevice device, 2513 VkEvent event, 2514 const VkAllocationCallbacks* pAllocator); 2515 2516VkResult VKAPI vkGetEventStatus( 2517 VkDevice device, 2518 VkEvent event); 2519 2520VkResult VKAPI vkSetEvent( 2521 VkDevice device, 2522 VkEvent event); 2523 2524VkResult VKAPI vkResetEvent( 2525 VkDevice device, 2526 VkEvent event); 2527 2528VkResult VKAPI vkCreateQueryPool( 2529 VkDevice device, 2530 const VkQueryPoolCreateInfo* pCreateInfo, 2531 const VkAllocationCallbacks* pAllocator, 2532 VkQueryPool* pQueryPool); 2533 2534void VKAPI vkDestroyQueryPool( 2535 VkDevice device, 2536 VkQueryPool queryPool, 2537 const VkAllocationCallbacks* pAllocator); 2538 2539VkResult VKAPI vkGetQueryPoolResults( 2540 VkDevice device, 2541 VkQueryPool queryPool, 2542 uint32_t startQuery, 2543 uint32_t queryCount, 2544 size_t dataSize, 2545 void* pData, 2546 VkDeviceSize stride, 2547 VkQueryResultFlags flags); 2548 2549VkResult VKAPI vkCreateBuffer( 2550 VkDevice device, 2551 const VkBufferCreateInfo* pCreateInfo, 2552 const VkAllocationCallbacks* pAllocator, 2553 VkBuffer* pBuffer); 2554 2555void VKAPI vkDestroyBuffer( 2556 VkDevice device, 2557 VkBuffer buffer, 2558 const VkAllocationCallbacks* pAllocator); 2559 2560VkResult VKAPI vkCreateBufferView( 2561 VkDevice device, 2562 const VkBufferViewCreateInfo* pCreateInfo, 2563 const VkAllocationCallbacks* pAllocator, 2564 VkBufferView* pView); 2565 2566void VKAPI vkDestroyBufferView( 2567 VkDevice device, 2568 VkBufferView bufferView, 2569 const VkAllocationCallbacks* pAllocator); 2570 2571VkResult VKAPI vkCreateImage( 2572 VkDevice device, 2573 const VkImageCreateInfo* pCreateInfo, 2574 const VkAllocationCallbacks* pAllocator, 2575 VkImage* pImage); 2576 2577void VKAPI vkDestroyImage( 2578 VkDevice device, 2579 VkImage image, 2580 const VkAllocationCallbacks* pAllocator); 2581 2582void VKAPI vkGetImageSubresourceLayout( 2583 VkDevice device, 2584 VkImage image, 2585 const VkImageSubresource* pSubresource, 2586 VkSubresourceLayout* pLayout); 2587 2588VkResult VKAPI vkCreateImageView( 2589 VkDevice device, 2590 const VkImageViewCreateInfo* pCreateInfo, 2591 const VkAllocationCallbacks* pAllocator, 2592 VkImageView* pView); 2593 2594void VKAPI vkDestroyImageView( 2595 VkDevice device, 2596 VkImageView imageView, 2597 const VkAllocationCallbacks* pAllocator); 2598 2599VkResult VKAPI vkCreateShaderModule( 2600 VkDevice device, 2601 const VkShaderModuleCreateInfo* pCreateInfo, 2602 const VkAllocationCallbacks* pAllocator, 2603 VkShaderModule* pShaderModule); 2604 2605void VKAPI vkDestroyShaderModule( 2606 VkDevice device, 2607 VkShaderModule shaderModule, 2608 const VkAllocationCallbacks* pAllocator); 2609 2610VkResult VKAPI vkCreateShader( 2611 VkDevice device, 2612 const VkShaderCreateInfo* pCreateInfo, 2613 const VkAllocationCallbacks* pAllocator, 2614 VkShader* pShader); 2615 2616void VKAPI vkDestroyShader( 2617 VkDevice device, 2618 VkShader shader, 2619 const VkAllocationCallbacks* pAllocator); 2620 2621VkResult VKAPI vkCreatePipelineCache( 2622 VkDevice device, 2623 const VkPipelineCacheCreateInfo* pCreateInfo, 2624 const VkAllocationCallbacks* pAllocator, 2625 VkPipelineCache* pPipelineCache); 2626 2627void VKAPI vkDestroyPipelineCache( 2628 VkDevice device, 2629 VkPipelineCache pipelineCache, 2630 const VkAllocationCallbacks* pAllocator); 2631 2632VkResult VKAPI vkGetPipelineCacheData( 2633 VkDevice device, 2634 VkPipelineCache pipelineCache, 2635 size_t* pDataSize, 2636 void* pData); 2637 2638VkResult VKAPI vkMergePipelineCaches( 2639 VkDevice device, 2640 VkPipelineCache dstCache, 2641 uint32_t srcCacheCount, 2642 const VkPipelineCache* pSrcCaches); 2643 2644VkResult VKAPI vkCreateGraphicsPipelines( 2645 VkDevice device, 2646 VkPipelineCache pipelineCache, 2647 uint32_t createInfoCount, 2648 const VkGraphicsPipelineCreateInfo* pCreateInfos, 2649 const VkAllocationCallbacks* pAllocator, 2650 VkPipeline* pPipelines); 2651 2652VkResult VKAPI vkCreateComputePipelines( 2653 VkDevice device, 2654 VkPipelineCache pipelineCache, 2655 uint32_t createInfoCount, 2656 const VkComputePipelineCreateInfo* pCreateInfos, 2657 const VkAllocationCallbacks* pAllocator, 2658 VkPipeline* pPipelines); 2659 2660void VKAPI vkDestroyPipeline( 2661 VkDevice device, 2662 VkPipeline pipeline, 2663 const VkAllocationCallbacks* pAllocator); 2664 2665VkResult VKAPI vkCreatePipelineLayout( 2666 VkDevice device, 2667 const VkPipelineLayoutCreateInfo* pCreateInfo, 2668 const VkAllocationCallbacks* pAllocator, 2669 VkPipelineLayout* pPipelineLayout); 2670 2671void VKAPI vkDestroyPipelineLayout( 2672 VkDevice device, 2673 VkPipelineLayout pipelineLayout, 2674 const VkAllocationCallbacks* pAllocator); 2675 2676VkResult VKAPI vkCreateSampler( 2677 VkDevice device, 2678 const VkSamplerCreateInfo* pCreateInfo, 2679 const VkAllocationCallbacks* pAllocator, 2680 VkSampler* pSampler); 2681 2682void VKAPI vkDestroySampler( 2683 VkDevice device, 2684 VkSampler sampler, 2685 const VkAllocationCallbacks* pAllocator); 2686 2687VkResult VKAPI vkCreateDescriptorSetLayout( 2688 VkDevice device, 2689 const VkDescriptorSetLayoutCreateInfo* pCreateInfo, 2690 const VkAllocationCallbacks* pAllocator, 2691 VkDescriptorSetLayout* pSetLayout); 2692 2693void VKAPI vkDestroyDescriptorSetLayout( 2694 VkDevice device, 2695 VkDescriptorSetLayout descriptorSetLayout, 2696 const VkAllocationCallbacks* pAllocator); 2697 2698VkResult VKAPI vkCreateDescriptorPool( 2699 VkDevice device, 2700 const VkDescriptorPoolCreateInfo* pCreateInfo, 2701 const VkAllocationCallbacks* pAllocator, 2702 VkDescriptorPool* pDescriptorPool); 2703 2704void VKAPI vkDestroyDescriptorPool( 2705 VkDevice device, 2706 VkDescriptorPool descriptorPool, 2707 const VkAllocationCallbacks* pAllocator); 2708 2709VkResult VKAPI vkResetDescriptorPool( 2710 VkDevice device, 2711 VkDescriptorPool descriptorPool, 2712 VkDescriptorPoolResetFlags flags); 2713 2714VkResult VKAPI vkAllocateDescriptorSets( 2715 VkDevice device, 2716 const VkDescriptorSetAllocateInfo* pAllocateInfo, 2717 VkDescriptorSet* pDescriptorSets); 2718 2719VkResult VKAPI vkFreeDescriptorSets( 2720 VkDevice device, 2721 VkDescriptorPool descriptorPool, 2722 uint32_t descriptorSetCount, 2723 const VkDescriptorSet* pDescriptorSets); 2724 2725void VKAPI vkUpdateDescriptorSets( 2726 VkDevice device, 2727 uint32_t descriptorWriteCount, 2728 const VkWriteDescriptorSet* pDescriptorWrites, 2729 uint32_t descriptorCopyCount, 2730 const VkCopyDescriptorSet* pDescriptorCopies); 2731 2732VkResult VKAPI vkCreateFramebuffer( 2733 VkDevice device, 2734 const VkFramebufferCreateInfo* pCreateInfo, 2735 const VkAllocationCallbacks* pAllocator, 2736 VkFramebuffer* pFramebuffer); 2737 2738void VKAPI vkDestroyFramebuffer( 2739 VkDevice device, 2740 VkFramebuffer framebuffer, 2741 const VkAllocationCallbacks* pAllocator); 2742 2743VkResult VKAPI vkCreateRenderPass( 2744 VkDevice device, 2745 const VkRenderPassCreateInfo* pCreateInfo, 2746 const VkAllocationCallbacks* pAllocator, 2747 VkRenderPass* pRenderPass); 2748 2749void VKAPI vkDestroyRenderPass( 2750 VkDevice device, 2751 VkRenderPass renderPass, 2752 const VkAllocationCallbacks* pAllocator); 2753 2754void VKAPI vkGetRenderAreaGranularity( 2755 VkDevice device, 2756 VkRenderPass renderPass, 2757 VkExtent2D* pGranularity); 2758 2759VkResult VKAPI vkCreateCommandPool( 2760 VkDevice device, 2761 const VkCommandPoolCreateInfo* pCreateInfo, 2762 const VkAllocationCallbacks* pAllocator, 2763 VkCommandPool* pCommandPool); 2764 2765void VKAPI vkDestroyCommandPool( 2766 VkDevice device, 2767 VkCommandPool CommandPool, 2768 const VkAllocationCallbacks* pAllocator); 2769 2770VkResult VKAPI vkResetCommandPool( 2771 VkDevice device, 2772 VkCommandPool CommandPool, 2773 VkCommandPoolResetFlags flags); 2774 2775VkResult VKAPI vkAllocateCommandBuffers( 2776 VkDevice device, 2777 const VkCommandBufferAllocateInfo* pAllocateInfo, 2778 VkCommandBuffer* pCommandBuffers); 2779 2780void VKAPI vkFreeCommandBuffers( 2781 VkDevice device, 2782 VkCommandPool CommandPool, 2783 uint32_t commandBufferCount, 2784 const VkCommandBuffer* pCommandBuffers); 2785 2786VkResult VKAPI vkBeginCommandBuffer( 2787 VkCommandBuffer commandBuffer, 2788 const VkCommandBufferBeginInfo* pBeginInfo); 2789 2790VkResult VKAPI vkEndCommandBuffer( 2791 VkCommandBuffer commandBuffer); 2792 2793VkResult VKAPI vkResetCommandBuffer( 2794 VkCommandBuffer commandBuffer, 2795 VkCommandBufferResetFlags flags); 2796 2797void VKAPI vkCmdBindPipeline( 2798 VkCommandBuffer commandBuffer, 2799 VkPipelineBindPoint pipelineBindPoint, 2800 VkPipeline pipeline); 2801 2802void VKAPI vkCmdSetViewport( 2803 VkCommandBuffer commandBuffer, 2804 uint32_t viewportCount, 2805 const VkViewport* pViewports); 2806 2807void VKAPI vkCmdSetScissor( 2808 VkCommandBuffer commandBuffer, 2809 uint32_t scissorCount, 2810 const VkRect2D* pScissors); 2811 2812void VKAPI vkCmdSetLineWidth( 2813 VkCommandBuffer commandBuffer, 2814 float lineWidth); 2815 2816void VKAPI vkCmdSetDepthBias( 2817 VkCommandBuffer commandBuffer, 2818 float depthBiasConstantFactor, 2819 float depthBiasClamp, 2820 float depthBiasSlopeFactor); 2821 2822void VKAPI vkCmdSetBlendConstants( 2823 VkCommandBuffer commandBuffer, 2824 const float blendConstants[4]); 2825 2826void VKAPI vkCmdSetDepthBounds( 2827 VkCommandBuffer commandBuffer, 2828 float minDepthBounds, 2829 float maxDepthBounds); 2830 2831void VKAPI vkCmdSetStencilCompareMask( 2832 VkCommandBuffer commandBuffer, 2833 VkStencilFaceFlags faceMask, 2834 uint32_t stencilCompareMask); 2835 2836void VKAPI vkCmdSetStencilWriteMask( 2837 VkCommandBuffer commandBuffer, 2838 VkStencilFaceFlags faceMask, 2839 uint32_t stencilWriteMask); 2840 2841void VKAPI vkCmdSetStencilReference( 2842 VkCommandBuffer commandBuffer, 2843 VkStencilFaceFlags faceMask, 2844 uint32_t stencilReference); 2845 2846void VKAPI vkCmdBindDescriptorSets( 2847 VkCommandBuffer commandBuffer, 2848 VkPipelineBindPoint pipelineBindPoint, 2849 VkPipelineLayout layout, 2850 uint32_t firstSet, 2851 uint32_t descriptorSetCount, 2852 const VkDescriptorSet* pDescriptorSets, 2853 uint32_t dynamicOffsetCount, 2854 const uint32_t* pDynamicOffsets); 2855 2856void VKAPI vkCmdBindIndexBuffer( 2857 VkCommandBuffer commandBuffer, 2858 VkBuffer buffer, 2859 VkDeviceSize offset, 2860 VkIndexType indexType); 2861 2862void VKAPI vkCmdBindVertexBuffers( 2863 VkCommandBuffer commandBuffer, 2864 uint32_t startBinding, 2865 uint32_t bindingCount, 2866 const VkBuffer* pBuffers, 2867 const VkDeviceSize* pOffsets); 2868 2869void VKAPI vkCmdDraw( 2870 VkCommandBuffer commandBuffer, 2871 uint32_t vertexCount, 2872 uint32_t instanceCount, 2873 uint32_t firstVertex, 2874 uint32_t firstInstance); 2875 2876void VKAPI vkCmdDrawIndexed( 2877 VkCommandBuffer commandBuffer, 2878 uint32_t indexCount, 2879 uint32_t instanceCount, 2880 uint32_t firstIndex, 2881 int32_t vertexOffset, 2882 uint32_t firstInstance); 2883 2884void VKAPI vkCmdDrawIndirect( 2885 VkCommandBuffer commandBuffer, 2886 VkBuffer buffer, 2887 VkDeviceSize offset, 2888 uint32_t drawCount, 2889 uint32_t stride); 2890 2891void VKAPI vkCmdDrawIndexedIndirect( 2892 VkCommandBuffer commandBuffer, 2893 VkBuffer buffer, 2894 VkDeviceSize offset, 2895 uint32_t drawCount, 2896 uint32_t stride); 2897 2898void VKAPI vkCmdDispatch( 2899 VkCommandBuffer commandBuffer, 2900 uint32_t x, 2901 uint32_t y, 2902 uint32_t z); 2903 2904void VKAPI vkCmdDispatchIndirect( 2905 VkCommandBuffer commandBuffer, 2906 VkBuffer buffer, 2907 VkDeviceSize offset); 2908 2909void VKAPI vkCmdCopyBuffer( 2910 VkCommandBuffer commandBuffer, 2911 VkBuffer srcBuffer, 2912 VkBuffer dstBuffer, 2913 uint32_t regionCount, 2914 const VkBufferCopy* pRegions); 2915 2916void VKAPI vkCmdCopyImage( 2917 VkCommandBuffer commandBuffer, 2918 VkImage srcImage, 2919 VkImageLayout srcImageLayout, 2920 VkImage dstImage, 2921 VkImageLayout dstImageLayout, 2922 uint32_t regionCount, 2923 const VkImageCopy* pRegions); 2924 2925void VKAPI vkCmdBlitImage( 2926 VkCommandBuffer commandBuffer, 2927 VkImage srcImage, 2928 VkImageLayout srcImageLayout, 2929 VkImage dstImage, 2930 VkImageLayout dstImageLayout, 2931 uint32_t regionCount, 2932 const VkImageBlit* pRegions, 2933 VkFilter filter); 2934 2935void VKAPI vkCmdCopyBufferToImage( 2936 VkCommandBuffer commandBuffer, 2937 VkBuffer srcBuffer, 2938 VkImage dstImage, 2939 VkImageLayout dstImageLayout, 2940 uint32_t regionCount, 2941 const VkBufferImageCopy* pRegions); 2942 2943void VKAPI vkCmdCopyImageToBuffer( 2944 VkCommandBuffer commandBuffer, 2945 VkImage srcImage, 2946 VkImageLayout srcImageLayout, 2947 VkBuffer dstBuffer, 2948 uint32_t regionCount, 2949 const VkBufferImageCopy* pRegions); 2950 2951void VKAPI vkCmdUpdateBuffer( 2952 VkCommandBuffer commandBuffer, 2953 VkBuffer dstBuffer, 2954 VkDeviceSize dstOffset, 2955 VkDeviceSize dataSize, 2956 const uint32_t* pData); 2957 2958void VKAPI vkCmdFillBuffer( 2959 VkCommandBuffer commandBuffer, 2960 VkBuffer dstBuffer, 2961 VkDeviceSize dstOffset, 2962 VkDeviceSize size, 2963 uint32_t data); 2964 2965void VKAPI vkCmdClearColorImage( 2966 VkCommandBuffer commandBuffer, 2967 VkImage image, 2968 VkImageLayout imageLayout, 2969 const VkClearColorValue* pColor, 2970 uint32_t rangeCount, 2971 const VkImageSubresourceRange* pRanges); 2972 2973void VKAPI vkCmdClearDepthStencilImage( 2974 VkCommandBuffer commandBuffer, 2975 VkImage image, 2976 VkImageLayout imageLayout, 2977 const VkClearDepthStencilValue* pDepthStencil, 2978 uint32_t rangeCount, 2979 const VkImageSubresourceRange* pRanges); 2980 2981void VKAPI vkCmdClearAttachments( 2982 VkCommandBuffer commandBuffer, 2983 uint32_t attachmentCount, 2984 const VkClearAttachment* pAttachments, 2985 uint32_t rectCount, 2986 const VkClearRect* pRects); 2987 2988void VKAPI vkCmdResolveImage( 2989 VkCommandBuffer commandBuffer, 2990 VkImage srcImage, 2991 VkImageLayout srcImageLayout, 2992 VkImage dstImage, 2993 VkImageLayout dstImageLayout, 2994 uint32_t regionCount, 2995 const VkImageResolve* pRegions); 2996 2997void VKAPI vkCmdSetEvent( 2998 VkCommandBuffer commandBuffer, 2999 VkEvent event, 3000 VkPipelineStageFlags stageMask); 3001 3002void VKAPI vkCmdResetEvent( 3003 VkCommandBuffer commandBuffer, 3004 VkEvent event, 3005 VkPipelineStageFlags stageMask); 3006 3007void VKAPI vkCmdWaitEvents( 3008 VkCommandBuffer commandBuffer, 3009 uint32_t eventCount, 3010 const VkEvent* pEvents, 3011 VkPipelineStageFlags srcStageMask, 3012 VkPipelineStageFlags dstStageMask, 3013 uint32_t memoryBarrierCount, 3014 const void* const* ppMemoryBarriers); 3015 3016void VKAPI vkCmdPipelineBarrier( 3017 VkCommandBuffer commandBuffer, 3018 VkPipelineStageFlags srcStageMask, 3019 VkPipelineStageFlags dstStageMask, 3020 VkDependencyFlags dependencyFlags, 3021 uint32_t memoryBarrierCount, 3022 const void* const* ppMemoryBarriers); 3023 3024void VKAPI vkCmdBeginQuery( 3025 VkCommandBuffer commandBuffer, 3026 VkQueryPool queryPool, 3027 uint32_t slot, 3028 VkQueryControlFlags flags); 3029 3030void VKAPI vkCmdEndQuery( 3031 VkCommandBuffer commandBuffer, 3032 VkQueryPool queryPool, 3033 uint32_t slot); 3034 3035void VKAPI vkCmdResetQueryPool( 3036 VkCommandBuffer commandBuffer, 3037 VkQueryPool queryPool, 3038 uint32_t startQuery, 3039 uint32_t queryCount); 3040 3041void VKAPI vkCmdWriteTimestamp( 3042 VkCommandBuffer commandBuffer, 3043 VkPipelineStageFlagBits pipelineStage, 3044 VkQueryPool queryPool, 3045 uint32_t slot); 3046 3047void VKAPI vkCmdCopyQueryPoolResults( 3048 VkCommandBuffer commandBuffer, 3049 VkQueryPool queryPool, 3050 uint32_t startQuery, 3051 uint32_t queryCount, 3052 VkBuffer dstBuffer, 3053 VkDeviceSize dstOffset, 3054 VkDeviceSize stride, 3055 VkQueryResultFlags flags); 3056 3057void VKAPI vkCmdPushConstants( 3058 VkCommandBuffer commandBuffer, 3059 VkPipelineLayout layout, 3060 VkShaderStageFlags stageFlags, 3061 uint32_t offset, 3062 uint32_t size, 3063 const void* values); 3064 3065void VKAPI vkCmdBeginRenderPass( 3066 VkCommandBuffer commandBuffer, 3067 const VkRenderPassBeginInfo* pRenderPassBegin, 3068 VkRenderPassContents contents); 3069 3070void VKAPI vkCmdNextSubpass( 3071 VkCommandBuffer commandBuffer, 3072 VkRenderPassContents contents); 3073 3074void VKAPI vkCmdEndRenderPass( 3075 VkCommandBuffer commandBuffer); 3076 3077void VKAPI vkCmdExecuteCommands( 3078 VkCommandBuffer commandBuffer, 3079 uint32_t commandBuffersCount, 3080 const VkCommandBuffer* pCommandBuffers); 3081#endif 3082 3083#define vk_ext_khr_surface 1 3084VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR) 3085 3086#define VK_EXT_KHR_SURFACE_REVISION 20 3087#define VK_EXT_KHR_SURFACE_EXTENSION_NUMBER 1 3088#define VK_EXT_KHR_SURFACE_EXTENSION_NAME "VK_EXT_KHR_surface" 3089#define VK_ERROR_SURFACE_LOST_KHR ((VkResult)(int)0xc0000400) 3090 3091 3092typedef enum { 3093 VK_SURFACE_TRANSFORM_NONE_KHR = 0, 3094 VK_SURFACE_TRANSFORM_ROT90_KHR = 1, 3095 VK_SURFACE_TRANSFORM_ROT180_KHR = 2, 3096 VK_SURFACE_TRANSFORM_ROT270_KHR = 3, 3097 VK_SURFACE_TRANSFORM_HMIRROR_KHR = 4, 3098 VK_SURFACE_TRANSFORM_HMIRROR_ROT90_KHR = 5, 3099 VK_SURFACE_TRANSFORM_HMIRROR_ROT180_KHR = 6, 3100 VK_SURFACE_TRANSFORM_HMIRROR_ROT270_KHR = 7, 3101 VK_SURFACE_TRANSFORM_INHERIT_KHR = 8, 3102 VK_SURFACE_TRANSFORM_BEGIN_RANGE = VK_SURFACE_TRANSFORM_NONE_KHR, 3103 VK_SURFACE_TRANSFORM_END_RANGE = VK_SURFACE_TRANSFORM_INHERIT_KHR, 3104 VK_SURFACE_TRANSFORM_RANGE_SIZE = (VK_SURFACE_TRANSFORM_INHERIT_KHR - VK_SURFACE_TRANSFORM_NONE_KHR + 1), 3105 VK_SURFACE_TRANSFORM_MAX_ENUM = 0x7FFFFFFF 3106} VkSurfaceTransformKHR; 3107 3108typedef enum { 3109 VK_COLORSPACE_SRGB_NONLINEAR_KHR = 0, 3110 VK_COLORSPACE_BEGIN_RANGE = VK_COLORSPACE_SRGB_NONLINEAR_KHR, 3111 VK_COLORSPACE_END_RANGE = VK_COLORSPACE_SRGB_NONLINEAR_KHR, 3112 VK_COLORSPACE_RANGE_SIZE = (VK_COLORSPACE_SRGB_NONLINEAR_KHR - VK_COLORSPACE_SRGB_NONLINEAR_KHR + 1), 3113 VK_COLORSPACE_MAX_ENUM = 0x7FFFFFFF 3114} VkColorSpaceKHR; 3115 3116typedef enum { 3117 VK_PRESENT_MODE_IMMEDIATE_KHR = 0, 3118 VK_PRESENT_MODE_MAILBOX_KHR = 1, 3119 VK_PRESENT_MODE_FIFO_KHR = 2, 3120 VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3, 3121 VK_PRESENT_MODE_BEGIN_RANGE = VK_PRESENT_MODE_IMMEDIATE_KHR, 3122 VK_PRESENT_MODE_END_RANGE = VK_PRESENT_MODE_FIFO_RELAXED_KHR, 3123 VK_PRESENT_MODE_RANGE_SIZE = (VK_PRESENT_MODE_FIFO_RELAXED_KHR - VK_PRESENT_MODE_IMMEDIATE_KHR + 1), 3124 VK_PRESENT_MODE_MAX_ENUM = 0x7FFFFFFF 3125} VkPresentModeKHR; 3126 3127 3128typedef enum { 3129 VK_SURFACE_TRANSFORM_NONE_BIT_KHR = 0x00000001, 3130 VK_SURFACE_TRANSFORM_ROT90_BIT_KHR = 0x00000002, 3131 VK_SURFACE_TRANSFORM_ROT180_BIT_KHR = 0x00000004, 3132 VK_SURFACE_TRANSFORM_ROT270_BIT_KHR = 0x00000008, 3133 VK_SURFACE_TRANSFORM_HMIRROR_BIT_KHR = 0x00000010, 3134 VK_SURFACE_TRANSFORM_HMIRROR_ROT90_BIT_KHR = 0x00000020, 3135 VK_SURFACE_TRANSFORM_HMIRROR_ROT180_BIT_KHR = 0x00000040, 3136 VK_SURFACE_TRANSFORM_HMIRROR_ROT270_BIT_KHR = 0x00000080, 3137 VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100, 3138} VkSurfaceTransformFlagBitsKHR; 3139typedef VkFlags VkSurfaceTransformFlagsKHR; 3140 3141typedef enum { 3142 VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, 3143 VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002, 3144 VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004, 3145 VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008, 3146} VkCompositeAlphaFlagBitsKHR; 3147typedef VkFlags VkCompositeAlphaFlagsKHR; 3148 3149typedef struct { 3150 uint32_t minImageCount; 3151 uint32_t maxImageCount; 3152 VkExtent2D currentExtent; 3153 VkExtent2D minImageExtent; 3154 VkExtent2D maxImageExtent; 3155 VkSurfaceTransformFlagsKHR supportedTransforms; 3156 VkSurfaceTransformKHR currentTransform; 3157 VkCompositeAlphaFlagsKHR supportedCompositeAlpha; 3158 uint32_t maxImageArraySize; 3159 VkImageUsageFlags supportedUsageFlags; 3160} VkSurfaceCapabilitiesKHR; 3161 3162typedef struct { 3163 VkFormat format; 3164 VkColorSpaceKHR colorSpace; 3165} VkSurfaceFormatKHR; 3166 3167 3168typedef void (VKAPI *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface); 3169typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported); 3170typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); 3171typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats); 3172typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes); 3173 3174#ifdef VK_PROTOTYPES 3175void VKAPI vkDestroySurfaceKHR( 3176 VkInstance instance, 3177 VkSurfaceKHR surface); 3178 3179VkResult VKAPI vkGetPhysicalDeviceSurfaceSupportKHR( 3180 VkPhysicalDevice physicalDevice, 3181 uint32_t queueFamilyIndex, 3182 VkSurfaceKHR surface, 3183 VkBool32* pSupported); 3184 3185VkResult VKAPI vkGetPhysicalDeviceSurfaceCapabilitiesKHR( 3186 VkPhysicalDevice physicalDevice, 3187 VkSurfaceKHR surface, 3188 VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); 3189 3190VkResult VKAPI vkGetPhysicalDeviceSurfaceFormatsKHR( 3191 VkPhysicalDevice physicalDevice, 3192 VkSurfaceKHR surface, 3193 uint32_t* pSurfaceFormatCount, 3194 VkSurfaceFormatKHR* pSurfaceFormats); 3195 3196VkResult VKAPI vkGetPhysicalDeviceSurfacePresentModesKHR( 3197 VkPhysicalDevice physicalDevice, 3198 VkSurfaceKHR surface, 3199 uint32_t* pPresentModeCount, 3200 VkPresentModeKHR* pPresentModes); 3201#endif 3202 3203#define vk_ext_khr_swapchain 1 3204VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR) 3205 3206#define VK_EXT_KHR_SWAPCHAIN_REVISION 62 3207#define VK_EXT_KHR_SWAPCHAIN_EXTENSION_NUMBER 2 3208#define VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME "VK_EXT_KHR_swapchain" 3209#define VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR ((VkStructureType)(int)0xc0000800) 3210#define VK_STRUCTURE_TYPE_PRESENT_INFO_KHR ((VkStructureType)(int)0xc0000801) 3211#define VK_IMAGE_LAYOUT_PRESENT_SRC_KHR ((VkImageLayout)(int)0xc0000802) 3212#define VK_SUBOPTIMAL_KHR ((VkResult)(int)0x40000403) 3213#define VK_ERROR_OUT_OF_DATE_KHR ((VkResult)(int)0xc0000804) 3214 3215typedef struct { 3216 VkStructureType sType; 3217 const void* pNext; 3218 VkSurfaceKHR surface; 3219 uint32_t minImageCount; 3220 VkFormat imageFormat; 3221 VkColorSpaceKHR imageColorSpace; 3222 VkExtent2D imageExtent; 3223 VkImageUsageFlags imageUsageFlags; 3224 VkSurfaceTransformKHR preTransform; 3225 VkCompositeAlphaFlagBitsKHR compositeAlpha; 3226 uint32_t imageArraySize; 3227 VkSharingMode sharingMode; 3228 uint32_t queueFamilyIndexCount; 3229 const uint32_t* pQueueFamilyIndices; 3230 VkPresentModeKHR presentMode; 3231 VkSwapchainKHR oldSwapchain; 3232 VkBool32 clipped; 3233} VkSwapchainCreateInfoKHR; 3234 3235typedef struct { 3236 VkStructureType sType; 3237 const void* pNext; 3238 uint32_t waitSemaphoreCount; 3239 const VkSemaphore* pWaitSemaphores; 3240 uint32_t swapchainCount; 3241 const VkSwapchainKHR* pSwapchains; 3242 const uint32_t* imageIndices; 3243} VkPresentInfoKHR; 3244 3245 3246typedef VkResult (VKAPI *PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, VkSwapchainKHR* pSwapchain); 3247typedef void (VKAPI *PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain); 3248typedef VkResult (VKAPI *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages); 3249typedef VkResult (VKAPI *PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex); 3250typedef VkResult (VKAPI *PFN_vkQueuePresentKHR)(VkQueue queue, VkPresentInfoKHR* pPresentInfo); 3251 3252#ifdef VK_PROTOTYPES 3253VkResult VKAPI vkCreateSwapchainKHR( 3254 VkDevice device, 3255 const VkSwapchainCreateInfoKHR* pCreateInfo, 3256 VkSwapchainKHR* pSwapchain); 3257 3258void VKAPI vkDestroySwapchainKHR( 3259 VkDevice device, 3260 VkSwapchainKHR swapchain); 3261 3262VkResult VKAPI vkGetSwapchainImagesKHR( 3263 VkDevice device, 3264 VkSwapchainKHR swapchain, 3265 uint32_t* pSwapchainImageCount, 3266 VkImage* pSwapchainImages); 3267 3268VkResult VKAPI vkAcquireNextImageKHR( 3269 VkDevice device, 3270 VkSwapchainKHR swapchain, 3271 uint64_t timeout, 3272 VkSemaphore semaphore, 3273 VkFence fence, 3274 uint32_t* pImageIndex); 3275 3276VkResult VKAPI vkQueuePresentKHR( 3277 VkQueue queue, 3278 VkPresentInfoKHR* pPresentInfo); 3279#endif 3280 3281#define vk_ext_khr_display 1 3282VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR) 3283VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR) 3284 3285#define VK_EXT_KHR_DISPLAY_REVISION 17 3286#define VK_EXT_KHR_DISPLAY_EXTENSION_NUMBER 3 3287#define VK_EXT_KHR_DISPLAY_EXTENSION_NAME "VK_EXT_KHR_display" 3288#define VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR ((VkStructureType)(int)0xc0000c00) 3289#define VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR ((VkStructureType)(int)0xc0000c01) 3290 3291 3292typedef enum { 3293 VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000001, 3294 VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000002, 3295 VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000004, 3296} VkDisplayPlaneAlphaFlagBitsKHR; 3297typedef VkFlags VkDisplayPlaneAlphaFlagsKHR; 3298 3299typedef struct { 3300 VkDisplayKHR display; 3301 const char* displayName; 3302 VkExtent2D physicalDimensions; 3303 VkExtent2D physicalResolution; 3304 VkSurfaceTransformFlagsKHR supportedTransforms; 3305 VkBool32 planeReorderPossible; 3306 VkBool32 persistentContent; 3307} VkDisplayPropertiesKHR; 3308 3309typedef struct { 3310 VkExtent2D visibleRegion; 3311 uint32_t refreshRate; 3312} VkDisplayModeParametersKHR; 3313 3314typedef struct { 3315 VkDisplayModeKHR displayMode; 3316 VkDisplayModeParametersKHR parameters; 3317} VkDisplayModePropertiesKHR; 3318 3319typedef struct { 3320 VkStructureType sType; 3321 const void* pNext; 3322 VkDisplayModeParametersKHR parameters; 3323} VkDisplayModeCreateInfoKHR; 3324 3325typedef struct { 3326 VkDisplayPlaneAlphaFlagsKHR supportedAlpha; 3327 VkOffset2D minSrcPosition; 3328 VkOffset2D maxSrcPosition; 3329 VkExtent2D minSrcExtent; 3330 VkExtent2D maxSrcExtent; 3331 VkOffset2D minDstPosition; 3332 VkOffset2D maxDstPosition; 3333 VkExtent2D minDstExtent; 3334 VkExtent2D maxDstExtent; 3335} VkDisplayPlaneCapabilitiesKHR; 3336 3337typedef struct { 3338 VkDisplayKHR currentDisplay; 3339 uint32_t currentStackIndex; 3340} VkDisplayPlanePropertiesKHR; 3341 3342typedef struct { 3343 VkStructureType sType; 3344 const void* pNext; 3345 VkDisplayModeKHR displayMode; 3346 uint32_t planeIndex; 3347 uint32_t planeStackIndex; 3348 VkSurfaceTransformKHR transform; 3349 float globalAlpha; 3350 VkDisplayPlaneAlphaFlagsKHR alphaMode; 3351 VkExtent2D imageSize; 3352} VkDisplaySurfaceCreateInfoKHR; 3353 3354 3355typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties); 3356typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties); 3357typedef VkResult (VKAPI *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayKHR* pProperties); 3358typedef VkResult (VKAPI *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties); 3359typedef VkResult (VKAPI *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR*pCreateInfo, VkDisplayModeKHR* pMode); 3360typedef VkResult (VKAPI *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeCreateInfoKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities); 3361typedef VkResult (VKAPI *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, VkSurfaceKHR* pSurface); 3362 3363#ifdef VK_PROTOTYPES 3364VkResult VKAPI vkGetPhysicalDeviceDisplayPropertiesKHR( 3365 VkPhysicalDevice physicalDevice, 3366 uint32_t* pPropertyCount, 3367 VkDisplayPropertiesKHR* pProperties); 3368 3369VkResult VKAPI vkGetPhysicalDeviceDisplayPlanePropertiesKHR( 3370 VkPhysicalDevice physicalDevice, 3371 uint32_t* pPropertyCount, 3372 VkDisplayPlanePropertiesKHR* pProperties); 3373 3374VkResult VKAPI vkGetDisplayPlaneSupportedDisplaysKHR( 3375 VkPhysicalDevice physicalDevice, 3376 uint32_t* pPropertyCount, 3377 VkDisplayKHR* pProperties); 3378 3379VkResult VKAPI vkGetDisplayModePropertiesKHR( 3380 VkPhysicalDevice physicalDevice, 3381 VkDisplayKHR display, 3382 uint32_t* pPropertyCount, 3383 VkDisplayModePropertiesKHR* pProperties); 3384 3385VkResult VKAPI vkCreateDisplayModeKHR( 3386 VkPhysicalDevice physicalDevice, 3387 VkDisplayKHR display, 3388 const VkDisplayModeCreateInfoKHR* pCreateInfo, 3389 VkDisplayModeKHR* pMode); 3390 3391VkResult VKAPI vkGetDisplayPlaneCapabilitiesKHR( 3392 VkPhysicalDevice physicalDevice, 3393 VkDisplayModeCreateInfoKHR mode, 3394 uint32_t planeIndex, 3395 VkDisplayPlaneCapabilitiesKHR* pCapabilities); 3396 3397VkResult VKAPI vkCreateDisplayPlaneSurfaceKHR( 3398 VkInstance instance, 3399 const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, 3400 VkSurfaceKHR* pSurface); 3401#endif 3402 3403#define vk_ext_khr_display_swapchain 1 3404#define VK_EXT_KHR_DISPLAY_SWAPCHAIN_REVISION 6 3405#define VK_EXT_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NUMBER 4 3406#define VK_EXT_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_EXT_KHR_display_swapchain" 3407#define VK_STRUCTURE_TYPE_DISPLAY_SWAPCHAIN_CREATE_INFO_KHR ((VkStructureType)(int)0xc0001000) 3408#define VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR ((VkStructureType)(int)0xc0001001) 3409#define VK_ERROR_INCOMPATIBLE_DISPLAY_KHR ((VkResult)(int)0xc0001002) 3410 3411typedef struct { 3412 VkStructureType sType; 3413 const void* pNext; 3414 const VkSwapchainCreateInfoKHR* pNextSwapchainCreateInfo; 3415} VkDisplaySwapchainCreateInfoKHR; 3416 3417typedef struct { 3418 VkStructureType sType; 3419 const void* pNext; 3420 VkRect2D srcRect; 3421 VkRect2D dstRect; 3422 VkBool32 persistent; 3423} VkDisplayPresentInfoKHR; 3424 3425 3426 3427#ifdef VK_USE_PLATFORM_XLIB_KHR 3428#define vk_ext_khr_xlib_surface 1 3429#include <X11/Xlib.h> 3430 3431#define VK_EXT_KHR_XLIB_SURFACE_REVISION 3 3432#define VK_EXT_KHR_XLIB_SURFACE_EXTENSION_NUMBER 5 3433#define VK_EXT_KHR_XLIB_SURFACE_EXTENSION_NAME "vk_ext_khr_xlib_surface" 3434 3435typedef VkResult (VKAPI *PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, Display* dpy, Window window, VkSurfaceKHR* pSurface); 3436typedef VkBool32 (VKAPI *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualId); 3437 3438#ifdef VK_PROTOTYPES 3439VkResult VKAPI vkCreateXlibSurfaceKHR( 3440 VkInstance instance, 3441 Display* dpy, 3442 Window window, 3443 VkSurfaceKHR* pSurface); 3444 3445VkBool32 VKAPI vkGetPhysicalDeviceXlibPresentationSupportKHR( 3446 VkPhysicalDevice physicalDevice, 3447 uint32_t queueFamilyIndex, 3448 Display* dpy, 3449 VisualID visualId); 3450#endif 3451#endif /* VK_USE_PLATFORM_XLIB_KHR */ 3452 3453#ifdef VK_USE_PLATFORM_XCB_KHR 3454#define vk_ext_khr_xcb_surface 1 3455#include <xcb/xcb.h> 3456 3457#define VK_EXT_KHR_XCB_SURFACE_REVISION 3 3458#define VK_EXT_KHR_XCB_SURFACE_EXTENSION_NUMBER 6 3459#define VK_EXT_KHR_XCB_SURFACE_EXTENSION_NAME "VK_EXT_KHR_xcb_surface" 3460 3461typedef VkResult (VKAPI *PFN_vkCreateXcbSurfaceKHR)(VkInstance instance, xcb_connection_t* connection, xcb_window_t window, VkSurfaceKHR* pSurface); 3462typedef VkBool32 (VKAPI *PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id); 3463 3464#ifdef VK_PROTOTYPES 3465VkResult VKAPI vkCreateXcbSurfaceKHR( 3466 VkInstance instance, 3467 xcb_connection_t* connection, 3468 xcb_window_t window, 3469 VkSurfaceKHR* pSurface); 3470 3471VkBool32 VKAPI vkGetPhysicalDeviceXcbPresentationSupportKHR( 3472 VkPhysicalDevice physicalDevice, 3473 uint32_t queueFamilyIndex, 3474 xcb_connection_t* connection, 3475 xcb_visualid_t visual_id); 3476#endif 3477#endif /* VK_USE_PLATFORM_XCB_KHR */ 3478 3479#ifdef VK_USE_PLATFORM_WAYLAND_KHR 3480#define vk_ext_khr_wayland_surface 1 3481#include <wayland-client.h> 3482 3483#define VK_EXT_KHR_WAYLAND_SURFACE_REVISION 2 3484#define VK_EXT_KHR_WAYLAND_SURFACE_EXTENSION_NUMBER 7 3485#define VK_EXT_KHR_WAYLAND_SURFACE_EXTENSION_NAME "VK_EXT_KHR_wayland_surface" 3486 3487typedef VkResult (VKAPI *PFN_vkCreateWaylandSurfaceKHR)(VkInstance instance, struct wl_display* display, struct wl_surface* surface, VkSurfaceKHR* pSurface); 3488typedef VkBool32 (VKAPI *PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display); 3489 3490#ifdef VK_PROTOTYPES 3491VkResult VKAPI vkCreateWaylandSurfaceKHR( 3492 VkInstance instance, 3493 struct wl_display* display, 3494 struct wl_surface* surface, 3495 VkSurfaceKHR* pSurface); 3496 3497VkBool32 VKAPI vkGetPhysicalDeviceWaylandPresentationSupportKHR( 3498 VkPhysicalDevice physicalDevice, 3499 uint32_t queueFamilyIndex, 3500 struct wl_display* display); 3501#endif 3502#endif /* VK_USE_PLATFORM_WAYLAND_KHR */ 3503 3504#ifdef VK_USE_PLATFORM_MIR_KHR 3505#define vk_ext_khr_mir_surface 1 3506#include <mir_toolkit/client_types.h> 3507 3508#define VK_EXT_KHR_MIR_SURFACE_REVISION 2 3509#define VK_EXT_KHR_MIR_SURFACE_EXTENSION_NUMBER 8 3510#define VK_EXT_KHR_MIR_SURFACE_EXTENSION_NAME "VK_EXT_KHR_mir_surface" 3511 3512typedef VkResult (VKAPI *PFN_vkCreateMirSurfaceKHR)(VkInstance instance, MirConnection* connection, MirSurface* mirSurface, VkSurfaceKHR* pSurface); 3513typedef VkBool32 (VKAPI *PFN_vkGetPhysicalDeviceMirPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, MirConnection* connection); 3514 3515#ifdef VK_PROTOTYPES 3516VkResult VKAPI vkCreateMirSurfaceKHR( 3517 VkInstance instance, 3518 MirConnection* connection, 3519 MirSurface* mirSurface, 3520 VkSurfaceKHR* pSurface); 3521 3522VkBool32 VKAPI vkGetPhysicalDeviceMirPresentationSupportKHR( 3523 VkPhysicalDevice physicalDevice, 3524 uint32_t queueFamilyIndex, 3525 MirConnection* connection); 3526#endif 3527#endif /* VK_USE_PLATFORM_MIR_KHR */ 3528 3529#ifdef VK_USE_PLATFORM_ANDROID_KHR 3530#define vk_ext_khr_android_surface 1 3531#include <android/native_window.h> 3532 3533#define VK_EXT_KHR_ANDROID_SURFACE_REVISION 1 3534#define VK_EXT_KHR_ANDROID_SURFACE_EXTENSION_NUMBER 9 3535#define VK_EXT_KHR_ANDROID_SURFACE_EXTENSION_NAME "VK_EXT_KHR_android_surface" 3536#define VK_ERROR_INVALID_ANDROID_WINDOW_KHR ((VkResult)(int)0xc0002400) 3537#define VK_ERROR_ANDROID_WINDOW_IN_USE_KHR ((VkResult)(int)0xc0002401) 3538 3539typedef VkResult (VKAPI *PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance, ANativeWindow* window, VkSurfaceKHR* pSurface); 3540 3541#ifdef VK_PROTOTYPES 3542VkResult VKAPI vkCreateAndroidSurfaceKHR( 3543 VkInstance instance, 3544 ANativeWindow* window, 3545 VkSurfaceKHR* pSurface); 3546#endif 3547#endif /* VK_USE_PLATFORM_ANDROID_KHR */ 3548 3549#ifdef VK_USE_PLATFORM_WIN32_KHR 3550#define vk_ext_khr_win32_surface 1 3551#include <windows.h> 3552 3553#define VK_EXT_KHR_WIN32_SURFACE_REVISION 2 3554#define VK_EXT_KHR_WIN32_SURFACE_EXTENSION_NUMBER 10 3555#define VK_EXT_KHR_WIN32_SURFACE_EXTENSION_NAME "VK_EXT_KHR_win32_surface" 3556 3557typedef VkResult (VKAPI *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, HINSTANCE hinstance, HWND hwnd, VkSurfaceKHR* pSurface); 3558typedef VkBool32 (VKAPI *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex); 3559 3560#ifdef VK_PROTOTYPES 3561VkResult VKAPI vkCreateWin32SurfaceKHR( 3562 VkInstance instance, 3563 HINSTANCE hinstance, 3564 HWND hwnd, 3565 VkSurfaceKHR* pSurface); 3566 3567VkBool32 VKAPI vkGetPhysicalDeviceWin32PresentationSupportKHR( 3568 VkPhysicalDevice physicalDevice, 3569 uint32_t queueFamilyIndex); 3570#endif 3571#endif /* VK_USE_PLATFORM_WIN32_KHR */ 3572 3573#ifdef __cplusplus 3574} 3575#endif 3576 3577#endif 3578