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