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