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