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