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