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