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