1 #ifndef VULKAN_CORE_H_ 2 #define VULKAN_CORE_H_ 1 3 4 #ifdef __cplusplus 5 extern "C" { 6 #endif 7 8 /* 9 ** Copyright (c) 2015-2018 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) // Patch version should always be set to 0 38 39 // Vulkan 1.0 version number 40 #define VK_API_VERSION_1_0 VK_MAKE_VERSION(1, 0, 0)// Patch version should always be set to 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 68 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_OUT_OF_POOL_MEMORY = -1000069000, 142 VK_ERROR_INVALID_EXTERNAL_HANDLE = -1000072003, 143 VK_ERROR_SURFACE_LOST_KHR = -1000000000, 144 VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001, 145 VK_SUBOPTIMAL_KHR = 1000001003, 146 VK_ERROR_OUT_OF_DATE_KHR = -1000001004, 147 VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001, 148 VK_ERROR_VALIDATION_FAILED_EXT = -1000011001, 149 VK_ERROR_INVALID_SHADER_NV = -1000012000, 150 VK_ERROR_NOT_PERMITTED_EXT = -1000174001, 151 VK_ERROR_OUT_OF_POOL_MEMORY_KHR = VK_ERROR_OUT_OF_POOL_MEMORY, 152 VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = VK_ERROR_INVALID_EXTERNAL_HANDLE, 153 VK_RESULT_BEGIN_RANGE = VK_ERROR_FRAGMENTED_POOL, 154 VK_RESULT_END_RANGE = VK_INCOMPLETE, 155 VK_RESULT_RANGE_SIZE = (VK_INCOMPLETE - VK_ERROR_FRAGMENTED_POOL + 1), 156 VK_RESULT_MAX_ENUM = 0x7FFFFFFF 157 } VkResult; 158 159 typedef enum VkStructureType { 160 VK_STRUCTURE_TYPE_APPLICATION_INFO = 0, 161 VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1, 162 VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2, 163 VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3, 164 VK_STRUCTURE_TYPE_SUBMIT_INFO = 4, 165 VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5, 166 VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6, 167 VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7, 168 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8, 169 VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9, 170 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10, 171 VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11, 172 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12, 173 VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13, 174 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14, 175 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15, 176 VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16, 177 VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17, 178 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18, 179 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19, 180 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20, 181 VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21, 182 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22, 183 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23, 184 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24, 185 VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25, 186 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26, 187 VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27, 188 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28, 189 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29, 190 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30, 191 VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31, 192 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32, 193 VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33, 194 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34, 195 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35, 196 VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36, 197 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37, 198 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38, 199 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39, 200 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40, 201 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41, 202 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42, 203 VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43, 204 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44, 205 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45, 206 VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46, 207 VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47, 208 VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48, 209 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES = 1000094000, 210 VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO = 1000157000, 211 VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO = 1000157001, 212 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES = 1000083000, 213 VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS = 1000127000, 214 VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO = 1000127001, 215 VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO = 1000060000, 216 VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO = 1000060003, 217 VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO = 1000060004, 218 VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO = 1000060005, 219 VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO = 1000060006, 220 VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO = 1000060013, 221 VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO = 1000060014, 222 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES = 1000070000, 223 VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO = 1000070001, 224 VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2 = 1000146000, 225 VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2 = 1000146001, 226 VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 = 1000146002, 227 VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 = 1000146003, 228 VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 = 1000146004, 229 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 = 1000059000, 230 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 = 1000059001, 231 VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 = 1000059002, 232 VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 = 1000059003, 233 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 = 1000059004, 234 VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 = 1000059005, 235 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 = 1000059006, 236 VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 = 1000059007, 237 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 = 1000059008, 238 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES = 1000117000, 239 VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO = 1000117001, 240 VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO = 1000117002, 241 VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO = 1000117003, 242 VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO = 1000053000, 243 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES = 1000053001, 244 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES = 1000053002, 245 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = 1000120000, 246 VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO = 1000145000, 247 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES = 1000145001, 248 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES = 1000145002, 249 VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 = 1000145003, 250 VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO = 1000156000, 251 VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO = 1000156001, 252 VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO = 1000156002, 253 VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO = 1000156003, 254 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES = 1000156004, 255 VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES = 1000156005, 256 VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO = 1000085000, 257 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO = 1000071000, 258 VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES = 1000071001, 259 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO = 1000071002, 260 VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES = 1000071003, 261 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES = 1000071004, 262 VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO = 1000072000, 263 VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO = 1000072001, 264 VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO = 1000072002, 265 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO = 1000112000, 266 VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES = 1000112001, 267 VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO = 1000113000, 268 VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO = 1000077000, 269 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO = 1000076000, 270 VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES = 1000076001, 271 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES = 1000168000, 272 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT = 1000168001, 273 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = 1000063000, 274 VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000, 275 VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001, 276 VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR = 1000060007, 277 VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR = 1000060008, 278 VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR = 1000060009, 279 VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR = 1000060010, 280 VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR = 1000060011, 281 VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR = 1000060012, 282 VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000, 283 VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001, 284 VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000, 285 VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000, 286 VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000, 287 VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000, 288 VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR = 1000007000, 289 VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000, 290 VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000, 291 VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000, 292 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000, 293 VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000, 294 VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001, 295 VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002, 296 VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000, 297 VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001, 298 VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002, 299 VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD = 1000041000, 300 VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000, 301 VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001, 302 VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000, 303 VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057001, 304 VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000, 305 VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = 1000061000, 306 VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN = 1000062000, 307 VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073000, 308 VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073001, 309 VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR = 1000073002, 310 VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR = 1000073003, 311 VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR = 1000074000, 312 VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR = 1000074001, 313 VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR = 1000074002, 314 VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR = 1000075000, 315 VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078000, 316 VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078001, 317 VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR = 1000078002, 318 VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR = 1000078003, 319 VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR = 1000079000, 320 VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR = 1000079001, 321 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = 1000080000, 322 VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000, 323 VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX = 1000086000, 324 VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX = 1000086001, 325 VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX = 1000086002, 326 VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX = 1000086003, 327 VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX = 1000086004, 328 VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX = 1000086005, 329 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV = 1000087000, 330 VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT = 1000090000, 331 VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT = 1000091000, 332 VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT = 1000091001, 333 VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT = 1000091002, 334 VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT = 1000091003, 335 VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE = 1000092000, 336 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX = 1000097000, 337 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV = 1000098000, 338 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT = 1000099000, 339 VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT = 1000099001, 340 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT = 1000101000, 341 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT = 1000101001, 342 VK_STRUCTURE_TYPE_HDR_METADATA_EXT = 1000105000, 343 VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000, 344 VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114000, 345 VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114001, 346 VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR = 1000114002, 347 VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR = 1000115000, 348 VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR = 1000115001, 349 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000, 350 VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001, 351 VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002, 352 VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK = 1000122000, 353 VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = 1000123000, 354 VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT = 1000128000, 355 VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT = 1000128001, 356 VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT = 1000128002, 357 VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT = 1000128003, 358 VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT = 1000128004, 359 VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID = 1000129000, 360 VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID = 1000129001, 361 VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID = 1000129002, 362 VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129003, 363 VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129004, 364 VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID = 1000129005, 365 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT = 1000130000, 366 VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT = 1000130001, 367 VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT = 1000143000, 368 VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT = 1000143001, 369 VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT = 1000143002, 370 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT = 1000143003, 371 VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT = 1000143004, 372 VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR = 1000147000, 373 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT = 1000148000, 374 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT = 1000148001, 375 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT = 1000148002, 376 VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV = 1000149000, 377 VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV = 1000152000, 378 VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160000, 379 VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160001, 380 VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT = 1000174000, 381 VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT = 1000178000, 382 VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT = 1000178001, 383 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002, 384 VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO, 385 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, 386 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, 387 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2, 388 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, 389 VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2, 390 VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2, 391 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2, 392 VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2, 393 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2, 394 VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2, 395 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2, 396 VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO, 397 VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO, 398 VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO, 399 VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO, 400 VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO, 401 VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO, 402 VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO, 403 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES, 404 VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO, 405 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO, 406 VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES, 407 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO, 408 VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES, 409 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES, 410 VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO, 411 VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, 412 VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO, 413 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO, 414 VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES, 415 VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO, 416 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, 417 VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO, 418 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO, 419 VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES, 420 VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO, 421 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES, 422 VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO, 423 VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO, 424 VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO, 425 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES, 426 VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS, 427 VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, 428 VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2, 429 VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2, 430 VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2, 431 VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2, 432 VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2, 433 VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO, 434 VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO, 435 VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO, 436 VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO, 437 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, 438 VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES, 439 VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO, 440 VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO, 441 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES, 442 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT, 443 VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO, 444 VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO, 445 VK_STRUCTURE_TYPE_RANGE_SIZE = (VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1), 446 VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF 447 } VkStructureType; 448 449 typedef enum VkSystemAllocationScope { 450 VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0, 451 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1, 452 VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2, 453 VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3, 454 VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4, 455 VK_SYSTEM_ALLOCATION_SCOPE_BEGIN_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_COMMAND, 456 VK_SYSTEM_ALLOCATION_SCOPE_END_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE, 457 VK_SYSTEM_ALLOCATION_SCOPE_RANGE_SIZE = (VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE - VK_SYSTEM_ALLOCATION_SCOPE_COMMAND + 1), 458 VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF 459 } VkSystemAllocationScope; 460 461 typedef enum VkInternalAllocationType { 462 VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0, 463 VK_INTERNAL_ALLOCATION_TYPE_BEGIN_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE, 464 VK_INTERNAL_ALLOCATION_TYPE_END_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE, 465 VK_INTERNAL_ALLOCATION_TYPE_RANGE_SIZE = (VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE - VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE + 1), 466 VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF 467 } VkInternalAllocationType; 468 469 typedef enum VkFormat { 470 VK_FORMAT_UNDEFINED = 0, 471 VK_FORMAT_R4G4_UNORM_PACK8 = 1, 472 VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2, 473 VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3, 474 VK_FORMAT_R5G6B5_UNORM_PACK16 = 4, 475 VK_FORMAT_B5G6R5_UNORM_PACK16 = 5, 476 VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6, 477 VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7, 478 VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8, 479 VK_FORMAT_R8_UNORM = 9, 480 VK_FORMAT_R8_SNORM = 10, 481 VK_FORMAT_R8_USCALED = 11, 482 VK_FORMAT_R8_SSCALED = 12, 483 VK_FORMAT_R8_UINT = 13, 484 VK_FORMAT_R8_SINT = 14, 485 VK_FORMAT_R8_SRGB = 15, 486 VK_FORMAT_R8G8_UNORM = 16, 487 VK_FORMAT_R8G8_SNORM = 17, 488 VK_FORMAT_R8G8_USCALED = 18, 489 VK_FORMAT_R8G8_SSCALED = 19, 490 VK_FORMAT_R8G8_UINT = 20, 491 VK_FORMAT_R8G8_SINT = 21, 492 VK_FORMAT_R8G8_SRGB = 22, 493 VK_FORMAT_R8G8B8_UNORM = 23, 494 VK_FORMAT_R8G8B8_SNORM = 24, 495 VK_FORMAT_R8G8B8_USCALED = 25, 496 VK_FORMAT_R8G8B8_SSCALED = 26, 497 VK_FORMAT_R8G8B8_UINT = 27, 498 VK_FORMAT_R8G8B8_SINT = 28, 499 VK_FORMAT_R8G8B8_SRGB = 29, 500 VK_FORMAT_B8G8R8_UNORM = 30, 501 VK_FORMAT_B8G8R8_SNORM = 31, 502 VK_FORMAT_B8G8R8_USCALED = 32, 503 VK_FORMAT_B8G8R8_SSCALED = 33, 504 VK_FORMAT_B8G8R8_UINT = 34, 505 VK_FORMAT_B8G8R8_SINT = 35, 506 VK_FORMAT_B8G8R8_SRGB = 36, 507 VK_FORMAT_R8G8B8A8_UNORM = 37, 508 VK_FORMAT_R8G8B8A8_SNORM = 38, 509 VK_FORMAT_R8G8B8A8_USCALED = 39, 510 VK_FORMAT_R8G8B8A8_SSCALED = 40, 511 VK_FORMAT_R8G8B8A8_UINT = 41, 512 VK_FORMAT_R8G8B8A8_SINT = 42, 513 VK_FORMAT_R8G8B8A8_SRGB = 43, 514 VK_FORMAT_B8G8R8A8_UNORM = 44, 515 VK_FORMAT_B8G8R8A8_SNORM = 45, 516 VK_FORMAT_B8G8R8A8_USCALED = 46, 517 VK_FORMAT_B8G8R8A8_SSCALED = 47, 518 VK_FORMAT_B8G8R8A8_UINT = 48, 519 VK_FORMAT_B8G8R8A8_SINT = 49, 520 VK_FORMAT_B8G8R8A8_SRGB = 50, 521 VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51, 522 VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52, 523 VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53, 524 VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54, 525 VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55, 526 VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56, 527 VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57, 528 VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58, 529 VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59, 530 VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60, 531 VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61, 532 VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62, 533 VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63, 534 VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64, 535 VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65, 536 VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66, 537 VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67, 538 VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68, 539 VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69, 540 VK_FORMAT_R16_UNORM = 70, 541 VK_FORMAT_R16_SNORM = 71, 542 VK_FORMAT_R16_USCALED = 72, 543 VK_FORMAT_R16_SSCALED = 73, 544 VK_FORMAT_R16_UINT = 74, 545 VK_FORMAT_R16_SINT = 75, 546 VK_FORMAT_R16_SFLOAT = 76, 547 VK_FORMAT_R16G16_UNORM = 77, 548 VK_FORMAT_R16G16_SNORM = 78, 549 VK_FORMAT_R16G16_USCALED = 79, 550 VK_FORMAT_R16G16_SSCALED = 80, 551 VK_FORMAT_R16G16_UINT = 81, 552 VK_FORMAT_R16G16_SINT = 82, 553 VK_FORMAT_R16G16_SFLOAT = 83, 554 VK_FORMAT_R16G16B16_UNORM = 84, 555 VK_FORMAT_R16G16B16_SNORM = 85, 556 VK_FORMAT_R16G16B16_USCALED = 86, 557 VK_FORMAT_R16G16B16_SSCALED = 87, 558 VK_FORMAT_R16G16B16_UINT = 88, 559 VK_FORMAT_R16G16B16_SINT = 89, 560 VK_FORMAT_R16G16B16_SFLOAT = 90, 561 VK_FORMAT_R16G16B16A16_UNORM = 91, 562 VK_FORMAT_R16G16B16A16_SNORM = 92, 563 VK_FORMAT_R16G16B16A16_USCALED = 93, 564 VK_FORMAT_R16G16B16A16_SSCALED = 94, 565 VK_FORMAT_R16G16B16A16_UINT = 95, 566 VK_FORMAT_R16G16B16A16_SINT = 96, 567 VK_FORMAT_R16G16B16A16_SFLOAT = 97, 568 VK_FORMAT_R32_UINT = 98, 569 VK_FORMAT_R32_SINT = 99, 570 VK_FORMAT_R32_SFLOAT = 100, 571 VK_FORMAT_R32G32_UINT = 101, 572 VK_FORMAT_R32G32_SINT = 102, 573 VK_FORMAT_R32G32_SFLOAT = 103, 574 VK_FORMAT_R32G32B32_UINT = 104, 575 VK_FORMAT_R32G32B32_SINT = 105, 576 VK_FORMAT_R32G32B32_SFLOAT = 106, 577 VK_FORMAT_R32G32B32A32_UINT = 107, 578 VK_FORMAT_R32G32B32A32_SINT = 108, 579 VK_FORMAT_R32G32B32A32_SFLOAT = 109, 580 VK_FORMAT_R64_UINT = 110, 581 VK_FORMAT_R64_SINT = 111, 582 VK_FORMAT_R64_SFLOAT = 112, 583 VK_FORMAT_R64G64_UINT = 113, 584 VK_FORMAT_R64G64_SINT = 114, 585 VK_FORMAT_R64G64_SFLOAT = 115, 586 VK_FORMAT_R64G64B64_UINT = 116, 587 VK_FORMAT_R64G64B64_SINT = 117, 588 VK_FORMAT_R64G64B64_SFLOAT = 118, 589 VK_FORMAT_R64G64B64A64_UINT = 119, 590 VK_FORMAT_R64G64B64A64_SINT = 120, 591 VK_FORMAT_R64G64B64A64_SFLOAT = 121, 592 VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122, 593 VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123, 594 VK_FORMAT_D16_UNORM = 124, 595 VK_FORMAT_X8_D24_UNORM_PACK32 = 125, 596 VK_FORMAT_D32_SFLOAT = 126, 597 VK_FORMAT_S8_UINT = 127, 598 VK_FORMAT_D16_UNORM_S8_UINT = 128, 599 VK_FORMAT_D24_UNORM_S8_UINT = 129, 600 VK_FORMAT_D32_SFLOAT_S8_UINT = 130, 601 VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131, 602 VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132, 603 VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133, 604 VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134, 605 VK_FORMAT_BC2_UNORM_BLOCK = 135, 606 VK_FORMAT_BC2_SRGB_BLOCK = 136, 607 VK_FORMAT_BC3_UNORM_BLOCK = 137, 608 VK_FORMAT_BC3_SRGB_BLOCK = 138, 609 VK_FORMAT_BC4_UNORM_BLOCK = 139, 610 VK_FORMAT_BC4_SNORM_BLOCK = 140, 611 VK_FORMAT_BC5_UNORM_BLOCK = 141, 612 VK_FORMAT_BC5_SNORM_BLOCK = 142, 613 VK_FORMAT_BC6H_UFLOAT_BLOCK = 143, 614 VK_FORMAT_BC6H_SFLOAT_BLOCK = 144, 615 VK_FORMAT_BC7_UNORM_BLOCK = 145, 616 VK_FORMAT_BC7_SRGB_BLOCK = 146, 617 VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147, 618 VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148, 619 VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149, 620 VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150, 621 VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151, 622 VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152, 623 VK_FORMAT_EAC_R11_UNORM_BLOCK = 153, 624 VK_FORMAT_EAC_R11_SNORM_BLOCK = 154, 625 VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155, 626 VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156, 627 VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157, 628 VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158, 629 VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159, 630 VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160, 631 VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161, 632 VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162, 633 VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163, 634 VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164, 635 VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165, 636 VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166, 637 VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167, 638 VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168, 639 VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169, 640 VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170, 641 VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171, 642 VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172, 643 VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173, 644 VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174, 645 VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175, 646 VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176, 647 VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177, 648 VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178, 649 VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179, 650 VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180, 651 VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181, 652 VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182, 653 VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183, 654 VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184, 655 VK_FORMAT_G8B8G8R8_422_UNORM = 1000156000, 656 VK_FORMAT_B8G8R8G8_422_UNORM = 1000156001, 657 VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM = 1000156002, 658 VK_FORMAT_G8_B8R8_2PLANE_420_UNORM = 1000156003, 659 VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM = 1000156004, 660 VK_FORMAT_G8_B8R8_2PLANE_422_UNORM = 1000156005, 661 VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM = 1000156006, 662 VK_FORMAT_R10X6_UNORM_PACK16 = 1000156007, 663 VK_FORMAT_R10X6G10X6_UNORM_2PACK16 = 1000156008, 664 VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 = 1000156009, 665 VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 = 1000156010, 666 VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 = 1000156011, 667 VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 = 1000156012, 668 VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 = 1000156013, 669 VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 = 1000156014, 670 VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 = 1000156015, 671 VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 = 1000156016, 672 VK_FORMAT_R12X4_UNORM_PACK16 = 1000156017, 673 VK_FORMAT_R12X4G12X4_UNORM_2PACK16 = 1000156018, 674 VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 = 1000156019, 675 VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 = 1000156020, 676 VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 = 1000156021, 677 VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 = 1000156022, 678 VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 = 1000156023, 679 VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 = 1000156024, 680 VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 = 1000156025, 681 VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 = 1000156026, 682 VK_FORMAT_G16B16G16R16_422_UNORM = 1000156027, 683 VK_FORMAT_B16G16R16G16_422_UNORM = 1000156028, 684 VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM = 1000156029, 685 VK_FORMAT_G16_B16R16_2PLANE_420_UNORM = 1000156030, 686 VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM = 1000156031, 687 VK_FORMAT_G16_B16R16_2PLANE_422_UNORM = 1000156032, 688 VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM = 1000156033, 689 VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000, 690 VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001, 691 VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002, 692 VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003, 693 VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004, 694 VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005, 695 VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006, 696 VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007, 697 VK_FORMAT_G8B8G8R8_422_UNORM_KHR = VK_FORMAT_G8B8G8R8_422_UNORM, 698 VK_FORMAT_B8G8R8G8_422_UNORM_KHR = VK_FORMAT_B8G8R8G8_422_UNORM, 699 VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM, 700 VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM, 701 VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM, 702 VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM, 703 VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM, 704 VK_FORMAT_R10X6_UNORM_PACK16_KHR = VK_FORMAT_R10X6_UNORM_PACK16, 705 VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR = VK_FORMAT_R10X6G10X6_UNORM_2PACK16, 706 VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16, 707 VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR = VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16, 708 VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16, 709 VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, 710 VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16, 711 VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16, 712 VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16, 713 VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16, 714 VK_FORMAT_R12X4_UNORM_PACK16_KHR = VK_FORMAT_R12X4_UNORM_PACK16, 715 VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR = VK_FORMAT_R12X4G12X4_UNORM_2PACK16, 716 VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR = VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16, 717 VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR = VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16, 718 VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR = VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16, 719 VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16, 720 VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16, 721 VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16, 722 VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16, 723 VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16, 724 VK_FORMAT_G16B16G16R16_422_UNORM_KHR = VK_FORMAT_G16B16G16R16_422_UNORM, 725 VK_FORMAT_B16G16R16G16_422_UNORM_KHR = VK_FORMAT_B16G16R16G16_422_UNORM, 726 VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, 727 VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM, 728 VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM, 729 VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, 730 VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM, 731 VK_FORMAT_BEGIN_RANGE = VK_FORMAT_UNDEFINED, 732 VK_FORMAT_END_RANGE = VK_FORMAT_ASTC_12x12_SRGB_BLOCK, 733 VK_FORMAT_RANGE_SIZE = (VK_FORMAT_ASTC_12x12_SRGB_BLOCK - VK_FORMAT_UNDEFINED + 1), 734 VK_FORMAT_MAX_ENUM = 0x7FFFFFFF 735 } VkFormat; 736 737 typedef enum VkImageType { 738 VK_IMAGE_TYPE_1D = 0, 739 VK_IMAGE_TYPE_2D = 1, 740 VK_IMAGE_TYPE_3D = 2, 741 VK_IMAGE_TYPE_BEGIN_RANGE = VK_IMAGE_TYPE_1D, 742 VK_IMAGE_TYPE_END_RANGE = VK_IMAGE_TYPE_3D, 743 VK_IMAGE_TYPE_RANGE_SIZE = (VK_IMAGE_TYPE_3D - VK_IMAGE_TYPE_1D + 1), 744 VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF 745 } VkImageType; 746 747 typedef enum VkImageTiling { 748 VK_IMAGE_TILING_OPTIMAL = 0, 749 VK_IMAGE_TILING_LINEAR = 1, 750 VK_IMAGE_TILING_BEGIN_RANGE = VK_IMAGE_TILING_OPTIMAL, 751 VK_IMAGE_TILING_END_RANGE = VK_IMAGE_TILING_LINEAR, 752 VK_IMAGE_TILING_RANGE_SIZE = (VK_IMAGE_TILING_LINEAR - VK_IMAGE_TILING_OPTIMAL + 1), 753 VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF 754 } VkImageTiling; 755 756 typedef enum VkPhysicalDeviceType { 757 VK_PHYSICAL_DEVICE_TYPE_OTHER = 0, 758 VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1, 759 VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2, 760 VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3, 761 VK_PHYSICAL_DEVICE_TYPE_CPU = 4, 762 VK_PHYSICAL_DEVICE_TYPE_BEGIN_RANGE = VK_PHYSICAL_DEVICE_TYPE_OTHER, 763 VK_PHYSICAL_DEVICE_TYPE_END_RANGE = VK_PHYSICAL_DEVICE_TYPE_CPU, 764 VK_PHYSICAL_DEVICE_TYPE_RANGE_SIZE = (VK_PHYSICAL_DEVICE_TYPE_CPU - VK_PHYSICAL_DEVICE_TYPE_OTHER + 1), 765 VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF 766 } VkPhysicalDeviceType; 767 768 typedef enum VkQueryType { 769 VK_QUERY_TYPE_OCCLUSION = 0, 770 VK_QUERY_TYPE_PIPELINE_STATISTICS = 1, 771 VK_QUERY_TYPE_TIMESTAMP = 2, 772 VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION, 773 VK_QUERY_TYPE_END_RANGE = VK_QUERY_TYPE_TIMESTAMP, 774 VK_QUERY_TYPE_RANGE_SIZE = (VK_QUERY_TYPE_TIMESTAMP - VK_QUERY_TYPE_OCCLUSION + 1), 775 VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF 776 } VkQueryType; 777 778 typedef enum VkSharingMode { 779 VK_SHARING_MODE_EXCLUSIVE = 0, 780 VK_SHARING_MODE_CONCURRENT = 1, 781 VK_SHARING_MODE_BEGIN_RANGE = VK_SHARING_MODE_EXCLUSIVE, 782 VK_SHARING_MODE_END_RANGE = VK_SHARING_MODE_CONCURRENT, 783 VK_SHARING_MODE_RANGE_SIZE = (VK_SHARING_MODE_CONCURRENT - VK_SHARING_MODE_EXCLUSIVE + 1), 784 VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF 785 } VkSharingMode; 786 787 typedef enum VkImageLayout { 788 VK_IMAGE_LAYOUT_UNDEFINED = 0, 789 VK_IMAGE_LAYOUT_GENERAL = 1, 790 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2, 791 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3, 792 VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4, 793 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5, 794 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6, 795 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7, 796 VK_IMAGE_LAYOUT_PREINITIALIZED = 8, 797 VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL = 1000117000, 798 VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL = 1000117001, 799 VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002, 800 VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000, 801 VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, 802 VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, 803 VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED, 804 VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_PREINITIALIZED, 805 VK_IMAGE_LAYOUT_RANGE_SIZE = (VK_IMAGE_LAYOUT_PREINITIALIZED - VK_IMAGE_LAYOUT_UNDEFINED + 1), 806 VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF 807 } VkImageLayout; 808 809 typedef enum VkImageViewType { 810 VK_IMAGE_VIEW_TYPE_1D = 0, 811 VK_IMAGE_VIEW_TYPE_2D = 1, 812 VK_IMAGE_VIEW_TYPE_3D = 2, 813 VK_IMAGE_VIEW_TYPE_CUBE = 3, 814 VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4, 815 VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5, 816 VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6, 817 VK_IMAGE_VIEW_TYPE_BEGIN_RANGE = VK_IMAGE_VIEW_TYPE_1D, 818 VK_IMAGE_VIEW_TYPE_END_RANGE = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, 819 VK_IMAGE_VIEW_TYPE_RANGE_SIZE = (VK_IMAGE_VIEW_TYPE_CUBE_ARRAY - VK_IMAGE_VIEW_TYPE_1D + 1), 820 VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF 821 } VkImageViewType; 822 823 typedef enum VkComponentSwizzle { 824 VK_COMPONENT_SWIZZLE_IDENTITY = 0, 825 VK_COMPONENT_SWIZZLE_ZERO = 1, 826 VK_COMPONENT_SWIZZLE_ONE = 2, 827 VK_COMPONENT_SWIZZLE_R = 3, 828 VK_COMPONENT_SWIZZLE_G = 4, 829 VK_COMPONENT_SWIZZLE_B = 5, 830 VK_COMPONENT_SWIZZLE_A = 6, 831 VK_COMPONENT_SWIZZLE_BEGIN_RANGE = VK_COMPONENT_SWIZZLE_IDENTITY, 832 VK_COMPONENT_SWIZZLE_END_RANGE = VK_COMPONENT_SWIZZLE_A, 833 VK_COMPONENT_SWIZZLE_RANGE_SIZE = (VK_COMPONENT_SWIZZLE_A - VK_COMPONENT_SWIZZLE_IDENTITY + 1), 834 VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF 835 } VkComponentSwizzle; 836 837 typedef enum VkVertexInputRate { 838 VK_VERTEX_INPUT_RATE_VERTEX = 0, 839 VK_VERTEX_INPUT_RATE_INSTANCE = 1, 840 VK_VERTEX_INPUT_RATE_BEGIN_RANGE = VK_VERTEX_INPUT_RATE_VERTEX, 841 VK_VERTEX_INPUT_RATE_END_RANGE = VK_VERTEX_INPUT_RATE_INSTANCE, 842 VK_VERTEX_INPUT_RATE_RANGE_SIZE = (VK_VERTEX_INPUT_RATE_INSTANCE - VK_VERTEX_INPUT_RATE_VERTEX + 1), 843 VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF 844 } VkVertexInputRate; 845 846 typedef enum VkPrimitiveTopology { 847 VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0, 848 VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1, 849 VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2, 850 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3, 851 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4, 852 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5, 853 VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6, 854 VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7, 855 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8, 856 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9, 857 VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10, 858 VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = VK_PRIMITIVE_TOPOLOGY_POINT_LIST, 859 VK_PRIMITIVE_TOPOLOGY_END_RANGE = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, 860 VK_PRIMITIVE_TOPOLOGY_RANGE_SIZE = (VK_PRIMITIVE_TOPOLOGY_PATCH_LIST - VK_PRIMITIVE_TOPOLOGY_POINT_LIST + 1), 861 VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF 862 } VkPrimitiveTopology; 863 864 typedef enum VkPolygonMode { 865 VK_POLYGON_MODE_FILL = 0, 866 VK_POLYGON_MODE_LINE = 1, 867 VK_POLYGON_MODE_POINT = 2, 868 VK_POLYGON_MODE_FILL_RECTANGLE_NV = 1000153000, 869 VK_POLYGON_MODE_BEGIN_RANGE = VK_POLYGON_MODE_FILL, 870 VK_POLYGON_MODE_END_RANGE = VK_POLYGON_MODE_POINT, 871 VK_POLYGON_MODE_RANGE_SIZE = (VK_POLYGON_MODE_POINT - VK_POLYGON_MODE_FILL + 1), 872 VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF 873 } VkPolygonMode; 874 875 typedef enum VkFrontFace { 876 VK_FRONT_FACE_COUNTER_CLOCKWISE = 0, 877 VK_FRONT_FACE_CLOCKWISE = 1, 878 VK_FRONT_FACE_BEGIN_RANGE = VK_FRONT_FACE_COUNTER_CLOCKWISE, 879 VK_FRONT_FACE_END_RANGE = VK_FRONT_FACE_CLOCKWISE, 880 VK_FRONT_FACE_RANGE_SIZE = (VK_FRONT_FACE_CLOCKWISE - VK_FRONT_FACE_COUNTER_CLOCKWISE + 1), 881 VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF 882 } VkFrontFace; 883 884 typedef enum VkCompareOp { 885 VK_COMPARE_OP_NEVER = 0, 886 VK_COMPARE_OP_LESS = 1, 887 VK_COMPARE_OP_EQUAL = 2, 888 VK_COMPARE_OP_LESS_OR_EQUAL = 3, 889 VK_COMPARE_OP_GREATER = 4, 890 VK_COMPARE_OP_NOT_EQUAL = 5, 891 VK_COMPARE_OP_GREATER_OR_EQUAL = 6, 892 VK_COMPARE_OP_ALWAYS = 7, 893 VK_COMPARE_OP_BEGIN_RANGE = VK_COMPARE_OP_NEVER, 894 VK_COMPARE_OP_END_RANGE = VK_COMPARE_OP_ALWAYS, 895 VK_COMPARE_OP_RANGE_SIZE = (VK_COMPARE_OP_ALWAYS - VK_COMPARE_OP_NEVER + 1), 896 VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF 897 } VkCompareOp; 898 899 typedef enum VkStencilOp { 900 VK_STENCIL_OP_KEEP = 0, 901 VK_STENCIL_OP_ZERO = 1, 902 VK_STENCIL_OP_REPLACE = 2, 903 VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3, 904 VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4, 905 VK_STENCIL_OP_INVERT = 5, 906 VK_STENCIL_OP_INCREMENT_AND_WRAP = 6, 907 VK_STENCIL_OP_DECREMENT_AND_WRAP = 7, 908 VK_STENCIL_OP_BEGIN_RANGE = VK_STENCIL_OP_KEEP, 909 VK_STENCIL_OP_END_RANGE = VK_STENCIL_OP_DECREMENT_AND_WRAP, 910 VK_STENCIL_OP_RANGE_SIZE = (VK_STENCIL_OP_DECREMENT_AND_WRAP - VK_STENCIL_OP_KEEP + 1), 911 VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF 912 } VkStencilOp; 913 914 typedef enum VkLogicOp { 915 VK_LOGIC_OP_CLEAR = 0, 916 VK_LOGIC_OP_AND = 1, 917 VK_LOGIC_OP_AND_REVERSE = 2, 918 VK_LOGIC_OP_COPY = 3, 919 VK_LOGIC_OP_AND_INVERTED = 4, 920 VK_LOGIC_OP_NO_OP = 5, 921 VK_LOGIC_OP_XOR = 6, 922 VK_LOGIC_OP_OR = 7, 923 VK_LOGIC_OP_NOR = 8, 924 VK_LOGIC_OP_EQUIVALENT = 9, 925 VK_LOGIC_OP_INVERT = 10, 926 VK_LOGIC_OP_OR_REVERSE = 11, 927 VK_LOGIC_OP_COPY_INVERTED = 12, 928 VK_LOGIC_OP_OR_INVERTED = 13, 929 VK_LOGIC_OP_NAND = 14, 930 VK_LOGIC_OP_SET = 15, 931 VK_LOGIC_OP_BEGIN_RANGE = VK_LOGIC_OP_CLEAR, 932 VK_LOGIC_OP_END_RANGE = VK_LOGIC_OP_SET, 933 VK_LOGIC_OP_RANGE_SIZE = (VK_LOGIC_OP_SET - VK_LOGIC_OP_CLEAR + 1), 934 VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF 935 } VkLogicOp; 936 937 typedef enum VkBlendFactor { 938 VK_BLEND_FACTOR_ZERO = 0, 939 VK_BLEND_FACTOR_ONE = 1, 940 VK_BLEND_FACTOR_SRC_COLOR = 2, 941 VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3, 942 VK_BLEND_FACTOR_DST_COLOR = 4, 943 VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5, 944 VK_BLEND_FACTOR_SRC_ALPHA = 6, 945 VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7, 946 VK_BLEND_FACTOR_DST_ALPHA = 8, 947 VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9, 948 VK_BLEND_FACTOR_CONSTANT_COLOR = 10, 949 VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11, 950 VK_BLEND_FACTOR_CONSTANT_ALPHA = 12, 951 VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13, 952 VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14, 953 VK_BLEND_FACTOR_SRC1_COLOR = 15, 954 VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16, 955 VK_BLEND_FACTOR_SRC1_ALPHA = 17, 956 VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18, 957 VK_BLEND_FACTOR_BEGIN_RANGE = VK_BLEND_FACTOR_ZERO, 958 VK_BLEND_FACTOR_END_RANGE = VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA, 959 VK_BLEND_FACTOR_RANGE_SIZE = (VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA - VK_BLEND_FACTOR_ZERO + 1), 960 VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF 961 } VkBlendFactor; 962 963 typedef enum VkBlendOp { 964 VK_BLEND_OP_ADD = 0, 965 VK_BLEND_OP_SUBTRACT = 1, 966 VK_BLEND_OP_REVERSE_SUBTRACT = 2, 967 VK_BLEND_OP_MIN = 3, 968 VK_BLEND_OP_MAX = 4, 969 VK_BLEND_OP_ZERO_EXT = 1000148000, 970 VK_BLEND_OP_SRC_EXT = 1000148001, 971 VK_BLEND_OP_DST_EXT = 1000148002, 972 VK_BLEND_OP_SRC_OVER_EXT = 1000148003, 973 VK_BLEND_OP_DST_OVER_EXT = 1000148004, 974 VK_BLEND_OP_SRC_IN_EXT = 1000148005, 975 VK_BLEND_OP_DST_IN_EXT = 1000148006, 976 VK_BLEND_OP_SRC_OUT_EXT = 1000148007, 977 VK_BLEND_OP_DST_OUT_EXT = 1000148008, 978 VK_BLEND_OP_SRC_ATOP_EXT = 1000148009, 979 VK_BLEND_OP_DST_ATOP_EXT = 1000148010, 980 VK_BLEND_OP_XOR_EXT = 1000148011, 981 VK_BLEND_OP_MULTIPLY_EXT = 1000148012, 982 VK_BLEND_OP_SCREEN_EXT = 1000148013, 983 VK_BLEND_OP_OVERLAY_EXT = 1000148014, 984 VK_BLEND_OP_DARKEN_EXT = 1000148015, 985 VK_BLEND_OP_LIGHTEN_EXT = 1000148016, 986 VK_BLEND_OP_COLORDODGE_EXT = 1000148017, 987 VK_BLEND_OP_COLORBURN_EXT = 1000148018, 988 VK_BLEND_OP_HARDLIGHT_EXT = 1000148019, 989 VK_BLEND_OP_SOFTLIGHT_EXT = 1000148020, 990 VK_BLEND_OP_DIFFERENCE_EXT = 1000148021, 991 VK_BLEND_OP_EXCLUSION_EXT = 1000148022, 992 VK_BLEND_OP_INVERT_EXT = 1000148023, 993 VK_BLEND_OP_INVERT_RGB_EXT = 1000148024, 994 VK_BLEND_OP_LINEARDODGE_EXT = 1000148025, 995 VK_BLEND_OP_LINEARBURN_EXT = 1000148026, 996 VK_BLEND_OP_VIVIDLIGHT_EXT = 1000148027, 997 VK_BLEND_OP_LINEARLIGHT_EXT = 1000148028, 998 VK_BLEND_OP_PINLIGHT_EXT = 1000148029, 999 VK_BLEND_OP_HARDMIX_EXT = 1000148030, 1000 VK_BLEND_OP_HSL_HUE_EXT = 1000148031, 1001 VK_BLEND_OP_HSL_SATURATION_EXT = 1000148032, 1002 VK_BLEND_OP_HSL_COLOR_EXT = 1000148033, 1003 VK_BLEND_OP_HSL_LUMINOSITY_EXT = 1000148034, 1004 VK_BLEND_OP_PLUS_EXT = 1000148035, 1005 VK_BLEND_OP_PLUS_CLAMPED_EXT = 1000148036, 1006 VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT = 1000148037, 1007 VK_BLEND_OP_PLUS_DARKER_EXT = 1000148038, 1008 VK_BLEND_OP_MINUS_EXT = 1000148039, 1009 VK_BLEND_OP_MINUS_CLAMPED_EXT = 1000148040, 1010 VK_BLEND_OP_CONTRAST_EXT = 1000148041, 1011 VK_BLEND_OP_INVERT_OVG_EXT = 1000148042, 1012 VK_BLEND_OP_RED_EXT = 1000148043, 1013 VK_BLEND_OP_GREEN_EXT = 1000148044, 1014 VK_BLEND_OP_BLUE_EXT = 1000148045, 1015 VK_BLEND_OP_BEGIN_RANGE = VK_BLEND_OP_ADD, 1016 VK_BLEND_OP_END_RANGE = VK_BLEND_OP_MAX, 1017 VK_BLEND_OP_RANGE_SIZE = (VK_BLEND_OP_MAX - VK_BLEND_OP_ADD + 1), 1018 VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF 1019 } VkBlendOp; 1020 1021 typedef enum VkDynamicState { 1022 VK_DYNAMIC_STATE_VIEWPORT = 0, 1023 VK_DYNAMIC_STATE_SCISSOR = 1, 1024 VK_DYNAMIC_STATE_LINE_WIDTH = 2, 1025 VK_DYNAMIC_STATE_DEPTH_BIAS = 3, 1026 VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4, 1027 VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5, 1028 VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6, 1029 VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7, 1030 VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8, 1031 VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV = 1000087000, 1032 VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = 1000099000, 1033 VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT = 1000143000, 1034 VK_DYNAMIC_STATE_BEGIN_RANGE = VK_DYNAMIC_STATE_VIEWPORT, 1035 VK_DYNAMIC_STATE_END_RANGE = VK_DYNAMIC_STATE_STENCIL_REFERENCE, 1036 VK_DYNAMIC_STATE_RANGE_SIZE = (VK_DYNAMIC_STATE_STENCIL_REFERENCE - VK_DYNAMIC_STATE_VIEWPORT + 1), 1037 VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF 1038 } VkDynamicState; 1039 1040 typedef enum VkFilter { 1041 VK_FILTER_NEAREST = 0, 1042 VK_FILTER_LINEAR = 1, 1043 VK_FILTER_CUBIC_IMG = 1000015000, 1044 VK_FILTER_BEGIN_RANGE = VK_FILTER_NEAREST, 1045 VK_FILTER_END_RANGE = VK_FILTER_LINEAR, 1046 VK_FILTER_RANGE_SIZE = (VK_FILTER_LINEAR - VK_FILTER_NEAREST + 1), 1047 VK_FILTER_MAX_ENUM = 0x7FFFFFFF 1048 } VkFilter; 1049 1050 typedef enum VkSamplerMipmapMode { 1051 VK_SAMPLER_MIPMAP_MODE_NEAREST = 0, 1052 VK_SAMPLER_MIPMAP_MODE_LINEAR = 1, 1053 VK_SAMPLER_MIPMAP_MODE_BEGIN_RANGE = VK_SAMPLER_MIPMAP_MODE_NEAREST, 1054 VK_SAMPLER_MIPMAP_MODE_END_RANGE = VK_SAMPLER_MIPMAP_MODE_LINEAR, 1055 VK_SAMPLER_MIPMAP_MODE_RANGE_SIZE = (VK_SAMPLER_MIPMAP_MODE_LINEAR - VK_SAMPLER_MIPMAP_MODE_NEAREST + 1), 1056 VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF 1057 } VkSamplerMipmapMode; 1058 1059 typedef enum VkSamplerAddressMode { 1060 VK_SAMPLER_ADDRESS_MODE_REPEAT = 0, 1061 VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1, 1062 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2, 1063 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3, 1064 VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4, 1065 VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE = VK_SAMPLER_ADDRESS_MODE_REPEAT, 1066 VK_SAMPLER_ADDRESS_MODE_END_RANGE = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER, 1067 VK_SAMPLER_ADDRESS_MODE_RANGE_SIZE = (VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER - VK_SAMPLER_ADDRESS_MODE_REPEAT + 1), 1068 VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF 1069 } VkSamplerAddressMode; 1070 1071 typedef enum VkBorderColor { 1072 VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0, 1073 VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1, 1074 VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2, 1075 VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3, 1076 VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4, 1077 VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5, 1078 VK_BORDER_COLOR_BEGIN_RANGE = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, 1079 VK_BORDER_COLOR_END_RANGE = VK_BORDER_COLOR_INT_OPAQUE_WHITE, 1080 VK_BORDER_COLOR_RANGE_SIZE = (VK_BORDER_COLOR_INT_OPAQUE_WHITE - VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK + 1), 1081 VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF 1082 } VkBorderColor; 1083 1084 typedef enum VkDescriptorType { 1085 VK_DESCRIPTOR_TYPE_SAMPLER = 0, 1086 VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1, 1087 VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2, 1088 VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3, 1089 VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4, 1090 VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5, 1091 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6, 1092 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7, 1093 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8, 1094 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9, 1095 VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10, 1096 VK_DESCRIPTOR_TYPE_BEGIN_RANGE = VK_DESCRIPTOR_TYPE_SAMPLER, 1097 VK_DESCRIPTOR_TYPE_END_RANGE = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, 1098 VK_DESCRIPTOR_TYPE_RANGE_SIZE = (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT - VK_DESCRIPTOR_TYPE_SAMPLER + 1), 1099 VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF 1100 } VkDescriptorType; 1101 1102 typedef enum VkAttachmentLoadOp { 1103 VK_ATTACHMENT_LOAD_OP_LOAD = 0, 1104 VK_ATTACHMENT_LOAD_OP_CLEAR = 1, 1105 VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2, 1106 VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE = VK_ATTACHMENT_LOAD_OP_LOAD, 1107 VK_ATTACHMENT_LOAD_OP_END_RANGE = VK_ATTACHMENT_LOAD_OP_DONT_CARE, 1108 VK_ATTACHMENT_LOAD_OP_RANGE_SIZE = (VK_ATTACHMENT_LOAD_OP_DONT_CARE - VK_ATTACHMENT_LOAD_OP_LOAD + 1), 1109 VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF 1110 } VkAttachmentLoadOp; 1111 1112 typedef enum VkAttachmentStoreOp { 1113 VK_ATTACHMENT_STORE_OP_STORE = 0, 1114 VK_ATTACHMENT_STORE_OP_DONT_CARE = 1, 1115 VK_ATTACHMENT_STORE_OP_BEGIN_RANGE = VK_ATTACHMENT_STORE_OP_STORE, 1116 VK_ATTACHMENT_STORE_OP_END_RANGE = VK_ATTACHMENT_STORE_OP_DONT_CARE, 1117 VK_ATTACHMENT_STORE_OP_RANGE_SIZE = (VK_ATTACHMENT_STORE_OP_DONT_CARE - VK_ATTACHMENT_STORE_OP_STORE + 1), 1118 VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF 1119 } VkAttachmentStoreOp; 1120 1121 typedef enum VkPipelineBindPoint { 1122 VK_PIPELINE_BIND_POINT_GRAPHICS = 0, 1123 VK_PIPELINE_BIND_POINT_COMPUTE = 1, 1124 VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VK_PIPELINE_BIND_POINT_GRAPHICS, 1125 VK_PIPELINE_BIND_POINT_END_RANGE = VK_PIPELINE_BIND_POINT_COMPUTE, 1126 VK_PIPELINE_BIND_POINT_RANGE_SIZE = (VK_PIPELINE_BIND_POINT_COMPUTE - VK_PIPELINE_BIND_POINT_GRAPHICS + 1), 1127 VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF 1128 } VkPipelineBindPoint; 1129 1130 typedef enum VkCommandBufferLevel { 1131 VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0, 1132 VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1, 1133 VK_COMMAND_BUFFER_LEVEL_BEGIN_RANGE = VK_COMMAND_BUFFER_LEVEL_PRIMARY, 1134 VK_COMMAND_BUFFER_LEVEL_END_RANGE = VK_COMMAND_BUFFER_LEVEL_SECONDARY, 1135 VK_COMMAND_BUFFER_LEVEL_RANGE_SIZE = (VK_COMMAND_BUFFER_LEVEL_SECONDARY - VK_COMMAND_BUFFER_LEVEL_PRIMARY + 1), 1136 VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF 1137 } VkCommandBufferLevel; 1138 1139 typedef enum VkIndexType { 1140 VK_INDEX_TYPE_UINT16 = 0, 1141 VK_INDEX_TYPE_UINT32 = 1, 1142 VK_INDEX_TYPE_BEGIN_RANGE = VK_INDEX_TYPE_UINT16, 1143 VK_INDEX_TYPE_END_RANGE = VK_INDEX_TYPE_UINT32, 1144 VK_INDEX_TYPE_RANGE_SIZE = (VK_INDEX_TYPE_UINT32 - VK_INDEX_TYPE_UINT16 + 1), 1145 VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF 1146 } VkIndexType; 1147 1148 typedef enum VkSubpassContents { 1149 VK_SUBPASS_CONTENTS_INLINE = 0, 1150 VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1, 1151 VK_SUBPASS_CONTENTS_BEGIN_RANGE = VK_SUBPASS_CONTENTS_INLINE, 1152 VK_SUBPASS_CONTENTS_END_RANGE = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS, 1153 VK_SUBPASS_CONTENTS_RANGE_SIZE = (VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS - VK_SUBPASS_CONTENTS_INLINE + 1), 1154 VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF 1155 } VkSubpassContents; 1156 1157 typedef enum VkObjectType { 1158 VK_OBJECT_TYPE_UNKNOWN = 0, 1159 VK_OBJECT_TYPE_INSTANCE = 1, 1160 VK_OBJECT_TYPE_PHYSICAL_DEVICE = 2, 1161 VK_OBJECT_TYPE_DEVICE = 3, 1162 VK_OBJECT_TYPE_QUEUE = 4, 1163 VK_OBJECT_TYPE_SEMAPHORE = 5, 1164 VK_OBJECT_TYPE_COMMAND_BUFFER = 6, 1165 VK_OBJECT_TYPE_FENCE = 7, 1166 VK_OBJECT_TYPE_DEVICE_MEMORY = 8, 1167 VK_OBJECT_TYPE_BUFFER = 9, 1168 VK_OBJECT_TYPE_IMAGE = 10, 1169 VK_OBJECT_TYPE_EVENT = 11, 1170 VK_OBJECT_TYPE_QUERY_POOL = 12, 1171 VK_OBJECT_TYPE_BUFFER_VIEW = 13, 1172 VK_OBJECT_TYPE_IMAGE_VIEW = 14, 1173 VK_OBJECT_TYPE_SHADER_MODULE = 15, 1174 VK_OBJECT_TYPE_PIPELINE_CACHE = 16, 1175 VK_OBJECT_TYPE_PIPELINE_LAYOUT = 17, 1176 VK_OBJECT_TYPE_RENDER_PASS = 18, 1177 VK_OBJECT_TYPE_PIPELINE = 19, 1178 VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 20, 1179 VK_OBJECT_TYPE_SAMPLER = 21, 1180 VK_OBJECT_TYPE_DESCRIPTOR_POOL = 22, 1181 VK_OBJECT_TYPE_DESCRIPTOR_SET = 23, 1182 VK_OBJECT_TYPE_FRAMEBUFFER = 24, 1183 VK_OBJECT_TYPE_COMMAND_POOL = 25, 1184 VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION = 1000156000, 1185 VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE = 1000085000, 1186 VK_OBJECT_TYPE_SURFACE_KHR = 1000000000, 1187 VK_OBJECT_TYPE_SWAPCHAIN_KHR = 1000001000, 1188 VK_OBJECT_TYPE_DISPLAY_KHR = 1000002000, 1189 VK_OBJECT_TYPE_DISPLAY_MODE_KHR = 1000002001, 1190 VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT = 1000011000, 1191 VK_OBJECT_TYPE_OBJECT_TABLE_NVX = 1000086000, 1192 VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX = 1000086001, 1193 VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT = 1000128000, 1194 VK_OBJECT_TYPE_VALIDATION_CACHE_EXT = 1000160000, 1195 VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE, 1196 VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION, 1197 VK_OBJECT_TYPE_BEGIN_RANGE = VK_OBJECT_TYPE_UNKNOWN, 1198 VK_OBJECT_TYPE_END_RANGE = VK_OBJECT_TYPE_COMMAND_POOL, 1199 VK_OBJECT_TYPE_RANGE_SIZE = (VK_OBJECT_TYPE_COMMAND_POOL - VK_OBJECT_TYPE_UNKNOWN + 1), 1200 VK_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF 1201 } VkObjectType; 1202 1203 typedef VkFlags VkInstanceCreateFlags; 1204 1205 typedef enum VkFormatFeatureFlagBits { 1206 VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001, 1207 VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002, 1208 VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004, 1209 VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008, 1210 VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010, 1211 VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020, 1212 VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040, 1213 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080, 1214 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100, 1215 VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200, 1216 VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400, 1217 VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800, 1218 VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000, 1219 VK_FORMAT_FEATURE_TRANSFER_SRC_BIT = 0x00004000, 1220 VK_FORMAT_FEATURE_TRANSFER_DST_BIT = 0x00008000, 1221 VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT = 0x00020000, 1222 VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT = 0x00040000, 1223 VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT = 0x00080000, 1224 VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT = 0x00100000, 1225 VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT = 0x00200000, 1226 VK_FORMAT_FEATURE_DISJOINT_BIT = 0x00400000, 1227 VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT = 0x00800000, 1228 VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = 0x00002000, 1229 VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT = 0x00010000, 1230 VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT, 1231 VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_DST_BIT, 1232 VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT, 1233 VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT, 1234 VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT, 1235 VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT, 1236 VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT, 1237 VK_FORMAT_FEATURE_DISJOINT_BIT_KHR = VK_FORMAT_FEATURE_DISJOINT_BIT, 1238 VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT, 1239 VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1240 } VkFormatFeatureFlagBits; 1241 typedef VkFlags VkFormatFeatureFlags; 1242 1243 typedef enum VkImageUsageFlagBits { 1244 VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001, 1245 VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002, 1246 VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004, 1247 VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008, 1248 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010, 1249 VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020, 1250 VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040, 1251 VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080, 1252 VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1253 } VkImageUsageFlagBits; 1254 typedef VkFlags VkImageUsageFlags; 1255 1256 typedef enum VkImageCreateFlagBits { 1257 VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001, 1258 VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, 1259 VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004, 1260 VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008, 1261 VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010, 1262 VK_IMAGE_CREATE_ALIAS_BIT = 0x00000400, 1263 VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT = 0x00000040, 1264 VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT = 0x00000020, 1265 VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT = 0x00000080, 1266 VK_IMAGE_CREATE_EXTENDED_USAGE_BIT = 0x00000100, 1267 VK_IMAGE_CREATE_PROTECTED_BIT = 0x00000800, 1268 VK_IMAGE_CREATE_DISJOINT_BIT = 0x00000200, 1269 VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = 0x00001000, 1270 VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT, 1271 VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT, 1272 VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT, 1273 VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT, 1274 VK_IMAGE_CREATE_DISJOINT_BIT_KHR = VK_IMAGE_CREATE_DISJOINT_BIT, 1275 VK_IMAGE_CREATE_ALIAS_BIT_KHR = VK_IMAGE_CREATE_ALIAS_BIT, 1276 VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1277 } VkImageCreateFlagBits; 1278 typedef VkFlags VkImageCreateFlags; 1279 1280 typedef enum VkSampleCountFlagBits { 1281 VK_SAMPLE_COUNT_1_BIT = 0x00000001, 1282 VK_SAMPLE_COUNT_2_BIT = 0x00000002, 1283 VK_SAMPLE_COUNT_4_BIT = 0x00000004, 1284 VK_SAMPLE_COUNT_8_BIT = 0x00000008, 1285 VK_SAMPLE_COUNT_16_BIT = 0x00000010, 1286 VK_SAMPLE_COUNT_32_BIT = 0x00000020, 1287 VK_SAMPLE_COUNT_64_BIT = 0x00000040, 1288 VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1289 } VkSampleCountFlagBits; 1290 typedef VkFlags VkSampleCountFlags; 1291 1292 typedef enum VkQueueFlagBits { 1293 VK_QUEUE_GRAPHICS_BIT = 0x00000001, 1294 VK_QUEUE_COMPUTE_BIT = 0x00000002, 1295 VK_QUEUE_TRANSFER_BIT = 0x00000004, 1296 VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008, 1297 VK_QUEUE_PROTECTED_BIT = 0x00000010, 1298 VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1299 } VkQueueFlagBits; 1300 typedef VkFlags VkQueueFlags; 1301 1302 typedef enum VkMemoryPropertyFlagBits { 1303 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001, 1304 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002, 1305 VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004, 1306 VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008, 1307 VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010, 1308 VK_MEMORY_PROPERTY_PROTECTED_BIT = 0x00000020, 1309 VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1310 } VkMemoryPropertyFlagBits; 1311 typedef VkFlags VkMemoryPropertyFlags; 1312 1313 typedef enum VkMemoryHeapFlagBits { 1314 VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001, 1315 VK_MEMORY_HEAP_MULTI_INSTANCE_BIT = 0x00000002, 1316 VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT, 1317 VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1318 } VkMemoryHeapFlagBits; 1319 typedef VkFlags VkMemoryHeapFlags; 1320 typedef VkFlags VkDeviceCreateFlags; 1321 1322 typedef enum VkDeviceQueueCreateFlagBits { 1323 VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT = 0x00000001, 1324 VK_DEVICE_QUEUE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1325 } VkDeviceQueueCreateFlagBits; 1326 typedef VkFlags VkDeviceQueueCreateFlags; 1327 1328 typedef enum VkPipelineStageFlagBits { 1329 VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001, 1330 VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002, 1331 VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004, 1332 VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008, 1333 VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010, 1334 VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020, 1335 VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040, 1336 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080, 1337 VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100, 1338 VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200, 1339 VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400, 1340 VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800, 1341 VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000, 1342 VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000, 1343 VK_PIPELINE_STAGE_HOST_BIT = 0x00004000, 1344 VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000, 1345 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000, 1346 VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX = 0x00020000, 1347 VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1348 } VkPipelineStageFlagBits; 1349 typedef VkFlags VkPipelineStageFlags; 1350 typedef VkFlags VkMemoryMapFlags; 1351 1352 typedef enum VkImageAspectFlagBits { 1353 VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001, 1354 VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002, 1355 VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004, 1356 VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008, 1357 VK_IMAGE_ASPECT_PLANE_0_BIT = 0x00000010, 1358 VK_IMAGE_ASPECT_PLANE_1_BIT = 0x00000020, 1359 VK_IMAGE_ASPECT_PLANE_2_BIT = 0x00000040, 1360 VK_IMAGE_ASPECT_PLANE_0_BIT_KHR = VK_IMAGE_ASPECT_PLANE_0_BIT, 1361 VK_IMAGE_ASPECT_PLANE_1_BIT_KHR = VK_IMAGE_ASPECT_PLANE_1_BIT, 1362 VK_IMAGE_ASPECT_PLANE_2_BIT_KHR = VK_IMAGE_ASPECT_PLANE_2_BIT, 1363 VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1364 } VkImageAspectFlagBits; 1365 typedef VkFlags VkImageAspectFlags; 1366 1367 typedef enum VkSparseImageFormatFlagBits { 1368 VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001, 1369 VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002, 1370 VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004, 1371 VK_SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1372 } VkSparseImageFormatFlagBits; 1373 typedef VkFlags VkSparseImageFormatFlags; 1374 1375 typedef enum VkSparseMemoryBindFlagBits { 1376 VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0x00000001, 1377 VK_SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1378 } VkSparseMemoryBindFlagBits; 1379 typedef VkFlags VkSparseMemoryBindFlags; 1380 1381 typedef enum VkFenceCreateFlagBits { 1382 VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001, 1383 VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1384 } VkFenceCreateFlagBits; 1385 typedef VkFlags VkFenceCreateFlags; 1386 typedef VkFlags VkSemaphoreCreateFlags; 1387 typedef VkFlags VkEventCreateFlags; 1388 typedef VkFlags VkQueryPoolCreateFlags; 1389 1390 typedef enum VkQueryPipelineStatisticFlagBits { 1391 VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001, 1392 VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002, 1393 VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004, 1394 VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008, 1395 VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0x00000010, 1396 VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0x00000020, 1397 VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0x00000040, 1398 VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0x00000080, 1399 VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x00000100, 1400 VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0x00000200, 1401 VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400, 1402 VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1403 } VkQueryPipelineStatisticFlagBits; 1404 typedef VkFlags VkQueryPipelineStatisticFlags; 1405 1406 typedef enum VkQueryResultFlagBits { 1407 VK_QUERY_RESULT_64_BIT = 0x00000001, 1408 VK_QUERY_RESULT_WAIT_BIT = 0x00000002, 1409 VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004, 1410 VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008, 1411 VK_QUERY_RESULT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1412 } VkQueryResultFlagBits; 1413 typedef VkFlags VkQueryResultFlags; 1414 1415 typedef enum VkBufferCreateFlagBits { 1416 VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001, 1417 VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, 1418 VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004, 1419 VK_BUFFER_CREATE_PROTECTED_BIT = 0x00000008, 1420 VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1421 } VkBufferCreateFlagBits; 1422 typedef VkFlags VkBufferCreateFlags; 1423 1424 typedef enum VkBufferUsageFlagBits { 1425 VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001, 1426 VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002, 1427 VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004, 1428 VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008, 1429 VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010, 1430 VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020, 1431 VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040, 1432 VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080, 1433 VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100, 1434 VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1435 } VkBufferUsageFlagBits; 1436 typedef VkFlags VkBufferUsageFlags; 1437 typedef VkFlags VkBufferViewCreateFlags; 1438 typedef VkFlags VkImageViewCreateFlags; 1439 typedef VkFlags VkShaderModuleCreateFlags; 1440 typedef VkFlags VkPipelineCacheCreateFlags; 1441 1442 typedef enum VkPipelineCreateFlagBits { 1443 VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001, 1444 VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002, 1445 VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004, 1446 VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0x00000008, 1447 VK_PIPELINE_CREATE_DISPATCH_BASE = 0x00000010, 1448 VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT, 1449 VK_PIPELINE_CREATE_DISPATCH_BASE_KHR = VK_PIPELINE_CREATE_DISPATCH_BASE, 1450 VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1451 } VkPipelineCreateFlagBits; 1452 typedef VkFlags VkPipelineCreateFlags; 1453 typedef VkFlags VkPipelineShaderStageCreateFlags; 1454 1455 typedef enum VkShaderStageFlagBits { 1456 VK_SHADER_STAGE_VERTEX_BIT = 0x00000001, 1457 VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002, 1458 VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004, 1459 VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008, 1460 VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010, 1461 VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020, 1462 VK_SHADER_STAGE_ALL_GRAPHICS = 0x0000001F, 1463 VK_SHADER_STAGE_ALL = 0x7FFFFFFF, 1464 VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1465 } VkShaderStageFlagBits; 1466 typedef VkFlags VkPipelineVertexInputStateCreateFlags; 1467 typedef VkFlags VkPipelineInputAssemblyStateCreateFlags; 1468 typedef VkFlags VkPipelineTessellationStateCreateFlags; 1469 typedef VkFlags VkPipelineViewportStateCreateFlags; 1470 typedef VkFlags VkPipelineRasterizationStateCreateFlags; 1471 1472 typedef enum VkCullModeFlagBits { 1473 VK_CULL_MODE_NONE = 0, 1474 VK_CULL_MODE_FRONT_BIT = 0x00000001, 1475 VK_CULL_MODE_BACK_BIT = 0x00000002, 1476 VK_CULL_MODE_FRONT_AND_BACK = 0x00000003, 1477 VK_CULL_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1478 } VkCullModeFlagBits; 1479 typedef VkFlags VkCullModeFlags; 1480 typedef VkFlags VkPipelineMultisampleStateCreateFlags; 1481 typedef VkFlags VkPipelineDepthStencilStateCreateFlags; 1482 typedef VkFlags VkPipelineColorBlendStateCreateFlags; 1483 1484 typedef enum VkColorComponentFlagBits { 1485 VK_COLOR_COMPONENT_R_BIT = 0x00000001, 1486 VK_COLOR_COMPONENT_G_BIT = 0x00000002, 1487 VK_COLOR_COMPONENT_B_BIT = 0x00000004, 1488 VK_COLOR_COMPONENT_A_BIT = 0x00000008, 1489 VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1490 } VkColorComponentFlagBits; 1491 typedef VkFlags VkColorComponentFlags; 1492 typedef VkFlags VkPipelineDynamicStateCreateFlags; 1493 typedef VkFlags VkPipelineLayoutCreateFlags; 1494 typedef VkFlags VkShaderStageFlags; 1495 typedef VkFlags VkSamplerCreateFlags; 1496 1497 typedef enum VkDescriptorSetLayoutCreateFlagBits { 1498 VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR = 0x00000001, 1499 VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1500 } VkDescriptorSetLayoutCreateFlagBits; 1501 typedef VkFlags VkDescriptorSetLayoutCreateFlags; 1502 1503 typedef enum VkDescriptorPoolCreateFlagBits { 1504 VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001, 1505 VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1506 } VkDescriptorPoolCreateFlagBits; 1507 typedef VkFlags VkDescriptorPoolCreateFlags; 1508 typedef VkFlags VkDescriptorPoolResetFlags; 1509 typedef VkFlags VkFramebufferCreateFlags; 1510 typedef VkFlags VkRenderPassCreateFlags; 1511 1512 typedef enum VkAttachmentDescriptionFlagBits { 1513 VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001, 1514 VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1515 } VkAttachmentDescriptionFlagBits; 1516 typedef VkFlags VkAttachmentDescriptionFlags; 1517 1518 typedef enum VkSubpassDescriptionFlagBits { 1519 VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX = 0x00000001, 1520 VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX = 0x00000002, 1521 VK_SUBPASS_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1522 } VkSubpassDescriptionFlagBits; 1523 typedef VkFlags VkSubpassDescriptionFlags; 1524 1525 typedef enum VkAccessFlagBits { 1526 VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001, 1527 VK_ACCESS_INDEX_READ_BIT = 0x00000002, 1528 VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004, 1529 VK_ACCESS_UNIFORM_READ_BIT = 0x00000008, 1530 VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0x00000010, 1531 VK_ACCESS_SHADER_READ_BIT = 0x00000020, 1532 VK_ACCESS_SHADER_WRITE_BIT = 0x00000040, 1533 VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0x00000080, 1534 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100, 1535 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200, 1536 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400, 1537 VK_ACCESS_TRANSFER_READ_BIT = 0x00000800, 1538 VK_ACCESS_TRANSFER_WRITE_BIT = 0x00001000, 1539 VK_ACCESS_HOST_READ_BIT = 0x00002000, 1540 VK_ACCESS_HOST_WRITE_BIT = 0x00004000, 1541 VK_ACCESS_MEMORY_READ_BIT = 0x00008000, 1542 VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000, 1543 VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX = 0x00020000, 1544 VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX = 0x00040000, 1545 VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000, 1546 VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1547 } VkAccessFlagBits; 1548 typedef VkFlags VkAccessFlags; 1549 1550 typedef enum VkDependencyFlagBits { 1551 VK_DEPENDENCY_BY_REGION_BIT = 0x00000001, 1552 VK_DEPENDENCY_DEVICE_GROUP_BIT = 0x00000004, 1553 VK_DEPENDENCY_VIEW_LOCAL_BIT = 0x00000002, 1554 VK_DEPENDENCY_VIEW_LOCAL_BIT_KHR = VK_DEPENDENCY_VIEW_LOCAL_BIT, 1555 VK_DEPENDENCY_DEVICE_GROUP_BIT_KHR = VK_DEPENDENCY_DEVICE_GROUP_BIT, 1556 VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1557 } VkDependencyFlagBits; 1558 typedef VkFlags VkDependencyFlags; 1559 1560 typedef enum VkCommandPoolCreateFlagBits { 1561 VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001, 1562 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002, 1563 VK_COMMAND_POOL_CREATE_PROTECTED_BIT = 0x00000004, 1564 VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1565 } VkCommandPoolCreateFlagBits; 1566 typedef VkFlags VkCommandPoolCreateFlags; 1567 1568 typedef enum VkCommandPoolResetFlagBits { 1569 VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001, 1570 VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1571 } VkCommandPoolResetFlagBits; 1572 typedef VkFlags VkCommandPoolResetFlags; 1573 1574 typedef enum VkCommandBufferUsageFlagBits { 1575 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001, 1576 VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002, 1577 VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004, 1578 VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1579 } VkCommandBufferUsageFlagBits; 1580 typedef VkFlags VkCommandBufferUsageFlags; 1581 1582 typedef enum VkQueryControlFlagBits { 1583 VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001, 1584 VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1585 } VkQueryControlFlagBits; 1586 typedef VkFlags VkQueryControlFlags; 1587 1588 typedef enum VkCommandBufferResetFlagBits { 1589 VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001, 1590 VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1591 } VkCommandBufferResetFlagBits; 1592 typedef VkFlags VkCommandBufferResetFlags; 1593 1594 typedef enum VkStencilFaceFlagBits { 1595 VK_STENCIL_FACE_FRONT_BIT = 0x00000001, 1596 VK_STENCIL_FACE_BACK_BIT = 0x00000002, 1597 VK_STENCIL_FRONT_AND_BACK = 0x00000003, 1598 VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1599 } VkStencilFaceFlagBits; 1600 typedef VkFlags VkStencilFaceFlags; 1601 1602 typedef struct VkApplicationInfo { 1603 VkStructureType sType; 1604 const void* pNext; 1605 const char* pApplicationName; 1606 uint32_t applicationVersion; 1607 const char* pEngineName; 1608 uint32_t engineVersion; 1609 uint32_t apiVersion; 1610 } VkApplicationInfo; 1611 1612 typedef struct VkInstanceCreateInfo { 1613 VkStructureType sType; 1614 const void* pNext; 1615 VkInstanceCreateFlags flags; 1616 const VkApplicationInfo* pApplicationInfo; 1617 uint32_t enabledLayerCount; 1618 const char* const* ppEnabledLayerNames; 1619 uint32_t enabledExtensionCount; 1620 const char* const* ppEnabledExtensionNames; 1621 } VkInstanceCreateInfo; 1622 1623 typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)( 1624 void* pUserData, 1625 size_t size, 1626 size_t alignment, 1627 VkSystemAllocationScope allocationScope); 1628 1629 typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)( 1630 void* pUserData, 1631 void* pOriginal, 1632 size_t size, 1633 size_t alignment, 1634 VkSystemAllocationScope allocationScope); 1635 1636 typedef void (VKAPI_PTR *PFN_vkFreeFunction)( 1637 void* pUserData, 1638 void* pMemory); 1639 1640 typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)( 1641 void* pUserData, 1642 size_t size, 1643 VkInternalAllocationType allocationType, 1644 VkSystemAllocationScope allocationScope); 1645 1646 typedef void (VKAPI_PTR *PFN_vkInternalFreeNotification)( 1647 void* pUserData, 1648 size_t size, 1649 VkInternalAllocationType allocationType, 1650 VkSystemAllocationScope allocationScope); 1651 1652 typedef struct VkAllocationCallbacks { 1653 void* pUserData; 1654 PFN_vkAllocationFunction pfnAllocation; 1655 PFN_vkReallocationFunction pfnReallocation; 1656 PFN_vkFreeFunction pfnFree; 1657 PFN_vkInternalAllocationNotification pfnInternalAllocation; 1658 PFN_vkInternalFreeNotification pfnInternalFree; 1659 } VkAllocationCallbacks; 1660 1661 typedef struct VkPhysicalDeviceFeatures { 1662 VkBool32 robustBufferAccess; 1663 VkBool32 fullDrawIndexUint32; 1664 VkBool32 imageCubeArray; 1665 VkBool32 independentBlend; 1666 VkBool32 geometryShader; 1667 VkBool32 tessellationShader; 1668 VkBool32 sampleRateShading; 1669 VkBool32 dualSrcBlend; 1670 VkBool32 logicOp; 1671 VkBool32 multiDrawIndirect; 1672 VkBool32 drawIndirectFirstInstance; 1673 VkBool32 depthClamp; 1674 VkBool32 depthBiasClamp; 1675 VkBool32 fillModeNonSolid; 1676 VkBool32 depthBounds; 1677 VkBool32 wideLines; 1678 VkBool32 largePoints; 1679 VkBool32 alphaToOne; 1680 VkBool32 multiViewport; 1681 VkBool32 samplerAnisotropy; 1682 VkBool32 textureCompressionETC2; 1683 VkBool32 textureCompressionASTC_LDR; 1684 VkBool32 textureCompressionBC; 1685 VkBool32 occlusionQueryPrecise; 1686 VkBool32 pipelineStatisticsQuery; 1687 VkBool32 vertexPipelineStoresAndAtomics; 1688 VkBool32 fragmentStoresAndAtomics; 1689 VkBool32 shaderTessellationAndGeometryPointSize; 1690 VkBool32 shaderImageGatherExtended; 1691 VkBool32 shaderStorageImageExtendedFormats; 1692 VkBool32 shaderStorageImageMultisample; 1693 VkBool32 shaderStorageImageReadWithoutFormat; 1694 VkBool32 shaderStorageImageWriteWithoutFormat; 1695 VkBool32 shaderUniformBufferArrayDynamicIndexing; 1696 VkBool32 shaderSampledImageArrayDynamicIndexing; 1697 VkBool32 shaderStorageBufferArrayDynamicIndexing; 1698 VkBool32 shaderStorageImageArrayDynamicIndexing; 1699 VkBool32 shaderClipDistance; 1700 VkBool32 shaderCullDistance; 1701 VkBool32 shaderFloat64; 1702 VkBool32 shaderInt64; 1703 VkBool32 shaderInt16; 1704 VkBool32 shaderResourceResidency; 1705 VkBool32 shaderResourceMinLod; 1706 VkBool32 sparseBinding; 1707 VkBool32 sparseResidencyBuffer; 1708 VkBool32 sparseResidencyImage2D; 1709 VkBool32 sparseResidencyImage3D; 1710 VkBool32 sparseResidency2Samples; 1711 VkBool32 sparseResidency4Samples; 1712 VkBool32 sparseResidency8Samples; 1713 VkBool32 sparseResidency16Samples; 1714 VkBool32 sparseResidencyAliased; 1715 VkBool32 variableMultisampleRate; 1716 VkBool32 inheritedQueries; 1717 } VkPhysicalDeviceFeatures; 1718 1719 typedef struct VkFormatProperties { 1720 VkFormatFeatureFlags linearTilingFeatures; 1721 VkFormatFeatureFlags optimalTilingFeatures; 1722 VkFormatFeatureFlags bufferFeatures; 1723 } VkFormatProperties; 1724 1725 typedef struct VkExtent3D { 1726 uint32_t width; 1727 uint32_t height; 1728 uint32_t depth; 1729 } VkExtent3D; 1730 1731 typedef struct VkImageFormatProperties { 1732 VkExtent3D maxExtent; 1733 uint32_t maxMipLevels; 1734 uint32_t maxArrayLayers; 1735 VkSampleCountFlags sampleCounts; 1736 VkDeviceSize maxResourceSize; 1737 } VkImageFormatProperties; 1738 1739 typedef struct VkPhysicalDeviceLimits { 1740 uint32_t maxImageDimension1D; 1741 uint32_t maxImageDimension2D; 1742 uint32_t maxImageDimension3D; 1743 uint32_t maxImageDimensionCube; 1744 uint32_t maxImageArrayLayers; 1745 uint32_t maxTexelBufferElements; 1746 uint32_t maxUniformBufferRange; 1747 uint32_t maxStorageBufferRange; 1748 uint32_t maxPushConstantsSize; 1749 uint32_t maxMemoryAllocationCount; 1750 uint32_t maxSamplerAllocationCount; 1751 VkDeviceSize bufferImageGranularity; 1752 VkDeviceSize sparseAddressSpaceSize; 1753 uint32_t maxBoundDescriptorSets; 1754 uint32_t maxPerStageDescriptorSamplers; 1755 uint32_t maxPerStageDescriptorUniformBuffers; 1756 uint32_t maxPerStageDescriptorStorageBuffers; 1757 uint32_t maxPerStageDescriptorSampledImages; 1758 uint32_t maxPerStageDescriptorStorageImages; 1759 uint32_t maxPerStageDescriptorInputAttachments; 1760 uint32_t maxPerStageResources; 1761 uint32_t maxDescriptorSetSamplers; 1762 uint32_t maxDescriptorSetUniformBuffers; 1763 uint32_t maxDescriptorSetUniformBuffersDynamic; 1764 uint32_t maxDescriptorSetStorageBuffers; 1765 uint32_t maxDescriptorSetStorageBuffersDynamic; 1766 uint32_t maxDescriptorSetSampledImages; 1767 uint32_t maxDescriptorSetStorageImages; 1768 uint32_t maxDescriptorSetInputAttachments; 1769 uint32_t maxVertexInputAttributes; 1770 uint32_t maxVertexInputBindings; 1771 uint32_t maxVertexInputAttributeOffset; 1772 uint32_t maxVertexInputBindingStride; 1773 uint32_t maxVertexOutputComponents; 1774 uint32_t maxTessellationGenerationLevel; 1775 uint32_t maxTessellationPatchSize; 1776 uint32_t maxTessellationControlPerVertexInputComponents; 1777 uint32_t maxTessellationControlPerVertexOutputComponents; 1778 uint32_t maxTessellationControlPerPatchOutputComponents; 1779 uint32_t maxTessellationControlTotalOutputComponents; 1780 uint32_t maxTessellationEvaluationInputComponents; 1781 uint32_t maxTessellationEvaluationOutputComponents; 1782 uint32_t maxGeometryShaderInvocations; 1783 uint32_t maxGeometryInputComponents; 1784 uint32_t maxGeometryOutputComponents; 1785 uint32_t maxGeometryOutputVertices; 1786 uint32_t maxGeometryTotalOutputComponents; 1787 uint32_t maxFragmentInputComponents; 1788 uint32_t maxFragmentOutputAttachments; 1789 uint32_t maxFragmentDualSrcAttachments; 1790 uint32_t maxFragmentCombinedOutputResources; 1791 uint32_t maxComputeSharedMemorySize; 1792 uint32_t maxComputeWorkGroupCount[3]; 1793 uint32_t maxComputeWorkGroupInvocations; 1794 uint32_t maxComputeWorkGroupSize[3]; 1795 uint32_t subPixelPrecisionBits; 1796 uint32_t subTexelPrecisionBits; 1797 uint32_t mipmapPrecisionBits; 1798 uint32_t maxDrawIndexedIndexValue; 1799 uint32_t maxDrawIndirectCount; 1800 float maxSamplerLodBias; 1801 float maxSamplerAnisotropy; 1802 uint32_t maxViewports; 1803 uint32_t maxViewportDimensions[2]; 1804 float viewportBoundsRange[2]; 1805 uint32_t viewportSubPixelBits; 1806 size_t minMemoryMapAlignment; 1807 VkDeviceSize minTexelBufferOffsetAlignment; 1808 VkDeviceSize minUniformBufferOffsetAlignment; 1809 VkDeviceSize minStorageBufferOffsetAlignment; 1810 int32_t minTexelOffset; 1811 uint32_t maxTexelOffset; 1812 int32_t minTexelGatherOffset; 1813 uint32_t maxTexelGatherOffset; 1814 float minInterpolationOffset; 1815 float maxInterpolationOffset; 1816 uint32_t subPixelInterpolationOffsetBits; 1817 uint32_t maxFramebufferWidth; 1818 uint32_t maxFramebufferHeight; 1819 uint32_t maxFramebufferLayers; 1820 VkSampleCountFlags framebufferColorSampleCounts; 1821 VkSampleCountFlags framebufferDepthSampleCounts; 1822 VkSampleCountFlags framebufferStencilSampleCounts; 1823 VkSampleCountFlags framebufferNoAttachmentsSampleCounts; 1824 uint32_t maxColorAttachments; 1825 VkSampleCountFlags sampledImageColorSampleCounts; 1826 VkSampleCountFlags sampledImageIntegerSampleCounts; 1827 VkSampleCountFlags sampledImageDepthSampleCounts; 1828 VkSampleCountFlags sampledImageStencilSampleCounts; 1829 VkSampleCountFlags storageImageSampleCounts; 1830 uint32_t maxSampleMaskWords; 1831 VkBool32 timestampComputeAndGraphics; 1832 float timestampPeriod; 1833 uint32_t maxClipDistances; 1834 uint32_t maxCullDistances; 1835 uint32_t maxCombinedClipAndCullDistances; 1836 uint32_t discreteQueuePriorities; 1837 float pointSizeRange[2]; 1838 float lineWidthRange[2]; 1839 float pointSizeGranularity; 1840 float lineWidthGranularity; 1841 VkBool32 strictLines; 1842 VkBool32 standardSampleLocations; 1843 VkDeviceSize optimalBufferCopyOffsetAlignment; 1844 VkDeviceSize optimalBufferCopyRowPitchAlignment; 1845 VkDeviceSize nonCoherentAtomSize; 1846 } VkPhysicalDeviceLimits; 1847 1848 typedef struct VkPhysicalDeviceSparseProperties { 1849 VkBool32 residencyStandard2DBlockShape; 1850 VkBool32 residencyStandard2DMultisampleBlockShape; 1851 VkBool32 residencyStandard3DBlockShape; 1852 VkBool32 residencyAlignedMipSize; 1853 VkBool32 residencyNonResidentStrict; 1854 } VkPhysicalDeviceSparseProperties; 1855 1856 typedef struct VkPhysicalDeviceProperties { 1857 uint32_t apiVersion; 1858 uint32_t driverVersion; 1859 uint32_t vendorID; 1860 uint32_t deviceID; 1861 VkPhysicalDeviceType deviceType; 1862 char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]; 1863 uint8_t pipelineCacheUUID[VK_UUID_SIZE]; 1864 VkPhysicalDeviceLimits limits; 1865 VkPhysicalDeviceSparseProperties sparseProperties; 1866 } VkPhysicalDeviceProperties; 1867 1868 typedef struct VkQueueFamilyProperties { 1869 VkQueueFlags queueFlags; 1870 uint32_t queueCount; 1871 uint32_t timestampValidBits; 1872 VkExtent3D minImageTransferGranularity; 1873 } VkQueueFamilyProperties; 1874 1875 typedef struct VkMemoryType { 1876 VkMemoryPropertyFlags propertyFlags; 1877 uint32_t heapIndex; 1878 } VkMemoryType; 1879 1880 typedef struct VkMemoryHeap { 1881 VkDeviceSize size; 1882 VkMemoryHeapFlags flags; 1883 } VkMemoryHeap; 1884 1885 typedef struct VkPhysicalDeviceMemoryProperties { 1886 uint32_t memoryTypeCount; 1887 VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES]; 1888 uint32_t memoryHeapCount; 1889 VkMemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS]; 1890 } VkPhysicalDeviceMemoryProperties; 1891 1892 typedef void (VKAPI_PTR *PFN_vkVoidFunction)(void); 1893 typedef struct VkDeviceQueueCreateInfo { 1894 VkStructureType sType; 1895 const void* pNext; 1896 VkDeviceQueueCreateFlags flags; 1897 uint32_t queueFamilyIndex; 1898 uint32_t queueCount; 1899 const float* pQueuePriorities; 1900 } VkDeviceQueueCreateInfo; 1901 1902 typedef struct VkDeviceCreateInfo { 1903 VkStructureType sType; 1904 const void* pNext; 1905 VkDeviceCreateFlags flags; 1906 uint32_t queueCreateInfoCount; 1907 const VkDeviceQueueCreateInfo* pQueueCreateInfos; 1908 uint32_t enabledLayerCount; 1909 const char* const* ppEnabledLayerNames; 1910 uint32_t enabledExtensionCount; 1911 const char* const* ppEnabledExtensionNames; 1912 const VkPhysicalDeviceFeatures* pEnabledFeatures; 1913 } VkDeviceCreateInfo; 1914 1915 typedef struct VkExtensionProperties { 1916 char extensionName[VK_MAX_EXTENSION_NAME_SIZE]; 1917 uint32_t specVersion; 1918 } VkExtensionProperties; 1919 1920 typedef struct VkLayerProperties { 1921 char layerName[VK_MAX_EXTENSION_NAME_SIZE]; 1922 uint32_t specVersion; 1923 uint32_t implementationVersion; 1924 char description[VK_MAX_DESCRIPTION_SIZE]; 1925 } VkLayerProperties; 1926 1927 typedef struct VkSubmitInfo { 1928 VkStructureType sType; 1929 const void* pNext; 1930 uint32_t waitSemaphoreCount; 1931 const VkSemaphore* pWaitSemaphores; 1932 const VkPipelineStageFlags* pWaitDstStageMask; 1933 uint32_t commandBufferCount; 1934 const VkCommandBuffer* pCommandBuffers; 1935 uint32_t signalSemaphoreCount; 1936 const VkSemaphore* pSignalSemaphores; 1937 } VkSubmitInfo; 1938 1939 typedef struct VkMemoryAllocateInfo { 1940 VkStructureType sType; 1941 const void* pNext; 1942 VkDeviceSize allocationSize; 1943 uint32_t memoryTypeIndex; 1944 } VkMemoryAllocateInfo; 1945 1946 typedef struct VkMappedMemoryRange { 1947 VkStructureType sType; 1948 const void* pNext; 1949 VkDeviceMemory memory; 1950 VkDeviceSize offset; 1951 VkDeviceSize size; 1952 } VkMappedMemoryRange; 1953 1954 typedef struct VkMemoryRequirements { 1955 VkDeviceSize size; 1956 VkDeviceSize alignment; 1957 uint32_t memoryTypeBits; 1958 } VkMemoryRequirements; 1959 1960 typedef struct VkSparseImageFormatProperties { 1961 VkImageAspectFlags aspectMask; 1962 VkExtent3D imageGranularity; 1963 VkSparseImageFormatFlags flags; 1964 } VkSparseImageFormatProperties; 1965 1966 typedef struct VkSparseImageMemoryRequirements { 1967 VkSparseImageFormatProperties formatProperties; 1968 uint32_t imageMipTailFirstLod; 1969 VkDeviceSize imageMipTailSize; 1970 VkDeviceSize imageMipTailOffset; 1971 VkDeviceSize imageMipTailStride; 1972 } VkSparseImageMemoryRequirements; 1973 1974 typedef struct VkSparseMemoryBind { 1975 VkDeviceSize resourceOffset; 1976 VkDeviceSize size; 1977 VkDeviceMemory memory; 1978 VkDeviceSize memoryOffset; 1979 VkSparseMemoryBindFlags flags; 1980 } VkSparseMemoryBind; 1981 1982 typedef struct VkSparseBufferMemoryBindInfo { 1983 VkBuffer buffer; 1984 uint32_t bindCount; 1985 const VkSparseMemoryBind* pBinds; 1986 } VkSparseBufferMemoryBindInfo; 1987 1988 typedef struct VkSparseImageOpaqueMemoryBindInfo { 1989 VkImage image; 1990 uint32_t bindCount; 1991 const VkSparseMemoryBind* pBinds; 1992 } VkSparseImageOpaqueMemoryBindInfo; 1993 1994 typedef struct VkImageSubresource { 1995 VkImageAspectFlags aspectMask; 1996 uint32_t mipLevel; 1997 uint32_t arrayLayer; 1998 } VkImageSubresource; 1999 2000 typedef struct VkOffset3D { 2001 int32_t x; 2002 int32_t y; 2003 int32_t z; 2004 } VkOffset3D; 2005 2006 typedef struct VkSparseImageMemoryBind { 2007 VkImageSubresource subresource; 2008 VkOffset3D offset; 2009 VkExtent3D extent; 2010 VkDeviceMemory memory; 2011 VkDeviceSize memoryOffset; 2012 VkSparseMemoryBindFlags flags; 2013 } VkSparseImageMemoryBind; 2014 2015 typedef struct VkSparseImageMemoryBindInfo { 2016 VkImage image; 2017 uint32_t bindCount; 2018 const VkSparseImageMemoryBind* pBinds; 2019 } VkSparseImageMemoryBindInfo; 2020 2021 typedef struct VkBindSparseInfo { 2022 VkStructureType sType; 2023 const void* pNext; 2024 uint32_t waitSemaphoreCount; 2025 const VkSemaphore* pWaitSemaphores; 2026 uint32_t bufferBindCount; 2027 const VkSparseBufferMemoryBindInfo* pBufferBinds; 2028 uint32_t imageOpaqueBindCount; 2029 const VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds; 2030 uint32_t imageBindCount; 2031 const VkSparseImageMemoryBindInfo* pImageBinds; 2032 uint32_t signalSemaphoreCount; 2033 const VkSemaphore* pSignalSemaphores; 2034 } VkBindSparseInfo; 2035 2036 typedef struct VkFenceCreateInfo { 2037 VkStructureType sType; 2038 const void* pNext; 2039 VkFenceCreateFlags flags; 2040 } VkFenceCreateInfo; 2041 2042 typedef struct VkSemaphoreCreateInfo { 2043 VkStructureType sType; 2044 const void* pNext; 2045 VkSemaphoreCreateFlags flags; 2046 } VkSemaphoreCreateInfo; 2047 2048 typedef struct VkEventCreateInfo { 2049 VkStructureType sType; 2050 const void* pNext; 2051 VkEventCreateFlags flags; 2052 } VkEventCreateInfo; 2053 2054 typedef struct VkQueryPoolCreateInfo { 2055 VkStructureType sType; 2056 const void* pNext; 2057 VkQueryPoolCreateFlags flags; 2058 VkQueryType queryType; 2059 uint32_t queryCount; 2060 VkQueryPipelineStatisticFlags pipelineStatistics; 2061 } VkQueryPoolCreateInfo; 2062 2063 typedef struct VkBufferCreateInfo { 2064 VkStructureType sType; 2065 const void* pNext; 2066 VkBufferCreateFlags flags; 2067 VkDeviceSize size; 2068 VkBufferUsageFlags usage; 2069 VkSharingMode sharingMode; 2070 uint32_t queueFamilyIndexCount; 2071 const uint32_t* pQueueFamilyIndices; 2072 } VkBufferCreateInfo; 2073 2074 typedef struct VkBufferViewCreateInfo { 2075 VkStructureType sType; 2076 const void* pNext; 2077 VkBufferViewCreateFlags flags; 2078 VkBuffer buffer; 2079 VkFormat format; 2080 VkDeviceSize offset; 2081 VkDeviceSize range; 2082 } VkBufferViewCreateInfo; 2083 2084 typedef struct VkImageCreateInfo { 2085 VkStructureType sType; 2086 const void* pNext; 2087 VkImageCreateFlags flags; 2088 VkImageType imageType; 2089 VkFormat format; 2090 VkExtent3D extent; 2091 uint32_t mipLevels; 2092 uint32_t arrayLayers; 2093 VkSampleCountFlagBits samples; 2094 VkImageTiling tiling; 2095 VkImageUsageFlags usage; 2096 VkSharingMode sharingMode; 2097 uint32_t queueFamilyIndexCount; 2098 const uint32_t* pQueueFamilyIndices; 2099 VkImageLayout initialLayout; 2100 } VkImageCreateInfo; 2101 2102 typedef struct VkSubresourceLayout { 2103 VkDeviceSize offset; 2104 VkDeviceSize size; 2105 VkDeviceSize rowPitch; 2106 VkDeviceSize arrayPitch; 2107 VkDeviceSize depthPitch; 2108 } VkSubresourceLayout; 2109 2110 typedef struct VkComponentMapping { 2111 VkComponentSwizzle r; 2112 VkComponentSwizzle g; 2113 VkComponentSwizzle b; 2114 VkComponentSwizzle a; 2115 } VkComponentMapping; 2116 2117 typedef struct VkImageSubresourceRange { 2118 VkImageAspectFlags aspectMask; 2119 uint32_t baseMipLevel; 2120 uint32_t levelCount; 2121 uint32_t baseArrayLayer; 2122 uint32_t layerCount; 2123 } VkImageSubresourceRange; 2124 2125 typedef struct VkImageViewCreateInfo { 2126 VkStructureType sType; 2127 const void* pNext; 2128 VkImageViewCreateFlags flags; 2129 VkImage image; 2130 VkImageViewType viewType; 2131 VkFormat format; 2132 VkComponentMapping components; 2133 VkImageSubresourceRange subresourceRange; 2134 } VkImageViewCreateInfo; 2135 2136 typedef struct VkShaderModuleCreateInfo { 2137 VkStructureType sType; 2138 const void* pNext; 2139 VkShaderModuleCreateFlags flags; 2140 size_t codeSize; 2141 const uint32_t* pCode; 2142 } VkShaderModuleCreateInfo; 2143 2144 typedef struct VkPipelineCacheCreateInfo { 2145 VkStructureType sType; 2146 const void* pNext; 2147 VkPipelineCacheCreateFlags flags; 2148 size_t initialDataSize; 2149 const void* pInitialData; 2150 } VkPipelineCacheCreateInfo; 2151 2152 typedef struct VkSpecializationMapEntry { 2153 uint32_t constantID; 2154 uint32_t offset; 2155 size_t size; 2156 } VkSpecializationMapEntry; 2157 2158 typedef struct VkSpecializationInfo { 2159 uint32_t mapEntryCount; 2160 const VkSpecializationMapEntry* pMapEntries; 2161 size_t dataSize; 2162 const void* pData; 2163 } VkSpecializationInfo; 2164 2165 typedef struct VkPipelineShaderStageCreateInfo { 2166 VkStructureType sType; 2167 const void* pNext; 2168 VkPipelineShaderStageCreateFlags flags; 2169 VkShaderStageFlagBits stage; 2170 VkShaderModule module; 2171 const char* pName; 2172 const VkSpecializationInfo* pSpecializationInfo; 2173 } VkPipelineShaderStageCreateInfo; 2174 2175 typedef struct VkVertexInputBindingDescription { 2176 uint32_t binding; 2177 uint32_t stride; 2178 VkVertexInputRate inputRate; 2179 } VkVertexInputBindingDescription; 2180 2181 typedef struct VkVertexInputAttributeDescription { 2182 uint32_t location; 2183 uint32_t binding; 2184 VkFormat format; 2185 uint32_t offset; 2186 } VkVertexInputAttributeDescription; 2187 2188 typedef struct VkPipelineVertexInputStateCreateInfo { 2189 VkStructureType sType; 2190 const void* pNext; 2191 VkPipelineVertexInputStateCreateFlags flags; 2192 uint32_t vertexBindingDescriptionCount; 2193 const VkVertexInputBindingDescription* pVertexBindingDescriptions; 2194 uint32_t vertexAttributeDescriptionCount; 2195 const VkVertexInputAttributeDescription* pVertexAttributeDescriptions; 2196 } VkPipelineVertexInputStateCreateInfo; 2197 2198 typedef struct VkPipelineInputAssemblyStateCreateInfo { 2199 VkStructureType sType; 2200 const void* pNext; 2201 VkPipelineInputAssemblyStateCreateFlags flags; 2202 VkPrimitiveTopology topology; 2203 VkBool32 primitiveRestartEnable; 2204 } VkPipelineInputAssemblyStateCreateInfo; 2205 2206 typedef struct VkPipelineTessellationStateCreateInfo { 2207 VkStructureType sType; 2208 const void* pNext; 2209 VkPipelineTessellationStateCreateFlags flags; 2210 uint32_t patchControlPoints; 2211 } VkPipelineTessellationStateCreateInfo; 2212 2213 typedef struct VkViewport { 2214 float x; 2215 float y; 2216 float width; 2217 float height; 2218 float minDepth; 2219 float maxDepth; 2220 } VkViewport; 2221 2222 typedef struct VkOffset2D { 2223 int32_t x; 2224 int32_t y; 2225 } VkOffset2D; 2226 2227 typedef struct VkExtent2D { 2228 uint32_t width; 2229 uint32_t height; 2230 } VkExtent2D; 2231 2232 typedef struct VkRect2D { 2233 VkOffset2D offset; 2234 VkExtent2D extent; 2235 } VkRect2D; 2236 2237 typedef struct VkPipelineViewportStateCreateInfo { 2238 VkStructureType sType; 2239 const void* pNext; 2240 VkPipelineViewportStateCreateFlags flags; 2241 uint32_t viewportCount; 2242 const VkViewport* pViewports; 2243 uint32_t scissorCount; 2244 const VkRect2D* pScissors; 2245 } VkPipelineViewportStateCreateInfo; 2246 2247 typedef struct VkPipelineRasterizationStateCreateInfo { 2248 VkStructureType sType; 2249 const void* pNext; 2250 VkPipelineRasterizationStateCreateFlags flags; 2251 VkBool32 depthClampEnable; 2252 VkBool32 rasterizerDiscardEnable; 2253 VkPolygonMode polygonMode; 2254 VkCullModeFlags cullMode; 2255 VkFrontFace frontFace; 2256 VkBool32 depthBiasEnable; 2257 float depthBiasConstantFactor; 2258 float depthBiasClamp; 2259 float depthBiasSlopeFactor; 2260 float lineWidth; 2261 } VkPipelineRasterizationStateCreateInfo; 2262 2263 typedef struct VkPipelineMultisampleStateCreateInfo { 2264 VkStructureType sType; 2265 const void* pNext; 2266 VkPipelineMultisampleStateCreateFlags flags; 2267 VkSampleCountFlagBits rasterizationSamples; 2268 VkBool32 sampleShadingEnable; 2269 float minSampleShading; 2270 const VkSampleMask* pSampleMask; 2271 VkBool32 alphaToCoverageEnable; 2272 VkBool32 alphaToOneEnable; 2273 } VkPipelineMultisampleStateCreateInfo; 2274 2275 typedef struct VkStencilOpState { 2276 VkStencilOp failOp; 2277 VkStencilOp passOp; 2278 VkStencilOp depthFailOp; 2279 VkCompareOp compareOp; 2280 uint32_t compareMask; 2281 uint32_t writeMask; 2282 uint32_t reference; 2283 } VkStencilOpState; 2284 2285 typedef struct VkPipelineDepthStencilStateCreateInfo { 2286 VkStructureType sType; 2287 const void* pNext; 2288 VkPipelineDepthStencilStateCreateFlags flags; 2289 VkBool32 depthTestEnable; 2290 VkBool32 depthWriteEnable; 2291 VkCompareOp depthCompareOp; 2292 VkBool32 depthBoundsTestEnable; 2293 VkBool32 stencilTestEnable; 2294 VkStencilOpState front; 2295 VkStencilOpState back; 2296 float minDepthBounds; 2297 float maxDepthBounds; 2298 } VkPipelineDepthStencilStateCreateInfo; 2299 2300 typedef struct VkPipelineColorBlendAttachmentState { 2301 VkBool32 blendEnable; 2302 VkBlendFactor srcColorBlendFactor; 2303 VkBlendFactor dstColorBlendFactor; 2304 VkBlendOp colorBlendOp; 2305 VkBlendFactor srcAlphaBlendFactor; 2306 VkBlendFactor dstAlphaBlendFactor; 2307 VkBlendOp alphaBlendOp; 2308 VkColorComponentFlags colorWriteMask; 2309 } VkPipelineColorBlendAttachmentState; 2310 2311 typedef struct VkPipelineColorBlendStateCreateInfo { 2312 VkStructureType sType; 2313 const void* pNext; 2314 VkPipelineColorBlendStateCreateFlags flags; 2315 VkBool32 logicOpEnable; 2316 VkLogicOp logicOp; 2317 uint32_t attachmentCount; 2318 const VkPipelineColorBlendAttachmentState* pAttachments; 2319 float blendConstants[4]; 2320 } VkPipelineColorBlendStateCreateInfo; 2321 2322 typedef struct VkPipelineDynamicStateCreateInfo { 2323 VkStructureType sType; 2324 const void* pNext; 2325 VkPipelineDynamicStateCreateFlags flags; 2326 uint32_t dynamicStateCount; 2327 const VkDynamicState* pDynamicStates; 2328 } VkPipelineDynamicStateCreateInfo; 2329 2330 typedef struct VkGraphicsPipelineCreateInfo { 2331 VkStructureType sType; 2332 const void* pNext; 2333 VkPipelineCreateFlags flags; 2334 uint32_t stageCount; 2335 const VkPipelineShaderStageCreateInfo* pStages; 2336 const VkPipelineVertexInputStateCreateInfo* pVertexInputState; 2337 const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState; 2338 const VkPipelineTessellationStateCreateInfo* pTessellationState; 2339 const VkPipelineViewportStateCreateInfo* pViewportState; 2340 const VkPipelineRasterizationStateCreateInfo* pRasterizationState; 2341 const VkPipelineMultisampleStateCreateInfo* pMultisampleState; 2342 const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState; 2343 const VkPipelineColorBlendStateCreateInfo* pColorBlendState; 2344 const VkPipelineDynamicStateCreateInfo* pDynamicState; 2345 VkPipelineLayout layout; 2346 VkRenderPass renderPass; 2347 uint32_t subpass; 2348 VkPipeline basePipelineHandle; 2349 int32_t basePipelineIndex; 2350 } VkGraphicsPipelineCreateInfo; 2351 2352 typedef struct VkComputePipelineCreateInfo { 2353 VkStructureType sType; 2354 const void* pNext; 2355 VkPipelineCreateFlags flags; 2356 VkPipelineShaderStageCreateInfo stage; 2357 VkPipelineLayout layout; 2358 VkPipeline basePipelineHandle; 2359 int32_t basePipelineIndex; 2360 } VkComputePipelineCreateInfo; 2361 2362 typedef struct VkPushConstantRange { 2363 VkShaderStageFlags stageFlags; 2364 uint32_t offset; 2365 uint32_t size; 2366 } VkPushConstantRange; 2367 2368 typedef struct VkPipelineLayoutCreateInfo { 2369 VkStructureType sType; 2370 const void* pNext; 2371 VkPipelineLayoutCreateFlags flags; 2372 uint32_t setLayoutCount; 2373 const VkDescriptorSetLayout* pSetLayouts; 2374 uint32_t pushConstantRangeCount; 2375 const VkPushConstantRange* pPushConstantRanges; 2376 } VkPipelineLayoutCreateInfo; 2377 2378 typedef struct VkSamplerCreateInfo { 2379 VkStructureType sType; 2380 const void* pNext; 2381 VkSamplerCreateFlags flags; 2382 VkFilter magFilter; 2383 VkFilter minFilter; 2384 VkSamplerMipmapMode mipmapMode; 2385 VkSamplerAddressMode addressModeU; 2386 VkSamplerAddressMode addressModeV; 2387 VkSamplerAddressMode addressModeW; 2388 float mipLodBias; 2389 VkBool32 anisotropyEnable; 2390 float maxAnisotropy; 2391 VkBool32 compareEnable; 2392 VkCompareOp compareOp; 2393 float minLod; 2394 float maxLod; 2395 VkBorderColor borderColor; 2396 VkBool32 unnormalizedCoordinates; 2397 } VkSamplerCreateInfo; 2398 2399 typedef struct VkDescriptorSetLayoutBinding { 2400 uint32_t binding; 2401 VkDescriptorType descriptorType; 2402 uint32_t descriptorCount; 2403 VkShaderStageFlags stageFlags; 2404 const VkSampler* pImmutableSamplers; 2405 } VkDescriptorSetLayoutBinding; 2406 2407 typedef struct VkDescriptorSetLayoutCreateInfo { 2408 VkStructureType sType; 2409 const void* pNext; 2410 VkDescriptorSetLayoutCreateFlags flags; 2411 uint32_t bindingCount; 2412 const VkDescriptorSetLayoutBinding* pBindings; 2413 } VkDescriptorSetLayoutCreateInfo; 2414 2415 typedef struct VkDescriptorPoolSize { 2416 VkDescriptorType type; 2417 uint32_t descriptorCount; 2418 } VkDescriptorPoolSize; 2419 2420 typedef struct VkDescriptorPoolCreateInfo { 2421 VkStructureType sType; 2422 const void* pNext; 2423 VkDescriptorPoolCreateFlags flags; 2424 uint32_t maxSets; 2425 uint32_t poolSizeCount; 2426 const VkDescriptorPoolSize* pPoolSizes; 2427 } VkDescriptorPoolCreateInfo; 2428 2429 typedef struct VkDescriptorSetAllocateInfo { 2430 VkStructureType sType; 2431 const void* pNext; 2432 VkDescriptorPool descriptorPool; 2433 uint32_t descriptorSetCount; 2434 const VkDescriptorSetLayout* pSetLayouts; 2435 } VkDescriptorSetAllocateInfo; 2436 2437 typedef struct VkDescriptorImageInfo { 2438 VkSampler sampler; 2439 VkImageView imageView; 2440 VkImageLayout imageLayout; 2441 } VkDescriptorImageInfo; 2442 2443 typedef struct VkDescriptorBufferInfo { 2444 VkBuffer buffer; 2445 VkDeviceSize offset; 2446 VkDeviceSize range; 2447 } VkDescriptorBufferInfo; 2448 2449 typedef struct VkWriteDescriptorSet { 2450 VkStructureType sType; 2451 const void* pNext; 2452 VkDescriptorSet dstSet; 2453 uint32_t dstBinding; 2454 uint32_t dstArrayElement; 2455 uint32_t descriptorCount; 2456 VkDescriptorType descriptorType; 2457 const VkDescriptorImageInfo* pImageInfo; 2458 const VkDescriptorBufferInfo* pBufferInfo; 2459 const VkBufferView* pTexelBufferView; 2460 } VkWriteDescriptorSet; 2461 2462 typedef struct VkCopyDescriptorSet { 2463 VkStructureType sType; 2464 const void* pNext; 2465 VkDescriptorSet srcSet; 2466 uint32_t srcBinding; 2467 uint32_t srcArrayElement; 2468 VkDescriptorSet dstSet; 2469 uint32_t dstBinding; 2470 uint32_t dstArrayElement; 2471 uint32_t descriptorCount; 2472 } VkCopyDescriptorSet; 2473 2474 typedef struct VkFramebufferCreateInfo { 2475 VkStructureType sType; 2476 const void* pNext; 2477 VkFramebufferCreateFlags flags; 2478 VkRenderPass renderPass; 2479 uint32_t attachmentCount; 2480 const VkImageView* pAttachments; 2481 uint32_t width; 2482 uint32_t height; 2483 uint32_t layers; 2484 } VkFramebufferCreateInfo; 2485 2486 typedef struct VkAttachmentDescription { 2487 VkAttachmentDescriptionFlags flags; 2488 VkFormat format; 2489 VkSampleCountFlagBits samples; 2490 VkAttachmentLoadOp loadOp; 2491 VkAttachmentStoreOp storeOp; 2492 VkAttachmentLoadOp stencilLoadOp; 2493 VkAttachmentStoreOp stencilStoreOp; 2494 VkImageLayout initialLayout; 2495 VkImageLayout finalLayout; 2496 } VkAttachmentDescription; 2497 2498 typedef struct VkAttachmentReference { 2499 uint32_t attachment; 2500 VkImageLayout layout; 2501 } VkAttachmentReference; 2502 2503 typedef struct VkSubpassDescription { 2504 VkSubpassDescriptionFlags flags; 2505 VkPipelineBindPoint pipelineBindPoint; 2506 uint32_t inputAttachmentCount; 2507 const VkAttachmentReference* pInputAttachments; 2508 uint32_t colorAttachmentCount; 2509 const VkAttachmentReference* pColorAttachments; 2510 const VkAttachmentReference* pResolveAttachments; 2511 const VkAttachmentReference* pDepthStencilAttachment; 2512 uint32_t preserveAttachmentCount; 2513 const uint32_t* pPreserveAttachments; 2514 } VkSubpassDescription; 2515 2516 typedef struct VkSubpassDependency { 2517 uint32_t srcSubpass; 2518 uint32_t dstSubpass; 2519 VkPipelineStageFlags srcStageMask; 2520 VkPipelineStageFlags dstStageMask; 2521 VkAccessFlags srcAccessMask; 2522 VkAccessFlags dstAccessMask; 2523 VkDependencyFlags dependencyFlags; 2524 } VkSubpassDependency; 2525 2526 typedef struct VkRenderPassCreateInfo { 2527 VkStructureType sType; 2528 const void* pNext; 2529 VkRenderPassCreateFlags flags; 2530 uint32_t attachmentCount; 2531 const VkAttachmentDescription* pAttachments; 2532 uint32_t subpassCount; 2533 const VkSubpassDescription* pSubpasses; 2534 uint32_t dependencyCount; 2535 const VkSubpassDependency* pDependencies; 2536 } VkRenderPassCreateInfo; 2537 2538 typedef struct VkCommandPoolCreateInfo { 2539 VkStructureType sType; 2540 const void* pNext; 2541 VkCommandPoolCreateFlags flags; 2542 uint32_t queueFamilyIndex; 2543 } VkCommandPoolCreateInfo; 2544 2545 typedef struct VkCommandBufferAllocateInfo { 2546 VkStructureType sType; 2547 const void* pNext; 2548 VkCommandPool commandPool; 2549 VkCommandBufferLevel level; 2550 uint32_t commandBufferCount; 2551 } VkCommandBufferAllocateInfo; 2552 2553 typedef struct VkCommandBufferInheritanceInfo { 2554 VkStructureType sType; 2555 const void* pNext; 2556 VkRenderPass renderPass; 2557 uint32_t subpass; 2558 VkFramebuffer framebuffer; 2559 VkBool32 occlusionQueryEnable; 2560 VkQueryControlFlags queryFlags; 2561 VkQueryPipelineStatisticFlags pipelineStatistics; 2562 } VkCommandBufferInheritanceInfo; 2563 2564 typedef struct VkCommandBufferBeginInfo { 2565 VkStructureType sType; 2566 const void* pNext; 2567 VkCommandBufferUsageFlags flags; 2568 const VkCommandBufferInheritanceInfo* pInheritanceInfo; 2569 } VkCommandBufferBeginInfo; 2570 2571 typedef struct VkBufferCopy { 2572 VkDeviceSize srcOffset; 2573 VkDeviceSize dstOffset; 2574 VkDeviceSize size; 2575 } VkBufferCopy; 2576 2577 typedef struct VkImageSubresourceLayers { 2578 VkImageAspectFlags aspectMask; 2579 uint32_t mipLevel; 2580 uint32_t baseArrayLayer; 2581 uint32_t layerCount; 2582 } VkImageSubresourceLayers; 2583 2584 typedef struct VkImageCopy { 2585 VkImageSubresourceLayers srcSubresource; 2586 VkOffset3D srcOffset; 2587 VkImageSubresourceLayers dstSubresource; 2588 VkOffset3D dstOffset; 2589 VkExtent3D extent; 2590 } VkImageCopy; 2591 2592 typedef struct VkImageBlit { 2593 VkImageSubresourceLayers srcSubresource; 2594 VkOffset3D srcOffsets[2]; 2595 VkImageSubresourceLayers dstSubresource; 2596 VkOffset3D dstOffsets[2]; 2597 } VkImageBlit; 2598 2599 typedef struct VkBufferImageCopy { 2600 VkDeviceSize bufferOffset; 2601 uint32_t bufferRowLength; 2602 uint32_t bufferImageHeight; 2603 VkImageSubresourceLayers imageSubresource; 2604 VkOffset3D imageOffset; 2605 VkExtent3D imageExtent; 2606 } VkBufferImageCopy; 2607 2608 typedef union VkClearColorValue { 2609 float float32[4]; 2610 int32_t int32[4]; 2611 uint32_t uint32[4]; 2612 } VkClearColorValue; 2613 2614 typedef struct VkClearDepthStencilValue { 2615 float depth; 2616 uint32_t stencil; 2617 } VkClearDepthStencilValue; 2618 2619 typedef union VkClearValue { 2620 VkClearColorValue color; 2621 VkClearDepthStencilValue depthStencil; 2622 } VkClearValue; 2623 2624 typedef struct VkClearAttachment { 2625 VkImageAspectFlags aspectMask; 2626 uint32_t colorAttachment; 2627 VkClearValue clearValue; 2628 } VkClearAttachment; 2629 2630 typedef struct VkClearRect { 2631 VkRect2D rect; 2632 uint32_t baseArrayLayer; 2633 uint32_t layerCount; 2634 } VkClearRect; 2635 2636 typedef struct VkImageResolve { 2637 VkImageSubresourceLayers srcSubresource; 2638 VkOffset3D srcOffset; 2639 VkImageSubresourceLayers dstSubresource; 2640 VkOffset3D dstOffset; 2641 VkExtent3D extent; 2642 } VkImageResolve; 2643 2644 typedef struct VkMemoryBarrier { 2645 VkStructureType sType; 2646 const void* pNext; 2647 VkAccessFlags srcAccessMask; 2648 VkAccessFlags dstAccessMask; 2649 } VkMemoryBarrier; 2650 2651 typedef struct VkBufferMemoryBarrier { 2652 VkStructureType sType; 2653 const void* pNext; 2654 VkAccessFlags srcAccessMask; 2655 VkAccessFlags dstAccessMask; 2656 uint32_t srcQueueFamilyIndex; 2657 uint32_t dstQueueFamilyIndex; 2658 VkBuffer buffer; 2659 VkDeviceSize offset; 2660 VkDeviceSize size; 2661 } VkBufferMemoryBarrier; 2662 2663 typedef struct VkImageMemoryBarrier { 2664 VkStructureType sType; 2665 const void* pNext; 2666 VkAccessFlags srcAccessMask; 2667 VkAccessFlags dstAccessMask; 2668 VkImageLayout oldLayout; 2669 VkImageLayout newLayout; 2670 uint32_t srcQueueFamilyIndex; 2671 uint32_t dstQueueFamilyIndex; 2672 VkImage image; 2673 VkImageSubresourceRange subresourceRange; 2674 } VkImageMemoryBarrier; 2675 2676 typedef struct VkRenderPassBeginInfo { 2677 VkStructureType sType; 2678 const void* pNext; 2679 VkRenderPass renderPass; 2680 VkFramebuffer framebuffer; 2681 VkRect2D renderArea; 2682 uint32_t clearValueCount; 2683 const VkClearValue* pClearValues; 2684 } VkRenderPassBeginInfo; 2685 2686 typedef struct VkDispatchIndirectCommand { 2687 uint32_t x; 2688 uint32_t y; 2689 uint32_t z; 2690 } VkDispatchIndirectCommand; 2691 2692 typedef struct VkDrawIndexedIndirectCommand { 2693 uint32_t indexCount; 2694 uint32_t instanceCount; 2695 uint32_t firstIndex; 2696 int32_t vertexOffset; 2697 uint32_t firstInstance; 2698 } VkDrawIndexedIndirectCommand; 2699 2700 typedef struct VkDrawIndirectCommand { 2701 uint32_t vertexCount; 2702 uint32_t instanceCount; 2703 uint32_t firstVertex; 2704 uint32_t firstInstance; 2705 } VkDrawIndirectCommand; 2706 2707 2708 typedef VkResult (VKAPI_PTR *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance); 2709 typedef void (VKAPI_PTR *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks* pAllocator); 2710 typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); 2711 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures); 2712 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties); 2713 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties); 2714 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties); 2715 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties); 2716 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties); 2717 typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName); 2718 typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName); 2719 typedef VkResult (VKAPI_PTR *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice); 2720 typedef void (VKAPI_PTR *PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks* pAllocator); 2721 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); 2722 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); 2723 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties); 2724 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties); 2725 typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue); 2726 typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence); 2727 typedef VkResult (VKAPI_PTR *PFN_vkQueueWaitIdle)(VkQueue queue); 2728 typedef VkResult (VKAPI_PTR *PFN_vkDeviceWaitIdle)(VkDevice device); 2729 typedef VkResult (VKAPI_PTR *PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory); 2730 typedef void (VKAPI_PTR *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator); 2731 typedef VkResult (VKAPI_PTR *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData); 2732 typedef void (VKAPI_PTR *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory); 2733 typedef VkResult (VKAPI_PTR *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); 2734 typedef VkResult (VKAPI_PTR *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); 2735 typedef void (VKAPI_PTR *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes); 2736 typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset); 2737 typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset); 2738 typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements); 2739 typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements); 2740 typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements); 2741 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties); 2742 typedef VkResult (VKAPI_PTR *PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence); 2743 typedef VkResult (VKAPI_PTR *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); 2744 typedef void (VKAPI_PTR *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator); 2745 typedef VkResult (VKAPI_PTR *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences); 2746 typedef VkResult (VKAPI_PTR *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence); 2747 typedef VkResult (VKAPI_PTR *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout); 2748 typedef VkResult (VKAPI_PTR *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore); 2749 typedef void (VKAPI_PTR *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator); 2750 typedef VkResult (VKAPI_PTR *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent); 2751 typedef void (VKAPI_PTR *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator); 2752 typedef VkResult (VKAPI_PTR *PFN_vkGetEventStatus)(VkDevice device, VkEvent event); 2753 typedef VkResult (VKAPI_PTR *PFN_vkSetEvent)(VkDevice device, VkEvent event); 2754 typedef VkResult (VKAPI_PTR *PFN_vkResetEvent)(VkDevice device, VkEvent event); 2755 typedef VkResult (VKAPI_PTR *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool); 2756 typedef void (VKAPI_PTR *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator); 2757 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); 2758 typedef VkResult (VKAPI_PTR *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer); 2759 typedef void (VKAPI_PTR *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator); 2760 typedef VkResult (VKAPI_PTR *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView); 2761 typedef void (VKAPI_PTR *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator); 2762 typedef VkResult (VKAPI_PTR *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage); 2763 typedef void (VKAPI_PTR *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator); 2764 typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout); 2765 typedef VkResult (VKAPI_PTR *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView); 2766 typedef void (VKAPI_PTR *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator); 2767 typedef VkResult (VKAPI_PTR *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule); 2768 typedef void (VKAPI_PTR *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator); 2769 typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache); 2770 typedef void (VKAPI_PTR *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator); 2771 typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData); 2772 typedef VkResult (VKAPI_PTR *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches); 2773 typedef VkResult (VKAPI_PTR *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); 2774 typedef VkResult (VKAPI_PTR *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); 2775 typedef void (VKAPI_PTR *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator); 2776 typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout); 2777 typedef void (VKAPI_PTR *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator); 2778 typedef VkResult (VKAPI_PTR *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler); 2779 typedef void (VKAPI_PTR *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator); 2780 typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout); 2781 typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator); 2782 typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool); 2783 typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator); 2784 typedef VkResult (VKAPI_PTR *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags); 2785 typedef VkResult (VKAPI_PTR *PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets); 2786 typedef VkResult (VKAPI_PTR *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets); 2787 typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies); 2788 typedef VkResult (VKAPI_PTR *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer); 2789 typedef void (VKAPI_PTR *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator); 2790 typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); 2791 typedef void (VKAPI_PTR *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator); 2792 typedef void (VKAPI_PTR *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity); 2793 typedef VkResult (VKAPI_PTR *PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool); 2794 typedef void (VKAPI_PTR *PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator); 2795 typedef VkResult (VKAPI_PTR *PFN_vkResetCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags); 2796 typedef VkResult (VKAPI_PTR *PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers); 2797 typedef void (VKAPI_PTR *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); 2798 typedef VkResult (VKAPI_PTR *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo); 2799 typedef VkResult (VKAPI_PTR *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer); 2800 typedef VkResult (VKAPI_PTR *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags); 2801 typedef void (VKAPI_PTR *PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); 2802 typedef void (VKAPI_PTR *PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports); 2803 typedef void (VKAPI_PTR *PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors); 2804 typedef void (VKAPI_PTR *PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth); 2805 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor); 2806 typedef void (VKAPI_PTR *PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4]); 2807 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds); 2808 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask); 2809 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask); 2810 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference); 2811 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); 2812 typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); 2813 typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets); 2814 typedef void (VKAPI_PTR *PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance); 2815 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance); 2816 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); 2817 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); 2818 typedef void (VKAPI_PTR *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); 2819 typedef void (VKAPI_PTR *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); 2820 typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions); 2821 typedef void (VKAPI_PTR *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions); 2822 typedef void (VKAPI_PTR *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter); 2823 typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions); 2824 typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions); 2825 typedef void (VKAPI_PTR *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData); 2826 typedef void (VKAPI_PTR *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data); 2827 typedef void (VKAPI_PTR *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); 2828 typedef void (VKAPI_PTR *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); 2829 typedef void (VKAPI_PTR *PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects); 2830 typedef void (VKAPI_PTR *PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions); 2831 typedef void (VKAPI_PTR *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); 2832 typedef void (VKAPI_PTR *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); 2833 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); 2834 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); 2835 typedef void (VKAPI_PTR *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags); 2836 typedef void (VKAPI_PTR *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query); 2837 typedef void (VKAPI_PTR *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); 2838 typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query); 2839 typedef void (VKAPI_PTR *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags); 2840 typedef void (VKAPI_PTR *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues); 2841 typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents); 2842 typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkSubpassContents contents); 2843 typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer); 2844 typedef void (VKAPI_PTR *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); 2845 2846 #ifndef VK_NO_PROTOTYPES 2847 VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance( 2848 const VkInstanceCreateInfo* pCreateInfo, 2849 const VkAllocationCallbacks* pAllocator, 2850 VkInstance* pInstance); 2851 2852 VKAPI_ATTR void VKAPI_CALL vkDestroyInstance( 2853 VkInstance instance, 2854 const VkAllocationCallbacks* pAllocator); 2855 2856 VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices( 2857 VkInstance instance, 2858 uint32_t* pPhysicalDeviceCount, 2859 VkPhysicalDevice* pPhysicalDevices); 2860 2861 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures( 2862 VkPhysicalDevice physicalDevice, 2863 VkPhysicalDeviceFeatures* pFeatures); 2864 2865 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties( 2866 VkPhysicalDevice physicalDevice, 2867 VkFormat format, 2868 VkFormatProperties* pFormatProperties); 2869 2870 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties( 2871 VkPhysicalDevice physicalDevice, 2872 VkFormat format, 2873 VkImageType type, 2874 VkImageTiling tiling, 2875 VkImageUsageFlags usage, 2876 VkImageCreateFlags flags, 2877 VkImageFormatProperties* pImageFormatProperties); 2878 2879 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties( 2880 VkPhysicalDevice physicalDevice, 2881 VkPhysicalDeviceProperties* pProperties); 2882 2883 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties( 2884 VkPhysicalDevice physicalDevice, 2885 uint32_t* pQueueFamilyPropertyCount, 2886 VkQueueFamilyProperties* pQueueFamilyProperties); 2887 2888 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties( 2889 VkPhysicalDevice physicalDevice, 2890 VkPhysicalDeviceMemoryProperties* pMemoryProperties); 2891 2892 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr( 2893 VkInstance instance, 2894 const char* pName); 2895 2896 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr( 2897 VkDevice device, 2898 const char* pName); 2899 2900 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice( 2901 VkPhysicalDevice physicalDevice, 2902 const VkDeviceCreateInfo* pCreateInfo, 2903 const VkAllocationCallbacks* pAllocator, 2904 VkDevice* pDevice); 2905 2906 VKAPI_ATTR void VKAPI_CALL vkDestroyDevice( 2907 VkDevice device, 2908 const VkAllocationCallbacks* pAllocator); 2909 2910 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties( 2911 const char* pLayerName, 2912 uint32_t* pPropertyCount, 2913 VkExtensionProperties* pProperties); 2914 2915 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties( 2916 VkPhysicalDevice physicalDevice, 2917 const char* pLayerName, 2918 uint32_t* pPropertyCount, 2919 VkExtensionProperties* pProperties); 2920 2921 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties( 2922 uint32_t* pPropertyCount, 2923 VkLayerProperties* pProperties); 2924 2925 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties( 2926 VkPhysicalDevice physicalDevice, 2927 uint32_t* pPropertyCount, 2928 VkLayerProperties* pProperties); 2929 2930 VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue( 2931 VkDevice device, 2932 uint32_t queueFamilyIndex, 2933 uint32_t queueIndex, 2934 VkQueue* pQueue); 2935 2936 VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit( 2937 VkQueue queue, 2938 uint32_t submitCount, 2939 const VkSubmitInfo* pSubmits, 2940 VkFence fence); 2941 2942 VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle( 2943 VkQueue queue); 2944 2945 VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle( 2946 VkDevice device); 2947 2948 VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory( 2949 VkDevice device, 2950 const VkMemoryAllocateInfo* pAllocateInfo, 2951 const VkAllocationCallbacks* pAllocator, 2952 VkDeviceMemory* pMemory); 2953 2954 VKAPI_ATTR void VKAPI_CALL vkFreeMemory( 2955 VkDevice device, 2956 VkDeviceMemory memory, 2957 const VkAllocationCallbacks* pAllocator); 2958 2959 VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory( 2960 VkDevice device, 2961 VkDeviceMemory memory, 2962 VkDeviceSize offset, 2963 VkDeviceSize size, 2964 VkMemoryMapFlags flags, 2965 void** ppData); 2966 2967 VKAPI_ATTR void VKAPI_CALL vkUnmapMemory( 2968 VkDevice device, 2969 VkDeviceMemory memory); 2970 2971 VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges( 2972 VkDevice device, 2973 uint32_t memoryRangeCount, 2974 const VkMappedMemoryRange* pMemoryRanges); 2975 2976 VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges( 2977 VkDevice device, 2978 uint32_t memoryRangeCount, 2979 const VkMappedMemoryRange* pMemoryRanges); 2980 2981 VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment( 2982 VkDevice device, 2983 VkDeviceMemory memory, 2984 VkDeviceSize* pCommittedMemoryInBytes); 2985 2986 VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory( 2987 VkDevice device, 2988 VkBuffer buffer, 2989 VkDeviceMemory memory, 2990 VkDeviceSize memoryOffset); 2991 2992 VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory( 2993 VkDevice device, 2994 VkImage image, 2995 VkDeviceMemory memory, 2996 VkDeviceSize memoryOffset); 2997 2998 VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements( 2999 VkDevice device, 3000 VkBuffer buffer, 3001 VkMemoryRequirements* pMemoryRequirements); 3002 3003 VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements( 3004 VkDevice device, 3005 VkImage image, 3006 VkMemoryRequirements* pMemoryRequirements); 3007 3008 VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements( 3009 VkDevice device, 3010 VkImage image, 3011 uint32_t* pSparseMemoryRequirementCount, 3012 VkSparseImageMemoryRequirements* pSparseMemoryRequirements); 3013 3014 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties( 3015 VkPhysicalDevice physicalDevice, 3016 VkFormat format, 3017 VkImageType type, 3018 VkSampleCountFlagBits samples, 3019 VkImageUsageFlags usage, 3020 VkImageTiling tiling, 3021 uint32_t* pPropertyCount, 3022 VkSparseImageFormatProperties* pProperties); 3023 3024 VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse( 3025 VkQueue queue, 3026 uint32_t bindInfoCount, 3027 const VkBindSparseInfo* pBindInfo, 3028 VkFence fence); 3029 3030 VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence( 3031 VkDevice device, 3032 const VkFenceCreateInfo* pCreateInfo, 3033 const VkAllocationCallbacks* pAllocator, 3034 VkFence* pFence); 3035 3036 VKAPI_ATTR void VKAPI_CALL vkDestroyFence( 3037 VkDevice device, 3038 VkFence fence, 3039 const VkAllocationCallbacks* pAllocator); 3040 3041 VKAPI_ATTR VkResult VKAPI_CALL vkResetFences( 3042 VkDevice device, 3043 uint32_t fenceCount, 3044 const VkFence* pFences); 3045 3046 VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus( 3047 VkDevice device, 3048 VkFence fence); 3049 3050 VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences( 3051 VkDevice device, 3052 uint32_t fenceCount, 3053 const VkFence* pFences, 3054 VkBool32 waitAll, 3055 uint64_t timeout); 3056 3057 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore( 3058 VkDevice device, 3059 const VkSemaphoreCreateInfo* pCreateInfo, 3060 const VkAllocationCallbacks* pAllocator, 3061 VkSemaphore* pSemaphore); 3062 3063 VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore( 3064 VkDevice device, 3065 VkSemaphore semaphore, 3066 const VkAllocationCallbacks* pAllocator); 3067 3068 VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent( 3069 VkDevice device, 3070 const VkEventCreateInfo* pCreateInfo, 3071 const VkAllocationCallbacks* pAllocator, 3072 VkEvent* pEvent); 3073 3074 VKAPI_ATTR void VKAPI_CALL vkDestroyEvent( 3075 VkDevice device, 3076 VkEvent event, 3077 const VkAllocationCallbacks* pAllocator); 3078 3079 VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus( 3080 VkDevice device, 3081 VkEvent event); 3082 3083 VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent( 3084 VkDevice device, 3085 VkEvent event); 3086 3087 VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent( 3088 VkDevice device, 3089 VkEvent event); 3090 3091 VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool( 3092 VkDevice device, 3093 const VkQueryPoolCreateInfo* pCreateInfo, 3094 const VkAllocationCallbacks* pAllocator, 3095 VkQueryPool* pQueryPool); 3096 3097 VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool( 3098 VkDevice device, 3099 VkQueryPool queryPool, 3100 const VkAllocationCallbacks* pAllocator); 3101 3102 VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults( 3103 VkDevice device, 3104 VkQueryPool queryPool, 3105 uint32_t firstQuery, 3106 uint32_t queryCount, 3107 size_t dataSize, 3108 void* pData, 3109 VkDeviceSize stride, 3110 VkQueryResultFlags flags); 3111 3112 VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer( 3113 VkDevice device, 3114 const VkBufferCreateInfo* pCreateInfo, 3115 const VkAllocationCallbacks* pAllocator, 3116 VkBuffer* pBuffer); 3117 3118 VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer( 3119 VkDevice device, 3120 VkBuffer buffer, 3121 const VkAllocationCallbacks* pAllocator); 3122 3123 VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView( 3124 VkDevice device, 3125 const VkBufferViewCreateInfo* pCreateInfo, 3126 const VkAllocationCallbacks* pAllocator, 3127 VkBufferView* pView); 3128 3129 VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView( 3130 VkDevice device, 3131 VkBufferView bufferView, 3132 const VkAllocationCallbacks* pAllocator); 3133 3134 VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage( 3135 VkDevice device, 3136 const VkImageCreateInfo* pCreateInfo, 3137 const VkAllocationCallbacks* pAllocator, 3138 VkImage* pImage); 3139 3140 VKAPI_ATTR void VKAPI_CALL vkDestroyImage( 3141 VkDevice device, 3142 VkImage image, 3143 const VkAllocationCallbacks* pAllocator); 3144 3145 VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout( 3146 VkDevice device, 3147 VkImage image, 3148 const VkImageSubresource* pSubresource, 3149 VkSubresourceLayout* pLayout); 3150 3151 VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView( 3152 VkDevice device, 3153 const VkImageViewCreateInfo* pCreateInfo, 3154 const VkAllocationCallbacks* pAllocator, 3155 VkImageView* pView); 3156 3157 VKAPI_ATTR void VKAPI_CALL vkDestroyImageView( 3158 VkDevice device, 3159 VkImageView imageView, 3160 const VkAllocationCallbacks* pAllocator); 3161 3162 VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule( 3163 VkDevice device, 3164 const VkShaderModuleCreateInfo* pCreateInfo, 3165 const VkAllocationCallbacks* pAllocator, 3166 VkShaderModule* pShaderModule); 3167 3168 VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule( 3169 VkDevice device, 3170 VkShaderModule shaderModule, 3171 const VkAllocationCallbacks* pAllocator); 3172 3173 VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache( 3174 VkDevice device, 3175 const VkPipelineCacheCreateInfo* pCreateInfo, 3176 const VkAllocationCallbacks* pAllocator, 3177 VkPipelineCache* pPipelineCache); 3178 3179 VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache( 3180 VkDevice device, 3181 VkPipelineCache pipelineCache, 3182 const VkAllocationCallbacks* pAllocator); 3183 3184 VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData( 3185 VkDevice device, 3186 VkPipelineCache pipelineCache, 3187 size_t* pDataSize, 3188 void* pData); 3189 3190 VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches( 3191 VkDevice device, 3192 VkPipelineCache dstCache, 3193 uint32_t srcCacheCount, 3194 const VkPipelineCache* pSrcCaches); 3195 3196 VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines( 3197 VkDevice device, 3198 VkPipelineCache pipelineCache, 3199 uint32_t createInfoCount, 3200 const VkGraphicsPipelineCreateInfo* pCreateInfos, 3201 const VkAllocationCallbacks* pAllocator, 3202 VkPipeline* pPipelines); 3203 3204 VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines( 3205 VkDevice device, 3206 VkPipelineCache pipelineCache, 3207 uint32_t createInfoCount, 3208 const VkComputePipelineCreateInfo* pCreateInfos, 3209 const VkAllocationCallbacks* pAllocator, 3210 VkPipeline* pPipelines); 3211 3212 VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline( 3213 VkDevice device, 3214 VkPipeline pipeline, 3215 const VkAllocationCallbacks* pAllocator); 3216 3217 VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout( 3218 VkDevice device, 3219 const VkPipelineLayoutCreateInfo* pCreateInfo, 3220 const VkAllocationCallbacks* pAllocator, 3221 VkPipelineLayout* pPipelineLayout); 3222 3223 VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout( 3224 VkDevice device, 3225 VkPipelineLayout pipelineLayout, 3226 const VkAllocationCallbacks* pAllocator); 3227 3228 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler( 3229 VkDevice device, 3230 const VkSamplerCreateInfo* pCreateInfo, 3231 const VkAllocationCallbacks* pAllocator, 3232 VkSampler* pSampler); 3233 3234 VKAPI_ATTR void VKAPI_CALL vkDestroySampler( 3235 VkDevice device, 3236 VkSampler sampler, 3237 const VkAllocationCallbacks* pAllocator); 3238 3239 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout( 3240 VkDevice device, 3241 const VkDescriptorSetLayoutCreateInfo* pCreateInfo, 3242 const VkAllocationCallbacks* pAllocator, 3243 VkDescriptorSetLayout* pSetLayout); 3244 3245 VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout( 3246 VkDevice device, 3247 VkDescriptorSetLayout descriptorSetLayout, 3248 const VkAllocationCallbacks* pAllocator); 3249 3250 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool( 3251 VkDevice device, 3252 const VkDescriptorPoolCreateInfo* pCreateInfo, 3253 const VkAllocationCallbacks* pAllocator, 3254 VkDescriptorPool* pDescriptorPool); 3255 3256 VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool( 3257 VkDevice device, 3258 VkDescriptorPool descriptorPool, 3259 const VkAllocationCallbacks* pAllocator); 3260 3261 VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool( 3262 VkDevice device, 3263 VkDescriptorPool descriptorPool, 3264 VkDescriptorPoolResetFlags flags); 3265 3266 VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets( 3267 VkDevice device, 3268 const VkDescriptorSetAllocateInfo* pAllocateInfo, 3269 VkDescriptorSet* pDescriptorSets); 3270 3271 VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets( 3272 VkDevice device, 3273 VkDescriptorPool descriptorPool, 3274 uint32_t descriptorSetCount, 3275 const VkDescriptorSet* pDescriptorSets); 3276 3277 VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets( 3278 VkDevice device, 3279 uint32_t descriptorWriteCount, 3280 const VkWriteDescriptorSet* pDescriptorWrites, 3281 uint32_t descriptorCopyCount, 3282 const VkCopyDescriptorSet* pDescriptorCopies); 3283 3284 VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer( 3285 VkDevice device, 3286 const VkFramebufferCreateInfo* pCreateInfo, 3287 const VkAllocationCallbacks* pAllocator, 3288 VkFramebuffer* pFramebuffer); 3289 3290 VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer( 3291 VkDevice device, 3292 VkFramebuffer framebuffer, 3293 const VkAllocationCallbacks* pAllocator); 3294 3295 VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass( 3296 VkDevice device, 3297 const VkRenderPassCreateInfo* pCreateInfo, 3298 const VkAllocationCallbacks* pAllocator, 3299 VkRenderPass* pRenderPass); 3300 3301 VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass( 3302 VkDevice device, 3303 VkRenderPass renderPass, 3304 const VkAllocationCallbacks* pAllocator); 3305 3306 VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity( 3307 VkDevice device, 3308 VkRenderPass renderPass, 3309 VkExtent2D* pGranularity); 3310 3311 VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool( 3312 VkDevice device, 3313 const VkCommandPoolCreateInfo* pCreateInfo, 3314 const VkAllocationCallbacks* pAllocator, 3315 VkCommandPool* pCommandPool); 3316 3317 VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool( 3318 VkDevice device, 3319 VkCommandPool commandPool, 3320 const VkAllocationCallbacks* pAllocator); 3321 3322 VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool( 3323 VkDevice device, 3324 VkCommandPool commandPool, 3325 VkCommandPoolResetFlags flags); 3326 3327 VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers( 3328 VkDevice device, 3329 const VkCommandBufferAllocateInfo* pAllocateInfo, 3330 VkCommandBuffer* pCommandBuffers); 3331 3332 VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers( 3333 VkDevice device, 3334 VkCommandPool commandPool, 3335 uint32_t commandBufferCount, 3336 const VkCommandBuffer* pCommandBuffers); 3337 3338 VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer( 3339 VkCommandBuffer commandBuffer, 3340 const VkCommandBufferBeginInfo* pBeginInfo); 3341 3342 VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer( 3343 VkCommandBuffer commandBuffer); 3344 3345 VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer( 3346 VkCommandBuffer commandBuffer, 3347 VkCommandBufferResetFlags flags); 3348 3349 VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline( 3350 VkCommandBuffer commandBuffer, 3351 VkPipelineBindPoint pipelineBindPoint, 3352 VkPipeline pipeline); 3353 3354 VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport( 3355 VkCommandBuffer commandBuffer, 3356 uint32_t firstViewport, 3357 uint32_t viewportCount, 3358 const VkViewport* pViewports); 3359 3360 VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor( 3361 VkCommandBuffer commandBuffer, 3362 uint32_t firstScissor, 3363 uint32_t scissorCount, 3364 const VkRect2D* pScissors); 3365 3366 VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth( 3367 VkCommandBuffer commandBuffer, 3368 float lineWidth); 3369 3370 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias( 3371 VkCommandBuffer commandBuffer, 3372 float depthBiasConstantFactor, 3373 float depthBiasClamp, 3374 float depthBiasSlopeFactor); 3375 3376 VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants( 3377 VkCommandBuffer commandBuffer, 3378 const float blendConstants[4]); 3379 3380 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds( 3381 VkCommandBuffer commandBuffer, 3382 float minDepthBounds, 3383 float maxDepthBounds); 3384 3385 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask( 3386 VkCommandBuffer commandBuffer, 3387 VkStencilFaceFlags faceMask, 3388 uint32_t compareMask); 3389 3390 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask( 3391 VkCommandBuffer commandBuffer, 3392 VkStencilFaceFlags faceMask, 3393 uint32_t writeMask); 3394 3395 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference( 3396 VkCommandBuffer commandBuffer, 3397 VkStencilFaceFlags faceMask, 3398 uint32_t reference); 3399 3400 VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets( 3401 VkCommandBuffer commandBuffer, 3402 VkPipelineBindPoint pipelineBindPoint, 3403 VkPipelineLayout layout, 3404 uint32_t firstSet, 3405 uint32_t descriptorSetCount, 3406 const VkDescriptorSet* pDescriptorSets, 3407 uint32_t dynamicOffsetCount, 3408 const uint32_t* pDynamicOffsets); 3409 3410 VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer( 3411 VkCommandBuffer commandBuffer, 3412 VkBuffer buffer, 3413 VkDeviceSize offset, 3414 VkIndexType indexType); 3415 3416 VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers( 3417 VkCommandBuffer commandBuffer, 3418 uint32_t firstBinding, 3419 uint32_t bindingCount, 3420 const VkBuffer* pBuffers, 3421 const VkDeviceSize* pOffsets); 3422 3423 VKAPI_ATTR void VKAPI_CALL vkCmdDraw( 3424 VkCommandBuffer commandBuffer, 3425 uint32_t vertexCount, 3426 uint32_t instanceCount, 3427 uint32_t firstVertex, 3428 uint32_t firstInstance); 3429 3430 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed( 3431 VkCommandBuffer commandBuffer, 3432 uint32_t indexCount, 3433 uint32_t instanceCount, 3434 uint32_t firstIndex, 3435 int32_t vertexOffset, 3436 uint32_t firstInstance); 3437 3438 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect( 3439 VkCommandBuffer commandBuffer, 3440 VkBuffer buffer, 3441 VkDeviceSize offset, 3442 uint32_t drawCount, 3443 uint32_t stride); 3444 3445 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect( 3446 VkCommandBuffer commandBuffer, 3447 VkBuffer buffer, 3448 VkDeviceSize offset, 3449 uint32_t drawCount, 3450 uint32_t stride); 3451 3452 VKAPI_ATTR void VKAPI_CALL vkCmdDispatch( 3453 VkCommandBuffer commandBuffer, 3454 uint32_t groupCountX, 3455 uint32_t groupCountY, 3456 uint32_t groupCountZ); 3457 3458 VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect( 3459 VkCommandBuffer commandBuffer, 3460 VkBuffer buffer, 3461 VkDeviceSize offset); 3462 3463 VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer( 3464 VkCommandBuffer commandBuffer, 3465 VkBuffer srcBuffer, 3466 VkBuffer dstBuffer, 3467 uint32_t regionCount, 3468 const VkBufferCopy* pRegions); 3469 3470 VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage( 3471 VkCommandBuffer commandBuffer, 3472 VkImage srcImage, 3473 VkImageLayout srcImageLayout, 3474 VkImage dstImage, 3475 VkImageLayout dstImageLayout, 3476 uint32_t regionCount, 3477 const VkImageCopy* pRegions); 3478 3479 VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage( 3480 VkCommandBuffer commandBuffer, 3481 VkImage srcImage, 3482 VkImageLayout srcImageLayout, 3483 VkImage dstImage, 3484 VkImageLayout dstImageLayout, 3485 uint32_t regionCount, 3486 const VkImageBlit* pRegions, 3487 VkFilter filter); 3488 3489 VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage( 3490 VkCommandBuffer commandBuffer, 3491 VkBuffer srcBuffer, 3492 VkImage dstImage, 3493 VkImageLayout dstImageLayout, 3494 uint32_t regionCount, 3495 const VkBufferImageCopy* pRegions); 3496 3497 VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer( 3498 VkCommandBuffer commandBuffer, 3499 VkImage srcImage, 3500 VkImageLayout srcImageLayout, 3501 VkBuffer dstBuffer, 3502 uint32_t regionCount, 3503 const VkBufferImageCopy* pRegions); 3504 3505 VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer( 3506 VkCommandBuffer commandBuffer, 3507 VkBuffer dstBuffer, 3508 VkDeviceSize dstOffset, 3509 VkDeviceSize dataSize, 3510 const void* pData); 3511 3512 VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer( 3513 VkCommandBuffer commandBuffer, 3514 VkBuffer dstBuffer, 3515 VkDeviceSize dstOffset, 3516 VkDeviceSize size, 3517 uint32_t data); 3518 3519 VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage( 3520 VkCommandBuffer commandBuffer, 3521 VkImage image, 3522 VkImageLayout imageLayout, 3523 const VkClearColorValue* pColor, 3524 uint32_t rangeCount, 3525 const VkImageSubresourceRange* pRanges); 3526 3527 VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage( 3528 VkCommandBuffer commandBuffer, 3529 VkImage image, 3530 VkImageLayout imageLayout, 3531 const VkClearDepthStencilValue* pDepthStencil, 3532 uint32_t rangeCount, 3533 const VkImageSubresourceRange* pRanges); 3534 3535 VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments( 3536 VkCommandBuffer commandBuffer, 3537 uint32_t attachmentCount, 3538 const VkClearAttachment* pAttachments, 3539 uint32_t rectCount, 3540 const VkClearRect* pRects); 3541 3542 VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage( 3543 VkCommandBuffer commandBuffer, 3544 VkImage srcImage, 3545 VkImageLayout srcImageLayout, 3546 VkImage dstImage, 3547 VkImageLayout dstImageLayout, 3548 uint32_t regionCount, 3549 const VkImageResolve* pRegions); 3550 3551 VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent( 3552 VkCommandBuffer commandBuffer, 3553 VkEvent event, 3554 VkPipelineStageFlags stageMask); 3555 3556 VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent( 3557 VkCommandBuffer commandBuffer, 3558 VkEvent event, 3559 VkPipelineStageFlags stageMask); 3560 3561 VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents( 3562 VkCommandBuffer commandBuffer, 3563 uint32_t eventCount, 3564 const VkEvent* pEvents, 3565 VkPipelineStageFlags srcStageMask, 3566 VkPipelineStageFlags dstStageMask, 3567 uint32_t memoryBarrierCount, 3568 const VkMemoryBarrier* pMemoryBarriers, 3569 uint32_t bufferMemoryBarrierCount, 3570 const VkBufferMemoryBarrier* pBufferMemoryBarriers, 3571 uint32_t imageMemoryBarrierCount, 3572 const VkImageMemoryBarrier* pImageMemoryBarriers); 3573 3574 VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier( 3575 VkCommandBuffer commandBuffer, 3576 VkPipelineStageFlags srcStageMask, 3577 VkPipelineStageFlags dstStageMask, 3578 VkDependencyFlags dependencyFlags, 3579 uint32_t memoryBarrierCount, 3580 const VkMemoryBarrier* pMemoryBarriers, 3581 uint32_t bufferMemoryBarrierCount, 3582 const VkBufferMemoryBarrier* pBufferMemoryBarriers, 3583 uint32_t imageMemoryBarrierCount, 3584 const VkImageMemoryBarrier* pImageMemoryBarriers); 3585 3586 VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery( 3587 VkCommandBuffer commandBuffer, 3588 VkQueryPool queryPool, 3589 uint32_t query, 3590 VkQueryControlFlags flags); 3591 3592 VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery( 3593 VkCommandBuffer commandBuffer, 3594 VkQueryPool queryPool, 3595 uint32_t query); 3596 3597 VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool( 3598 VkCommandBuffer commandBuffer, 3599 VkQueryPool queryPool, 3600 uint32_t firstQuery, 3601 uint32_t queryCount); 3602 3603 VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp( 3604 VkCommandBuffer commandBuffer, 3605 VkPipelineStageFlagBits pipelineStage, 3606 VkQueryPool queryPool, 3607 uint32_t query); 3608 3609 VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults( 3610 VkCommandBuffer commandBuffer, 3611 VkQueryPool queryPool, 3612 uint32_t firstQuery, 3613 uint32_t queryCount, 3614 VkBuffer dstBuffer, 3615 VkDeviceSize dstOffset, 3616 VkDeviceSize stride, 3617 VkQueryResultFlags flags); 3618 3619 VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants( 3620 VkCommandBuffer commandBuffer, 3621 VkPipelineLayout layout, 3622 VkShaderStageFlags stageFlags, 3623 uint32_t offset, 3624 uint32_t size, 3625 const void* pValues); 3626 3627 VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass( 3628 VkCommandBuffer commandBuffer, 3629 const VkRenderPassBeginInfo* pRenderPassBegin, 3630 VkSubpassContents contents); 3631 3632 VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass( 3633 VkCommandBuffer commandBuffer, 3634 VkSubpassContents contents); 3635 3636 VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass( 3637 VkCommandBuffer commandBuffer); 3638 3639 VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands( 3640 VkCommandBuffer commandBuffer, 3641 uint32_t commandBufferCount, 3642 const VkCommandBuffer* pCommandBuffers); 3643 #endif 3644 3645 #define VK_VERSION_1_1 1 3646 // Vulkan 1.1 version number 3647 #define VK_API_VERSION_1_1 VK_MAKE_VERSION(1, 1, 0)// Patch version should always be set to 0 3648 3649 3650 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSamplerYcbcrConversion) 3651 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorUpdateTemplate) 3652 3653 #define VK_MAX_DEVICE_GROUP_SIZE 32 3654 #define VK_LUID_SIZE 8 3655 #define VK_QUEUE_FAMILY_EXTERNAL (~0U-1) 3656 3657 3658 typedef enum VkPointClippingBehavior { 3659 VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES = 0, 3660 VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY = 1, 3661 VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES, 3662 VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY, 3663 VK_POINT_CLIPPING_BEHAVIOR_BEGIN_RANGE = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES, 3664 VK_POINT_CLIPPING_BEHAVIOR_END_RANGE = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY, 3665 VK_POINT_CLIPPING_BEHAVIOR_RANGE_SIZE = (VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY - VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES + 1), 3666 VK_POINT_CLIPPING_BEHAVIOR_MAX_ENUM = 0x7FFFFFFF 3667 } VkPointClippingBehavior; 3668 3669 typedef enum VkTessellationDomainOrigin { 3670 VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT = 0, 3671 VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT = 1, 3672 VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT, 3673 VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT, 3674 VK_TESSELLATION_DOMAIN_ORIGIN_BEGIN_RANGE = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT, 3675 VK_TESSELLATION_DOMAIN_ORIGIN_END_RANGE = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT, 3676 VK_TESSELLATION_DOMAIN_ORIGIN_RANGE_SIZE = (VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT - VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT + 1), 3677 VK_TESSELLATION_DOMAIN_ORIGIN_MAX_ENUM = 0x7FFFFFFF 3678 } VkTessellationDomainOrigin; 3679 3680 typedef enum VkSamplerYcbcrModelConversion { 3681 VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY = 0, 3682 VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY = 1, 3683 VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709 = 2, 3684 VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601 = 3, 3685 VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 = 4, 3686 VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY, 3687 VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY, 3688 VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709, 3689 VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601, 3690 VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020, 3691 VK_SAMPLER_YCBCR_MODEL_CONVERSION_BEGIN_RANGE = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY, 3692 VK_SAMPLER_YCBCR_MODEL_CONVERSION_END_RANGE = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020, 3693 VK_SAMPLER_YCBCR_MODEL_CONVERSION_RANGE_SIZE = (VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 - VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY + 1), 3694 VK_SAMPLER_YCBCR_MODEL_CONVERSION_MAX_ENUM = 0x7FFFFFFF 3695 } VkSamplerYcbcrModelConversion; 3696 3697 typedef enum VkSamplerYcbcrRange { 3698 VK_SAMPLER_YCBCR_RANGE_ITU_FULL = 0, 3699 VK_SAMPLER_YCBCR_RANGE_ITU_NARROW = 1, 3700 VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_FULL, 3701 VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW, 3702 VK_SAMPLER_YCBCR_RANGE_BEGIN_RANGE = VK_SAMPLER_YCBCR_RANGE_ITU_FULL, 3703 VK_SAMPLER_YCBCR_RANGE_END_RANGE = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW, 3704 VK_SAMPLER_YCBCR_RANGE_RANGE_SIZE = (VK_SAMPLER_YCBCR_RANGE_ITU_NARROW - VK_SAMPLER_YCBCR_RANGE_ITU_FULL + 1), 3705 VK_SAMPLER_YCBCR_RANGE_MAX_ENUM = 0x7FFFFFFF 3706 } VkSamplerYcbcrRange; 3707 3708 typedef enum VkChromaLocation { 3709 VK_CHROMA_LOCATION_COSITED_EVEN = 0, 3710 VK_CHROMA_LOCATION_MIDPOINT = 1, 3711 VK_CHROMA_LOCATION_COSITED_EVEN_KHR = VK_CHROMA_LOCATION_COSITED_EVEN, 3712 VK_CHROMA_LOCATION_MIDPOINT_KHR = VK_CHROMA_LOCATION_MIDPOINT, 3713 VK_CHROMA_LOCATION_BEGIN_RANGE = VK_CHROMA_LOCATION_COSITED_EVEN, 3714 VK_CHROMA_LOCATION_END_RANGE = VK_CHROMA_LOCATION_MIDPOINT, 3715 VK_CHROMA_LOCATION_RANGE_SIZE = (VK_CHROMA_LOCATION_MIDPOINT - VK_CHROMA_LOCATION_COSITED_EVEN + 1), 3716 VK_CHROMA_LOCATION_MAX_ENUM = 0x7FFFFFFF 3717 } VkChromaLocation; 3718 3719 typedef enum VkDescriptorUpdateTemplateType { 3720 VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET = 0, 3721 VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = 1, 3722 VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET, 3723 VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_BEGIN_RANGE = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET, 3724 VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_END_RANGE = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET, 3725 VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_RANGE_SIZE = (VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET - VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET + 1), 3726 VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM = 0x7FFFFFFF 3727 } VkDescriptorUpdateTemplateType; 3728 3729 3730 typedef enum VkSubgroupFeatureFlagBits { 3731 VK_SUBGROUP_FEATURE_BASIC_BIT = 0x00000001, 3732 VK_SUBGROUP_FEATURE_VOTE_BIT = 0x00000002, 3733 VK_SUBGROUP_FEATURE_ARITHMETIC_BIT = 0x00000004, 3734 VK_SUBGROUP_FEATURE_BALLOT_BIT = 0x00000008, 3735 VK_SUBGROUP_FEATURE_SHUFFLE_BIT = 0x00000010, 3736 VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT = 0x00000020, 3737 VK_SUBGROUP_FEATURE_CLUSTERED_BIT = 0x00000040, 3738 VK_SUBGROUP_FEATURE_QUAD_BIT = 0x00000080, 3739 VK_SUBGROUP_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 3740 } VkSubgroupFeatureFlagBits; 3741 typedef VkFlags VkSubgroupFeatureFlags; 3742 3743 typedef enum VkPeerMemoryFeatureFlagBits { 3744 VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT = 0x00000001, 3745 VK_PEER_MEMORY_FEATURE_COPY_DST_BIT = 0x00000002, 3746 VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT = 0x00000004, 3747 VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT = 0x00000008, 3748 VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHR = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT, 3749 VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHR = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT, 3750 VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHR = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT, 3751 VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHR = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT, 3752 VK_PEER_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 3753 } VkPeerMemoryFeatureFlagBits; 3754 typedef VkFlags VkPeerMemoryFeatureFlags; 3755 3756 typedef enum VkMemoryAllocateFlagBits { 3757 VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT = 0x00000001, 3758 VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT, 3759 VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 3760 } VkMemoryAllocateFlagBits; 3761 typedef VkFlags VkMemoryAllocateFlags; 3762 typedef VkFlags VkCommandPoolTrimFlags; 3763 typedef VkFlags VkDescriptorUpdateTemplateCreateFlags; 3764 3765 typedef enum VkExternalMemoryHandleTypeFlagBits { 3766 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001, 3767 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002, 3768 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004, 3769 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT = 0x00000008, 3770 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT = 0x00000010, 3771 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT = 0x00000020, 3772 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT = 0x00000040, 3773 VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT = 0x00000200, 3774 VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID = 0x00000400, 3775 VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT = 0x00000080, 3776 VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT = 0x00000100, 3777 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT, 3778 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, 3779 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, 3780 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, 3781 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT, 3782 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, 3783 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, 3784 VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 3785 } VkExternalMemoryHandleTypeFlagBits; 3786 typedef VkFlags VkExternalMemoryHandleTypeFlags; 3787 3788 typedef enum VkExternalMemoryFeatureFlagBits { 3789 VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT = 0x00000001, 3790 VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT = 0x00000002, 3791 VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT = 0x00000004, 3792 VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT, 3793 VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT, 3794 VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT, 3795 VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 3796 } VkExternalMemoryFeatureFlagBits; 3797 typedef VkFlags VkExternalMemoryFeatureFlags; 3798 3799 typedef enum VkExternalFenceHandleTypeFlagBits { 3800 VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001, 3801 VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002, 3802 VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004, 3803 VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000008, 3804 VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT, 3805 VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT, 3806 VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, 3807 VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT, 3808 VK_EXTERNAL_FENCE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 3809 } VkExternalFenceHandleTypeFlagBits; 3810 typedef VkFlags VkExternalFenceHandleTypeFlags; 3811 3812 typedef enum VkExternalFenceFeatureFlagBits { 3813 VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT = 0x00000001, 3814 VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT = 0x00000002, 3815 VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT, 3816 VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT, 3817 VK_EXTERNAL_FENCE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 3818 } VkExternalFenceFeatureFlagBits; 3819 typedef VkFlags VkExternalFenceFeatureFlags; 3820 3821 typedef enum VkFenceImportFlagBits { 3822 VK_FENCE_IMPORT_TEMPORARY_BIT = 0x00000001, 3823 VK_FENCE_IMPORT_TEMPORARY_BIT_KHR = VK_FENCE_IMPORT_TEMPORARY_BIT, 3824 VK_FENCE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 3825 } VkFenceImportFlagBits; 3826 typedef VkFlags VkFenceImportFlags; 3827 3828 typedef enum VkSemaphoreImportFlagBits { 3829 VK_SEMAPHORE_IMPORT_TEMPORARY_BIT = 0x00000001, 3830 VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT, 3831 VK_SEMAPHORE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 3832 } VkSemaphoreImportFlagBits; 3833 typedef VkFlags VkSemaphoreImportFlags; 3834 3835 typedef enum VkExternalSemaphoreHandleTypeFlagBits { 3836 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001, 3837 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002, 3838 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004, 3839 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT = 0x00000008, 3840 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000010, 3841 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT, 3842 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT, 3843 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, 3844 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT, 3845 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT, 3846 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 3847 } VkExternalSemaphoreHandleTypeFlagBits; 3848 typedef VkFlags VkExternalSemaphoreHandleTypeFlags; 3849 3850 typedef enum VkExternalSemaphoreFeatureFlagBits { 3851 VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT = 0x00000001, 3852 VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT = 0x00000002, 3853 VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT, 3854 VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT, 3855 VK_EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 3856 } VkExternalSemaphoreFeatureFlagBits; 3857 typedef VkFlags VkExternalSemaphoreFeatureFlags; 3858 3859 typedef struct VkPhysicalDeviceSubgroupProperties { 3860 VkStructureType sType; 3861 void* pNext; 3862 uint32_t subgroupSize; 3863 VkShaderStageFlags supportedStages; 3864 VkSubgroupFeatureFlags supportedOperations; 3865 VkBool32 quadOperationsInAllStages; 3866 } VkPhysicalDeviceSubgroupProperties; 3867 3868 typedef struct VkBindBufferMemoryInfo { 3869 VkStructureType sType; 3870 const void* pNext; 3871 VkBuffer buffer; 3872 VkDeviceMemory memory; 3873 VkDeviceSize memoryOffset; 3874 } VkBindBufferMemoryInfo; 3875 3876 typedef struct VkBindImageMemoryInfo { 3877 VkStructureType sType; 3878 const void* pNext; 3879 VkImage image; 3880 VkDeviceMemory memory; 3881 VkDeviceSize memoryOffset; 3882 } VkBindImageMemoryInfo; 3883 3884 typedef struct VkPhysicalDevice16BitStorageFeatures { 3885 VkStructureType sType; 3886 void* pNext; 3887 VkBool32 storageBuffer16BitAccess; 3888 VkBool32 uniformAndStorageBuffer16BitAccess; 3889 VkBool32 storagePushConstant16; 3890 VkBool32 storageInputOutput16; 3891 } VkPhysicalDevice16BitStorageFeatures; 3892 3893 typedef struct VkMemoryDedicatedRequirements { 3894 VkStructureType sType; 3895 void* pNext; 3896 VkBool32 prefersDedicatedAllocation; 3897 VkBool32 requiresDedicatedAllocation; 3898 } VkMemoryDedicatedRequirements; 3899 3900 typedef struct VkMemoryDedicatedAllocateInfo { 3901 VkStructureType sType; 3902 const void* pNext; 3903 VkImage image; 3904 VkBuffer buffer; 3905 } VkMemoryDedicatedAllocateInfo; 3906 3907 typedef struct VkMemoryAllocateFlagsInfo { 3908 VkStructureType sType; 3909 const void* pNext; 3910 VkMemoryAllocateFlags flags; 3911 uint32_t deviceMask; 3912 } VkMemoryAllocateFlagsInfo; 3913 3914 typedef struct VkDeviceGroupRenderPassBeginInfo { 3915 VkStructureType sType; 3916 const void* pNext; 3917 uint32_t deviceMask; 3918 uint32_t deviceRenderAreaCount; 3919 const VkRect2D* pDeviceRenderAreas; 3920 } VkDeviceGroupRenderPassBeginInfo; 3921 3922 typedef struct VkDeviceGroupCommandBufferBeginInfo { 3923 VkStructureType sType; 3924 const void* pNext; 3925 uint32_t deviceMask; 3926 } VkDeviceGroupCommandBufferBeginInfo; 3927 3928 typedef struct VkDeviceGroupSubmitInfo { 3929 VkStructureType sType; 3930 const void* pNext; 3931 uint32_t waitSemaphoreCount; 3932 const uint32_t* pWaitSemaphoreDeviceIndices; 3933 uint32_t commandBufferCount; 3934 const uint32_t* pCommandBufferDeviceMasks; 3935 uint32_t signalSemaphoreCount; 3936 const uint32_t* pSignalSemaphoreDeviceIndices; 3937 } VkDeviceGroupSubmitInfo; 3938 3939 typedef struct VkDeviceGroupBindSparseInfo { 3940 VkStructureType sType; 3941 const void* pNext; 3942 uint32_t resourceDeviceIndex; 3943 uint32_t memoryDeviceIndex; 3944 } VkDeviceGroupBindSparseInfo; 3945 3946 typedef struct VkBindBufferMemoryDeviceGroupInfo { 3947 VkStructureType sType; 3948 const void* pNext; 3949 uint32_t deviceIndexCount; 3950 const uint32_t* pDeviceIndices; 3951 } VkBindBufferMemoryDeviceGroupInfo; 3952 3953 typedef struct VkBindImageMemoryDeviceGroupInfo { 3954 VkStructureType sType; 3955 const void* pNext; 3956 uint32_t deviceIndexCount; 3957 const uint32_t* pDeviceIndices; 3958 uint32_t splitInstanceBindRegionCount; 3959 const VkRect2D* pSplitInstanceBindRegions; 3960 } VkBindImageMemoryDeviceGroupInfo; 3961 3962 typedef struct VkPhysicalDeviceGroupProperties { 3963 VkStructureType sType; 3964 void* pNext; 3965 uint32_t physicalDeviceCount; 3966 VkPhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE]; 3967 VkBool32 subsetAllocation; 3968 } VkPhysicalDeviceGroupProperties; 3969 3970 typedef struct VkDeviceGroupDeviceCreateInfo { 3971 VkStructureType sType; 3972 const void* pNext; 3973 uint32_t physicalDeviceCount; 3974 const VkPhysicalDevice* pPhysicalDevices; 3975 } VkDeviceGroupDeviceCreateInfo; 3976 3977 typedef struct VkBufferMemoryRequirementsInfo2 { 3978 VkStructureType sType; 3979 const void* pNext; 3980 VkBuffer buffer; 3981 } VkBufferMemoryRequirementsInfo2; 3982 3983 typedef struct VkImageMemoryRequirementsInfo2 { 3984 VkStructureType sType; 3985 const void* pNext; 3986 VkImage image; 3987 } VkImageMemoryRequirementsInfo2; 3988 3989 typedef struct VkImageSparseMemoryRequirementsInfo2 { 3990 VkStructureType sType; 3991 const void* pNext; 3992 VkImage image; 3993 } VkImageSparseMemoryRequirementsInfo2; 3994 3995 typedef struct VkMemoryRequirements2 { 3996 VkStructureType sType; 3997 void* pNext; 3998 VkMemoryRequirements memoryRequirements; 3999 } VkMemoryRequirements2; 4000 4001 typedef struct VkSparseImageMemoryRequirements2 { 4002 VkStructureType sType; 4003 void* pNext; 4004 VkSparseImageMemoryRequirements memoryRequirements; 4005 } VkSparseImageMemoryRequirements2; 4006 4007 typedef struct VkPhysicalDeviceFeatures2 { 4008 VkStructureType sType; 4009 void* pNext; 4010 VkPhysicalDeviceFeatures features; 4011 } VkPhysicalDeviceFeatures2; 4012 4013 typedef struct VkPhysicalDeviceProperties2 { 4014 VkStructureType sType; 4015 void* pNext; 4016 VkPhysicalDeviceProperties properties; 4017 } VkPhysicalDeviceProperties2; 4018 4019 typedef struct VkFormatProperties2 { 4020 VkStructureType sType; 4021 void* pNext; 4022 VkFormatProperties formatProperties; 4023 } VkFormatProperties2; 4024 4025 typedef struct VkImageFormatProperties2 { 4026 VkStructureType sType; 4027 void* pNext; 4028 VkImageFormatProperties imageFormatProperties; 4029 } VkImageFormatProperties2; 4030 4031 typedef struct VkPhysicalDeviceImageFormatInfo2 { 4032 VkStructureType sType; 4033 const void* pNext; 4034 VkFormat format; 4035 VkImageType type; 4036 VkImageTiling tiling; 4037 VkImageUsageFlags usage; 4038 VkImageCreateFlags flags; 4039 } VkPhysicalDeviceImageFormatInfo2; 4040 4041 typedef struct VkQueueFamilyProperties2 { 4042 VkStructureType sType; 4043 void* pNext; 4044 VkQueueFamilyProperties queueFamilyProperties; 4045 } VkQueueFamilyProperties2; 4046 4047 typedef struct VkPhysicalDeviceMemoryProperties2 { 4048 VkStructureType sType; 4049 void* pNext; 4050 VkPhysicalDeviceMemoryProperties memoryProperties; 4051 } VkPhysicalDeviceMemoryProperties2; 4052 4053 typedef struct VkSparseImageFormatProperties2 { 4054 VkStructureType sType; 4055 void* pNext; 4056 VkSparseImageFormatProperties properties; 4057 } VkSparseImageFormatProperties2; 4058 4059 typedef struct VkPhysicalDeviceSparseImageFormatInfo2 { 4060 VkStructureType sType; 4061 const void* pNext; 4062 VkFormat format; 4063 VkImageType type; 4064 VkSampleCountFlagBits samples; 4065 VkImageUsageFlags usage; 4066 VkImageTiling tiling; 4067 } VkPhysicalDeviceSparseImageFormatInfo2; 4068 4069 typedef struct VkPhysicalDevicePointClippingProperties { 4070 VkStructureType sType; 4071 void* pNext; 4072 VkPointClippingBehavior pointClippingBehavior; 4073 } VkPhysicalDevicePointClippingProperties; 4074 4075 typedef struct VkInputAttachmentAspectReference { 4076 uint32_t subpass; 4077 uint32_t inputAttachmentIndex; 4078 VkImageAspectFlags aspectMask; 4079 } VkInputAttachmentAspectReference; 4080 4081 typedef struct VkRenderPassInputAttachmentAspectCreateInfo { 4082 VkStructureType sType; 4083 const void* pNext; 4084 uint32_t aspectReferenceCount; 4085 const VkInputAttachmentAspectReference* pAspectReferences; 4086 } VkRenderPassInputAttachmentAspectCreateInfo; 4087 4088 typedef struct VkImageViewUsageCreateInfo { 4089 VkStructureType sType; 4090 const void* pNext; 4091 VkImageUsageFlags usage; 4092 } VkImageViewUsageCreateInfo; 4093 4094 typedef struct VkPipelineTessellationDomainOriginStateCreateInfo { 4095 VkStructureType sType; 4096 const void* pNext; 4097 VkTessellationDomainOrigin domainOrigin; 4098 } VkPipelineTessellationDomainOriginStateCreateInfo; 4099 4100 typedef struct VkRenderPassMultiviewCreateInfo { 4101 VkStructureType sType; 4102 const void* pNext; 4103 uint32_t subpassCount; 4104 const uint32_t* pViewMasks; 4105 uint32_t dependencyCount; 4106 const int32_t* pViewOffsets; 4107 uint32_t correlationMaskCount; 4108 const uint32_t* pCorrelationMasks; 4109 } VkRenderPassMultiviewCreateInfo; 4110 4111 typedef struct VkPhysicalDeviceMultiviewFeatures { 4112 VkStructureType sType; 4113 void* pNext; 4114 VkBool32 multiview; 4115 VkBool32 multiviewGeometryShader; 4116 VkBool32 multiviewTessellationShader; 4117 } VkPhysicalDeviceMultiviewFeatures; 4118 4119 typedef struct VkPhysicalDeviceMultiviewProperties { 4120 VkStructureType sType; 4121 void* pNext; 4122 uint32_t maxMultiviewViewCount; 4123 uint32_t maxMultiviewInstanceIndex; 4124 } VkPhysicalDeviceMultiviewProperties; 4125 4126 typedef struct VkPhysicalDeviceVariablePointerFeatures { 4127 VkStructureType sType; 4128 void* pNext; 4129 VkBool32 variablePointersStorageBuffer; 4130 VkBool32 variablePointers; 4131 } VkPhysicalDeviceVariablePointerFeatures; 4132 4133 typedef struct VkPhysicalDeviceProtectedMemoryFeatures { 4134 VkStructureType sType; 4135 void* pNext; 4136 VkBool32 protectedMemory; 4137 } VkPhysicalDeviceProtectedMemoryFeatures; 4138 4139 typedef struct VkPhysicalDeviceProtectedMemoryProperties { 4140 VkStructureType sType; 4141 void* pNext; 4142 VkBool32 protectedNoFault; 4143 } VkPhysicalDeviceProtectedMemoryProperties; 4144 4145 typedef struct VkDeviceQueueInfo2 { 4146 VkStructureType sType; 4147 const void* pNext; 4148 VkDeviceQueueCreateFlags flags; 4149 uint32_t queueFamilyIndex; 4150 uint32_t queueIndex; 4151 } VkDeviceQueueInfo2; 4152 4153 typedef struct VkProtectedSubmitInfo { 4154 VkStructureType sType; 4155 const void* pNext; 4156 VkBool32 protectedSubmit; 4157 } VkProtectedSubmitInfo; 4158 4159 typedef struct VkSamplerYcbcrConversionCreateInfo { 4160 VkStructureType sType; 4161 const void* pNext; 4162 VkFormat format; 4163 VkSamplerYcbcrModelConversion ycbcrModel; 4164 VkSamplerYcbcrRange ycbcrRange; 4165 VkComponentMapping components; 4166 VkChromaLocation xChromaOffset; 4167 VkChromaLocation yChromaOffset; 4168 VkFilter chromaFilter; 4169 VkBool32 forceExplicitReconstruction; 4170 } VkSamplerYcbcrConversionCreateInfo; 4171 4172 typedef struct VkSamplerYcbcrConversionInfo { 4173 VkStructureType sType; 4174 const void* pNext; 4175 VkSamplerYcbcrConversion conversion; 4176 } VkSamplerYcbcrConversionInfo; 4177 4178 typedef struct VkBindImagePlaneMemoryInfo { 4179 VkStructureType sType; 4180 const void* pNext; 4181 VkImageAspectFlagBits planeAspect; 4182 } VkBindImagePlaneMemoryInfo; 4183 4184 typedef struct VkImagePlaneMemoryRequirementsInfo { 4185 VkStructureType sType; 4186 const void* pNext; 4187 VkImageAspectFlagBits planeAspect; 4188 } VkImagePlaneMemoryRequirementsInfo; 4189 4190 typedef struct VkPhysicalDeviceSamplerYcbcrConversionFeatures { 4191 VkStructureType sType; 4192 void* pNext; 4193 VkBool32 samplerYcbcrConversion; 4194 } VkPhysicalDeviceSamplerYcbcrConversionFeatures; 4195 4196 typedef struct VkSamplerYcbcrConversionImageFormatProperties { 4197 VkStructureType sType; 4198 void* pNext; 4199 uint32_t combinedImageSamplerDescriptorCount; 4200 } VkSamplerYcbcrConversionImageFormatProperties; 4201 4202 typedef struct VkDescriptorUpdateTemplateEntry { 4203 uint32_t dstBinding; 4204 uint32_t dstArrayElement; 4205 uint32_t descriptorCount; 4206 VkDescriptorType descriptorType; 4207 size_t offset; 4208 size_t stride; 4209 } VkDescriptorUpdateTemplateEntry; 4210 4211 typedef struct VkDescriptorUpdateTemplateCreateInfo { 4212 VkStructureType sType; 4213 void* pNext; 4214 VkDescriptorUpdateTemplateCreateFlags flags; 4215 uint32_t descriptorUpdateEntryCount; 4216 const VkDescriptorUpdateTemplateEntry* pDescriptorUpdateEntries; 4217 VkDescriptorUpdateTemplateType templateType; 4218 VkDescriptorSetLayout descriptorSetLayout; 4219 VkPipelineBindPoint pipelineBindPoint; 4220 VkPipelineLayout pipelineLayout; 4221 uint32_t set; 4222 } VkDescriptorUpdateTemplateCreateInfo; 4223 4224 typedef struct VkExternalMemoryProperties { 4225 VkExternalMemoryFeatureFlags externalMemoryFeatures; 4226 VkExternalMemoryHandleTypeFlags exportFromImportedHandleTypes; 4227 VkExternalMemoryHandleTypeFlags compatibleHandleTypes; 4228 } VkExternalMemoryProperties; 4229 4230 typedef struct VkPhysicalDeviceExternalImageFormatInfo { 4231 VkStructureType sType; 4232 const void* pNext; 4233 VkExternalMemoryHandleTypeFlagBits handleType; 4234 } VkPhysicalDeviceExternalImageFormatInfo; 4235 4236 typedef struct VkExternalImageFormatProperties { 4237 VkStructureType sType; 4238 void* pNext; 4239 VkExternalMemoryProperties externalMemoryProperties; 4240 } VkExternalImageFormatProperties; 4241 4242 typedef struct VkPhysicalDeviceExternalBufferInfo { 4243 VkStructureType sType; 4244 const void* pNext; 4245 VkBufferCreateFlags flags; 4246 VkBufferUsageFlags usage; 4247 VkExternalMemoryHandleTypeFlagBits handleType; 4248 } VkPhysicalDeviceExternalBufferInfo; 4249 4250 typedef struct VkExternalBufferProperties { 4251 VkStructureType sType; 4252 void* pNext; 4253 VkExternalMemoryProperties externalMemoryProperties; 4254 } VkExternalBufferProperties; 4255 4256 typedef struct VkPhysicalDeviceIDProperties { 4257 VkStructureType sType; 4258 void* pNext; 4259 uint8_t deviceUUID[VK_UUID_SIZE]; 4260 uint8_t driverUUID[VK_UUID_SIZE]; 4261 uint8_t deviceLUID[VK_LUID_SIZE]; 4262 uint32_t deviceNodeMask; 4263 VkBool32 deviceLUIDValid; 4264 } VkPhysicalDeviceIDProperties; 4265 4266 typedef struct VkExternalMemoryImageCreateInfo { 4267 VkStructureType sType; 4268 const void* pNext; 4269 VkExternalMemoryHandleTypeFlags handleTypes; 4270 } VkExternalMemoryImageCreateInfo; 4271 4272 typedef struct VkExternalMemoryBufferCreateInfo { 4273 VkStructureType sType; 4274 const void* pNext; 4275 VkExternalMemoryHandleTypeFlags handleTypes; 4276 } VkExternalMemoryBufferCreateInfo; 4277 4278 typedef struct VkExportMemoryAllocateInfo { 4279 VkStructureType sType; 4280 const void* pNext; 4281 VkExternalMemoryHandleTypeFlags handleTypes; 4282 } VkExportMemoryAllocateInfo; 4283 4284 typedef struct VkPhysicalDeviceExternalFenceInfo { 4285 VkStructureType sType; 4286 const void* pNext; 4287 VkExternalFenceHandleTypeFlagBits handleType; 4288 } VkPhysicalDeviceExternalFenceInfo; 4289 4290 typedef struct VkExternalFenceProperties { 4291 VkStructureType sType; 4292 void* pNext; 4293 VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes; 4294 VkExternalFenceHandleTypeFlags compatibleHandleTypes; 4295 VkExternalFenceFeatureFlags externalFenceFeatures; 4296 } VkExternalFenceProperties; 4297 4298 typedef struct VkExportFenceCreateInfo { 4299 VkStructureType sType; 4300 const void* pNext; 4301 VkExternalFenceHandleTypeFlags handleTypes; 4302 } VkExportFenceCreateInfo; 4303 4304 typedef struct VkExportSemaphoreCreateInfo { 4305 VkStructureType sType; 4306 const void* pNext; 4307 VkExternalSemaphoreHandleTypeFlags handleTypes; 4308 } VkExportSemaphoreCreateInfo; 4309 4310 typedef struct VkPhysicalDeviceExternalSemaphoreInfo { 4311 VkStructureType sType; 4312 const void* pNext; 4313 VkExternalSemaphoreHandleTypeFlagBits handleType; 4314 } VkPhysicalDeviceExternalSemaphoreInfo; 4315 4316 typedef struct VkExternalSemaphoreProperties { 4317 VkStructureType sType; 4318 void* pNext; 4319 VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes; 4320 VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes; 4321 VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures; 4322 } VkExternalSemaphoreProperties; 4323 4324 typedef struct VkPhysicalDeviceMaintenance3Properties { 4325 VkStructureType sType; 4326 void* pNext; 4327 uint32_t maxPerSetDescriptors; 4328 VkDeviceSize maxMemoryAllocationSize; 4329 } VkPhysicalDeviceMaintenance3Properties; 4330 4331 typedef struct VkDescriptorSetLayoutSupport { 4332 VkStructureType sType; 4333 void* pNext; 4334 VkBool32 supported; 4335 } VkDescriptorSetLayoutSupport; 4336 4337 typedef struct VkPhysicalDeviceShaderDrawParameterFeatures { 4338 VkStructureType sType; 4339 void* pNext; 4340 VkBool32 shaderDrawParameters; 4341 } VkPhysicalDeviceShaderDrawParameterFeatures; 4342 4343 4344 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceVersion)(uint32_t* pApiVersion); 4345 typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos); 4346 typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos); 4347 typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeatures)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); 4348 typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMask)(VkCommandBuffer commandBuffer, uint32_t deviceMask); 4349 typedef void (VKAPI_PTR *PFN_vkCmdDispatchBase)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); 4350 typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroups)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); 4351 typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2)(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); 4352 typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2)(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); 4353 typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements2)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); 4354 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures); 4355 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties); 4356 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties); 4357 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties); 4358 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties); 4359 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties); 4360 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties); 4361 typedef void (VKAPI_PTR *PFN_vkTrimCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags); 4362 typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue2)(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue); 4363 typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversion)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion); 4364 typedef void (VKAPI_PTR *PFN_vkDestroySamplerYcbcrConversion)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator); 4365 typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplate)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); 4366 typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplate)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator); 4367 typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplate)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData); 4368 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties); 4369 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFenceProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties); 4370 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphoreProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties); 4371 typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutSupport)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport); 4372 4373 #ifndef VK_NO_PROTOTYPES 4374 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceVersion( 4375 uint32_t* pApiVersion); 4376 4377 VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2( 4378 VkDevice device, 4379 uint32_t bindInfoCount, 4380 const VkBindBufferMemoryInfo* pBindInfos); 4381 4382 VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2( 4383 VkDevice device, 4384 uint32_t bindInfoCount, 4385 const VkBindImageMemoryInfo* pBindInfos); 4386 4387 VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeatures( 4388 VkDevice device, 4389 uint32_t heapIndex, 4390 uint32_t localDeviceIndex, 4391 uint32_t remoteDeviceIndex, 4392 VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); 4393 4394 VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMask( 4395 VkCommandBuffer commandBuffer, 4396 uint32_t deviceMask); 4397 4398 VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBase( 4399 VkCommandBuffer commandBuffer, 4400 uint32_t baseGroupX, 4401 uint32_t baseGroupY, 4402 uint32_t baseGroupZ, 4403 uint32_t groupCountX, 4404 uint32_t groupCountY, 4405 uint32_t groupCountZ); 4406 4407 VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroups( 4408 VkInstance instance, 4409 uint32_t* pPhysicalDeviceGroupCount, 4410 VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); 4411 4412 VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2( 4413 VkDevice device, 4414 const VkImageMemoryRequirementsInfo2* pInfo, 4415 VkMemoryRequirements2* pMemoryRequirements); 4416 4417 VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2( 4418 VkDevice device, 4419 const VkBufferMemoryRequirementsInfo2* pInfo, 4420 VkMemoryRequirements2* pMemoryRequirements); 4421 4422 VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2( 4423 VkDevice device, 4424 const VkImageSparseMemoryRequirementsInfo2* pInfo, 4425 uint32_t* pSparseMemoryRequirementCount, 4426 VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); 4427 4428 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2( 4429 VkPhysicalDevice physicalDevice, 4430 VkPhysicalDeviceFeatures2* pFeatures); 4431 4432 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2( 4433 VkPhysicalDevice physicalDevice, 4434 VkPhysicalDeviceProperties2* pProperties); 4435 4436 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2( 4437 VkPhysicalDevice physicalDevice, 4438 VkFormat format, 4439 VkFormatProperties2* pFormatProperties); 4440 4441 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2( 4442 VkPhysicalDevice physicalDevice, 4443 const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, 4444 VkImageFormatProperties2* pImageFormatProperties); 4445 4446 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2( 4447 VkPhysicalDevice physicalDevice, 4448 uint32_t* pQueueFamilyPropertyCount, 4449 VkQueueFamilyProperties2* pQueueFamilyProperties); 4450 4451 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2( 4452 VkPhysicalDevice physicalDevice, 4453 VkPhysicalDeviceMemoryProperties2* pMemoryProperties); 4454 4455 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2( 4456 VkPhysicalDevice physicalDevice, 4457 const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, 4458 uint32_t* pPropertyCount, 4459 VkSparseImageFormatProperties2* pProperties); 4460 4461 VKAPI_ATTR void VKAPI_CALL vkTrimCommandPool( 4462 VkDevice device, 4463 VkCommandPool commandPool, 4464 VkCommandPoolTrimFlags flags); 4465 4466 VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue2( 4467 VkDevice device, 4468 const VkDeviceQueueInfo2* pQueueInfo, 4469 VkQueue* pQueue); 4470 4471 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversion( 4472 VkDevice device, 4473 const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, 4474 const VkAllocationCallbacks* pAllocator, 4475 VkSamplerYcbcrConversion* pYcbcrConversion); 4476 4477 VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversion( 4478 VkDevice device, 4479 VkSamplerYcbcrConversion ycbcrConversion, 4480 const VkAllocationCallbacks* pAllocator); 4481 4482 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplate( 4483 VkDevice device, 4484 const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, 4485 const VkAllocationCallbacks* pAllocator, 4486 VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); 4487 4488 VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplate( 4489 VkDevice device, 4490 VkDescriptorUpdateTemplate descriptorUpdateTemplate, 4491 const VkAllocationCallbacks* pAllocator); 4492 4493 VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplate( 4494 VkDevice device, 4495 VkDescriptorSet descriptorSet, 4496 VkDescriptorUpdateTemplate descriptorUpdateTemplate, 4497 const void* pData); 4498 4499 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferProperties( 4500 VkPhysicalDevice physicalDevice, 4501 const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, 4502 VkExternalBufferProperties* pExternalBufferProperties); 4503 4504 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFenceProperties( 4505 VkPhysicalDevice physicalDevice, 4506 const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, 4507 VkExternalFenceProperties* pExternalFenceProperties); 4508 4509 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphoreProperties( 4510 VkPhysicalDevice physicalDevice, 4511 const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, 4512 VkExternalSemaphoreProperties* pExternalSemaphoreProperties); 4513 4514 VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupport( 4515 VkDevice device, 4516 const VkDescriptorSetLayoutCreateInfo* pCreateInfo, 4517 VkDescriptorSetLayoutSupport* pSupport); 4518 #endif 4519 4520 #define VK_KHR_surface 1 4521 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR) 4522 4523 #define VK_KHR_SURFACE_SPEC_VERSION 25 4524 #define VK_KHR_SURFACE_EXTENSION_NAME "VK_KHR_surface" 4525 #define VK_COLORSPACE_SRGB_NONLINEAR_KHR VK_COLOR_SPACE_SRGB_NONLINEAR_KHR 4526 4527 4528 typedef enum VkColorSpaceKHR { 4529 VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0, 4530 VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT = 1000104001, 4531 VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT = 1000104002, 4532 VK_COLOR_SPACE_DCI_P3_LINEAR_EXT = 1000104003, 4533 VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT = 1000104004, 4534 VK_COLOR_SPACE_BT709_LINEAR_EXT = 1000104005, 4535 VK_COLOR_SPACE_BT709_NONLINEAR_EXT = 1000104006, 4536 VK_COLOR_SPACE_BT2020_LINEAR_EXT = 1000104007, 4537 VK_COLOR_SPACE_HDR10_ST2084_EXT = 1000104008, 4538 VK_COLOR_SPACE_DOLBYVISION_EXT = 1000104009, 4539 VK_COLOR_SPACE_HDR10_HLG_EXT = 1000104010, 4540 VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT = 1000104011, 4541 VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT = 1000104012, 4542 VK_COLOR_SPACE_PASS_THROUGH_EXT = 1000104013, 4543 VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT = 1000104014, 4544 VK_COLOR_SPACE_BEGIN_RANGE_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, 4545 VK_COLOR_SPACE_END_RANGE_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, 4546 VK_COLOR_SPACE_RANGE_SIZE_KHR = (VK_COLOR_SPACE_SRGB_NONLINEAR_KHR - VK_COLOR_SPACE_SRGB_NONLINEAR_KHR + 1), 4547 VK_COLOR_SPACE_MAX_ENUM_KHR = 0x7FFFFFFF 4548 } VkColorSpaceKHR; 4549 4550 typedef enum VkPresentModeKHR { 4551 VK_PRESENT_MODE_IMMEDIATE_KHR = 0, 4552 VK_PRESENT_MODE_MAILBOX_KHR = 1, 4553 VK_PRESENT_MODE_FIFO_KHR = 2, 4554 VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3, 4555 VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR = 1000111000, 4556 VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR = 1000111001, 4557 VK_PRESENT_MODE_BEGIN_RANGE_KHR = VK_PRESENT_MODE_IMMEDIATE_KHR, 4558 VK_PRESENT_MODE_END_RANGE_KHR = VK_PRESENT_MODE_FIFO_RELAXED_KHR, 4559 VK_PRESENT_MODE_RANGE_SIZE_KHR = (VK_PRESENT_MODE_FIFO_RELAXED_KHR - VK_PRESENT_MODE_IMMEDIATE_KHR + 1), 4560 VK_PRESENT_MODE_MAX_ENUM_KHR = 0x7FFFFFFF 4561 } VkPresentModeKHR; 4562 4563 4564 typedef enum VkSurfaceTransformFlagBitsKHR { 4565 VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 0x00000001, 4566 VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 0x00000002, 4567 VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 0x00000004, 4568 VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 0x00000008, 4569 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 0x00000010, 4570 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 0x00000020, 4571 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 0x00000040, 4572 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 0x00000080, 4573 VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100, 4574 VK_SURFACE_TRANSFORM_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 4575 } VkSurfaceTransformFlagBitsKHR; 4576 typedef VkFlags VkSurfaceTransformFlagsKHR; 4577 4578 typedef enum VkCompositeAlphaFlagBitsKHR { 4579 VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, 4580 VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002, 4581 VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004, 4582 VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008, 4583 VK_COMPOSITE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 4584 } VkCompositeAlphaFlagBitsKHR; 4585 typedef VkFlags VkCompositeAlphaFlagsKHR; 4586 4587 typedef struct VkSurfaceCapabilitiesKHR { 4588 uint32_t minImageCount; 4589 uint32_t maxImageCount; 4590 VkExtent2D currentExtent; 4591 VkExtent2D minImageExtent; 4592 VkExtent2D maxImageExtent; 4593 uint32_t maxImageArrayLayers; 4594 VkSurfaceTransformFlagsKHR supportedTransforms; 4595 VkSurfaceTransformFlagBitsKHR currentTransform; 4596 VkCompositeAlphaFlagsKHR supportedCompositeAlpha; 4597 VkImageUsageFlags supportedUsageFlags; 4598 } VkSurfaceCapabilitiesKHR; 4599 4600 typedef struct VkSurfaceFormatKHR { 4601 VkFormat format; 4602 VkColorSpaceKHR colorSpace; 4603 } VkSurfaceFormatKHR; 4604 4605 4606 typedef void (VKAPI_PTR *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator); 4607 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported); 4608 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); 4609 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats); 4610 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes); 4611 4612 #ifndef VK_NO_PROTOTYPES 4613 VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR( 4614 VkInstance instance, 4615 VkSurfaceKHR surface, 4616 const VkAllocationCallbacks* pAllocator); 4617 4618 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR( 4619 VkPhysicalDevice physicalDevice, 4620 uint32_t queueFamilyIndex, 4621 VkSurfaceKHR surface, 4622 VkBool32* pSupported); 4623 4624 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR( 4625 VkPhysicalDevice physicalDevice, 4626 VkSurfaceKHR surface, 4627 VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); 4628 4629 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR( 4630 VkPhysicalDevice physicalDevice, 4631 VkSurfaceKHR surface, 4632 uint32_t* pSurfaceFormatCount, 4633 VkSurfaceFormatKHR* pSurfaceFormats); 4634 4635 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR( 4636 VkPhysicalDevice physicalDevice, 4637 VkSurfaceKHR surface, 4638 uint32_t* pPresentModeCount, 4639 VkPresentModeKHR* pPresentModes); 4640 #endif 4641 4642 #define VK_KHR_swapchain 1 4643 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR) 4644 4645 #define VK_KHR_SWAPCHAIN_SPEC_VERSION 70 4646 #define VK_KHR_SWAPCHAIN_EXTENSION_NAME "VK_KHR_swapchain" 4647 4648 4649 typedef enum VkSwapchainCreateFlagBitsKHR { 4650 VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = 0x00000001, 4651 VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR = 0x00000002, 4652 VK_SWAPCHAIN_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 4653 } VkSwapchainCreateFlagBitsKHR; 4654 typedef VkFlags VkSwapchainCreateFlagsKHR; 4655 4656 typedef enum VkDeviceGroupPresentModeFlagBitsKHR { 4657 VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR = 0x00000001, 4658 VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR = 0x00000002, 4659 VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR = 0x00000004, 4660 VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR = 0x00000008, 4661 VK_DEVICE_GROUP_PRESENT_MODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 4662 } VkDeviceGroupPresentModeFlagBitsKHR; 4663 typedef VkFlags VkDeviceGroupPresentModeFlagsKHR; 4664 4665 typedef struct VkSwapchainCreateInfoKHR { 4666 VkStructureType sType; 4667 const void* pNext; 4668 VkSwapchainCreateFlagsKHR flags; 4669 VkSurfaceKHR surface; 4670 uint32_t minImageCount; 4671 VkFormat imageFormat; 4672 VkColorSpaceKHR imageColorSpace; 4673 VkExtent2D imageExtent; 4674 uint32_t imageArrayLayers; 4675 VkImageUsageFlags imageUsage; 4676 VkSharingMode imageSharingMode; 4677 uint32_t queueFamilyIndexCount; 4678 const uint32_t* pQueueFamilyIndices; 4679 VkSurfaceTransformFlagBitsKHR preTransform; 4680 VkCompositeAlphaFlagBitsKHR compositeAlpha; 4681 VkPresentModeKHR presentMode; 4682 VkBool32 clipped; 4683 VkSwapchainKHR oldSwapchain; 4684 } VkSwapchainCreateInfoKHR; 4685 4686 typedef struct VkPresentInfoKHR { 4687 VkStructureType sType; 4688 const void* pNext; 4689 uint32_t waitSemaphoreCount; 4690 const VkSemaphore* pWaitSemaphores; 4691 uint32_t swapchainCount; 4692 const VkSwapchainKHR* pSwapchains; 4693 const uint32_t* pImageIndices; 4694 VkResult* pResults; 4695 } VkPresentInfoKHR; 4696 4697 typedef struct VkImageSwapchainCreateInfoKHR { 4698 VkStructureType sType; 4699 const void* pNext; 4700 VkSwapchainKHR swapchain; 4701 } VkImageSwapchainCreateInfoKHR; 4702 4703 typedef struct VkBindImageMemorySwapchainInfoKHR { 4704 VkStructureType sType; 4705 const void* pNext; 4706 VkSwapchainKHR swapchain; 4707 uint32_t imageIndex; 4708 } VkBindImageMemorySwapchainInfoKHR; 4709 4710 typedef struct VkAcquireNextImageInfoKHR { 4711 VkStructureType sType; 4712 const void* pNext; 4713 VkSwapchainKHR swapchain; 4714 uint64_t timeout; 4715 VkSemaphore semaphore; 4716 VkFence fence; 4717 uint32_t deviceMask; 4718 } VkAcquireNextImageInfoKHR; 4719 4720 typedef struct VkDeviceGroupPresentCapabilitiesKHR { 4721 VkStructureType sType; 4722 const void* pNext; 4723 uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE]; 4724 VkDeviceGroupPresentModeFlagsKHR modes; 4725 } VkDeviceGroupPresentCapabilitiesKHR; 4726 4727 typedef struct VkDeviceGroupPresentInfoKHR { 4728 VkStructureType sType; 4729 const void* pNext; 4730 uint32_t swapchainCount; 4731 const uint32_t* pDeviceMasks; 4732 VkDeviceGroupPresentModeFlagBitsKHR mode; 4733 } VkDeviceGroupPresentInfoKHR; 4734 4735 typedef struct VkDeviceGroupSwapchainCreateInfoKHR { 4736 VkStructureType sType; 4737 const void* pNext; 4738 VkDeviceGroupPresentModeFlagsKHR modes; 4739 } VkDeviceGroupSwapchainCreateInfoKHR; 4740 4741 4742 typedef VkResult (VKAPI_PTR *PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain); 4743 typedef void (VKAPI_PTR *PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator); 4744 typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages); 4745 typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex); 4746 typedef VkResult (VKAPI_PTR *PFN_vkQueuePresentKHR)(VkQueue queue, const VkPresentInfoKHR* pPresentInfo); 4747 typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupPresentCapabilitiesKHR)(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities); 4748 typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupSurfacePresentModesKHR)(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes); 4749 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDevicePresentRectanglesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects); 4750 typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImage2KHR)(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex); 4751 4752 #ifndef VK_NO_PROTOTYPES 4753 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR( 4754 VkDevice device, 4755 const VkSwapchainCreateInfoKHR* pCreateInfo, 4756 const VkAllocationCallbacks* pAllocator, 4757 VkSwapchainKHR* pSwapchain); 4758 4759 VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR( 4760 VkDevice device, 4761 VkSwapchainKHR swapchain, 4762 const VkAllocationCallbacks* pAllocator); 4763 4764 VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR( 4765 VkDevice device, 4766 VkSwapchainKHR swapchain, 4767 uint32_t* pSwapchainImageCount, 4768 VkImage* pSwapchainImages); 4769 4770 VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR( 4771 VkDevice device, 4772 VkSwapchainKHR swapchain, 4773 uint64_t timeout, 4774 VkSemaphore semaphore, 4775 VkFence fence, 4776 uint32_t* pImageIndex); 4777 4778 VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR( 4779 VkQueue queue, 4780 const VkPresentInfoKHR* pPresentInfo); 4781 4782 VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupPresentCapabilitiesKHR( 4783 VkDevice device, 4784 VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities); 4785 4786 VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModesKHR( 4787 VkDevice device, 4788 VkSurfaceKHR surface, 4789 VkDeviceGroupPresentModeFlagsKHR* pModes); 4790 4791 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDevicePresentRectanglesKHR( 4792 VkPhysicalDevice physicalDevice, 4793 VkSurfaceKHR surface, 4794 uint32_t* pRectCount, 4795 VkRect2D* pRects); 4796 4797 VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImage2KHR( 4798 VkDevice device, 4799 const VkAcquireNextImageInfoKHR* pAcquireInfo, 4800 uint32_t* pImageIndex); 4801 #endif 4802 4803 #define VK_KHR_display 1 4804 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR) 4805 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR) 4806 4807 #define VK_KHR_DISPLAY_SPEC_VERSION 21 4808 #define VK_KHR_DISPLAY_EXTENSION_NAME "VK_KHR_display" 4809 4810 4811 typedef enum VkDisplayPlaneAlphaFlagBitsKHR { 4812 VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, 4813 VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000002, 4814 VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000004, 4815 VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000008, 4816 VK_DISPLAY_PLANE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 4817 } VkDisplayPlaneAlphaFlagBitsKHR; 4818 typedef VkFlags VkDisplayPlaneAlphaFlagsKHR; 4819 typedef VkFlags VkDisplayModeCreateFlagsKHR; 4820 typedef VkFlags VkDisplaySurfaceCreateFlagsKHR; 4821 4822 typedef struct VkDisplayPropertiesKHR { 4823 VkDisplayKHR display; 4824 const char* displayName; 4825 VkExtent2D physicalDimensions; 4826 VkExtent2D physicalResolution; 4827 VkSurfaceTransformFlagsKHR supportedTransforms; 4828 VkBool32 planeReorderPossible; 4829 VkBool32 persistentContent; 4830 } VkDisplayPropertiesKHR; 4831 4832 typedef struct VkDisplayModeParametersKHR { 4833 VkExtent2D visibleRegion; 4834 uint32_t refreshRate; 4835 } VkDisplayModeParametersKHR; 4836 4837 typedef struct VkDisplayModePropertiesKHR { 4838 VkDisplayModeKHR displayMode; 4839 VkDisplayModeParametersKHR parameters; 4840 } VkDisplayModePropertiesKHR; 4841 4842 typedef struct VkDisplayModeCreateInfoKHR { 4843 VkStructureType sType; 4844 const void* pNext; 4845 VkDisplayModeCreateFlagsKHR flags; 4846 VkDisplayModeParametersKHR parameters; 4847 } VkDisplayModeCreateInfoKHR; 4848 4849 typedef struct VkDisplayPlaneCapabilitiesKHR { 4850 VkDisplayPlaneAlphaFlagsKHR supportedAlpha; 4851 VkOffset2D minSrcPosition; 4852 VkOffset2D maxSrcPosition; 4853 VkExtent2D minSrcExtent; 4854 VkExtent2D maxSrcExtent; 4855 VkOffset2D minDstPosition; 4856 VkOffset2D maxDstPosition; 4857 VkExtent2D minDstExtent; 4858 VkExtent2D maxDstExtent; 4859 } VkDisplayPlaneCapabilitiesKHR; 4860 4861 typedef struct VkDisplayPlanePropertiesKHR { 4862 VkDisplayKHR currentDisplay; 4863 uint32_t currentStackIndex; 4864 } VkDisplayPlanePropertiesKHR; 4865 4866 typedef struct VkDisplaySurfaceCreateInfoKHR { 4867 VkStructureType sType; 4868 const void* pNext; 4869 VkDisplaySurfaceCreateFlagsKHR flags; 4870 VkDisplayModeKHR displayMode; 4871 uint32_t planeIndex; 4872 uint32_t planeStackIndex; 4873 VkSurfaceTransformFlagBitsKHR transform; 4874 float globalAlpha; 4875 VkDisplayPlaneAlphaFlagBitsKHR alphaMode; 4876 VkExtent2D imageExtent; 4877 } VkDisplaySurfaceCreateInfoKHR; 4878 4879 4880 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties); 4881 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties); 4882 typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays); 4883 typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties); 4884 typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode); 4885 typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities); 4886 typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); 4887 4888 #ifndef VK_NO_PROTOTYPES 4889 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR( 4890 VkPhysicalDevice physicalDevice, 4891 uint32_t* pPropertyCount, 4892 VkDisplayPropertiesKHR* pProperties); 4893 4894 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR( 4895 VkPhysicalDevice physicalDevice, 4896 uint32_t* pPropertyCount, 4897 VkDisplayPlanePropertiesKHR* pProperties); 4898 4899 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR( 4900 VkPhysicalDevice physicalDevice, 4901 uint32_t planeIndex, 4902 uint32_t* pDisplayCount, 4903 VkDisplayKHR* pDisplays); 4904 4905 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR( 4906 VkPhysicalDevice physicalDevice, 4907 VkDisplayKHR display, 4908 uint32_t* pPropertyCount, 4909 VkDisplayModePropertiesKHR* pProperties); 4910 4911 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR( 4912 VkPhysicalDevice physicalDevice, 4913 VkDisplayKHR display, 4914 const VkDisplayModeCreateInfoKHR* pCreateInfo, 4915 const VkAllocationCallbacks* pAllocator, 4916 VkDisplayModeKHR* pMode); 4917 4918 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR( 4919 VkPhysicalDevice physicalDevice, 4920 VkDisplayModeKHR mode, 4921 uint32_t planeIndex, 4922 VkDisplayPlaneCapabilitiesKHR* pCapabilities); 4923 4924 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR( 4925 VkInstance instance, 4926 const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, 4927 const VkAllocationCallbacks* pAllocator, 4928 VkSurfaceKHR* pSurface); 4929 #endif 4930 4931 #define VK_KHR_display_swapchain 1 4932 #define VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION 9 4933 #define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain" 4934 4935 typedef struct VkDisplayPresentInfoKHR { 4936 VkStructureType sType; 4937 const void* pNext; 4938 VkRect2D srcRect; 4939 VkRect2D dstRect; 4940 VkBool32 persistent; 4941 } VkDisplayPresentInfoKHR; 4942 4943 4944 typedef VkResult (VKAPI_PTR *PFN_vkCreateSharedSwapchainsKHR)(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains); 4945 4946 #ifndef VK_NO_PROTOTYPES 4947 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR( 4948 VkDevice device, 4949 uint32_t swapchainCount, 4950 const VkSwapchainCreateInfoKHR* pCreateInfos, 4951 const VkAllocationCallbacks* pAllocator, 4952 VkSwapchainKHR* pSwapchains); 4953 #endif 4954 4955 #define VK_KHR_sampler_mirror_clamp_to_edge 1 4956 #define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION 1 4957 #define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME "VK_KHR_sampler_mirror_clamp_to_edge" 4958 4959 4960 #define VK_KHR_multiview 1 4961 #define VK_KHR_MULTIVIEW_SPEC_VERSION 1 4962 #define VK_KHR_MULTIVIEW_EXTENSION_NAME "VK_KHR_multiview" 4963 4964 typedef VkRenderPassMultiviewCreateInfo VkRenderPassMultiviewCreateInfoKHR; 4965 4966 typedef VkPhysicalDeviceMultiviewFeatures VkPhysicalDeviceMultiviewFeaturesKHR; 4967 4968 typedef VkPhysicalDeviceMultiviewProperties VkPhysicalDeviceMultiviewPropertiesKHR; 4969 4970 4971 4972 #define VK_KHR_get_physical_device_properties2 1 4973 #define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION 1 4974 #define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_physical_device_properties2" 4975 4976 typedef VkPhysicalDeviceFeatures2 VkPhysicalDeviceFeatures2KHR; 4977 4978 typedef VkPhysicalDeviceProperties2 VkPhysicalDeviceProperties2KHR; 4979 4980 typedef VkFormatProperties2 VkFormatProperties2KHR; 4981 4982 typedef VkImageFormatProperties2 VkImageFormatProperties2KHR; 4983 4984 typedef VkPhysicalDeviceImageFormatInfo2 VkPhysicalDeviceImageFormatInfo2KHR; 4985 4986 typedef VkQueueFamilyProperties2 VkQueueFamilyProperties2KHR; 4987 4988 typedef VkPhysicalDeviceMemoryProperties2 VkPhysicalDeviceMemoryProperties2KHR; 4989 4990 typedef VkSparseImageFormatProperties2 VkSparseImageFormatProperties2KHR; 4991 4992 typedef VkPhysicalDeviceSparseImageFormatInfo2 VkPhysicalDeviceSparseImageFormatInfo2KHR; 4993 4994 4995 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures); 4996 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties); 4997 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2KHR)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties); 4998 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties); 4999 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties); 5000 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties); 5001 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties); 5002 5003 #ifndef VK_NO_PROTOTYPES 5004 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2KHR( 5005 VkPhysicalDevice physicalDevice, 5006 VkPhysicalDeviceFeatures2* pFeatures); 5007 5008 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2KHR( 5009 VkPhysicalDevice physicalDevice, 5010 VkPhysicalDeviceProperties2* pProperties); 5011 5012 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2KHR( 5013 VkPhysicalDevice physicalDevice, 5014 VkFormat format, 5015 VkFormatProperties2* pFormatProperties); 5016 5017 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2KHR( 5018 VkPhysicalDevice physicalDevice, 5019 const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, 5020 VkImageFormatProperties2* pImageFormatProperties); 5021 5022 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2KHR( 5023 VkPhysicalDevice physicalDevice, 5024 uint32_t* pQueueFamilyPropertyCount, 5025 VkQueueFamilyProperties2* pQueueFamilyProperties); 5026 5027 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2KHR( 5028 VkPhysicalDevice physicalDevice, 5029 VkPhysicalDeviceMemoryProperties2* pMemoryProperties); 5030 5031 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2KHR( 5032 VkPhysicalDevice physicalDevice, 5033 const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, 5034 uint32_t* pPropertyCount, 5035 VkSparseImageFormatProperties2* pProperties); 5036 #endif 5037 5038 #define VK_KHR_device_group 1 5039 #define VK_KHR_DEVICE_GROUP_SPEC_VERSION 3 5040 #define VK_KHR_DEVICE_GROUP_EXTENSION_NAME "VK_KHR_device_group" 5041 5042 typedef VkPeerMemoryFeatureFlags VkPeerMemoryFeatureFlagsKHR; 5043 5044 typedef VkPeerMemoryFeatureFlagBits VkPeerMemoryFeatureFlagBitsKHR; 5045 5046 typedef VkMemoryAllocateFlags VkMemoryAllocateFlagsKHR; 5047 5048 typedef VkMemoryAllocateFlagBits VkMemoryAllocateFlagBitsKHR; 5049 5050 5051 typedef VkMemoryAllocateFlagsInfo VkMemoryAllocateFlagsInfoKHR; 5052 5053 typedef VkDeviceGroupRenderPassBeginInfo VkDeviceGroupRenderPassBeginInfoKHR; 5054 5055 typedef VkDeviceGroupCommandBufferBeginInfo VkDeviceGroupCommandBufferBeginInfoKHR; 5056 5057 typedef VkDeviceGroupSubmitInfo VkDeviceGroupSubmitInfoKHR; 5058 5059 typedef VkDeviceGroupBindSparseInfo VkDeviceGroupBindSparseInfoKHR; 5060 5061 typedef VkBindBufferMemoryDeviceGroupInfo VkBindBufferMemoryDeviceGroupInfoKHR; 5062 5063 typedef VkBindImageMemoryDeviceGroupInfo VkBindImageMemoryDeviceGroupInfoKHR; 5064 5065 5066 typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); 5067 typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMaskKHR)(VkCommandBuffer commandBuffer, uint32_t deviceMask); 5068 typedef void (VKAPI_PTR *PFN_vkCmdDispatchBaseKHR)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); 5069 5070 #ifndef VK_NO_PROTOTYPES 5071 VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeaturesKHR( 5072 VkDevice device, 5073 uint32_t heapIndex, 5074 uint32_t localDeviceIndex, 5075 uint32_t remoteDeviceIndex, 5076 VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); 5077 5078 VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMaskKHR( 5079 VkCommandBuffer commandBuffer, 5080 uint32_t deviceMask); 5081 5082 VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBaseKHR( 5083 VkCommandBuffer commandBuffer, 5084 uint32_t baseGroupX, 5085 uint32_t baseGroupY, 5086 uint32_t baseGroupZ, 5087 uint32_t groupCountX, 5088 uint32_t groupCountY, 5089 uint32_t groupCountZ); 5090 #endif 5091 5092 #define VK_KHR_shader_draw_parameters 1 5093 #define VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION 1 5094 #define VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME "VK_KHR_shader_draw_parameters" 5095 5096 5097 #define VK_KHR_maintenance1 1 5098 #define VK_KHR_MAINTENANCE1_SPEC_VERSION 1 5099 #define VK_KHR_MAINTENANCE1_EXTENSION_NAME "VK_KHR_maintenance1" 5100 5101 typedef VkCommandPoolTrimFlags VkCommandPoolTrimFlagsKHR; 5102 5103 5104 typedef void (VKAPI_PTR *PFN_vkTrimCommandPoolKHR)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags); 5105 5106 #ifndef VK_NO_PROTOTYPES 5107 VKAPI_ATTR void VKAPI_CALL vkTrimCommandPoolKHR( 5108 VkDevice device, 5109 VkCommandPool commandPool, 5110 VkCommandPoolTrimFlags flags); 5111 #endif 5112 5113 #define VK_KHR_device_group_creation 1 5114 #define VK_KHR_DEVICE_GROUP_CREATION_SPEC_VERSION 1 5115 #define VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME "VK_KHR_device_group_creation" 5116 #define VK_MAX_DEVICE_GROUP_SIZE_KHR VK_MAX_DEVICE_GROUP_SIZE 5117 5118 typedef VkPhysicalDeviceGroupProperties VkPhysicalDeviceGroupPropertiesKHR; 5119 5120 typedef VkDeviceGroupDeviceCreateInfo VkDeviceGroupDeviceCreateInfoKHR; 5121 5122 5123 typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroupsKHR)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); 5124 5125 #ifndef VK_NO_PROTOTYPES 5126 VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroupsKHR( 5127 VkInstance instance, 5128 uint32_t* pPhysicalDeviceGroupCount, 5129 VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); 5130 #endif 5131 5132 #define VK_KHR_external_memory_capabilities 1 5133 #define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1 5134 #define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_memory_capabilities" 5135 #define VK_LUID_SIZE_KHR VK_LUID_SIZE 5136 5137 typedef VkExternalMemoryHandleTypeFlags VkExternalMemoryHandleTypeFlagsKHR; 5138 5139 typedef VkExternalMemoryHandleTypeFlagBits VkExternalMemoryHandleTypeFlagBitsKHR; 5140 5141 typedef VkExternalMemoryFeatureFlags VkExternalMemoryFeatureFlagsKHR; 5142 5143 typedef VkExternalMemoryFeatureFlagBits VkExternalMemoryFeatureFlagBitsKHR; 5144 5145 5146 typedef VkExternalMemoryProperties VkExternalMemoryPropertiesKHR; 5147 5148 typedef VkPhysicalDeviceExternalImageFormatInfo VkPhysicalDeviceExternalImageFormatInfoKHR; 5149 5150 typedef VkExternalImageFormatProperties VkExternalImageFormatPropertiesKHR; 5151 5152 typedef VkPhysicalDeviceExternalBufferInfo VkPhysicalDeviceExternalBufferInfoKHR; 5153 5154 typedef VkExternalBufferProperties VkExternalBufferPropertiesKHR; 5155 5156 typedef VkPhysicalDeviceIDProperties VkPhysicalDeviceIDPropertiesKHR; 5157 5158 5159 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties); 5160 5161 #ifndef VK_NO_PROTOTYPES 5162 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferPropertiesKHR( 5163 VkPhysicalDevice physicalDevice, 5164 const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, 5165 VkExternalBufferProperties* pExternalBufferProperties); 5166 #endif 5167 5168 #define VK_KHR_external_memory 1 5169 #define VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION 1 5170 #define VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME "VK_KHR_external_memory" 5171 #define VK_QUEUE_FAMILY_EXTERNAL_KHR VK_QUEUE_FAMILY_EXTERNAL 5172 5173 typedef VkExternalMemoryImageCreateInfo VkExternalMemoryImageCreateInfoKHR; 5174 5175 typedef VkExternalMemoryBufferCreateInfo VkExternalMemoryBufferCreateInfoKHR; 5176 5177 typedef VkExportMemoryAllocateInfo VkExportMemoryAllocateInfoKHR; 5178 5179 5180 5181 #define VK_KHR_external_memory_fd 1 5182 #define VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION 1 5183 #define VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME "VK_KHR_external_memory_fd" 5184 5185 typedef struct VkImportMemoryFdInfoKHR { 5186 VkStructureType sType; 5187 const void* pNext; 5188 VkExternalMemoryHandleTypeFlagBits handleType; 5189 int fd; 5190 } VkImportMemoryFdInfoKHR; 5191 5192 typedef struct VkMemoryFdPropertiesKHR { 5193 VkStructureType sType; 5194 void* pNext; 5195 uint32_t memoryTypeBits; 5196 } VkMemoryFdPropertiesKHR; 5197 5198 typedef struct VkMemoryGetFdInfoKHR { 5199 VkStructureType sType; 5200 const void* pNext; 5201 VkDeviceMemory memory; 5202 VkExternalMemoryHandleTypeFlagBits handleType; 5203 } VkMemoryGetFdInfoKHR; 5204 5205 5206 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdKHR)(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd); 5207 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdPropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties); 5208 5209 #ifndef VK_NO_PROTOTYPES 5210 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdKHR( 5211 VkDevice device, 5212 const VkMemoryGetFdInfoKHR* pGetFdInfo, 5213 int* pFd); 5214 5215 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdPropertiesKHR( 5216 VkDevice device, 5217 VkExternalMemoryHandleTypeFlagBits handleType, 5218 int fd, 5219 VkMemoryFdPropertiesKHR* pMemoryFdProperties); 5220 #endif 5221 5222 #define VK_KHR_external_semaphore_capabilities 1 5223 #define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION 1 5224 #define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_semaphore_capabilities" 5225 5226 typedef VkExternalSemaphoreHandleTypeFlags VkExternalSemaphoreHandleTypeFlagsKHR; 5227 5228 typedef VkExternalSemaphoreHandleTypeFlagBits VkExternalSemaphoreHandleTypeFlagBitsKHR; 5229 5230 typedef VkExternalSemaphoreFeatureFlags VkExternalSemaphoreFeatureFlagsKHR; 5231 5232 typedef VkExternalSemaphoreFeatureFlagBits VkExternalSemaphoreFeatureFlagBitsKHR; 5233 5234 5235 typedef VkPhysicalDeviceExternalSemaphoreInfo VkPhysicalDeviceExternalSemaphoreInfoKHR; 5236 5237 typedef VkExternalSemaphoreProperties VkExternalSemaphorePropertiesKHR; 5238 5239 5240 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties); 5241 5242 #ifndef VK_NO_PROTOTYPES 5243 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( 5244 VkPhysicalDevice physicalDevice, 5245 const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, 5246 VkExternalSemaphoreProperties* pExternalSemaphoreProperties); 5247 #endif 5248 5249 #define VK_KHR_external_semaphore 1 5250 #define VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION 1 5251 #define VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME "VK_KHR_external_semaphore" 5252 5253 typedef VkSemaphoreImportFlags VkSemaphoreImportFlagsKHR; 5254 5255 typedef VkSemaphoreImportFlagBits VkSemaphoreImportFlagBitsKHR; 5256 5257 5258 typedef VkExportSemaphoreCreateInfo VkExportSemaphoreCreateInfoKHR; 5259 5260 5261 5262 #define VK_KHR_external_semaphore_fd 1 5263 #define VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION 1 5264 #define VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME "VK_KHR_external_semaphore_fd" 5265 5266 typedef struct VkImportSemaphoreFdInfoKHR { 5267 VkStructureType sType; 5268 const void* pNext; 5269 VkSemaphore semaphore; 5270 VkSemaphoreImportFlags flags; 5271 VkExternalSemaphoreHandleTypeFlagBits handleType; 5272 int fd; 5273 } VkImportSemaphoreFdInfoKHR; 5274 5275 typedef struct VkSemaphoreGetFdInfoKHR { 5276 VkStructureType sType; 5277 const void* pNext; 5278 VkSemaphore semaphore; 5279 VkExternalSemaphoreHandleTypeFlagBits handleType; 5280 } VkSemaphoreGetFdInfoKHR; 5281 5282 5283 typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreFdKHR)(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo); 5284 typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreFdKHR)(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd); 5285 5286 #ifndef VK_NO_PROTOTYPES 5287 VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreFdKHR( 5288 VkDevice device, 5289 const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo); 5290 5291 VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreFdKHR( 5292 VkDevice device, 5293 const VkSemaphoreGetFdInfoKHR* pGetFdInfo, 5294 int* pFd); 5295 #endif 5296 5297 #define VK_KHR_push_descriptor 1 5298 #define VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION 2 5299 #define VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME "VK_KHR_push_descriptor" 5300 5301 typedef struct VkPhysicalDevicePushDescriptorPropertiesKHR { 5302 VkStructureType sType; 5303 void* pNext; 5304 uint32_t maxPushDescriptors; 5305 } VkPhysicalDevicePushDescriptorPropertiesKHR; 5306 5307 5308 typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetKHR)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites); 5309 typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetWithTemplateKHR)(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData); 5310 5311 #ifndef VK_NO_PROTOTYPES 5312 VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetKHR( 5313 VkCommandBuffer commandBuffer, 5314 VkPipelineBindPoint pipelineBindPoint, 5315 VkPipelineLayout layout, 5316 uint32_t set, 5317 uint32_t descriptorWriteCount, 5318 const VkWriteDescriptorSet* pDescriptorWrites); 5319 5320 VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplateKHR( 5321 VkCommandBuffer commandBuffer, 5322 VkDescriptorUpdateTemplate descriptorUpdateTemplate, 5323 VkPipelineLayout layout, 5324 uint32_t set, 5325 const void* pData); 5326 #endif 5327 5328 #define VK_KHR_16bit_storage 1 5329 #define VK_KHR_16BIT_STORAGE_SPEC_VERSION 1 5330 #define VK_KHR_16BIT_STORAGE_EXTENSION_NAME "VK_KHR_16bit_storage" 5331 5332 typedef VkPhysicalDevice16BitStorageFeatures VkPhysicalDevice16BitStorageFeaturesKHR; 5333 5334 5335 5336 #define VK_KHR_incremental_present 1 5337 #define VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION 1 5338 #define VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME "VK_KHR_incremental_present" 5339 5340 typedef struct VkRectLayerKHR { 5341 VkOffset2D offset; 5342 VkExtent2D extent; 5343 uint32_t layer; 5344 } VkRectLayerKHR; 5345 5346 typedef struct VkPresentRegionKHR { 5347 uint32_t rectangleCount; 5348 const VkRectLayerKHR* pRectangles; 5349 } VkPresentRegionKHR; 5350 5351 typedef struct VkPresentRegionsKHR { 5352 VkStructureType sType; 5353 const void* pNext; 5354 uint32_t swapchainCount; 5355 const VkPresentRegionKHR* pRegions; 5356 } VkPresentRegionsKHR; 5357 5358 5359 5360 #define VK_KHR_descriptor_update_template 1 5361 typedef VkDescriptorUpdateTemplate VkDescriptorUpdateTemplateKHR; 5362 5363 5364 #define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION 1 5365 #define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME "VK_KHR_descriptor_update_template" 5366 5367 typedef VkDescriptorUpdateTemplateType VkDescriptorUpdateTemplateTypeKHR; 5368 5369 5370 typedef VkDescriptorUpdateTemplateCreateFlags VkDescriptorUpdateTemplateCreateFlagsKHR; 5371 5372 5373 typedef VkDescriptorUpdateTemplateEntry VkDescriptorUpdateTemplateEntryKHR; 5374 5375 typedef VkDescriptorUpdateTemplateCreateInfo VkDescriptorUpdateTemplateCreateInfoKHR; 5376 5377 5378 typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplateKHR)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); 5379 typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplateKHR)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator); 5380 typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplateKHR)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData); 5381 5382 #ifndef VK_NO_PROTOTYPES 5383 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplateKHR( 5384 VkDevice device, 5385 const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, 5386 const VkAllocationCallbacks* pAllocator, 5387 VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); 5388 5389 VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplateKHR( 5390 VkDevice device, 5391 VkDescriptorUpdateTemplate descriptorUpdateTemplate, 5392 const VkAllocationCallbacks* pAllocator); 5393 5394 VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplateKHR( 5395 VkDevice device, 5396 VkDescriptorSet descriptorSet, 5397 VkDescriptorUpdateTemplate descriptorUpdateTemplate, 5398 const void* pData); 5399 #endif 5400 5401 #define VK_KHR_shared_presentable_image 1 5402 #define VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION 1 5403 #define VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME "VK_KHR_shared_presentable_image" 5404 5405 typedef struct VkSharedPresentSurfaceCapabilitiesKHR { 5406 VkStructureType sType; 5407 void* pNext; 5408 VkImageUsageFlags sharedPresentSupportedUsageFlags; 5409 } VkSharedPresentSurfaceCapabilitiesKHR; 5410 5411 5412 typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainStatusKHR)(VkDevice device, VkSwapchainKHR swapchain); 5413 5414 #ifndef VK_NO_PROTOTYPES 5415 VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainStatusKHR( 5416 VkDevice device, 5417 VkSwapchainKHR swapchain); 5418 #endif 5419 5420 #define VK_KHR_external_fence_capabilities 1 5421 #define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION 1 5422 #define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_fence_capabilities" 5423 5424 typedef VkExternalFenceHandleTypeFlags VkExternalFenceHandleTypeFlagsKHR; 5425 5426 typedef VkExternalFenceHandleTypeFlagBits VkExternalFenceHandleTypeFlagBitsKHR; 5427 5428 typedef VkExternalFenceFeatureFlags VkExternalFenceFeatureFlagsKHR; 5429 5430 typedef VkExternalFenceFeatureFlagBits VkExternalFenceFeatureFlagBitsKHR; 5431 5432 5433 typedef VkPhysicalDeviceExternalFenceInfo VkPhysicalDeviceExternalFenceInfoKHR; 5434 5435 typedef VkExternalFenceProperties VkExternalFencePropertiesKHR; 5436 5437 5438 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties); 5439 5440 #ifndef VK_NO_PROTOTYPES 5441 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFencePropertiesKHR( 5442 VkPhysicalDevice physicalDevice, 5443 const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, 5444 VkExternalFenceProperties* pExternalFenceProperties); 5445 #endif 5446 5447 #define VK_KHR_external_fence 1 5448 #define VK_KHR_EXTERNAL_FENCE_SPEC_VERSION 1 5449 #define VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME "VK_KHR_external_fence" 5450 5451 typedef VkFenceImportFlags VkFenceImportFlagsKHR; 5452 5453 typedef VkFenceImportFlagBits VkFenceImportFlagBitsKHR; 5454 5455 5456 typedef VkExportFenceCreateInfo VkExportFenceCreateInfoKHR; 5457 5458 5459 5460 #define VK_KHR_external_fence_fd 1 5461 #define VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION 1 5462 #define VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME "VK_KHR_external_fence_fd" 5463 5464 typedef struct VkImportFenceFdInfoKHR { 5465 VkStructureType sType; 5466 const void* pNext; 5467 VkFence fence; 5468 VkFenceImportFlags flags; 5469 VkExternalFenceHandleTypeFlagBits handleType; 5470 int fd; 5471 } VkImportFenceFdInfoKHR; 5472 5473 typedef struct VkFenceGetFdInfoKHR { 5474 VkStructureType sType; 5475 const void* pNext; 5476 VkFence fence; 5477 VkExternalFenceHandleTypeFlagBits handleType; 5478 } VkFenceGetFdInfoKHR; 5479 5480 5481 typedef VkResult (VKAPI_PTR *PFN_vkImportFenceFdKHR)(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo); 5482 typedef VkResult (VKAPI_PTR *PFN_vkGetFenceFdKHR)(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd); 5483 5484 #ifndef VK_NO_PROTOTYPES 5485 VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceFdKHR( 5486 VkDevice device, 5487 const VkImportFenceFdInfoKHR* pImportFenceFdInfo); 5488 5489 VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceFdKHR( 5490 VkDevice device, 5491 const VkFenceGetFdInfoKHR* pGetFdInfo, 5492 int* pFd); 5493 #endif 5494 5495 #define VK_KHR_maintenance2 1 5496 #define VK_KHR_MAINTENANCE2_SPEC_VERSION 1 5497 #define VK_KHR_MAINTENANCE2_EXTENSION_NAME "VK_KHR_maintenance2" 5498 5499 typedef VkPointClippingBehavior VkPointClippingBehaviorKHR; 5500 5501 typedef VkTessellationDomainOrigin VkTessellationDomainOriginKHR; 5502 5503 5504 typedef VkPhysicalDevicePointClippingProperties VkPhysicalDevicePointClippingPropertiesKHR; 5505 5506 typedef VkRenderPassInputAttachmentAspectCreateInfo VkRenderPassInputAttachmentAspectCreateInfoKHR; 5507 5508 typedef VkInputAttachmentAspectReference VkInputAttachmentAspectReferenceKHR; 5509 5510 typedef VkImageViewUsageCreateInfo VkImageViewUsageCreateInfoKHR; 5511 5512 typedef VkPipelineTessellationDomainOriginStateCreateInfo VkPipelineTessellationDomainOriginStateCreateInfoKHR; 5513 5514 5515 5516 #define VK_KHR_get_surface_capabilities2 1 5517 #define VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION 1 5518 #define VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME "VK_KHR_get_surface_capabilities2" 5519 5520 typedef struct VkPhysicalDeviceSurfaceInfo2KHR { 5521 VkStructureType sType; 5522 const void* pNext; 5523 VkSurfaceKHR surface; 5524 } VkPhysicalDeviceSurfaceInfo2KHR; 5525 5526 typedef struct VkSurfaceCapabilities2KHR { 5527 VkStructureType sType; 5528 void* pNext; 5529 VkSurfaceCapabilitiesKHR surfaceCapabilities; 5530 } VkSurfaceCapabilities2KHR; 5531 5532 typedef struct VkSurfaceFormat2KHR { 5533 VkStructureType sType; 5534 void* pNext; 5535 VkSurfaceFormatKHR surfaceFormat; 5536 } VkSurfaceFormat2KHR; 5537 5538 5539 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities); 5540 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormats2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats); 5541 5542 #ifndef VK_NO_PROTOTYPES 5543 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2KHR( 5544 VkPhysicalDevice physicalDevice, 5545 const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, 5546 VkSurfaceCapabilities2KHR* pSurfaceCapabilities); 5547 5548 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormats2KHR( 5549 VkPhysicalDevice physicalDevice, 5550 const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, 5551 uint32_t* pSurfaceFormatCount, 5552 VkSurfaceFormat2KHR* pSurfaceFormats); 5553 #endif 5554 5555 #define VK_KHR_variable_pointers 1 5556 #define VK_KHR_VARIABLE_POINTERS_SPEC_VERSION 1 5557 #define VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME "VK_KHR_variable_pointers" 5558 5559 typedef VkPhysicalDeviceVariablePointerFeatures VkPhysicalDeviceVariablePointerFeaturesKHR; 5560 5561 5562 5563 #define VK_KHR_dedicated_allocation 1 5564 #define VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION 3 5565 #define VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_KHR_dedicated_allocation" 5566 5567 typedef VkMemoryDedicatedRequirements VkMemoryDedicatedRequirementsKHR; 5568 5569 typedef VkMemoryDedicatedAllocateInfo VkMemoryDedicatedAllocateInfoKHR; 5570 5571 5572 5573 #define VK_KHR_storage_buffer_storage_class 1 5574 #define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION 1 5575 #define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME "VK_KHR_storage_buffer_storage_class" 5576 5577 5578 #define VK_KHR_relaxed_block_layout 1 5579 #define VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION 1 5580 #define VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME "VK_KHR_relaxed_block_layout" 5581 5582 5583 #define VK_KHR_get_memory_requirements2 1 5584 #define VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION 1 5585 #define VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME "VK_KHR_get_memory_requirements2" 5586 5587 typedef VkBufferMemoryRequirementsInfo2 VkBufferMemoryRequirementsInfo2KHR; 5588 5589 typedef VkImageMemoryRequirementsInfo2 VkImageMemoryRequirementsInfo2KHR; 5590 5591 typedef VkImageSparseMemoryRequirementsInfo2 VkImageSparseMemoryRequirementsInfo2KHR; 5592 5593 typedef VkMemoryRequirements2 VkMemoryRequirements2KHR; 5594 5595 typedef VkSparseImageMemoryRequirements2 VkSparseImageMemoryRequirements2KHR; 5596 5597 5598 typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2KHR)(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); 5599 typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2KHR)(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); 5600 typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements2KHR)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); 5601 5602 #ifndef VK_NO_PROTOTYPES 5603 VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2KHR( 5604 VkDevice device, 5605 const VkImageMemoryRequirementsInfo2* pInfo, 5606 VkMemoryRequirements2* pMemoryRequirements); 5607 5608 VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2KHR( 5609 VkDevice device, 5610 const VkBufferMemoryRequirementsInfo2* pInfo, 5611 VkMemoryRequirements2* pMemoryRequirements); 5612 5613 VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2KHR( 5614 VkDevice device, 5615 const VkImageSparseMemoryRequirementsInfo2* pInfo, 5616 uint32_t* pSparseMemoryRequirementCount, 5617 VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); 5618 #endif 5619 5620 #define VK_KHR_image_format_list 1 5621 #define VK_KHR_IMAGE_FORMAT_LIST_SPEC_VERSION 1 5622 #define VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME "VK_KHR_image_format_list" 5623 5624 typedef struct VkImageFormatListCreateInfoKHR { 5625 VkStructureType sType; 5626 const void* pNext; 5627 uint32_t viewFormatCount; 5628 const VkFormat* pViewFormats; 5629 } VkImageFormatListCreateInfoKHR; 5630 5631 5632 5633 #define VK_KHR_sampler_ycbcr_conversion 1 5634 typedef VkSamplerYcbcrConversion VkSamplerYcbcrConversionKHR; 5635 5636 5637 #define VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION 1 5638 #define VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME "VK_KHR_sampler_ycbcr_conversion" 5639 5640 typedef VkSamplerYcbcrModelConversion VkSamplerYcbcrModelConversionKHR; 5641 5642 typedef VkSamplerYcbcrRange VkSamplerYcbcrRangeKHR; 5643 5644 typedef VkChromaLocation VkChromaLocationKHR; 5645 5646 5647 typedef VkSamplerYcbcrConversionCreateInfo VkSamplerYcbcrConversionCreateInfoKHR; 5648 5649 typedef VkSamplerYcbcrConversionInfo VkSamplerYcbcrConversionInfoKHR; 5650 5651 typedef VkBindImagePlaneMemoryInfo VkBindImagePlaneMemoryInfoKHR; 5652 5653 typedef VkImagePlaneMemoryRequirementsInfo VkImagePlaneMemoryRequirementsInfoKHR; 5654 5655 typedef VkPhysicalDeviceSamplerYcbcrConversionFeatures VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR; 5656 5657 typedef VkSamplerYcbcrConversionImageFormatProperties VkSamplerYcbcrConversionImageFormatPropertiesKHR; 5658 5659 5660 typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversionKHR)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion); 5661 typedef void (VKAPI_PTR *PFN_vkDestroySamplerYcbcrConversionKHR)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator); 5662 5663 #ifndef VK_NO_PROTOTYPES 5664 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversionKHR( 5665 VkDevice device, 5666 const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, 5667 const VkAllocationCallbacks* pAllocator, 5668 VkSamplerYcbcrConversion* pYcbcrConversion); 5669 5670 VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversionKHR( 5671 VkDevice device, 5672 VkSamplerYcbcrConversion ycbcrConversion, 5673 const VkAllocationCallbacks* pAllocator); 5674 #endif 5675 5676 #define VK_KHR_bind_memory2 1 5677 #define VK_KHR_BIND_MEMORY_2_SPEC_VERSION 1 5678 #define VK_KHR_BIND_MEMORY_2_EXTENSION_NAME "VK_KHR_bind_memory2" 5679 5680 typedef VkBindBufferMemoryInfo VkBindBufferMemoryInfoKHR; 5681 5682 typedef VkBindImageMemoryInfo VkBindImageMemoryInfoKHR; 5683 5684 5685 typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos); 5686 typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos); 5687 5688 #ifndef VK_NO_PROTOTYPES 5689 VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2KHR( 5690 VkDevice device, 5691 uint32_t bindInfoCount, 5692 const VkBindBufferMemoryInfo* pBindInfos); 5693 5694 VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2KHR( 5695 VkDevice device, 5696 uint32_t bindInfoCount, 5697 const VkBindImageMemoryInfo* pBindInfos); 5698 #endif 5699 5700 #define VK_KHR_maintenance3 1 5701 #define VK_KHR_MAINTENANCE3_SPEC_VERSION 1 5702 #define VK_KHR_MAINTENANCE3_EXTENSION_NAME "VK_KHR_maintenance3" 5703 5704 typedef VkPhysicalDeviceMaintenance3Properties VkPhysicalDeviceMaintenance3PropertiesKHR; 5705 5706 typedef VkDescriptorSetLayoutSupport VkDescriptorSetLayoutSupportKHR; 5707 5708 5709 typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutSupportKHR)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport); 5710 5711 #ifndef VK_NO_PROTOTYPES 5712 VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupportKHR( 5713 VkDevice device, 5714 const VkDescriptorSetLayoutCreateInfo* pCreateInfo, 5715 VkDescriptorSetLayoutSupport* pSupport); 5716 #endif 5717 5718 #define VK_EXT_debug_report 1 5719 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT) 5720 5721 #define VK_EXT_DEBUG_REPORT_SPEC_VERSION 9 5722 #define VK_EXT_DEBUG_REPORT_EXTENSION_NAME "VK_EXT_debug_report" 5723 #define VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT 5724 #define VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT 5725 5726 5727 typedef enum VkDebugReportObjectTypeEXT { 5728 VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0, 5729 VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1, 5730 VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2, 5731 VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3, 5732 VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4, 5733 VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5, 5734 VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6, 5735 VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7, 5736 VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8, 5737 VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9, 5738 VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10, 5739 VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11, 5740 VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12, 5741 VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13, 5742 VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14, 5743 VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15, 5744 VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16, 5745 VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17, 5746 VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18, 5747 VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19, 5748 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20, 5749 VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21, 5750 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22, 5751 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23, 5752 VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24, 5753 VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25, 5754 VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26, 5755 VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27, 5756 VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT = 28, 5757 VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT = 29, 5758 VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT = 30, 5759 VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT = 31, 5760 VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT = 32, 5761 VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT = 33, 5762 VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT = 1000156000, 5763 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT = 1000085000, 5764 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT, 5765 VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT, 5766 VK_DEBUG_REPORT_OBJECT_TYPE_BEGIN_RANGE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 5767 VK_DEBUG_REPORT_OBJECT_TYPE_END_RANGE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT, 5768 VK_DEBUG_REPORT_OBJECT_TYPE_RANGE_SIZE_EXT = (VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT - VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT + 1), 5769 VK_DEBUG_REPORT_OBJECT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF 5770 } VkDebugReportObjectTypeEXT; 5771 5772 5773 typedef enum VkDebugReportFlagBitsEXT { 5774 VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 0x00000001, 5775 VK_DEBUG_REPORT_WARNING_BIT_EXT = 0x00000002, 5776 VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 0x00000004, 5777 VK_DEBUG_REPORT_ERROR_BIT_EXT = 0x00000008, 5778 VK_DEBUG_REPORT_DEBUG_BIT_EXT = 0x00000010, 5779 VK_DEBUG_REPORT_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF 5780 } VkDebugReportFlagBitsEXT; 5781 typedef VkFlags VkDebugReportFlagsEXT; 5782 5783 typedef VkBool32 (VKAPI_PTR *PFN_vkDebugReportCallbackEXT)( 5784 VkDebugReportFlagsEXT flags, 5785 VkDebugReportObjectTypeEXT objectType, 5786 uint64_t object, 5787 size_t location, 5788 int32_t messageCode, 5789 const char* pLayerPrefix, 5790 const char* pMessage, 5791 void* pUserData); 5792 5793 typedef struct VkDebugReportCallbackCreateInfoEXT { 5794 VkStructureType sType; 5795 const void* pNext; 5796 VkDebugReportFlagsEXT flags; 5797 PFN_vkDebugReportCallbackEXT pfnCallback; 5798 void* pUserData; 5799 } VkDebugReportCallbackCreateInfoEXT; 5800 5801 5802 typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugReportCallbackEXT)(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback); 5803 typedef void (VKAPI_PTR *PFN_vkDestroyDebugReportCallbackEXT)(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator); 5804 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); 5805 5806 #ifndef VK_NO_PROTOTYPES 5807 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT( 5808 VkInstance instance, 5809 const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, 5810 const VkAllocationCallbacks* pAllocator, 5811 VkDebugReportCallbackEXT* pCallback); 5812 5813 VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT( 5814 VkInstance instance, 5815 VkDebugReportCallbackEXT callback, 5816 const VkAllocationCallbacks* pAllocator); 5817 5818 VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT( 5819 VkInstance instance, 5820 VkDebugReportFlagsEXT flags, 5821 VkDebugReportObjectTypeEXT objectType, 5822 uint64_t object, 5823 size_t location, 5824 int32_t messageCode, 5825 const char* pLayerPrefix, 5826 const char* pMessage); 5827 #endif 5828 5829 #define VK_NV_glsl_shader 1 5830 #define VK_NV_GLSL_SHADER_SPEC_VERSION 1 5831 #define VK_NV_GLSL_SHADER_EXTENSION_NAME "VK_NV_glsl_shader" 5832 5833 5834 #define VK_EXT_depth_range_unrestricted 1 5835 #define VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION 1 5836 #define VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME "VK_EXT_depth_range_unrestricted" 5837 5838 5839 #define VK_IMG_filter_cubic 1 5840 #define VK_IMG_FILTER_CUBIC_SPEC_VERSION 1 5841 #define VK_IMG_FILTER_CUBIC_EXTENSION_NAME "VK_IMG_filter_cubic" 5842 5843 5844 #define VK_AMD_rasterization_order 1 5845 #define VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION 1 5846 #define VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME "VK_AMD_rasterization_order" 5847 5848 5849 typedef enum VkRasterizationOrderAMD { 5850 VK_RASTERIZATION_ORDER_STRICT_AMD = 0, 5851 VK_RASTERIZATION_ORDER_RELAXED_AMD = 1, 5852 VK_RASTERIZATION_ORDER_BEGIN_RANGE_AMD = VK_RASTERIZATION_ORDER_STRICT_AMD, 5853 VK_RASTERIZATION_ORDER_END_RANGE_AMD = VK_RASTERIZATION_ORDER_RELAXED_AMD, 5854 VK_RASTERIZATION_ORDER_RANGE_SIZE_AMD = (VK_RASTERIZATION_ORDER_RELAXED_AMD - VK_RASTERIZATION_ORDER_STRICT_AMD + 1), 5855 VK_RASTERIZATION_ORDER_MAX_ENUM_AMD = 0x7FFFFFFF 5856 } VkRasterizationOrderAMD; 5857 5858 typedef struct VkPipelineRasterizationStateRasterizationOrderAMD { 5859 VkStructureType sType; 5860 const void* pNext; 5861 VkRasterizationOrderAMD rasterizationOrder; 5862 } VkPipelineRasterizationStateRasterizationOrderAMD; 5863 5864 5865 5866 #define VK_AMD_shader_trinary_minmax 1 5867 #define VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION 1 5868 #define VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME "VK_AMD_shader_trinary_minmax" 5869 5870 5871 #define VK_AMD_shader_explicit_vertex_parameter 1 5872 #define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION 1 5873 #define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME "VK_AMD_shader_explicit_vertex_parameter" 5874 5875 5876 #define VK_EXT_debug_marker 1 5877 #define VK_EXT_DEBUG_MARKER_SPEC_VERSION 4 5878 #define VK_EXT_DEBUG_MARKER_EXTENSION_NAME "VK_EXT_debug_marker" 5879 5880 typedef struct VkDebugMarkerObjectNameInfoEXT { 5881 VkStructureType sType; 5882 const void* pNext; 5883 VkDebugReportObjectTypeEXT objectType; 5884 uint64_t object; 5885 const char* pObjectName; 5886 } VkDebugMarkerObjectNameInfoEXT; 5887 5888 typedef struct VkDebugMarkerObjectTagInfoEXT { 5889 VkStructureType sType; 5890 const void* pNext; 5891 VkDebugReportObjectTypeEXT objectType; 5892 uint64_t object; 5893 uint64_t tagName; 5894 size_t tagSize; 5895 const void* pTag; 5896 } VkDebugMarkerObjectTagInfoEXT; 5897 5898 typedef struct VkDebugMarkerMarkerInfoEXT { 5899 VkStructureType sType; 5900 const void* pNext; 5901 const char* pMarkerName; 5902 float color[4]; 5903 } VkDebugMarkerMarkerInfoEXT; 5904 5905 5906 typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectTagEXT)(VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo); 5907 typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectNameEXT)(VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo); 5908 typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerBeginEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); 5909 typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerEndEXT)(VkCommandBuffer commandBuffer); 5910 typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerInsertEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); 5911 5912 #ifndef VK_NO_PROTOTYPES 5913 VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectTagEXT( 5914 VkDevice device, 5915 const VkDebugMarkerObjectTagInfoEXT* pTagInfo); 5916 5917 VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectNameEXT( 5918 VkDevice device, 5919 const VkDebugMarkerObjectNameInfoEXT* pNameInfo); 5920 5921 VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerBeginEXT( 5922 VkCommandBuffer commandBuffer, 5923 const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); 5924 5925 VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerEndEXT( 5926 VkCommandBuffer commandBuffer); 5927 5928 VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerInsertEXT( 5929 VkCommandBuffer commandBuffer, 5930 const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); 5931 #endif 5932 5933 #define VK_AMD_gcn_shader 1 5934 #define VK_AMD_GCN_SHADER_SPEC_VERSION 1 5935 #define VK_AMD_GCN_SHADER_EXTENSION_NAME "VK_AMD_gcn_shader" 5936 5937 5938 #define VK_NV_dedicated_allocation 1 5939 #define VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION 1 5940 #define VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_NV_dedicated_allocation" 5941 5942 typedef struct VkDedicatedAllocationImageCreateInfoNV { 5943 VkStructureType sType; 5944 const void* pNext; 5945 VkBool32 dedicatedAllocation; 5946 } VkDedicatedAllocationImageCreateInfoNV; 5947 5948 typedef struct VkDedicatedAllocationBufferCreateInfoNV { 5949 VkStructureType sType; 5950 const void* pNext; 5951 VkBool32 dedicatedAllocation; 5952 } VkDedicatedAllocationBufferCreateInfoNV; 5953 5954 typedef struct VkDedicatedAllocationMemoryAllocateInfoNV { 5955 VkStructureType sType; 5956 const void* pNext; 5957 VkImage image; 5958 VkBuffer buffer; 5959 } VkDedicatedAllocationMemoryAllocateInfoNV; 5960 5961 5962 5963 #define VK_AMD_draw_indirect_count 1 5964 #define VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION 1 5965 #define VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_AMD_draw_indirect_count" 5966 5967 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); 5968 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); 5969 5970 #ifndef VK_NO_PROTOTYPES 5971 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountAMD( 5972 VkCommandBuffer commandBuffer, 5973 VkBuffer buffer, 5974 VkDeviceSize offset, 5975 VkBuffer countBuffer, 5976 VkDeviceSize countBufferOffset, 5977 uint32_t maxDrawCount, 5978 uint32_t stride); 5979 5980 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountAMD( 5981 VkCommandBuffer commandBuffer, 5982 VkBuffer buffer, 5983 VkDeviceSize offset, 5984 VkBuffer countBuffer, 5985 VkDeviceSize countBufferOffset, 5986 uint32_t maxDrawCount, 5987 uint32_t stride); 5988 #endif 5989 5990 #define VK_AMD_negative_viewport_height 1 5991 #define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION 1 5992 #define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME "VK_AMD_negative_viewport_height" 5993 5994 5995 #define VK_AMD_gpu_shader_half_float 1 5996 #define VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION 1 5997 #define VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME "VK_AMD_gpu_shader_half_float" 5998 5999 6000 #define VK_AMD_shader_ballot 1 6001 #define VK_AMD_SHADER_BALLOT_SPEC_VERSION 1 6002 #define VK_AMD_SHADER_BALLOT_EXTENSION_NAME "VK_AMD_shader_ballot" 6003 6004 6005 #define VK_AMD_texture_gather_bias_lod 1 6006 #define VK_AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION 1 6007 #define VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME "VK_AMD_texture_gather_bias_lod" 6008 6009 typedef struct VkTextureLODGatherFormatPropertiesAMD { 6010 VkStructureType sType; 6011 void* pNext; 6012 VkBool32 supportsTextureGatherLODBiasAMD; 6013 } VkTextureLODGatherFormatPropertiesAMD; 6014 6015 6016 6017 #define VK_AMD_shader_info 1 6018 #define VK_AMD_SHADER_INFO_SPEC_VERSION 1 6019 #define VK_AMD_SHADER_INFO_EXTENSION_NAME "VK_AMD_shader_info" 6020 6021 6022 typedef enum VkShaderInfoTypeAMD { 6023 VK_SHADER_INFO_TYPE_STATISTICS_AMD = 0, 6024 VK_SHADER_INFO_TYPE_BINARY_AMD = 1, 6025 VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD = 2, 6026 VK_SHADER_INFO_TYPE_BEGIN_RANGE_AMD = VK_SHADER_INFO_TYPE_STATISTICS_AMD, 6027 VK_SHADER_INFO_TYPE_END_RANGE_AMD = VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD, 6028 VK_SHADER_INFO_TYPE_RANGE_SIZE_AMD = (VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD - VK_SHADER_INFO_TYPE_STATISTICS_AMD + 1), 6029 VK_SHADER_INFO_TYPE_MAX_ENUM_AMD = 0x7FFFFFFF 6030 } VkShaderInfoTypeAMD; 6031 6032 typedef struct VkShaderResourceUsageAMD { 6033 uint32_t numUsedVgprs; 6034 uint32_t numUsedSgprs; 6035 uint32_t ldsSizePerLocalWorkGroup; 6036 size_t ldsUsageSizeInBytes; 6037 size_t scratchMemUsageInBytes; 6038 } VkShaderResourceUsageAMD; 6039 6040 typedef struct VkShaderStatisticsInfoAMD { 6041 VkShaderStageFlags shaderStageMask; 6042 VkShaderResourceUsageAMD resourceUsage; 6043 uint32_t numPhysicalVgprs; 6044 uint32_t numPhysicalSgprs; 6045 uint32_t numAvailableVgprs; 6046 uint32_t numAvailableSgprs; 6047 uint32_t computeWorkGroupSize[3]; 6048 } VkShaderStatisticsInfoAMD; 6049 6050 6051 typedef VkResult (VKAPI_PTR *PFN_vkGetShaderInfoAMD)(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo); 6052 6053 #ifndef VK_NO_PROTOTYPES 6054 VKAPI_ATTR VkResult VKAPI_CALL vkGetShaderInfoAMD( 6055 VkDevice device, 6056 VkPipeline pipeline, 6057 VkShaderStageFlagBits shaderStage, 6058 VkShaderInfoTypeAMD infoType, 6059 size_t* pInfoSize, 6060 void* pInfo); 6061 #endif 6062 6063 #define VK_AMD_shader_image_load_store_lod 1 6064 #define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION 1 6065 #define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME "VK_AMD_shader_image_load_store_lod" 6066 6067 6068 #define VK_IMG_format_pvrtc 1 6069 #define VK_IMG_FORMAT_PVRTC_SPEC_VERSION 1 6070 #define VK_IMG_FORMAT_PVRTC_EXTENSION_NAME "VK_IMG_format_pvrtc" 6071 6072 6073 #define VK_NV_external_memory_capabilities 1 6074 #define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1 6075 #define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_NV_external_memory_capabilities" 6076 6077 6078 typedef enum VkExternalMemoryHandleTypeFlagBitsNV { 6079 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = 0x00000001, 6080 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = 0x00000002, 6081 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = 0x00000004, 6082 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = 0x00000008, 6083 VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF 6084 } VkExternalMemoryHandleTypeFlagBitsNV; 6085 typedef VkFlags VkExternalMemoryHandleTypeFlagsNV; 6086 6087 typedef enum VkExternalMemoryFeatureFlagBitsNV { 6088 VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = 0x00000001, 6089 VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = 0x00000002, 6090 VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = 0x00000004, 6091 VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF 6092 } VkExternalMemoryFeatureFlagBitsNV; 6093 typedef VkFlags VkExternalMemoryFeatureFlagsNV; 6094 6095 typedef struct VkExternalImageFormatPropertiesNV { 6096 VkImageFormatProperties imageFormatProperties; 6097 VkExternalMemoryFeatureFlagsNV externalMemoryFeatures; 6098 VkExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes; 6099 VkExternalMemoryHandleTypeFlagsNV compatibleHandleTypes; 6100 } VkExternalImageFormatPropertiesNV; 6101 6102 6103 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties); 6104 6105 #ifndef VK_NO_PROTOTYPES 6106 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceExternalImageFormatPropertiesNV( 6107 VkPhysicalDevice physicalDevice, 6108 VkFormat format, 6109 VkImageType type, 6110 VkImageTiling tiling, 6111 VkImageUsageFlags usage, 6112 VkImageCreateFlags flags, 6113 VkExternalMemoryHandleTypeFlagsNV externalHandleType, 6114 VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties); 6115 #endif 6116 6117 #define VK_NV_external_memory 1 6118 #define VK_NV_EXTERNAL_MEMORY_SPEC_VERSION 1 6119 #define VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME "VK_NV_external_memory" 6120 6121 typedef struct VkExternalMemoryImageCreateInfoNV { 6122 VkStructureType sType; 6123 const void* pNext; 6124 VkExternalMemoryHandleTypeFlagsNV handleTypes; 6125 } VkExternalMemoryImageCreateInfoNV; 6126 6127 typedef struct VkExportMemoryAllocateInfoNV { 6128 VkStructureType sType; 6129 const void* pNext; 6130 VkExternalMemoryHandleTypeFlagsNV handleTypes; 6131 } VkExportMemoryAllocateInfoNV; 6132 6133 6134 6135 #define VK_EXT_validation_flags 1 6136 #define VK_EXT_VALIDATION_FLAGS_SPEC_VERSION 1 6137 #define VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME "VK_EXT_validation_flags" 6138 6139 6140 typedef enum VkValidationCheckEXT { 6141 VK_VALIDATION_CHECK_ALL_EXT = 0, 6142 VK_VALIDATION_CHECK_SHADERS_EXT = 1, 6143 VK_VALIDATION_CHECK_BEGIN_RANGE_EXT = VK_VALIDATION_CHECK_ALL_EXT, 6144 VK_VALIDATION_CHECK_END_RANGE_EXT = VK_VALIDATION_CHECK_SHADERS_EXT, 6145 VK_VALIDATION_CHECK_RANGE_SIZE_EXT = (VK_VALIDATION_CHECK_SHADERS_EXT - VK_VALIDATION_CHECK_ALL_EXT + 1), 6146 VK_VALIDATION_CHECK_MAX_ENUM_EXT = 0x7FFFFFFF 6147 } VkValidationCheckEXT; 6148 6149 typedef struct VkValidationFlagsEXT { 6150 VkStructureType sType; 6151 const void* pNext; 6152 uint32_t disabledValidationCheckCount; 6153 VkValidationCheckEXT* pDisabledValidationChecks; 6154 } VkValidationFlagsEXT; 6155 6156 6157 6158 #define VK_EXT_shader_subgroup_ballot 1 6159 #define VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION 1 6160 #define VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME "VK_EXT_shader_subgroup_ballot" 6161 6162 6163 #define VK_EXT_shader_subgroup_vote 1 6164 #define VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION 1 6165 #define VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME "VK_EXT_shader_subgroup_vote" 6166 6167 6168 #define VK_NVX_device_generated_commands 1 6169 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkObjectTableNVX) 6170 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutNVX) 6171 6172 #define VK_NVX_DEVICE_GENERATED_COMMANDS_SPEC_VERSION 3 6173 #define VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME "VK_NVX_device_generated_commands" 6174 6175 6176 typedef enum VkIndirectCommandsTokenTypeNVX { 6177 VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX = 0, 6178 VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX = 1, 6179 VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX = 2, 6180 VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX = 3, 6181 VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX = 4, 6182 VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX = 5, 6183 VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX = 6, 6184 VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX = 7, 6185 VK_INDIRECT_COMMANDS_TOKEN_TYPE_BEGIN_RANGE_NVX = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX, 6186 VK_INDIRECT_COMMANDS_TOKEN_TYPE_END_RANGE_NVX = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX, 6187 VK_INDIRECT_COMMANDS_TOKEN_TYPE_RANGE_SIZE_NVX = (VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX - VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX + 1), 6188 VK_INDIRECT_COMMANDS_TOKEN_TYPE_MAX_ENUM_NVX = 0x7FFFFFFF 6189 } VkIndirectCommandsTokenTypeNVX; 6190 6191 typedef enum VkObjectEntryTypeNVX { 6192 VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX = 0, 6193 VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX = 1, 6194 VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX = 2, 6195 VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX = 3, 6196 VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX = 4, 6197 VK_OBJECT_ENTRY_TYPE_BEGIN_RANGE_NVX = VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX, 6198 VK_OBJECT_ENTRY_TYPE_END_RANGE_NVX = VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX, 6199 VK_OBJECT_ENTRY_TYPE_RANGE_SIZE_NVX = (VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX - VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX + 1), 6200 VK_OBJECT_ENTRY_TYPE_MAX_ENUM_NVX = 0x7FFFFFFF 6201 } VkObjectEntryTypeNVX; 6202 6203 6204 typedef enum VkIndirectCommandsLayoutUsageFlagBitsNVX { 6205 VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX = 0x00000001, 6206 VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX = 0x00000002, 6207 VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX = 0x00000004, 6208 VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX = 0x00000008, 6209 VK_INDIRECT_COMMANDS_LAYOUT_USAGE_FLAG_BITS_MAX_ENUM_NVX = 0x7FFFFFFF 6210 } VkIndirectCommandsLayoutUsageFlagBitsNVX; 6211 typedef VkFlags VkIndirectCommandsLayoutUsageFlagsNVX; 6212 6213 typedef enum VkObjectEntryUsageFlagBitsNVX { 6214 VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX = 0x00000001, 6215 VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX = 0x00000002, 6216 VK_OBJECT_ENTRY_USAGE_FLAG_BITS_MAX_ENUM_NVX = 0x7FFFFFFF 6217 } VkObjectEntryUsageFlagBitsNVX; 6218 typedef VkFlags VkObjectEntryUsageFlagsNVX; 6219 6220 typedef struct VkDeviceGeneratedCommandsFeaturesNVX { 6221 VkStructureType sType; 6222 const void* pNext; 6223 VkBool32 computeBindingPointSupport; 6224 } VkDeviceGeneratedCommandsFeaturesNVX; 6225 6226 typedef struct VkDeviceGeneratedCommandsLimitsNVX { 6227 VkStructureType sType; 6228 const void* pNext; 6229 uint32_t maxIndirectCommandsLayoutTokenCount; 6230 uint32_t maxObjectEntryCounts; 6231 uint32_t minSequenceCountBufferOffsetAlignment; 6232 uint32_t minSequenceIndexBufferOffsetAlignment; 6233 uint32_t minCommandsTokenBufferOffsetAlignment; 6234 } VkDeviceGeneratedCommandsLimitsNVX; 6235 6236 typedef struct VkIndirectCommandsTokenNVX { 6237 VkIndirectCommandsTokenTypeNVX tokenType; 6238 VkBuffer buffer; 6239 VkDeviceSize offset; 6240 } VkIndirectCommandsTokenNVX; 6241 6242 typedef struct VkIndirectCommandsLayoutTokenNVX { 6243 VkIndirectCommandsTokenTypeNVX tokenType; 6244 uint32_t bindingUnit; 6245 uint32_t dynamicCount; 6246 uint32_t divisor; 6247 } VkIndirectCommandsLayoutTokenNVX; 6248 6249 typedef struct VkIndirectCommandsLayoutCreateInfoNVX { 6250 VkStructureType sType; 6251 const void* pNext; 6252 VkPipelineBindPoint pipelineBindPoint; 6253 VkIndirectCommandsLayoutUsageFlagsNVX flags; 6254 uint32_t tokenCount; 6255 const VkIndirectCommandsLayoutTokenNVX* pTokens; 6256 } VkIndirectCommandsLayoutCreateInfoNVX; 6257 6258 typedef struct VkCmdProcessCommandsInfoNVX { 6259 VkStructureType sType; 6260 const void* pNext; 6261 VkObjectTableNVX objectTable; 6262 VkIndirectCommandsLayoutNVX indirectCommandsLayout; 6263 uint32_t indirectCommandsTokenCount; 6264 const VkIndirectCommandsTokenNVX* pIndirectCommandsTokens; 6265 uint32_t maxSequencesCount; 6266 VkCommandBuffer targetCommandBuffer; 6267 VkBuffer sequencesCountBuffer; 6268 VkDeviceSize sequencesCountOffset; 6269 VkBuffer sequencesIndexBuffer; 6270 VkDeviceSize sequencesIndexOffset; 6271 } VkCmdProcessCommandsInfoNVX; 6272 6273 typedef struct VkCmdReserveSpaceForCommandsInfoNVX { 6274 VkStructureType sType; 6275 const void* pNext; 6276 VkObjectTableNVX objectTable; 6277 VkIndirectCommandsLayoutNVX indirectCommandsLayout; 6278 uint32_t maxSequencesCount; 6279 } VkCmdReserveSpaceForCommandsInfoNVX; 6280 6281 typedef struct VkObjectTableCreateInfoNVX { 6282 VkStructureType sType; 6283 const void* pNext; 6284 uint32_t objectCount; 6285 const VkObjectEntryTypeNVX* pObjectEntryTypes; 6286 const uint32_t* pObjectEntryCounts; 6287 const VkObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags; 6288 uint32_t maxUniformBuffersPerDescriptor; 6289 uint32_t maxStorageBuffersPerDescriptor; 6290 uint32_t maxStorageImagesPerDescriptor; 6291 uint32_t maxSampledImagesPerDescriptor; 6292 uint32_t maxPipelineLayouts; 6293 } VkObjectTableCreateInfoNVX; 6294 6295 typedef struct VkObjectTableEntryNVX { 6296 VkObjectEntryTypeNVX type; 6297 VkObjectEntryUsageFlagsNVX flags; 6298 } VkObjectTableEntryNVX; 6299 6300 typedef struct VkObjectTablePipelineEntryNVX { 6301 VkObjectEntryTypeNVX type; 6302 VkObjectEntryUsageFlagsNVX flags; 6303 VkPipeline pipeline; 6304 } VkObjectTablePipelineEntryNVX; 6305 6306 typedef struct VkObjectTableDescriptorSetEntryNVX { 6307 VkObjectEntryTypeNVX type; 6308 VkObjectEntryUsageFlagsNVX flags; 6309 VkPipelineLayout pipelineLayout; 6310 VkDescriptorSet descriptorSet; 6311 } VkObjectTableDescriptorSetEntryNVX; 6312 6313 typedef struct VkObjectTableVertexBufferEntryNVX { 6314 VkObjectEntryTypeNVX type; 6315 VkObjectEntryUsageFlagsNVX flags; 6316 VkBuffer buffer; 6317 } VkObjectTableVertexBufferEntryNVX; 6318 6319 typedef struct VkObjectTableIndexBufferEntryNVX { 6320 VkObjectEntryTypeNVX type; 6321 VkObjectEntryUsageFlagsNVX flags; 6322 VkBuffer buffer; 6323 VkIndexType indexType; 6324 } VkObjectTableIndexBufferEntryNVX; 6325 6326 typedef struct VkObjectTablePushConstantEntryNVX { 6327 VkObjectEntryTypeNVX type; 6328 VkObjectEntryUsageFlagsNVX flags; 6329 VkPipelineLayout pipelineLayout; 6330 VkShaderStageFlags stageFlags; 6331 } VkObjectTablePushConstantEntryNVX; 6332 6333 6334 typedef void (VKAPI_PTR *PFN_vkCmdProcessCommandsNVX)(VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo); 6335 typedef void (VKAPI_PTR *PFN_vkCmdReserveSpaceForCommandsNVX)(VkCommandBuffer commandBuffer, const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo); 6336 typedef VkResult (VKAPI_PTR *PFN_vkCreateIndirectCommandsLayoutNVX)(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout); 6337 typedef void (VKAPI_PTR *PFN_vkDestroyIndirectCommandsLayoutNVX)(VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout, const VkAllocationCallbacks* pAllocator); 6338 typedef VkResult (VKAPI_PTR *PFN_vkCreateObjectTableNVX)(VkDevice device, const VkObjectTableCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkObjectTableNVX* pObjectTable); 6339 typedef void (VKAPI_PTR *PFN_vkDestroyObjectTableNVX)(VkDevice device, VkObjectTableNVX objectTable, const VkAllocationCallbacks* pAllocator); 6340 typedef VkResult (VKAPI_PTR *PFN_vkRegisterObjectsNVX)(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectTableEntryNVX* const* ppObjectTableEntries, const uint32_t* pObjectIndices); 6341 typedef VkResult (VKAPI_PTR *PFN_vkUnregisterObjectsNVX)(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices); 6342 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX)(VkPhysicalDevice physicalDevice, VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, VkDeviceGeneratedCommandsLimitsNVX* pLimits); 6343 6344 #ifndef VK_NO_PROTOTYPES 6345 VKAPI_ATTR void VKAPI_CALL vkCmdProcessCommandsNVX( 6346 VkCommandBuffer commandBuffer, 6347 const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo); 6348 6349 VKAPI_ATTR void VKAPI_CALL vkCmdReserveSpaceForCommandsNVX( 6350 VkCommandBuffer commandBuffer, 6351 const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo); 6352 6353 VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutNVX( 6354 VkDevice device, 6355 const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, 6356 const VkAllocationCallbacks* pAllocator, 6357 VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout); 6358 6359 VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectCommandsLayoutNVX( 6360 VkDevice device, 6361 VkIndirectCommandsLayoutNVX indirectCommandsLayout, 6362 const VkAllocationCallbacks* pAllocator); 6363 6364 VKAPI_ATTR VkResult VKAPI_CALL vkCreateObjectTableNVX( 6365 VkDevice device, 6366 const VkObjectTableCreateInfoNVX* pCreateInfo, 6367 const VkAllocationCallbacks* pAllocator, 6368 VkObjectTableNVX* pObjectTable); 6369 6370 VKAPI_ATTR void VKAPI_CALL vkDestroyObjectTableNVX( 6371 VkDevice device, 6372 VkObjectTableNVX objectTable, 6373 const VkAllocationCallbacks* pAllocator); 6374 6375 VKAPI_ATTR VkResult VKAPI_CALL vkRegisterObjectsNVX( 6376 VkDevice device, 6377 VkObjectTableNVX objectTable, 6378 uint32_t objectCount, 6379 const VkObjectTableEntryNVX* const* ppObjectTableEntries, 6380 const uint32_t* pObjectIndices); 6381 6382 VKAPI_ATTR VkResult VKAPI_CALL vkUnregisterObjectsNVX( 6383 VkDevice device, 6384 VkObjectTableNVX objectTable, 6385 uint32_t objectCount, 6386 const VkObjectEntryTypeNVX* pObjectEntryTypes, 6387 const uint32_t* pObjectIndices); 6388 6389 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( 6390 VkPhysicalDevice physicalDevice, 6391 VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, 6392 VkDeviceGeneratedCommandsLimitsNVX* pLimits); 6393 #endif 6394 6395 #define VK_NV_clip_space_w_scaling 1 6396 #define VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION 1 6397 #define VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME "VK_NV_clip_space_w_scaling" 6398 6399 typedef struct VkViewportWScalingNV { 6400 float xcoeff; 6401 float ycoeff; 6402 } VkViewportWScalingNV; 6403 6404 typedef struct VkPipelineViewportWScalingStateCreateInfoNV { 6405 VkStructureType sType; 6406 const void* pNext; 6407 VkBool32 viewportWScalingEnable; 6408 uint32_t viewportCount; 6409 const VkViewportWScalingNV* pViewportWScalings; 6410 } VkPipelineViewportWScalingStateCreateInfoNV; 6411 6412 6413 typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWScalingNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings); 6414 6415 #ifndef VK_NO_PROTOTYPES 6416 VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingNV( 6417 VkCommandBuffer commandBuffer, 6418 uint32_t firstViewport, 6419 uint32_t viewportCount, 6420 const VkViewportWScalingNV* pViewportWScalings); 6421 #endif 6422 6423 #define VK_EXT_direct_mode_display 1 6424 #define VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION 1 6425 #define VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME "VK_EXT_direct_mode_display" 6426 6427 typedef VkResult (VKAPI_PTR *PFN_vkReleaseDisplayEXT)(VkPhysicalDevice physicalDevice, VkDisplayKHR display); 6428 6429 #ifndef VK_NO_PROTOTYPES 6430 VKAPI_ATTR VkResult VKAPI_CALL vkReleaseDisplayEXT( 6431 VkPhysicalDevice physicalDevice, 6432 VkDisplayKHR display); 6433 #endif 6434 6435 #define VK_EXT_display_surface_counter 1 6436 #define VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION 1 6437 #define VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME "VK_EXT_display_surface_counter" 6438 #define VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT 6439 6440 6441 typedef enum VkSurfaceCounterFlagBitsEXT { 6442 VK_SURFACE_COUNTER_VBLANK_EXT = 0x00000001, 6443 VK_SURFACE_COUNTER_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF 6444 } VkSurfaceCounterFlagBitsEXT; 6445 typedef VkFlags VkSurfaceCounterFlagsEXT; 6446 6447 typedef struct VkSurfaceCapabilities2EXT { 6448 VkStructureType sType; 6449 void* pNext; 6450 uint32_t minImageCount; 6451 uint32_t maxImageCount; 6452 VkExtent2D currentExtent; 6453 VkExtent2D minImageExtent; 6454 VkExtent2D maxImageExtent; 6455 uint32_t maxImageArrayLayers; 6456 VkSurfaceTransformFlagsKHR supportedTransforms; 6457 VkSurfaceTransformFlagBitsKHR currentTransform; 6458 VkCompositeAlphaFlagsKHR supportedCompositeAlpha; 6459 VkImageUsageFlags supportedUsageFlags; 6460 VkSurfaceCounterFlagsEXT supportedSurfaceCounters; 6461 } VkSurfaceCapabilities2EXT; 6462 6463 6464 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities); 6465 6466 #ifndef VK_NO_PROTOTYPES 6467 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2EXT( 6468 VkPhysicalDevice physicalDevice, 6469 VkSurfaceKHR surface, 6470 VkSurfaceCapabilities2EXT* pSurfaceCapabilities); 6471 #endif 6472 6473 #define VK_EXT_display_control 1 6474 #define VK_EXT_DISPLAY_CONTROL_SPEC_VERSION 1 6475 #define VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME "VK_EXT_display_control" 6476 6477 6478 typedef enum VkDisplayPowerStateEXT { 6479 VK_DISPLAY_POWER_STATE_OFF_EXT = 0, 6480 VK_DISPLAY_POWER_STATE_SUSPEND_EXT = 1, 6481 VK_DISPLAY_POWER_STATE_ON_EXT = 2, 6482 VK_DISPLAY_POWER_STATE_BEGIN_RANGE_EXT = VK_DISPLAY_POWER_STATE_OFF_EXT, 6483 VK_DISPLAY_POWER_STATE_END_RANGE_EXT = VK_DISPLAY_POWER_STATE_ON_EXT, 6484 VK_DISPLAY_POWER_STATE_RANGE_SIZE_EXT = (VK_DISPLAY_POWER_STATE_ON_EXT - VK_DISPLAY_POWER_STATE_OFF_EXT + 1), 6485 VK_DISPLAY_POWER_STATE_MAX_ENUM_EXT = 0x7FFFFFFF 6486 } VkDisplayPowerStateEXT; 6487 6488 typedef enum VkDeviceEventTypeEXT { 6489 VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT = 0, 6490 VK_DEVICE_EVENT_TYPE_BEGIN_RANGE_EXT = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT, 6491 VK_DEVICE_EVENT_TYPE_END_RANGE_EXT = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT, 6492 VK_DEVICE_EVENT_TYPE_RANGE_SIZE_EXT = (VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT - VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT + 1), 6493 VK_DEVICE_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF 6494 } VkDeviceEventTypeEXT; 6495 6496 typedef enum VkDisplayEventTypeEXT { 6497 VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT = 0, 6498 VK_DISPLAY_EVENT_TYPE_BEGIN_RANGE_EXT = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT, 6499 VK_DISPLAY_EVENT_TYPE_END_RANGE_EXT = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT, 6500 VK_DISPLAY_EVENT_TYPE_RANGE_SIZE_EXT = (VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT - VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT + 1), 6501 VK_DISPLAY_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF 6502 } VkDisplayEventTypeEXT; 6503 6504 typedef struct VkDisplayPowerInfoEXT { 6505 VkStructureType sType; 6506 const void* pNext; 6507 VkDisplayPowerStateEXT powerState; 6508 } VkDisplayPowerInfoEXT; 6509 6510 typedef struct VkDeviceEventInfoEXT { 6511 VkStructureType sType; 6512 const void* pNext; 6513 VkDeviceEventTypeEXT deviceEvent; 6514 } VkDeviceEventInfoEXT; 6515 6516 typedef struct VkDisplayEventInfoEXT { 6517 VkStructureType sType; 6518 const void* pNext; 6519 VkDisplayEventTypeEXT displayEvent; 6520 } VkDisplayEventInfoEXT; 6521 6522 typedef struct VkSwapchainCounterCreateInfoEXT { 6523 VkStructureType sType; 6524 const void* pNext; 6525 VkSurfaceCounterFlagsEXT surfaceCounters; 6526 } VkSwapchainCounterCreateInfoEXT; 6527 6528 6529 typedef VkResult (VKAPI_PTR *PFN_vkDisplayPowerControlEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo); 6530 typedef VkResult (VKAPI_PTR *PFN_vkRegisterDeviceEventEXT)(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); 6531 typedef VkResult (VKAPI_PTR *PFN_vkRegisterDisplayEventEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); 6532 typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainCounterEXT)(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue); 6533 6534 #ifndef VK_NO_PROTOTYPES 6535 VKAPI_ATTR VkResult VKAPI_CALL vkDisplayPowerControlEXT( 6536 VkDevice device, 6537 VkDisplayKHR display, 6538 const VkDisplayPowerInfoEXT* pDisplayPowerInfo); 6539 6540 VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDeviceEventEXT( 6541 VkDevice device, 6542 const VkDeviceEventInfoEXT* pDeviceEventInfo, 6543 const VkAllocationCallbacks* pAllocator, 6544 VkFence* pFence); 6545 6546 VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDisplayEventEXT( 6547 VkDevice device, 6548 VkDisplayKHR display, 6549 const VkDisplayEventInfoEXT* pDisplayEventInfo, 6550 const VkAllocationCallbacks* pAllocator, 6551 VkFence* pFence); 6552 6553 VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainCounterEXT( 6554 VkDevice device, 6555 VkSwapchainKHR swapchain, 6556 VkSurfaceCounterFlagBitsEXT counter, 6557 uint64_t* pCounterValue); 6558 #endif 6559 6560 #define VK_GOOGLE_display_timing 1 6561 #define VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION 1 6562 #define VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME "VK_GOOGLE_display_timing" 6563 6564 typedef struct VkRefreshCycleDurationGOOGLE { 6565 uint64_t refreshDuration; 6566 } VkRefreshCycleDurationGOOGLE; 6567 6568 typedef struct VkPastPresentationTimingGOOGLE { 6569 uint32_t presentID; 6570 uint64_t desiredPresentTime; 6571 uint64_t actualPresentTime; 6572 uint64_t earliestPresentTime; 6573 uint64_t presentMargin; 6574 } VkPastPresentationTimingGOOGLE; 6575 6576 typedef struct VkPresentTimeGOOGLE { 6577 uint32_t presentID; 6578 uint64_t desiredPresentTime; 6579 } VkPresentTimeGOOGLE; 6580 6581 typedef struct VkPresentTimesInfoGOOGLE { 6582 VkStructureType sType; 6583 const void* pNext; 6584 uint32_t swapchainCount; 6585 const VkPresentTimeGOOGLE* pTimes; 6586 } VkPresentTimesInfoGOOGLE; 6587 6588 6589 typedef VkResult (VKAPI_PTR *PFN_vkGetRefreshCycleDurationGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties); 6590 typedef VkResult (VKAPI_PTR *PFN_vkGetPastPresentationTimingGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings); 6591 6592 #ifndef VK_NO_PROTOTYPES 6593 VKAPI_ATTR VkResult VKAPI_CALL vkGetRefreshCycleDurationGOOGLE( 6594 VkDevice device, 6595 VkSwapchainKHR swapchain, 6596 VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties); 6597 6598 VKAPI_ATTR VkResult VKAPI_CALL vkGetPastPresentationTimingGOOGLE( 6599 VkDevice device, 6600 VkSwapchainKHR swapchain, 6601 uint32_t* pPresentationTimingCount, 6602 VkPastPresentationTimingGOOGLE* pPresentationTimings); 6603 #endif 6604 6605 #define VK_NV_sample_mask_override_coverage 1 6606 #define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION 1 6607 #define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME "VK_NV_sample_mask_override_coverage" 6608 6609 6610 #define VK_NV_geometry_shader_passthrough 1 6611 #define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION 1 6612 #define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME "VK_NV_geometry_shader_passthrough" 6613 6614 6615 #define VK_NV_viewport_array2 1 6616 #define VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION 1 6617 #define VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME "VK_NV_viewport_array2" 6618 6619 6620 #define VK_NVX_multiview_per_view_attributes 1 6621 #define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION 1 6622 #define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME "VK_NVX_multiview_per_view_attributes" 6623 6624 typedef struct VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { 6625 VkStructureType sType; 6626 void* pNext; 6627 VkBool32 perViewPositionAllComponents; 6628 } VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; 6629 6630 6631 6632 #define VK_NV_viewport_swizzle 1 6633 #define VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION 1 6634 #define VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME "VK_NV_viewport_swizzle" 6635 6636 6637 typedef enum VkViewportCoordinateSwizzleNV { 6638 VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV = 0, 6639 VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV = 1, 6640 VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV = 2, 6641 VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV = 3, 6642 VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV = 4, 6643 VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV = 5, 6644 VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV = 6, 6645 VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV = 7, 6646 VK_VIEWPORT_COORDINATE_SWIZZLE_BEGIN_RANGE_NV = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV, 6647 VK_VIEWPORT_COORDINATE_SWIZZLE_END_RANGE_NV = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV, 6648 VK_VIEWPORT_COORDINATE_SWIZZLE_RANGE_SIZE_NV = (VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV - VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV + 1), 6649 VK_VIEWPORT_COORDINATE_SWIZZLE_MAX_ENUM_NV = 0x7FFFFFFF 6650 } VkViewportCoordinateSwizzleNV; 6651 6652 typedef VkFlags VkPipelineViewportSwizzleStateCreateFlagsNV; 6653 6654 typedef struct VkViewportSwizzleNV { 6655 VkViewportCoordinateSwizzleNV x; 6656 VkViewportCoordinateSwizzleNV y; 6657 VkViewportCoordinateSwizzleNV z; 6658 VkViewportCoordinateSwizzleNV w; 6659 } VkViewportSwizzleNV; 6660 6661 typedef struct VkPipelineViewportSwizzleStateCreateInfoNV { 6662 VkStructureType sType; 6663 const void* pNext; 6664 VkPipelineViewportSwizzleStateCreateFlagsNV flags; 6665 uint32_t viewportCount; 6666 const VkViewportSwizzleNV* pViewportSwizzles; 6667 } VkPipelineViewportSwizzleStateCreateInfoNV; 6668 6669 6670 6671 #define VK_EXT_discard_rectangles 1 6672 #define VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION 1 6673 #define VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME "VK_EXT_discard_rectangles" 6674 6675 6676 typedef enum VkDiscardRectangleModeEXT { 6677 VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = 0, 6678 VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = 1, 6679 VK_DISCARD_RECTANGLE_MODE_BEGIN_RANGE_EXT = VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT, 6680 VK_DISCARD_RECTANGLE_MODE_END_RANGE_EXT = VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT, 6681 VK_DISCARD_RECTANGLE_MODE_RANGE_SIZE_EXT = (VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT - VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT + 1), 6682 VK_DISCARD_RECTANGLE_MODE_MAX_ENUM_EXT = 0x7FFFFFFF 6683 } VkDiscardRectangleModeEXT; 6684 6685 typedef VkFlags VkPipelineDiscardRectangleStateCreateFlagsEXT; 6686 6687 typedef struct VkPhysicalDeviceDiscardRectanglePropertiesEXT { 6688 VkStructureType sType; 6689 void* pNext; 6690 uint32_t maxDiscardRectangles; 6691 } VkPhysicalDeviceDiscardRectanglePropertiesEXT; 6692 6693 typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT { 6694 VkStructureType sType; 6695 const void* pNext; 6696 VkPipelineDiscardRectangleStateCreateFlagsEXT flags; 6697 VkDiscardRectangleModeEXT discardRectangleMode; 6698 uint32_t discardRectangleCount; 6699 const VkRect2D* pDiscardRectangles; 6700 } VkPipelineDiscardRectangleStateCreateInfoEXT; 6701 6702 6703 typedef void (VKAPI_PTR *PFN_vkCmdSetDiscardRectangleEXT)(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles); 6704 6705 #ifndef VK_NO_PROTOTYPES 6706 VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEXT( 6707 VkCommandBuffer commandBuffer, 6708 uint32_t firstDiscardRectangle, 6709 uint32_t discardRectangleCount, 6710 const VkRect2D* pDiscardRectangles); 6711 #endif 6712 6713 #define VK_EXT_conservative_rasterization 1 6714 #define VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION 1 6715 #define VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME "VK_EXT_conservative_rasterization" 6716 6717 6718 typedef enum VkConservativeRasterizationModeEXT { 6719 VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT = 0, 6720 VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT = 1, 6721 VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT = 2, 6722 VK_CONSERVATIVE_RASTERIZATION_MODE_BEGIN_RANGE_EXT = VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT, 6723 VK_CONSERVATIVE_RASTERIZATION_MODE_END_RANGE_EXT = VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT, 6724 VK_CONSERVATIVE_RASTERIZATION_MODE_RANGE_SIZE_EXT = (VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT - VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT + 1), 6725 VK_CONSERVATIVE_RASTERIZATION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF 6726 } VkConservativeRasterizationModeEXT; 6727 6728 typedef VkFlags VkPipelineRasterizationConservativeStateCreateFlagsEXT; 6729 6730 typedef struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT { 6731 VkStructureType sType; 6732 void* pNext; 6733 float primitiveOverestimationSize; 6734 float maxExtraPrimitiveOverestimationSize; 6735 float extraPrimitiveOverestimationSizeGranularity; 6736 VkBool32 primitiveUnderestimation; 6737 VkBool32 conservativePointAndLineRasterization; 6738 VkBool32 degenerateTrianglesRasterized; 6739 VkBool32 degenerateLinesRasterized; 6740 VkBool32 fullyCoveredFragmentShaderInputVariable; 6741 VkBool32 conservativeRasterizationPostDepthCoverage; 6742 } VkPhysicalDeviceConservativeRasterizationPropertiesEXT; 6743 6744 typedef struct VkPipelineRasterizationConservativeStateCreateInfoEXT { 6745 VkStructureType sType; 6746 const void* pNext; 6747 VkPipelineRasterizationConservativeStateCreateFlagsEXT flags; 6748 VkConservativeRasterizationModeEXT conservativeRasterizationMode; 6749 float extraPrimitiveOverestimationSize; 6750 } VkPipelineRasterizationConservativeStateCreateInfoEXT; 6751 6752 6753 6754 #define VK_EXT_swapchain_colorspace 1 6755 #define VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION 3 6756 #define VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME "VK_EXT_swapchain_colorspace" 6757 6758 6759 #define VK_EXT_hdr_metadata 1 6760 #define VK_EXT_HDR_METADATA_SPEC_VERSION 1 6761 #define VK_EXT_HDR_METADATA_EXTENSION_NAME "VK_EXT_hdr_metadata" 6762 6763 typedef struct VkXYColorEXT { 6764 float x; 6765 float y; 6766 } VkXYColorEXT; 6767 6768 typedef struct VkHdrMetadataEXT { 6769 VkStructureType sType; 6770 const void* pNext; 6771 VkXYColorEXT displayPrimaryRed; 6772 VkXYColorEXT displayPrimaryGreen; 6773 VkXYColorEXT displayPrimaryBlue; 6774 VkXYColorEXT whitePoint; 6775 float maxLuminance; 6776 float minLuminance; 6777 float maxContentLightLevel; 6778 float maxFrameAverageLightLevel; 6779 } VkHdrMetadataEXT; 6780 6781 6782 typedef void (VKAPI_PTR *PFN_vkSetHdrMetadataEXT)(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata); 6783 6784 #ifndef VK_NO_PROTOTYPES 6785 VKAPI_ATTR void VKAPI_CALL vkSetHdrMetadataEXT( 6786 VkDevice device, 6787 uint32_t swapchainCount, 6788 const VkSwapchainKHR* pSwapchains, 6789 const VkHdrMetadataEXT* pMetadata); 6790 #endif 6791 6792 #define VK_EXT_external_memory_dma_buf 1 6793 #define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION 1 6794 #define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME "VK_EXT_external_memory_dma_buf" 6795 6796 6797 #define VK_EXT_queue_family_foreign 1 6798 #define VK_EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION 1 6799 #define VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME "VK_EXT_queue_family_foreign" 6800 #define VK_QUEUE_FAMILY_FOREIGN_EXT (~0U-2) 6801 6802 6803 #define VK_EXT_debug_utils 1 6804 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugUtilsMessengerEXT) 6805 6806 #define VK_EXT_DEBUG_UTILS_SPEC_VERSION 1 6807 #define VK_EXT_DEBUG_UTILS_EXTENSION_NAME "VK_EXT_debug_utils" 6808 6809 typedef VkFlags VkDebugUtilsMessengerCallbackDataFlagsEXT; 6810 typedef VkFlags VkDebugUtilsMessengerCreateFlagsEXT; 6811 6812 typedef enum VkDebugUtilsMessageSeverityFlagBitsEXT { 6813 VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT = 0x00000001, 6814 VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT = 0x00000010, 6815 VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT = 0x00000100, 6816 VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT = 0x00001000, 6817 VK_DEBUG_UTILS_MESSAGE_SEVERITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF 6818 } VkDebugUtilsMessageSeverityFlagBitsEXT; 6819 typedef VkFlags VkDebugUtilsMessageSeverityFlagsEXT; 6820 6821 typedef enum VkDebugUtilsMessageTypeFlagBitsEXT { 6822 VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT = 0x00000001, 6823 VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT = 0x00000002, 6824 VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT = 0x00000004, 6825 VK_DEBUG_UTILS_MESSAGE_TYPE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF 6826 } VkDebugUtilsMessageTypeFlagBitsEXT; 6827 typedef VkFlags VkDebugUtilsMessageTypeFlagsEXT; 6828 6829 typedef struct VkDebugUtilsObjectNameInfoEXT { 6830 VkStructureType sType; 6831 const void* pNext; 6832 VkObjectType objectType; 6833 uint64_t objectHandle; 6834 const char* pObjectName; 6835 } VkDebugUtilsObjectNameInfoEXT; 6836 6837 typedef struct VkDebugUtilsObjectTagInfoEXT { 6838 VkStructureType sType; 6839 const void* pNext; 6840 VkObjectType objectType; 6841 uint64_t objectHandle; 6842 uint64_t tagName; 6843 size_t tagSize; 6844 const void* pTag; 6845 } VkDebugUtilsObjectTagInfoEXT; 6846 6847 typedef struct VkDebugUtilsLabelEXT { 6848 VkStructureType sType; 6849 const void* pNext; 6850 const char* pLabelName; 6851 float color[4]; 6852 } VkDebugUtilsLabelEXT; 6853 6854 typedef struct VkDebugUtilsMessengerCallbackDataEXT { 6855 VkStructureType sType; 6856 const void* pNext; 6857 VkDebugUtilsMessengerCallbackDataFlagsEXT flags; 6858 const char* pMessageIdName; 6859 int32_t messageIdNumber; 6860 const char* pMessage; 6861 uint32_t queueLabelCount; 6862 VkDebugUtilsLabelEXT* pQueueLabels; 6863 uint32_t cmdBufLabelCount; 6864 VkDebugUtilsLabelEXT* pCmdBufLabels; 6865 uint32_t objectCount; 6866 VkDebugUtilsObjectNameInfoEXT* pObjects; 6867 } VkDebugUtilsMessengerCallbackDataEXT; 6868 6869 typedef VkBool32 (VKAPI_PTR *PFN_vkDebugUtilsMessengerCallbackEXT)( 6870 VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, 6871 VkDebugUtilsMessageTypeFlagsEXT messageType, 6872 const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, 6873 void* pUserData); 6874 6875 typedef struct VkDebugUtilsMessengerCreateInfoEXT { 6876 VkStructureType sType; 6877 const void* pNext; 6878 VkDebugUtilsMessengerCreateFlagsEXT flags; 6879 VkDebugUtilsMessageSeverityFlagsEXT messageSeverity; 6880 VkDebugUtilsMessageTypeFlagsEXT messageType; 6881 PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback; 6882 void* pUserData; 6883 } VkDebugUtilsMessengerCreateInfoEXT; 6884 6885 6886 typedef VkResult (VKAPI_PTR *PFN_vkSetDebugUtilsObjectNameEXT)(VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo); 6887 typedef VkResult (VKAPI_PTR *PFN_vkSetDebugUtilsObjectTagEXT)(VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo); 6888 typedef void (VKAPI_PTR *PFN_vkQueueBeginDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo); 6889 typedef void (VKAPI_PTR *PFN_vkQueueEndDebugUtilsLabelEXT)(VkQueue queue); 6890 typedef void (VKAPI_PTR *PFN_vkQueueInsertDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo); 6891 typedef void (VKAPI_PTR *PFN_vkCmdBeginDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo); 6892 typedef void (VKAPI_PTR *PFN_vkCmdEndDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer); 6893 typedef void (VKAPI_PTR *PFN_vkCmdInsertDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo); 6894 typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugUtilsMessengerEXT)(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger); 6895 typedef void (VKAPI_PTR *PFN_vkDestroyDebugUtilsMessengerEXT)(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator); 6896 typedef void (VKAPI_PTR *PFN_vkSubmitDebugUtilsMessageEXT)(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData); 6897 6898 #ifndef VK_NO_PROTOTYPES 6899 VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectNameEXT( 6900 VkDevice device, 6901 const VkDebugUtilsObjectNameInfoEXT* pNameInfo); 6902 6903 VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectTagEXT( 6904 VkDevice device, 6905 const VkDebugUtilsObjectTagInfoEXT* pTagInfo); 6906 6907 VKAPI_ATTR void VKAPI_CALL vkQueueBeginDebugUtilsLabelEXT( 6908 VkQueue queue, 6909 const VkDebugUtilsLabelEXT* pLabelInfo); 6910 6911 VKAPI_ATTR void VKAPI_CALL vkQueueEndDebugUtilsLabelEXT( 6912 VkQueue queue); 6913 6914 VKAPI_ATTR void VKAPI_CALL vkQueueInsertDebugUtilsLabelEXT( 6915 VkQueue queue, 6916 const VkDebugUtilsLabelEXT* pLabelInfo); 6917 6918 VKAPI_ATTR void VKAPI_CALL vkCmdBeginDebugUtilsLabelEXT( 6919 VkCommandBuffer commandBuffer, 6920 const VkDebugUtilsLabelEXT* pLabelInfo); 6921 6922 VKAPI_ATTR void VKAPI_CALL vkCmdEndDebugUtilsLabelEXT( 6923 VkCommandBuffer commandBuffer); 6924 6925 VKAPI_ATTR void VKAPI_CALL vkCmdInsertDebugUtilsLabelEXT( 6926 VkCommandBuffer commandBuffer, 6927 const VkDebugUtilsLabelEXT* pLabelInfo); 6928 6929 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugUtilsMessengerEXT( 6930 VkInstance instance, 6931 const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, 6932 const VkAllocationCallbacks* pAllocator, 6933 VkDebugUtilsMessengerEXT* pMessenger); 6934 6935 VKAPI_ATTR void VKAPI_CALL vkDestroyDebugUtilsMessengerEXT( 6936 VkInstance instance, 6937 VkDebugUtilsMessengerEXT messenger, 6938 const VkAllocationCallbacks* pAllocator); 6939 6940 VKAPI_ATTR void VKAPI_CALL vkSubmitDebugUtilsMessageEXT( 6941 VkInstance instance, 6942 VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, 6943 VkDebugUtilsMessageTypeFlagsEXT messageTypes, 6944 const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData); 6945 #endif 6946 6947 #define VK_EXT_sampler_filter_minmax 1 6948 #define VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION 1 6949 #define VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME "VK_EXT_sampler_filter_minmax" 6950 6951 6952 typedef enum VkSamplerReductionModeEXT { 6953 VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT = 0, 6954 VK_SAMPLER_REDUCTION_MODE_MIN_EXT = 1, 6955 VK_SAMPLER_REDUCTION_MODE_MAX_EXT = 2, 6956 VK_SAMPLER_REDUCTION_MODE_BEGIN_RANGE_EXT = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT, 6957 VK_SAMPLER_REDUCTION_MODE_END_RANGE_EXT = VK_SAMPLER_REDUCTION_MODE_MAX_EXT, 6958 VK_SAMPLER_REDUCTION_MODE_RANGE_SIZE_EXT = (VK_SAMPLER_REDUCTION_MODE_MAX_EXT - VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT + 1), 6959 VK_SAMPLER_REDUCTION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF 6960 } VkSamplerReductionModeEXT; 6961 6962 typedef struct VkSamplerReductionModeCreateInfoEXT { 6963 VkStructureType sType; 6964 const void* pNext; 6965 VkSamplerReductionModeEXT reductionMode; 6966 } VkSamplerReductionModeCreateInfoEXT; 6967 6968 typedef struct VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT { 6969 VkStructureType sType; 6970 void* pNext; 6971 VkBool32 filterMinmaxSingleComponentFormats; 6972 VkBool32 filterMinmaxImageComponentMapping; 6973 } VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT; 6974 6975 6976 6977 #define VK_AMD_gpu_shader_int16 1 6978 #define VK_AMD_GPU_SHADER_INT16_SPEC_VERSION 1 6979 #define VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME "VK_AMD_gpu_shader_int16" 6980 6981 6982 #define VK_AMD_mixed_attachment_samples 1 6983 #define VK_AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION 1 6984 #define VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME "VK_AMD_mixed_attachment_samples" 6985 6986 6987 #define VK_AMD_shader_fragment_mask 1 6988 #define VK_AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION 1 6989 #define VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME "VK_AMD_shader_fragment_mask" 6990 6991 6992 #define VK_EXT_shader_stencil_export 1 6993 #define VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION 1 6994 #define VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME "VK_EXT_shader_stencil_export" 6995 6996 6997 #define VK_EXT_sample_locations 1 6998 #define VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION 1 6999 #define VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME "VK_EXT_sample_locations" 7000 7001 typedef struct VkSampleLocationEXT { 7002 float x; 7003 float y; 7004 } VkSampleLocationEXT; 7005 7006 typedef struct VkSampleLocationsInfoEXT { 7007 VkStructureType sType; 7008 const void* pNext; 7009 VkSampleCountFlagBits sampleLocationsPerPixel; 7010 VkExtent2D sampleLocationGridSize; 7011 uint32_t sampleLocationsCount; 7012 const VkSampleLocationEXT* pSampleLocations; 7013 } VkSampleLocationsInfoEXT; 7014 7015 typedef struct VkAttachmentSampleLocationsEXT { 7016 uint32_t attachmentIndex; 7017 VkSampleLocationsInfoEXT sampleLocationsInfo; 7018 } VkAttachmentSampleLocationsEXT; 7019 7020 typedef struct VkSubpassSampleLocationsEXT { 7021 uint32_t subpassIndex; 7022 VkSampleLocationsInfoEXT sampleLocationsInfo; 7023 } VkSubpassSampleLocationsEXT; 7024 7025 typedef struct VkRenderPassSampleLocationsBeginInfoEXT { 7026 VkStructureType sType; 7027 const void* pNext; 7028 uint32_t attachmentInitialSampleLocationsCount; 7029 const VkAttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations; 7030 uint32_t postSubpassSampleLocationsCount; 7031 const VkSubpassSampleLocationsEXT* pPostSubpassSampleLocations; 7032 } VkRenderPassSampleLocationsBeginInfoEXT; 7033 7034 typedef struct VkPipelineSampleLocationsStateCreateInfoEXT { 7035 VkStructureType sType; 7036 const void* pNext; 7037 VkBool32 sampleLocationsEnable; 7038 VkSampleLocationsInfoEXT sampleLocationsInfo; 7039 } VkPipelineSampleLocationsStateCreateInfoEXT; 7040 7041 typedef struct VkPhysicalDeviceSampleLocationsPropertiesEXT { 7042 VkStructureType sType; 7043 void* pNext; 7044 VkSampleCountFlags sampleLocationSampleCounts; 7045 VkExtent2D maxSampleLocationGridSize; 7046 float sampleLocationCoordinateRange[2]; 7047 uint32_t sampleLocationSubPixelBits; 7048 VkBool32 variableSampleLocations; 7049 } VkPhysicalDeviceSampleLocationsPropertiesEXT; 7050 7051 typedef struct VkMultisamplePropertiesEXT { 7052 VkStructureType sType; 7053 void* pNext; 7054 VkExtent2D maxSampleLocationGridSize; 7055 } VkMultisamplePropertiesEXT; 7056 7057 7058 typedef void (VKAPI_PTR *PFN_vkCmdSetSampleLocationsEXT)(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo); 7059 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT)(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties); 7060 7061 #ifndef VK_NO_PROTOTYPES 7062 VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleLocationsEXT( 7063 VkCommandBuffer commandBuffer, 7064 const VkSampleLocationsInfoEXT* pSampleLocationsInfo); 7065 7066 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMultisamplePropertiesEXT( 7067 VkPhysicalDevice physicalDevice, 7068 VkSampleCountFlagBits samples, 7069 VkMultisamplePropertiesEXT* pMultisampleProperties); 7070 #endif 7071 7072 #define VK_EXT_blend_operation_advanced 1 7073 #define VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION 2 7074 #define VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME "VK_EXT_blend_operation_advanced" 7075 7076 7077 typedef enum VkBlendOverlapEXT { 7078 VK_BLEND_OVERLAP_UNCORRELATED_EXT = 0, 7079 VK_BLEND_OVERLAP_DISJOINT_EXT = 1, 7080 VK_BLEND_OVERLAP_CONJOINT_EXT = 2, 7081 VK_BLEND_OVERLAP_BEGIN_RANGE_EXT = VK_BLEND_OVERLAP_UNCORRELATED_EXT, 7082 VK_BLEND_OVERLAP_END_RANGE_EXT = VK_BLEND_OVERLAP_CONJOINT_EXT, 7083 VK_BLEND_OVERLAP_RANGE_SIZE_EXT = (VK_BLEND_OVERLAP_CONJOINT_EXT - VK_BLEND_OVERLAP_UNCORRELATED_EXT + 1), 7084 VK_BLEND_OVERLAP_MAX_ENUM_EXT = 0x7FFFFFFF 7085 } VkBlendOverlapEXT; 7086 7087 typedef struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT { 7088 VkStructureType sType; 7089 void* pNext; 7090 VkBool32 advancedBlendCoherentOperations; 7091 } VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT; 7092 7093 typedef struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT { 7094 VkStructureType sType; 7095 void* pNext; 7096 uint32_t advancedBlendMaxColorAttachments; 7097 VkBool32 advancedBlendIndependentBlend; 7098 VkBool32 advancedBlendNonPremultipliedSrcColor; 7099 VkBool32 advancedBlendNonPremultipliedDstColor; 7100 VkBool32 advancedBlendCorrelatedOverlap; 7101 VkBool32 advancedBlendAllOperations; 7102 } VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT; 7103 7104 typedef struct VkPipelineColorBlendAdvancedStateCreateInfoEXT { 7105 VkStructureType sType; 7106 const void* pNext; 7107 VkBool32 srcPremultiplied; 7108 VkBool32 dstPremultiplied; 7109 VkBlendOverlapEXT blendOverlap; 7110 } VkPipelineColorBlendAdvancedStateCreateInfoEXT; 7111 7112 7113 7114 #define VK_NV_fragment_coverage_to_color 1 7115 #define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION 1 7116 #define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME "VK_NV_fragment_coverage_to_color" 7117 7118 typedef VkFlags VkPipelineCoverageToColorStateCreateFlagsNV; 7119 7120 typedef struct VkPipelineCoverageToColorStateCreateInfoNV { 7121 VkStructureType sType; 7122 const void* pNext; 7123 VkPipelineCoverageToColorStateCreateFlagsNV flags; 7124 VkBool32 coverageToColorEnable; 7125 uint32_t coverageToColorLocation; 7126 } VkPipelineCoverageToColorStateCreateInfoNV; 7127 7128 7129 7130 #define VK_NV_framebuffer_mixed_samples 1 7131 #define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION 1 7132 #define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME "VK_NV_framebuffer_mixed_samples" 7133 7134 7135 typedef enum VkCoverageModulationModeNV { 7136 VK_COVERAGE_MODULATION_MODE_NONE_NV = 0, 7137 VK_COVERAGE_MODULATION_MODE_RGB_NV = 1, 7138 VK_COVERAGE_MODULATION_MODE_ALPHA_NV = 2, 7139 VK_COVERAGE_MODULATION_MODE_RGBA_NV = 3, 7140 VK_COVERAGE_MODULATION_MODE_BEGIN_RANGE_NV = VK_COVERAGE_MODULATION_MODE_NONE_NV, 7141 VK_COVERAGE_MODULATION_MODE_END_RANGE_NV = VK_COVERAGE_MODULATION_MODE_RGBA_NV, 7142 VK_COVERAGE_MODULATION_MODE_RANGE_SIZE_NV = (VK_COVERAGE_MODULATION_MODE_RGBA_NV - VK_COVERAGE_MODULATION_MODE_NONE_NV + 1), 7143 VK_COVERAGE_MODULATION_MODE_MAX_ENUM_NV = 0x7FFFFFFF 7144 } VkCoverageModulationModeNV; 7145 7146 typedef VkFlags VkPipelineCoverageModulationStateCreateFlagsNV; 7147 7148 typedef struct VkPipelineCoverageModulationStateCreateInfoNV { 7149 VkStructureType sType; 7150 const void* pNext; 7151 VkPipelineCoverageModulationStateCreateFlagsNV flags; 7152 VkCoverageModulationModeNV coverageModulationMode; 7153 VkBool32 coverageModulationTableEnable; 7154 uint32_t coverageModulationTableCount; 7155 const float* pCoverageModulationTable; 7156 } VkPipelineCoverageModulationStateCreateInfoNV; 7157 7158 7159 7160 #define VK_NV_fill_rectangle 1 7161 #define VK_NV_FILL_RECTANGLE_SPEC_VERSION 1 7162 #define VK_NV_FILL_RECTANGLE_EXTENSION_NAME "VK_NV_fill_rectangle" 7163 7164 7165 #define VK_EXT_post_depth_coverage 1 7166 #define VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION 1 7167 #define VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME "VK_EXT_post_depth_coverage" 7168 7169 7170 #define VK_EXT_validation_cache 1 7171 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkValidationCacheEXT) 7172 7173 #define VK_EXT_VALIDATION_CACHE_SPEC_VERSION 1 7174 #define VK_EXT_VALIDATION_CACHE_EXTENSION_NAME "VK_EXT_validation_cache" 7175 #define VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT 7176 7177 7178 typedef enum VkValidationCacheHeaderVersionEXT { 7179 VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT = 1, 7180 VK_VALIDATION_CACHE_HEADER_VERSION_BEGIN_RANGE_EXT = VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT, 7181 VK_VALIDATION_CACHE_HEADER_VERSION_END_RANGE_EXT = VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT, 7182 VK_VALIDATION_CACHE_HEADER_VERSION_RANGE_SIZE_EXT = (VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT - VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT + 1), 7183 VK_VALIDATION_CACHE_HEADER_VERSION_MAX_ENUM_EXT = 0x7FFFFFFF 7184 } VkValidationCacheHeaderVersionEXT; 7185 7186 typedef VkFlags VkValidationCacheCreateFlagsEXT; 7187 7188 typedef struct VkValidationCacheCreateInfoEXT { 7189 VkStructureType sType; 7190 const void* pNext; 7191 VkValidationCacheCreateFlagsEXT flags; 7192 size_t initialDataSize; 7193 const void* pInitialData; 7194 } VkValidationCacheCreateInfoEXT; 7195 7196 typedef struct VkShaderModuleValidationCacheCreateInfoEXT { 7197 VkStructureType sType; 7198 const void* pNext; 7199 VkValidationCacheEXT validationCache; 7200 } VkShaderModuleValidationCacheCreateInfoEXT; 7201 7202 7203 typedef VkResult (VKAPI_PTR *PFN_vkCreateValidationCacheEXT)(VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache); 7204 typedef void (VKAPI_PTR *PFN_vkDestroyValidationCacheEXT)(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator); 7205 typedef VkResult (VKAPI_PTR *PFN_vkMergeValidationCachesEXT)(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches); 7206 typedef VkResult (VKAPI_PTR *PFN_vkGetValidationCacheDataEXT)(VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData); 7207 7208 #ifndef VK_NO_PROTOTYPES 7209 VKAPI_ATTR VkResult VKAPI_CALL vkCreateValidationCacheEXT( 7210 VkDevice device, 7211 const VkValidationCacheCreateInfoEXT* pCreateInfo, 7212 const VkAllocationCallbacks* pAllocator, 7213 VkValidationCacheEXT* pValidationCache); 7214 7215 VKAPI_ATTR void VKAPI_CALL vkDestroyValidationCacheEXT( 7216 VkDevice device, 7217 VkValidationCacheEXT validationCache, 7218 const VkAllocationCallbacks* pAllocator); 7219 7220 VKAPI_ATTR VkResult VKAPI_CALL vkMergeValidationCachesEXT( 7221 VkDevice device, 7222 VkValidationCacheEXT dstCache, 7223 uint32_t srcCacheCount, 7224 const VkValidationCacheEXT* pSrcCaches); 7225 7226 VKAPI_ATTR VkResult VKAPI_CALL vkGetValidationCacheDataEXT( 7227 VkDevice device, 7228 VkValidationCacheEXT validationCache, 7229 size_t* pDataSize, 7230 void* pData); 7231 #endif 7232 7233 #define VK_EXT_shader_viewport_index_layer 1 7234 #define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION 1 7235 #define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME "VK_EXT_shader_viewport_index_layer" 7236 7237 7238 #define VK_EXT_global_priority 1 7239 #define VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION 2 7240 #define VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME "VK_EXT_global_priority" 7241 7242 7243 typedef enum VkQueueGlobalPriorityEXT { 7244 VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT = 128, 7245 VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT = 256, 7246 VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT = 512, 7247 VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT = 1024, 7248 VK_QUEUE_GLOBAL_PRIORITY_BEGIN_RANGE_EXT = VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT, 7249 VK_QUEUE_GLOBAL_PRIORITY_END_RANGE_EXT = VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT, 7250 VK_QUEUE_GLOBAL_PRIORITY_RANGE_SIZE_EXT = (VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT - VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT + 1), 7251 VK_QUEUE_GLOBAL_PRIORITY_MAX_ENUM_EXT = 0x7FFFFFFF 7252 } VkQueueGlobalPriorityEXT; 7253 7254 typedef struct VkDeviceQueueGlobalPriorityCreateInfoEXT { 7255 VkStructureType sType; 7256 const void* pNext; 7257 VkQueueGlobalPriorityEXT globalPriority; 7258 } VkDeviceQueueGlobalPriorityCreateInfoEXT; 7259 7260 7261 7262 #define VK_EXT_external_memory_host 1 7263 #define VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION 1 7264 #define VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME "VK_EXT_external_memory_host" 7265 7266 typedef struct VkImportMemoryHostPointerInfoEXT { 7267 VkStructureType sType; 7268 const void* pNext; 7269 VkExternalMemoryHandleTypeFlagBits handleType; 7270 void* pHostPointer; 7271 } VkImportMemoryHostPointerInfoEXT; 7272 7273 typedef struct VkMemoryHostPointerPropertiesEXT { 7274 VkStructureType sType; 7275 void* pNext; 7276 uint32_t memoryTypeBits; 7277 } VkMemoryHostPointerPropertiesEXT; 7278 7279 typedef struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT { 7280 VkStructureType sType; 7281 void* pNext; 7282 VkDeviceSize minImportedHostPointerAlignment; 7283 } VkPhysicalDeviceExternalMemoryHostPropertiesEXT; 7284 7285 7286 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryHostPointerPropertiesEXT)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties); 7287 7288 #ifndef VK_NO_PROTOTYPES 7289 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryHostPointerPropertiesEXT( 7290 VkDevice device, 7291 VkExternalMemoryHandleTypeFlagBits handleType, 7292 const void* pHostPointer, 7293 VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties); 7294 #endif 7295 7296 #ifdef __cplusplus 7297 } 7298 #endif 7299 7300 #endif 7301