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