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