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