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