vulkan.h revision d1af812f20e0793d94702817d441ab799bf46df7
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, 197, 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_LOCAL_BIT = 0x00000001, 814 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002, 815 VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004, 816 VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008, 817 VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010, 818} VkMemoryPropertyFlagBits; 819typedef VkFlags VkMemoryPropertyFlags; 820 821typedef enum { 822 VK_MEMORY_HEAP_DEVICE_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; 842typedef VkFlags VkSparseMemoryBindFlags; 843 844typedef enum { 845 VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001, 846} VkFenceCreateFlagBits; 847typedef VkFlags VkFenceCreateFlags; 848typedef VkFlags VkSemaphoreCreateFlags; 849typedef VkFlags VkEventCreateFlags; 850typedef VkFlags VkQueryPoolCreateFlags; 851 852typedef enum { 853 VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001, 854 VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002, 855 VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004, 856 VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008, 857 VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0x00000010, 858 VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0x00000020, 859 VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0x00000040, 860 VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0x00000080, 861 VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x00000100, 862 VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0x00000200, 863 VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400, 864} VkQueryPipelineStatisticFlagBits; 865typedef VkFlags VkQueryPipelineStatisticFlags; 866 867typedef enum { 868 VK_QUERY_RESULT_DEFAULT = 0, 869 VK_QUERY_RESULT_64_BIT = 0x00000001, 870 VK_QUERY_RESULT_WAIT_BIT = 0x00000002, 871 VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004, 872 VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008, 873} VkQueryResultFlagBits; 874typedef VkFlags VkQueryResultFlags; 875 876typedef enum { 877 VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001, 878 VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, 879 VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004, 880} VkBufferCreateFlagBits; 881typedef VkFlags VkBufferCreateFlags; 882 883typedef enum { 884 VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001, 885 VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002, 886 VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004, 887 VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008, 888 VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010, 889 VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020, 890 VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040, 891 VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080, 892 VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100, 893} VkBufferUsageFlagBits; 894typedef VkFlags VkBufferUsageFlags; 895typedef VkFlags VkBufferViewCreateFlags; 896typedef VkFlags VkImageViewCreateFlags; 897typedef VkFlags VkImageAspectFlags; 898typedef VkFlags VkShaderModuleCreateFlags; 899typedef VkFlags VkShaderCreateFlags; 900 901typedef enum { 902 VK_SHADER_STAGE_VERTEX_BIT = 0x00000001, 903 VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002, 904 VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004, 905 VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008, 906 VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010, 907 VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020, 908 VK_SHADER_STAGE_ALL_GRAPHICS = 0x1F, 909 VK_SHADER_STAGE_ALL = 0x7FFFFFFF, 910} VkShaderStageFlagBits; 911typedef VkFlags VkPipelineCacheCreateFlags; 912 913typedef enum { 914 VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001, 915 VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002, 916 VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004, 917} VkPipelineCreateFlagBits; 918typedef VkFlags VkPipelineCreateFlags; 919typedef VkFlags VkPipelineShaderStageCreateFlags; 920typedef VkFlags VkPipelineVertexInputStateCreateFlags; 921typedef VkFlags VkPipelineInputAssemblyStateCreateFlags; 922typedef VkFlags VkPipelineTesselationStateCreateFlags; 923typedef VkFlags VkPipelineViewportStateCreateFlags; 924typedef VkFlags VkPipelineRasterizationStateCreateFlags; 925 926typedef enum { 927 VK_CULL_MODE_NONE = 0, 928 VK_CULL_MODE_FRONT_BIT = 0x00000001, 929 VK_CULL_MODE_BACK_BIT = 0x00000002, 930 VK_CULL_MODE_FRONT_AND_BACK = 0x3, 931} VkCullModeFlagBits; 932typedef VkFlags VkCullModeFlags; 933typedef VkFlags VkPipelineMultisampleStateCreateFlags; 934typedef VkFlags VkPipelineDepthStencilStateCreateFlags; 935typedef VkFlags VkPipelineColorBlendStateCreateFlags; 936 937typedef enum { 938 VK_CHANNEL_R_BIT = 0x00000001, 939 VK_CHANNEL_G_BIT = 0x00000002, 940 VK_CHANNEL_B_BIT = 0x00000004, 941 VK_CHANNEL_A_BIT = 0x00000008, 942} VkChannelFlagBits; 943typedef VkFlags VkChannelFlags; 944typedef VkFlags VkPipelineDynamicStateCreateFlags; 945typedef VkFlags VkPipelineLayoutCreateFlags; 946typedef VkFlags VkShaderStageFlags; 947typedef VkFlags VkSamplerCreateFlags; 948typedef VkFlags VkDescriptorSetLayoutCreateFlags; 949 950typedef enum { 951 VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001, 952} VkDescriptorPoolCreateFlagBits; 953typedef VkFlags VkDescriptorPoolCreateFlags; 954typedef VkFlags VkDescriptorPoolResetFlags; 955typedef VkFlags VkFramebufferCreateFlags; 956typedef VkFlags VkRenderPassCreateFlags; 957 958typedef enum { 959 VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001, 960} VkAttachmentDescriptionFlagBits; 961typedef VkFlags VkAttachmentDescriptionFlags; 962typedef VkFlags VkSubpassDescriptionFlags; 963 964typedef enum { 965 VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001, 966 VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002, 967 VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004, 968 VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008, 969 VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010, 970 VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020, 971 VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040, 972 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080, 973 VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100, 974 VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200, 975 VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400, 976 VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800, 977 VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000, 978 VK_PIPELINE_STAGE_HOST_BIT = 0x00002000, 979 VK_PIPELINE_STAGE_ALL_GRAPHICS = 0x000007FF, 980 VK_PIPELINE_STAGE_ALL_GPU_COMMANDS = 0x00001FFF, 981} VkPipelineStageFlagBits; 982typedef VkFlags VkPipelineStageFlags; 983 984typedef enum { 985 VK_MEMORY_OUTPUT_HOST_WRITE_BIT = 0x00000001, 986 VK_MEMORY_OUTPUT_SHADER_WRITE_BIT = 0x00000002, 987 VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT = 0x00000004, 988 VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000008, 989 VK_MEMORY_OUTPUT_TRANSFER_BIT = 0x00000010, 990} VkMemoryOutputFlagBits; 991typedef VkFlags VkMemoryOutputFlags; 992 993typedef enum { 994 VK_MEMORY_INPUT_HOST_READ_BIT = 0x00000001, 995 VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT = 0x00000002, 996 VK_MEMORY_INPUT_INDEX_FETCH_BIT = 0x00000004, 997 VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT = 0x00000008, 998 VK_MEMORY_INPUT_UNIFORM_READ_BIT = 0x00000010, 999 VK_MEMORY_INPUT_SHADER_READ_BIT = 0x00000020, 1000 VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT = 0x00000040, 1001 VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000080, 1002 VK_MEMORY_INPUT_INPUT_ATTACHMENT_BIT = 0x00000100, 1003 VK_MEMORY_INPUT_TRANSFER_BIT = 0x00000200, 1004} VkMemoryInputFlagBits; 1005typedef VkFlags VkMemoryInputFlags; 1006 1007typedef enum { 1008 VK_DEPENDENCY_BY_REGION_BIT = 0x00000001, 1009} VkDependencyFlagBits; 1010typedef VkFlags VkDependencyFlags; 1011 1012typedef enum { 1013 VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001, 1014 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002, 1015} VkCommandPoolCreateFlagBits; 1016typedef VkFlags VkCommandPoolCreateFlags; 1017 1018typedef enum { 1019 VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001, 1020} VkCommandPoolResetFlagBits; 1021typedef VkFlags VkCommandPoolResetFlags; 1022 1023typedef enum { 1024 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001, 1025 VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002, 1026 VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004, 1027} VkCommandBufferUsageFlagBits; 1028typedef VkFlags VkCommandBufferUsageFlags; 1029 1030typedef enum { 1031 VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001, 1032} VkCommandBufferResetFlagBits; 1033typedef VkFlags VkCommandBufferResetFlags; 1034 1035typedef enum { 1036 VK_STENCIL_FACE_NONE = 0, 1037 VK_STENCIL_FACE_FRONT_BIT = 0x00000001, 1038 VK_STENCIL_FACE_BACK_BIT = 0x00000002, 1039 VK_STENCIL_FRONT_AND_BACK = 0x3, 1040} VkStencilFaceFlagBits; 1041typedef VkFlags VkStencilFaceFlags; 1042 1043typedef enum { 1044 VK_QUERY_CONTROL_CONSERVATIVE_BIT = 0x00000001, 1045} VkQueryControlFlagBits; 1046typedef VkFlags VkQueryControlFlags; 1047 1048typedef void* (VKAPI *PFN_vkAllocationFunction)( 1049 void* pUserData, 1050 size_t size, 1051 size_t alignment, 1052 VkSystemAllocationScope allocationScope); 1053 1054typedef void* (VKAPI *PFN_vkReallocationFunction)( 1055 void* pUserData, 1056 void* pOriginal, 1057 size_t size, 1058 size_t alignment, 1059 VkSystemAllocationScope allocationScope); 1060 1061typedef void (VKAPI *PFN_vkFreeFunction)( 1062 void* pUserData, 1063 void* pMemory); 1064 1065typedef void (VKAPI *PFN_vkInternalAllocationNotification)( 1066 void* pUserData, 1067 size_t size, 1068 VkInternalAllocationType allocationType, 1069 VkSystemAllocationScope allocationScope); 1070 1071typedef void (VKAPI *PFN_vkInternalFreeNotification)( 1072 void* pUserData, 1073 size_t size, 1074 VkInternalAllocationType allocationType, 1075 VkSystemAllocationScope allocationScope); 1076 1077typedef void (VKAPI *PFN_vkVoidFunction)(void); 1078 1079typedef struct { 1080 VkStructureType sType; 1081 const void* pNext; 1082 const char* pApplicationName; 1083 uint32_t applicationVersion; 1084 const char* pEngineName; 1085 uint32_t engineVersion; 1086 uint32_t apiVersion; 1087} VkApplicationInfo; 1088 1089typedef struct { 1090 VkStructureType sType; 1091 const void* pNext; 1092 VkInstanceCreateFlags flags; 1093 const VkApplicationInfo* pApplicationInfo; 1094 uint32_t enabledLayerNameCount; 1095 const char*const* ppEnabledLayerNames; 1096 uint32_t enabledExtensionNameCount; 1097 const char*const* ppEnabledExtensionNames; 1098} VkInstanceCreateInfo; 1099 1100typedef struct { 1101 void* pUserData; 1102 PFN_vkAllocationFunction pfnAllocation; 1103 PFN_vkReallocationFunction pfnReallocation; 1104 PFN_vkFreeFunction pfnFree; 1105 PFN_vkInternalAllocationNotification pfnInternalAllocation; 1106 PFN_vkInternalFreeNotification pfnInternalFree; 1107} VkAllocationCallbacks; 1108 1109typedef struct { 1110 VkBool32 robustBufferAccess; 1111 VkBool32 fullDrawIndexUint32; 1112 VkBool32 imageCubeArray; 1113 VkBool32 independentBlend; 1114 VkBool32 geometryShader; 1115 VkBool32 tessellationShader; 1116 VkBool32 sampleRateShading; 1117 VkBool32 dualSrcBlend; 1118 VkBool32 logicOp; 1119 VkBool32 multiDrawIndirect; 1120 VkBool32 depthClamp; 1121 VkBool32 depthBiasClamp; 1122 VkBool32 fillModeNonSolid; 1123 VkBool32 depthBounds; 1124 VkBool32 wideLines; 1125 VkBool32 largePoints; 1126 VkBool32 alphaToOne; 1127 VkBool32 multiViewport; 1128 VkBool32 samplerAnisotropy; 1129 VkBool32 textureCompressionETC2; 1130 VkBool32 textureCompressionASTC_LDR; 1131 VkBool32 textureCompressionBC; 1132 VkBool32 occlusionQueryNonConservative; 1133 VkBool32 pipelineStatisticsQuery; 1134 VkBool32 vertexPipelineStoresAndAtomics; 1135 VkBool32 fragmentStoresAndAtomics; 1136 VkBool32 shaderTessellationAndGeometryPointSize; 1137 VkBool32 shaderImageGatherExtended; 1138 VkBool32 shaderStorageImageExtendedFormats; 1139 VkBool32 shaderStorageImageMultisample; 1140 VkBool32 shaderStorageImageReadWithoutFormat; 1141 VkBool32 shaderStorageImageWriteWithoutFormat; 1142 VkBool32 shaderUniformBufferArrayDynamicIndexing; 1143 VkBool32 shaderSampledImageArrayDynamicIndexing; 1144 VkBool32 shaderStorageBufferArrayDynamicIndexing; 1145 VkBool32 shaderStorageImageArrayDynamicIndexing; 1146 VkBool32 shaderClipDistance; 1147 VkBool32 shaderCullDistance; 1148 VkBool32 shaderFloat64; 1149 VkBool32 shaderInt64; 1150 VkBool32 shaderInt16; 1151 VkBool32 shaderResourceResidency; 1152 VkBool32 shaderResourceMinLOD; 1153 VkBool32 sparseBinding; 1154 VkBool32 sparseResidencyBuffer; 1155 VkBool32 sparseResidencyImage2D; 1156 VkBool32 sparseResidencyImage3D; 1157 VkBool32 sparseResidency2Samples; 1158 VkBool32 sparseResidency4Samples; 1159 VkBool32 sparseResidency8Samples; 1160 VkBool32 sparseResidency16Samples; 1161 VkBool32 sparseResidencyAliased; 1162 VkBool32 variableMultisampleRate; 1163} VkPhysicalDeviceFeatures; 1164 1165typedef struct { 1166 VkFormatFeatureFlags linearTilingFeatures; 1167 VkFormatFeatureFlags optimalTilingFeatures; 1168 VkFormatFeatureFlags bufferFeatures; 1169} VkFormatProperties; 1170 1171typedef struct { 1172 int32_t width; 1173 int32_t height; 1174 int32_t depth; 1175} VkExtent3D; 1176 1177typedef struct { 1178 VkExtent3D maxExtent; 1179 uint32_t maxMipLevels; 1180 uint32_t maxArrayLayers; 1181 VkSampleCountFlags sampleCounts; 1182 VkDeviceSize maxResourceSize; 1183} VkImageFormatProperties; 1184 1185typedef struct { 1186 uint32_t maxImageDimension1D; 1187 uint32_t maxImageDimension2D; 1188 uint32_t maxImageDimension3D; 1189 uint32_t maxImageDimensionCube; 1190 uint32_t maxImageArrayLayers; 1191 VkSampleCountFlags sampleCounts; 1192 uint32_t maxTexelBufferElements; 1193 uint32_t maxUniformBufferRange; 1194 uint32_t maxStorageBufferRange; 1195 uint32_t maxPushConstantsSize; 1196 uint32_t maxMemoryAllocationCount; 1197 VkDeviceSize bufferImageGranularity; 1198 VkDeviceSize sparseAddressSpaceSize; 1199 uint32_t maxBoundDescriptorSets; 1200 uint32_t maxPerStageDescriptorSamplers; 1201 uint32_t maxPerStageDescriptorUniformBuffers; 1202 uint32_t maxPerStageDescriptorStorageBuffers; 1203 uint32_t maxPerStageDescriptorSampledImages; 1204 uint32_t maxPerStageDescriptorStorageImages; 1205 uint32_t maxDescriptorSetSamplers; 1206 uint32_t maxDescriptorSetUniformBuffers; 1207 uint32_t maxDescriptorSetUniformBuffersDynamic; 1208 uint32_t maxDescriptorSetStorageBuffers; 1209 uint32_t maxDescriptorSetStorageBuffersDynamic; 1210 uint32_t maxDescriptorSetSampledImages; 1211 uint32_t maxDescriptorSetStorageImages; 1212 uint32_t maxVertexInputAttributes; 1213 uint32_t maxVertexInputBindings; 1214 uint32_t maxVertexInputAttributeOffset; 1215 uint32_t maxVertexInputBindingStride; 1216 uint32_t maxVertexOutputComponents; 1217 uint32_t maxTessellationGenerationLevel; 1218 uint32_t maxTessellationPatchSize; 1219 uint32_t maxTessellationControlPerVertexInputComponents; 1220 uint32_t maxTessellationControlPerVertexOutputComponents; 1221 uint32_t maxTessellationControlPerPatchOutputComponents; 1222 uint32_t maxTessellationControlTotalOutputComponents; 1223 uint32_t maxTessellationEvaluationInputComponents; 1224 uint32_t maxTessellationEvaluationOutputComponents; 1225 uint32_t maxGeometryShaderInvocations; 1226 uint32_t maxGeometryInputComponents; 1227 uint32_t maxGeometryOutputComponents; 1228 uint32_t maxGeometryOutputVertices; 1229 uint32_t maxGeometryTotalOutputComponents; 1230 uint32_t maxFragmentInputComponents; 1231 uint32_t maxFragmentOutputAttachments; 1232 uint32_t maxFragmentDualSrcAttachments; 1233 uint32_t maxFragmentCombinedOutputResources; 1234 uint32_t maxComputeSharedMemorySize; 1235 uint32_t maxComputeWorkGroupCount[3]; 1236 uint32_t maxComputeWorkGroupInvocations; 1237 uint32_t maxComputeWorkGroupSize[3]; 1238 uint32_t subPixelPrecisionBits; 1239 uint32_t subTexelPrecisionBits; 1240 uint32_t mipmapPrecisionBits; 1241 uint32_t maxDrawIndexedIndexValue; 1242 uint32_t maxDrawIndirectInstanceCount; 1243 float maxSamplerLodBias; 1244 float maxSamplerAnisotropy; 1245 uint32_t maxViewports; 1246 uint32_t maxViewportDimensions[2]; 1247 float viewportBoundsRange[2]; 1248 uint32_t viewportSubPixelBits; 1249 size_t minMemoryMapAlignment; 1250 VkDeviceSize minTexelBufferOffsetAlignment; 1251 VkDeviceSize minUniformBufferOffsetAlignment; 1252 VkDeviceSize minStorageBufferOffsetAlignment; 1253 int32_t minTexelOffset; 1254 uint32_t maxTexelOffset; 1255 int32_t minTexelGatherOffset; 1256 uint32_t maxTexelGatherOffset; 1257 float minInterpolationOffset; 1258 float maxInterpolationOffset; 1259 uint32_t subPixelInterpolationOffsetBits; 1260 uint32_t maxFramebufferWidth; 1261 uint32_t maxFramebufferHeight; 1262 uint32_t maxFramebufferLayers; 1263 uint32_t maxFramebufferColorSamples; 1264 uint32_t maxFramebufferDepthSamples; 1265 uint32_t maxFramebufferStencilSamples; 1266 uint32_t maxColorAttachments; 1267 uint32_t maxSampledImageColorSamples; 1268 uint32_t maxSampledImageDepthSamples; 1269 uint32_t maxSampledImageStencilSamples; 1270 uint32_t maxSampledImageIntegerSamples; 1271 uint32_t maxStorageImageSamples; 1272 uint32_t maxSampleMaskWords; 1273 float timestampPeriod; 1274 uint32_t maxClipDistances; 1275 uint32_t maxCullDistances; 1276 uint32_t maxCombinedClipAndCullDistances; 1277 uint32_t discreteQueuePriorities; 1278 float pointSizeRange[2]; 1279 float lineWidthRange[2]; 1280 float pointSizeGranularity; 1281 float lineWidthGranularity; 1282 VkBool32 strictLines; 1283 VkDeviceSize recommendedBufferCopyOffsetAlignment; 1284 VkDeviceSize recommendedBufferCopyRowPitchAlignment; 1285} VkPhysicalDeviceLimits; 1286 1287typedef struct { 1288 VkBool32 residencyStandard2DBlockShape; 1289 VkBool32 residencyStandard2DMultisampleBlockShape; 1290 VkBool32 residencyStandard3DBlockShape; 1291 VkBool32 residencyAlignedMipSize; 1292 VkBool32 residencyNonResidentStrict; 1293} VkPhysicalDeviceSparseProperties; 1294 1295typedef struct { 1296 uint32_t apiVersion; 1297 uint32_t driverVersion; 1298 uint32_t vendorId; 1299 uint32_t deviceId; 1300 VkPhysicalDeviceType deviceType; 1301 char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME]; 1302 uint8_t pipelineCacheUUID[VK_UUID_LENGTH]; 1303 VkPhysicalDeviceLimits limits; 1304 VkPhysicalDeviceSparseProperties sparseProperties; 1305} VkPhysicalDeviceProperties; 1306 1307typedef struct { 1308 VkQueueFlags queueFlags; 1309 uint32_t queueCount; 1310 uint32_t timestampValidBits; 1311} VkQueueFamilyProperties; 1312 1313typedef struct { 1314 VkMemoryPropertyFlags propertyFlags; 1315 uint32_t heapIndex; 1316} VkMemoryType; 1317 1318typedef struct { 1319 VkDeviceSize size; 1320 VkMemoryHeapFlags flags; 1321} VkMemoryHeap; 1322 1323typedef struct { 1324 uint32_t memoryTypeCount; 1325 VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES]; 1326 uint32_t memoryHeapCount; 1327 VkMemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS]; 1328} VkPhysicalDeviceMemoryProperties; 1329 1330typedef struct { 1331 VkStructureType sType; 1332 const void* pNext; 1333 VkDeviceQueueCreateFlags flags; 1334 uint32_t queueFamilyIndex; 1335 uint32_t queuePriorityCount; 1336 const float* pQueuePriorities; 1337} VkDeviceQueueCreateInfo; 1338 1339typedef struct { 1340 VkStructureType sType; 1341 const void* pNext; 1342 VkDeviceCreateFlags flags; 1343 uint32_t requestedQueueCount; 1344 const VkDeviceQueueCreateInfo* pRequestedQueues; 1345 uint32_t enabledLayerNameCount; 1346 const char*const* ppEnabledLayerNames; 1347 uint32_t enabledExtensionNameCount; 1348 const char*const* ppEnabledExtensionNames; 1349 const VkPhysicalDeviceFeatures* pEnabledFeatures; 1350} VkDeviceCreateInfo; 1351 1352typedef struct { 1353 char extensionName[VK_MAX_EXTENSION_NAME]; 1354 uint32_t specVersion; 1355} VkExtensionProperties; 1356 1357typedef struct { 1358 char layerName[VK_MAX_EXTENSION_NAME]; 1359 uint32_t specVersion; 1360 uint32_t implementationVersion; 1361 char description[VK_MAX_DESCRIPTION]; 1362} VkLayerProperties; 1363 1364typedef struct { 1365 VkStructureType sType; 1366 const void* pNext; 1367 uint32_t waitSemaphoreCount; 1368 const VkSemaphore* pWaitSemaphores; 1369 uint32_t commandBufferCount; 1370 const VkCommandBuffer* pCommandBuffers; 1371 uint32_t signalSemaphoreCount; 1372 const VkSemaphore* pSignalSemaphores; 1373} VkSubmitInfo; 1374 1375typedef struct { 1376 VkStructureType sType; 1377 const void* pNext; 1378 VkDeviceSize allocationSize; 1379 uint32_t memoryTypeIndex; 1380} VkMemoryAllocateInfo; 1381 1382typedef struct { 1383 VkStructureType sType; 1384 const void* pNext; 1385 VkDeviceMemory memory; 1386 VkDeviceSize offset; 1387 VkDeviceSize size; 1388} VkMappedMemoryRange; 1389 1390typedef struct { 1391 VkDeviceSize size; 1392 VkDeviceSize alignment; 1393 uint32_t memoryTypeBits; 1394} VkMemoryRequirements; 1395 1396typedef struct { 1397 VkImageAspectFlagBits aspect; 1398 VkExtent3D imageGranularity; 1399 VkSparseImageFormatFlags flags; 1400} VkSparseImageFormatProperties; 1401 1402typedef struct { 1403 VkSparseImageFormatProperties formatProperties; 1404 uint32_t imageMipTailStartLOD; 1405 VkDeviceSize imageMipTailSize; 1406 VkDeviceSize imageMipTailOffset; 1407 VkDeviceSize imageMipTailStride; 1408} VkSparseImageMemoryRequirements; 1409 1410typedef struct { 1411 VkDeviceSize resourceOffset; 1412 VkDeviceSize size; 1413 VkDeviceMemory memory; 1414 VkDeviceSize memoryOffset; 1415 VkSparseMemoryBindFlags flags; 1416} VkSparseMemoryBind; 1417 1418typedef struct { 1419 VkBuffer buffer; 1420 uint32_t bindCount; 1421 const VkSparseMemoryBind* pBinds; 1422} VkSparseBufferMemoryBindInfo; 1423 1424typedef struct { 1425 VkImage image; 1426 uint32_t bindCount; 1427 const VkSparseMemoryBind* pBinds; 1428} VkSparseImageOpaqueMemoryBindInfo; 1429 1430typedef struct { 1431 VkImageAspectFlagBits aspect; 1432 uint32_t mipLevel; 1433 uint32_t arrayLayer; 1434} VkImageSubresource; 1435 1436typedef struct { 1437 int32_t x; 1438 int32_t y; 1439 int32_t z; 1440} VkOffset3D; 1441 1442typedef struct { 1443 VkImageSubresource subresource; 1444 VkOffset3D offset; 1445 VkExtent3D extent; 1446 VkDeviceMemory memory; 1447 VkDeviceSize memoryOffset; 1448 VkSparseMemoryBindFlags flags; 1449} VkSparseImageMemoryBind; 1450 1451typedef struct { 1452 VkImage image; 1453 uint32_t bindCount; 1454 const VkSparseImageMemoryBind* pBinds; 1455} VkSparseImageMemoryBindInfo; 1456 1457typedef struct { 1458 VkStructureType sType; 1459 const void* pNext; 1460 uint32_t waitSemaphoreCount; 1461 const VkSemaphore* pWaitSemaphores; 1462 uint32_t bufferBindCount; 1463 const VkSparseBufferMemoryBindInfo* pBufferBinds; 1464 uint32_t imageOpaqueBindCount; 1465 const VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds; 1466 uint32_t imageBindCount; 1467 const VkSparseImageMemoryBindInfo* pImageBinds; 1468 uint32_t signalSemaphoreCount; 1469 const VkSemaphore* pSignalSemaphores; 1470} VkBindSparseInfo; 1471 1472typedef struct { 1473 VkStructureType sType; 1474 const void* pNext; 1475 VkFenceCreateFlags flags; 1476} VkFenceCreateInfo; 1477 1478typedef struct { 1479 VkStructureType sType; 1480 const void* pNext; 1481 VkSemaphoreCreateFlags flags; 1482} VkSemaphoreCreateInfo; 1483 1484typedef struct { 1485 VkStructureType sType; 1486 const void* pNext; 1487 VkEventCreateFlags flags; 1488} VkEventCreateInfo; 1489 1490typedef struct { 1491 VkStructureType sType; 1492 const void* pNext; 1493 VkQueryPoolCreateFlags flags; 1494 VkQueryType queryType; 1495 uint32_t slots; 1496 VkQueryPipelineStatisticFlags pipelineStatistics; 1497} VkQueryPoolCreateInfo; 1498 1499typedef struct { 1500 VkStructureType sType; 1501 const void* pNext; 1502 VkBufferCreateFlags flags; 1503 VkDeviceSize size; 1504 VkBufferUsageFlags usage; 1505 VkSharingMode sharingMode; 1506 uint32_t queueFamilyIndexCount; 1507 const uint32_t* pQueueFamilyIndices; 1508} VkBufferCreateInfo; 1509 1510typedef struct { 1511 VkStructureType sType; 1512 const void* pNext; 1513 VkBufferViewCreateFlags flags; 1514 VkBuffer buffer; 1515 VkFormat format; 1516 VkDeviceSize offset; 1517 VkDeviceSize range; 1518} VkBufferViewCreateInfo; 1519 1520typedef struct { 1521 VkStructureType sType; 1522 const void* pNext; 1523 VkImageCreateFlags flags; 1524 VkImageType imageType; 1525 VkFormat format; 1526 VkExtent3D extent; 1527 uint32_t mipLevels; 1528 uint32_t arrayLayers; 1529 uint32_t samples; 1530 VkImageTiling tiling; 1531 VkImageUsageFlags usage; 1532 VkSharingMode sharingMode; 1533 uint32_t queueFamilyIndexCount; 1534 const uint32_t* pQueueFamilyIndices; 1535 VkImageLayout initialLayout; 1536} VkImageCreateInfo; 1537 1538typedef struct { 1539 VkDeviceSize offset; 1540 VkDeviceSize size; 1541 VkDeviceSize rowPitch; 1542 VkDeviceSize depthPitch; 1543} VkSubresourceLayout; 1544 1545typedef struct { 1546 VkChannelSwizzle r; 1547 VkChannelSwizzle g; 1548 VkChannelSwizzle b; 1549 VkChannelSwizzle a; 1550} VkChannelMapping; 1551 1552typedef struct { 1553 VkImageAspectFlags aspectMask; 1554 uint32_t baseMipLevel; 1555 uint32_t levelCount; 1556 uint32_t baseArrayLayer; 1557 uint32_t layerCount; 1558} VkImageSubresourceRange; 1559 1560typedef struct { 1561 VkStructureType sType; 1562 const void* pNext; 1563 VkImageViewCreateFlags flags; 1564 VkImage image; 1565 VkImageViewType viewType; 1566 VkFormat format; 1567 VkChannelMapping channels; 1568 VkImageSubresourceRange subresourceRange; 1569} VkImageViewCreateInfo; 1570 1571typedef struct { 1572 VkStructureType sType; 1573 const void* pNext; 1574 VkShaderModuleCreateFlags flags; 1575 size_t codeSize; 1576 const uint32_t* pCode; 1577} VkShaderModuleCreateInfo; 1578 1579typedef struct { 1580 VkStructureType sType; 1581 const void* pNext; 1582 VkShaderCreateFlags flags; 1583 VkShaderModule module; 1584 const char* pName; 1585 VkShaderStageFlagBits stage; 1586} VkShaderCreateInfo; 1587 1588typedef struct { 1589 VkStructureType sType; 1590 const void* pNext; 1591 VkPipelineCacheCreateFlags flags; 1592 size_t initialDataSize; 1593 const void* pInitialData; 1594} VkPipelineCacheCreateInfo; 1595 1596typedef struct { 1597 uint32_t constantId; 1598 uint32_t offset; 1599 size_t size; 1600} VkSpecializationMapEntry; 1601 1602typedef struct { 1603 uint32_t mapEntryCount; 1604 const VkSpecializationMapEntry* pMapEntries; 1605 size_t dataSize; 1606 const void* pData; 1607} VkSpecializationInfo; 1608 1609typedef struct { 1610 VkStructureType sType; 1611 const void* pNext; 1612 VkPipelineShaderStageCreateFlags flags; 1613 VkShader shader; 1614 const VkSpecializationInfo* pSpecializationInfo; 1615} VkPipelineShaderStageCreateInfo; 1616 1617typedef struct { 1618 uint32_t binding; 1619 uint32_t stride; 1620 VkVertexInputStepRate stepRate; 1621} VkVertexInputBindingDescription; 1622 1623typedef struct { 1624 uint32_t location; 1625 uint32_t binding; 1626 VkFormat format; 1627 uint32_t offset; 1628} VkVertexInputAttributeDescription; 1629 1630typedef struct { 1631 VkStructureType sType; 1632 const void* pNext; 1633 VkPipelineVertexInputStateCreateFlags flags; 1634 uint32_t vertexBindingDescriptionCount; 1635 const VkVertexInputBindingDescription* pVertexBindingDescriptions; 1636 uint32_t vertexAttributeDescriptionCount; 1637 const VkVertexInputAttributeDescription* pVertexAttributeDescriptions; 1638} VkPipelineVertexInputStateCreateInfo; 1639 1640typedef struct { 1641 VkStructureType sType; 1642 const void* pNext; 1643 VkPipelineInputAssemblyStateCreateFlags flags; 1644 VkPrimitiveTopology topology; 1645 VkBool32 primitiveRestartEnable; 1646} VkPipelineInputAssemblyStateCreateInfo; 1647 1648typedef struct { 1649 VkStructureType sType; 1650 const void* pNext; 1651 VkPipelineTesselationStateCreateFlags flags; 1652 uint32_t patchControlPoints; 1653} VkPipelineTessellationStateCreateInfo; 1654 1655typedef struct { 1656 float originX; 1657 float originY; 1658 float width; 1659 float height; 1660 float minDepth; 1661 float maxDepth; 1662} VkViewport; 1663 1664typedef struct { 1665 int32_t x; 1666 int32_t y; 1667} VkOffset2D; 1668 1669typedef struct { 1670 int32_t width; 1671 int32_t height; 1672} VkExtent2D; 1673 1674typedef struct { 1675 VkOffset2D offset; 1676 VkExtent2D extent; 1677} VkRect2D; 1678 1679typedef struct { 1680 VkStructureType sType; 1681 const void* pNext; 1682 VkPipelineViewportStateCreateFlags flags; 1683 uint32_t viewportCount; 1684 const VkViewport* pViewports; 1685 uint32_t scissorCount; 1686 const VkRect2D* pScissors; 1687} VkPipelineViewportStateCreateInfo; 1688 1689typedef struct { 1690 VkStructureType sType; 1691 const void* pNext; 1692 VkPipelineRasterizationStateCreateFlags flags; 1693 VkBool32 depthClampEnable; 1694 VkBool32 rasterizerDiscardEnable; 1695 VkFillMode fillMode; 1696 VkCullModeFlags cullMode; 1697 VkFrontFace frontFace; 1698 VkBool32 depthBiasEnable; 1699 float depthBiasConstantFactor; 1700 float depthBiasClamp; 1701 float depthBiasSlopeFactor; 1702 float lineWidth; 1703} VkPipelineRasterizationStateCreateInfo; 1704 1705typedef struct { 1706 VkStructureType sType; 1707 const void* pNext; 1708 VkPipelineMultisampleStateCreateFlags flags; 1709 uint32_t rasterizationSamples; 1710 VkBool32 sampleShadingEnable; 1711 float minSampleShading; 1712 const VkSampleMask* pSampleMask; 1713 VkBool32 alphaToCoverageEnable; 1714 VkBool32 alphaToOneEnable; 1715} VkPipelineMultisampleStateCreateInfo; 1716 1717typedef struct { 1718 VkStencilOp stencilFailOp; 1719 VkStencilOp stencilPassOp; 1720 VkStencilOp stencilDepthFailOp; 1721 VkCompareOp stencilCompareOp; 1722 uint32_t stencilCompareMask; 1723 uint32_t stencilWriteMask; 1724 uint32_t stencilReference; 1725} VkStencilOpState; 1726 1727typedef struct { 1728 VkStructureType sType; 1729 const void* pNext; 1730 VkPipelineDepthStencilStateCreateFlags flags; 1731 VkBool32 depthTestEnable; 1732 VkBool32 depthWriteEnable; 1733 VkCompareOp depthCompareOp; 1734 VkBool32 depthBoundsTestEnable; 1735 VkBool32 stencilTestEnable; 1736 VkStencilOpState front; 1737 VkStencilOpState back; 1738 float minDepthBounds; 1739 float maxDepthBounds; 1740} VkPipelineDepthStencilStateCreateInfo; 1741 1742typedef struct { 1743 VkBool32 blendEnable; 1744 VkBlend srcBlendColor; 1745 VkBlend dstBlendColor; 1746 VkBlendOp blendOpColor; 1747 VkBlend srcBlendAlpha; 1748 VkBlend dstBlendAlpha; 1749 VkBlendOp blendOpAlpha; 1750 VkChannelFlags channelWriteMask; 1751} VkPipelineColorBlendAttachmentState; 1752 1753typedef struct { 1754 VkStructureType sType; 1755 const void* pNext; 1756 VkPipelineColorBlendStateCreateFlags flags; 1757 VkBool32 logicOpEnable; 1758 VkLogicOp logicOp; 1759 uint32_t attachmentCount; 1760 const VkPipelineColorBlendAttachmentState* pAttachments; 1761 float blendConstants[4]; 1762} VkPipelineColorBlendStateCreateInfo; 1763 1764typedef struct { 1765 VkStructureType sType; 1766 const void* pNext; 1767 VkPipelineDynamicStateCreateFlags flags; 1768 uint32_t dynamicStateCount; 1769 const VkDynamicState* pDynamicStates; 1770} VkPipelineDynamicStateCreateInfo; 1771 1772typedef struct { 1773 VkStructureType sType; 1774 const void* pNext; 1775 VkPipelineCreateFlags flags; 1776 uint32_t stageCount; 1777 const VkPipelineShaderStageCreateInfo* pStages; 1778 const VkPipelineVertexInputStateCreateInfo* pVertexInputState; 1779 const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState; 1780 const VkPipelineTessellationStateCreateInfo* pTessellationState; 1781 const VkPipelineViewportStateCreateInfo* pViewportState; 1782 const VkPipelineRasterizationStateCreateInfo* pRasterizationState; 1783 const VkPipelineMultisampleStateCreateInfo* pMultisampleState; 1784 const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState; 1785 const VkPipelineColorBlendStateCreateInfo* pColorBlendState; 1786 const VkPipelineDynamicStateCreateInfo* pDynamicState; 1787 VkPipelineLayout layout; 1788 VkRenderPass renderPass; 1789 uint32_t subpass; 1790 VkPipeline basePipelineHandle; 1791 int32_t basePipelineIndex; 1792} VkGraphicsPipelineCreateInfo; 1793 1794typedef struct { 1795 VkStructureType sType; 1796 const void* pNext; 1797 VkPipelineCreateFlags flags; 1798 VkPipelineShaderStageCreateInfo stage; 1799 VkPipelineLayout layout; 1800 VkPipeline basePipelineHandle; 1801 int32_t basePipelineIndex; 1802} VkComputePipelineCreateInfo; 1803 1804typedef struct { 1805 VkShaderStageFlags stageFlags; 1806 uint32_t offset; 1807 uint32_t size; 1808} VkPushConstantRange; 1809 1810typedef struct { 1811 VkStructureType sType; 1812 const void* pNext; 1813 VkPipelineLayoutCreateFlags flags; 1814 uint32_t setLayoutCount; 1815 const VkDescriptorSetLayout* pSetLayouts; 1816 uint32_t pushConstantRangeCount; 1817 const VkPushConstantRange* pPushConstantRanges; 1818} VkPipelineLayoutCreateInfo; 1819 1820typedef struct { 1821 VkStructureType sType; 1822 const void* pNext; 1823 VkSamplerCreateFlags flags; 1824 VkFilter magFilter; 1825 VkFilter minFilter; 1826 VkSamplerMipmapMode mipmapMode; 1827 VkSamplerAddressMode addressModeU; 1828 VkSamplerAddressMode addressModeV; 1829 VkSamplerAddressMode addressModeW; 1830 float mipLodBias; 1831 float maxAnisotropy; 1832 VkBool32 compareEnable; 1833 VkCompareOp compareOp; 1834 float minLod; 1835 float maxLod; 1836 VkBorderColor borderColor; 1837 VkBool32 unnormalizedCoordinates; 1838} VkSamplerCreateInfo; 1839 1840typedef struct { 1841 VkDescriptorType descriptorType; 1842 uint32_t arraySize; 1843 VkShaderStageFlags stageFlags; 1844 const VkSampler* pImmutableSamplers; 1845} VkDescriptorSetLayoutBinding; 1846 1847typedef struct { 1848 VkStructureType sType; 1849 const void* pNext; 1850 VkDescriptorSetLayoutCreateFlags flags; 1851 uint32_t bindingCount; 1852 const VkDescriptorSetLayoutBinding* pBindings; 1853} VkDescriptorSetLayoutCreateInfo; 1854 1855typedef struct { 1856 VkDescriptorType type; 1857 uint32_t descriptorCount; 1858} VkDescriptorTypeCount; 1859 1860typedef struct { 1861 VkStructureType sType; 1862 const void* pNext; 1863 VkDescriptorPoolCreateFlags flags; 1864 uint32_t maxSets; 1865 uint32_t typeCount; 1866 const VkDescriptorTypeCount* pTypeCounts; 1867} VkDescriptorPoolCreateInfo; 1868 1869typedef struct { 1870 VkStructureType sType; 1871 const void* pNext; 1872 VkDescriptorPool descriptorPool; 1873 uint32_t setLayoutCount; 1874 const VkDescriptorSetLayout* pSetLayouts; 1875} VkDescriptorSetAllocateInfo; 1876 1877typedef struct { 1878 VkSampler sampler; 1879 VkImageView imageView; 1880 VkImageLayout imageLayout; 1881} VkDescriptorImageInfo; 1882 1883typedef struct { 1884 VkBuffer buffer; 1885 VkDeviceSize offset; 1886 VkDeviceSize range; 1887} VkDescriptorBufferInfo; 1888 1889typedef struct { 1890 VkStructureType sType; 1891 const void* pNext; 1892 VkDescriptorSet dstSet; 1893 uint32_t dstBinding; 1894 uint32_t dstArrayElement; 1895 uint32_t descriptorCount; 1896 VkDescriptorType descriptorType; 1897 const VkDescriptorImageInfo* pImageInfo; 1898 const VkDescriptorBufferInfo* pBufferInfo; 1899 const VkBufferView* pTexelBufferView; 1900} VkWriteDescriptorSet; 1901 1902typedef struct { 1903 VkStructureType sType; 1904 const void* pNext; 1905 VkDescriptorSet srcSet; 1906 uint32_t srcBinding; 1907 uint32_t srcArrayElement; 1908 VkDescriptorSet dstSet; 1909 uint32_t dstBinding; 1910 uint32_t dstArrayElement; 1911 uint32_t descriptorCount; 1912} VkCopyDescriptorSet; 1913 1914typedef struct { 1915 VkStructureType sType; 1916 const void* pNext; 1917 VkFramebufferCreateFlags flags; 1918 VkRenderPass renderPass; 1919 uint32_t attachmentCount; 1920 const VkImageView* pAttachments; 1921 uint32_t width; 1922 uint32_t height; 1923 uint32_t layers; 1924} VkFramebufferCreateInfo; 1925 1926typedef struct { 1927 VkAttachmentDescriptionFlags flags; 1928 VkFormat format; 1929 uint32_t samples; 1930 VkAttachmentLoadOp loadOp; 1931 VkAttachmentStoreOp storeOp; 1932 VkAttachmentLoadOp stencilLoadOp; 1933 VkAttachmentStoreOp stencilStoreOp; 1934 VkImageLayout initialLayout; 1935 VkImageLayout finalLayout; 1936} VkAttachmentDescription; 1937 1938typedef struct { 1939 uint32_t attachment; 1940 VkImageLayout layout; 1941} VkAttachmentReference; 1942 1943typedef struct { 1944 VkSubpassDescriptionFlags flags; 1945 VkPipelineBindPoint pipelineBindPoint; 1946 uint32_t inputAttachmentCount; 1947 const VkAttachmentReference* pInputAttachments; 1948 uint32_t colorAttachmentCount; 1949 const VkAttachmentReference* pColorAttachments; 1950 const VkAttachmentReference* pResolveAttachments; 1951 const VkAttachmentReference* pDepthStencilAttachment; 1952 uint32_t preserveAttachmentCount; 1953 const VkAttachmentReference* pPreserveAttachments; 1954} VkSubpassDescription; 1955 1956typedef struct { 1957 uint32_t srcSubpass; 1958 uint32_t dstSubpass; 1959 VkPipelineStageFlags srcStageMask; 1960 VkPipelineStageFlags dstStageMask; 1961 VkMemoryOutputFlags outputMask; 1962 VkMemoryInputFlags inputMask; 1963 VkDependencyFlags dependencyFlags; 1964} VkSubpassDependency; 1965 1966typedef struct { 1967 VkStructureType sType; 1968 const void* pNext; 1969 VkRenderPassCreateFlags flags; 1970 uint32_t attachmentCount; 1971 const VkAttachmentDescription* pAttachments; 1972 uint32_t subpassCount; 1973 const VkSubpassDescription* pSubpasses; 1974 uint32_t dependencyCount; 1975 const VkSubpassDependency* pDependencies; 1976} VkRenderPassCreateInfo; 1977 1978typedef struct { 1979 VkStructureType sType; 1980 const void* pNext; 1981 VkCommandPoolCreateFlags flags; 1982 uint32_t queueFamilyIndex; 1983} VkCommandPoolCreateInfo; 1984 1985typedef struct { 1986 VkStructureType sType; 1987 const void* pNext; 1988 VkCommandPool commandPool; 1989 VkCommandBufferLevel level; 1990 uint32_t bufferCount; 1991} VkCommandBufferAllocateInfo; 1992 1993typedef struct { 1994 VkStructureType sType; 1995 const void* pNext; 1996 VkCommandBufferUsageFlags flags; 1997 VkRenderPass renderPass; 1998 uint32_t subpass; 1999 VkFramebuffer framebuffer; 2000} VkCommandBufferBeginInfo; 2001 2002typedef struct { 2003 VkDeviceSize srcOffset; 2004 VkDeviceSize dstOffset; 2005 VkDeviceSize size; 2006} VkBufferCopy; 2007 2008typedef struct { 2009 VkImageAspectFlags aspect; 2010 uint32_t mipLevel; 2011 uint32_t baseArrayLayer; 2012 uint32_t layerCount; 2013} VkImageSubresourceCopy; 2014 2015typedef struct { 2016 VkImageSubresourceCopy srcSubresource; 2017 VkOffset3D srcOffset; 2018 VkImageSubresourceCopy dstSubresource; 2019 VkOffset3D dstOffset; 2020 VkExtent3D extent; 2021} VkImageCopy; 2022 2023typedef struct { 2024 VkImageSubresourceCopy srcSubresource; 2025 VkOffset3D srcOffset; 2026 VkExtent3D srcExtent; 2027 VkImageSubresourceCopy dstSubresource; 2028 VkOffset3D dstOffset; 2029 VkExtent3D dstExtent; 2030} VkImageBlit; 2031 2032typedef struct { 2033 VkDeviceSize bufferOffset; 2034 uint32_t bufferRowLength; 2035 uint32_t bufferImageHeight; 2036 VkImageSubresourceCopy imageSubresource; 2037 VkOffset3D imageOffset; 2038 VkExtent3D imageExtent; 2039} VkBufferImageCopy; 2040 2041typedef union { 2042 float float32[4]; 2043 int32_t int32[4]; 2044 uint32_t uint32[4]; 2045} VkClearColorValue; 2046 2047typedef struct { 2048 float depth; 2049 uint32_t stencil; 2050} VkClearDepthStencilValue; 2051 2052typedef union { 2053 VkClearColorValue color; 2054 VkClearDepthStencilValue depthStencil; 2055} VkClearValue; 2056 2057typedef struct { 2058 VkImageAspectFlags aspectMask; 2059 uint32_t colorAttachment; 2060 VkClearValue clearValue; 2061} VkClearAttachment; 2062 2063typedef struct { 2064 VkRect2D rect; 2065 uint32_t baseArrayLayer; 2066 uint32_t layerCount; 2067} VkClearRect; 2068 2069typedef struct { 2070 VkImageSubresourceCopy srcSubresource; 2071 VkOffset3D srcOffset; 2072 VkImageSubresourceCopy dstSubresource; 2073 VkOffset3D dstOffset; 2074 VkExtent3D extent; 2075} VkImageResolve; 2076 2077typedef struct { 2078 VkStructureType sType; 2079 const void* pNext; 2080 VkRenderPass renderPass; 2081 VkFramebuffer framebuffer; 2082 VkRect2D renderArea; 2083 uint32_t clearValueCount; 2084 const VkClearValue* pClearValues; 2085} VkRenderPassBeginInfo; 2086 2087typedef struct { 2088 VkStructureType sType; 2089 const void* pNext; 2090 VkMemoryOutputFlags outputMask; 2091 VkMemoryInputFlags inputMask; 2092 uint32_t srcQueueFamilyIndex; 2093 uint32_t dstQueueFamilyIndex; 2094 VkBuffer buffer; 2095 VkDeviceSize offset; 2096 VkDeviceSize size; 2097} VkBufferMemoryBarrier; 2098 2099typedef struct { 2100 uint32_t x; 2101 uint32_t y; 2102 uint32_t z; 2103} VkDispatchIndirectCommand; 2104 2105typedef struct { 2106 uint32_t indexCount; 2107 uint32_t instanceCount; 2108 uint32_t firstIndex; 2109 int32_t vertexOffset; 2110 uint32_t firstInstance; 2111} VkDrawIndexedIndirectCommand; 2112 2113typedef struct { 2114 uint32_t vertexCount; 2115 uint32_t instanceCount; 2116 uint32_t firstVertex; 2117 uint32_t firstInstance; 2118} VkDrawIndirectCommand; 2119 2120typedef struct { 2121 VkStructureType sType; 2122 const void* pNext; 2123 VkMemoryOutputFlags outputMask; 2124 VkMemoryInputFlags inputMask; 2125 VkImageLayout oldLayout; 2126 VkImageLayout newLayout; 2127 uint32_t srcQueueFamilyIndex; 2128 uint32_t dstQueueFamilyIndex; 2129 VkImage image; 2130 VkImageSubresourceRange subresourceRange; 2131} VkImageMemoryBarrier; 2132 2133typedef struct { 2134 VkStructureType sType; 2135 const void* pNext; 2136 VkMemoryOutputFlags outputMask; 2137 VkMemoryInputFlags inputMask; 2138} VkMemoryBarrier; 2139 2140 2141typedef VkResult (VKAPI *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance); 2142typedef void (VKAPI *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks* pAllocator); 2143typedef VkResult (VKAPI *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); 2144typedef void (VKAPI *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures); 2145typedef void (VKAPI *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties); 2146typedef void (VKAPI *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties); 2147typedef void (VKAPI *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties); 2148typedef void (VKAPI *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties); 2149typedef void (VKAPI *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties); 2150typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName); 2151typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName); 2152typedef VkResult (VKAPI *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice); 2153typedef void (VKAPI *PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks* pAllocator); 2154typedef VkResult (VKAPI *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); 2155typedef VkResult (VKAPI *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); 2156typedef VkResult (VKAPI *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties); 2157typedef VkResult (VKAPI *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties); 2158typedef void (VKAPI *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue); 2159typedef VkResult (VKAPI *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence); 2160typedef VkResult (VKAPI *PFN_vkQueueWaitIdle)(VkQueue queue); 2161typedef VkResult (VKAPI *PFN_vkDeviceWaitIdle)(VkDevice device); 2162typedef VkResult (VKAPI *PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory); 2163typedef void (VKAPI *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator); 2164typedef VkResult (VKAPI *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData); 2165typedef void (VKAPI *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory); 2166typedef VkResult (VKAPI *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); 2167typedef VkResult (VKAPI *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); 2168typedef void (VKAPI *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes); 2169typedef VkResult (VKAPI *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset); 2170typedef VkResult (VKAPI *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset); 2171typedef void (VKAPI *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements); 2172typedef void (VKAPI *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements); 2173typedef void (VKAPI *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements); 2174typedef void (VKAPI *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties); 2175typedef VkResult (VKAPI *PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence); 2176typedef VkResult (VKAPI *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); 2177typedef void (VKAPI *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator); 2178typedef VkResult (VKAPI *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences); 2179typedef VkResult (VKAPI *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence); 2180typedef VkResult (VKAPI *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout); 2181typedef VkResult (VKAPI *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore); 2182typedef void (VKAPI *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator); 2183typedef VkResult (VKAPI *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent); 2184typedef void (VKAPI *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator); 2185typedef VkResult (VKAPI *PFN_vkGetEventStatus)(VkDevice device, VkEvent event); 2186typedef VkResult (VKAPI *PFN_vkSetEvent)(VkDevice device, VkEvent event); 2187typedef VkResult (VKAPI *PFN_vkResetEvent)(VkDevice device, VkEvent event); 2188typedef VkResult (VKAPI *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool); 2189typedef void (VKAPI *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator); 2190typedef VkResult (VKAPI *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags); 2191typedef VkResult (VKAPI *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer); 2192typedef void (VKAPI *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator); 2193typedef VkResult (VKAPI *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView); 2194typedef void (VKAPI *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator); 2195typedef VkResult (VKAPI *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage); 2196typedef void (VKAPI *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator); 2197typedef void (VKAPI *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout); 2198typedef VkResult (VKAPI *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView); 2199typedef void (VKAPI *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator); 2200typedef VkResult (VKAPI *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule); 2201typedef void (VKAPI *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator); 2202typedef VkResult (VKAPI *PFN_vkCreateShader)(VkDevice device, const VkShaderCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShader* pShader); 2203typedef void (VKAPI *PFN_vkDestroyShader)(VkDevice device, VkShader shader, const VkAllocationCallbacks* pAllocator); 2204typedef VkResult (VKAPI *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache); 2205typedef void (VKAPI *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator); 2206typedef VkResult (VKAPI *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData); 2207typedef VkResult (VKAPI *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches); 2208typedef VkResult (VKAPI *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); 2209typedef VkResult (VKAPI *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); 2210typedef void (VKAPI *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator); 2211typedef VkResult (VKAPI *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout); 2212typedef void (VKAPI *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator); 2213typedef VkResult (VKAPI *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler); 2214typedef void (VKAPI *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator); 2215typedef VkResult (VKAPI *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout); 2216typedef void (VKAPI *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator); 2217typedef VkResult (VKAPI *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool); 2218typedef void (VKAPI *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator); 2219typedef VkResult (VKAPI *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags); 2220typedef VkResult (VKAPI *PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets); 2221typedef VkResult (VKAPI *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets); 2222typedef void (VKAPI *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies); 2223typedef VkResult (VKAPI *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer); 2224typedef void (VKAPI *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator); 2225typedef VkResult (VKAPI *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); 2226typedef void (VKAPI *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator); 2227typedef void (VKAPI *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity); 2228typedef VkResult (VKAPI *PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool); 2229typedef void (VKAPI *PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool CommandPool, const VkAllocationCallbacks* pAllocator); 2230typedef VkResult (VKAPI *PFN_vkResetCommandPool)(VkDevice device, VkCommandPool CommandPool, VkCommandPoolResetFlags flags); 2231typedef VkResult (VKAPI *PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers); 2232typedef void (VKAPI *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool CommandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); 2233typedef VkResult (VKAPI *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo); 2234typedef VkResult (VKAPI *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer); 2235typedef VkResult (VKAPI *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags); 2236typedef void (VKAPI *PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); 2237typedef void (VKAPI *PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports); 2238typedef void (VKAPI *PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors); 2239typedef void (VKAPI *PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth); 2240typedef void (VKAPI *PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor); 2241typedef void (VKAPI *PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4]); 2242typedef void (VKAPI *PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds); 2243typedef void (VKAPI *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask); 2244typedef void (VKAPI *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask); 2245typedef void (VKAPI *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference); 2246typedef 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); 2247typedef void (VKAPI *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); 2248typedef void (VKAPI *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets); 2249typedef void (VKAPI *PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance); 2250typedef void (VKAPI *PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance); 2251typedef void (VKAPI *PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); 2252typedef void (VKAPI *PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); 2253typedef void (VKAPI *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z); 2254typedef void (VKAPI *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); 2255typedef void (VKAPI *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions); 2256typedef void (VKAPI *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions); 2257typedef void (VKAPI *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter); 2258typedef void (VKAPI *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions); 2259typedef void (VKAPI *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions); 2260typedef void (VKAPI *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint32_t* pData); 2261typedef void (VKAPI *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data); 2262typedef void (VKAPI *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); 2263typedef void (VKAPI *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); 2264typedef void (VKAPI *PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects); 2265typedef void (VKAPI *PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions); 2266typedef void (VKAPI *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); 2267typedef void (VKAPI *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); 2268typedef void (VKAPI *PFN_vkCmdWaitEvents)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers); 2269typedef void (VKAPI *PFN_vkCmdPipelineBarrier)(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers); 2270typedef void (VKAPI *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags); 2271typedef void (VKAPI *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot); 2272typedef void (VKAPI *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount); 2273typedef void (VKAPI *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot); 2274typedef void (VKAPI *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags); 2275typedef void (VKAPI *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* values); 2276typedef void (VKAPI *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents); 2277typedef void (VKAPI *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkRenderPassContents contents); 2278typedef void (VKAPI *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer); 2279typedef void (VKAPI *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount, const VkCommandBuffer* pCommandBuffers); 2280 2281#ifdef VK_PROTOTYPES 2282VkResult VKAPI vkCreateInstance( 2283 const VkInstanceCreateInfo* pCreateInfo, 2284 const VkAllocationCallbacks* pAllocator, 2285 VkInstance* pInstance); 2286 2287void VKAPI vkDestroyInstance( 2288 VkInstance instance, 2289 const VkAllocationCallbacks* pAllocator); 2290 2291VkResult VKAPI vkEnumeratePhysicalDevices( 2292 VkInstance instance, 2293 uint32_t* pPhysicalDeviceCount, 2294 VkPhysicalDevice* pPhysicalDevices); 2295 2296void VKAPI vkGetPhysicalDeviceFeatures( 2297 VkPhysicalDevice physicalDevice, 2298 VkPhysicalDeviceFeatures* pFeatures); 2299 2300void VKAPI vkGetPhysicalDeviceFormatProperties( 2301 VkPhysicalDevice physicalDevice, 2302 VkFormat format, 2303 VkFormatProperties* pFormatProperties); 2304 2305void VKAPI vkGetPhysicalDeviceImageFormatProperties( 2306 VkPhysicalDevice physicalDevice, 2307 VkFormat format, 2308 VkImageType type, 2309 VkImageTiling tiling, 2310 VkImageUsageFlags usage, 2311 VkImageCreateFlags flags, 2312 VkImageFormatProperties* pImageFormatProperties); 2313 2314void VKAPI vkGetPhysicalDeviceProperties( 2315 VkPhysicalDevice physicalDevice, 2316 VkPhysicalDeviceProperties* pProperties); 2317 2318void VKAPI vkGetPhysicalDeviceQueueFamilyProperties( 2319 VkPhysicalDevice physicalDevice, 2320 uint32_t* pQueueFamilyPropertyCount, 2321 VkQueueFamilyProperties* pQueueFamilyProperties); 2322 2323void VKAPI vkGetPhysicalDeviceMemoryProperties( 2324 VkPhysicalDevice physicalDevice, 2325 VkPhysicalDeviceMemoryProperties* pMemoryProperties); 2326 2327PFN_vkVoidFunction VKAPI vkGetInstanceProcAddr( 2328 VkInstance instance, 2329 const char* pName); 2330 2331PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr( 2332 VkDevice device, 2333 const char* pName); 2334 2335VkResult VKAPI vkCreateDevice( 2336 VkPhysicalDevice physicalDevice, 2337 const VkDeviceCreateInfo* pCreateInfo, 2338 const VkAllocationCallbacks* pAllocator, 2339 VkDevice* pDevice); 2340 2341void VKAPI vkDestroyDevice( 2342 VkDevice device, 2343 const VkAllocationCallbacks* pAllocator); 2344 2345VkResult VKAPI vkEnumerateInstanceExtensionProperties( 2346 const char* pLayerName, 2347 uint32_t* pPropertyCount, 2348 VkExtensionProperties* pProperties); 2349 2350VkResult VKAPI vkEnumerateDeviceExtensionProperties( 2351 VkPhysicalDevice physicalDevice, 2352 const char* pLayerName, 2353 uint32_t* pPropertyCount, 2354 VkExtensionProperties* pProperties); 2355 2356VkResult VKAPI vkEnumerateInstanceLayerProperties( 2357 uint32_t* pPropertyCount, 2358 VkLayerProperties* pProperties); 2359 2360VkResult VKAPI vkEnumerateDeviceLayerProperties( 2361 VkPhysicalDevice physicalDevice, 2362 uint32_t* pPropertyCount, 2363 VkLayerProperties* pProperties); 2364 2365void VKAPI vkGetDeviceQueue( 2366 VkDevice device, 2367 uint32_t queueFamilyIndex, 2368 uint32_t queueIndex, 2369 VkQueue* pQueue); 2370 2371VkResult VKAPI vkQueueSubmit( 2372 VkQueue queue, 2373 uint32_t submitCount, 2374 const VkSubmitInfo* pSubmits, 2375 VkFence fence); 2376 2377VkResult VKAPI vkQueueWaitIdle( 2378 VkQueue queue); 2379 2380VkResult VKAPI vkDeviceWaitIdle( 2381 VkDevice device); 2382 2383VkResult VKAPI vkAllocateMemory( 2384 VkDevice device, 2385 const VkMemoryAllocateInfo* pAllocateInfo, 2386 const VkAllocationCallbacks* pAllocator, 2387 VkDeviceMemory* pMemory); 2388 2389void VKAPI vkFreeMemory( 2390 VkDevice device, 2391 VkDeviceMemory memory, 2392 const VkAllocationCallbacks* pAllocator); 2393 2394VkResult VKAPI vkMapMemory( 2395 VkDevice device, 2396 VkDeviceMemory memory, 2397 VkDeviceSize offset, 2398 VkDeviceSize size, 2399 VkMemoryMapFlags flags, 2400 void** ppData); 2401 2402void VKAPI vkUnmapMemory( 2403 VkDevice device, 2404 VkDeviceMemory memory); 2405 2406VkResult VKAPI vkFlushMappedMemoryRanges( 2407 VkDevice device, 2408 uint32_t memoryRangeCount, 2409 const VkMappedMemoryRange* pMemoryRanges); 2410 2411VkResult VKAPI vkInvalidateMappedMemoryRanges( 2412 VkDevice device, 2413 uint32_t memoryRangeCount, 2414 const VkMappedMemoryRange* pMemoryRanges); 2415 2416void VKAPI vkGetDeviceMemoryCommitment( 2417 VkDevice device, 2418 VkDeviceMemory memory, 2419 VkDeviceSize* pCommittedMemoryInBytes); 2420 2421VkResult VKAPI vkBindBufferMemory( 2422 VkDevice device, 2423 VkBuffer buffer, 2424 VkDeviceMemory memory, 2425 VkDeviceSize memoryOffset); 2426 2427VkResult VKAPI vkBindImageMemory( 2428 VkDevice device, 2429 VkImage image, 2430 VkDeviceMemory memory, 2431 VkDeviceSize memoryOffset); 2432 2433void VKAPI vkGetBufferMemoryRequirements( 2434 VkDevice device, 2435 VkBuffer buffer, 2436 VkMemoryRequirements* pMemoryRequirements); 2437 2438void VKAPI vkGetImageMemoryRequirements( 2439 VkDevice device, 2440 VkImage image, 2441 VkMemoryRequirements* pMemoryRequirements); 2442 2443void VKAPI vkGetImageSparseMemoryRequirements( 2444 VkDevice device, 2445 VkImage image, 2446 uint32_t* pSparseMemoryRequirementCount, 2447 VkSparseImageMemoryRequirements* pSparseMemoryRequirements); 2448 2449void VKAPI vkGetPhysicalDeviceSparseImageFormatProperties( 2450 VkPhysicalDevice physicalDevice, 2451 VkFormat format, 2452 VkImageType type, 2453 uint32_t samples, 2454 VkImageUsageFlags usage, 2455 VkImageTiling tiling, 2456 uint32_t* pPropertyCount, 2457 VkSparseImageFormatProperties* pProperties); 2458 2459VkResult VKAPI vkQueueBindSparse( 2460 VkQueue queue, 2461 uint32_t bindInfoCount, 2462 const VkBindSparseInfo* pBindInfo, 2463 VkFence fence); 2464 2465VkResult VKAPI vkCreateFence( 2466 VkDevice device, 2467 const VkFenceCreateInfo* pCreateInfo, 2468 const VkAllocationCallbacks* pAllocator, 2469 VkFence* pFence); 2470 2471void VKAPI vkDestroyFence( 2472 VkDevice device, 2473 VkFence fence, 2474 const VkAllocationCallbacks* pAllocator); 2475 2476VkResult VKAPI vkResetFences( 2477 VkDevice device, 2478 uint32_t fenceCount, 2479 const VkFence* pFences); 2480 2481VkResult VKAPI vkGetFenceStatus( 2482 VkDevice device, 2483 VkFence fence); 2484 2485VkResult VKAPI vkWaitForFences( 2486 VkDevice device, 2487 uint32_t fenceCount, 2488 const VkFence* pFences, 2489 VkBool32 waitAll, 2490 uint64_t timeout); 2491 2492VkResult VKAPI vkCreateSemaphore( 2493 VkDevice device, 2494 const VkSemaphoreCreateInfo* pCreateInfo, 2495 const VkAllocationCallbacks* pAllocator, 2496 VkSemaphore* pSemaphore); 2497 2498void VKAPI vkDestroySemaphore( 2499 VkDevice device, 2500 VkSemaphore semaphore, 2501 const VkAllocationCallbacks* pAllocator); 2502 2503VkResult VKAPI vkCreateEvent( 2504 VkDevice device, 2505 const VkEventCreateInfo* pCreateInfo, 2506 const VkAllocationCallbacks* pAllocator, 2507 VkEvent* pEvent); 2508 2509void VKAPI vkDestroyEvent( 2510 VkDevice device, 2511 VkEvent event, 2512 const VkAllocationCallbacks* pAllocator); 2513 2514VkResult VKAPI vkGetEventStatus( 2515 VkDevice device, 2516 VkEvent event); 2517 2518VkResult VKAPI vkSetEvent( 2519 VkDevice device, 2520 VkEvent event); 2521 2522VkResult VKAPI vkResetEvent( 2523 VkDevice device, 2524 VkEvent event); 2525 2526VkResult VKAPI vkCreateQueryPool( 2527 VkDevice device, 2528 const VkQueryPoolCreateInfo* pCreateInfo, 2529 const VkAllocationCallbacks* pAllocator, 2530 VkQueryPool* pQueryPool); 2531 2532void VKAPI vkDestroyQueryPool( 2533 VkDevice device, 2534 VkQueryPool queryPool, 2535 const VkAllocationCallbacks* pAllocator); 2536 2537VkResult VKAPI vkGetQueryPoolResults( 2538 VkDevice device, 2539 VkQueryPool queryPool, 2540 uint32_t startQuery, 2541 uint32_t queryCount, 2542 size_t dataSize, 2543 void* pData, 2544 VkDeviceSize stride, 2545 VkQueryResultFlags flags); 2546 2547VkResult VKAPI vkCreateBuffer( 2548 VkDevice device, 2549 const VkBufferCreateInfo* pCreateInfo, 2550 const VkAllocationCallbacks* pAllocator, 2551 VkBuffer* pBuffer); 2552 2553void VKAPI vkDestroyBuffer( 2554 VkDevice device, 2555 VkBuffer buffer, 2556 const VkAllocationCallbacks* pAllocator); 2557 2558VkResult VKAPI vkCreateBufferView( 2559 VkDevice device, 2560 const VkBufferViewCreateInfo* pCreateInfo, 2561 const VkAllocationCallbacks* pAllocator, 2562 VkBufferView* pView); 2563 2564void VKAPI vkDestroyBufferView( 2565 VkDevice device, 2566 VkBufferView bufferView, 2567 const VkAllocationCallbacks* pAllocator); 2568 2569VkResult VKAPI vkCreateImage( 2570 VkDevice device, 2571 const VkImageCreateInfo* pCreateInfo, 2572 const VkAllocationCallbacks* pAllocator, 2573 VkImage* pImage); 2574 2575void VKAPI vkDestroyImage( 2576 VkDevice device, 2577 VkImage image, 2578 const VkAllocationCallbacks* pAllocator); 2579 2580void VKAPI vkGetImageSubresourceLayout( 2581 VkDevice device, 2582 VkImage image, 2583 const VkImageSubresource* pSubresource, 2584 VkSubresourceLayout* pLayout); 2585 2586VkResult VKAPI vkCreateImageView( 2587 VkDevice device, 2588 const VkImageViewCreateInfo* pCreateInfo, 2589 const VkAllocationCallbacks* pAllocator, 2590 VkImageView* pView); 2591 2592void VKAPI vkDestroyImageView( 2593 VkDevice device, 2594 VkImageView imageView, 2595 const VkAllocationCallbacks* pAllocator); 2596 2597VkResult VKAPI vkCreateShaderModule( 2598 VkDevice device, 2599 const VkShaderModuleCreateInfo* pCreateInfo, 2600 const VkAllocationCallbacks* pAllocator, 2601 VkShaderModule* pShaderModule); 2602 2603void VKAPI vkDestroyShaderModule( 2604 VkDevice device, 2605 VkShaderModule shaderModule, 2606 const VkAllocationCallbacks* pAllocator); 2607 2608VkResult VKAPI vkCreateShader( 2609 VkDevice device, 2610 const VkShaderCreateInfo* pCreateInfo, 2611 const VkAllocationCallbacks* pAllocator, 2612 VkShader* pShader); 2613 2614void VKAPI vkDestroyShader( 2615 VkDevice device, 2616 VkShader shader, 2617 const VkAllocationCallbacks* pAllocator); 2618 2619VkResult VKAPI vkCreatePipelineCache( 2620 VkDevice device, 2621 const VkPipelineCacheCreateInfo* pCreateInfo, 2622 const VkAllocationCallbacks* pAllocator, 2623 VkPipelineCache* pPipelineCache); 2624 2625void VKAPI vkDestroyPipelineCache( 2626 VkDevice device, 2627 VkPipelineCache pipelineCache, 2628 const VkAllocationCallbacks* pAllocator); 2629 2630VkResult VKAPI vkGetPipelineCacheData( 2631 VkDevice device, 2632 VkPipelineCache pipelineCache, 2633 size_t* pDataSize, 2634 void* pData); 2635 2636VkResult VKAPI vkMergePipelineCaches( 2637 VkDevice device, 2638 VkPipelineCache dstCache, 2639 uint32_t srcCacheCount, 2640 const VkPipelineCache* pSrcCaches); 2641 2642VkResult VKAPI vkCreateGraphicsPipelines( 2643 VkDevice device, 2644 VkPipelineCache pipelineCache, 2645 uint32_t createInfoCount, 2646 const VkGraphicsPipelineCreateInfo* pCreateInfos, 2647 const VkAllocationCallbacks* pAllocator, 2648 VkPipeline* pPipelines); 2649 2650VkResult VKAPI vkCreateComputePipelines( 2651 VkDevice device, 2652 VkPipelineCache pipelineCache, 2653 uint32_t createInfoCount, 2654 const VkComputePipelineCreateInfo* pCreateInfos, 2655 const VkAllocationCallbacks* pAllocator, 2656 VkPipeline* pPipelines); 2657 2658void VKAPI vkDestroyPipeline( 2659 VkDevice device, 2660 VkPipeline pipeline, 2661 const VkAllocationCallbacks* pAllocator); 2662 2663VkResult VKAPI vkCreatePipelineLayout( 2664 VkDevice device, 2665 const VkPipelineLayoutCreateInfo* pCreateInfo, 2666 const VkAllocationCallbacks* pAllocator, 2667 VkPipelineLayout* pPipelineLayout); 2668 2669void VKAPI vkDestroyPipelineLayout( 2670 VkDevice device, 2671 VkPipelineLayout pipelineLayout, 2672 const VkAllocationCallbacks* pAllocator); 2673 2674VkResult VKAPI vkCreateSampler( 2675 VkDevice device, 2676 const VkSamplerCreateInfo* pCreateInfo, 2677 const VkAllocationCallbacks* pAllocator, 2678 VkSampler* pSampler); 2679 2680void VKAPI vkDestroySampler( 2681 VkDevice device, 2682 VkSampler sampler, 2683 const VkAllocationCallbacks* pAllocator); 2684 2685VkResult VKAPI vkCreateDescriptorSetLayout( 2686 VkDevice device, 2687 const VkDescriptorSetLayoutCreateInfo* pCreateInfo, 2688 const VkAllocationCallbacks* pAllocator, 2689 VkDescriptorSetLayout* pSetLayout); 2690 2691void VKAPI vkDestroyDescriptorSetLayout( 2692 VkDevice device, 2693 VkDescriptorSetLayout descriptorSetLayout, 2694 const VkAllocationCallbacks* pAllocator); 2695 2696VkResult VKAPI vkCreateDescriptorPool( 2697 VkDevice device, 2698 const VkDescriptorPoolCreateInfo* pCreateInfo, 2699 const VkAllocationCallbacks* pAllocator, 2700 VkDescriptorPool* pDescriptorPool); 2701 2702void VKAPI vkDestroyDescriptorPool( 2703 VkDevice device, 2704 VkDescriptorPool descriptorPool, 2705 const VkAllocationCallbacks* pAllocator); 2706 2707VkResult VKAPI vkResetDescriptorPool( 2708 VkDevice device, 2709 VkDescriptorPool descriptorPool, 2710 VkDescriptorPoolResetFlags flags); 2711 2712VkResult VKAPI vkAllocateDescriptorSets( 2713 VkDevice device, 2714 const VkDescriptorSetAllocateInfo* pAllocateInfo, 2715 VkDescriptorSet* pDescriptorSets); 2716 2717VkResult VKAPI vkFreeDescriptorSets( 2718 VkDevice device, 2719 VkDescriptorPool descriptorPool, 2720 uint32_t descriptorSetCount, 2721 const VkDescriptorSet* pDescriptorSets); 2722 2723void VKAPI vkUpdateDescriptorSets( 2724 VkDevice device, 2725 uint32_t descriptorWriteCount, 2726 const VkWriteDescriptorSet* pDescriptorWrites, 2727 uint32_t descriptorCopyCount, 2728 const VkCopyDescriptorSet* pDescriptorCopies); 2729 2730VkResult VKAPI vkCreateFramebuffer( 2731 VkDevice device, 2732 const VkFramebufferCreateInfo* pCreateInfo, 2733 const VkAllocationCallbacks* pAllocator, 2734 VkFramebuffer* pFramebuffer); 2735 2736void VKAPI vkDestroyFramebuffer( 2737 VkDevice device, 2738 VkFramebuffer framebuffer, 2739 const VkAllocationCallbacks* pAllocator); 2740 2741VkResult VKAPI vkCreateRenderPass( 2742 VkDevice device, 2743 const VkRenderPassCreateInfo* pCreateInfo, 2744 const VkAllocationCallbacks* pAllocator, 2745 VkRenderPass* pRenderPass); 2746 2747void VKAPI vkDestroyRenderPass( 2748 VkDevice device, 2749 VkRenderPass renderPass, 2750 const VkAllocationCallbacks* pAllocator); 2751 2752void VKAPI vkGetRenderAreaGranularity( 2753 VkDevice device, 2754 VkRenderPass renderPass, 2755 VkExtent2D* pGranularity); 2756 2757VkResult VKAPI vkCreateCommandPool( 2758 VkDevice device, 2759 const VkCommandPoolCreateInfo* pCreateInfo, 2760 const VkAllocationCallbacks* pAllocator, 2761 VkCommandPool* pCommandPool); 2762 2763void VKAPI vkDestroyCommandPool( 2764 VkDevice device, 2765 VkCommandPool CommandPool, 2766 const VkAllocationCallbacks* pAllocator); 2767 2768VkResult VKAPI vkResetCommandPool( 2769 VkDevice device, 2770 VkCommandPool CommandPool, 2771 VkCommandPoolResetFlags flags); 2772 2773VkResult VKAPI vkAllocateCommandBuffers( 2774 VkDevice device, 2775 const VkCommandBufferAllocateInfo* pAllocateInfo, 2776 VkCommandBuffer* pCommandBuffers); 2777 2778void VKAPI vkFreeCommandBuffers( 2779 VkDevice device, 2780 VkCommandPool CommandPool, 2781 uint32_t commandBufferCount, 2782 const VkCommandBuffer* pCommandBuffers); 2783 2784VkResult VKAPI vkBeginCommandBuffer( 2785 VkCommandBuffer commandBuffer, 2786 const VkCommandBufferBeginInfo* pBeginInfo); 2787 2788VkResult VKAPI vkEndCommandBuffer( 2789 VkCommandBuffer commandBuffer); 2790 2791VkResult VKAPI vkResetCommandBuffer( 2792 VkCommandBuffer commandBuffer, 2793 VkCommandBufferResetFlags flags); 2794 2795void VKAPI vkCmdBindPipeline( 2796 VkCommandBuffer commandBuffer, 2797 VkPipelineBindPoint pipelineBindPoint, 2798 VkPipeline pipeline); 2799 2800void VKAPI vkCmdSetViewport( 2801 VkCommandBuffer commandBuffer, 2802 uint32_t viewportCount, 2803 const VkViewport* pViewports); 2804 2805void VKAPI vkCmdSetScissor( 2806 VkCommandBuffer commandBuffer, 2807 uint32_t scissorCount, 2808 const VkRect2D* pScissors); 2809 2810void VKAPI vkCmdSetLineWidth( 2811 VkCommandBuffer commandBuffer, 2812 float lineWidth); 2813 2814void VKAPI vkCmdSetDepthBias( 2815 VkCommandBuffer commandBuffer, 2816 float depthBiasConstantFactor, 2817 float depthBiasClamp, 2818 float depthBiasSlopeFactor); 2819 2820void VKAPI vkCmdSetBlendConstants( 2821 VkCommandBuffer commandBuffer, 2822 const float blendConstants[4]); 2823 2824void VKAPI vkCmdSetDepthBounds( 2825 VkCommandBuffer commandBuffer, 2826 float minDepthBounds, 2827 float maxDepthBounds); 2828 2829void VKAPI vkCmdSetStencilCompareMask( 2830 VkCommandBuffer commandBuffer, 2831 VkStencilFaceFlags faceMask, 2832 uint32_t stencilCompareMask); 2833 2834void VKAPI vkCmdSetStencilWriteMask( 2835 VkCommandBuffer commandBuffer, 2836 VkStencilFaceFlags faceMask, 2837 uint32_t stencilWriteMask); 2838 2839void VKAPI vkCmdSetStencilReference( 2840 VkCommandBuffer commandBuffer, 2841 VkStencilFaceFlags faceMask, 2842 uint32_t stencilReference); 2843 2844void VKAPI vkCmdBindDescriptorSets( 2845 VkCommandBuffer commandBuffer, 2846 VkPipelineBindPoint pipelineBindPoint, 2847 VkPipelineLayout layout, 2848 uint32_t firstSet, 2849 uint32_t descriptorSetCount, 2850 const VkDescriptorSet* pDescriptorSets, 2851 uint32_t dynamicOffsetCount, 2852 const uint32_t* pDynamicOffsets); 2853 2854void VKAPI vkCmdBindIndexBuffer( 2855 VkCommandBuffer commandBuffer, 2856 VkBuffer buffer, 2857 VkDeviceSize offset, 2858 VkIndexType indexType); 2859 2860void VKAPI vkCmdBindVertexBuffers( 2861 VkCommandBuffer commandBuffer, 2862 uint32_t startBinding, 2863 uint32_t bindingCount, 2864 const VkBuffer* pBuffers, 2865 const VkDeviceSize* pOffsets); 2866 2867void VKAPI vkCmdDraw( 2868 VkCommandBuffer commandBuffer, 2869 uint32_t vertexCount, 2870 uint32_t instanceCount, 2871 uint32_t firstVertex, 2872 uint32_t firstInstance); 2873 2874void VKAPI vkCmdDrawIndexed( 2875 VkCommandBuffer commandBuffer, 2876 uint32_t indexCount, 2877 uint32_t instanceCount, 2878 uint32_t firstIndex, 2879 int32_t vertexOffset, 2880 uint32_t firstInstance); 2881 2882void VKAPI vkCmdDrawIndirect( 2883 VkCommandBuffer commandBuffer, 2884 VkBuffer buffer, 2885 VkDeviceSize offset, 2886 uint32_t drawCount, 2887 uint32_t stride); 2888 2889void VKAPI vkCmdDrawIndexedIndirect( 2890 VkCommandBuffer commandBuffer, 2891 VkBuffer buffer, 2892 VkDeviceSize offset, 2893 uint32_t drawCount, 2894 uint32_t stride); 2895 2896void VKAPI vkCmdDispatch( 2897 VkCommandBuffer commandBuffer, 2898 uint32_t x, 2899 uint32_t y, 2900 uint32_t z); 2901 2902void VKAPI vkCmdDispatchIndirect( 2903 VkCommandBuffer commandBuffer, 2904 VkBuffer buffer, 2905 VkDeviceSize offset); 2906 2907void VKAPI vkCmdCopyBuffer( 2908 VkCommandBuffer commandBuffer, 2909 VkBuffer srcBuffer, 2910 VkBuffer dstBuffer, 2911 uint32_t regionCount, 2912 const VkBufferCopy* pRegions); 2913 2914void VKAPI vkCmdCopyImage( 2915 VkCommandBuffer commandBuffer, 2916 VkImage srcImage, 2917 VkImageLayout srcImageLayout, 2918 VkImage dstImage, 2919 VkImageLayout dstImageLayout, 2920 uint32_t regionCount, 2921 const VkImageCopy* pRegions); 2922 2923void VKAPI vkCmdBlitImage( 2924 VkCommandBuffer commandBuffer, 2925 VkImage srcImage, 2926 VkImageLayout srcImageLayout, 2927 VkImage dstImage, 2928 VkImageLayout dstImageLayout, 2929 uint32_t regionCount, 2930 const VkImageBlit* pRegions, 2931 VkFilter filter); 2932 2933void VKAPI vkCmdCopyBufferToImage( 2934 VkCommandBuffer commandBuffer, 2935 VkBuffer srcBuffer, 2936 VkImage dstImage, 2937 VkImageLayout dstImageLayout, 2938 uint32_t regionCount, 2939 const VkBufferImageCopy* pRegions); 2940 2941void VKAPI vkCmdCopyImageToBuffer( 2942 VkCommandBuffer commandBuffer, 2943 VkImage srcImage, 2944 VkImageLayout srcImageLayout, 2945 VkBuffer dstBuffer, 2946 uint32_t regionCount, 2947 const VkBufferImageCopy* pRegions); 2948 2949void VKAPI vkCmdUpdateBuffer( 2950 VkCommandBuffer commandBuffer, 2951 VkBuffer dstBuffer, 2952 VkDeviceSize dstOffset, 2953 VkDeviceSize dataSize, 2954 const uint32_t* pData); 2955 2956void VKAPI vkCmdFillBuffer( 2957 VkCommandBuffer commandBuffer, 2958 VkBuffer dstBuffer, 2959 VkDeviceSize dstOffset, 2960 VkDeviceSize size, 2961 uint32_t data); 2962 2963void VKAPI vkCmdClearColorImage( 2964 VkCommandBuffer commandBuffer, 2965 VkImage image, 2966 VkImageLayout imageLayout, 2967 const VkClearColorValue* pColor, 2968 uint32_t rangeCount, 2969 const VkImageSubresourceRange* pRanges); 2970 2971void VKAPI vkCmdClearDepthStencilImage( 2972 VkCommandBuffer commandBuffer, 2973 VkImage image, 2974 VkImageLayout imageLayout, 2975 const VkClearDepthStencilValue* pDepthStencil, 2976 uint32_t rangeCount, 2977 const VkImageSubresourceRange* pRanges); 2978 2979void VKAPI vkCmdClearAttachments( 2980 VkCommandBuffer commandBuffer, 2981 uint32_t attachmentCount, 2982 const VkClearAttachment* pAttachments, 2983 uint32_t rectCount, 2984 const VkClearRect* pRects); 2985 2986void VKAPI vkCmdResolveImage( 2987 VkCommandBuffer commandBuffer, 2988 VkImage srcImage, 2989 VkImageLayout srcImageLayout, 2990 VkImage dstImage, 2991 VkImageLayout dstImageLayout, 2992 uint32_t regionCount, 2993 const VkImageResolve* pRegions); 2994 2995void VKAPI vkCmdSetEvent( 2996 VkCommandBuffer commandBuffer, 2997 VkEvent event, 2998 VkPipelineStageFlags stageMask); 2999 3000void VKAPI vkCmdResetEvent( 3001 VkCommandBuffer commandBuffer, 3002 VkEvent event, 3003 VkPipelineStageFlags stageMask); 3004 3005void VKAPI vkCmdWaitEvents( 3006 VkCommandBuffer commandBuffer, 3007 uint32_t eventCount, 3008 const VkEvent* pEvents, 3009 VkPipelineStageFlags srcStageMask, 3010 VkPipelineStageFlags dstStageMask, 3011 uint32_t memoryBarrierCount, 3012 const void* const* ppMemoryBarriers); 3013 3014void VKAPI vkCmdPipelineBarrier( 3015 VkCommandBuffer commandBuffer, 3016 VkPipelineStageFlags srcStageMask, 3017 VkPipelineStageFlags dstStageMask, 3018 VkDependencyFlags dependencyFlags, 3019 uint32_t memoryBarrierCount, 3020 const void* const* ppMemoryBarriers); 3021 3022void VKAPI vkCmdBeginQuery( 3023 VkCommandBuffer commandBuffer, 3024 VkQueryPool queryPool, 3025 uint32_t slot, 3026 VkQueryControlFlags flags); 3027 3028void VKAPI vkCmdEndQuery( 3029 VkCommandBuffer commandBuffer, 3030 VkQueryPool queryPool, 3031 uint32_t slot); 3032 3033void VKAPI vkCmdResetQueryPool( 3034 VkCommandBuffer commandBuffer, 3035 VkQueryPool queryPool, 3036 uint32_t startQuery, 3037 uint32_t queryCount); 3038 3039void VKAPI vkCmdWriteTimestamp( 3040 VkCommandBuffer commandBuffer, 3041 VkPipelineStageFlagBits pipelineStage, 3042 VkQueryPool queryPool, 3043 uint32_t slot); 3044 3045void VKAPI vkCmdCopyQueryPoolResults( 3046 VkCommandBuffer commandBuffer, 3047 VkQueryPool queryPool, 3048 uint32_t startQuery, 3049 uint32_t queryCount, 3050 VkBuffer dstBuffer, 3051 VkDeviceSize dstOffset, 3052 VkDeviceSize stride, 3053 VkQueryResultFlags flags); 3054 3055void VKAPI vkCmdPushConstants( 3056 VkCommandBuffer commandBuffer, 3057 VkPipelineLayout layout, 3058 VkShaderStageFlags stageFlags, 3059 uint32_t offset, 3060 uint32_t size, 3061 const void* values); 3062 3063void VKAPI vkCmdBeginRenderPass( 3064 VkCommandBuffer commandBuffer, 3065 const VkRenderPassBeginInfo* pRenderPassBegin, 3066 VkRenderPassContents contents); 3067 3068void VKAPI vkCmdNextSubpass( 3069 VkCommandBuffer commandBuffer, 3070 VkRenderPassContents contents); 3071 3072void VKAPI vkCmdEndRenderPass( 3073 VkCommandBuffer commandBuffer); 3074 3075void VKAPI vkCmdExecuteCommands( 3076 VkCommandBuffer commandBuffer, 3077 uint32_t commandBuffersCount, 3078 const VkCommandBuffer* pCommandBuffers); 3079#endif 3080 3081#define vk_ext_khr_surface 1 3082VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR) 3083 3084#define VK_EXT_KHR_SURFACE_REVISION 20 3085#define VK_EXT_KHR_SURFACE_EXTENSION_NUMBER 1 3086#define VK_EXT_KHR_SURFACE_EXTENSION_NAME "VK_EXT_KHR_surface" 3087#define VK_ERROR_SURFACE_LOST_KHR ((VkResult)(int)0xc0000400) 3088 3089 3090typedef enum { 3091 VK_SURFACE_TRANSFORM_NONE_KHR = 0, 3092 VK_SURFACE_TRANSFORM_ROT90_KHR = 1, 3093 VK_SURFACE_TRANSFORM_ROT180_KHR = 2, 3094 VK_SURFACE_TRANSFORM_ROT270_KHR = 3, 3095 VK_SURFACE_TRANSFORM_HMIRROR_KHR = 4, 3096 VK_SURFACE_TRANSFORM_HMIRROR_ROT90_KHR = 5, 3097 VK_SURFACE_TRANSFORM_HMIRROR_ROT180_KHR = 6, 3098 VK_SURFACE_TRANSFORM_HMIRROR_ROT270_KHR = 7, 3099 VK_SURFACE_TRANSFORM_INHERIT_KHR = 8, 3100 VK_SURFACE_TRANSFORM_BEGIN_RANGE = VK_SURFACE_TRANSFORM_NONE_KHR, 3101 VK_SURFACE_TRANSFORM_END_RANGE = VK_SURFACE_TRANSFORM_INHERIT_KHR, 3102 VK_SURFACE_TRANSFORM_RANGE_SIZE = (VK_SURFACE_TRANSFORM_INHERIT_KHR - VK_SURFACE_TRANSFORM_NONE_KHR + 1), 3103 VK_SURFACE_TRANSFORM_MAX_ENUM = 0x7FFFFFFF 3104} VkSurfaceTransformKHR; 3105 3106typedef enum { 3107 VK_COLORSPACE_SRGB_NONLINEAR_KHR = 0, 3108 VK_COLORSPACE_BEGIN_RANGE = VK_COLORSPACE_SRGB_NONLINEAR_KHR, 3109 VK_COLORSPACE_END_RANGE = VK_COLORSPACE_SRGB_NONLINEAR_KHR, 3110 VK_COLORSPACE_RANGE_SIZE = (VK_COLORSPACE_SRGB_NONLINEAR_KHR - VK_COLORSPACE_SRGB_NONLINEAR_KHR + 1), 3111 VK_COLORSPACE_MAX_ENUM = 0x7FFFFFFF 3112} VkColorSpaceKHR; 3113 3114typedef enum { 3115 VK_PRESENT_MODE_IMMEDIATE_KHR = 0, 3116 VK_PRESENT_MODE_MAILBOX_KHR = 1, 3117 VK_PRESENT_MODE_FIFO_KHR = 2, 3118 VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3, 3119 VK_PRESENT_MODE_BEGIN_RANGE = VK_PRESENT_MODE_IMMEDIATE_KHR, 3120 VK_PRESENT_MODE_END_RANGE = VK_PRESENT_MODE_FIFO_RELAXED_KHR, 3121 VK_PRESENT_MODE_RANGE_SIZE = (VK_PRESENT_MODE_FIFO_RELAXED_KHR - VK_PRESENT_MODE_IMMEDIATE_KHR + 1), 3122 VK_PRESENT_MODE_MAX_ENUM = 0x7FFFFFFF 3123} VkPresentModeKHR; 3124 3125 3126typedef enum { 3127 VK_SURFACE_TRANSFORM_NONE_BIT_KHR = 0x00000001, 3128 VK_SURFACE_TRANSFORM_ROT90_BIT_KHR = 0x00000002, 3129 VK_SURFACE_TRANSFORM_ROT180_BIT_KHR = 0x00000004, 3130 VK_SURFACE_TRANSFORM_ROT270_BIT_KHR = 0x00000008, 3131 VK_SURFACE_TRANSFORM_HMIRROR_BIT_KHR = 0x00000010, 3132 VK_SURFACE_TRANSFORM_HMIRROR_ROT90_BIT_KHR = 0x00000020, 3133 VK_SURFACE_TRANSFORM_HMIRROR_ROT180_BIT_KHR = 0x00000040, 3134 VK_SURFACE_TRANSFORM_HMIRROR_ROT270_BIT_KHR = 0x00000080, 3135 VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100, 3136} VkSurfaceTransformFlagBitsKHR; 3137typedef VkFlags VkSurfaceTransformFlagsKHR; 3138 3139typedef enum { 3140 VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, 3141 VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002, 3142 VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004, 3143 VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008, 3144} VkCompositeAlphaFlagBitsKHR; 3145typedef VkFlags VkCompositeAlphaFlagsKHR; 3146 3147typedef struct { 3148 uint32_t minImageCount; 3149 uint32_t maxImageCount; 3150 VkExtent2D currentExtent; 3151 VkExtent2D minImageExtent; 3152 VkExtent2D maxImageExtent; 3153 VkSurfaceTransformFlagsKHR supportedTransforms; 3154 VkSurfaceTransformKHR currentTransform; 3155 VkCompositeAlphaFlagsKHR supportedCompositeAlpha; 3156 uint32_t maxImageArraySize; 3157 VkImageUsageFlags supportedUsageFlags; 3158} VkSurfaceCapabilitiesKHR; 3159 3160typedef struct { 3161 VkFormat format; 3162 VkColorSpaceKHR colorSpace; 3163} VkSurfaceFormatKHR; 3164 3165 3166typedef void (VKAPI *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface); 3167typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported); 3168typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); 3169typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats); 3170typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes); 3171 3172#ifdef VK_PROTOTYPES 3173void VKAPI vkDestroySurfaceKHR( 3174 VkInstance instance, 3175 VkSurfaceKHR surface); 3176 3177VkResult VKAPI vkGetPhysicalDeviceSurfaceSupportKHR( 3178 VkPhysicalDevice physicalDevice, 3179 uint32_t queueFamilyIndex, 3180 VkSurfaceKHR surface, 3181 VkBool32* pSupported); 3182 3183VkResult VKAPI vkGetPhysicalDeviceSurfaceCapabilitiesKHR( 3184 VkPhysicalDevice physicalDevice, 3185 VkSurfaceKHR surface, 3186 VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); 3187 3188VkResult VKAPI vkGetPhysicalDeviceSurfaceFormatsKHR( 3189 VkPhysicalDevice physicalDevice, 3190 VkSurfaceKHR surface, 3191 uint32_t* pSurfaceFormatCount, 3192 VkSurfaceFormatKHR* pSurfaceFormats); 3193 3194VkResult VKAPI vkGetPhysicalDeviceSurfacePresentModesKHR( 3195 VkPhysicalDevice physicalDevice, 3196 VkSurfaceKHR surface, 3197 uint32_t* pPresentModeCount, 3198 VkPresentModeKHR* pPresentModes); 3199#endif 3200 3201#define vk_ext_khr_swapchain 1 3202VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR) 3203 3204#define VK_EXT_KHR_SWAPCHAIN_REVISION 62 3205#define VK_EXT_KHR_SWAPCHAIN_EXTENSION_NUMBER 2 3206#define VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME "VK_EXT_KHR_swapchain" 3207#define VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR ((VkStructureType)(int)0xc0000800) 3208#define VK_STRUCTURE_TYPE_PRESENT_INFO_KHR ((VkStructureType)(int)0xc0000801) 3209#define VK_IMAGE_LAYOUT_PRESENT_SRC_KHR ((VkImageLayout)(int)0xc0000802) 3210#define VK_SUBOPTIMAL_KHR ((VkResult)(int)0x40000403) 3211#define VK_ERROR_OUT_OF_DATE_KHR ((VkResult)(int)0xc0000804) 3212 3213typedef struct { 3214 VkStructureType sType; 3215 const void* pNext; 3216 VkSurfaceKHR surface; 3217 uint32_t minImageCount; 3218 VkFormat imageFormat; 3219 VkColorSpaceKHR imageColorSpace; 3220 VkExtent2D imageExtent; 3221 VkImageUsageFlags imageUsageFlags; 3222 VkSurfaceTransformKHR preTransform; 3223 VkCompositeAlphaFlagBitsKHR compositeAlpha; 3224 uint32_t imageArraySize; 3225 VkSharingMode sharingMode; 3226 uint32_t queueFamilyIndexCount; 3227 const uint32_t* pQueueFamilyIndices; 3228 VkPresentModeKHR presentMode; 3229 VkSwapchainKHR oldSwapchain; 3230 VkBool32 clipped; 3231} VkSwapchainCreateInfoKHR; 3232 3233typedef struct { 3234 VkStructureType sType; 3235 const void* pNext; 3236 uint32_t waitSemaphoreCount; 3237 const VkSemaphore* pWaitSemaphores; 3238 uint32_t swapchainCount; 3239 const VkSwapchainKHR* pSwapchains; 3240 const uint32_t* imageIndices; 3241} VkPresentInfoKHR; 3242 3243 3244typedef VkResult (VKAPI *PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, VkSwapchainKHR* pSwapchain); 3245typedef void (VKAPI *PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain); 3246typedef VkResult (VKAPI *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages); 3247typedef VkResult (VKAPI *PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex); 3248typedef VkResult (VKAPI *PFN_vkQueuePresentKHR)(VkQueue queue, VkPresentInfoKHR* pPresentInfo); 3249 3250#ifdef VK_PROTOTYPES 3251VkResult VKAPI vkCreateSwapchainKHR( 3252 VkDevice device, 3253 const VkSwapchainCreateInfoKHR* pCreateInfo, 3254 VkSwapchainKHR* pSwapchain); 3255 3256void VKAPI vkDestroySwapchainKHR( 3257 VkDevice device, 3258 VkSwapchainKHR swapchain); 3259 3260VkResult VKAPI vkGetSwapchainImagesKHR( 3261 VkDevice device, 3262 VkSwapchainKHR swapchain, 3263 uint32_t* pSwapchainImageCount, 3264 VkImage* pSwapchainImages); 3265 3266VkResult VKAPI vkAcquireNextImageKHR( 3267 VkDevice device, 3268 VkSwapchainKHR swapchain, 3269 uint64_t timeout, 3270 VkSemaphore semaphore, 3271 VkFence fence, 3272 uint32_t* pImageIndex); 3273 3274VkResult VKAPI vkQueuePresentKHR( 3275 VkQueue queue, 3276 VkPresentInfoKHR* pPresentInfo); 3277#endif 3278 3279#define vk_ext_khr_display 1 3280VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR) 3281VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR) 3282 3283#define VK_EXT_KHR_DISPLAY_REVISION 17 3284#define VK_EXT_KHR_DISPLAY_EXTENSION_NUMBER 3 3285#define VK_EXT_KHR_DISPLAY_EXTENSION_NAME "VK_EXT_KHR_display" 3286#define VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR ((VkStructureType)(int)0xc0000c00) 3287#define VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR ((VkStructureType)(int)0xc0000c01) 3288 3289 3290typedef enum { 3291 VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000001, 3292 VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000002, 3293 VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000004, 3294} VkDisplayPlaneAlphaFlagBitsKHR; 3295typedef VkFlags VkDisplayPlaneAlphaFlagsKHR; 3296 3297typedef struct { 3298 VkDisplayKHR display; 3299 const char* displayName; 3300 VkExtent2D physicalDimensions; 3301 VkExtent2D physicalResolution; 3302 VkSurfaceTransformFlagsKHR supportedTransforms; 3303 VkBool32 planeReorderPossible; 3304 VkBool32 persistentContent; 3305} VkDisplayPropertiesKHR; 3306 3307typedef struct { 3308 VkExtent2D visibleRegion; 3309 uint32_t refreshRate; 3310} VkDisplayModeParametersKHR; 3311 3312typedef struct { 3313 VkDisplayModeKHR displayMode; 3314 VkDisplayModeParametersKHR parameters; 3315} VkDisplayModePropertiesKHR; 3316 3317typedef struct { 3318 VkStructureType sType; 3319 const void* pNext; 3320 VkDisplayModeParametersKHR parameters; 3321} VkDisplayModeCreateInfoKHR; 3322 3323typedef struct { 3324 VkDisplayPlaneAlphaFlagsKHR supportedAlpha; 3325 VkOffset2D minSrcPosition; 3326 VkOffset2D maxSrcPosition; 3327 VkExtent2D minSrcExtent; 3328 VkExtent2D maxSrcExtent; 3329 VkOffset2D minDstPosition; 3330 VkOffset2D maxDstPosition; 3331 VkExtent2D minDstExtent; 3332 VkExtent2D maxDstExtent; 3333} VkDisplayPlaneCapabilitiesKHR; 3334 3335typedef struct { 3336 VkDisplayKHR currentDisplay; 3337 uint32_t currentStackIndex; 3338} VkDisplayPlanePropertiesKHR; 3339 3340typedef struct { 3341 VkStructureType sType; 3342 const void* pNext; 3343 VkDisplayModeKHR displayMode; 3344 uint32_t planeIndex; 3345 uint32_t planeStackIndex; 3346 VkSurfaceTransformKHR transform; 3347 float globalAlpha; 3348 VkDisplayPlaneAlphaFlagsKHR alphaMode; 3349 VkExtent2D imageSize; 3350} VkDisplaySurfaceCreateInfoKHR; 3351 3352 3353typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties); 3354typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties); 3355typedef VkResult (VKAPI *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayKHR* pProperties); 3356typedef VkResult (VKAPI *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties); 3357typedef VkResult (VKAPI *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR*pCreateInfo, VkDisplayModeKHR* pMode); 3358typedef VkResult (VKAPI *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeCreateInfoKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities); 3359typedef VkResult (VKAPI *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, VkSurfaceKHR* pSurface); 3360 3361#ifdef VK_PROTOTYPES 3362VkResult VKAPI vkGetPhysicalDeviceDisplayPropertiesKHR( 3363 VkPhysicalDevice physicalDevice, 3364 uint32_t* pPropertyCount, 3365 VkDisplayPropertiesKHR* pProperties); 3366 3367VkResult VKAPI vkGetPhysicalDeviceDisplayPlanePropertiesKHR( 3368 VkPhysicalDevice physicalDevice, 3369 uint32_t* pPropertyCount, 3370 VkDisplayPlanePropertiesKHR* pProperties); 3371 3372VkResult VKAPI vkGetDisplayPlaneSupportedDisplaysKHR( 3373 VkPhysicalDevice physicalDevice, 3374 uint32_t* pPropertyCount, 3375 VkDisplayKHR* pProperties); 3376 3377VkResult VKAPI vkGetDisplayModePropertiesKHR( 3378 VkPhysicalDevice physicalDevice, 3379 VkDisplayKHR display, 3380 uint32_t* pPropertyCount, 3381 VkDisplayModePropertiesKHR* pProperties); 3382 3383VkResult VKAPI vkCreateDisplayModeKHR( 3384 VkPhysicalDevice physicalDevice, 3385 VkDisplayKHR display, 3386 const VkDisplayModeCreateInfoKHR* pCreateInfo, 3387 VkDisplayModeKHR* pMode); 3388 3389VkResult VKAPI vkGetDisplayPlaneCapabilitiesKHR( 3390 VkPhysicalDevice physicalDevice, 3391 VkDisplayModeCreateInfoKHR mode, 3392 uint32_t planeIndex, 3393 VkDisplayPlaneCapabilitiesKHR* pCapabilities); 3394 3395VkResult VKAPI vkCreateDisplayPlaneSurfaceKHR( 3396 VkInstance instance, 3397 const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, 3398 VkSurfaceKHR* pSurface); 3399#endif 3400 3401#define vk_ext_khr_display_swapchain 1 3402#define VK_EXT_KHR_DISPLAY_SWAPCHAIN_REVISION 6 3403#define VK_EXT_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NUMBER 4 3404#define VK_EXT_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_EXT_KHR_display_swapchain" 3405#define VK_STRUCTURE_TYPE_DISPLAY_SWAPCHAIN_CREATE_INFO_KHR ((VkStructureType)(int)0xc0001000) 3406#define VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR ((VkStructureType)(int)0xc0001001) 3407#define VK_ERROR_INCOMPATIBLE_DISPLAY_KHR ((VkResult)(int)0xc0001002) 3408 3409typedef struct { 3410 VkStructureType sType; 3411 const void* pNext; 3412 const VkSwapchainCreateInfoKHR* pNextSwapchainCreateInfo; 3413} VkDisplaySwapchainCreateInfoKHR; 3414 3415typedef struct { 3416 VkStructureType sType; 3417 const void* pNext; 3418 VkRect2D srcRect; 3419 VkRect2D dstRect; 3420 VkBool32 persistent; 3421} VkDisplayPresentInfoKHR; 3422 3423 3424 3425#ifdef VK_USE_PLATFORM_XLIB_KHR 3426#define vk_ext_khr_xlib_surface 1 3427#include <X11/Xlib.h> 3428 3429#define VK_EXT_KHR_XLIB_SURFACE_REVISION 3 3430#define VK_EXT_KHR_XLIB_SURFACE_EXTENSION_NUMBER 5 3431#define VK_EXT_KHR_XLIB_SURFACE_EXTENSION_NAME "vk_ext_khr_xlib_surface" 3432 3433typedef VkResult (VKAPI *PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, Display* dpy, Window window, VkSurfaceKHR* pSurface); 3434typedef VkBool32 (VKAPI *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualId); 3435 3436#ifdef VK_PROTOTYPES 3437VkResult VKAPI vkCreateXlibSurfaceKHR( 3438 VkInstance instance, 3439 Display* dpy, 3440 Window window, 3441 VkSurfaceKHR* pSurface); 3442 3443VkBool32 VKAPI vkGetPhysicalDeviceXlibPresentationSupportKHR( 3444 VkPhysicalDevice physicalDevice, 3445 uint32_t queueFamilyIndex, 3446 Display* dpy, 3447 VisualID visualId); 3448#endif 3449#endif /* VK_USE_PLATFORM_XLIB_KHR */ 3450 3451#ifdef VK_USE_PLATFORM_XCB_KHR 3452#define vk_ext_khr_xcb_surface 1 3453#include <xcb/xcb.h> 3454 3455#define VK_EXT_KHR_XCB_SURFACE_REVISION 3 3456#define VK_EXT_KHR_XCB_SURFACE_EXTENSION_NUMBER 6 3457#define VK_EXT_KHR_XCB_SURFACE_EXTENSION_NAME "VK_EXT_KHR_xcb_surface" 3458 3459typedef VkResult (VKAPI *PFN_vkCreateXcbSurfaceKHR)(VkInstance instance, xcb_connection_t* connection, xcb_window_t window, VkSurfaceKHR* pSurface); 3460typedef VkBool32 (VKAPI *PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id); 3461 3462#ifdef VK_PROTOTYPES 3463VkResult VKAPI vkCreateXcbSurfaceKHR( 3464 VkInstance instance, 3465 xcb_connection_t* connection, 3466 xcb_window_t window, 3467 VkSurfaceKHR* pSurface); 3468 3469VkBool32 VKAPI vkGetPhysicalDeviceXcbPresentationSupportKHR( 3470 VkPhysicalDevice physicalDevice, 3471 uint32_t queueFamilyIndex, 3472 xcb_connection_t* connection, 3473 xcb_visualid_t visual_id); 3474#endif 3475#endif /* VK_USE_PLATFORM_XCB_KHR */ 3476 3477#ifdef VK_USE_PLATFORM_WAYLAND_KHR 3478#define vk_ext_khr_wayland_surface 1 3479#include <wayland-client.h> 3480 3481#define VK_EXT_KHR_WAYLAND_SURFACE_REVISION 2 3482#define VK_EXT_KHR_WAYLAND_SURFACE_EXTENSION_NUMBER 7 3483#define VK_EXT_KHR_WAYLAND_SURFACE_EXTENSION_NAME "VK_EXT_KHR_wayland_surface" 3484 3485typedef VkResult (VKAPI *PFN_vkCreateWaylandSurfaceKHR)(VkInstance instance, struct wl_display* display, struct wl_surface* surface, VkSurfaceKHR* pSurface); 3486typedef VkBool32 (VKAPI *PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display); 3487 3488#ifdef VK_PROTOTYPES 3489VkResult VKAPI vkCreateWaylandSurfaceKHR( 3490 VkInstance instance, 3491 struct wl_display* display, 3492 struct wl_surface* surface, 3493 VkSurfaceKHR* pSurface); 3494 3495VkBool32 VKAPI vkGetPhysicalDeviceWaylandPresentationSupportKHR( 3496 VkPhysicalDevice physicalDevice, 3497 uint32_t queueFamilyIndex, 3498 struct wl_display* display); 3499#endif 3500#endif /* VK_USE_PLATFORM_WAYLAND_KHR */ 3501 3502#ifdef VK_USE_PLATFORM_MIR_KHR 3503#define vk_ext_khr_mir_surface 1 3504#include <mir_toolkit/client_types.h> 3505 3506#define VK_EXT_KHR_MIR_SURFACE_REVISION 2 3507#define VK_EXT_KHR_MIR_SURFACE_EXTENSION_NUMBER 8 3508#define VK_EXT_KHR_MIR_SURFACE_EXTENSION_NAME "VK_EXT_KHR_mir_surface" 3509 3510typedef VkResult (VKAPI *PFN_vkCreateMirSurfaceKHR)(VkInstance instance, MirConnection* connection, MirSurface* mirSurface, VkSurfaceKHR* pSurface); 3511typedef VkBool32 (VKAPI *PFN_vkGetPhysicalDeviceMirPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, MirConnection* connection); 3512 3513#ifdef VK_PROTOTYPES 3514VkResult VKAPI vkCreateMirSurfaceKHR( 3515 VkInstance instance, 3516 MirConnection* connection, 3517 MirSurface* mirSurface, 3518 VkSurfaceKHR* pSurface); 3519 3520VkBool32 VKAPI vkGetPhysicalDeviceMirPresentationSupportKHR( 3521 VkPhysicalDevice physicalDevice, 3522 uint32_t queueFamilyIndex, 3523 MirConnection* connection); 3524#endif 3525#endif /* VK_USE_PLATFORM_MIR_KHR */ 3526 3527#ifdef VK_USE_PLATFORM_ANDROID_KHR 3528#define vk_ext_khr_android_surface 1 3529#include <android/native_window.h> 3530 3531#define VK_EXT_KHR_ANDROID_SURFACE_REVISION 1 3532#define VK_EXT_KHR_ANDROID_SURFACE_EXTENSION_NUMBER 9 3533#define VK_EXT_KHR_ANDROID_SURFACE_EXTENSION_NAME "VK_EXT_KHR_android_surface" 3534#define VK_ERROR_INVALID_ANDROID_WINDOW_KHR ((VkResult)(int)0xc0002400) 3535#define VK_ERROR_ANDROID_WINDOW_IN_USE_KHR ((VkResult)(int)0xc0002401) 3536 3537typedef VkResult (VKAPI *PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance, ANativeWindow* window, VkSurfaceKHR* pSurface); 3538 3539#ifdef VK_PROTOTYPES 3540VkResult VKAPI vkCreateAndroidSurfaceKHR( 3541 VkInstance instance, 3542 ANativeWindow* window, 3543 VkSurfaceKHR* pSurface); 3544#endif 3545#endif /* VK_USE_PLATFORM_ANDROID_KHR */ 3546 3547#ifdef VK_USE_PLATFORM_WIN32_KHR 3548#define vk_ext_khr_win32_surface 1 3549#include <windows.h> 3550 3551#define VK_EXT_KHR_WIN32_SURFACE_REVISION 2 3552#define VK_EXT_KHR_WIN32_SURFACE_EXTENSION_NUMBER 10 3553#define VK_EXT_KHR_WIN32_SURFACE_EXTENSION_NAME "VK_EXT_KHR_win32_surface" 3554 3555typedef VkResult (VKAPI *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, HINSTANCE hinstance, HWND hwnd, VkSurfaceKHR* pSurface); 3556typedef VkBool32 (VKAPI *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex); 3557 3558#ifdef VK_PROTOTYPES 3559VkResult VKAPI vkCreateWin32SurfaceKHR( 3560 VkInstance instance, 3561 HINSTANCE hinstance, 3562 HWND hwnd, 3563 VkSurfaceKHR* pSurface); 3564 3565VkBool32 VKAPI vkGetPhysicalDeviceWin32PresentationSupportKHR( 3566 VkPhysicalDevice physicalDevice, 3567 uint32_t queueFamilyIndex); 3568#endif 3569#endif /* VK_USE_PLATFORM_WIN32_KHR */ 3570 3571#ifdef __cplusplus 3572} 3573#endif 3574 3575#endif 3576