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