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