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