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