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