1 #ifndef VULKAN_H_ 2 #define VULKAN_H_ 1 3 4 #ifdef __cplusplus 5 extern "C" { 6 #endif 7 8 /* 9 ** Copyright (c) 2015-2017 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 66 47 48 49 #define VK_NULL_HANDLE 0 50 51 52 53 #define VK_DEFINE_HANDLE(object) typedef struct object##_T* object; 54 55 56 #if !defined(VK_DEFINE_NON_DISPATCHABLE_HANDLE) 57 #if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__) 58 #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object; 59 #else 60 #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object; 61 #endif 62 #endif 63 64 65 66 typedef uint32_t VkFlags; 67 typedef uint32_t VkBool32; 68 typedef uint64_t VkDeviceSize; 69 typedef uint32_t VkSampleMask; 70 71 VK_DEFINE_HANDLE(VkInstance) 72 VK_DEFINE_HANDLE(VkPhysicalDevice) 73 VK_DEFINE_HANDLE(VkDevice) 74 VK_DEFINE_HANDLE(VkQueue) 75 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore) 76 VK_DEFINE_HANDLE(VkCommandBuffer) 77 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence) 78 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory) 79 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer) 80 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage) 81 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent) 82 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool) 83 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView) 84 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView) 85 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule) 86 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache) 87 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout) 88 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass) 89 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline) 90 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout) 91 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler) 92 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool) 93 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet) 94 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer) 95 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool) 96 97 #define VK_LOD_CLAMP_NONE 1000.0f 98 #define VK_REMAINING_MIP_LEVELS (~0U) 99 #define VK_REMAINING_ARRAY_LAYERS (~0U) 100 #define VK_WHOLE_SIZE (~0ULL) 101 #define VK_ATTACHMENT_UNUSED (~0U) 102 #define VK_TRUE 1 103 #define VK_FALSE 0 104 #define VK_QUEUE_FAMILY_IGNORED (~0U) 105 #define VK_SUBPASS_EXTERNAL (~0U) 106 #define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE 256 107 #define VK_UUID_SIZE 16 108 #define VK_MAX_MEMORY_TYPES 32 109 #define VK_MAX_MEMORY_HEAPS 16 110 #define VK_MAX_EXTENSION_NAME_SIZE 256 111 #define VK_MAX_DESCRIPTION_SIZE 256 112 113 114 typedef enum VkPipelineCacheHeaderVersion { 115 VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1, 116 VK_PIPELINE_CACHE_HEADER_VERSION_BEGIN_RANGE = VK_PIPELINE_CACHE_HEADER_VERSION_ONE, 117 VK_PIPELINE_CACHE_HEADER_VERSION_END_RANGE = VK_PIPELINE_CACHE_HEADER_VERSION_ONE, 118 VK_PIPELINE_CACHE_HEADER_VERSION_RANGE_SIZE = (VK_PIPELINE_CACHE_HEADER_VERSION_ONE - VK_PIPELINE_CACHE_HEADER_VERSION_ONE + 1), 119 VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF 120 } VkPipelineCacheHeaderVersion; 121 122 typedef enum VkResult { 123 VK_SUCCESS = 0, 124 VK_NOT_READY = 1, 125 VK_TIMEOUT = 2, 126 VK_EVENT_SET = 3, 127 VK_EVENT_RESET = 4, 128 VK_INCOMPLETE = 5, 129 VK_ERROR_OUT_OF_HOST_MEMORY = -1, 130 VK_ERROR_OUT_OF_DEVICE_MEMORY = -2, 131 VK_ERROR_INITIALIZATION_FAILED = -3, 132 VK_ERROR_DEVICE_LOST = -4, 133 VK_ERROR_MEMORY_MAP_FAILED = -5, 134 VK_ERROR_LAYER_NOT_PRESENT = -6, 135 VK_ERROR_EXTENSION_NOT_PRESENT = -7, 136 VK_ERROR_FEATURE_NOT_PRESENT = -8, 137 VK_ERROR_INCOMPATIBLE_DRIVER = -9, 138 VK_ERROR_TOO_MANY_OBJECTS = -10, 139 VK_ERROR_FORMAT_NOT_SUPPORTED = -11, 140 VK_ERROR_FRAGMENTED_POOL = -12, 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_OUT_OF_POOL_MEMORY_KHR = -1000069000, 149 VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = -1000072003, 150 VK_ERROR_NOT_PERMITTED_EXT = -1000174001, 151 VK_RESULT_BEGIN_RANGE = VK_ERROR_FRAGMENTED_POOL, 152 VK_RESULT_END_RANGE = VK_INCOMPLETE, 153 VK_RESULT_RANGE_SIZE = (VK_INCOMPLETE - VK_ERROR_FRAGMENTED_POOL + 1), 154 VK_RESULT_MAX_ENUM = 0x7FFFFFFF 155 } VkResult; 156 157 typedef enum VkStructureType { 158 VK_STRUCTURE_TYPE_APPLICATION_INFO = 0, 159 VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1, 160 VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2, 161 VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3, 162 VK_STRUCTURE_TYPE_SUBMIT_INFO = 4, 163 VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5, 164 VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6, 165 VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7, 166 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8, 167 VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9, 168 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10, 169 VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11, 170 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12, 171 VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13, 172 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14, 173 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15, 174 VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16, 175 VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17, 176 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18, 177 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19, 178 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20, 179 VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21, 180 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22, 181 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23, 182 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24, 183 VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25, 184 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26, 185 VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27, 186 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28, 187 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29, 188 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30, 189 VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31, 190 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32, 191 VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33, 192 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34, 193 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35, 194 VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36, 195 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37, 196 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38, 197 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39, 198 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40, 199 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41, 200 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42, 201 VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43, 202 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44, 203 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45, 204 VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46, 205 VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47, 206 VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48, 207 VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000, 208 VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001, 209 VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000, 210 VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001, 211 VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000, 212 VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000, 213 VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000, 214 VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000, 215 VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR = 1000007000, 216 VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000, 217 VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000, 218 VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000, 219 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000, 220 VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000, 221 VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001, 222 VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002, 223 VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000, 224 VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001, 225 VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002, 226 VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD = 1000041000, 227 VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHX = 1000053000, 228 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHX = 1000053001, 229 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHX = 1000053002, 230 VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000, 231 VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001, 232 VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000, 233 VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057001, 234 VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000, 235 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR = 1000059000, 236 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR = 1000059001, 237 VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR = 1000059002, 238 VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR = 1000059003, 239 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR = 1000059004, 240 VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR = 1000059005, 241 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR = 1000059006, 242 VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR = 1000059007, 243 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR = 1000059008, 244 VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHX = 1000060000, 245 VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHX = 1000060003, 246 VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHX = 1000060004, 247 VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHX = 1000060005, 248 VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHX = 1000060006, 249 VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHX = 1000060010, 250 VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHX = 1000060013, 251 VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHX = 1000060014, 252 VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHX = 1000060007, 253 VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHX = 1000060008, 254 VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHX = 1000060009, 255 VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHX = 1000060011, 256 VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHX = 1000060012, 257 VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = 1000061000, 258 VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN = 1000062000, 259 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHX = 1000070000, 260 VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHX = 1000070001, 261 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR = 1000071000, 262 VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR = 1000071001, 263 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR = 1000071002, 264 VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR = 1000071003, 265 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR = 1000071004, 266 VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR = 1000072000, 267 VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR = 1000072001, 268 VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR = 1000072002, 269 VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073000, 270 VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073001, 271 VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR = 1000073002, 272 VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR = 1000073003, 273 VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR = 1000074000, 274 VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR = 1000074001, 275 VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR = 1000074002, 276 VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR = 1000075000, 277 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR = 1000076000, 278 VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR = 1000076001, 279 VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR = 1000077000, 280 VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078000, 281 VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078001, 282 VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR = 1000078002, 283 VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR = 1000078003, 284 VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR = 1000079000, 285 VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR = 1000079001, 286 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = 1000080000, 287 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR = 1000083000, 288 VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000, 289 VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = 1000085000, 290 VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX = 1000086000, 291 VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX = 1000086001, 292 VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX = 1000086002, 293 VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX = 1000086003, 294 VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX = 1000086004, 295 VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX = 1000086005, 296 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV = 1000087000, 297 VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT = 1000090000, 298 VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT = 1000091000, 299 VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT = 1000091001, 300 VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT = 1000091002, 301 VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT = 1000091003, 302 VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE = 1000092000, 303 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX = 1000097000, 304 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV = 1000098000, 305 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT = 1000099000, 306 VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT = 1000099001, 307 VK_STRUCTURE_TYPE_HDR_METADATA_EXT = 1000105000, 308 VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000, 309 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR = 1000112000, 310 VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR = 1000112001, 311 VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR = 1000113000, 312 VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114000, 313 VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114001, 314 VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR = 1000114002, 315 VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR = 1000115000, 316 VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR = 1000115001, 317 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR = 1000117000, 318 VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR = 1000117001, 319 VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR = 1000117002, 320 VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR = 1000117003, 321 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000, 322 VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001, 323 VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002, 324 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR = 1000120000, 325 VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK = 1000122000, 326 VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = 1000123000, 327 VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR = 1000127000, 328 VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR = 1000127001, 329 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT = 1000130000, 330 VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT = 1000130001, 331 VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT = 1000143000, 332 VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT = 1000143001, 333 VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT = 1000143002, 334 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT = 1000143003, 335 VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT = 1000143004, 336 VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR = 1000146000, 337 VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR = 1000146001, 338 VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR = 1000146002, 339 VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR = 1000146003, 340 VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR = 1000146004, 341 VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR = 1000147000, 342 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT = 1000148000, 343 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT = 1000148001, 344 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT = 1000148002, 345 VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV = 1000149000, 346 VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV = 1000152000, 347 VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR = 1000156000, 348 VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR = 1000156001, 349 VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR = 1000156002, 350 VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR = 1000156003, 351 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR = 1000156004, 352 VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR = 1000156005, 353 VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR = 1000157000, 354 VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR = 1000157001, 355 VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160000, 356 VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160001, 357 VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT = 1000174000, 358 VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT = 1000178000, 359 VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT = 1000178001, 360 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002, 361 VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO, 362 VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO, 363 VK_STRUCTURE_TYPE_RANGE_SIZE = (VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1), 364 VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF 365 } VkStructureType; 366 367 typedef enum VkSystemAllocationScope { 368 VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0, 369 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1, 370 VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2, 371 VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3, 372 VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4, 373 VK_SYSTEM_ALLOCATION_SCOPE_BEGIN_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_COMMAND, 374 VK_SYSTEM_ALLOCATION_SCOPE_END_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE, 375 VK_SYSTEM_ALLOCATION_SCOPE_RANGE_SIZE = (VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE - VK_SYSTEM_ALLOCATION_SCOPE_COMMAND + 1), 376 VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF 377 } VkSystemAllocationScope; 378 379 typedef enum VkInternalAllocationType { 380 VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0, 381 VK_INTERNAL_ALLOCATION_TYPE_BEGIN_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE, 382 VK_INTERNAL_ALLOCATION_TYPE_END_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE, 383 VK_INTERNAL_ALLOCATION_TYPE_RANGE_SIZE = (VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE - VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE + 1), 384 VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF 385 } VkInternalAllocationType; 386 387 typedef enum VkFormat { 388 VK_FORMAT_UNDEFINED = 0, 389 VK_FORMAT_R4G4_UNORM_PACK8 = 1, 390 VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2, 391 VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3, 392 VK_FORMAT_R5G6B5_UNORM_PACK16 = 4, 393 VK_FORMAT_B5G6R5_UNORM_PACK16 = 5, 394 VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6, 395 VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7, 396 VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8, 397 VK_FORMAT_R8_UNORM = 9, 398 VK_FORMAT_R8_SNORM = 10, 399 VK_FORMAT_R8_USCALED = 11, 400 VK_FORMAT_R8_SSCALED = 12, 401 VK_FORMAT_R8_UINT = 13, 402 VK_FORMAT_R8_SINT = 14, 403 VK_FORMAT_R8_SRGB = 15, 404 VK_FORMAT_R8G8_UNORM = 16, 405 VK_FORMAT_R8G8_SNORM = 17, 406 VK_FORMAT_R8G8_USCALED = 18, 407 VK_FORMAT_R8G8_SSCALED = 19, 408 VK_FORMAT_R8G8_UINT = 20, 409 VK_FORMAT_R8G8_SINT = 21, 410 VK_FORMAT_R8G8_SRGB = 22, 411 VK_FORMAT_R8G8B8_UNORM = 23, 412 VK_FORMAT_R8G8B8_SNORM = 24, 413 VK_FORMAT_R8G8B8_USCALED = 25, 414 VK_FORMAT_R8G8B8_SSCALED = 26, 415 VK_FORMAT_R8G8B8_UINT = 27, 416 VK_FORMAT_R8G8B8_SINT = 28, 417 VK_FORMAT_R8G8B8_SRGB = 29, 418 VK_FORMAT_B8G8R8_UNORM = 30, 419 VK_FORMAT_B8G8R8_SNORM = 31, 420 VK_FORMAT_B8G8R8_USCALED = 32, 421 VK_FORMAT_B8G8R8_SSCALED = 33, 422 VK_FORMAT_B8G8R8_UINT = 34, 423 VK_FORMAT_B8G8R8_SINT = 35, 424 VK_FORMAT_B8G8R8_SRGB = 36, 425 VK_FORMAT_R8G8B8A8_UNORM = 37, 426 VK_FORMAT_R8G8B8A8_SNORM = 38, 427 VK_FORMAT_R8G8B8A8_USCALED = 39, 428 VK_FORMAT_R8G8B8A8_SSCALED = 40, 429 VK_FORMAT_R8G8B8A8_UINT = 41, 430 VK_FORMAT_R8G8B8A8_SINT = 42, 431 VK_FORMAT_R8G8B8A8_SRGB = 43, 432 VK_FORMAT_B8G8R8A8_UNORM = 44, 433 VK_FORMAT_B8G8R8A8_SNORM = 45, 434 VK_FORMAT_B8G8R8A8_USCALED = 46, 435 VK_FORMAT_B8G8R8A8_SSCALED = 47, 436 VK_FORMAT_B8G8R8A8_UINT = 48, 437 VK_FORMAT_B8G8R8A8_SINT = 49, 438 VK_FORMAT_B8G8R8A8_SRGB = 50, 439 VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51, 440 VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52, 441 VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53, 442 VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54, 443 VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55, 444 VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56, 445 VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57, 446 VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58, 447 VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59, 448 VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60, 449 VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61, 450 VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62, 451 VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63, 452 VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64, 453 VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65, 454 VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66, 455 VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67, 456 VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68, 457 VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69, 458 VK_FORMAT_R16_UNORM = 70, 459 VK_FORMAT_R16_SNORM = 71, 460 VK_FORMAT_R16_USCALED = 72, 461 VK_FORMAT_R16_SSCALED = 73, 462 VK_FORMAT_R16_UINT = 74, 463 VK_FORMAT_R16_SINT = 75, 464 VK_FORMAT_R16_SFLOAT = 76, 465 VK_FORMAT_R16G16_UNORM = 77, 466 VK_FORMAT_R16G16_SNORM = 78, 467 VK_FORMAT_R16G16_USCALED = 79, 468 VK_FORMAT_R16G16_SSCALED = 80, 469 VK_FORMAT_R16G16_UINT = 81, 470 VK_FORMAT_R16G16_SINT = 82, 471 VK_FORMAT_R16G16_SFLOAT = 83, 472 VK_FORMAT_R16G16B16_UNORM = 84, 473 VK_FORMAT_R16G16B16_SNORM = 85, 474 VK_FORMAT_R16G16B16_USCALED = 86, 475 VK_FORMAT_R16G16B16_SSCALED = 87, 476 VK_FORMAT_R16G16B16_UINT = 88, 477 VK_FORMAT_R16G16B16_SINT = 89, 478 VK_FORMAT_R16G16B16_SFLOAT = 90, 479 VK_FORMAT_R16G16B16A16_UNORM = 91, 480 VK_FORMAT_R16G16B16A16_SNORM = 92, 481 VK_FORMAT_R16G16B16A16_USCALED = 93, 482 VK_FORMAT_R16G16B16A16_SSCALED = 94, 483 VK_FORMAT_R16G16B16A16_UINT = 95, 484 VK_FORMAT_R16G16B16A16_SINT = 96, 485 VK_FORMAT_R16G16B16A16_SFLOAT = 97, 486 VK_FORMAT_R32_UINT = 98, 487 VK_FORMAT_R32_SINT = 99, 488 VK_FORMAT_R32_SFLOAT = 100, 489 VK_FORMAT_R32G32_UINT = 101, 490 VK_FORMAT_R32G32_SINT = 102, 491 VK_FORMAT_R32G32_SFLOAT = 103, 492 VK_FORMAT_R32G32B32_UINT = 104, 493 VK_FORMAT_R32G32B32_SINT = 105, 494 VK_FORMAT_R32G32B32_SFLOAT = 106, 495 VK_FORMAT_R32G32B32A32_UINT = 107, 496 VK_FORMAT_R32G32B32A32_SINT = 108, 497 VK_FORMAT_R32G32B32A32_SFLOAT = 109, 498 VK_FORMAT_R64_UINT = 110, 499 VK_FORMAT_R64_SINT = 111, 500 VK_FORMAT_R64_SFLOAT = 112, 501 VK_FORMAT_R64G64_UINT = 113, 502 VK_FORMAT_R64G64_SINT = 114, 503 VK_FORMAT_R64G64_SFLOAT = 115, 504 VK_FORMAT_R64G64B64_UINT = 116, 505 VK_FORMAT_R64G64B64_SINT = 117, 506 VK_FORMAT_R64G64B64_SFLOAT = 118, 507 VK_FORMAT_R64G64B64A64_UINT = 119, 508 VK_FORMAT_R64G64B64A64_SINT = 120, 509 VK_FORMAT_R64G64B64A64_SFLOAT = 121, 510 VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122, 511 VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123, 512 VK_FORMAT_D16_UNORM = 124, 513 VK_FORMAT_X8_D24_UNORM_PACK32 = 125, 514 VK_FORMAT_D32_SFLOAT = 126, 515 VK_FORMAT_S8_UINT = 127, 516 VK_FORMAT_D16_UNORM_S8_UINT = 128, 517 VK_FORMAT_D24_UNORM_S8_UINT = 129, 518 VK_FORMAT_D32_SFLOAT_S8_UINT = 130, 519 VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131, 520 VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132, 521 VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133, 522 VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134, 523 VK_FORMAT_BC2_UNORM_BLOCK = 135, 524 VK_FORMAT_BC2_SRGB_BLOCK = 136, 525 VK_FORMAT_BC3_UNORM_BLOCK = 137, 526 VK_FORMAT_BC3_SRGB_BLOCK = 138, 527 VK_FORMAT_BC4_UNORM_BLOCK = 139, 528 VK_FORMAT_BC4_SNORM_BLOCK = 140, 529 VK_FORMAT_BC5_UNORM_BLOCK = 141, 530 VK_FORMAT_BC5_SNORM_BLOCK = 142, 531 VK_FORMAT_BC6H_UFLOAT_BLOCK = 143, 532 VK_FORMAT_BC6H_SFLOAT_BLOCK = 144, 533 VK_FORMAT_BC7_UNORM_BLOCK = 145, 534 VK_FORMAT_BC7_SRGB_BLOCK = 146, 535 VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147, 536 VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148, 537 VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149, 538 VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150, 539 VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151, 540 VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152, 541 VK_FORMAT_EAC_R11_UNORM_BLOCK = 153, 542 VK_FORMAT_EAC_R11_SNORM_BLOCK = 154, 543 VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155, 544 VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156, 545 VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157, 546 VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158, 547 VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159, 548 VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160, 549 VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161, 550 VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162, 551 VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163, 552 VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164, 553 VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165, 554 VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166, 555 VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167, 556 VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168, 557 VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169, 558 VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170, 559 VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171, 560 VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172, 561 VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173, 562 VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174, 563 VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175, 564 VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176, 565 VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177, 566 VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178, 567 VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179, 568 VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180, 569 VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181, 570 VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182, 571 VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183, 572 VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184, 573 VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000, 574 VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001, 575 VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002, 576 VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003, 577 VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004, 578 VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005, 579 VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006, 580 VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007, 581 VK_FORMAT_G8B8G8R8_422_UNORM_KHR = 1000156000, 582 VK_FORMAT_B8G8R8G8_422_UNORM_KHR = 1000156001, 583 VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR = 1000156002, 584 VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR = 1000156003, 585 VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR = 1000156004, 586 VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR = 1000156005, 587 VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR = 1000156006, 588 VK_FORMAT_R10X6_UNORM_PACK16_KHR = 1000156007, 589 VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR = 1000156008, 590 VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR = 1000156009, 591 VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR = 1000156010, 592 VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR = 1000156011, 593 VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR = 1000156012, 594 VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR = 1000156013, 595 VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR = 1000156014, 596 VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR = 1000156015, 597 VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR = 1000156016, 598 VK_FORMAT_R12X4_UNORM_PACK16_KHR = 1000156017, 599 VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR = 1000156018, 600 VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR = 1000156019, 601 VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR = 1000156020, 602 VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR = 1000156021, 603 VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR = 1000156022, 604 VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR = 1000156023, 605 VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR = 1000156024, 606 VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR = 1000156025, 607 VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR = 1000156026, 608 VK_FORMAT_G16B16G16R16_422_UNORM_KHR = 1000156027, 609 VK_FORMAT_B16G16R16G16_422_UNORM_KHR = 1000156028, 610 VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR = 1000156029, 611 VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR = 1000156030, 612 VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR = 1000156031, 613 VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR = 1000156032, 614 VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR = 1000156033, 615 VK_FORMAT_BEGIN_RANGE = VK_FORMAT_UNDEFINED, 616 VK_FORMAT_END_RANGE = VK_FORMAT_ASTC_12x12_SRGB_BLOCK, 617 VK_FORMAT_RANGE_SIZE = (VK_FORMAT_ASTC_12x12_SRGB_BLOCK - VK_FORMAT_UNDEFINED + 1), 618 VK_FORMAT_MAX_ENUM = 0x7FFFFFFF 619 } VkFormat; 620 621 typedef enum VkImageType { 622 VK_IMAGE_TYPE_1D = 0, 623 VK_IMAGE_TYPE_2D = 1, 624 VK_IMAGE_TYPE_3D = 2, 625 VK_IMAGE_TYPE_BEGIN_RANGE = VK_IMAGE_TYPE_1D, 626 VK_IMAGE_TYPE_END_RANGE = VK_IMAGE_TYPE_3D, 627 VK_IMAGE_TYPE_RANGE_SIZE = (VK_IMAGE_TYPE_3D - VK_IMAGE_TYPE_1D + 1), 628 VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF 629 } VkImageType; 630 631 typedef enum VkImageTiling { 632 VK_IMAGE_TILING_OPTIMAL = 0, 633 VK_IMAGE_TILING_LINEAR = 1, 634 VK_IMAGE_TILING_BEGIN_RANGE = VK_IMAGE_TILING_OPTIMAL, 635 VK_IMAGE_TILING_END_RANGE = VK_IMAGE_TILING_LINEAR, 636 VK_IMAGE_TILING_RANGE_SIZE = (VK_IMAGE_TILING_LINEAR - VK_IMAGE_TILING_OPTIMAL + 1), 637 VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF 638 } VkImageTiling; 639 640 typedef enum VkPhysicalDeviceType { 641 VK_PHYSICAL_DEVICE_TYPE_OTHER = 0, 642 VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1, 643 VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2, 644 VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3, 645 VK_PHYSICAL_DEVICE_TYPE_CPU = 4, 646 VK_PHYSICAL_DEVICE_TYPE_BEGIN_RANGE = VK_PHYSICAL_DEVICE_TYPE_OTHER, 647 VK_PHYSICAL_DEVICE_TYPE_END_RANGE = VK_PHYSICAL_DEVICE_TYPE_CPU, 648 VK_PHYSICAL_DEVICE_TYPE_RANGE_SIZE = (VK_PHYSICAL_DEVICE_TYPE_CPU - VK_PHYSICAL_DEVICE_TYPE_OTHER + 1), 649 VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF 650 } VkPhysicalDeviceType; 651 652 typedef enum VkQueryType { 653 VK_QUERY_TYPE_OCCLUSION = 0, 654 VK_QUERY_TYPE_PIPELINE_STATISTICS = 1, 655 VK_QUERY_TYPE_TIMESTAMP = 2, 656 VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION, 657 VK_QUERY_TYPE_END_RANGE = VK_QUERY_TYPE_TIMESTAMP, 658 VK_QUERY_TYPE_RANGE_SIZE = (VK_QUERY_TYPE_TIMESTAMP - VK_QUERY_TYPE_OCCLUSION + 1), 659 VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF 660 } VkQueryType; 661 662 typedef enum VkSharingMode { 663 VK_SHARING_MODE_EXCLUSIVE = 0, 664 VK_SHARING_MODE_CONCURRENT = 1, 665 VK_SHARING_MODE_BEGIN_RANGE = VK_SHARING_MODE_EXCLUSIVE, 666 VK_SHARING_MODE_END_RANGE = VK_SHARING_MODE_CONCURRENT, 667 VK_SHARING_MODE_RANGE_SIZE = (VK_SHARING_MODE_CONCURRENT - VK_SHARING_MODE_EXCLUSIVE + 1), 668 VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF 669 } VkSharingMode; 670 671 typedef enum VkImageLayout { 672 VK_IMAGE_LAYOUT_UNDEFINED = 0, 673 VK_IMAGE_LAYOUT_GENERAL = 1, 674 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2, 675 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3, 676 VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4, 677 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5, 678 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6, 679 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7, 680 VK_IMAGE_LAYOUT_PREINITIALIZED = 8, 681 VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002, 682 VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000, 683 VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR = 1000117000, 684 VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR = 1000117001, 685 VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED, 686 VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_PREINITIALIZED, 687 VK_IMAGE_LAYOUT_RANGE_SIZE = (VK_IMAGE_LAYOUT_PREINITIALIZED - VK_IMAGE_LAYOUT_UNDEFINED + 1), 688 VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF 689 } VkImageLayout; 690 691 typedef enum VkImageViewType { 692 VK_IMAGE_VIEW_TYPE_1D = 0, 693 VK_IMAGE_VIEW_TYPE_2D = 1, 694 VK_IMAGE_VIEW_TYPE_3D = 2, 695 VK_IMAGE_VIEW_TYPE_CUBE = 3, 696 VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4, 697 VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5, 698 VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6, 699 VK_IMAGE_VIEW_TYPE_BEGIN_RANGE = VK_IMAGE_VIEW_TYPE_1D, 700 VK_IMAGE_VIEW_TYPE_END_RANGE = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, 701 VK_IMAGE_VIEW_TYPE_RANGE_SIZE = (VK_IMAGE_VIEW_TYPE_CUBE_ARRAY - VK_IMAGE_VIEW_TYPE_1D + 1), 702 VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF 703 } VkImageViewType; 704 705 typedef enum VkComponentSwizzle { 706 VK_COMPONENT_SWIZZLE_IDENTITY = 0, 707 VK_COMPONENT_SWIZZLE_ZERO = 1, 708 VK_COMPONENT_SWIZZLE_ONE = 2, 709 VK_COMPONENT_SWIZZLE_R = 3, 710 VK_COMPONENT_SWIZZLE_G = 4, 711 VK_COMPONENT_SWIZZLE_B = 5, 712 VK_COMPONENT_SWIZZLE_A = 6, 713 VK_COMPONENT_SWIZZLE_BEGIN_RANGE = VK_COMPONENT_SWIZZLE_IDENTITY, 714 VK_COMPONENT_SWIZZLE_END_RANGE = VK_COMPONENT_SWIZZLE_A, 715 VK_COMPONENT_SWIZZLE_RANGE_SIZE = (VK_COMPONENT_SWIZZLE_A - VK_COMPONENT_SWIZZLE_IDENTITY + 1), 716 VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF 717 } VkComponentSwizzle; 718 719 typedef enum VkVertexInputRate { 720 VK_VERTEX_INPUT_RATE_VERTEX = 0, 721 VK_VERTEX_INPUT_RATE_INSTANCE = 1, 722 VK_VERTEX_INPUT_RATE_BEGIN_RANGE = VK_VERTEX_INPUT_RATE_VERTEX, 723 VK_VERTEX_INPUT_RATE_END_RANGE = VK_VERTEX_INPUT_RATE_INSTANCE, 724 VK_VERTEX_INPUT_RATE_RANGE_SIZE = (VK_VERTEX_INPUT_RATE_INSTANCE - VK_VERTEX_INPUT_RATE_VERTEX + 1), 725 VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF 726 } VkVertexInputRate; 727 728 typedef enum VkPrimitiveTopology { 729 VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0, 730 VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1, 731 VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2, 732 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3, 733 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4, 734 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5, 735 VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6, 736 VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7, 737 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8, 738 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9, 739 VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10, 740 VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = VK_PRIMITIVE_TOPOLOGY_POINT_LIST, 741 VK_PRIMITIVE_TOPOLOGY_END_RANGE = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, 742 VK_PRIMITIVE_TOPOLOGY_RANGE_SIZE = (VK_PRIMITIVE_TOPOLOGY_PATCH_LIST - VK_PRIMITIVE_TOPOLOGY_POINT_LIST + 1), 743 VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF 744 } VkPrimitiveTopology; 745 746 typedef enum VkPolygonMode { 747 VK_POLYGON_MODE_FILL = 0, 748 VK_POLYGON_MODE_LINE = 1, 749 VK_POLYGON_MODE_POINT = 2, 750 VK_POLYGON_MODE_FILL_RECTANGLE_NV = 1000153000, 751 VK_POLYGON_MODE_BEGIN_RANGE = VK_POLYGON_MODE_FILL, 752 VK_POLYGON_MODE_END_RANGE = VK_POLYGON_MODE_POINT, 753 VK_POLYGON_MODE_RANGE_SIZE = (VK_POLYGON_MODE_POINT - VK_POLYGON_MODE_FILL + 1), 754 VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF 755 } VkPolygonMode; 756 757 typedef enum VkFrontFace { 758 VK_FRONT_FACE_COUNTER_CLOCKWISE = 0, 759 VK_FRONT_FACE_CLOCKWISE = 1, 760 VK_FRONT_FACE_BEGIN_RANGE = VK_FRONT_FACE_COUNTER_CLOCKWISE, 761 VK_FRONT_FACE_END_RANGE = VK_FRONT_FACE_CLOCKWISE, 762 VK_FRONT_FACE_RANGE_SIZE = (VK_FRONT_FACE_CLOCKWISE - VK_FRONT_FACE_COUNTER_CLOCKWISE + 1), 763 VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF 764 } VkFrontFace; 765 766 typedef enum VkCompareOp { 767 VK_COMPARE_OP_NEVER = 0, 768 VK_COMPARE_OP_LESS = 1, 769 VK_COMPARE_OP_EQUAL = 2, 770 VK_COMPARE_OP_LESS_OR_EQUAL = 3, 771 VK_COMPARE_OP_GREATER = 4, 772 VK_COMPARE_OP_NOT_EQUAL = 5, 773 VK_COMPARE_OP_GREATER_OR_EQUAL = 6, 774 VK_COMPARE_OP_ALWAYS = 7, 775 VK_COMPARE_OP_BEGIN_RANGE = VK_COMPARE_OP_NEVER, 776 VK_COMPARE_OP_END_RANGE = VK_COMPARE_OP_ALWAYS, 777 VK_COMPARE_OP_RANGE_SIZE = (VK_COMPARE_OP_ALWAYS - VK_COMPARE_OP_NEVER + 1), 778 VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF 779 } VkCompareOp; 780 781 typedef enum VkStencilOp { 782 VK_STENCIL_OP_KEEP = 0, 783 VK_STENCIL_OP_ZERO = 1, 784 VK_STENCIL_OP_REPLACE = 2, 785 VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3, 786 VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4, 787 VK_STENCIL_OP_INVERT = 5, 788 VK_STENCIL_OP_INCREMENT_AND_WRAP = 6, 789 VK_STENCIL_OP_DECREMENT_AND_WRAP = 7, 790 VK_STENCIL_OP_BEGIN_RANGE = VK_STENCIL_OP_KEEP, 791 VK_STENCIL_OP_END_RANGE = VK_STENCIL_OP_DECREMENT_AND_WRAP, 792 VK_STENCIL_OP_RANGE_SIZE = (VK_STENCIL_OP_DECREMENT_AND_WRAP - VK_STENCIL_OP_KEEP + 1), 793 VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF 794 } VkStencilOp; 795 796 typedef enum VkLogicOp { 797 VK_LOGIC_OP_CLEAR = 0, 798 VK_LOGIC_OP_AND = 1, 799 VK_LOGIC_OP_AND_REVERSE = 2, 800 VK_LOGIC_OP_COPY = 3, 801 VK_LOGIC_OP_AND_INVERTED = 4, 802 VK_LOGIC_OP_NO_OP = 5, 803 VK_LOGIC_OP_XOR = 6, 804 VK_LOGIC_OP_OR = 7, 805 VK_LOGIC_OP_NOR = 8, 806 VK_LOGIC_OP_EQUIVALENT = 9, 807 VK_LOGIC_OP_INVERT = 10, 808 VK_LOGIC_OP_OR_REVERSE = 11, 809 VK_LOGIC_OP_COPY_INVERTED = 12, 810 VK_LOGIC_OP_OR_INVERTED = 13, 811 VK_LOGIC_OP_NAND = 14, 812 VK_LOGIC_OP_SET = 15, 813 VK_LOGIC_OP_BEGIN_RANGE = VK_LOGIC_OP_CLEAR, 814 VK_LOGIC_OP_END_RANGE = VK_LOGIC_OP_SET, 815 VK_LOGIC_OP_RANGE_SIZE = (VK_LOGIC_OP_SET - VK_LOGIC_OP_CLEAR + 1), 816 VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF 817 } VkLogicOp; 818 819 typedef enum VkBlendFactor { 820 VK_BLEND_FACTOR_ZERO = 0, 821 VK_BLEND_FACTOR_ONE = 1, 822 VK_BLEND_FACTOR_SRC_COLOR = 2, 823 VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3, 824 VK_BLEND_FACTOR_DST_COLOR = 4, 825 VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5, 826 VK_BLEND_FACTOR_SRC_ALPHA = 6, 827 VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7, 828 VK_BLEND_FACTOR_DST_ALPHA = 8, 829 VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9, 830 VK_BLEND_FACTOR_CONSTANT_COLOR = 10, 831 VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11, 832 VK_BLEND_FACTOR_CONSTANT_ALPHA = 12, 833 VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13, 834 VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14, 835 VK_BLEND_FACTOR_SRC1_COLOR = 15, 836 VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16, 837 VK_BLEND_FACTOR_SRC1_ALPHA = 17, 838 VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18, 839 VK_BLEND_FACTOR_BEGIN_RANGE = VK_BLEND_FACTOR_ZERO, 840 VK_BLEND_FACTOR_END_RANGE = VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA, 841 VK_BLEND_FACTOR_RANGE_SIZE = (VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA - VK_BLEND_FACTOR_ZERO + 1), 842 VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF 843 } VkBlendFactor; 844 845 typedef enum VkBlendOp { 846 VK_BLEND_OP_ADD = 0, 847 VK_BLEND_OP_SUBTRACT = 1, 848 VK_BLEND_OP_REVERSE_SUBTRACT = 2, 849 VK_BLEND_OP_MIN = 3, 850 VK_BLEND_OP_MAX = 4, 851 VK_BLEND_OP_ZERO_EXT = 1000148000, 852 VK_BLEND_OP_SRC_EXT = 1000148001, 853 VK_BLEND_OP_DST_EXT = 1000148002, 854 VK_BLEND_OP_SRC_OVER_EXT = 1000148003, 855 VK_BLEND_OP_DST_OVER_EXT = 1000148004, 856 VK_BLEND_OP_SRC_IN_EXT = 1000148005, 857 VK_BLEND_OP_DST_IN_EXT = 1000148006, 858 VK_BLEND_OP_SRC_OUT_EXT = 1000148007, 859 VK_BLEND_OP_DST_OUT_EXT = 1000148008, 860 VK_BLEND_OP_SRC_ATOP_EXT = 1000148009, 861 VK_BLEND_OP_DST_ATOP_EXT = 1000148010, 862 VK_BLEND_OP_XOR_EXT = 1000148011, 863 VK_BLEND_OP_MULTIPLY_EXT = 1000148012, 864 VK_BLEND_OP_SCREEN_EXT = 1000148013, 865 VK_BLEND_OP_OVERLAY_EXT = 1000148014, 866 VK_BLEND_OP_DARKEN_EXT = 1000148015, 867 VK_BLEND_OP_LIGHTEN_EXT = 1000148016, 868 VK_BLEND_OP_COLORDODGE_EXT = 1000148017, 869 VK_BLEND_OP_COLORBURN_EXT = 1000148018, 870 VK_BLEND_OP_HARDLIGHT_EXT = 1000148019, 871 VK_BLEND_OP_SOFTLIGHT_EXT = 1000148020, 872 VK_BLEND_OP_DIFFERENCE_EXT = 1000148021, 873 VK_BLEND_OP_EXCLUSION_EXT = 1000148022, 874 VK_BLEND_OP_INVERT_EXT = 1000148023, 875 VK_BLEND_OP_INVERT_RGB_EXT = 1000148024, 876 VK_BLEND_OP_LINEARDODGE_EXT = 1000148025, 877 VK_BLEND_OP_LINEARBURN_EXT = 1000148026, 878 VK_BLEND_OP_VIVIDLIGHT_EXT = 1000148027, 879 VK_BLEND_OP_LINEARLIGHT_EXT = 1000148028, 880 VK_BLEND_OP_PINLIGHT_EXT = 1000148029, 881 VK_BLEND_OP_HARDMIX_EXT = 1000148030, 882 VK_BLEND_OP_HSL_HUE_EXT = 1000148031, 883 VK_BLEND_OP_HSL_SATURATION_EXT = 1000148032, 884 VK_BLEND_OP_HSL_COLOR_EXT = 1000148033, 885 VK_BLEND_OP_HSL_LUMINOSITY_EXT = 1000148034, 886 VK_BLEND_OP_PLUS_EXT = 1000148035, 887 VK_BLEND_OP_PLUS_CLAMPED_EXT = 1000148036, 888 VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT = 1000148037, 889 VK_BLEND_OP_PLUS_DARKER_EXT = 1000148038, 890 VK_BLEND_OP_MINUS_EXT = 1000148039, 891 VK_BLEND_OP_MINUS_CLAMPED_EXT = 1000148040, 892 VK_BLEND_OP_CONTRAST_EXT = 1000148041, 893 VK_BLEND_OP_INVERT_OVG_EXT = 1000148042, 894 VK_BLEND_OP_RED_EXT = 1000148043, 895 VK_BLEND_OP_GREEN_EXT = 1000148044, 896 VK_BLEND_OP_BLUE_EXT = 1000148045, 897 VK_BLEND_OP_BEGIN_RANGE = VK_BLEND_OP_ADD, 898 VK_BLEND_OP_END_RANGE = VK_BLEND_OP_MAX, 899 VK_BLEND_OP_RANGE_SIZE = (VK_BLEND_OP_MAX - VK_BLEND_OP_ADD + 1), 900 VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF 901 } VkBlendOp; 902 903 typedef enum VkDynamicState { 904 VK_DYNAMIC_STATE_VIEWPORT = 0, 905 VK_DYNAMIC_STATE_SCISSOR = 1, 906 VK_DYNAMIC_STATE_LINE_WIDTH = 2, 907 VK_DYNAMIC_STATE_DEPTH_BIAS = 3, 908 VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4, 909 VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5, 910 VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6, 911 VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7, 912 VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8, 913 VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV = 1000087000, 914 VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = 1000099000, 915 VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT = 1000143000, 916 VK_DYNAMIC_STATE_BEGIN_RANGE = VK_DYNAMIC_STATE_VIEWPORT, 917 VK_DYNAMIC_STATE_END_RANGE = VK_DYNAMIC_STATE_STENCIL_REFERENCE, 918 VK_DYNAMIC_STATE_RANGE_SIZE = (VK_DYNAMIC_STATE_STENCIL_REFERENCE - VK_DYNAMIC_STATE_VIEWPORT + 1), 919 VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF 920 } VkDynamicState; 921 922 typedef enum VkFilter { 923 VK_FILTER_NEAREST = 0, 924 VK_FILTER_LINEAR = 1, 925 VK_FILTER_CUBIC_IMG = 1000015000, 926 VK_FILTER_BEGIN_RANGE = VK_FILTER_NEAREST, 927 VK_FILTER_END_RANGE = VK_FILTER_LINEAR, 928 VK_FILTER_RANGE_SIZE = (VK_FILTER_LINEAR - VK_FILTER_NEAREST + 1), 929 VK_FILTER_MAX_ENUM = 0x7FFFFFFF 930 } VkFilter; 931 932 typedef enum VkSamplerMipmapMode { 933 VK_SAMPLER_MIPMAP_MODE_NEAREST = 0, 934 VK_SAMPLER_MIPMAP_MODE_LINEAR = 1, 935 VK_SAMPLER_MIPMAP_MODE_BEGIN_RANGE = VK_SAMPLER_MIPMAP_MODE_NEAREST, 936 VK_SAMPLER_MIPMAP_MODE_END_RANGE = VK_SAMPLER_MIPMAP_MODE_LINEAR, 937 VK_SAMPLER_MIPMAP_MODE_RANGE_SIZE = (VK_SAMPLER_MIPMAP_MODE_LINEAR - VK_SAMPLER_MIPMAP_MODE_NEAREST + 1), 938 VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF 939 } VkSamplerMipmapMode; 940 941 typedef enum VkSamplerAddressMode { 942 VK_SAMPLER_ADDRESS_MODE_REPEAT = 0, 943 VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1, 944 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2, 945 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3, 946 VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4, 947 VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE = VK_SAMPLER_ADDRESS_MODE_REPEAT, 948 VK_SAMPLER_ADDRESS_MODE_END_RANGE = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER, 949 VK_SAMPLER_ADDRESS_MODE_RANGE_SIZE = (VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER - VK_SAMPLER_ADDRESS_MODE_REPEAT + 1), 950 VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF 951 } VkSamplerAddressMode; 952 953 typedef enum VkBorderColor { 954 VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0, 955 VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1, 956 VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2, 957 VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3, 958 VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4, 959 VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5, 960 VK_BORDER_COLOR_BEGIN_RANGE = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, 961 VK_BORDER_COLOR_END_RANGE = VK_BORDER_COLOR_INT_OPAQUE_WHITE, 962 VK_BORDER_COLOR_RANGE_SIZE = (VK_BORDER_COLOR_INT_OPAQUE_WHITE - VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK + 1), 963 VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF 964 } VkBorderColor; 965 966 typedef enum VkDescriptorType { 967 VK_DESCRIPTOR_TYPE_SAMPLER = 0, 968 VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1, 969 VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2, 970 VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3, 971 VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4, 972 VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5, 973 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6, 974 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7, 975 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8, 976 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9, 977 VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10, 978 VK_DESCRIPTOR_TYPE_BEGIN_RANGE = VK_DESCRIPTOR_TYPE_SAMPLER, 979 VK_DESCRIPTOR_TYPE_END_RANGE = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, 980 VK_DESCRIPTOR_TYPE_RANGE_SIZE = (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT - VK_DESCRIPTOR_TYPE_SAMPLER + 1), 981 VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF 982 } VkDescriptorType; 983 984 typedef enum VkAttachmentLoadOp { 985 VK_ATTACHMENT_LOAD_OP_LOAD = 0, 986 VK_ATTACHMENT_LOAD_OP_CLEAR = 1, 987 VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2, 988 VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE = VK_ATTACHMENT_LOAD_OP_LOAD, 989 VK_ATTACHMENT_LOAD_OP_END_RANGE = VK_ATTACHMENT_LOAD_OP_DONT_CARE, 990 VK_ATTACHMENT_LOAD_OP_RANGE_SIZE = (VK_ATTACHMENT_LOAD_OP_DONT_CARE - VK_ATTACHMENT_LOAD_OP_LOAD + 1), 991 VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF 992 } VkAttachmentLoadOp; 993 994 typedef enum VkAttachmentStoreOp { 995 VK_ATTACHMENT_STORE_OP_STORE = 0, 996 VK_ATTACHMENT_STORE_OP_DONT_CARE = 1, 997 VK_ATTACHMENT_STORE_OP_BEGIN_RANGE = VK_ATTACHMENT_STORE_OP_STORE, 998 VK_ATTACHMENT_STORE_OP_END_RANGE = VK_ATTACHMENT_STORE_OP_DONT_CARE, 999 VK_ATTACHMENT_STORE_OP_RANGE_SIZE = (VK_ATTACHMENT_STORE_OP_DONT_CARE - VK_ATTACHMENT_STORE_OP_STORE + 1), 1000 VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF 1001 } VkAttachmentStoreOp; 1002 1003 typedef enum VkPipelineBindPoint { 1004 VK_PIPELINE_BIND_POINT_GRAPHICS = 0, 1005 VK_PIPELINE_BIND_POINT_COMPUTE = 1, 1006 VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VK_PIPELINE_BIND_POINT_GRAPHICS, 1007 VK_PIPELINE_BIND_POINT_END_RANGE = VK_PIPELINE_BIND_POINT_COMPUTE, 1008 VK_PIPELINE_BIND_POINT_RANGE_SIZE = (VK_PIPELINE_BIND_POINT_COMPUTE - VK_PIPELINE_BIND_POINT_GRAPHICS + 1), 1009 VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF 1010 } VkPipelineBindPoint; 1011 1012 typedef enum VkCommandBufferLevel { 1013 VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0, 1014 VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1, 1015 VK_COMMAND_BUFFER_LEVEL_BEGIN_RANGE = VK_COMMAND_BUFFER_LEVEL_PRIMARY, 1016 VK_COMMAND_BUFFER_LEVEL_END_RANGE = VK_COMMAND_BUFFER_LEVEL_SECONDARY, 1017 VK_COMMAND_BUFFER_LEVEL_RANGE_SIZE = (VK_COMMAND_BUFFER_LEVEL_SECONDARY - VK_COMMAND_BUFFER_LEVEL_PRIMARY + 1), 1018 VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF 1019 } VkCommandBufferLevel; 1020 1021 typedef enum VkIndexType { 1022 VK_INDEX_TYPE_UINT16 = 0, 1023 VK_INDEX_TYPE_UINT32 = 1, 1024 VK_INDEX_TYPE_BEGIN_RANGE = VK_INDEX_TYPE_UINT16, 1025 VK_INDEX_TYPE_END_RANGE = VK_INDEX_TYPE_UINT32, 1026 VK_INDEX_TYPE_RANGE_SIZE = (VK_INDEX_TYPE_UINT32 - VK_INDEX_TYPE_UINT16 + 1), 1027 VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF 1028 } VkIndexType; 1029 1030 typedef enum VkSubpassContents { 1031 VK_SUBPASS_CONTENTS_INLINE = 0, 1032 VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1, 1033 VK_SUBPASS_CONTENTS_BEGIN_RANGE = VK_SUBPASS_CONTENTS_INLINE, 1034 VK_SUBPASS_CONTENTS_END_RANGE = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS, 1035 VK_SUBPASS_CONTENTS_RANGE_SIZE = (VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS - VK_SUBPASS_CONTENTS_INLINE + 1), 1036 VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF 1037 } VkSubpassContents; 1038 1039 typedef enum VkObjectType { 1040 VK_OBJECT_TYPE_UNKNOWN = 0, 1041 VK_OBJECT_TYPE_INSTANCE = 1, 1042 VK_OBJECT_TYPE_PHYSICAL_DEVICE = 2, 1043 VK_OBJECT_TYPE_DEVICE = 3, 1044 VK_OBJECT_TYPE_QUEUE = 4, 1045 VK_OBJECT_TYPE_SEMAPHORE = 5, 1046 VK_OBJECT_TYPE_COMMAND_BUFFER = 6, 1047 VK_OBJECT_TYPE_FENCE = 7, 1048 VK_OBJECT_TYPE_DEVICE_MEMORY = 8, 1049 VK_OBJECT_TYPE_BUFFER = 9, 1050 VK_OBJECT_TYPE_IMAGE = 10, 1051 VK_OBJECT_TYPE_EVENT = 11, 1052 VK_OBJECT_TYPE_QUERY_POOL = 12, 1053 VK_OBJECT_TYPE_BUFFER_VIEW = 13, 1054 VK_OBJECT_TYPE_IMAGE_VIEW = 14, 1055 VK_OBJECT_TYPE_SHADER_MODULE = 15, 1056 VK_OBJECT_TYPE_PIPELINE_CACHE = 16, 1057 VK_OBJECT_TYPE_PIPELINE_LAYOUT = 17, 1058 VK_OBJECT_TYPE_RENDER_PASS = 18, 1059 VK_OBJECT_TYPE_PIPELINE = 19, 1060 VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 20, 1061 VK_OBJECT_TYPE_SAMPLER = 21, 1062 VK_OBJECT_TYPE_DESCRIPTOR_POOL = 22, 1063 VK_OBJECT_TYPE_DESCRIPTOR_SET = 23, 1064 VK_OBJECT_TYPE_FRAMEBUFFER = 24, 1065 VK_OBJECT_TYPE_COMMAND_POOL = 25, 1066 VK_OBJECT_TYPE_SURFACE_KHR = 1000000000, 1067 VK_OBJECT_TYPE_SWAPCHAIN_KHR = 1000001000, 1068 VK_OBJECT_TYPE_DISPLAY_KHR = 1000002000, 1069 VK_OBJECT_TYPE_DISPLAY_MODE_KHR = 1000002001, 1070 VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT = 1000011000, 1071 VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = 1000085000, 1072 VK_OBJECT_TYPE_OBJECT_TABLE_NVX = 1000086000, 1073 VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX = 1000086001, 1074 VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR = 1000156000, 1075 VK_OBJECT_TYPE_VALIDATION_CACHE_EXT = 1000160000, 1076 VK_OBJECT_TYPE_BEGIN_RANGE = VK_OBJECT_TYPE_UNKNOWN, 1077 VK_OBJECT_TYPE_END_RANGE = VK_OBJECT_TYPE_COMMAND_POOL, 1078 VK_OBJECT_TYPE_RANGE_SIZE = (VK_OBJECT_TYPE_COMMAND_POOL - VK_OBJECT_TYPE_UNKNOWN + 1), 1079 VK_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF 1080 } VkObjectType; 1081 1082 typedef VkFlags VkInstanceCreateFlags; 1083 1084 typedef enum VkFormatFeatureFlagBits { 1085 VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001, 1086 VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002, 1087 VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004, 1088 VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008, 1089 VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010, 1090 VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020, 1091 VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040, 1092 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080, 1093 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100, 1094 VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200, 1095 VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400, 1096 VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800, 1097 VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000, 1098 VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = 0x00002000, 1099 VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = 0x00004000, 1100 VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = 0x00008000, 1101 VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT = 0x00010000, 1102 VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR = 0x00020000, 1103 VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR = 0x00040000, 1104 VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR = 0x00080000, 1105 VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR = 0x00100000, 1106 VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR = 0x00200000, 1107 VK_FORMAT_FEATURE_DISJOINT_BIT_KHR = 0x00400000, 1108 VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR = 0x00800000, 1109 VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1110 } VkFormatFeatureFlagBits; 1111 typedef VkFlags VkFormatFeatureFlags; 1112 1113 typedef enum VkImageUsageFlagBits { 1114 VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001, 1115 VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002, 1116 VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004, 1117 VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008, 1118 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010, 1119 VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020, 1120 VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040, 1121 VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080, 1122 VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1123 } VkImageUsageFlagBits; 1124 typedef VkFlags VkImageUsageFlags; 1125 1126 typedef enum VkImageCreateFlagBits { 1127 VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001, 1128 VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, 1129 VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004, 1130 VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008, 1131 VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010, 1132 VK_IMAGE_CREATE_BIND_SFR_BIT_KHX = 0x00000040, 1133 VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = 0x00000020, 1134 VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR = 0x00000080, 1135 VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR = 0x00000100, 1136 VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = 0x00001000, 1137 VK_IMAGE_CREATE_DISJOINT_BIT_KHR = 0x00000200, 1138 VK_IMAGE_CREATE_ALIAS_BIT_KHR = 0x00000400, 1139 VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1140 } VkImageCreateFlagBits; 1141 typedef VkFlags VkImageCreateFlags; 1142 1143 typedef enum VkSampleCountFlagBits { 1144 VK_SAMPLE_COUNT_1_BIT = 0x00000001, 1145 VK_SAMPLE_COUNT_2_BIT = 0x00000002, 1146 VK_SAMPLE_COUNT_4_BIT = 0x00000004, 1147 VK_SAMPLE_COUNT_8_BIT = 0x00000008, 1148 VK_SAMPLE_COUNT_16_BIT = 0x00000010, 1149 VK_SAMPLE_COUNT_32_BIT = 0x00000020, 1150 VK_SAMPLE_COUNT_64_BIT = 0x00000040, 1151 VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1152 } VkSampleCountFlagBits; 1153 typedef VkFlags VkSampleCountFlags; 1154 1155 typedef enum VkQueueFlagBits { 1156 VK_QUEUE_GRAPHICS_BIT = 0x00000001, 1157 VK_QUEUE_COMPUTE_BIT = 0x00000002, 1158 VK_QUEUE_TRANSFER_BIT = 0x00000004, 1159 VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008, 1160 VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1161 } VkQueueFlagBits; 1162 typedef VkFlags VkQueueFlags; 1163 1164 typedef enum VkMemoryPropertyFlagBits { 1165 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001, 1166 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002, 1167 VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004, 1168 VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008, 1169 VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010, 1170 VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1171 } VkMemoryPropertyFlagBits; 1172 typedef VkFlags VkMemoryPropertyFlags; 1173 1174 typedef enum VkMemoryHeapFlagBits { 1175 VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001, 1176 VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHX = 0x00000002, 1177 VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1178 } VkMemoryHeapFlagBits; 1179 typedef VkFlags VkMemoryHeapFlags; 1180 typedef VkFlags VkDeviceCreateFlags; 1181 typedef VkFlags VkDeviceQueueCreateFlags; 1182 1183 typedef enum VkPipelineStageFlagBits { 1184 VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001, 1185 VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002, 1186 VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004, 1187 VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008, 1188 VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010, 1189 VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020, 1190 VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040, 1191 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080, 1192 VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100, 1193 VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200, 1194 VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400, 1195 VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800, 1196 VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000, 1197 VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000, 1198 VK_PIPELINE_STAGE_HOST_BIT = 0x00004000, 1199 VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000, 1200 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000, 1201 VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX = 0x00020000, 1202 VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1203 } VkPipelineStageFlagBits; 1204 typedef VkFlags VkPipelineStageFlags; 1205 typedef VkFlags VkMemoryMapFlags; 1206 1207 typedef enum VkImageAspectFlagBits { 1208 VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001, 1209 VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002, 1210 VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004, 1211 VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008, 1212 VK_IMAGE_ASPECT_PLANE_0_BIT_KHR = 0x00000010, 1213 VK_IMAGE_ASPECT_PLANE_1_BIT_KHR = 0x00000020, 1214 VK_IMAGE_ASPECT_PLANE_2_BIT_KHR = 0x00000040, 1215 VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1216 } VkImageAspectFlagBits; 1217 typedef VkFlags VkImageAspectFlags; 1218 1219 typedef enum VkSparseImageFormatFlagBits { 1220 VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001, 1221 VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002, 1222 VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004, 1223 VK_SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1224 } VkSparseImageFormatFlagBits; 1225 typedef VkFlags VkSparseImageFormatFlags; 1226 1227 typedef enum VkSparseMemoryBindFlagBits { 1228 VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0x00000001, 1229 VK_SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1230 } VkSparseMemoryBindFlagBits; 1231 typedef VkFlags VkSparseMemoryBindFlags; 1232 1233 typedef enum VkFenceCreateFlagBits { 1234 VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001, 1235 VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1236 } VkFenceCreateFlagBits; 1237 typedef VkFlags VkFenceCreateFlags; 1238 typedef VkFlags VkSemaphoreCreateFlags; 1239 typedef VkFlags VkEventCreateFlags; 1240 typedef VkFlags VkQueryPoolCreateFlags; 1241 1242 typedef enum VkQueryPipelineStatisticFlagBits { 1243 VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001, 1244 VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002, 1245 VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004, 1246 VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008, 1247 VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0x00000010, 1248 VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0x00000020, 1249 VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0x00000040, 1250 VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0x00000080, 1251 VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x00000100, 1252 VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0x00000200, 1253 VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400, 1254 VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1255 } VkQueryPipelineStatisticFlagBits; 1256 typedef VkFlags VkQueryPipelineStatisticFlags; 1257 1258 typedef enum VkQueryResultFlagBits { 1259 VK_QUERY_RESULT_64_BIT = 0x00000001, 1260 VK_QUERY_RESULT_WAIT_BIT = 0x00000002, 1261 VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004, 1262 VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008, 1263 VK_QUERY_RESULT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1264 } VkQueryResultFlagBits; 1265 typedef VkFlags VkQueryResultFlags; 1266 1267 typedef enum VkBufferCreateFlagBits { 1268 VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001, 1269 VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, 1270 VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004, 1271 VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1272 } VkBufferCreateFlagBits; 1273 typedef VkFlags VkBufferCreateFlags; 1274 1275 typedef enum VkBufferUsageFlagBits { 1276 VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001, 1277 VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002, 1278 VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004, 1279 VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008, 1280 VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010, 1281 VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020, 1282 VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040, 1283 VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080, 1284 VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100, 1285 VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1286 } VkBufferUsageFlagBits; 1287 typedef VkFlags VkBufferUsageFlags; 1288 typedef VkFlags VkBufferViewCreateFlags; 1289 typedef VkFlags VkImageViewCreateFlags; 1290 typedef VkFlags VkShaderModuleCreateFlags; 1291 typedef VkFlags VkPipelineCacheCreateFlags; 1292 1293 typedef enum VkPipelineCreateFlagBits { 1294 VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001, 1295 VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002, 1296 VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004, 1297 VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHX = 0x00000008, 1298 VK_PIPELINE_CREATE_DISPATCH_BASE_KHX = 0x00000010, 1299 VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1300 } VkPipelineCreateFlagBits; 1301 typedef VkFlags VkPipelineCreateFlags; 1302 typedef VkFlags VkPipelineShaderStageCreateFlags; 1303 1304 typedef enum VkShaderStageFlagBits { 1305 VK_SHADER_STAGE_VERTEX_BIT = 0x00000001, 1306 VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002, 1307 VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004, 1308 VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008, 1309 VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010, 1310 VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020, 1311 VK_SHADER_STAGE_ALL_GRAPHICS = 0x0000001F, 1312 VK_SHADER_STAGE_ALL = 0x7FFFFFFF, 1313 VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1314 } VkShaderStageFlagBits; 1315 typedef VkFlags VkPipelineVertexInputStateCreateFlags; 1316 typedef VkFlags VkPipelineInputAssemblyStateCreateFlags; 1317 typedef VkFlags VkPipelineTessellationStateCreateFlags; 1318 typedef VkFlags VkPipelineViewportStateCreateFlags; 1319 typedef VkFlags VkPipelineRasterizationStateCreateFlags; 1320 1321 typedef enum VkCullModeFlagBits { 1322 VK_CULL_MODE_NONE = 0, 1323 VK_CULL_MODE_FRONT_BIT = 0x00000001, 1324 VK_CULL_MODE_BACK_BIT = 0x00000002, 1325 VK_CULL_MODE_FRONT_AND_BACK = 0x00000003, 1326 VK_CULL_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1327 } VkCullModeFlagBits; 1328 typedef VkFlags VkCullModeFlags; 1329 typedef VkFlags VkPipelineMultisampleStateCreateFlags; 1330 typedef VkFlags VkPipelineDepthStencilStateCreateFlags; 1331 typedef VkFlags VkPipelineColorBlendStateCreateFlags; 1332 1333 typedef enum VkColorComponentFlagBits { 1334 VK_COLOR_COMPONENT_R_BIT = 0x00000001, 1335 VK_COLOR_COMPONENT_G_BIT = 0x00000002, 1336 VK_COLOR_COMPONENT_B_BIT = 0x00000004, 1337 VK_COLOR_COMPONENT_A_BIT = 0x00000008, 1338 VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1339 } VkColorComponentFlagBits; 1340 typedef VkFlags VkColorComponentFlags; 1341 typedef VkFlags VkPipelineDynamicStateCreateFlags; 1342 typedef VkFlags VkPipelineLayoutCreateFlags; 1343 typedef VkFlags VkShaderStageFlags; 1344 typedef VkFlags VkSamplerCreateFlags; 1345 1346 typedef enum VkDescriptorSetLayoutCreateFlagBits { 1347 VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR = 0x00000001, 1348 VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1349 } VkDescriptorSetLayoutCreateFlagBits; 1350 typedef VkFlags VkDescriptorSetLayoutCreateFlags; 1351 1352 typedef enum VkDescriptorPoolCreateFlagBits { 1353 VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001, 1354 VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1355 } VkDescriptorPoolCreateFlagBits; 1356 typedef VkFlags VkDescriptorPoolCreateFlags; 1357 typedef VkFlags VkDescriptorPoolResetFlags; 1358 typedef VkFlags VkFramebufferCreateFlags; 1359 typedef VkFlags VkRenderPassCreateFlags; 1360 1361 typedef enum VkAttachmentDescriptionFlagBits { 1362 VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001, 1363 VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1364 } VkAttachmentDescriptionFlagBits; 1365 typedef VkFlags VkAttachmentDescriptionFlags; 1366 1367 typedef enum VkSubpassDescriptionFlagBits { 1368 VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX = 0x00000001, 1369 VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX = 0x00000002, 1370 VK_SUBPASS_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1371 } VkSubpassDescriptionFlagBits; 1372 typedef VkFlags VkSubpassDescriptionFlags; 1373 1374 typedef enum VkAccessFlagBits { 1375 VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001, 1376 VK_ACCESS_INDEX_READ_BIT = 0x00000002, 1377 VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004, 1378 VK_ACCESS_UNIFORM_READ_BIT = 0x00000008, 1379 VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0x00000010, 1380 VK_ACCESS_SHADER_READ_BIT = 0x00000020, 1381 VK_ACCESS_SHADER_WRITE_BIT = 0x00000040, 1382 VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0x00000080, 1383 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100, 1384 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200, 1385 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400, 1386 VK_ACCESS_TRANSFER_READ_BIT = 0x00000800, 1387 VK_ACCESS_TRANSFER_WRITE_BIT = 0x00001000, 1388 VK_ACCESS_HOST_READ_BIT = 0x00002000, 1389 VK_ACCESS_HOST_WRITE_BIT = 0x00004000, 1390 VK_ACCESS_MEMORY_READ_BIT = 0x00008000, 1391 VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000, 1392 VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX = 0x00020000, 1393 VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX = 0x00040000, 1394 VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000, 1395 VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1396 } VkAccessFlagBits; 1397 typedef VkFlags VkAccessFlags; 1398 1399 typedef enum VkDependencyFlagBits { 1400 VK_DEPENDENCY_BY_REGION_BIT = 0x00000001, 1401 VK_DEPENDENCY_VIEW_LOCAL_BIT_KHX = 0x00000002, 1402 VK_DEPENDENCY_DEVICE_GROUP_BIT_KHX = 0x00000004, 1403 VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1404 } VkDependencyFlagBits; 1405 typedef VkFlags VkDependencyFlags; 1406 1407 typedef enum VkCommandPoolCreateFlagBits { 1408 VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001, 1409 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002, 1410 VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1411 } VkCommandPoolCreateFlagBits; 1412 typedef VkFlags VkCommandPoolCreateFlags; 1413 1414 typedef enum VkCommandPoolResetFlagBits { 1415 VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001, 1416 VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1417 } VkCommandPoolResetFlagBits; 1418 typedef VkFlags VkCommandPoolResetFlags; 1419 1420 typedef enum VkCommandBufferUsageFlagBits { 1421 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001, 1422 VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002, 1423 VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004, 1424 VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1425 } VkCommandBufferUsageFlagBits; 1426 typedef VkFlags VkCommandBufferUsageFlags; 1427 1428 typedef enum VkQueryControlFlagBits { 1429 VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001, 1430 VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1431 } VkQueryControlFlagBits; 1432 typedef VkFlags VkQueryControlFlags; 1433 1434 typedef enum VkCommandBufferResetFlagBits { 1435 VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001, 1436 VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1437 } VkCommandBufferResetFlagBits; 1438 typedef VkFlags VkCommandBufferResetFlags; 1439 1440 typedef enum VkStencilFaceFlagBits { 1441 VK_STENCIL_FACE_FRONT_BIT = 0x00000001, 1442 VK_STENCIL_FACE_BACK_BIT = 0x00000002, 1443 VK_STENCIL_FRONT_AND_BACK = 0x00000003, 1444 VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1445 } VkStencilFaceFlagBits; 1446 typedef VkFlags VkStencilFaceFlags; 1447 1448 typedef struct VkApplicationInfo { 1449 VkStructureType sType; 1450 const void* pNext; 1451 const char* pApplicationName; 1452 uint32_t applicationVersion; 1453 const char* pEngineName; 1454 uint32_t engineVersion; 1455 uint32_t apiVersion; 1456 } VkApplicationInfo; 1457 1458 typedef struct VkInstanceCreateInfo { 1459 VkStructureType sType; 1460 const void* pNext; 1461 VkInstanceCreateFlags flags; 1462 const VkApplicationInfo* pApplicationInfo; 1463 uint32_t enabledLayerCount; 1464 const char* const* ppEnabledLayerNames; 1465 uint32_t enabledExtensionCount; 1466 const char* const* ppEnabledExtensionNames; 1467 } VkInstanceCreateInfo; 1468 1469 typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)( 1470 void* pUserData, 1471 size_t size, 1472 size_t alignment, 1473 VkSystemAllocationScope allocationScope); 1474 1475 typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)( 1476 void* pUserData, 1477 void* pOriginal, 1478 size_t size, 1479 size_t alignment, 1480 VkSystemAllocationScope allocationScope); 1481 1482 typedef void (VKAPI_PTR *PFN_vkFreeFunction)( 1483 void* pUserData, 1484 void* pMemory); 1485 1486 typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)( 1487 void* pUserData, 1488 size_t size, 1489 VkInternalAllocationType allocationType, 1490 VkSystemAllocationScope allocationScope); 1491 1492 typedef void (VKAPI_PTR *PFN_vkInternalFreeNotification)( 1493 void* pUserData, 1494 size_t size, 1495 VkInternalAllocationType allocationType, 1496 VkSystemAllocationScope allocationScope); 1497 1498 typedef struct VkAllocationCallbacks { 1499 void* pUserData; 1500 PFN_vkAllocationFunction pfnAllocation; 1501 PFN_vkReallocationFunction pfnReallocation; 1502 PFN_vkFreeFunction pfnFree; 1503 PFN_vkInternalAllocationNotification pfnInternalAllocation; 1504 PFN_vkInternalFreeNotification pfnInternalFree; 1505 } VkAllocationCallbacks; 1506 1507 typedef struct VkPhysicalDeviceFeatures { 1508 VkBool32 robustBufferAccess; 1509 VkBool32 fullDrawIndexUint32; 1510 VkBool32 imageCubeArray; 1511 VkBool32 independentBlend; 1512 VkBool32 geometryShader; 1513 VkBool32 tessellationShader; 1514 VkBool32 sampleRateShading; 1515 VkBool32 dualSrcBlend; 1516 VkBool32 logicOp; 1517 VkBool32 multiDrawIndirect; 1518 VkBool32 drawIndirectFirstInstance; 1519 VkBool32 depthClamp; 1520 VkBool32 depthBiasClamp; 1521 VkBool32 fillModeNonSolid; 1522 VkBool32 depthBounds; 1523 VkBool32 wideLines; 1524 VkBool32 largePoints; 1525 VkBool32 alphaToOne; 1526 VkBool32 multiViewport; 1527 VkBool32 samplerAnisotropy; 1528 VkBool32 textureCompressionETC2; 1529 VkBool32 textureCompressionASTC_LDR; 1530 VkBool32 textureCompressionBC; 1531 VkBool32 occlusionQueryPrecise; 1532 VkBool32 pipelineStatisticsQuery; 1533 VkBool32 vertexPipelineStoresAndAtomics; 1534 VkBool32 fragmentStoresAndAtomics; 1535 VkBool32 shaderTessellationAndGeometryPointSize; 1536 VkBool32 shaderImageGatherExtended; 1537 VkBool32 shaderStorageImageExtendedFormats; 1538 VkBool32 shaderStorageImageMultisample; 1539 VkBool32 shaderStorageImageReadWithoutFormat; 1540 VkBool32 shaderStorageImageWriteWithoutFormat; 1541 VkBool32 shaderUniformBufferArrayDynamicIndexing; 1542 VkBool32 shaderSampledImageArrayDynamicIndexing; 1543 VkBool32 shaderStorageBufferArrayDynamicIndexing; 1544 VkBool32 shaderStorageImageArrayDynamicIndexing; 1545 VkBool32 shaderClipDistance; 1546 VkBool32 shaderCullDistance; 1547 VkBool32 shaderFloat64; 1548 VkBool32 shaderInt64; 1549 VkBool32 shaderInt16; 1550 VkBool32 shaderResourceResidency; 1551 VkBool32 shaderResourceMinLod; 1552 VkBool32 sparseBinding; 1553 VkBool32 sparseResidencyBuffer; 1554 VkBool32 sparseResidencyImage2D; 1555 VkBool32 sparseResidencyImage3D; 1556 VkBool32 sparseResidency2Samples; 1557 VkBool32 sparseResidency4Samples; 1558 VkBool32 sparseResidency8Samples; 1559 VkBool32 sparseResidency16Samples; 1560 VkBool32 sparseResidencyAliased; 1561 VkBool32 variableMultisampleRate; 1562 VkBool32 inheritedQueries; 1563 } VkPhysicalDeviceFeatures; 1564 1565 typedef struct VkFormatProperties { 1566 VkFormatFeatureFlags linearTilingFeatures; 1567 VkFormatFeatureFlags optimalTilingFeatures; 1568 VkFormatFeatureFlags bufferFeatures; 1569 } VkFormatProperties; 1570 1571 typedef struct VkExtent3D { 1572 uint32_t width; 1573 uint32_t height; 1574 uint32_t depth; 1575 } VkExtent3D; 1576 1577 typedef struct VkImageFormatProperties { 1578 VkExtent3D maxExtent; 1579 uint32_t maxMipLevels; 1580 uint32_t maxArrayLayers; 1581 VkSampleCountFlags sampleCounts; 1582 VkDeviceSize maxResourceSize; 1583 } VkImageFormatProperties; 1584 1585 typedef struct VkPhysicalDeviceLimits { 1586 uint32_t maxImageDimension1D; 1587 uint32_t maxImageDimension2D; 1588 uint32_t maxImageDimension3D; 1589 uint32_t maxImageDimensionCube; 1590 uint32_t maxImageArrayLayers; 1591 uint32_t maxTexelBufferElements; 1592 uint32_t maxUniformBufferRange; 1593 uint32_t maxStorageBufferRange; 1594 uint32_t maxPushConstantsSize; 1595 uint32_t maxMemoryAllocationCount; 1596 uint32_t maxSamplerAllocationCount; 1597 VkDeviceSize bufferImageGranularity; 1598 VkDeviceSize sparseAddressSpaceSize; 1599 uint32_t maxBoundDescriptorSets; 1600 uint32_t maxPerStageDescriptorSamplers; 1601 uint32_t maxPerStageDescriptorUniformBuffers; 1602 uint32_t maxPerStageDescriptorStorageBuffers; 1603 uint32_t maxPerStageDescriptorSampledImages; 1604 uint32_t maxPerStageDescriptorStorageImages; 1605 uint32_t maxPerStageDescriptorInputAttachments; 1606 uint32_t maxPerStageResources; 1607 uint32_t maxDescriptorSetSamplers; 1608 uint32_t maxDescriptorSetUniformBuffers; 1609 uint32_t maxDescriptorSetUniformBuffersDynamic; 1610 uint32_t maxDescriptorSetStorageBuffers; 1611 uint32_t maxDescriptorSetStorageBuffersDynamic; 1612 uint32_t maxDescriptorSetSampledImages; 1613 uint32_t maxDescriptorSetStorageImages; 1614 uint32_t maxDescriptorSetInputAttachments; 1615 uint32_t maxVertexInputAttributes; 1616 uint32_t maxVertexInputBindings; 1617 uint32_t maxVertexInputAttributeOffset; 1618 uint32_t maxVertexInputBindingStride; 1619 uint32_t maxVertexOutputComponents; 1620 uint32_t maxTessellationGenerationLevel; 1621 uint32_t maxTessellationPatchSize; 1622 uint32_t maxTessellationControlPerVertexInputComponents; 1623 uint32_t maxTessellationControlPerVertexOutputComponents; 1624 uint32_t maxTessellationControlPerPatchOutputComponents; 1625 uint32_t maxTessellationControlTotalOutputComponents; 1626 uint32_t maxTessellationEvaluationInputComponents; 1627 uint32_t maxTessellationEvaluationOutputComponents; 1628 uint32_t maxGeometryShaderInvocations; 1629 uint32_t maxGeometryInputComponents; 1630 uint32_t maxGeometryOutputComponents; 1631 uint32_t maxGeometryOutputVertices; 1632 uint32_t maxGeometryTotalOutputComponents; 1633 uint32_t maxFragmentInputComponents; 1634 uint32_t maxFragmentOutputAttachments; 1635 uint32_t maxFragmentDualSrcAttachments; 1636 uint32_t maxFragmentCombinedOutputResources; 1637 uint32_t maxComputeSharedMemorySize; 1638 uint32_t maxComputeWorkGroupCount[3]; 1639 uint32_t maxComputeWorkGroupInvocations; 1640 uint32_t maxComputeWorkGroupSize[3]; 1641 uint32_t subPixelPrecisionBits; 1642 uint32_t subTexelPrecisionBits; 1643 uint32_t mipmapPrecisionBits; 1644 uint32_t maxDrawIndexedIndexValue; 1645 uint32_t maxDrawIndirectCount; 1646 float maxSamplerLodBias; 1647 float maxSamplerAnisotropy; 1648 uint32_t maxViewports; 1649 uint32_t maxViewportDimensions[2]; 1650 float viewportBoundsRange[2]; 1651 uint32_t viewportSubPixelBits; 1652 size_t minMemoryMapAlignment; 1653 VkDeviceSize minTexelBufferOffsetAlignment; 1654 VkDeviceSize minUniformBufferOffsetAlignment; 1655 VkDeviceSize minStorageBufferOffsetAlignment; 1656 int32_t minTexelOffset; 1657 uint32_t maxTexelOffset; 1658 int32_t minTexelGatherOffset; 1659 uint32_t maxTexelGatherOffset; 1660 float minInterpolationOffset; 1661 float maxInterpolationOffset; 1662 uint32_t subPixelInterpolationOffsetBits; 1663 uint32_t maxFramebufferWidth; 1664 uint32_t maxFramebufferHeight; 1665 uint32_t maxFramebufferLayers; 1666 VkSampleCountFlags framebufferColorSampleCounts; 1667 VkSampleCountFlags framebufferDepthSampleCounts; 1668 VkSampleCountFlags framebufferStencilSampleCounts; 1669 VkSampleCountFlags framebufferNoAttachmentsSampleCounts; 1670 uint32_t maxColorAttachments; 1671 VkSampleCountFlags sampledImageColorSampleCounts; 1672 VkSampleCountFlags sampledImageIntegerSampleCounts; 1673 VkSampleCountFlags sampledImageDepthSampleCounts; 1674 VkSampleCountFlags sampledImageStencilSampleCounts; 1675 VkSampleCountFlags storageImageSampleCounts; 1676 uint32_t maxSampleMaskWords; 1677 VkBool32 timestampComputeAndGraphics; 1678 float timestampPeriod; 1679 uint32_t maxClipDistances; 1680 uint32_t maxCullDistances; 1681 uint32_t maxCombinedClipAndCullDistances; 1682 uint32_t discreteQueuePriorities; 1683 float pointSizeRange[2]; 1684 float lineWidthRange[2]; 1685 float pointSizeGranularity; 1686 float lineWidthGranularity; 1687 VkBool32 strictLines; 1688 VkBool32 standardSampleLocations; 1689 VkDeviceSize optimalBufferCopyOffsetAlignment; 1690 VkDeviceSize optimalBufferCopyRowPitchAlignment; 1691 VkDeviceSize nonCoherentAtomSize; 1692 } VkPhysicalDeviceLimits; 1693 1694 typedef struct VkPhysicalDeviceSparseProperties { 1695 VkBool32 residencyStandard2DBlockShape; 1696 VkBool32 residencyStandard2DMultisampleBlockShape; 1697 VkBool32 residencyStandard3DBlockShape; 1698 VkBool32 residencyAlignedMipSize; 1699 VkBool32 residencyNonResidentStrict; 1700 } VkPhysicalDeviceSparseProperties; 1701 1702 typedef struct VkPhysicalDeviceProperties { 1703 uint32_t apiVersion; 1704 uint32_t driverVersion; 1705 uint32_t vendorID; 1706 uint32_t deviceID; 1707 VkPhysicalDeviceType deviceType; 1708 char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]; 1709 uint8_t pipelineCacheUUID[VK_UUID_SIZE]; 1710 VkPhysicalDeviceLimits limits; 1711 VkPhysicalDeviceSparseProperties sparseProperties; 1712 } VkPhysicalDeviceProperties; 1713 1714 typedef struct VkQueueFamilyProperties { 1715 VkQueueFlags queueFlags; 1716 uint32_t queueCount; 1717 uint32_t timestampValidBits; 1718 VkExtent3D minImageTransferGranularity; 1719 } VkQueueFamilyProperties; 1720 1721 typedef struct VkMemoryType { 1722 VkMemoryPropertyFlags propertyFlags; 1723 uint32_t heapIndex; 1724 } VkMemoryType; 1725 1726 typedef struct VkMemoryHeap { 1727 VkDeviceSize size; 1728 VkMemoryHeapFlags flags; 1729 } VkMemoryHeap; 1730 1731 typedef struct VkPhysicalDeviceMemoryProperties { 1732 uint32_t memoryTypeCount; 1733 VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES]; 1734 uint32_t memoryHeapCount; 1735 VkMemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS]; 1736 } VkPhysicalDeviceMemoryProperties; 1737 1738 typedef void (VKAPI_PTR *PFN_vkVoidFunction)(void); 1739 typedef struct VkDeviceQueueCreateInfo { 1740 VkStructureType sType; 1741 const void* pNext; 1742 VkDeviceQueueCreateFlags flags; 1743 uint32_t queueFamilyIndex; 1744 uint32_t queueCount; 1745 const float* pQueuePriorities; 1746 } VkDeviceQueueCreateInfo; 1747 1748 typedef struct VkDeviceCreateInfo { 1749 VkStructureType sType; 1750 const void* pNext; 1751 VkDeviceCreateFlags flags; 1752 uint32_t queueCreateInfoCount; 1753 const VkDeviceQueueCreateInfo* pQueueCreateInfos; 1754 uint32_t enabledLayerCount; 1755 const char* const* ppEnabledLayerNames; 1756 uint32_t enabledExtensionCount; 1757 const char* const* ppEnabledExtensionNames; 1758 const VkPhysicalDeviceFeatures* pEnabledFeatures; 1759 } VkDeviceCreateInfo; 1760 1761 typedef struct VkExtensionProperties { 1762 char extensionName[VK_MAX_EXTENSION_NAME_SIZE]; 1763 uint32_t specVersion; 1764 } VkExtensionProperties; 1765 1766 typedef struct VkLayerProperties { 1767 char layerName[VK_MAX_EXTENSION_NAME_SIZE]; 1768 uint32_t specVersion; 1769 uint32_t implementationVersion; 1770 char description[VK_MAX_DESCRIPTION_SIZE]; 1771 } VkLayerProperties; 1772 1773 typedef struct VkSubmitInfo { 1774 VkStructureType sType; 1775 const void* pNext; 1776 uint32_t waitSemaphoreCount; 1777 const VkSemaphore* pWaitSemaphores; 1778 const VkPipelineStageFlags* pWaitDstStageMask; 1779 uint32_t commandBufferCount; 1780 const VkCommandBuffer* pCommandBuffers; 1781 uint32_t signalSemaphoreCount; 1782 const VkSemaphore* pSignalSemaphores; 1783 } VkSubmitInfo; 1784 1785 typedef struct VkMemoryAllocateInfo { 1786 VkStructureType sType; 1787 const void* pNext; 1788 VkDeviceSize allocationSize; 1789 uint32_t memoryTypeIndex; 1790 } VkMemoryAllocateInfo; 1791 1792 typedef struct VkMappedMemoryRange { 1793 VkStructureType sType; 1794 const void* pNext; 1795 VkDeviceMemory memory; 1796 VkDeviceSize offset; 1797 VkDeviceSize size; 1798 } VkMappedMemoryRange; 1799 1800 typedef struct VkMemoryRequirements { 1801 VkDeviceSize size; 1802 VkDeviceSize alignment; 1803 uint32_t memoryTypeBits; 1804 } VkMemoryRequirements; 1805 1806 typedef struct VkSparseImageFormatProperties { 1807 VkImageAspectFlags aspectMask; 1808 VkExtent3D imageGranularity; 1809 VkSparseImageFormatFlags flags; 1810 } VkSparseImageFormatProperties; 1811 1812 typedef struct VkSparseImageMemoryRequirements { 1813 VkSparseImageFormatProperties formatProperties; 1814 uint32_t imageMipTailFirstLod; 1815 VkDeviceSize imageMipTailSize; 1816 VkDeviceSize imageMipTailOffset; 1817 VkDeviceSize imageMipTailStride; 1818 } VkSparseImageMemoryRequirements; 1819 1820 typedef struct VkSparseMemoryBind { 1821 VkDeviceSize resourceOffset; 1822 VkDeviceSize size; 1823 VkDeviceMemory memory; 1824 VkDeviceSize memoryOffset; 1825 VkSparseMemoryBindFlags flags; 1826 } VkSparseMemoryBind; 1827 1828 typedef struct VkSparseBufferMemoryBindInfo { 1829 VkBuffer buffer; 1830 uint32_t bindCount; 1831 const VkSparseMemoryBind* pBinds; 1832 } VkSparseBufferMemoryBindInfo; 1833 1834 typedef struct VkSparseImageOpaqueMemoryBindInfo { 1835 VkImage image; 1836 uint32_t bindCount; 1837 const VkSparseMemoryBind* pBinds; 1838 } VkSparseImageOpaqueMemoryBindInfo; 1839 1840 typedef struct VkImageSubresource { 1841 VkImageAspectFlags aspectMask; 1842 uint32_t mipLevel; 1843 uint32_t arrayLayer; 1844 } VkImageSubresource; 1845 1846 typedef struct VkOffset3D { 1847 int32_t x; 1848 int32_t y; 1849 int32_t z; 1850 } VkOffset3D; 1851 1852 typedef struct VkSparseImageMemoryBind { 1853 VkImageSubresource subresource; 1854 VkOffset3D offset; 1855 VkExtent3D extent; 1856 VkDeviceMemory memory; 1857 VkDeviceSize memoryOffset; 1858 VkSparseMemoryBindFlags flags; 1859 } VkSparseImageMemoryBind; 1860 1861 typedef struct VkSparseImageMemoryBindInfo { 1862 VkImage image; 1863 uint32_t bindCount; 1864 const VkSparseImageMemoryBind* pBinds; 1865 } VkSparseImageMemoryBindInfo; 1866 1867 typedef struct VkBindSparseInfo { 1868 VkStructureType sType; 1869 const void* pNext; 1870 uint32_t waitSemaphoreCount; 1871 const VkSemaphore* pWaitSemaphores; 1872 uint32_t bufferBindCount; 1873 const VkSparseBufferMemoryBindInfo* pBufferBinds; 1874 uint32_t imageOpaqueBindCount; 1875 const VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds; 1876 uint32_t imageBindCount; 1877 const VkSparseImageMemoryBindInfo* pImageBinds; 1878 uint32_t signalSemaphoreCount; 1879 const VkSemaphore* pSignalSemaphores; 1880 } VkBindSparseInfo; 1881 1882 typedef struct VkFenceCreateInfo { 1883 VkStructureType sType; 1884 const void* pNext; 1885 VkFenceCreateFlags flags; 1886 } VkFenceCreateInfo; 1887 1888 typedef struct VkSemaphoreCreateInfo { 1889 VkStructureType sType; 1890 const void* pNext; 1891 VkSemaphoreCreateFlags flags; 1892 } VkSemaphoreCreateInfo; 1893 1894 typedef struct VkEventCreateInfo { 1895 VkStructureType sType; 1896 const void* pNext; 1897 VkEventCreateFlags flags; 1898 } VkEventCreateInfo; 1899 1900 typedef struct VkQueryPoolCreateInfo { 1901 VkStructureType sType; 1902 const void* pNext; 1903 VkQueryPoolCreateFlags flags; 1904 VkQueryType queryType; 1905 uint32_t queryCount; 1906 VkQueryPipelineStatisticFlags pipelineStatistics; 1907 } VkQueryPoolCreateInfo; 1908 1909 typedef struct VkBufferCreateInfo { 1910 VkStructureType sType; 1911 const void* pNext; 1912 VkBufferCreateFlags flags; 1913 VkDeviceSize size; 1914 VkBufferUsageFlags usage; 1915 VkSharingMode sharingMode; 1916 uint32_t queueFamilyIndexCount; 1917 const uint32_t* pQueueFamilyIndices; 1918 } VkBufferCreateInfo; 1919 1920 typedef struct VkBufferViewCreateInfo { 1921 VkStructureType sType; 1922 const void* pNext; 1923 VkBufferViewCreateFlags flags; 1924 VkBuffer buffer; 1925 VkFormat format; 1926 VkDeviceSize offset; 1927 VkDeviceSize range; 1928 } VkBufferViewCreateInfo; 1929 1930 typedef struct VkImageCreateInfo { 1931 VkStructureType sType; 1932 const void* pNext; 1933 VkImageCreateFlags flags; 1934 VkImageType imageType; 1935 VkFormat format; 1936 VkExtent3D extent; 1937 uint32_t mipLevels; 1938 uint32_t arrayLayers; 1939 VkSampleCountFlagBits samples; 1940 VkImageTiling tiling; 1941 VkImageUsageFlags usage; 1942 VkSharingMode sharingMode; 1943 uint32_t queueFamilyIndexCount; 1944 const uint32_t* pQueueFamilyIndices; 1945 VkImageLayout initialLayout; 1946 } VkImageCreateInfo; 1947 1948 typedef struct VkSubresourceLayout { 1949 VkDeviceSize offset; 1950 VkDeviceSize size; 1951 VkDeviceSize rowPitch; 1952 VkDeviceSize arrayPitch; 1953 VkDeviceSize depthPitch; 1954 } VkSubresourceLayout; 1955 1956 typedef struct VkComponentMapping { 1957 VkComponentSwizzle r; 1958 VkComponentSwizzle g; 1959 VkComponentSwizzle b; 1960 VkComponentSwizzle a; 1961 } VkComponentMapping; 1962 1963 typedef struct VkImageSubresourceRange { 1964 VkImageAspectFlags aspectMask; 1965 uint32_t baseMipLevel; 1966 uint32_t levelCount; 1967 uint32_t baseArrayLayer; 1968 uint32_t layerCount; 1969 } VkImageSubresourceRange; 1970 1971 typedef struct VkImageViewCreateInfo { 1972 VkStructureType sType; 1973 const void* pNext; 1974 VkImageViewCreateFlags flags; 1975 VkImage image; 1976 VkImageViewType viewType; 1977 VkFormat format; 1978 VkComponentMapping components; 1979 VkImageSubresourceRange subresourceRange; 1980 } VkImageViewCreateInfo; 1981 1982 typedef struct VkShaderModuleCreateInfo { 1983 VkStructureType sType; 1984 const void* pNext; 1985 VkShaderModuleCreateFlags flags; 1986 size_t codeSize; 1987 const uint32_t* pCode; 1988 } VkShaderModuleCreateInfo; 1989 1990 typedef struct VkPipelineCacheCreateInfo { 1991 VkStructureType sType; 1992 const void* pNext; 1993 VkPipelineCacheCreateFlags flags; 1994 size_t initialDataSize; 1995 const void* pInitialData; 1996 } VkPipelineCacheCreateInfo; 1997 1998 typedef struct VkSpecializationMapEntry { 1999 uint32_t constantID; 2000 uint32_t offset; 2001 size_t size; 2002 } VkSpecializationMapEntry; 2003 2004 typedef struct VkSpecializationInfo { 2005 uint32_t mapEntryCount; 2006 const VkSpecializationMapEntry* pMapEntries; 2007 size_t dataSize; 2008 const void* pData; 2009 } VkSpecializationInfo; 2010 2011 typedef struct VkPipelineShaderStageCreateInfo { 2012 VkStructureType sType; 2013 const void* pNext; 2014 VkPipelineShaderStageCreateFlags flags; 2015 VkShaderStageFlagBits stage; 2016 VkShaderModule module; 2017 const char* pName; 2018 const VkSpecializationInfo* pSpecializationInfo; 2019 } VkPipelineShaderStageCreateInfo; 2020 2021 typedef struct VkVertexInputBindingDescription { 2022 uint32_t binding; 2023 uint32_t stride; 2024 VkVertexInputRate inputRate; 2025 } VkVertexInputBindingDescription; 2026 2027 typedef struct VkVertexInputAttributeDescription { 2028 uint32_t location; 2029 uint32_t binding; 2030 VkFormat format; 2031 uint32_t offset; 2032 } VkVertexInputAttributeDescription; 2033 2034 typedef struct VkPipelineVertexInputStateCreateInfo { 2035 VkStructureType sType; 2036 const void* pNext; 2037 VkPipelineVertexInputStateCreateFlags flags; 2038 uint32_t vertexBindingDescriptionCount; 2039 const VkVertexInputBindingDescription* pVertexBindingDescriptions; 2040 uint32_t vertexAttributeDescriptionCount; 2041 const VkVertexInputAttributeDescription* pVertexAttributeDescriptions; 2042 } VkPipelineVertexInputStateCreateInfo; 2043 2044 typedef struct VkPipelineInputAssemblyStateCreateInfo { 2045 VkStructureType sType; 2046 const void* pNext; 2047 VkPipelineInputAssemblyStateCreateFlags flags; 2048 VkPrimitiveTopology topology; 2049 VkBool32 primitiveRestartEnable; 2050 } VkPipelineInputAssemblyStateCreateInfo; 2051 2052 typedef struct VkPipelineTessellationStateCreateInfo { 2053 VkStructureType sType; 2054 const void* pNext; 2055 VkPipelineTessellationStateCreateFlags flags; 2056 uint32_t patchControlPoints; 2057 } VkPipelineTessellationStateCreateInfo; 2058 2059 typedef struct VkViewport { 2060 float x; 2061 float y; 2062 float width; 2063 float height; 2064 float minDepth; 2065 float maxDepth; 2066 } VkViewport; 2067 2068 typedef struct VkOffset2D { 2069 int32_t x; 2070 int32_t y; 2071 } VkOffset2D; 2072 2073 typedef struct VkExtent2D { 2074 uint32_t width; 2075 uint32_t height; 2076 } VkExtent2D; 2077 2078 typedef struct VkRect2D { 2079 VkOffset2D offset; 2080 VkExtent2D extent; 2081 } VkRect2D; 2082 2083 typedef struct VkPipelineViewportStateCreateInfo { 2084 VkStructureType sType; 2085 const void* pNext; 2086 VkPipelineViewportStateCreateFlags flags; 2087 uint32_t viewportCount; 2088 const VkViewport* pViewports; 2089 uint32_t scissorCount; 2090 const VkRect2D* pScissors; 2091 } VkPipelineViewportStateCreateInfo; 2092 2093 typedef struct VkPipelineRasterizationStateCreateInfo { 2094 VkStructureType sType; 2095 const void* pNext; 2096 VkPipelineRasterizationStateCreateFlags flags; 2097 VkBool32 depthClampEnable; 2098 VkBool32 rasterizerDiscardEnable; 2099 VkPolygonMode polygonMode; 2100 VkCullModeFlags cullMode; 2101 VkFrontFace frontFace; 2102 VkBool32 depthBiasEnable; 2103 float depthBiasConstantFactor; 2104 float depthBiasClamp; 2105 float depthBiasSlopeFactor; 2106 float lineWidth; 2107 } VkPipelineRasterizationStateCreateInfo; 2108 2109 typedef struct VkPipelineMultisampleStateCreateInfo { 2110 VkStructureType sType; 2111 const void* pNext; 2112 VkPipelineMultisampleStateCreateFlags flags; 2113 VkSampleCountFlagBits rasterizationSamples; 2114 VkBool32 sampleShadingEnable; 2115 float minSampleShading; 2116 const VkSampleMask* pSampleMask; 2117 VkBool32 alphaToCoverageEnable; 2118 VkBool32 alphaToOneEnable; 2119 } VkPipelineMultisampleStateCreateInfo; 2120 2121 typedef struct VkStencilOpState { 2122 VkStencilOp failOp; 2123 VkStencilOp passOp; 2124 VkStencilOp depthFailOp; 2125 VkCompareOp compareOp; 2126 uint32_t compareMask; 2127 uint32_t writeMask; 2128 uint32_t reference; 2129 } VkStencilOpState; 2130 2131 typedef struct VkPipelineDepthStencilStateCreateInfo { 2132 VkStructureType sType; 2133 const void* pNext; 2134 VkPipelineDepthStencilStateCreateFlags flags; 2135 VkBool32 depthTestEnable; 2136 VkBool32 depthWriteEnable; 2137 VkCompareOp depthCompareOp; 2138 VkBool32 depthBoundsTestEnable; 2139 VkBool32 stencilTestEnable; 2140 VkStencilOpState front; 2141 VkStencilOpState back; 2142 float minDepthBounds; 2143 float maxDepthBounds; 2144 } VkPipelineDepthStencilStateCreateInfo; 2145 2146 typedef struct VkPipelineColorBlendAttachmentState { 2147 VkBool32 blendEnable; 2148 VkBlendFactor srcColorBlendFactor; 2149 VkBlendFactor dstColorBlendFactor; 2150 VkBlendOp colorBlendOp; 2151 VkBlendFactor srcAlphaBlendFactor; 2152 VkBlendFactor dstAlphaBlendFactor; 2153 VkBlendOp alphaBlendOp; 2154 VkColorComponentFlags colorWriteMask; 2155 } VkPipelineColorBlendAttachmentState; 2156 2157 typedef struct VkPipelineColorBlendStateCreateInfo { 2158 VkStructureType sType; 2159 const void* pNext; 2160 VkPipelineColorBlendStateCreateFlags flags; 2161 VkBool32 logicOpEnable; 2162 VkLogicOp logicOp; 2163 uint32_t attachmentCount; 2164 const VkPipelineColorBlendAttachmentState* pAttachments; 2165 float blendConstants[4]; 2166 } VkPipelineColorBlendStateCreateInfo; 2167 2168 typedef struct VkPipelineDynamicStateCreateInfo { 2169 VkStructureType sType; 2170 const void* pNext; 2171 VkPipelineDynamicStateCreateFlags flags; 2172 uint32_t dynamicStateCount; 2173 const VkDynamicState* pDynamicStates; 2174 } VkPipelineDynamicStateCreateInfo; 2175 2176 typedef struct VkGraphicsPipelineCreateInfo { 2177 VkStructureType sType; 2178 const void* pNext; 2179 VkPipelineCreateFlags flags; 2180 uint32_t stageCount; 2181 const VkPipelineShaderStageCreateInfo* pStages; 2182 const VkPipelineVertexInputStateCreateInfo* pVertexInputState; 2183 const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState; 2184 const VkPipelineTessellationStateCreateInfo* pTessellationState; 2185 const VkPipelineViewportStateCreateInfo* pViewportState; 2186 const VkPipelineRasterizationStateCreateInfo* pRasterizationState; 2187 const VkPipelineMultisampleStateCreateInfo* pMultisampleState; 2188 const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState; 2189 const VkPipelineColorBlendStateCreateInfo* pColorBlendState; 2190 const VkPipelineDynamicStateCreateInfo* pDynamicState; 2191 VkPipelineLayout layout; 2192 VkRenderPass renderPass; 2193 uint32_t subpass; 2194 VkPipeline basePipelineHandle; 2195 int32_t basePipelineIndex; 2196 } VkGraphicsPipelineCreateInfo; 2197 2198 typedef struct VkComputePipelineCreateInfo { 2199 VkStructureType sType; 2200 const void* pNext; 2201 VkPipelineCreateFlags flags; 2202 VkPipelineShaderStageCreateInfo stage; 2203 VkPipelineLayout layout; 2204 VkPipeline basePipelineHandle; 2205 int32_t basePipelineIndex; 2206 } VkComputePipelineCreateInfo; 2207 2208 typedef struct VkPushConstantRange { 2209 VkShaderStageFlags stageFlags; 2210 uint32_t offset; 2211 uint32_t size; 2212 } VkPushConstantRange; 2213 2214 typedef struct VkPipelineLayoutCreateInfo { 2215 VkStructureType sType; 2216 const void* pNext; 2217 VkPipelineLayoutCreateFlags flags; 2218 uint32_t setLayoutCount; 2219 const VkDescriptorSetLayout* pSetLayouts; 2220 uint32_t pushConstantRangeCount; 2221 const VkPushConstantRange* pPushConstantRanges; 2222 } VkPipelineLayoutCreateInfo; 2223 2224 typedef struct VkSamplerCreateInfo { 2225 VkStructureType sType; 2226 const void* pNext; 2227 VkSamplerCreateFlags flags; 2228 VkFilter magFilter; 2229 VkFilter minFilter; 2230 VkSamplerMipmapMode mipmapMode; 2231 VkSamplerAddressMode addressModeU; 2232 VkSamplerAddressMode addressModeV; 2233 VkSamplerAddressMode addressModeW; 2234 float mipLodBias; 2235 VkBool32 anisotropyEnable; 2236 float maxAnisotropy; 2237 VkBool32 compareEnable; 2238 VkCompareOp compareOp; 2239 float minLod; 2240 float maxLod; 2241 VkBorderColor borderColor; 2242 VkBool32 unnormalizedCoordinates; 2243 } VkSamplerCreateInfo; 2244 2245 typedef struct VkDescriptorSetLayoutBinding { 2246 uint32_t binding; 2247 VkDescriptorType descriptorType; 2248 uint32_t descriptorCount; 2249 VkShaderStageFlags stageFlags; 2250 const VkSampler* pImmutableSamplers; 2251 } VkDescriptorSetLayoutBinding; 2252 2253 typedef struct VkDescriptorSetLayoutCreateInfo { 2254 VkStructureType sType; 2255 const void* pNext; 2256 VkDescriptorSetLayoutCreateFlags flags; 2257 uint32_t bindingCount; 2258 const VkDescriptorSetLayoutBinding* pBindings; 2259 } VkDescriptorSetLayoutCreateInfo; 2260 2261 typedef struct VkDescriptorPoolSize { 2262 VkDescriptorType type; 2263 uint32_t descriptorCount; 2264 } VkDescriptorPoolSize; 2265 2266 typedef struct VkDescriptorPoolCreateInfo { 2267 VkStructureType sType; 2268 const void* pNext; 2269 VkDescriptorPoolCreateFlags flags; 2270 uint32_t maxSets; 2271 uint32_t poolSizeCount; 2272 const VkDescriptorPoolSize* pPoolSizes; 2273 } VkDescriptorPoolCreateInfo; 2274 2275 typedef struct VkDescriptorSetAllocateInfo { 2276 VkStructureType sType; 2277 const void* pNext; 2278 VkDescriptorPool descriptorPool; 2279 uint32_t descriptorSetCount; 2280 const VkDescriptorSetLayout* pSetLayouts; 2281 } VkDescriptorSetAllocateInfo; 2282 2283 typedef struct VkDescriptorImageInfo { 2284 VkSampler sampler; 2285 VkImageView imageView; 2286 VkImageLayout imageLayout; 2287 } VkDescriptorImageInfo; 2288 2289 typedef struct VkDescriptorBufferInfo { 2290 VkBuffer buffer; 2291 VkDeviceSize offset; 2292 VkDeviceSize range; 2293 } VkDescriptorBufferInfo; 2294 2295 typedef struct VkWriteDescriptorSet { 2296 VkStructureType sType; 2297 const void* pNext; 2298 VkDescriptorSet dstSet; 2299 uint32_t dstBinding; 2300 uint32_t dstArrayElement; 2301 uint32_t descriptorCount; 2302 VkDescriptorType descriptorType; 2303 const VkDescriptorImageInfo* pImageInfo; 2304 const VkDescriptorBufferInfo* pBufferInfo; 2305 const VkBufferView* pTexelBufferView; 2306 } VkWriteDescriptorSet; 2307 2308 typedef struct VkCopyDescriptorSet { 2309 VkStructureType sType; 2310 const void* pNext; 2311 VkDescriptorSet srcSet; 2312 uint32_t srcBinding; 2313 uint32_t srcArrayElement; 2314 VkDescriptorSet dstSet; 2315 uint32_t dstBinding; 2316 uint32_t dstArrayElement; 2317 uint32_t descriptorCount; 2318 } VkCopyDescriptorSet; 2319 2320 typedef struct VkFramebufferCreateInfo { 2321 VkStructureType sType; 2322 const void* pNext; 2323 VkFramebufferCreateFlags flags; 2324 VkRenderPass renderPass; 2325 uint32_t attachmentCount; 2326 const VkImageView* pAttachments; 2327 uint32_t width; 2328 uint32_t height; 2329 uint32_t layers; 2330 } VkFramebufferCreateInfo; 2331 2332 typedef struct VkAttachmentDescription { 2333 VkAttachmentDescriptionFlags flags; 2334 VkFormat format; 2335 VkSampleCountFlagBits samples; 2336 VkAttachmentLoadOp loadOp; 2337 VkAttachmentStoreOp storeOp; 2338 VkAttachmentLoadOp stencilLoadOp; 2339 VkAttachmentStoreOp stencilStoreOp; 2340 VkImageLayout initialLayout; 2341 VkImageLayout finalLayout; 2342 } VkAttachmentDescription; 2343 2344 typedef struct VkAttachmentReference { 2345 uint32_t attachment; 2346 VkImageLayout layout; 2347 } VkAttachmentReference; 2348 2349 typedef struct VkSubpassDescription { 2350 VkSubpassDescriptionFlags flags; 2351 VkPipelineBindPoint pipelineBindPoint; 2352 uint32_t inputAttachmentCount; 2353 const VkAttachmentReference* pInputAttachments; 2354 uint32_t colorAttachmentCount; 2355 const VkAttachmentReference* pColorAttachments; 2356 const VkAttachmentReference* pResolveAttachments; 2357 const VkAttachmentReference* pDepthStencilAttachment; 2358 uint32_t preserveAttachmentCount; 2359 const uint32_t* pPreserveAttachments; 2360 } VkSubpassDescription; 2361 2362 typedef struct VkSubpassDependency { 2363 uint32_t srcSubpass; 2364 uint32_t dstSubpass; 2365 VkPipelineStageFlags srcStageMask; 2366 VkPipelineStageFlags dstStageMask; 2367 VkAccessFlags srcAccessMask; 2368 VkAccessFlags dstAccessMask; 2369 VkDependencyFlags dependencyFlags; 2370 } VkSubpassDependency; 2371 2372 typedef struct VkRenderPassCreateInfo { 2373 VkStructureType sType; 2374 const void* pNext; 2375 VkRenderPassCreateFlags flags; 2376 uint32_t attachmentCount; 2377 const VkAttachmentDescription* pAttachments; 2378 uint32_t subpassCount; 2379 const VkSubpassDescription* pSubpasses; 2380 uint32_t dependencyCount; 2381 const VkSubpassDependency* pDependencies; 2382 } VkRenderPassCreateInfo; 2383 2384 typedef struct VkCommandPoolCreateInfo { 2385 VkStructureType sType; 2386 const void* pNext; 2387 VkCommandPoolCreateFlags flags; 2388 uint32_t queueFamilyIndex; 2389 } VkCommandPoolCreateInfo; 2390 2391 typedef struct VkCommandBufferAllocateInfo { 2392 VkStructureType sType; 2393 const void* pNext; 2394 VkCommandPool commandPool; 2395 VkCommandBufferLevel level; 2396 uint32_t commandBufferCount; 2397 } VkCommandBufferAllocateInfo; 2398 2399 typedef struct VkCommandBufferInheritanceInfo { 2400 VkStructureType sType; 2401 const void* pNext; 2402 VkRenderPass renderPass; 2403 uint32_t subpass; 2404 VkFramebuffer framebuffer; 2405 VkBool32 occlusionQueryEnable; 2406 VkQueryControlFlags queryFlags; 2407 VkQueryPipelineStatisticFlags pipelineStatistics; 2408 } VkCommandBufferInheritanceInfo; 2409 2410 typedef struct VkCommandBufferBeginInfo { 2411 VkStructureType sType; 2412 const void* pNext; 2413 VkCommandBufferUsageFlags flags; 2414 const VkCommandBufferInheritanceInfo* pInheritanceInfo; 2415 } VkCommandBufferBeginInfo; 2416 2417 typedef struct VkBufferCopy { 2418 VkDeviceSize srcOffset; 2419 VkDeviceSize dstOffset; 2420 VkDeviceSize size; 2421 } VkBufferCopy; 2422 2423 typedef struct VkImageSubresourceLayers { 2424 VkImageAspectFlags aspectMask; 2425 uint32_t mipLevel; 2426 uint32_t baseArrayLayer; 2427 uint32_t layerCount; 2428 } VkImageSubresourceLayers; 2429 2430 typedef struct VkImageCopy { 2431 VkImageSubresourceLayers srcSubresource; 2432 VkOffset3D srcOffset; 2433 VkImageSubresourceLayers dstSubresource; 2434 VkOffset3D dstOffset; 2435 VkExtent3D extent; 2436 } VkImageCopy; 2437 2438 typedef struct VkImageBlit { 2439 VkImageSubresourceLayers srcSubresource; 2440 VkOffset3D srcOffsets[2]; 2441 VkImageSubresourceLayers dstSubresource; 2442 VkOffset3D dstOffsets[2]; 2443 } VkImageBlit; 2444 2445 typedef struct VkBufferImageCopy { 2446 VkDeviceSize bufferOffset; 2447 uint32_t bufferRowLength; 2448 uint32_t bufferImageHeight; 2449 VkImageSubresourceLayers imageSubresource; 2450 VkOffset3D imageOffset; 2451 VkExtent3D imageExtent; 2452 } VkBufferImageCopy; 2453 2454 typedef union VkClearColorValue { 2455 float float32[4]; 2456 int32_t int32[4]; 2457 uint32_t uint32[4]; 2458 } VkClearColorValue; 2459 2460 typedef struct VkClearDepthStencilValue { 2461 float depth; 2462 uint32_t stencil; 2463 } VkClearDepthStencilValue; 2464 2465 typedef union VkClearValue { 2466 VkClearColorValue color; 2467 VkClearDepthStencilValue depthStencil; 2468 } VkClearValue; 2469 2470 typedef struct VkClearAttachment { 2471 VkImageAspectFlags aspectMask; 2472 uint32_t colorAttachment; 2473 VkClearValue clearValue; 2474 } VkClearAttachment; 2475 2476 typedef struct VkClearRect { 2477 VkRect2D rect; 2478 uint32_t baseArrayLayer; 2479 uint32_t layerCount; 2480 } VkClearRect; 2481 2482 typedef struct VkImageResolve { 2483 VkImageSubresourceLayers srcSubresource; 2484 VkOffset3D srcOffset; 2485 VkImageSubresourceLayers dstSubresource; 2486 VkOffset3D dstOffset; 2487 VkExtent3D extent; 2488 } VkImageResolve; 2489 2490 typedef struct VkMemoryBarrier { 2491 VkStructureType sType; 2492 const void* pNext; 2493 VkAccessFlags srcAccessMask; 2494 VkAccessFlags dstAccessMask; 2495 } VkMemoryBarrier; 2496 2497 typedef struct VkBufferMemoryBarrier { 2498 VkStructureType sType; 2499 const void* pNext; 2500 VkAccessFlags srcAccessMask; 2501 VkAccessFlags dstAccessMask; 2502 uint32_t srcQueueFamilyIndex; 2503 uint32_t dstQueueFamilyIndex; 2504 VkBuffer buffer; 2505 VkDeviceSize offset; 2506 VkDeviceSize size; 2507 } VkBufferMemoryBarrier; 2508 2509 typedef struct VkImageMemoryBarrier { 2510 VkStructureType sType; 2511 const void* pNext; 2512 VkAccessFlags srcAccessMask; 2513 VkAccessFlags dstAccessMask; 2514 VkImageLayout oldLayout; 2515 VkImageLayout newLayout; 2516 uint32_t srcQueueFamilyIndex; 2517 uint32_t dstQueueFamilyIndex; 2518 VkImage image; 2519 VkImageSubresourceRange subresourceRange; 2520 } VkImageMemoryBarrier; 2521 2522 typedef struct VkRenderPassBeginInfo { 2523 VkStructureType sType; 2524 const void* pNext; 2525 VkRenderPass renderPass; 2526 VkFramebuffer framebuffer; 2527 VkRect2D renderArea; 2528 uint32_t clearValueCount; 2529 const VkClearValue* pClearValues; 2530 } VkRenderPassBeginInfo; 2531 2532 typedef struct VkDispatchIndirectCommand { 2533 uint32_t x; 2534 uint32_t y; 2535 uint32_t z; 2536 } VkDispatchIndirectCommand; 2537 2538 typedef struct VkDrawIndexedIndirectCommand { 2539 uint32_t indexCount; 2540 uint32_t instanceCount; 2541 uint32_t firstIndex; 2542 int32_t vertexOffset; 2543 uint32_t firstInstance; 2544 } VkDrawIndexedIndirectCommand; 2545 2546 typedef struct VkDrawIndirectCommand { 2547 uint32_t vertexCount; 2548 uint32_t instanceCount; 2549 uint32_t firstVertex; 2550 uint32_t firstInstance; 2551 } VkDrawIndirectCommand; 2552 2553 2554 typedef VkResult (VKAPI_PTR *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance); 2555 typedef void (VKAPI_PTR *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks* pAllocator); 2556 typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); 2557 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures); 2558 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties); 2559 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties); 2560 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties); 2561 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties); 2562 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties); 2563 typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName); 2564 typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName); 2565 typedef VkResult (VKAPI_PTR *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice); 2566 typedef void (VKAPI_PTR *PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks* pAllocator); 2567 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); 2568 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); 2569 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties); 2570 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties); 2571 typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue); 2572 typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence); 2573 typedef VkResult (VKAPI_PTR *PFN_vkQueueWaitIdle)(VkQueue queue); 2574 typedef VkResult (VKAPI_PTR *PFN_vkDeviceWaitIdle)(VkDevice device); 2575 typedef VkResult (VKAPI_PTR *PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory); 2576 typedef void (VKAPI_PTR *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator); 2577 typedef VkResult (VKAPI_PTR *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData); 2578 typedef void (VKAPI_PTR *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory); 2579 typedef VkResult (VKAPI_PTR *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); 2580 typedef VkResult (VKAPI_PTR *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); 2581 typedef void (VKAPI_PTR *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes); 2582 typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset); 2583 typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset); 2584 typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements); 2585 typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements); 2586 typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements); 2587 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties); 2588 typedef VkResult (VKAPI_PTR *PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence); 2589 typedef VkResult (VKAPI_PTR *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); 2590 typedef void (VKAPI_PTR *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator); 2591 typedef VkResult (VKAPI_PTR *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences); 2592 typedef VkResult (VKAPI_PTR *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence); 2593 typedef VkResult (VKAPI_PTR *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout); 2594 typedef VkResult (VKAPI_PTR *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore); 2595 typedef void (VKAPI_PTR *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator); 2596 typedef VkResult (VKAPI_PTR *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent); 2597 typedef void (VKAPI_PTR *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator); 2598 typedef VkResult (VKAPI_PTR *PFN_vkGetEventStatus)(VkDevice device, VkEvent event); 2599 typedef VkResult (VKAPI_PTR *PFN_vkSetEvent)(VkDevice device, VkEvent event); 2600 typedef VkResult (VKAPI_PTR *PFN_vkResetEvent)(VkDevice device, VkEvent event); 2601 typedef VkResult (VKAPI_PTR *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool); 2602 typedef void (VKAPI_PTR *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator); 2603 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); 2604 typedef VkResult (VKAPI_PTR *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer); 2605 typedef void (VKAPI_PTR *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator); 2606 typedef VkResult (VKAPI_PTR *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView); 2607 typedef void (VKAPI_PTR *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator); 2608 typedef VkResult (VKAPI_PTR *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage); 2609 typedef void (VKAPI_PTR *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator); 2610 typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout); 2611 typedef VkResult (VKAPI_PTR *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView); 2612 typedef void (VKAPI_PTR *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator); 2613 typedef VkResult (VKAPI_PTR *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule); 2614 typedef void (VKAPI_PTR *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator); 2615 typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache); 2616 typedef void (VKAPI_PTR *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator); 2617 typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData); 2618 typedef VkResult (VKAPI_PTR *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches); 2619 typedef VkResult (VKAPI_PTR *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); 2620 typedef VkResult (VKAPI_PTR *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); 2621 typedef void (VKAPI_PTR *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator); 2622 typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout); 2623 typedef void (VKAPI_PTR *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator); 2624 typedef VkResult (VKAPI_PTR *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler); 2625 typedef void (VKAPI_PTR *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator); 2626 typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout); 2627 typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator); 2628 typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool); 2629 typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator); 2630 typedef VkResult (VKAPI_PTR *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags); 2631 typedef VkResult (VKAPI_PTR *PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets); 2632 typedef VkResult (VKAPI_PTR *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets); 2633 typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies); 2634 typedef VkResult (VKAPI_PTR *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer); 2635 typedef void (VKAPI_PTR *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator); 2636 typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); 2637 typedef void (VKAPI_PTR *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator); 2638 typedef void (VKAPI_PTR *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity); 2639 typedef VkResult (VKAPI_PTR *PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool); 2640 typedef void (VKAPI_PTR *PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator); 2641 typedef VkResult (VKAPI_PTR *PFN_vkResetCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags); 2642 typedef VkResult (VKAPI_PTR *PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers); 2643 typedef void (VKAPI_PTR *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); 2644 typedef VkResult (VKAPI_PTR *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo); 2645 typedef VkResult (VKAPI_PTR *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer); 2646 typedef VkResult (VKAPI_PTR *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags); 2647 typedef void (VKAPI_PTR *PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); 2648 typedef void (VKAPI_PTR *PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports); 2649 typedef void (VKAPI_PTR *PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors); 2650 typedef void (VKAPI_PTR *PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth); 2651 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor); 2652 typedef void (VKAPI_PTR *PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4]); 2653 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds); 2654 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask); 2655 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask); 2656 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference); 2657 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); 2658 typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); 2659 typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets); 2660 typedef void (VKAPI_PTR *PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance); 2661 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance); 2662 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); 2663 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); 2664 typedef void (VKAPI_PTR *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); 2665 typedef void (VKAPI_PTR *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); 2666 typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions); 2667 typedef void (VKAPI_PTR *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions); 2668 typedef void (VKAPI_PTR *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter); 2669 typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions); 2670 typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions); 2671 typedef void (VKAPI_PTR *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData); 2672 typedef void (VKAPI_PTR *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data); 2673 typedef void (VKAPI_PTR *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); 2674 typedef void (VKAPI_PTR *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); 2675 typedef void (VKAPI_PTR *PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects); 2676 typedef void (VKAPI_PTR *PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions); 2677 typedef void (VKAPI_PTR *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); 2678 typedef void (VKAPI_PTR *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); 2679 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); 2680 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); 2681 typedef void (VKAPI_PTR *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags); 2682 typedef void (VKAPI_PTR *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query); 2683 typedef void (VKAPI_PTR *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); 2684 typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query); 2685 typedef void (VKAPI_PTR *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags); 2686 typedef void (VKAPI_PTR *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues); 2687 typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents); 2688 typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkSubpassContents contents); 2689 typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer); 2690 typedef void (VKAPI_PTR *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); 2691 2692 #ifndef VK_NO_PROTOTYPES 2693 VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance( 2694 const VkInstanceCreateInfo* pCreateInfo, 2695 const VkAllocationCallbacks* pAllocator, 2696 VkInstance* pInstance); 2697 2698 VKAPI_ATTR void VKAPI_CALL vkDestroyInstance( 2699 VkInstance instance, 2700 const VkAllocationCallbacks* pAllocator); 2701 2702 VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices( 2703 VkInstance instance, 2704 uint32_t* pPhysicalDeviceCount, 2705 VkPhysicalDevice* pPhysicalDevices); 2706 2707 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures( 2708 VkPhysicalDevice physicalDevice, 2709 VkPhysicalDeviceFeatures* pFeatures); 2710 2711 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties( 2712 VkPhysicalDevice physicalDevice, 2713 VkFormat format, 2714 VkFormatProperties* pFormatProperties); 2715 2716 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties( 2717 VkPhysicalDevice physicalDevice, 2718 VkFormat format, 2719 VkImageType type, 2720 VkImageTiling tiling, 2721 VkImageUsageFlags usage, 2722 VkImageCreateFlags flags, 2723 VkImageFormatProperties* pImageFormatProperties); 2724 2725 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties( 2726 VkPhysicalDevice physicalDevice, 2727 VkPhysicalDeviceProperties* pProperties); 2728 2729 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties( 2730 VkPhysicalDevice physicalDevice, 2731 uint32_t* pQueueFamilyPropertyCount, 2732 VkQueueFamilyProperties* pQueueFamilyProperties); 2733 2734 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties( 2735 VkPhysicalDevice physicalDevice, 2736 VkPhysicalDeviceMemoryProperties* pMemoryProperties); 2737 2738 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr( 2739 VkInstance instance, 2740 const char* pName); 2741 2742 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr( 2743 VkDevice device, 2744 const char* pName); 2745 2746 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice( 2747 VkPhysicalDevice physicalDevice, 2748 const VkDeviceCreateInfo* pCreateInfo, 2749 const VkAllocationCallbacks* pAllocator, 2750 VkDevice* pDevice); 2751 2752 VKAPI_ATTR void VKAPI_CALL vkDestroyDevice( 2753 VkDevice device, 2754 const VkAllocationCallbacks* pAllocator); 2755 2756 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties( 2757 const char* pLayerName, 2758 uint32_t* pPropertyCount, 2759 VkExtensionProperties* pProperties); 2760 2761 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties( 2762 VkPhysicalDevice physicalDevice, 2763 const char* pLayerName, 2764 uint32_t* pPropertyCount, 2765 VkExtensionProperties* pProperties); 2766 2767 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties( 2768 uint32_t* pPropertyCount, 2769 VkLayerProperties* pProperties); 2770 2771 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties( 2772 VkPhysicalDevice physicalDevice, 2773 uint32_t* pPropertyCount, 2774 VkLayerProperties* pProperties); 2775 2776 VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue( 2777 VkDevice device, 2778 uint32_t queueFamilyIndex, 2779 uint32_t queueIndex, 2780 VkQueue* pQueue); 2781 2782 VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit( 2783 VkQueue queue, 2784 uint32_t submitCount, 2785 const VkSubmitInfo* pSubmits, 2786 VkFence fence); 2787 2788 VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle( 2789 VkQueue queue); 2790 2791 VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle( 2792 VkDevice device); 2793 2794 VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory( 2795 VkDevice device, 2796 const VkMemoryAllocateInfo* pAllocateInfo, 2797 const VkAllocationCallbacks* pAllocator, 2798 VkDeviceMemory* pMemory); 2799 2800 VKAPI_ATTR void VKAPI_CALL vkFreeMemory( 2801 VkDevice device, 2802 VkDeviceMemory memory, 2803 const VkAllocationCallbacks* pAllocator); 2804 2805 VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory( 2806 VkDevice device, 2807 VkDeviceMemory memory, 2808 VkDeviceSize offset, 2809 VkDeviceSize size, 2810 VkMemoryMapFlags flags, 2811 void** ppData); 2812 2813 VKAPI_ATTR void VKAPI_CALL vkUnmapMemory( 2814 VkDevice device, 2815 VkDeviceMemory memory); 2816 2817 VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges( 2818 VkDevice device, 2819 uint32_t memoryRangeCount, 2820 const VkMappedMemoryRange* pMemoryRanges); 2821 2822 VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges( 2823 VkDevice device, 2824 uint32_t memoryRangeCount, 2825 const VkMappedMemoryRange* pMemoryRanges); 2826 2827 VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment( 2828 VkDevice device, 2829 VkDeviceMemory memory, 2830 VkDeviceSize* pCommittedMemoryInBytes); 2831 2832 VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory( 2833 VkDevice device, 2834 VkBuffer buffer, 2835 VkDeviceMemory memory, 2836 VkDeviceSize memoryOffset); 2837 2838 VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory( 2839 VkDevice device, 2840 VkImage image, 2841 VkDeviceMemory memory, 2842 VkDeviceSize memoryOffset); 2843 2844 VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements( 2845 VkDevice device, 2846 VkBuffer buffer, 2847 VkMemoryRequirements* pMemoryRequirements); 2848 2849 VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements( 2850 VkDevice device, 2851 VkImage image, 2852 VkMemoryRequirements* pMemoryRequirements); 2853 2854 VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements( 2855 VkDevice device, 2856 VkImage image, 2857 uint32_t* pSparseMemoryRequirementCount, 2858 VkSparseImageMemoryRequirements* pSparseMemoryRequirements); 2859 2860 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties( 2861 VkPhysicalDevice physicalDevice, 2862 VkFormat format, 2863 VkImageType type, 2864 VkSampleCountFlagBits samples, 2865 VkImageUsageFlags usage, 2866 VkImageTiling tiling, 2867 uint32_t* pPropertyCount, 2868 VkSparseImageFormatProperties* pProperties); 2869 2870 VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse( 2871 VkQueue queue, 2872 uint32_t bindInfoCount, 2873 const VkBindSparseInfo* pBindInfo, 2874 VkFence fence); 2875 2876 VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence( 2877 VkDevice device, 2878 const VkFenceCreateInfo* pCreateInfo, 2879 const VkAllocationCallbacks* pAllocator, 2880 VkFence* pFence); 2881 2882 VKAPI_ATTR void VKAPI_CALL vkDestroyFence( 2883 VkDevice device, 2884 VkFence fence, 2885 const VkAllocationCallbacks* pAllocator); 2886 2887 VKAPI_ATTR VkResult VKAPI_CALL vkResetFences( 2888 VkDevice device, 2889 uint32_t fenceCount, 2890 const VkFence* pFences); 2891 2892 VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus( 2893 VkDevice device, 2894 VkFence fence); 2895 2896 VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences( 2897 VkDevice device, 2898 uint32_t fenceCount, 2899 const VkFence* pFences, 2900 VkBool32 waitAll, 2901 uint64_t timeout); 2902 2903 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore( 2904 VkDevice device, 2905 const VkSemaphoreCreateInfo* pCreateInfo, 2906 const VkAllocationCallbacks* pAllocator, 2907 VkSemaphore* pSemaphore); 2908 2909 VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore( 2910 VkDevice device, 2911 VkSemaphore semaphore, 2912 const VkAllocationCallbacks* pAllocator); 2913 2914 VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent( 2915 VkDevice device, 2916 const VkEventCreateInfo* pCreateInfo, 2917 const VkAllocationCallbacks* pAllocator, 2918 VkEvent* pEvent); 2919 2920 VKAPI_ATTR void VKAPI_CALL vkDestroyEvent( 2921 VkDevice device, 2922 VkEvent event, 2923 const VkAllocationCallbacks* pAllocator); 2924 2925 VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus( 2926 VkDevice device, 2927 VkEvent event); 2928 2929 VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent( 2930 VkDevice device, 2931 VkEvent event); 2932 2933 VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent( 2934 VkDevice device, 2935 VkEvent event); 2936 2937 VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool( 2938 VkDevice device, 2939 const VkQueryPoolCreateInfo* pCreateInfo, 2940 const VkAllocationCallbacks* pAllocator, 2941 VkQueryPool* pQueryPool); 2942 2943 VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool( 2944 VkDevice device, 2945 VkQueryPool queryPool, 2946 const VkAllocationCallbacks* pAllocator); 2947 2948 VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults( 2949 VkDevice device, 2950 VkQueryPool queryPool, 2951 uint32_t firstQuery, 2952 uint32_t queryCount, 2953 size_t dataSize, 2954 void* pData, 2955 VkDeviceSize stride, 2956 VkQueryResultFlags flags); 2957 2958 VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer( 2959 VkDevice device, 2960 const VkBufferCreateInfo* pCreateInfo, 2961 const VkAllocationCallbacks* pAllocator, 2962 VkBuffer* pBuffer); 2963 2964 VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer( 2965 VkDevice device, 2966 VkBuffer buffer, 2967 const VkAllocationCallbacks* pAllocator); 2968 2969 VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView( 2970 VkDevice device, 2971 const VkBufferViewCreateInfo* pCreateInfo, 2972 const VkAllocationCallbacks* pAllocator, 2973 VkBufferView* pView); 2974 2975 VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView( 2976 VkDevice device, 2977 VkBufferView bufferView, 2978 const VkAllocationCallbacks* pAllocator); 2979 2980 VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage( 2981 VkDevice device, 2982 const VkImageCreateInfo* pCreateInfo, 2983 const VkAllocationCallbacks* pAllocator, 2984 VkImage* pImage); 2985 2986 VKAPI_ATTR void VKAPI_CALL vkDestroyImage( 2987 VkDevice device, 2988 VkImage image, 2989 const VkAllocationCallbacks* pAllocator); 2990 2991 VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout( 2992 VkDevice device, 2993 VkImage image, 2994 const VkImageSubresource* pSubresource, 2995 VkSubresourceLayout* pLayout); 2996 2997 VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView( 2998 VkDevice device, 2999 const VkImageViewCreateInfo* pCreateInfo, 3000 const VkAllocationCallbacks* pAllocator, 3001 VkImageView* pView); 3002 3003 VKAPI_ATTR void VKAPI_CALL vkDestroyImageView( 3004 VkDevice device, 3005 VkImageView imageView, 3006 const VkAllocationCallbacks* pAllocator); 3007 3008 VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule( 3009 VkDevice device, 3010 const VkShaderModuleCreateInfo* pCreateInfo, 3011 const VkAllocationCallbacks* pAllocator, 3012 VkShaderModule* pShaderModule); 3013 3014 VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule( 3015 VkDevice device, 3016 VkShaderModule shaderModule, 3017 const VkAllocationCallbacks* pAllocator); 3018 3019 VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache( 3020 VkDevice device, 3021 const VkPipelineCacheCreateInfo* pCreateInfo, 3022 const VkAllocationCallbacks* pAllocator, 3023 VkPipelineCache* pPipelineCache); 3024 3025 VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache( 3026 VkDevice device, 3027 VkPipelineCache pipelineCache, 3028 const VkAllocationCallbacks* pAllocator); 3029 3030 VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData( 3031 VkDevice device, 3032 VkPipelineCache pipelineCache, 3033 size_t* pDataSize, 3034 void* pData); 3035 3036 VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches( 3037 VkDevice device, 3038 VkPipelineCache dstCache, 3039 uint32_t srcCacheCount, 3040 const VkPipelineCache* pSrcCaches); 3041 3042 VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines( 3043 VkDevice device, 3044 VkPipelineCache pipelineCache, 3045 uint32_t createInfoCount, 3046 const VkGraphicsPipelineCreateInfo* pCreateInfos, 3047 const VkAllocationCallbacks* pAllocator, 3048 VkPipeline* pPipelines); 3049 3050 VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines( 3051 VkDevice device, 3052 VkPipelineCache pipelineCache, 3053 uint32_t createInfoCount, 3054 const VkComputePipelineCreateInfo* pCreateInfos, 3055 const VkAllocationCallbacks* pAllocator, 3056 VkPipeline* pPipelines); 3057 3058 VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline( 3059 VkDevice device, 3060 VkPipeline pipeline, 3061 const VkAllocationCallbacks* pAllocator); 3062 3063 VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout( 3064 VkDevice device, 3065 const VkPipelineLayoutCreateInfo* pCreateInfo, 3066 const VkAllocationCallbacks* pAllocator, 3067 VkPipelineLayout* pPipelineLayout); 3068 3069 VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout( 3070 VkDevice device, 3071 VkPipelineLayout pipelineLayout, 3072 const VkAllocationCallbacks* pAllocator); 3073 3074 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler( 3075 VkDevice device, 3076 const VkSamplerCreateInfo* pCreateInfo, 3077 const VkAllocationCallbacks* pAllocator, 3078 VkSampler* pSampler); 3079 3080 VKAPI_ATTR void VKAPI_CALL vkDestroySampler( 3081 VkDevice device, 3082 VkSampler sampler, 3083 const VkAllocationCallbacks* pAllocator); 3084 3085 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout( 3086 VkDevice device, 3087 const VkDescriptorSetLayoutCreateInfo* pCreateInfo, 3088 const VkAllocationCallbacks* pAllocator, 3089 VkDescriptorSetLayout* pSetLayout); 3090 3091 VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout( 3092 VkDevice device, 3093 VkDescriptorSetLayout descriptorSetLayout, 3094 const VkAllocationCallbacks* pAllocator); 3095 3096 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool( 3097 VkDevice device, 3098 const VkDescriptorPoolCreateInfo* pCreateInfo, 3099 const VkAllocationCallbacks* pAllocator, 3100 VkDescriptorPool* pDescriptorPool); 3101 3102 VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool( 3103 VkDevice device, 3104 VkDescriptorPool descriptorPool, 3105 const VkAllocationCallbacks* pAllocator); 3106 3107 VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool( 3108 VkDevice device, 3109 VkDescriptorPool descriptorPool, 3110 VkDescriptorPoolResetFlags flags); 3111 3112 VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets( 3113 VkDevice device, 3114 const VkDescriptorSetAllocateInfo* pAllocateInfo, 3115 VkDescriptorSet* pDescriptorSets); 3116 3117 VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets( 3118 VkDevice device, 3119 VkDescriptorPool descriptorPool, 3120 uint32_t descriptorSetCount, 3121 const VkDescriptorSet* pDescriptorSets); 3122 3123 VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets( 3124 VkDevice device, 3125 uint32_t descriptorWriteCount, 3126 const VkWriteDescriptorSet* pDescriptorWrites, 3127 uint32_t descriptorCopyCount, 3128 const VkCopyDescriptorSet* pDescriptorCopies); 3129 3130 VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer( 3131 VkDevice device, 3132 const VkFramebufferCreateInfo* pCreateInfo, 3133 const VkAllocationCallbacks* pAllocator, 3134 VkFramebuffer* pFramebuffer); 3135 3136 VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer( 3137 VkDevice device, 3138 VkFramebuffer framebuffer, 3139 const VkAllocationCallbacks* pAllocator); 3140 3141 VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass( 3142 VkDevice device, 3143 const VkRenderPassCreateInfo* pCreateInfo, 3144 const VkAllocationCallbacks* pAllocator, 3145 VkRenderPass* pRenderPass); 3146 3147 VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass( 3148 VkDevice device, 3149 VkRenderPass renderPass, 3150 const VkAllocationCallbacks* pAllocator); 3151 3152 VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity( 3153 VkDevice device, 3154 VkRenderPass renderPass, 3155 VkExtent2D* pGranularity); 3156 3157 VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool( 3158 VkDevice device, 3159 const VkCommandPoolCreateInfo* pCreateInfo, 3160 const VkAllocationCallbacks* pAllocator, 3161 VkCommandPool* pCommandPool); 3162 3163 VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool( 3164 VkDevice device, 3165 VkCommandPool commandPool, 3166 const VkAllocationCallbacks* pAllocator); 3167 3168 VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool( 3169 VkDevice device, 3170 VkCommandPool commandPool, 3171 VkCommandPoolResetFlags flags); 3172 3173 VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers( 3174 VkDevice device, 3175 const VkCommandBufferAllocateInfo* pAllocateInfo, 3176 VkCommandBuffer* pCommandBuffers); 3177 3178 VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers( 3179 VkDevice device, 3180 VkCommandPool commandPool, 3181 uint32_t commandBufferCount, 3182 const VkCommandBuffer* pCommandBuffers); 3183 3184 VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer( 3185 VkCommandBuffer commandBuffer, 3186 const VkCommandBufferBeginInfo* pBeginInfo); 3187 3188 VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer( 3189 VkCommandBuffer commandBuffer); 3190 3191 VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer( 3192 VkCommandBuffer commandBuffer, 3193 VkCommandBufferResetFlags flags); 3194 3195 VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline( 3196 VkCommandBuffer commandBuffer, 3197 VkPipelineBindPoint pipelineBindPoint, 3198 VkPipeline pipeline); 3199 3200 VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport( 3201 VkCommandBuffer commandBuffer, 3202 uint32_t firstViewport, 3203 uint32_t viewportCount, 3204 const VkViewport* pViewports); 3205 3206 VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor( 3207 VkCommandBuffer commandBuffer, 3208 uint32_t firstScissor, 3209 uint32_t scissorCount, 3210 const VkRect2D* pScissors); 3211 3212 VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth( 3213 VkCommandBuffer commandBuffer, 3214 float lineWidth); 3215 3216 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias( 3217 VkCommandBuffer commandBuffer, 3218 float depthBiasConstantFactor, 3219 float depthBiasClamp, 3220 float depthBiasSlopeFactor); 3221 3222 VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants( 3223 VkCommandBuffer commandBuffer, 3224 const float blendConstants[4]); 3225 3226 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds( 3227 VkCommandBuffer commandBuffer, 3228 float minDepthBounds, 3229 float maxDepthBounds); 3230 3231 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask( 3232 VkCommandBuffer commandBuffer, 3233 VkStencilFaceFlags faceMask, 3234 uint32_t compareMask); 3235 3236 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask( 3237 VkCommandBuffer commandBuffer, 3238 VkStencilFaceFlags faceMask, 3239 uint32_t writeMask); 3240 3241 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference( 3242 VkCommandBuffer commandBuffer, 3243 VkStencilFaceFlags faceMask, 3244 uint32_t reference); 3245 3246 VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets( 3247 VkCommandBuffer commandBuffer, 3248 VkPipelineBindPoint pipelineBindPoint, 3249 VkPipelineLayout layout, 3250 uint32_t firstSet, 3251 uint32_t descriptorSetCount, 3252 const VkDescriptorSet* pDescriptorSets, 3253 uint32_t dynamicOffsetCount, 3254 const uint32_t* pDynamicOffsets); 3255 3256 VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer( 3257 VkCommandBuffer commandBuffer, 3258 VkBuffer buffer, 3259 VkDeviceSize offset, 3260 VkIndexType indexType); 3261 3262 VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers( 3263 VkCommandBuffer commandBuffer, 3264 uint32_t firstBinding, 3265 uint32_t bindingCount, 3266 const VkBuffer* pBuffers, 3267 const VkDeviceSize* pOffsets); 3268 3269 VKAPI_ATTR void VKAPI_CALL vkCmdDraw( 3270 VkCommandBuffer commandBuffer, 3271 uint32_t vertexCount, 3272 uint32_t instanceCount, 3273 uint32_t firstVertex, 3274 uint32_t firstInstance); 3275 3276 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed( 3277 VkCommandBuffer commandBuffer, 3278 uint32_t indexCount, 3279 uint32_t instanceCount, 3280 uint32_t firstIndex, 3281 int32_t vertexOffset, 3282 uint32_t firstInstance); 3283 3284 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect( 3285 VkCommandBuffer commandBuffer, 3286 VkBuffer buffer, 3287 VkDeviceSize offset, 3288 uint32_t drawCount, 3289 uint32_t stride); 3290 3291 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect( 3292 VkCommandBuffer commandBuffer, 3293 VkBuffer buffer, 3294 VkDeviceSize offset, 3295 uint32_t drawCount, 3296 uint32_t stride); 3297 3298 VKAPI_ATTR void VKAPI_CALL vkCmdDispatch( 3299 VkCommandBuffer commandBuffer, 3300 uint32_t groupCountX, 3301 uint32_t groupCountY, 3302 uint32_t groupCountZ); 3303 3304 VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect( 3305 VkCommandBuffer commandBuffer, 3306 VkBuffer buffer, 3307 VkDeviceSize offset); 3308 3309 VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer( 3310 VkCommandBuffer commandBuffer, 3311 VkBuffer srcBuffer, 3312 VkBuffer dstBuffer, 3313 uint32_t regionCount, 3314 const VkBufferCopy* pRegions); 3315 3316 VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage( 3317 VkCommandBuffer commandBuffer, 3318 VkImage srcImage, 3319 VkImageLayout srcImageLayout, 3320 VkImage dstImage, 3321 VkImageLayout dstImageLayout, 3322 uint32_t regionCount, 3323 const VkImageCopy* pRegions); 3324 3325 VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage( 3326 VkCommandBuffer commandBuffer, 3327 VkImage srcImage, 3328 VkImageLayout srcImageLayout, 3329 VkImage dstImage, 3330 VkImageLayout dstImageLayout, 3331 uint32_t regionCount, 3332 const VkImageBlit* pRegions, 3333 VkFilter filter); 3334 3335 VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage( 3336 VkCommandBuffer commandBuffer, 3337 VkBuffer srcBuffer, 3338 VkImage dstImage, 3339 VkImageLayout dstImageLayout, 3340 uint32_t regionCount, 3341 const VkBufferImageCopy* pRegions); 3342 3343 VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer( 3344 VkCommandBuffer commandBuffer, 3345 VkImage srcImage, 3346 VkImageLayout srcImageLayout, 3347 VkBuffer dstBuffer, 3348 uint32_t regionCount, 3349 const VkBufferImageCopy* pRegions); 3350 3351 VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer( 3352 VkCommandBuffer commandBuffer, 3353 VkBuffer dstBuffer, 3354 VkDeviceSize dstOffset, 3355 VkDeviceSize dataSize, 3356 const void* pData); 3357 3358 VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer( 3359 VkCommandBuffer commandBuffer, 3360 VkBuffer dstBuffer, 3361 VkDeviceSize dstOffset, 3362 VkDeviceSize size, 3363 uint32_t data); 3364 3365 VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage( 3366 VkCommandBuffer commandBuffer, 3367 VkImage image, 3368 VkImageLayout imageLayout, 3369 const VkClearColorValue* pColor, 3370 uint32_t rangeCount, 3371 const VkImageSubresourceRange* pRanges); 3372 3373 VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage( 3374 VkCommandBuffer commandBuffer, 3375 VkImage image, 3376 VkImageLayout imageLayout, 3377 const VkClearDepthStencilValue* pDepthStencil, 3378 uint32_t rangeCount, 3379 const VkImageSubresourceRange* pRanges); 3380 3381 VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments( 3382 VkCommandBuffer commandBuffer, 3383 uint32_t attachmentCount, 3384 const VkClearAttachment* pAttachments, 3385 uint32_t rectCount, 3386 const VkClearRect* pRects); 3387 3388 VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage( 3389 VkCommandBuffer commandBuffer, 3390 VkImage srcImage, 3391 VkImageLayout srcImageLayout, 3392 VkImage dstImage, 3393 VkImageLayout dstImageLayout, 3394 uint32_t regionCount, 3395 const VkImageResolve* pRegions); 3396 3397 VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent( 3398 VkCommandBuffer commandBuffer, 3399 VkEvent event, 3400 VkPipelineStageFlags stageMask); 3401 3402 VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent( 3403 VkCommandBuffer commandBuffer, 3404 VkEvent event, 3405 VkPipelineStageFlags stageMask); 3406 3407 VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents( 3408 VkCommandBuffer commandBuffer, 3409 uint32_t eventCount, 3410 const VkEvent* pEvents, 3411 VkPipelineStageFlags srcStageMask, 3412 VkPipelineStageFlags dstStageMask, 3413 uint32_t memoryBarrierCount, 3414 const VkMemoryBarrier* pMemoryBarriers, 3415 uint32_t bufferMemoryBarrierCount, 3416 const VkBufferMemoryBarrier* pBufferMemoryBarriers, 3417 uint32_t imageMemoryBarrierCount, 3418 const VkImageMemoryBarrier* pImageMemoryBarriers); 3419 3420 VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier( 3421 VkCommandBuffer commandBuffer, 3422 VkPipelineStageFlags srcStageMask, 3423 VkPipelineStageFlags dstStageMask, 3424 VkDependencyFlags dependencyFlags, 3425 uint32_t memoryBarrierCount, 3426 const VkMemoryBarrier* pMemoryBarriers, 3427 uint32_t bufferMemoryBarrierCount, 3428 const VkBufferMemoryBarrier* pBufferMemoryBarriers, 3429 uint32_t imageMemoryBarrierCount, 3430 const VkImageMemoryBarrier* pImageMemoryBarriers); 3431 3432 VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery( 3433 VkCommandBuffer commandBuffer, 3434 VkQueryPool queryPool, 3435 uint32_t query, 3436 VkQueryControlFlags flags); 3437 3438 VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery( 3439 VkCommandBuffer commandBuffer, 3440 VkQueryPool queryPool, 3441 uint32_t query); 3442 3443 VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool( 3444 VkCommandBuffer commandBuffer, 3445 VkQueryPool queryPool, 3446 uint32_t firstQuery, 3447 uint32_t queryCount); 3448 3449 VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp( 3450 VkCommandBuffer commandBuffer, 3451 VkPipelineStageFlagBits pipelineStage, 3452 VkQueryPool queryPool, 3453 uint32_t query); 3454 3455 VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults( 3456 VkCommandBuffer commandBuffer, 3457 VkQueryPool queryPool, 3458 uint32_t firstQuery, 3459 uint32_t queryCount, 3460 VkBuffer dstBuffer, 3461 VkDeviceSize dstOffset, 3462 VkDeviceSize stride, 3463 VkQueryResultFlags flags); 3464 3465 VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants( 3466 VkCommandBuffer commandBuffer, 3467 VkPipelineLayout layout, 3468 VkShaderStageFlags stageFlags, 3469 uint32_t offset, 3470 uint32_t size, 3471 const void* pValues); 3472 3473 VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass( 3474 VkCommandBuffer commandBuffer, 3475 const VkRenderPassBeginInfo* pRenderPassBegin, 3476 VkSubpassContents contents); 3477 3478 VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass( 3479 VkCommandBuffer commandBuffer, 3480 VkSubpassContents contents); 3481 3482 VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass( 3483 VkCommandBuffer commandBuffer); 3484 3485 VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands( 3486 VkCommandBuffer commandBuffer, 3487 uint32_t commandBufferCount, 3488 const VkCommandBuffer* pCommandBuffers); 3489 #endif 3490 3491 #define VK_KHR_surface 1 3492 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR) 3493 3494 #define VK_KHR_SURFACE_SPEC_VERSION 25 3495 #define VK_KHR_SURFACE_EXTENSION_NAME "VK_KHR_surface" 3496 #define VK_COLORSPACE_SRGB_NONLINEAR_KHR VK_COLOR_SPACE_SRGB_NONLINEAR_KHR 3497 3498 3499 typedef enum VkColorSpaceKHR { 3500 VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0, 3501 VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT = 1000104001, 3502 VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT = 1000104002, 3503 VK_COLOR_SPACE_DCI_P3_LINEAR_EXT = 1000104003, 3504 VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT = 1000104004, 3505 VK_COLOR_SPACE_BT709_LINEAR_EXT = 1000104005, 3506 VK_COLOR_SPACE_BT709_NONLINEAR_EXT = 1000104006, 3507 VK_COLOR_SPACE_BT2020_LINEAR_EXT = 1000104007, 3508 VK_COLOR_SPACE_HDR10_ST2084_EXT = 1000104008, 3509 VK_COLOR_SPACE_DOLBYVISION_EXT = 1000104009, 3510 VK_COLOR_SPACE_HDR10_HLG_EXT = 1000104010, 3511 VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT = 1000104011, 3512 VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT = 1000104012, 3513 VK_COLOR_SPACE_PASS_THROUGH_EXT = 1000104013, 3514 VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT = 1000104014, 3515 VK_COLOR_SPACE_BEGIN_RANGE_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, 3516 VK_COLOR_SPACE_END_RANGE_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, 3517 VK_COLOR_SPACE_RANGE_SIZE_KHR = (VK_COLOR_SPACE_SRGB_NONLINEAR_KHR - VK_COLOR_SPACE_SRGB_NONLINEAR_KHR + 1), 3518 VK_COLOR_SPACE_MAX_ENUM_KHR = 0x7FFFFFFF 3519 } VkColorSpaceKHR; 3520 3521 typedef enum VkPresentModeKHR { 3522 VK_PRESENT_MODE_IMMEDIATE_KHR = 0, 3523 VK_PRESENT_MODE_MAILBOX_KHR = 1, 3524 VK_PRESENT_MODE_FIFO_KHR = 2, 3525 VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3, 3526 VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR = 1000111000, 3527 VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR = 1000111001, 3528 VK_PRESENT_MODE_BEGIN_RANGE_KHR = VK_PRESENT_MODE_IMMEDIATE_KHR, 3529 VK_PRESENT_MODE_END_RANGE_KHR = VK_PRESENT_MODE_FIFO_RELAXED_KHR, 3530 VK_PRESENT_MODE_RANGE_SIZE_KHR = (VK_PRESENT_MODE_FIFO_RELAXED_KHR - VK_PRESENT_MODE_IMMEDIATE_KHR + 1), 3531 VK_PRESENT_MODE_MAX_ENUM_KHR = 0x7FFFFFFF 3532 } VkPresentModeKHR; 3533 3534 3535 typedef enum VkSurfaceTransformFlagBitsKHR { 3536 VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 0x00000001, 3537 VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 0x00000002, 3538 VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 0x00000004, 3539 VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 0x00000008, 3540 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 0x00000010, 3541 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 0x00000020, 3542 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 0x00000040, 3543 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 0x00000080, 3544 VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100, 3545 VK_SURFACE_TRANSFORM_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 3546 } VkSurfaceTransformFlagBitsKHR; 3547 typedef VkFlags VkSurfaceTransformFlagsKHR; 3548 3549 typedef enum VkCompositeAlphaFlagBitsKHR { 3550 VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, 3551 VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002, 3552 VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004, 3553 VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008, 3554 VK_COMPOSITE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 3555 } VkCompositeAlphaFlagBitsKHR; 3556 typedef VkFlags VkCompositeAlphaFlagsKHR; 3557 3558 typedef struct VkSurfaceCapabilitiesKHR { 3559 uint32_t minImageCount; 3560 uint32_t maxImageCount; 3561 VkExtent2D currentExtent; 3562 VkExtent2D minImageExtent; 3563 VkExtent2D maxImageExtent; 3564 uint32_t maxImageArrayLayers; 3565 VkSurfaceTransformFlagsKHR supportedTransforms; 3566 VkSurfaceTransformFlagBitsKHR currentTransform; 3567 VkCompositeAlphaFlagsKHR supportedCompositeAlpha; 3568 VkImageUsageFlags supportedUsageFlags; 3569 } VkSurfaceCapabilitiesKHR; 3570 3571 typedef struct VkSurfaceFormatKHR { 3572 VkFormat format; 3573 VkColorSpaceKHR colorSpace; 3574 } VkSurfaceFormatKHR; 3575 3576 3577 typedef void (VKAPI_PTR *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator); 3578 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported); 3579 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); 3580 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats); 3581 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes); 3582 3583 #ifndef VK_NO_PROTOTYPES 3584 VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR( 3585 VkInstance instance, 3586 VkSurfaceKHR surface, 3587 const VkAllocationCallbacks* pAllocator); 3588 3589 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR( 3590 VkPhysicalDevice physicalDevice, 3591 uint32_t queueFamilyIndex, 3592 VkSurfaceKHR surface, 3593 VkBool32* pSupported); 3594 3595 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR( 3596 VkPhysicalDevice physicalDevice, 3597 VkSurfaceKHR surface, 3598 VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); 3599 3600 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR( 3601 VkPhysicalDevice physicalDevice, 3602 VkSurfaceKHR surface, 3603 uint32_t* pSurfaceFormatCount, 3604 VkSurfaceFormatKHR* pSurfaceFormats); 3605 3606 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR( 3607 VkPhysicalDevice physicalDevice, 3608 VkSurfaceKHR surface, 3609 uint32_t* pPresentModeCount, 3610 VkPresentModeKHR* pPresentModes); 3611 #endif 3612 3613 #define VK_KHR_swapchain 1 3614 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR) 3615 3616 #define VK_KHR_SWAPCHAIN_SPEC_VERSION 68 3617 #define VK_KHR_SWAPCHAIN_EXTENSION_NAME "VK_KHR_swapchain" 3618 3619 3620 typedef enum VkSwapchainCreateFlagBitsKHR { 3621 VK_SWAPCHAIN_CREATE_BIND_SFR_BIT_KHX = 0x00000001, 3622 VK_SWAPCHAIN_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 3623 } VkSwapchainCreateFlagBitsKHR; 3624 typedef VkFlags VkSwapchainCreateFlagsKHR; 3625 3626 typedef struct VkSwapchainCreateInfoKHR { 3627 VkStructureType sType; 3628 const void* pNext; 3629 VkSwapchainCreateFlagsKHR flags; 3630 VkSurfaceKHR surface; 3631 uint32_t minImageCount; 3632 VkFormat imageFormat; 3633 VkColorSpaceKHR imageColorSpace; 3634 VkExtent2D imageExtent; 3635 uint32_t imageArrayLayers; 3636 VkImageUsageFlags imageUsage; 3637 VkSharingMode imageSharingMode; 3638 uint32_t queueFamilyIndexCount; 3639 const uint32_t* pQueueFamilyIndices; 3640 VkSurfaceTransformFlagBitsKHR preTransform; 3641 VkCompositeAlphaFlagBitsKHR compositeAlpha; 3642 VkPresentModeKHR presentMode; 3643 VkBool32 clipped; 3644 VkSwapchainKHR oldSwapchain; 3645 } VkSwapchainCreateInfoKHR; 3646 3647 typedef struct VkPresentInfoKHR { 3648 VkStructureType sType; 3649 const void* pNext; 3650 uint32_t waitSemaphoreCount; 3651 const VkSemaphore* pWaitSemaphores; 3652 uint32_t swapchainCount; 3653 const VkSwapchainKHR* pSwapchains; 3654 const uint32_t* pImageIndices; 3655 VkResult* pResults; 3656 } VkPresentInfoKHR; 3657 3658 3659 typedef VkResult (VKAPI_PTR *PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain); 3660 typedef void (VKAPI_PTR *PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator); 3661 typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages); 3662 typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex); 3663 typedef VkResult (VKAPI_PTR *PFN_vkQueuePresentKHR)(VkQueue queue, const VkPresentInfoKHR* pPresentInfo); 3664 3665 #ifndef VK_NO_PROTOTYPES 3666 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR( 3667 VkDevice device, 3668 const VkSwapchainCreateInfoKHR* pCreateInfo, 3669 const VkAllocationCallbacks* pAllocator, 3670 VkSwapchainKHR* pSwapchain); 3671 3672 VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR( 3673 VkDevice device, 3674 VkSwapchainKHR swapchain, 3675 const VkAllocationCallbacks* pAllocator); 3676 3677 VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR( 3678 VkDevice device, 3679 VkSwapchainKHR swapchain, 3680 uint32_t* pSwapchainImageCount, 3681 VkImage* pSwapchainImages); 3682 3683 VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR( 3684 VkDevice device, 3685 VkSwapchainKHR swapchain, 3686 uint64_t timeout, 3687 VkSemaphore semaphore, 3688 VkFence fence, 3689 uint32_t* pImageIndex); 3690 3691 VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR( 3692 VkQueue queue, 3693 const VkPresentInfoKHR* pPresentInfo); 3694 #endif 3695 3696 #define VK_KHR_display 1 3697 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR) 3698 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR) 3699 3700 #define VK_KHR_DISPLAY_SPEC_VERSION 21 3701 #define VK_KHR_DISPLAY_EXTENSION_NAME "VK_KHR_display" 3702 3703 3704 typedef enum VkDisplayPlaneAlphaFlagBitsKHR { 3705 VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, 3706 VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000002, 3707 VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000004, 3708 VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000008, 3709 VK_DISPLAY_PLANE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 3710 } VkDisplayPlaneAlphaFlagBitsKHR; 3711 typedef VkFlags VkDisplayPlaneAlphaFlagsKHR; 3712 typedef VkFlags VkDisplayModeCreateFlagsKHR; 3713 typedef VkFlags VkDisplaySurfaceCreateFlagsKHR; 3714 3715 typedef struct VkDisplayPropertiesKHR { 3716 VkDisplayKHR display; 3717 const char* displayName; 3718 VkExtent2D physicalDimensions; 3719 VkExtent2D physicalResolution; 3720 VkSurfaceTransformFlagsKHR supportedTransforms; 3721 VkBool32 planeReorderPossible; 3722 VkBool32 persistentContent; 3723 } VkDisplayPropertiesKHR; 3724 3725 typedef struct VkDisplayModeParametersKHR { 3726 VkExtent2D visibleRegion; 3727 uint32_t refreshRate; 3728 } VkDisplayModeParametersKHR; 3729 3730 typedef struct VkDisplayModePropertiesKHR { 3731 VkDisplayModeKHR displayMode; 3732 VkDisplayModeParametersKHR parameters; 3733 } VkDisplayModePropertiesKHR; 3734 3735 typedef struct VkDisplayModeCreateInfoKHR { 3736 VkStructureType sType; 3737 const void* pNext; 3738 VkDisplayModeCreateFlagsKHR flags; 3739 VkDisplayModeParametersKHR parameters; 3740 } VkDisplayModeCreateInfoKHR; 3741 3742 typedef struct VkDisplayPlaneCapabilitiesKHR { 3743 VkDisplayPlaneAlphaFlagsKHR supportedAlpha; 3744 VkOffset2D minSrcPosition; 3745 VkOffset2D maxSrcPosition; 3746 VkExtent2D minSrcExtent; 3747 VkExtent2D maxSrcExtent; 3748 VkOffset2D minDstPosition; 3749 VkOffset2D maxDstPosition; 3750 VkExtent2D minDstExtent; 3751 VkExtent2D maxDstExtent; 3752 } VkDisplayPlaneCapabilitiesKHR; 3753 3754 typedef struct VkDisplayPlanePropertiesKHR { 3755 VkDisplayKHR currentDisplay; 3756 uint32_t currentStackIndex; 3757 } VkDisplayPlanePropertiesKHR; 3758 3759 typedef struct VkDisplaySurfaceCreateInfoKHR { 3760 VkStructureType sType; 3761 const void* pNext; 3762 VkDisplaySurfaceCreateFlagsKHR flags; 3763 VkDisplayModeKHR displayMode; 3764 uint32_t planeIndex; 3765 uint32_t planeStackIndex; 3766 VkSurfaceTransformFlagBitsKHR transform; 3767 float globalAlpha; 3768 VkDisplayPlaneAlphaFlagBitsKHR alphaMode; 3769 VkExtent2D imageExtent; 3770 } VkDisplaySurfaceCreateInfoKHR; 3771 3772 3773 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties); 3774 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties); 3775 typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays); 3776 typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties); 3777 typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode); 3778 typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities); 3779 typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); 3780 3781 #ifndef VK_NO_PROTOTYPES 3782 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR( 3783 VkPhysicalDevice physicalDevice, 3784 uint32_t* pPropertyCount, 3785 VkDisplayPropertiesKHR* pProperties); 3786 3787 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR( 3788 VkPhysicalDevice physicalDevice, 3789 uint32_t* pPropertyCount, 3790 VkDisplayPlanePropertiesKHR* pProperties); 3791 3792 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR( 3793 VkPhysicalDevice physicalDevice, 3794 uint32_t planeIndex, 3795 uint32_t* pDisplayCount, 3796 VkDisplayKHR* pDisplays); 3797 3798 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR( 3799 VkPhysicalDevice physicalDevice, 3800 VkDisplayKHR display, 3801 uint32_t* pPropertyCount, 3802 VkDisplayModePropertiesKHR* pProperties); 3803 3804 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR( 3805 VkPhysicalDevice physicalDevice, 3806 VkDisplayKHR display, 3807 const VkDisplayModeCreateInfoKHR* pCreateInfo, 3808 const VkAllocationCallbacks* pAllocator, 3809 VkDisplayModeKHR* pMode); 3810 3811 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR( 3812 VkPhysicalDevice physicalDevice, 3813 VkDisplayModeKHR mode, 3814 uint32_t planeIndex, 3815 VkDisplayPlaneCapabilitiesKHR* pCapabilities); 3816 3817 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR( 3818 VkInstance instance, 3819 const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, 3820 const VkAllocationCallbacks* pAllocator, 3821 VkSurfaceKHR* pSurface); 3822 #endif 3823 3824 #define VK_KHR_display_swapchain 1 3825 #define VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION 9 3826 #define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain" 3827 3828 typedef struct VkDisplayPresentInfoKHR { 3829 VkStructureType sType; 3830 const void* pNext; 3831 VkRect2D srcRect; 3832 VkRect2D dstRect; 3833 VkBool32 persistent; 3834 } VkDisplayPresentInfoKHR; 3835 3836 3837 typedef VkResult (VKAPI_PTR *PFN_vkCreateSharedSwapchainsKHR)(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains); 3838 3839 #ifndef VK_NO_PROTOTYPES 3840 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR( 3841 VkDevice device, 3842 uint32_t swapchainCount, 3843 const VkSwapchainCreateInfoKHR* pCreateInfos, 3844 const VkAllocationCallbacks* pAllocator, 3845 VkSwapchainKHR* pSwapchains); 3846 #endif 3847 3848 #ifdef VK_USE_PLATFORM_XLIB_KHR 3849 #define VK_KHR_xlib_surface 1 3850 #include <X11/Xlib.h> 3851 3852 #define VK_KHR_XLIB_SURFACE_SPEC_VERSION 6 3853 #define VK_KHR_XLIB_SURFACE_EXTENSION_NAME "VK_KHR_xlib_surface" 3854 3855 typedef VkFlags VkXlibSurfaceCreateFlagsKHR; 3856 3857 typedef struct VkXlibSurfaceCreateInfoKHR { 3858 VkStructureType sType; 3859 const void* pNext; 3860 VkXlibSurfaceCreateFlagsKHR flags; 3861 Display* dpy; 3862 Window window; 3863 } VkXlibSurfaceCreateInfoKHR; 3864 3865 3866 typedef VkResult (VKAPI_PTR *PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); 3867 typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID); 3868 3869 #ifndef VK_NO_PROTOTYPES 3870 VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR( 3871 VkInstance instance, 3872 const VkXlibSurfaceCreateInfoKHR* pCreateInfo, 3873 const VkAllocationCallbacks* pAllocator, 3874 VkSurfaceKHR* pSurface); 3875 3876 VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR( 3877 VkPhysicalDevice physicalDevice, 3878 uint32_t queueFamilyIndex, 3879 Display* dpy, 3880 VisualID visualID); 3881 #endif 3882 #endif /* VK_USE_PLATFORM_XLIB_KHR */ 3883 3884 #ifdef VK_USE_PLATFORM_XCB_KHR 3885 #define VK_KHR_xcb_surface 1 3886 #include <xcb/xcb.h> 3887 3888 #define VK_KHR_XCB_SURFACE_SPEC_VERSION 6 3889 #define VK_KHR_XCB_SURFACE_EXTENSION_NAME "VK_KHR_xcb_surface" 3890 3891 typedef VkFlags VkXcbSurfaceCreateFlagsKHR; 3892 3893 typedef struct VkXcbSurfaceCreateInfoKHR { 3894 VkStructureType sType; 3895 const void* pNext; 3896 VkXcbSurfaceCreateFlagsKHR flags; 3897 xcb_connection_t* connection; 3898 xcb_window_t window; 3899 } VkXcbSurfaceCreateInfoKHR; 3900 3901 3902 typedef VkResult (VKAPI_PTR *PFN_vkCreateXcbSurfaceKHR)(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); 3903 typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id); 3904 3905 #ifndef VK_NO_PROTOTYPES 3906 VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR( 3907 VkInstance instance, 3908 const VkXcbSurfaceCreateInfoKHR* pCreateInfo, 3909 const VkAllocationCallbacks* pAllocator, 3910 VkSurfaceKHR* pSurface); 3911 3912 VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR( 3913 VkPhysicalDevice physicalDevice, 3914 uint32_t queueFamilyIndex, 3915 xcb_connection_t* connection, 3916 xcb_visualid_t visual_id); 3917 #endif 3918 #endif /* VK_USE_PLATFORM_XCB_KHR */ 3919 3920 #ifdef VK_USE_PLATFORM_WAYLAND_KHR 3921 #define VK_KHR_wayland_surface 1 3922 #include <wayland-client.h> 3923 3924 #define VK_KHR_WAYLAND_SURFACE_SPEC_VERSION 6 3925 #define VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME "VK_KHR_wayland_surface" 3926 3927 typedef VkFlags VkWaylandSurfaceCreateFlagsKHR; 3928 3929 typedef struct VkWaylandSurfaceCreateInfoKHR { 3930 VkStructureType sType; 3931 const void* pNext; 3932 VkWaylandSurfaceCreateFlagsKHR flags; 3933 struct wl_display* display; 3934 struct wl_surface* surface; 3935 } VkWaylandSurfaceCreateInfoKHR; 3936 3937 3938 typedef VkResult (VKAPI_PTR *PFN_vkCreateWaylandSurfaceKHR)(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); 3939 typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display); 3940 3941 #ifndef VK_NO_PROTOTYPES 3942 VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR( 3943 VkInstance instance, 3944 const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, 3945 const VkAllocationCallbacks* pAllocator, 3946 VkSurfaceKHR* pSurface); 3947 3948 VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR( 3949 VkPhysicalDevice physicalDevice, 3950 uint32_t queueFamilyIndex, 3951 struct wl_display* display); 3952 #endif 3953 #endif /* VK_USE_PLATFORM_WAYLAND_KHR */ 3954 3955 #ifdef VK_USE_PLATFORM_MIR_KHR 3956 #define VK_KHR_mir_surface 1 3957 #include <mir_toolkit/client_types.h> 3958 3959 #define VK_KHR_MIR_SURFACE_SPEC_VERSION 4 3960 #define VK_KHR_MIR_SURFACE_EXTENSION_NAME "VK_KHR_mir_surface" 3961 3962 typedef VkFlags VkMirSurfaceCreateFlagsKHR; 3963 3964 typedef struct VkMirSurfaceCreateInfoKHR { 3965 VkStructureType sType; 3966 const void* pNext; 3967 VkMirSurfaceCreateFlagsKHR flags; 3968 MirConnection* connection; 3969 MirSurface* mirSurface; 3970 } VkMirSurfaceCreateInfoKHR; 3971 3972 3973 typedef VkResult (VKAPI_PTR *PFN_vkCreateMirSurfaceKHR)(VkInstance instance, const VkMirSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); 3974 typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceMirPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, MirConnection* connection); 3975 3976 #ifndef VK_NO_PROTOTYPES 3977 VKAPI_ATTR VkResult VKAPI_CALL vkCreateMirSurfaceKHR( 3978 VkInstance instance, 3979 const VkMirSurfaceCreateInfoKHR* pCreateInfo, 3980 const VkAllocationCallbacks* pAllocator, 3981 VkSurfaceKHR* pSurface); 3982 3983 VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceMirPresentationSupportKHR( 3984 VkPhysicalDevice physicalDevice, 3985 uint32_t queueFamilyIndex, 3986 MirConnection* connection); 3987 #endif 3988 #endif /* VK_USE_PLATFORM_MIR_KHR */ 3989 3990 #ifdef VK_USE_PLATFORM_ANDROID_KHR 3991 #define VK_KHR_android_surface 1 3992 #include <android/native_window.h> 3993 3994 #define VK_KHR_ANDROID_SURFACE_SPEC_VERSION 6 3995 #define VK_KHR_ANDROID_SURFACE_EXTENSION_NAME "VK_KHR_android_surface" 3996 3997 typedef VkFlags VkAndroidSurfaceCreateFlagsKHR; 3998 3999 typedef struct VkAndroidSurfaceCreateInfoKHR { 4000 VkStructureType sType; 4001 const void* pNext; 4002 VkAndroidSurfaceCreateFlagsKHR flags; 4003 ANativeWindow* window; 4004 } VkAndroidSurfaceCreateInfoKHR; 4005 4006 4007 typedef VkResult (VKAPI_PTR *PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); 4008 4009 #ifndef VK_NO_PROTOTYPES 4010 VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR( 4011 VkInstance instance, 4012 const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, 4013 const VkAllocationCallbacks* pAllocator, 4014 VkSurfaceKHR* pSurface); 4015 #endif 4016 #endif /* VK_USE_PLATFORM_ANDROID_KHR */ 4017 4018 #ifdef VK_USE_PLATFORM_WIN32_KHR 4019 #define VK_KHR_win32_surface 1 4020 #include <windows.h> 4021 4022 #define VK_KHR_WIN32_SURFACE_SPEC_VERSION 6 4023 #define VK_KHR_WIN32_SURFACE_EXTENSION_NAME "VK_KHR_win32_surface" 4024 4025 typedef VkFlags VkWin32SurfaceCreateFlagsKHR; 4026 4027 typedef struct VkWin32SurfaceCreateInfoKHR { 4028 VkStructureType sType; 4029 const void* pNext; 4030 VkWin32SurfaceCreateFlagsKHR flags; 4031 HINSTANCE hinstance; 4032 HWND hwnd; 4033 } VkWin32SurfaceCreateInfoKHR; 4034 4035 4036 typedef VkResult (VKAPI_PTR *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); 4037 typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex); 4038 4039 #ifndef VK_NO_PROTOTYPES 4040 VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR( 4041 VkInstance instance, 4042 const VkWin32SurfaceCreateInfoKHR* pCreateInfo, 4043 const VkAllocationCallbacks* pAllocator, 4044 VkSurfaceKHR* pSurface); 4045 4046 VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR( 4047 VkPhysicalDevice physicalDevice, 4048 uint32_t queueFamilyIndex); 4049 #endif 4050 #endif /* VK_USE_PLATFORM_WIN32_KHR */ 4051 4052 #define VK_KHR_sampler_mirror_clamp_to_edge 1 4053 #define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION 1 4054 #define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME "VK_KHR_sampler_mirror_clamp_to_edge" 4055 4056 4057 #define VK_KHR_get_physical_device_properties2 1 4058 #define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION 1 4059 #define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_physical_device_properties2" 4060 4061 typedef struct VkPhysicalDeviceFeatures2KHR { 4062 VkStructureType sType; 4063 void* pNext; 4064 VkPhysicalDeviceFeatures features; 4065 } VkPhysicalDeviceFeatures2KHR; 4066 4067 typedef struct VkPhysicalDeviceProperties2KHR { 4068 VkStructureType sType; 4069 void* pNext; 4070 VkPhysicalDeviceProperties properties; 4071 } VkPhysicalDeviceProperties2KHR; 4072 4073 typedef struct VkFormatProperties2KHR { 4074 VkStructureType sType; 4075 void* pNext; 4076 VkFormatProperties formatProperties; 4077 } VkFormatProperties2KHR; 4078 4079 typedef struct VkImageFormatProperties2KHR { 4080 VkStructureType sType; 4081 void* pNext; 4082 VkImageFormatProperties imageFormatProperties; 4083 } VkImageFormatProperties2KHR; 4084 4085 typedef struct VkPhysicalDeviceImageFormatInfo2KHR { 4086 VkStructureType sType; 4087 const void* pNext; 4088 VkFormat format; 4089 VkImageType type; 4090 VkImageTiling tiling; 4091 VkImageUsageFlags usage; 4092 VkImageCreateFlags flags; 4093 } VkPhysicalDeviceImageFormatInfo2KHR; 4094 4095 typedef struct VkQueueFamilyProperties2KHR { 4096 VkStructureType sType; 4097 void* pNext; 4098 VkQueueFamilyProperties queueFamilyProperties; 4099 } VkQueueFamilyProperties2KHR; 4100 4101 typedef struct VkPhysicalDeviceMemoryProperties2KHR { 4102 VkStructureType sType; 4103 void* pNext; 4104 VkPhysicalDeviceMemoryProperties memoryProperties; 4105 } VkPhysicalDeviceMemoryProperties2KHR; 4106 4107 typedef struct VkSparseImageFormatProperties2KHR { 4108 VkStructureType sType; 4109 void* pNext; 4110 VkSparseImageFormatProperties properties; 4111 } VkSparseImageFormatProperties2KHR; 4112 4113 typedef struct VkPhysicalDeviceSparseImageFormatInfo2KHR { 4114 VkStructureType sType; 4115 const void* pNext; 4116 VkFormat format; 4117 VkImageType type; 4118 VkSampleCountFlagBits samples; 4119 VkImageUsageFlags usage; 4120 VkImageTiling tiling; 4121 } VkPhysicalDeviceSparseImageFormatInfo2KHR; 4122 4123 4124 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2KHR* pFeatures); 4125 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2KHR* pProperties); 4126 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2KHR)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2KHR* pFormatProperties); 4127 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2KHR* pImageFormatInfo, VkImageFormatProperties2KHR* pImageFormatProperties); 4128 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2KHR* pQueueFamilyProperties); 4129 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2KHR* pMemoryProperties); 4130 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2KHR* pProperties); 4131 4132 #ifndef VK_NO_PROTOTYPES 4133 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2KHR( 4134 VkPhysicalDevice physicalDevice, 4135 VkPhysicalDeviceFeatures2KHR* pFeatures); 4136 4137 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2KHR( 4138 VkPhysicalDevice physicalDevice, 4139 VkPhysicalDeviceProperties2KHR* pProperties); 4140 4141 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2KHR( 4142 VkPhysicalDevice physicalDevice, 4143 VkFormat format, 4144 VkFormatProperties2KHR* pFormatProperties); 4145 4146 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2KHR( 4147 VkPhysicalDevice physicalDevice, 4148 const VkPhysicalDeviceImageFormatInfo2KHR* pImageFormatInfo, 4149 VkImageFormatProperties2KHR* pImageFormatProperties); 4150 4151 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2KHR( 4152 VkPhysicalDevice physicalDevice, 4153 uint32_t* pQueueFamilyPropertyCount, 4154 VkQueueFamilyProperties2KHR* pQueueFamilyProperties); 4155 4156 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2KHR( 4157 VkPhysicalDevice physicalDevice, 4158 VkPhysicalDeviceMemoryProperties2KHR* pMemoryProperties); 4159 4160 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2KHR( 4161 VkPhysicalDevice physicalDevice, 4162 const VkPhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo, 4163 uint32_t* pPropertyCount, 4164 VkSparseImageFormatProperties2KHR* pProperties); 4165 #endif 4166 4167 #define VK_KHR_shader_draw_parameters 1 4168 #define VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION 1 4169 #define VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME "VK_KHR_shader_draw_parameters" 4170 4171 4172 #define VK_KHR_maintenance1 1 4173 #define VK_KHR_MAINTENANCE1_SPEC_VERSION 1 4174 #define VK_KHR_MAINTENANCE1_EXTENSION_NAME "VK_KHR_maintenance1" 4175 4176 typedef VkFlags VkCommandPoolTrimFlagsKHR; 4177 4178 typedef void (VKAPI_PTR *PFN_vkTrimCommandPoolKHR)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlagsKHR flags); 4179 4180 #ifndef VK_NO_PROTOTYPES 4181 VKAPI_ATTR void VKAPI_CALL vkTrimCommandPoolKHR( 4182 VkDevice device, 4183 VkCommandPool commandPool, 4184 VkCommandPoolTrimFlagsKHR flags); 4185 #endif 4186 4187 #define VK_KHR_external_memory_capabilities 1 4188 #define VK_LUID_SIZE_KHR 8 4189 #define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1 4190 #define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_memory_capabilities" 4191 4192 4193 typedef enum VkExternalMemoryHandleTypeFlagBitsKHR { 4194 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = 0x00000001, 4195 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = 0x00000002, 4196 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = 0x00000004, 4197 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR = 0x00000008, 4198 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR = 0x00000010, 4199 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR = 0x00000020, 4200 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR = 0x00000040, 4201 VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT = 0x00000200, 4202 VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT = 0x00000080, 4203 VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT = 0x00000100, 4204 VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 4205 } VkExternalMemoryHandleTypeFlagBitsKHR; 4206 typedef VkFlags VkExternalMemoryHandleTypeFlagsKHR; 4207 4208 typedef enum VkExternalMemoryFeatureFlagBitsKHR { 4209 VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR = 0x00000001, 4210 VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR = 0x00000002, 4211 VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR = 0x00000004, 4212 VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 4213 } VkExternalMemoryFeatureFlagBitsKHR; 4214 typedef VkFlags VkExternalMemoryFeatureFlagsKHR; 4215 4216 typedef struct VkExternalMemoryPropertiesKHR { 4217 VkExternalMemoryFeatureFlagsKHR externalMemoryFeatures; 4218 VkExternalMemoryHandleTypeFlagsKHR exportFromImportedHandleTypes; 4219 VkExternalMemoryHandleTypeFlagsKHR compatibleHandleTypes; 4220 } VkExternalMemoryPropertiesKHR; 4221 4222 typedef struct VkPhysicalDeviceExternalImageFormatInfoKHR { 4223 VkStructureType sType; 4224 const void* pNext; 4225 VkExternalMemoryHandleTypeFlagBitsKHR handleType; 4226 } VkPhysicalDeviceExternalImageFormatInfoKHR; 4227 4228 typedef struct VkExternalImageFormatPropertiesKHR { 4229 VkStructureType sType; 4230 void* pNext; 4231 VkExternalMemoryPropertiesKHR externalMemoryProperties; 4232 } VkExternalImageFormatPropertiesKHR; 4233 4234 typedef struct VkPhysicalDeviceExternalBufferInfoKHR { 4235 VkStructureType sType; 4236 const void* pNext; 4237 VkBufferCreateFlags flags; 4238 VkBufferUsageFlags usage; 4239 VkExternalMemoryHandleTypeFlagBitsKHR handleType; 4240 } VkPhysicalDeviceExternalBufferInfoKHR; 4241 4242 typedef struct VkExternalBufferPropertiesKHR { 4243 VkStructureType sType; 4244 void* pNext; 4245 VkExternalMemoryPropertiesKHR externalMemoryProperties; 4246 } VkExternalBufferPropertiesKHR; 4247 4248 typedef struct VkPhysicalDeviceIDPropertiesKHR { 4249 VkStructureType sType; 4250 void* pNext; 4251 uint8_t deviceUUID[VK_UUID_SIZE]; 4252 uint8_t driverUUID[VK_UUID_SIZE]; 4253 uint8_t deviceLUID[VK_LUID_SIZE_KHR]; 4254 uint32_t deviceNodeMask; 4255 VkBool32 deviceLUIDValid; 4256 } VkPhysicalDeviceIDPropertiesKHR; 4257 4258 4259 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo, VkExternalBufferPropertiesKHR* pExternalBufferProperties); 4260 4261 #ifndef VK_NO_PROTOTYPES 4262 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferPropertiesKHR( 4263 VkPhysicalDevice physicalDevice, 4264 const VkPhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo, 4265 VkExternalBufferPropertiesKHR* pExternalBufferProperties); 4266 #endif 4267 4268 #define VK_KHR_external_memory 1 4269 #define VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION 1 4270 #define VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME "VK_KHR_external_memory" 4271 #define VK_QUEUE_FAMILY_EXTERNAL_KHR (~0U-1) 4272 4273 typedef struct VkExternalMemoryImageCreateInfoKHR { 4274 VkStructureType sType; 4275 const void* pNext; 4276 VkExternalMemoryHandleTypeFlagsKHR handleTypes; 4277 } VkExternalMemoryImageCreateInfoKHR; 4278 4279 typedef struct VkExternalMemoryBufferCreateInfoKHR { 4280 VkStructureType sType; 4281 const void* pNext; 4282 VkExternalMemoryHandleTypeFlagsKHR handleTypes; 4283 } VkExternalMemoryBufferCreateInfoKHR; 4284 4285 typedef struct VkExportMemoryAllocateInfoKHR { 4286 VkStructureType sType; 4287 const void* pNext; 4288 VkExternalMemoryHandleTypeFlagsKHR handleTypes; 4289 } VkExportMemoryAllocateInfoKHR; 4290 4291 4292 4293 #ifdef VK_USE_PLATFORM_WIN32_KHR 4294 #define VK_KHR_external_memory_win32 1 4295 #define VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1 4296 #define VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_KHR_external_memory_win32" 4297 4298 typedef struct VkImportMemoryWin32HandleInfoKHR { 4299 VkStructureType sType; 4300 const void* pNext; 4301 VkExternalMemoryHandleTypeFlagBitsKHR handleType; 4302 HANDLE handle; 4303 LPCWSTR name; 4304 } VkImportMemoryWin32HandleInfoKHR; 4305 4306 typedef struct VkExportMemoryWin32HandleInfoKHR { 4307 VkStructureType sType; 4308 const void* pNext; 4309 const SECURITY_ATTRIBUTES* pAttributes; 4310 DWORD dwAccess; 4311 LPCWSTR name; 4312 } VkExportMemoryWin32HandleInfoKHR; 4313 4314 typedef struct VkMemoryWin32HandlePropertiesKHR { 4315 VkStructureType sType; 4316 void* pNext; 4317 uint32_t memoryTypeBits; 4318 } VkMemoryWin32HandlePropertiesKHR; 4319 4320 typedef struct VkMemoryGetWin32HandleInfoKHR { 4321 VkStructureType sType; 4322 const void* pNext; 4323 VkDeviceMemory memory; 4324 VkExternalMemoryHandleTypeFlagBitsKHR handleType; 4325 } VkMemoryGetWin32HandleInfoKHR; 4326 4327 4328 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleKHR)(VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle); 4329 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHR handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties); 4330 4331 #ifndef VK_NO_PROTOTYPES 4332 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR( 4333 VkDevice device, 4334 const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, 4335 HANDLE* pHandle); 4336 4337 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR( 4338 VkDevice device, 4339 VkExternalMemoryHandleTypeFlagBitsKHR handleType, 4340 HANDLE handle, 4341 VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties); 4342 #endif 4343 #endif /* VK_USE_PLATFORM_WIN32_KHR */ 4344 4345 #define VK_KHR_external_memory_fd 1 4346 #define VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION 1 4347 #define VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME "VK_KHR_external_memory_fd" 4348 4349 typedef struct VkImportMemoryFdInfoKHR { 4350 VkStructureType sType; 4351 const void* pNext; 4352 VkExternalMemoryHandleTypeFlagBitsKHR handleType; 4353 int fd; 4354 } VkImportMemoryFdInfoKHR; 4355 4356 typedef struct VkMemoryFdPropertiesKHR { 4357 VkStructureType sType; 4358 void* pNext; 4359 uint32_t memoryTypeBits; 4360 } VkMemoryFdPropertiesKHR; 4361 4362 typedef struct VkMemoryGetFdInfoKHR { 4363 VkStructureType sType; 4364 const void* pNext; 4365 VkDeviceMemory memory; 4366 VkExternalMemoryHandleTypeFlagBitsKHR handleType; 4367 } VkMemoryGetFdInfoKHR; 4368 4369 4370 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdKHR)(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd); 4371 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdPropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHR handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties); 4372 4373 #ifndef VK_NO_PROTOTYPES 4374 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdKHR( 4375 VkDevice device, 4376 const VkMemoryGetFdInfoKHR* pGetFdInfo, 4377 int* pFd); 4378 4379 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdPropertiesKHR( 4380 VkDevice device, 4381 VkExternalMemoryHandleTypeFlagBitsKHR handleType, 4382 int fd, 4383 VkMemoryFdPropertiesKHR* pMemoryFdProperties); 4384 #endif 4385 4386 #ifdef VK_USE_PLATFORM_WIN32_KHR 4387 #define VK_KHR_win32_keyed_mutex 1 4388 #define VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION 1 4389 #define VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_KHR_win32_keyed_mutex" 4390 4391 typedef struct VkWin32KeyedMutexAcquireReleaseInfoKHR { 4392 VkStructureType sType; 4393 const void* pNext; 4394 uint32_t acquireCount; 4395 const VkDeviceMemory* pAcquireSyncs; 4396 const uint64_t* pAcquireKeys; 4397 const uint32_t* pAcquireTimeouts; 4398 uint32_t releaseCount; 4399 const VkDeviceMemory* pReleaseSyncs; 4400 const uint64_t* pReleaseKeys; 4401 } VkWin32KeyedMutexAcquireReleaseInfoKHR; 4402 4403 4404 #endif /* VK_USE_PLATFORM_WIN32_KHR */ 4405 4406 #define VK_KHR_external_semaphore_capabilities 1 4407 #define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION 1 4408 #define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_semaphore_capabilities" 4409 4410 4411 typedef enum VkExternalSemaphoreHandleTypeFlagBitsKHR { 4412 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = 0x00000001, 4413 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = 0x00000002, 4414 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = 0x00000004, 4415 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR = 0x00000008, 4416 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR = 0x00000010, 4417 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 4418 } VkExternalSemaphoreHandleTypeFlagBitsKHR; 4419 typedef VkFlags VkExternalSemaphoreHandleTypeFlagsKHR; 4420 4421 typedef enum VkExternalSemaphoreFeatureFlagBitsKHR { 4422 VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR = 0x00000001, 4423 VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR = 0x00000002, 4424 VK_EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 4425 } VkExternalSemaphoreFeatureFlagBitsKHR; 4426 typedef VkFlags VkExternalSemaphoreFeatureFlagsKHR; 4427 4428 typedef struct VkPhysicalDeviceExternalSemaphoreInfoKHR { 4429 VkStructureType sType; 4430 const void* pNext; 4431 VkExternalSemaphoreHandleTypeFlagBitsKHR handleType; 4432 } VkPhysicalDeviceExternalSemaphoreInfoKHR; 4433 4434 typedef struct VkExternalSemaphorePropertiesKHR { 4435 VkStructureType sType; 4436 void* pNext; 4437 VkExternalSemaphoreHandleTypeFlagsKHR exportFromImportedHandleTypes; 4438 VkExternalSemaphoreHandleTypeFlagsKHR compatibleHandleTypes; 4439 VkExternalSemaphoreFeatureFlagsKHR externalSemaphoreFeatures; 4440 } VkExternalSemaphorePropertiesKHR; 4441 4442 4443 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo, VkExternalSemaphorePropertiesKHR* pExternalSemaphoreProperties); 4444 4445 #ifndef VK_NO_PROTOTYPES 4446 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( 4447 VkPhysicalDevice physicalDevice, 4448 const VkPhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo, 4449 VkExternalSemaphorePropertiesKHR* pExternalSemaphoreProperties); 4450 #endif 4451 4452 #define VK_KHR_external_semaphore 1 4453 #define VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION 1 4454 #define VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME "VK_KHR_external_semaphore" 4455 4456 4457 typedef enum VkSemaphoreImportFlagBitsKHR { 4458 VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR = 0x00000001, 4459 VK_SEMAPHORE_IMPORT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 4460 } VkSemaphoreImportFlagBitsKHR; 4461 typedef VkFlags VkSemaphoreImportFlagsKHR; 4462 4463 typedef struct VkExportSemaphoreCreateInfoKHR { 4464 VkStructureType sType; 4465 const void* pNext; 4466 VkExternalSemaphoreHandleTypeFlagsKHR handleTypes; 4467 } VkExportSemaphoreCreateInfoKHR; 4468 4469 4470 4471 #ifdef VK_USE_PLATFORM_WIN32_KHR 4472 #define VK_KHR_external_semaphore_win32 1 4473 #define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION 1 4474 #define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME "VK_KHR_external_semaphore_win32" 4475 4476 typedef struct VkImportSemaphoreWin32HandleInfoKHR { 4477 VkStructureType sType; 4478 const void* pNext; 4479 VkSemaphore semaphore; 4480 VkSemaphoreImportFlagsKHR flags; 4481 VkExternalSemaphoreHandleTypeFlagBitsKHR handleType; 4482 HANDLE handle; 4483 LPCWSTR name; 4484 } VkImportSemaphoreWin32HandleInfoKHR; 4485 4486 typedef struct VkExportSemaphoreWin32HandleInfoKHR { 4487 VkStructureType sType; 4488 const void* pNext; 4489 const SECURITY_ATTRIBUTES* pAttributes; 4490 DWORD dwAccess; 4491 LPCWSTR name; 4492 } VkExportSemaphoreWin32HandleInfoKHR; 4493 4494 typedef struct VkD3D12FenceSubmitInfoKHR { 4495 VkStructureType sType; 4496 const void* pNext; 4497 uint32_t waitSemaphoreValuesCount; 4498 const uint64_t* pWaitSemaphoreValues; 4499 uint32_t signalSemaphoreValuesCount; 4500 const uint64_t* pSignalSemaphoreValues; 4501 } VkD3D12FenceSubmitInfoKHR; 4502 4503 typedef struct VkSemaphoreGetWin32HandleInfoKHR { 4504 VkStructureType sType; 4505 const void* pNext; 4506 VkSemaphore semaphore; 4507 VkExternalSemaphoreHandleTypeFlagBitsKHR handleType; 4508 } VkSemaphoreGetWin32HandleInfoKHR; 4509 4510 4511 typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreWin32HandleKHR)(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo); 4512 typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreWin32HandleKHR)(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle); 4513 4514 #ifndef VK_NO_PROTOTYPES 4515 VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHR( 4516 VkDevice device, 4517 const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo); 4518 4519 VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHR( 4520 VkDevice device, 4521 const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, 4522 HANDLE* pHandle); 4523 #endif 4524 #endif /* VK_USE_PLATFORM_WIN32_KHR */ 4525 4526 #define VK_KHR_external_semaphore_fd 1 4527 #define VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION 1 4528 #define VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME "VK_KHR_external_semaphore_fd" 4529 4530 typedef struct VkImportSemaphoreFdInfoKHR { 4531 VkStructureType sType; 4532 const void* pNext; 4533 VkSemaphore semaphore; 4534 VkSemaphoreImportFlagsKHR flags; 4535 VkExternalSemaphoreHandleTypeFlagBitsKHR handleType; 4536 int fd; 4537 } VkImportSemaphoreFdInfoKHR; 4538 4539 typedef struct VkSemaphoreGetFdInfoKHR { 4540 VkStructureType sType; 4541 const void* pNext; 4542 VkSemaphore semaphore; 4543 VkExternalSemaphoreHandleTypeFlagBitsKHR handleType; 4544 } VkSemaphoreGetFdInfoKHR; 4545 4546 4547 typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreFdKHR)(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo); 4548 typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreFdKHR)(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd); 4549 4550 #ifndef VK_NO_PROTOTYPES 4551 VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreFdKHR( 4552 VkDevice device, 4553 const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo); 4554 4555 VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreFdKHR( 4556 VkDevice device, 4557 const VkSemaphoreGetFdInfoKHR* pGetFdInfo, 4558 int* pFd); 4559 #endif 4560 4561 #define VK_KHR_push_descriptor 1 4562 #define VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION 1 4563 #define VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME "VK_KHR_push_descriptor" 4564 4565 typedef struct VkPhysicalDevicePushDescriptorPropertiesKHR { 4566 VkStructureType sType; 4567 void* pNext; 4568 uint32_t maxPushDescriptors; 4569 } VkPhysicalDevicePushDescriptorPropertiesKHR; 4570 4571 4572 typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetKHR)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites); 4573 4574 #ifndef VK_NO_PROTOTYPES 4575 VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetKHR( 4576 VkCommandBuffer commandBuffer, 4577 VkPipelineBindPoint pipelineBindPoint, 4578 VkPipelineLayout layout, 4579 uint32_t set, 4580 uint32_t descriptorWriteCount, 4581 const VkWriteDescriptorSet* pDescriptorWrites); 4582 #endif 4583 4584 #define VK_KHR_16bit_storage 1 4585 #define VK_KHR_16BIT_STORAGE_SPEC_VERSION 1 4586 #define VK_KHR_16BIT_STORAGE_EXTENSION_NAME "VK_KHR_16bit_storage" 4587 4588 typedef struct VkPhysicalDevice16BitStorageFeaturesKHR { 4589 VkStructureType sType; 4590 void* pNext; 4591 VkBool32 storageBuffer16BitAccess; 4592 VkBool32 uniformAndStorageBuffer16BitAccess; 4593 VkBool32 storagePushConstant16; 4594 VkBool32 storageInputOutput16; 4595 } VkPhysicalDevice16BitStorageFeaturesKHR; 4596 4597 4598 4599 #define VK_KHR_incremental_present 1 4600 #define VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION 1 4601 #define VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME "VK_KHR_incremental_present" 4602 4603 typedef struct VkRectLayerKHR { 4604 VkOffset2D offset; 4605 VkExtent2D extent; 4606 uint32_t layer; 4607 } VkRectLayerKHR; 4608 4609 typedef struct VkPresentRegionKHR { 4610 uint32_t rectangleCount; 4611 const VkRectLayerKHR* pRectangles; 4612 } VkPresentRegionKHR; 4613 4614 typedef struct VkPresentRegionsKHR { 4615 VkStructureType sType; 4616 const void* pNext; 4617 uint32_t swapchainCount; 4618 const VkPresentRegionKHR* pRegions; 4619 } VkPresentRegionsKHR; 4620 4621 4622 4623 #define VK_KHR_descriptor_update_template 1 4624 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorUpdateTemplateKHR) 4625 4626 #define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION 1 4627 #define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME "VK_KHR_descriptor_update_template" 4628 4629 4630 typedef enum VkDescriptorUpdateTemplateTypeKHR { 4631 VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR = 0, 4632 VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = 1, 4633 VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_BEGIN_RANGE_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR, 4634 VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_END_RANGE_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR, 4635 VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_RANGE_SIZE_KHR = (VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR - VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR + 1), 4636 VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF 4637 } VkDescriptorUpdateTemplateTypeKHR; 4638 4639 typedef VkFlags VkDescriptorUpdateTemplateCreateFlagsKHR; 4640 4641 typedef struct VkDescriptorUpdateTemplateEntryKHR { 4642 uint32_t dstBinding; 4643 uint32_t dstArrayElement; 4644 uint32_t descriptorCount; 4645 VkDescriptorType descriptorType; 4646 size_t offset; 4647 size_t stride; 4648 } VkDescriptorUpdateTemplateEntryKHR; 4649 4650 typedef struct VkDescriptorUpdateTemplateCreateInfoKHR { 4651 VkStructureType sType; 4652 void* pNext; 4653 VkDescriptorUpdateTemplateCreateFlagsKHR flags; 4654 uint32_t descriptorUpdateEntryCount; 4655 const VkDescriptorUpdateTemplateEntryKHR* pDescriptorUpdateEntries; 4656 VkDescriptorUpdateTemplateTypeKHR templateType; 4657 VkDescriptorSetLayout descriptorSetLayout; 4658 VkPipelineBindPoint pipelineBindPoint; 4659 VkPipelineLayout pipelineLayout; 4660 uint32_t set; 4661 } VkDescriptorUpdateTemplateCreateInfoKHR; 4662 4663 4664 typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplateKHR)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplateKHR* pDescriptorUpdateTemplate); 4665 typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplateKHR)(VkDevice device, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator); 4666 typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplateKHR)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, const void* pData); 4667 typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetWithTemplateKHR)(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData); 4668 4669 #ifndef VK_NO_PROTOTYPES 4670 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplateKHR( 4671 VkDevice device, 4672 const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo, 4673 const VkAllocationCallbacks* pAllocator, 4674 VkDescriptorUpdateTemplateKHR* pDescriptorUpdateTemplate); 4675 4676 VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplateKHR( 4677 VkDevice device, 4678 VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, 4679 const VkAllocationCallbacks* pAllocator); 4680 4681 VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplateKHR( 4682 VkDevice device, 4683 VkDescriptorSet descriptorSet, 4684 VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, 4685 const void* pData); 4686 4687 VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplateKHR( 4688 VkCommandBuffer commandBuffer, 4689 VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, 4690 VkPipelineLayout layout, 4691 uint32_t set, 4692 const void* pData); 4693 #endif 4694 4695 #define VK_KHR_shared_presentable_image 1 4696 #define VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION 1 4697 #define VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME "VK_KHR_shared_presentable_image" 4698 4699 typedef struct VkSharedPresentSurfaceCapabilitiesKHR { 4700 VkStructureType sType; 4701 void* pNext; 4702 VkImageUsageFlags sharedPresentSupportedUsageFlags; 4703 } VkSharedPresentSurfaceCapabilitiesKHR; 4704 4705 4706 typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainStatusKHR)(VkDevice device, VkSwapchainKHR swapchain); 4707 4708 #ifndef VK_NO_PROTOTYPES 4709 VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainStatusKHR( 4710 VkDevice device, 4711 VkSwapchainKHR swapchain); 4712 #endif 4713 4714 #define VK_KHR_external_fence_capabilities 1 4715 #define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION 1 4716 #define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_fence_capabilities" 4717 4718 4719 typedef enum VkExternalFenceHandleTypeFlagBitsKHR { 4720 VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = 0x00000001, 4721 VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = 0x00000002, 4722 VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = 0x00000004, 4723 VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR = 0x00000008, 4724 VK_EXTERNAL_FENCE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 4725 } VkExternalFenceHandleTypeFlagBitsKHR; 4726 typedef VkFlags VkExternalFenceHandleTypeFlagsKHR; 4727 4728 typedef enum VkExternalFenceFeatureFlagBitsKHR { 4729 VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR = 0x00000001, 4730 VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR = 0x00000002, 4731 VK_EXTERNAL_FENCE_FEATURE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 4732 } VkExternalFenceFeatureFlagBitsKHR; 4733 typedef VkFlags VkExternalFenceFeatureFlagsKHR; 4734 4735 typedef struct VkPhysicalDeviceExternalFenceInfoKHR { 4736 VkStructureType sType; 4737 const void* pNext; 4738 VkExternalFenceHandleTypeFlagBitsKHR handleType; 4739 } VkPhysicalDeviceExternalFenceInfoKHR; 4740 4741 typedef struct VkExternalFencePropertiesKHR { 4742 VkStructureType sType; 4743 void* pNext; 4744 VkExternalFenceHandleTypeFlagsKHR exportFromImportedHandleTypes; 4745 VkExternalFenceHandleTypeFlagsKHR compatibleHandleTypes; 4746 VkExternalFenceFeatureFlagsKHR externalFenceFeatures; 4747 } VkExternalFencePropertiesKHR; 4748 4749 4750 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo, VkExternalFencePropertiesKHR* pExternalFenceProperties); 4751 4752 #ifndef VK_NO_PROTOTYPES 4753 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFencePropertiesKHR( 4754 VkPhysicalDevice physicalDevice, 4755 const VkPhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo, 4756 VkExternalFencePropertiesKHR* pExternalFenceProperties); 4757 #endif 4758 4759 #define VK_KHR_external_fence 1 4760 #define VK_KHR_EXTERNAL_FENCE_SPEC_VERSION 1 4761 #define VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME "VK_KHR_external_fence" 4762 4763 4764 typedef enum VkFenceImportFlagBitsKHR { 4765 VK_FENCE_IMPORT_TEMPORARY_BIT_KHR = 0x00000001, 4766 VK_FENCE_IMPORT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 4767 } VkFenceImportFlagBitsKHR; 4768 typedef VkFlags VkFenceImportFlagsKHR; 4769 4770 typedef struct VkExportFenceCreateInfoKHR { 4771 VkStructureType sType; 4772 const void* pNext; 4773 VkExternalFenceHandleTypeFlagsKHR handleTypes; 4774 } VkExportFenceCreateInfoKHR; 4775 4776 4777 4778 #ifdef VK_USE_PLATFORM_WIN32_KHR 4779 #define VK_KHR_external_fence_win32 1 4780 #define VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION 1 4781 #define VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME "VK_KHR_external_fence_win32" 4782 4783 typedef struct VkImportFenceWin32HandleInfoKHR { 4784 VkStructureType sType; 4785 const void* pNext; 4786 VkFence fence; 4787 VkFenceImportFlagsKHR flags; 4788 VkExternalFenceHandleTypeFlagBitsKHR handleType; 4789 HANDLE handle; 4790 LPCWSTR name; 4791 } VkImportFenceWin32HandleInfoKHR; 4792 4793 typedef struct VkExportFenceWin32HandleInfoKHR { 4794 VkStructureType sType; 4795 const void* pNext; 4796 const SECURITY_ATTRIBUTES* pAttributes; 4797 DWORD dwAccess; 4798 LPCWSTR name; 4799 } VkExportFenceWin32HandleInfoKHR; 4800 4801 typedef struct VkFenceGetWin32HandleInfoKHR { 4802 VkStructureType sType; 4803 const void* pNext; 4804 VkFence fence; 4805 VkExternalFenceHandleTypeFlagBitsKHR handleType; 4806 } VkFenceGetWin32HandleInfoKHR; 4807 4808 4809 typedef VkResult (VKAPI_PTR *PFN_vkImportFenceWin32HandleKHR)(VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo); 4810 typedef VkResult (VKAPI_PTR *PFN_vkGetFenceWin32HandleKHR)(VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle); 4811 4812 #ifndef VK_NO_PROTOTYPES 4813 VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceWin32HandleKHR( 4814 VkDevice device, 4815 const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo); 4816 4817 VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceWin32HandleKHR( 4818 VkDevice device, 4819 const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, 4820 HANDLE* pHandle); 4821 #endif 4822 #endif /* VK_USE_PLATFORM_WIN32_KHR */ 4823 4824 #define VK_KHR_external_fence_fd 1 4825 #define VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION 1 4826 #define VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME "VK_KHR_external_fence_fd" 4827 4828 typedef struct VkImportFenceFdInfoKHR { 4829 VkStructureType sType; 4830 const void* pNext; 4831 VkFence fence; 4832 VkFenceImportFlagsKHR flags; 4833 VkExternalFenceHandleTypeFlagBitsKHR handleType; 4834 int fd; 4835 } VkImportFenceFdInfoKHR; 4836 4837 typedef struct VkFenceGetFdInfoKHR { 4838 VkStructureType sType; 4839 const void* pNext; 4840 VkFence fence; 4841 VkExternalFenceHandleTypeFlagBitsKHR handleType; 4842 } VkFenceGetFdInfoKHR; 4843 4844 4845 typedef VkResult (VKAPI_PTR *PFN_vkImportFenceFdKHR)(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo); 4846 typedef VkResult (VKAPI_PTR *PFN_vkGetFenceFdKHR)(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd); 4847 4848 #ifndef VK_NO_PROTOTYPES 4849 VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceFdKHR( 4850 VkDevice device, 4851 const VkImportFenceFdInfoKHR* pImportFenceFdInfo); 4852 4853 VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceFdKHR( 4854 VkDevice device, 4855 const VkFenceGetFdInfoKHR* pGetFdInfo, 4856 int* pFd); 4857 #endif 4858 4859 #define VK_KHR_maintenance2 1 4860 #define VK_KHR_MAINTENANCE2_SPEC_VERSION 1 4861 #define VK_KHR_MAINTENANCE2_EXTENSION_NAME "VK_KHR_maintenance2" 4862 4863 4864 typedef enum VkPointClippingBehaviorKHR { 4865 VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR = 0, 4866 VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR = 1, 4867 VK_POINT_CLIPPING_BEHAVIOR_BEGIN_RANGE_KHR = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR, 4868 VK_POINT_CLIPPING_BEHAVIOR_END_RANGE_KHR = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR, 4869 VK_POINT_CLIPPING_BEHAVIOR_RANGE_SIZE_KHR = (VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR - VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR + 1), 4870 VK_POINT_CLIPPING_BEHAVIOR_MAX_ENUM_KHR = 0x7FFFFFFF 4871 } VkPointClippingBehaviorKHR; 4872 4873 typedef enum VkTessellationDomainOriginKHR { 4874 VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR = 0, 4875 VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR = 1, 4876 VK_TESSELLATION_DOMAIN_ORIGIN_BEGIN_RANGE_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR, 4877 VK_TESSELLATION_DOMAIN_ORIGIN_END_RANGE_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR, 4878 VK_TESSELLATION_DOMAIN_ORIGIN_RANGE_SIZE_KHR = (VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR - VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR + 1), 4879 VK_TESSELLATION_DOMAIN_ORIGIN_MAX_ENUM_KHR = 0x7FFFFFFF 4880 } VkTessellationDomainOriginKHR; 4881 4882 typedef struct VkPhysicalDevicePointClippingPropertiesKHR { 4883 VkStructureType sType; 4884 void* pNext; 4885 VkPointClippingBehaviorKHR pointClippingBehavior; 4886 } VkPhysicalDevicePointClippingPropertiesKHR; 4887 4888 typedef struct VkInputAttachmentAspectReferenceKHR { 4889 uint32_t subpass; 4890 uint32_t inputAttachmentIndex; 4891 VkImageAspectFlags aspectMask; 4892 } VkInputAttachmentAspectReferenceKHR; 4893 4894 typedef struct VkRenderPassInputAttachmentAspectCreateInfoKHR { 4895 VkStructureType sType; 4896 const void* pNext; 4897 uint32_t aspectReferenceCount; 4898 const VkInputAttachmentAspectReferenceKHR* pAspectReferences; 4899 } VkRenderPassInputAttachmentAspectCreateInfoKHR; 4900 4901 typedef struct VkImageViewUsageCreateInfoKHR { 4902 VkStructureType sType; 4903 const void* pNext; 4904 VkImageUsageFlags usage; 4905 } VkImageViewUsageCreateInfoKHR; 4906 4907 typedef struct VkPipelineTessellationDomainOriginStateCreateInfoKHR { 4908 VkStructureType sType; 4909 const void* pNext; 4910 VkTessellationDomainOriginKHR domainOrigin; 4911 } VkPipelineTessellationDomainOriginStateCreateInfoKHR; 4912 4913 4914 4915 #define VK_KHR_get_surface_capabilities2 1 4916 #define VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION 1 4917 #define VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME "VK_KHR_get_surface_capabilities2" 4918 4919 typedef struct VkPhysicalDeviceSurfaceInfo2KHR { 4920 VkStructureType sType; 4921 const void* pNext; 4922 VkSurfaceKHR surface; 4923 } VkPhysicalDeviceSurfaceInfo2KHR; 4924 4925 typedef struct VkSurfaceCapabilities2KHR { 4926 VkStructureType sType; 4927 void* pNext; 4928 VkSurfaceCapabilitiesKHR surfaceCapabilities; 4929 } VkSurfaceCapabilities2KHR; 4930 4931 typedef struct VkSurfaceFormat2KHR { 4932 VkStructureType sType; 4933 void* pNext; 4934 VkSurfaceFormatKHR surfaceFormat; 4935 } VkSurfaceFormat2KHR; 4936 4937 4938 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities); 4939 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormats2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats); 4940 4941 #ifndef VK_NO_PROTOTYPES 4942 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2KHR( 4943 VkPhysicalDevice physicalDevice, 4944 const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, 4945 VkSurfaceCapabilities2KHR* pSurfaceCapabilities); 4946 4947 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormats2KHR( 4948 VkPhysicalDevice physicalDevice, 4949 const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, 4950 uint32_t* pSurfaceFormatCount, 4951 VkSurfaceFormat2KHR* pSurfaceFormats); 4952 #endif 4953 4954 #define VK_KHR_variable_pointers 1 4955 #define VK_KHR_VARIABLE_POINTERS_SPEC_VERSION 1 4956 #define VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME "VK_KHR_variable_pointers" 4957 4958 typedef struct VkPhysicalDeviceVariablePointerFeaturesKHR { 4959 VkStructureType sType; 4960 void* pNext; 4961 VkBool32 variablePointersStorageBuffer; 4962 VkBool32 variablePointers; 4963 } VkPhysicalDeviceVariablePointerFeaturesKHR; 4964 4965 4966 4967 #define VK_KHR_dedicated_allocation 1 4968 #define VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION 3 4969 #define VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_KHR_dedicated_allocation" 4970 4971 typedef struct VkMemoryDedicatedRequirementsKHR { 4972 VkStructureType sType; 4973 void* pNext; 4974 VkBool32 prefersDedicatedAllocation; 4975 VkBool32 requiresDedicatedAllocation; 4976 } VkMemoryDedicatedRequirementsKHR; 4977 4978 typedef struct VkMemoryDedicatedAllocateInfoKHR { 4979 VkStructureType sType; 4980 const void* pNext; 4981 VkImage image; 4982 VkBuffer buffer; 4983 } VkMemoryDedicatedAllocateInfoKHR; 4984 4985 4986 4987 #define VK_KHR_storage_buffer_storage_class 1 4988 #define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION 1 4989 #define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME "VK_KHR_storage_buffer_storage_class" 4990 4991 4992 #define VK_KHR_relaxed_block_layout 1 4993 #define VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION 1 4994 #define VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME "VK_KHR_relaxed_block_layout" 4995 4996 4997 #define VK_KHR_get_memory_requirements2 1 4998 #define VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION 1 4999 #define VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME "VK_KHR_get_memory_requirements2" 5000 5001 typedef struct VkBufferMemoryRequirementsInfo2KHR { 5002 VkStructureType sType; 5003 const void* pNext; 5004 VkBuffer buffer; 5005 } VkBufferMemoryRequirementsInfo2KHR; 5006 5007 typedef struct VkImageMemoryRequirementsInfo2KHR { 5008 VkStructureType sType; 5009 const void* pNext; 5010 VkImage image; 5011 } VkImageMemoryRequirementsInfo2KHR; 5012 5013 typedef struct VkImageSparseMemoryRequirementsInfo2KHR { 5014 VkStructureType sType; 5015 const void* pNext; 5016 VkImage image; 5017 } VkImageSparseMemoryRequirementsInfo2KHR; 5018 5019 typedef struct VkMemoryRequirements2KHR { 5020 VkStructureType sType; 5021 void* pNext; 5022 VkMemoryRequirements memoryRequirements; 5023 } VkMemoryRequirements2KHR; 5024 5025 typedef struct VkSparseImageMemoryRequirements2KHR { 5026 VkStructureType sType; 5027 void* pNext; 5028 VkSparseImageMemoryRequirements memoryRequirements; 5029 } VkSparseImageMemoryRequirements2KHR; 5030 5031 5032 typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2KHR)(VkDevice device, const VkImageMemoryRequirementsInfo2KHR* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements); 5033 typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2KHR)(VkDevice device, const VkBufferMemoryRequirementsInfo2KHR* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements); 5034 typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements2KHR)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2KHR* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2KHR* pSparseMemoryRequirements); 5035 5036 #ifndef VK_NO_PROTOTYPES 5037 VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2KHR( 5038 VkDevice device, 5039 const VkImageMemoryRequirementsInfo2KHR* pInfo, 5040 VkMemoryRequirements2KHR* pMemoryRequirements); 5041 5042 VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2KHR( 5043 VkDevice device, 5044 const VkBufferMemoryRequirementsInfo2KHR* pInfo, 5045 VkMemoryRequirements2KHR* pMemoryRequirements); 5046 5047 VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2KHR( 5048 VkDevice device, 5049 const VkImageSparseMemoryRequirementsInfo2KHR* pInfo, 5050 uint32_t* pSparseMemoryRequirementCount, 5051 VkSparseImageMemoryRequirements2KHR* pSparseMemoryRequirements); 5052 #endif 5053 5054 #define VK_KHR_image_format_list 1 5055 #define VK_KHR_IMAGE_FORMAT_LIST_SPEC_VERSION 1 5056 #define VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME "VK_KHR_image_format_list" 5057 5058 typedef struct VkImageFormatListCreateInfoKHR { 5059 VkStructureType sType; 5060 const void* pNext; 5061 uint32_t viewFormatCount; 5062 const VkFormat* pViewFormats; 5063 } VkImageFormatListCreateInfoKHR; 5064 5065 5066 5067 #define VK_KHR_sampler_ycbcr_conversion 1 5068 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSamplerYcbcrConversionKHR) 5069 5070 #define VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION 1 5071 #define VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME "VK_KHR_sampler_ycbcr_conversion" 5072 5073 5074 typedef enum VkSamplerYcbcrModelConversionKHR { 5075 VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR = 0, 5076 VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR = 1, 5077 VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR = 2, 5078 VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR = 3, 5079 VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR = 4, 5080 VK_SAMPLER_YCBCR_MODEL_CONVERSION_BEGIN_RANGE_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR, 5081 VK_SAMPLER_YCBCR_MODEL_CONVERSION_END_RANGE_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR, 5082 VK_SAMPLER_YCBCR_MODEL_CONVERSION_RANGE_SIZE_KHR = (VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR - VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR + 1), 5083 VK_SAMPLER_YCBCR_MODEL_CONVERSION_MAX_ENUM_KHR = 0x7FFFFFFF 5084 } VkSamplerYcbcrModelConversionKHR; 5085 5086 typedef enum VkSamplerYcbcrRangeKHR { 5087 VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR = 0, 5088 VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR = 1, 5089 VK_SAMPLER_YCBCR_RANGE_BEGIN_RANGE_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR, 5090 VK_SAMPLER_YCBCR_RANGE_END_RANGE_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR, 5091 VK_SAMPLER_YCBCR_RANGE_RANGE_SIZE_KHR = (VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR - VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR + 1), 5092 VK_SAMPLER_YCBCR_RANGE_MAX_ENUM_KHR = 0x7FFFFFFF 5093 } VkSamplerYcbcrRangeKHR; 5094 5095 typedef enum VkChromaLocationKHR { 5096 VK_CHROMA_LOCATION_COSITED_EVEN_KHR = 0, 5097 VK_CHROMA_LOCATION_MIDPOINT_KHR = 1, 5098 VK_CHROMA_LOCATION_BEGIN_RANGE_KHR = VK_CHROMA_LOCATION_COSITED_EVEN_KHR, 5099 VK_CHROMA_LOCATION_END_RANGE_KHR = VK_CHROMA_LOCATION_MIDPOINT_KHR, 5100 VK_CHROMA_LOCATION_RANGE_SIZE_KHR = (VK_CHROMA_LOCATION_MIDPOINT_KHR - VK_CHROMA_LOCATION_COSITED_EVEN_KHR + 1), 5101 VK_CHROMA_LOCATION_MAX_ENUM_KHR = 0x7FFFFFFF 5102 } VkChromaLocationKHR; 5103 5104 typedef struct VkSamplerYcbcrConversionCreateInfoKHR { 5105 VkStructureType sType; 5106 const void* pNext; 5107 VkFormat format; 5108 VkSamplerYcbcrModelConversionKHR ycbcrModel; 5109 VkSamplerYcbcrRangeKHR ycbcrRange; 5110 VkComponentMapping components; 5111 VkChromaLocationKHR xChromaOffset; 5112 VkChromaLocationKHR yChromaOffset; 5113 VkFilter chromaFilter; 5114 VkBool32 forceExplicitReconstruction; 5115 } VkSamplerYcbcrConversionCreateInfoKHR; 5116 5117 typedef struct VkSamplerYcbcrConversionInfoKHR { 5118 VkStructureType sType; 5119 const void* pNext; 5120 VkSamplerYcbcrConversionKHR conversion; 5121 } VkSamplerYcbcrConversionInfoKHR; 5122 5123 typedef struct VkBindImagePlaneMemoryInfoKHR { 5124 VkStructureType sType; 5125 const void* pNext; 5126 VkImageAspectFlagBits planeAspect; 5127 } VkBindImagePlaneMemoryInfoKHR; 5128 5129 typedef struct VkImagePlaneMemoryRequirementsInfoKHR { 5130 VkStructureType sType; 5131 const void* pNext; 5132 VkImageAspectFlagBits planeAspect; 5133 } VkImagePlaneMemoryRequirementsInfoKHR; 5134 5135 typedef struct VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR { 5136 VkStructureType sType; 5137 void* pNext; 5138 VkBool32 samplerYcbcrConversion; 5139 } VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR; 5140 5141 typedef struct VkSamplerYcbcrConversionImageFormatPropertiesKHR { 5142 VkStructureType sType; 5143 void* pNext; 5144 uint32_t combinedImageSamplerDescriptorCount; 5145 } VkSamplerYcbcrConversionImageFormatPropertiesKHR; 5146 5147 5148 typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversionKHR)(VkDevice device, const VkSamplerYcbcrConversionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversionKHR* pYcbcrConversion); 5149 typedef void (VKAPI_PTR *PFN_vkDestroySamplerYcbcrConversionKHR)(VkDevice device, VkSamplerYcbcrConversionKHR ycbcrConversion, const VkAllocationCallbacks* pAllocator); 5150 5151 #ifndef VK_NO_PROTOTYPES 5152 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversionKHR( 5153 VkDevice device, 5154 const VkSamplerYcbcrConversionCreateInfoKHR* pCreateInfo, 5155 const VkAllocationCallbacks* pAllocator, 5156 VkSamplerYcbcrConversionKHR* pYcbcrConversion); 5157 5158 VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversionKHR( 5159 VkDevice device, 5160 VkSamplerYcbcrConversionKHR ycbcrConversion, 5161 const VkAllocationCallbacks* pAllocator); 5162 #endif 5163 5164 #define VK_KHR_bind_memory2 1 5165 #define VK_KHR_BIND_MEMORY_2_SPEC_VERSION 1 5166 #define VK_KHR_BIND_MEMORY_2_EXTENSION_NAME "VK_KHR_bind_memory2" 5167 5168 typedef struct VkBindBufferMemoryInfoKHR { 5169 VkStructureType sType; 5170 const void* pNext; 5171 VkBuffer buffer; 5172 VkDeviceMemory memory; 5173 VkDeviceSize memoryOffset; 5174 } VkBindBufferMemoryInfoKHR; 5175 5176 typedef struct VkBindImageMemoryInfoKHR { 5177 VkStructureType sType; 5178 const void* pNext; 5179 VkImage image; 5180 VkDeviceMemory memory; 5181 VkDeviceSize memoryOffset; 5182 } VkBindImageMemoryInfoKHR; 5183 5184 5185 typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfoKHR* pBindInfos); 5186 typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfoKHR* pBindInfos); 5187 5188 #ifndef VK_NO_PROTOTYPES 5189 VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2KHR( 5190 VkDevice device, 5191 uint32_t bindInfoCount, 5192 const VkBindBufferMemoryInfoKHR* pBindInfos); 5193 5194 VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2KHR( 5195 VkDevice device, 5196 uint32_t bindInfoCount, 5197 const VkBindImageMemoryInfoKHR* pBindInfos); 5198 #endif 5199 5200 #define VK_EXT_debug_report 1 5201 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT) 5202 5203 #define VK_EXT_DEBUG_REPORT_SPEC_VERSION 9 5204 #define VK_EXT_DEBUG_REPORT_EXTENSION_NAME "VK_EXT_debug_report" 5205 #define VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT 5206 #define VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT 5207 5208 5209 typedef enum VkDebugReportObjectTypeEXT { 5210 VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0, 5211 VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1, 5212 VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2, 5213 VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3, 5214 VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4, 5215 VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5, 5216 VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6, 5217 VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7, 5218 VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8, 5219 VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9, 5220 VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10, 5221 VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11, 5222 VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12, 5223 VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13, 5224 VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14, 5225 VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15, 5226 VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16, 5227 VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17, 5228 VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18, 5229 VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19, 5230 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20, 5231 VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21, 5232 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22, 5233 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23, 5234 VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24, 5235 VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25, 5236 VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26, 5237 VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27, 5238 VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT = 28, 5239 VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT = 29, 5240 VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT = 30, 5241 VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT = 31, 5242 VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT = 32, 5243 VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT = 33, 5244 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT = 1000085000, 5245 VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT = 1000156000, 5246 VK_DEBUG_REPORT_OBJECT_TYPE_BEGIN_RANGE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 5247 VK_DEBUG_REPORT_OBJECT_TYPE_END_RANGE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT, 5248 VK_DEBUG_REPORT_OBJECT_TYPE_RANGE_SIZE_EXT = (VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT - VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT + 1), 5249 VK_DEBUG_REPORT_OBJECT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF 5250 } VkDebugReportObjectTypeEXT; 5251 5252 5253 typedef enum VkDebugReportFlagBitsEXT { 5254 VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 0x00000001, 5255 VK_DEBUG_REPORT_WARNING_BIT_EXT = 0x00000002, 5256 VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 0x00000004, 5257 VK_DEBUG_REPORT_ERROR_BIT_EXT = 0x00000008, 5258 VK_DEBUG_REPORT_DEBUG_BIT_EXT = 0x00000010, 5259 VK_DEBUG_REPORT_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF 5260 } VkDebugReportFlagBitsEXT; 5261 typedef VkFlags VkDebugReportFlagsEXT; 5262 5263 typedef VkBool32 (VKAPI_PTR *PFN_vkDebugReportCallbackEXT)( 5264 VkDebugReportFlagsEXT flags, 5265 VkDebugReportObjectTypeEXT objectType, 5266 uint64_t object, 5267 size_t location, 5268 int32_t messageCode, 5269 const char* pLayerPrefix, 5270 const char* pMessage, 5271 void* pUserData); 5272 5273 typedef struct VkDebugReportCallbackCreateInfoEXT { 5274 VkStructureType sType; 5275 const void* pNext; 5276 VkDebugReportFlagsEXT flags; 5277 PFN_vkDebugReportCallbackEXT pfnCallback; 5278 void* pUserData; 5279 } VkDebugReportCallbackCreateInfoEXT; 5280 5281 5282 typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugReportCallbackEXT)(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback); 5283 typedef void (VKAPI_PTR *PFN_vkDestroyDebugReportCallbackEXT)(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator); 5284 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); 5285 5286 #ifndef VK_NO_PROTOTYPES 5287 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT( 5288 VkInstance instance, 5289 const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, 5290 const VkAllocationCallbacks* pAllocator, 5291 VkDebugReportCallbackEXT* pCallback); 5292 5293 VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT( 5294 VkInstance instance, 5295 VkDebugReportCallbackEXT callback, 5296 const VkAllocationCallbacks* pAllocator); 5297 5298 VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT( 5299 VkInstance instance, 5300 VkDebugReportFlagsEXT flags, 5301 VkDebugReportObjectTypeEXT objectType, 5302 uint64_t object, 5303 size_t location, 5304 int32_t messageCode, 5305 const char* pLayerPrefix, 5306 const char* pMessage); 5307 #endif 5308 5309 #define VK_NV_glsl_shader 1 5310 #define VK_NV_GLSL_SHADER_SPEC_VERSION 1 5311 #define VK_NV_GLSL_SHADER_EXTENSION_NAME "VK_NV_glsl_shader" 5312 5313 5314 #define VK_EXT_depth_range_unrestricted 1 5315 #define VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION 1 5316 #define VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME "VK_EXT_depth_range_unrestricted" 5317 5318 5319 #define VK_IMG_filter_cubic 1 5320 #define VK_IMG_FILTER_CUBIC_SPEC_VERSION 1 5321 #define VK_IMG_FILTER_CUBIC_EXTENSION_NAME "VK_IMG_filter_cubic" 5322 5323 5324 #define VK_AMD_rasterization_order 1 5325 #define VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION 1 5326 #define VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME "VK_AMD_rasterization_order" 5327 5328 5329 typedef enum VkRasterizationOrderAMD { 5330 VK_RASTERIZATION_ORDER_STRICT_AMD = 0, 5331 VK_RASTERIZATION_ORDER_RELAXED_AMD = 1, 5332 VK_RASTERIZATION_ORDER_BEGIN_RANGE_AMD = VK_RASTERIZATION_ORDER_STRICT_AMD, 5333 VK_RASTERIZATION_ORDER_END_RANGE_AMD = VK_RASTERIZATION_ORDER_RELAXED_AMD, 5334 VK_RASTERIZATION_ORDER_RANGE_SIZE_AMD = (VK_RASTERIZATION_ORDER_RELAXED_AMD - VK_RASTERIZATION_ORDER_STRICT_AMD + 1), 5335 VK_RASTERIZATION_ORDER_MAX_ENUM_AMD = 0x7FFFFFFF 5336 } VkRasterizationOrderAMD; 5337 5338 typedef struct VkPipelineRasterizationStateRasterizationOrderAMD { 5339 VkStructureType sType; 5340 const void* pNext; 5341 VkRasterizationOrderAMD rasterizationOrder; 5342 } VkPipelineRasterizationStateRasterizationOrderAMD; 5343 5344 5345 5346 #define VK_AMD_shader_trinary_minmax 1 5347 #define VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION 1 5348 #define VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME "VK_AMD_shader_trinary_minmax" 5349 5350 5351 #define VK_AMD_shader_explicit_vertex_parameter 1 5352 #define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION 1 5353 #define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME "VK_AMD_shader_explicit_vertex_parameter" 5354 5355 5356 #define VK_EXT_debug_marker 1 5357 #define VK_EXT_DEBUG_MARKER_SPEC_VERSION 4 5358 #define VK_EXT_DEBUG_MARKER_EXTENSION_NAME "VK_EXT_debug_marker" 5359 5360 typedef struct VkDebugMarkerObjectNameInfoEXT { 5361 VkStructureType sType; 5362 const void* pNext; 5363 VkDebugReportObjectTypeEXT objectType; 5364 uint64_t object; 5365 const char* pObjectName; 5366 } VkDebugMarkerObjectNameInfoEXT; 5367 5368 typedef struct VkDebugMarkerObjectTagInfoEXT { 5369 VkStructureType sType; 5370 const void* pNext; 5371 VkDebugReportObjectTypeEXT objectType; 5372 uint64_t object; 5373 uint64_t tagName; 5374 size_t tagSize; 5375 const void* pTag; 5376 } VkDebugMarkerObjectTagInfoEXT; 5377 5378 typedef struct VkDebugMarkerMarkerInfoEXT { 5379 VkStructureType sType; 5380 const void* pNext; 5381 const char* pMarkerName; 5382 float color[4]; 5383 } VkDebugMarkerMarkerInfoEXT; 5384 5385 5386 typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectTagEXT)(VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo); 5387 typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectNameEXT)(VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo); 5388 typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerBeginEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); 5389 typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerEndEXT)(VkCommandBuffer commandBuffer); 5390 typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerInsertEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); 5391 5392 #ifndef VK_NO_PROTOTYPES 5393 VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectTagEXT( 5394 VkDevice device, 5395 const VkDebugMarkerObjectTagInfoEXT* pTagInfo); 5396 5397 VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectNameEXT( 5398 VkDevice device, 5399 const VkDebugMarkerObjectNameInfoEXT* pNameInfo); 5400 5401 VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerBeginEXT( 5402 VkCommandBuffer commandBuffer, 5403 const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); 5404 5405 VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerEndEXT( 5406 VkCommandBuffer commandBuffer); 5407 5408 VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerInsertEXT( 5409 VkCommandBuffer commandBuffer, 5410 const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); 5411 #endif 5412 5413 #define VK_AMD_gcn_shader 1 5414 #define VK_AMD_GCN_SHADER_SPEC_VERSION 1 5415 #define VK_AMD_GCN_SHADER_EXTENSION_NAME "VK_AMD_gcn_shader" 5416 5417 5418 #define VK_NV_dedicated_allocation 1 5419 #define VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION 1 5420 #define VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_NV_dedicated_allocation" 5421 5422 typedef struct VkDedicatedAllocationImageCreateInfoNV { 5423 VkStructureType sType; 5424 const void* pNext; 5425 VkBool32 dedicatedAllocation; 5426 } VkDedicatedAllocationImageCreateInfoNV; 5427 5428 typedef struct VkDedicatedAllocationBufferCreateInfoNV { 5429 VkStructureType sType; 5430 const void* pNext; 5431 VkBool32 dedicatedAllocation; 5432 } VkDedicatedAllocationBufferCreateInfoNV; 5433 5434 typedef struct VkDedicatedAllocationMemoryAllocateInfoNV { 5435 VkStructureType sType; 5436 const void* pNext; 5437 VkImage image; 5438 VkBuffer buffer; 5439 } VkDedicatedAllocationMemoryAllocateInfoNV; 5440 5441 5442 5443 #define VK_AMD_draw_indirect_count 1 5444 #define VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION 1 5445 #define VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_AMD_draw_indirect_count" 5446 5447 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); 5448 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); 5449 5450 #ifndef VK_NO_PROTOTYPES 5451 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountAMD( 5452 VkCommandBuffer commandBuffer, 5453 VkBuffer buffer, 5454 VkDeviceSize offset, 5455 VkBuffer countBuffer, 5456 VkDeviceSize countBufferOffset, 5457 uint32_t maxDrawCount, 5458 uint32_t stride); 5459 5460 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountAMD( 5461 VkCommandBuffer commandBuffer, 5462 VkBuffer buffer, 5463 VkDeviceSize offset, 5464 VkBuffer countBuffer, 5465 VkDeviceSize countBufferOffset, 5466 uint32_t maxDrawCount, 5467 uint32_t stride); 5468 #endif 5469 5470 #define VK_AMD_negative_viewport_height 1 5471 #define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION 1 5472 #define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME "VK_AMD_negative_viewport_height" 5473 5474 5475 #define VK_AMD_gpu_shader_half_float 1 5476 #define VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION 1 5477 #define VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME "VK_AMD_gpu_shader_half_float" 5478 5479 5480 #define VK_AMD_shader_ballot 1 5481 #define VK_AMD_SHADER_BALLOT_SPEC_VERSION 1 5482 #define VK_AMD_SHADER_BALLOT_EXTENSION_NAME "VK_AMD_shader_ballot" 5483 5484 5485 #define VK_AMD_texture_gather_bias_lod 1 5486 #define VK_AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION 1 5487 #define VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME "VK_AMD_texture_gather_bias_lod" 5488 5489 typedef struct VkTextureLODGatherFormatPropertiesAMD { 5490 VkStructureType sType; 5491 void* pNext; 5492 VkBool32 supportsTextureGatherLODBiasAMD; 5493 } VkTextureLODGatherFormatPropertiesAMD; 5494 5495 5496 5497 #define VK_AMD_shader_info 1 5498 #define VK_AMD_SHADER_INFO_SPEC_VERSION 1 5499 #define VK_AMD_SHADER_INFO_EXTENSION_NAME "VK_AMD_shader_info" 5500 5501 5502 typedef enum VkShaderInfoTypeAMD { 5503 VK_SHADER_INFO_TYPE_STATISTICS_AMD = 0, 5504 VK_SHADER_INFO_TYPE_BINARY_AMD = 1, 5505 VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD = 2, 5506 VK_SHADER_INFO_TYPE_BEGIN_RANGE_AMD = VK_SHADER_INFO_TYPE_STATISTICS_AMD, 5507 VK_SHADER_INFO_TYPE_END_RANGE_AMD = VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD, 5508 VK_SHADER_INFO_TYPE_RANGE_SIZE_AMD = (VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD - VK_SHADER_INFO_TYPE_STATISTICS_AMD + 1), 5509 VK_SHADER_INFO_TYPE_MAX_ENUM_AMD = 0x7FFFFFFF 5510 } VkShaderInfoTypeAMD; 5511 5512 typedef struct VkShaderResourceUsageAMD { 5513 uint32_t numUsedVgprs; 5514 uint32_t numUsedSgprs; 5515 uint32_t ldsSizePerLocalWorkGroup; 5516 size_t ldsUsageSizeInBytes; 5517 size_t scratchMemUsageInBytes; 5518 } VkShaderResourceUsageAMD; 5519 5520 typedef struct VkShaderStatisticsInfoAMD { 5521 VkShaderStageFlags shaderStageMask; 5522 VkShaderResourceUsageAMD resourceUsage; 5523 uint32_t numPhysicalVgprs; 5524 uint32_t numPhysicalSgprs; 5525 uint32_t numAvailableVgprs; 5526 uint32_t numAvailableSgprs; 5527 uint32_t computeWorkGroupSize[3]; 5528 } VkShaderStatisticsInfoAMD; 5529 5530 5531 typedef VkResult (VKAPI_PTR *PFN_vkGetShaderInfoAMD)(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo); 5532 5533 #ifndef VK_NO_PROTOTYPES 5534 VKAPI_ATTR VkResult VKAPI_CALL vkGetShaderInfoAMD( 5535 VkDevice device, 5536 VkPipeline pipeline, 5537 VkShaderStageFlagBits shaderStage, 5538 VkShaderInfoTypeAMD infoType, 5539 size_t* pInfoSize, 5540 void* pInfo); 5541 #endif 5542 5543 #define VK_AMD_shader_image_load_store_lod 1 5544 #define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION 1 5545 #define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME "VK_AMD_shader_image_load_store_lod" 5546 5547 5548 #define VK_KHX_multiview 1 5549 #define VK_KHX_MULTIVIEW_SPEC_VERSION 1 5550 #define VK_KHX_MULTIVIEW_EXTENSION_NAME "VK_KHX_multiview" 5551 5552 typedef struct VkRenderPassMultiviewCreateInfoKHX { 5553 VkStructureType sType; 5554 const void* pNext; 5555 uint32_t subpassCount; 5556 const uint32_t* pViewMasks; 5557 uint32_t dependencyCount; 5558 const int32_t* pViewOffsets; 5559 uint32_t correlationMaskCount; 5560 const uint32_t* pCorrelationMasks; 5561 } VkRenderPassMultiviewCreateInfoKHX; 5562 5563 typedef struct VkPhysicalDeviceMultiviewFeaturesKHX { 5564 VkStructureType sType; 5565 void* pNext; 5566 VkBool32 multiview; 5567 VkBool32 multiviewGeometryShader; 5568 VkBool32 multiviewTessellationShader; 5569 } VkPhysicalDeviceMultiviewFeaturesKHX; 5570 5571 typedef struct VkPhysicalDeviceMultiviewPropertiesKHX { 5572 VkStructureType sType; 5573 void* pNext; 5574 uint32_t maxMultiviewViewCount; 5575 uint32_t maxMultiviewInstanceIndex; 5576 } VkPhysicalDeviceMultiviewPropertiesKHX; 5577 5578 5579 5580 #define VK_IMG_format_pvrtc 1 5581 #define VK_IMG_FORMAT_PVRTC_SPEC_VERSION 1 5582 #define VK_IMG_FORMAT_PVRTC_EXTENSION_NAME "VK_IMG_format_pvrtc" 5583 5584 5585 #define VK_NV_external_memory_capabilities 1 5586 #define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1 5587 #define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_NV_external_memory_capabilities" 5588 5589 5590 typedef enum VkExternalMemoryHandleTypeFlagBitsNV { 5591 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = 0x00000001, 5592 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = 0x00000002, 5593 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = 0x00000004, 5594 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = 0x00000008, 5595 VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF 5596 } VkExternalMemoryHandleTypeFlagBitsNV; 5597 typedef VkFlags VkExternalMemoryHandleTypeFlagsNV; 5598 5599 typedef enum VkExternalMemoryFeatureFlagBitsNV { 5600 VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = 0x00000001, 5601 VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = 0x00000002, 5602 VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = 0x00000004, 5603 VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF 5604 } VkExternalMemoryFeatureFlagBitsNV; 5605 typedef VkFlags VkExternalMemoryFeatureFlagsNV; 5606 5607 typedef struct VkExternalImageFormatPropertiesNV { 5608 VkImageFormatProperties imageFormatProperties; 5609 VkExternalMemoryFeatureFlagsNV externalMemoryFeatures; 5610 VkExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes; 5611 VkExternalMemoryHandleTypeFlagsNV compatibleHandleTypes; 5612 } VkExternalImageFormatPropertiesNV; 5613 5614 5615 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties); 5616 5617 #ifndef VK_NO_PROTOTYPES 5618 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceExternalImageFormatPropertiesNV( 5619 VkPhysicalDevice physicalDevice, 5620 VkFormat format, 5621 VkImageType type, 5622 VkImageTiling tiling, 5623 VkImageUsageFlags usage, 5624 VkImageCreateFlags flags, 5625 VkExternalMemoryHandleTypeFlagsNV externalHandleType, 5626 VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties); 5627 #endif 5628 5629 #define VK_NV_external_memory 1 5630 #define VK_NV_EXTERNAL_MEMORY_SPEC_VERSION 1 5631 #define VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME "VK_NV_external_memory" 5632 5633 typedef struct VkExternalMemoryImageCreateInfoNV { 5634 VkStructureType sType; 5635 const void* pNext; 5636 VkExternalMemoryHandleTypeFlagsNV handleTypes; 5637 } VkExternalMemoryImageCreateInfoNV; 5638 5639 typedef struct VkExportMemoryAllocateInfoNV { 5640 VkStructureType sType; 5641 const void* pNext; 5642 VkExternalMemoryHandleTypeFlagsNV handleTypes; 5643 } VkExportMemoryAllocateInfoNV; 5644 5645 5646 5647 #ifdef VK_USE_PLATFORM_WIN32_KHR 5648 #define VK_NV_external_memory_win32 1 5649 #define VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1 5650 #define VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_NV_external_memory_win32" 5651 5652 typedef struct VkImportMemoryWin32HandleInfoNV { 5653 VkStructureType sType; 5654 const void* pNext; 5655 VkExternalMemoryHandleTypeFlagsNV handleType; 5656 HANDLE handle; 5657 } VkImportMemoryWin32HandleInfoNV; 5658 5659 typedef struct VkExportMemoryWin32HandleInfoNV { 5660 VkStructureType sType; 5661 const void* pNext; 5662 const SECURITY_ATTRIBUTES* pAttributes; 5663 DWORD dwAccess; 5664 } VkExportMemoryWin32HandleInfoNV; 5665 5666 5667 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleNV)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle); 5668 5669 #ifndef VK_NO_PROTOTYPES 5670 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV( 5671 VkDevice device, 5672 VkDeviceMemory memory, 5673 VkExternalMemoryHandleTypeFlagsNV handleType, 5674 HANDLE* pHandle); 5675 #endif 5676 #endif /* VK_USE_PLATFORM_WIN32_KHR */ 5677 5678 #ifdef VK_USE_PLATFORM_WIN32_KHR 5679 #define VK_NV_win32_keyed_mutex 1 5680 #define VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION 1 5681 #define VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_NV_win32_keyed_mutex" 5682 5683 typedef struct VkWin32KeyedMutexAcquireReleaseInfoNV { 5684 VkStructureType sType; 5685 const void* pNext; 5686 uint32_t acquireCount; 5687 const VkDeviceMemory* pAcquireSyncs; 5688 const uint64_t* pAcquireKeys; 5689 const uint32_t* pAcquireTimeoutMilliseconds; 5690 uint32_t releaseCount; 5691 const VkDeviceMemory* pReleaseSyncs; 5692 const uint64_t* pReleaseKeys; 5693 } VkWin32KeyedMutexAcquireReleaseInfoNV; 5694 5695 5696 #endif /* VK_USE_PLATFORM_WIN32_KHR */ 5697 5698 #define VK_KHX_device_group 1 5699 #define VK_KHX_DEVICE_GROUP_SPEC_VERSION 2 5700 #define VK_KHX_DEVICE_GROUP_EXTENSION_NAME "VK_KHX_device_group" 5701 #define VK_MAX_DEVICE_GROUP_SIZE_KHX 32 5702 5703 5704 typedef enum VkPeerMemoryFeatureFlagBitsKHX { 5705 VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHX = 0x00000001, 5706 VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHX = 0x00000002, 5707 VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHX = 0x00000004, 5708 VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHX = 0x00000008, 5709 VK_PEER_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_KHX = 0x7FFFFFFF 5710 } VkPeerMemoryFeatureFlagBitsKHX; 5711 typedef VkFlags VkPeerMemoryFeatureFlagsKHX; 5712 5713 typedef enum VkMemoryAllocateFlagBitsKHX { 5714 VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHX = 0x00000001, 5715 VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM_KHX = 0x7FFFFFFF 5716 } VkMemoryAllocateFlagBitsKHX; 5717 typedef VkFlags VkMemoryAllocateFlagsKHX; 5718 5719 typedef enum VkDeviceGroupPresentModeFlagBitsKHX { 5720 VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHX = 0x00000001, 5721 VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHX = 0x00000002, 5722 VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHX = 0x00000004, 5723 VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHX = 0x00000008, 5724 VK_DEVICE_GROUP_PRESENT_MODE_FLAG_BITS_MAX_ENUM_KHX = 0x7FFFFFFF 5725 } VkDeviceGroupPresentModeFlagBitsKHX; 5726 typedef VkFlags VkDeviceGroupPresentModeFlagsKHX; 5727 5728 typedef struct VkMemoryAllocateFlagsInfoKHX { 5729 VkStructureType sType; 5730 const void* pNext; 5731 VkMemoryAllocateFlagsKHX flags; 5732 uint32_t deviceMask; 5733 } VkMemoryAllocateFlagsInfoKHX; 5734 5735 typedef struct VkDeviceGroupRenderPassBeginInfoKHX { 5736 VkStructureType sType; 5737 const void* pNext; 5738 uint32_t deviceMask; 5739 uint32_t deviceRenderAreaCount; 5740 const VkRect2D* pDeviceRenderAreas; 5741 } VkDeviceGroupRenderPassBeginInfoKHX; 5742 5743 typedef struct VkDeviceGroupCommandBufferBeginInfoKHX { 5744 VkStructureType sType; 5745 const void* pNext; 5746 uint32_t deviceMask; 5747 } VkDeviceGroupCommandBufferBeginInfoKHX; 5748 5749 typedef struct VkDeviceGroupSubmitInfoKHX { 5750 VkStructureType sType; 5751 const void* pNext; 5752 uint32_t waitSemaphoreCount; 5753 const uint32_t* pWaitSemaphoreDeviceIndices; 5754 uint32_t commandBufferCount; 5755 const uint32_t* pCommandBufferDeviceMasks; 5756 uint32_t signalSemaphoreCount; 5757 const uint32_t* pSignalSemaphoreDeviceIndices; 5758 } VkDeviceGroupSubmitInfoKHX; 5759 5760 typedef struct VkDeviceGroupBindSparseInfoKHX { 5761 VkStructureType sType; 5762 const void* pNext; 5763 uint32_t resourceDeviceIndex; 5764 uint32_t memoryDeviceIndex; 5765 } VkDeviceGroupBindSparseInfoKHX; 5766 5767 typedef struct VkBindBufferMemoryDeviceGroupInfoKHX { 5768 VkStructureType sType; 5769 const void* pNext; 5770 uint32_t deviceIndexCount; 5771 const uint32_t* pDeviceIndices; 5772 } VkBindBufferMemoryDeviceGroupInfoKHX; 5773 5774 typedef struct VkBindImageMemoryDeviceGroupInfoKHX { 5775 VkStructureType sType; 5776 const void* pNext; 5777 uint32_t deviceIndexCount; 5778 const uint32_t* pDeviceIndices; 5779 uint32_t SFRRectCount; 5780 const VkRect2D* pSFRRects; 5781 } VkBindImageMemoryDeviceGroupInfoKHX; 5782 5783 typedef struct VkDeviceGroupPresentCapabilitiesKHX { 5784 VkStructureType sType; 5785 const void* pNext; 5786 uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE_KHX]; 5787 VkDeviceGroupPresentModeFlagsKHX modes; 5788 } VkDeviceGroupPresentCapabilitiesKHX; 5789 5790 typedef struct VkImageSwapchainCreateInfoKHX { 5791 VkStructureType sType; 5792 const void* pNext; 5793 VkSwapchainKHR swapchain; 5794 } VkImageSwapchainCreateInfoKHX; 5795 5796 typedef struct VkBindImageMemorySwapchainInfoKHX { 5797 VkStructureType sType; 5798 const void* pNext; 5799 VkSwapchainKHR swapchain; 5800 uint32_t imageIndex; 5801 } VkBindImageMemorySwapchainInfoKHX; 5802 5803 typedef struct VkAcquireNextImageInfoKHX { 5804 VkStructureType sType; 5805 const void* pNext; 5806 VkSwapchainKHR swapchain; 5807 uint64_t timeout; 5808 VkSemaphore semaphore; 5809 VkFence fence; 5810 uint32_t deviceMask; 5811 } VkAcquireNextImageInfoKHX; 5812 5813 typedef struct VkDeviceGroupPresentInfoKHX { 5814 VkStructureType sType; 5815 const void* pNext; 5816 uint32_t swapchainCount; 5817 const uint32_t* pDeviceMasks; 5818 VkDeviceGroupPresentModeFlagBitsKHX mode; 5819 } VkDeviceGroupPresentInfoKHX; 5820 5821 typedef struct VkDeviceGroupSwapchainCreateInfoKHX { 5822 VkStructureType sType; 5823 const void* pNext; 5824 VkDeviceGroupPresentModeFlagsKHX modes; 5825 } VkDeviceGroupSwapchainCreateInfoKHX; 5826 5827 5828 typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeaturesKHX)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlagsKHX* pPeerMemoryFeatures); 5829 typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMaskKHX)(VkCommandBuffer commandBuffer, uint32_t deviceMask); 5830 typedef void (VKAPI_PTR *PFN_vkCmdDispatchBaseKHX)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); 5831 typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupPresentCapabilitiesKHX)(VkDevice device, VkDeviceGroupPresentCapabilitiesKHX* pDeviceGroupPresentCapabilities); 5832 typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupSurfacePresentModesKHX)(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHX* pModes); 5833 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDevicePresentRectanglesKHX)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects); 5834 typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImage2KHX)(VkDevice device, const VkAcquireNextImageInfoKHX* pAcquireInfo, uint32_t* pImageIndex); 5835 5836 #ifndef VK_NO_PROTOTYPES 5837 VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeaturesKHX( 5838 VkDevice device, 5839 uint32_t heapIndex, 5840 uint32_t localDeviceIndex, 5841 uint32_t remoteDeviceIndex, 5842 VkPeerMemoryFeatureFlagsKHX* pPeerMemoryFeatures); 5843 5844 VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMaskKHX( 5845 VkCommandBuffer commandBuffer, 5846 uint32_t deviceMask); 5847 5848 VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBaseKHX( 5849 VkCommandBuffer commandBuffer, 5850 uint32_t baseGroupX, 5851 uint32_t baseGroupY, 5852 uint32_t baseGroupZ, 5853 uint32_t groupCountX, 5854 uint32_t groupCountY, 5855 uint32_t groupCountZ); 5856 5857 VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupPresentCapabilitiesKHX( 5858 VkDevice device, 5859 VkDeviceGroupPresentCapabilitiesKHX* pDeviceGroupPresentCapabilities); 5860 5861 VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModesKHX( 5862 VkDevice device, 5863 VkSurfaceKHR surface, 5864 VkDeviceGroupPresentModeFlagsKHX* pModes); 5865 5866 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDevicePresentRectanglesKHX( 5867 VkPhysicalDevice physicalDevice, 5868 VkSurfaceKHR surface, 5869 uint32_t* pRectCount, 5870 VkRect2D* pRects); 5871 5872 VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImage2KHX( 5873 VkDevice device, 5874 const VkAcquireNextImageInfoKHX* pAcquireInfo, 5875 uint32_t* pImageIndex); 5876 #endif 5877 5878 #define VK_EXT_validation_flags 1 5879 #define VK_EXT_VALIDATION_FLAGS_SPEC_VERSION 1 5880 #define VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME "VK_EXT_validation_flags" 5881 5882 5883 typedef enum VkValidationCheckEXT { 5884 VK_VALIDATION_CHECK_ALL_EXT = 0, 5885 VK_VALIDATION_CHECK_SHADERS_EXT = 1, 5886 VK_VALIDATION_CHECK_BEGIN_RANGE_EXT = VK_VALIDATION_CHECK_ALL_EXT, 5887 VK_VALIDATION_CHECK_END_RANGE_EXT = VK_VALIDATION_CHECK_SHADERS_EXT, 5888 VK_VALIDATION_CHECK_RANGE_SIZE_EXT = (VK_VALIDATION_CHECK_SHADERS_EXT - VK_VALIDATION_CHECK_ALL_EXT + 1), 5889 VK_VALIDATION_CHECK_MAX_ENUM_EXT = 0x7FFFFFFF 5890 } VkValidationCheckEXT; 5891 5892 typedef struct VkValidationFlagsEXT { 5893 VkStructureType sType; 5894 const void* pNext; 5895 uint32_t disabledValidationCheckCount; 5896 VkValidationCheckEXT* pDisabledValidationChecks; 5897 } VkValidationFlagsEXT; 5898 5899 5900 5901 #ifdef VK_USE_PLATFORM_VI_NN 5902 #define VK_NN_vi_surface 1 5903 #define VK_NN_VI_SURFACE_SPEC_VERSION 1 5904 #define VK_NN_VI_SURFACE_EXTENSION_NAME "VK_NN_vi_surface" 5905 5906 typedef VkFlags VkViSurfaceCreateFlagsNN; 5907 5908 typedef struct VkViSurfaceCreateInfoNN { 5909 VkStructureType sType; 5910 const void* pNext; 5911 VkViSurfaceCreateFlagsNN flags; 5912 void* window; 5913 } VkViSurfaceCreateInfoNN; 5914 5915 5916 typedef VkResult (VKAPI_PTR *PFN_vkCreateViSurfaceNN)(VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); 5917 5918 #ifndef VK_NO_PROTOTYPES 5919 VKAPI_ATTR VkResult VKAPI_CALL vkCreateViSurfaceNN( 5920 VkInstance instance, 5921 const VkViSurfaceCreateInfoNN* pCreateInfo, 5922 const VkAllocationCallbacks* pAllocator, 5923 VkSurfaceKHR* pSurface); 5924 #endif 5925 #endif /* VK_USE_PLATFORM_VI_NN */ 5926 5927 #define VK_EXT_shader_subgroup_ballot 1 5928 #define VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION 1 5929 #define VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME "VK_EXT_shader_subgroup_ballot" 5930 5931 5932 #define VK_EXT_shader_subgroup_vote 1 5933 #define VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION 1 5934 #define VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME "VK_EXT_shader_subgroup_vote" 5935 5936 5937 #define VK_KHX_device_group_creation 1 5938 #define VK_KHX_DEVICE_GROUP_CREATION_SPEC_VERSION 1 5939 #define VK_KHX_DEVICE_GROUP_CREATION_EXTENSION_NAME "VK_KHX_device_group_creation" 5940 5941 typedef struct VkPhysicalDeviceGroupPropertiesKHX { 5942 VkStructureType sType; 5943 void* pNext; 5944 uint32_t physicalDeviceCount; 5945 VkPhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE_KHX]; 5946 VkBool32 subsetAllocation; 5947 } VkPhysicalDeviceGroupPropertiesKHX; 5948 5949 typedef struct VkDeviceGroupDeviceCreateInfoKHX { 5950 VkStructureType sType; 5951 const void* pNext; 5952 uint32_t physicalDeviceCount; 5953 const VkPhysicalDevice* pPhysicalDevices; 5954 } VkDeviceGroupDeviceCreateInfoKHX; 5955 5956 5957 typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroupsKHX)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupPropertiesKHX* pPhysicalDeviceGroupProperties); 5958 5959 #ifndef VK_NO_PROTOTYPES 5960 VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroupsKHX( 5961 VkInstance instance, 5962 uint32_t* pPhysicalDeviceGroupCount, 5963 VkPhysicalDeviceGroupPropertiesKHX* pPhysicalDeviceGroupProperties); 5964 #endif 5965 5966 #define VK_NVX_device_generated_commands 1 5967 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkObjectTableNVX) 5968 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutNVX) 5969 5970 #define VK_NVX_DEVICE_GENERATED_COMMANDS_SPEC_VERSION 3 5971 #define VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME "VK_NVX_device_generated_commands" 5972 5973 5974 typedef enum VkIndirectCommandsTokenTypeNVX { 5975 VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX = 0, 5976 VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX = 1, 5977 VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX = 2, 5978 VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX = 3, 5979 VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX = 4, 5980 VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX = 5, 5981 VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX = 6, 5982 VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX = 7, 5983 VK_INDIRECT_COMMANDS_TOKEN_TYPE_BEGIN_RANGE_NVX = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX, 5984 VK_INDIRECT_COMMANDS_TOKEN_TYPE_END_RANGE_NVX = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX, 5985 VK_INDIRECT_COMMANDS_TOKEN_TYPE_RANGE_SIZE_NVX = (VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX - VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX + 1), 5986 VK_INDIRECT_COMMANDS_TOKEN_TYPE_MAX_ENUM_NVX = 0x7FFFFFFF 5987 } VkIndirectCommandsTokenTypeNVX; 5988 5989 typedef enum VkObjectEntryTypeNVX { 5990 VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX = 0, 5991 VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX = 1, 5992 VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX = 2, 5993 VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX = 3, 5994 VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX = 4, 5995 VK_OBJECT_ENTRY_TYPE_BEGIN_RANGE_NVX = VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX, 5996 VK_OBJECT_ENTRY_TYPE_END_RANGE_NVX = VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX, 5997 VK_OBJECT_ENTRY_TYPE_RANGE_SIZE_NVX = (VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX - VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX + 1), 5998 VK_OBJECT_ENTRY_TYPE_MAX_ENUM_NVX = 0x7FFFFFFF 5999 } VkObjectEntryTypeNVX; 6000 6001 6002 typedef enum VkIndirectCommandsLayoutUsageFlagBitsNVX { 6003 VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX = 0x00000001, 6004 VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX = 0x00000002, 6005 VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX = 0x00000004, 6006 VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX = 0x00000008, 6007 VK_INDIRECT_COMMANDS_LAYOUT_USAGE_FLAG_BITS_MAX_ENUM_NVX = 0x7FFFFFFF 6008 } VkIndirectCommandsLayoutUsageFlagBitsNVX; 6009 typedef VkFlags VkIndirectCommandsLayoutUsageFlagsNVX; 6010 6011 typedef enum VkObjectEntryUsageFlagBitsNVX { 6012 VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX = 0x00000001, 6013 VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX = 0x00000002, 6014 VK_OBJECT_ENTRY_USAGE_FLAG_BITS_MAX_ENUM_NVX = 0x7FFFFFFF 6015 } VkObjectEntryUsageFlagBitsNVX; 6016 typedef VkFlags VkObjectEntryUsageFlagsNVX; 6017 6018 typedef struct VkDeviceGeneratedCommandsFeaturesNVX { 6019 VkStructureType sType; 6020 const void* pNext; 6021 VkBool32 computeBindingPointSupport; 6022 } VkDeviceGeneratedCommandsFeaturesNVX; 6023 6024 typedef struct VkDeviceGeneratedCommandsLimitsNVX { 6025 VkStructureType sType; 6026 const void* pNext; 6027 uint32_t maxIndirectCommandsLayoutTokenCount; 6028 uint32_t maxObjectEntryCounts; 6029 uint32_t minSequenceCountBufferOffsetAlignment; 6030 uint32_t minSequenceIndexBufferOffsetAlignment; 6031 uint32_t minCommandsTokenBufferOffsetAlignment; 6032 } VkDeviceGeneratedCommandsLimitsNVX; 6033 6034 typedef struct VkIndirectCommandsTokenNVX { 6035 VkIndirectCommandsTokenTypeNVX tokenType; 6036 VkBuffer buffer; 6037 VkDeviceSize offset; 6038 } VkIndirectCommandsTokenNVX; 6039 6040 typedef struct VkIndirectCommandsLayoutTokenNVX { 6041 VkIndirectCommandsTokenTypeNVX tokenType; 6042 uint32_t bindingUnit; 6043 uint32_t dynamicCount; 6044 uint32_t divisor; 6045 } VkIndirectCommandsLayoutTokenNVX; 6046 6047 typedef struct VkIndirectCommandsLayoutCreateInfoNVX { 6048 VkStructureType sType; 6049 const void* pNext; 6050 VkPipelineBindPoint pipelineBindPoint; 6051 VkIndirectCommandsLayoutUsageFlagsNVX flags; 6052 uint32_t tokenCount; 6053 const VkIndirectCommandsLayoutTokenNVX* pTokens; 6054 } VkIndirectCommandsLayoutCreateInfoNVX; 6055 6056 typedef struct VkCmdProcessCommandsInfoNVX { 6057 VkStructureType sType; 6058 const void* pNext; 6059 VkObjectTableNVX objectTable; 6060 VkIndirectCommandsLayoutNVX indirectCommandsLayout; 6061 uint32_t indirectCommandsTokenCount; 6062 const VkIndirectCommandsTokenNVX* pIndirectCommandsTokens; 6063 uint32_t maxSequencesCount; 6064 VkCommandBuffer targetCommandBuffer; 6065 VkBuffer sequencesCountBuffer; 6066 VkDeviceSize sequencesCountOffset; 6067 VkBuffer sequencesIndexBuffer; 6068 VkDeviceSize sequencesIndexOffset; 6069 } VkCmdProcessCommandsInfoNVX; 6070 6071 typedef struct VkCmdReserveSpaceForCommandsInfoNVX { 6072 VkStructureType sType; 6073 const void* pNext; 6074 VkObjectTableNVX objectTable; 6075 VkIndirectCommandsLayoutNVX indirectCommandsLayout; 6076 uint32_t maxSequencesCount; 6077 } VkCmdReserveSpaceForCommandsInfoNVX; 6078 6079 typedef struct VkObjectTableCreateInfoNVX { 6080 VkStructureType sType; 6081 const void* pNext; 6082 uint32_t objectCount; 6083 const VkObjectEntryTypeNVX* pObjectEntryTypes; 6084 const uint32_t* pObjectEntryCounts; 6085 const VkObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags; 6086 uint32_t maxUniformBuffersPerDescriptor; 6087 uint32_t maxStorageBuffersPerDescriptor; 6088 uint32_t maxStorageImagesPerDescriptor; 6089 uint32_t maxSampledImagesPerDescriptor; 6090 uint32_t maxPipelineLayouts; 6091 } VkObjectTableCreateInfoNVX; 6092 6093 typedef struct VkObjectTableEntryNVX { 6094 VkObjectEntryTypeNVX type; 6095 VkObjectEntryUsageFlagsNVX flags; 6096 } VkObjectTableEntryNVX; 6097 6098 typedef struct VkObjectTablePipelineEntryNVX { 6099 VkObjectEntryTypeNVX type; 6100 VkObjectEntryUsageFlagsNVX flags; 6101 VkPipeline pipeline; 6102 } VkObjectTablePipelineEntryNVX; 6103 6104 typedef struct VkObjectTableDescriptorSetEntryNVX { 6105 VkObjectEntryTypeNVX type; 6106 VkObjectEntryUsageFlagsNVX flags; 6107 VkPipelineLayout pipelineLayout; 6108 VkDescriptorSet descriptorSet; 6109 } VkObjectTableDescriptorSetEntryNVX; 6110 6111 typedef struct VkObjectTableVertexBufferEntryNVX { 6112 VkObjectEntryTypeNVX type; 6113 VkObjectEntryUsageFlagsNVX flags; 6114 VkBuffer buffer; 6115 } VkObjectTableVertexBufferEntryNVX; 6116 6117 typedef struct VkObjectTableIndexBufferEntryNVX { 6118 VkObjectEntryTypeNVX type; 6119 VkObjectEntryUsageFlagsNVX flags; 6120 VkBuffer buffer; 6121 VkIndexType indexType; 6122 } VkObjectTableIndexBufferEntryNVX; 6123 6124 typedef struct VkObjectTablePushConstantEntryNVX { 6125 VkObjectEntryTypeNVX type; 6126 VkObjectEntryUsageFlagsNVX flags; 6127 VkPipelineLayout pipelineLayout; 6128 VkShaderStageFlags stageFlags; 6129 } VkObjectTablePushConstantEntryNVX; 6130 6131 6132 typedef void (VKAPI_PTR *PFN_vkCmdProcessCommandsNVX)(VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo); 6133 typedef void (VKAPI_PTR *PFN_vkCmdReserveSpaceForCommandsNVX)(VkCommandBuffer commandBuffer, const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo); 6134 typedef VkResult (VKAPI_PTR *PFN_vkCreateIndirectCommandsLayoutNVX)(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout); 6135 typedef void (VKAPI_PTR *PFN_vkDestroyIndirectCommandsLayoutNVX)(VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout, const VkAllocationCallbacks* pAllocator); 6136 typedef VkResult (VKAPI_PTR *PFN_vkCreateObjectTableNVX)(VkDevice device, const VkObjectTableCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkObjectTableNVX* pObjectTable); 6137 typedef void (VKAPI_PTR *PFN_vkDestroyObjectTableNVX)(VkDevice device, VkObjectTableNVX objectTable, const VkAllocationCallbacks* pAllocator); 6138 typedef VkResult (VKAPI_PTR *PFN_vkRegisterObjectsNVX)(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectTableEntryNVX* const* ppObjectTableEntries, const uint32_t* pObjectIndices); 6139 typedef VkResult (VKAPI_PTR *PFN_vkUnregisterObjectsNVX)(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices); 6140 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX)(VkPhysicalDevice physicalDevice, VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, VkDeviceGeneratedCommandsLimitsNVX* pLimits); 6141 6142 #ifndef VK_NO_PROTOTYPES 6143 VKAPI_ATTR void VKAPI_CALL vkCmdProcessCommandsNVX( 6144 VkCommandBuffer commandBuffer, 6145 const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo); 6146 6147 VKAPI_ATTR void VKAPI_CALL vkCmdReserveSpaceForCommandsNVX( 6148 VkCommandBuffer commandBuffer, 6149 const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo); 6150 6151 VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutNVX( 6152 VkDevice device, 6153 const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, 6154 const VkAllocationCallbacks* pAllocator, 6155 VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout); 6156 6157 VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectCommandsLayoutNVX( 6158 VkDevice device, 6159 VkIndirectCommandsLayoutNVX indirectCommandsLayout, 6160 const VkAllocationCallbacks* pAllocator); 6161 6162 VKAPI_ATTR VkResult VKAPI_CALL vkCreateObjectTableNVX( 6163 VkDevice device, 6164 const VkObjectTableCreateInfoNVX* pCreateInfo, 6165 const VkAllocationCallbacks* pAllocator, 6166 VkObjectTableNVX* pObjectTable); 6167 6168 VKAPI_ATTR void VKAPI_CALL vkDestroyObjectTableNVX( 6169 VkDevice device, 6170 VkObjectTableNVX objectTable, 6171 const VkAllocationCallbacks* pAllocator); 6172 6173 VKAPI_ATTR VkResult VKAPI_CALL vkRegisterObjectsNVX( 6174 VkDevice device, 6175 VkObjectTableNVX objectTable, 6176 uint32_t objectCount, 6177 const VkObjectTableEntryNVX* const* ppObjectTableEntries, 6178 const uint32_t* pObjectIndices); 6179 6180 VKAPI_ATTR VkResult VKAPI_CALL vkUnregisterObjectsNVX( 6181 VkDevice device, 6182 VkObjectTableNVX objectTable, 6183 uint32_t objectCount, 6184 const VkObjectEntryTypeNVX* pObjectEntryTypes, 6185 const uint32_t* pObjectIndices); 6186 6187 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( 6188 VkPhysicalDevice physicalDevice, 6189 VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, 6190 VkDeviceGeneratedCommandsLimitsNVX* pLimits); 6191 #endif 6192 6193 #define VK_NV_clip_space_w_scaling 1 6194 #define VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION 1 6195 #define VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME "VK_NV_clip_space_w_scaling" 6196 6197 typedef struct VkViewportWScalingNV { 6198 float xcoeff; 6199 float ycoeff; 6200 } VkViewportWScalingNV; 6201 6202 typedef struct VkPipelineViewportWScalingStateCreateInfoNV { 6203 VkStructureType sType; 6204 const void* pNext; 6205 VkBool32 viewportWScalingEnable; 6206 uint32_t viewportCount; 6207 const VkViewportWScalingNV* pViewportWScalings; 6208 } VkPipelineViewportWScalingStateCreateInfoNV; 6209 6210 6211 typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWScalingNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings); 6212 6213 #ifndef VK_NO_PROTOTYPES 6214 VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingNV( 6215 VkCommandBuffer commandBuffer, 6216 uint32_t firstViewport, 6217 uint32_t viewportCount, 6218 const VkViewportWScalingNV* pViewportWScalings); 6219 #endif 6220 6221 #define VK_EXT_direct_mode_display 1 6222 #define VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION 1 6223 #define VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME "VK_EXT_direct_mode_display" 6224 6225 typedef VkResult (VKAPI_PTR *PFN_vkReleaseDisplayEXT)(VkPhysicalDevice physicalDevice, VkDisplayKHR display); 6226 6227 #ifndef VK_NO_PROTOTYPES 6228 VKAPI_ATTR VkResult VKAPI_CALL vkReleaseDisplayEXT( 6229 VkPhysicalDevice physicalDevice, 6230 VkDisplayKHR display); 6231 #endif 6232 6233 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT 6234 #define VK_EXT_acquire_xlib_display 1 6235 #include <X11/extensions/Xrandr.h> 6236 6237 #define VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION 1 6238 #define VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME "VK_EXT_acquire_xlib_display" 6239 6240 typedef VkResult (VKAPI_PTR *PFN_vkAcquireXlibDisplayEXT)(VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display); 6241 typedef VkResult (VKAPI_PTR *PFN_vkGetRandROutputDisplayEXT)(VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay); 6242 6243 #ifndef VK_NO_PROTOTYPES 6244 VKAPI_ATTR VkResult VKAPI_CALL vkAcquireXlibDisplayEXT( 6245 VkPhysicalDevice physicalDevice, 6246 Display* dpy, 6247 VkDisplayKHR display); 6248 6249 VKAPI_ATTR VkResult VKAPI_CALL vkGetRandROutputDisplayEXT( 6250 VkPhysicalDevice physicalDevice, 6251 Display* dpy, 6252 RROutput rrOutput, 6253 VkDisplayKHR* pDisplay); 6254 #endif 6255 #endif /* VK_USE_PLATFORM_XLIB_XRANDR_EXT */ 6256 6257 #define VK_EXT_display_surface_counter 1 6258 #define VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION 1 6259 #define VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME "VK_EXT_display_surface_counter" 6260 #define VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT 6261 6262 6263 typedef enum VkSurfaceCounterFlagBitsEXT { 6264 VK_SURFACE_COUNTER_VBLANK_EXT = 0x00000001, 6265 VK_SURFACE_COUNTER_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF 6266 } VkSurfaceCounterFlagBitsEXT; 6267 typedef VkFlags VkSurfaceCounterFlagsEXT; 6268 6269 typedef struct VkSurfaceCapabilities2EXT { 6270 VkStructureType sType; 6271 void* pNext; 6272 uint32_t minImageCount; 6273 uint32_t maxImageCount; 6274 VkExtent2D currentExtent; 6275 VkExtent2D minImageExtent; 6276 VkExtent2D maxImageExtent; 6277 uint32_t maxImageArrayLayers; 6278 VkSurfaceTransformFlagsKHR supportedTransforms; 6279 VkSurfaceTransformFlagBitsKHR currentTransform; 6280 VkCompositeAlphaFlagsKHR supportedCompositeAlpha; 6281 VkImageUsageFlags supportedUsageFlags; 6282 VkSurfaceCounterFlagsEXT supportedSurfaceCounters; 6283 } VkSurfaceCapabilities2EXT; 6284 6285 6286 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities); 6287 6288 #ifndef VK_NO_PROTOTYPES 6289 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2EXT( 6290 VkPhysicalDevice physicalDevice, 6291 VkSurfaceKHR surface, 6292 VkSurfaceCapabilities2EXT* pSurfaceCapabilities); 6293 #endif 6294 6295 #define VK_EXT_display_control 1 6296 #define VK_EXT_DISPLAY_CONTROL_SPEC_VERSION 1 6297 #define VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME "VK_EXT_display_control" 6298 6299 6300 typedef enum VkDisplayPowerStateEXT { 6301 VK_DISPLAY_POWER_STATE_OFF_EXT = 0, 6302 VK_DISPLAY_POWER_STATE_SUSPEND_EXT = 1, 6303 VK_DISPLAY_POWER_STATE_ON_EXT = 2, 6304 VK_DISPLAY_POWER_STATE_BEGIN_RANGE_EXT = VK_DISPLAY_POWER_STATE_OFF_EXT, 6305 VK_DISPLAY_POWER_STATE_END_RANGE_EXT = VK_DISPLAY_POWER_STATE_ON_EXT, 6306 VK_DISPLAY_POWER_STATE_RANGE_SIZE_EXT = (VK_DISPLAY_POWER_STATE_ON_EXT - VK_DISPLAY_POWER_STATE_OFF_EXT + 1), 6307 VK_DISPLAY_POWER_STATE_MAX_ENUM_EXT = 0x7FFFFFFF 6308 } VkDisplayPowerStateEXT; 6309 6310 typedef enum VkDeviceEventTypeEXT { 6311 VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT = 0, 6312 VK_DEVICE_EVENT_TYPE_BEGIN_RANGE_EXT = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT, 6313 VK_DEVICE_EVENT_TYPE_END_RANGE_EXT = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT, 6314 VK_DEVICE_EVENT_TYPE_RANGE_SIZE_EXT = (VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT - VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT + 1), 6315 VK_DEVICE_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF 6316 } VkDeviceEventTypeEXT; 6317 6318 typedef enum VkDisplayEventTypeEXT { 6319 VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT = 0, 6320 VK_DISPLAY_EVENT_TYPE_BEGIN_RANGE_EXT = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT, 6321 VK_DISPLAY_EVENT_TYPE_END_RANGE_EXT = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT, 6322 VK_DISPLAY_EVENT_TYPE_RANGE_SIZE_EXT = (VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT - VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT + 1), 6323 VK_DISPLAY_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF 6324 } VkDisplayEventTypeEXT; 6325 6326 typedef struct VkDisplayPowerInfoEXT { 6327 VkStructureType sType; 6328 const void* pNext; 6329 VkDisplayPowerStateEXT powerState; 6330 } VkDisplayPowerInfoEXT; 6331 6332 typedef struct VkDeviceEventInfoEXT { 6333 VkStructureType sType; 6334 const void* pNext; 6335 VkDeviceEventTypeEXT deviceEvent; 6336 } VkDeviceEventInfoEXT; 6337 6338 typedef struct VkDisplayEventInfoEXT { 6339 VkStructureType sType; 6340 const void* pNext; 6341 VkDisplayEventTypeEXT displayEvent; 6342 } VkDisplayEventInfoEXT; 6343 6344 typedef struct VkSwapchainCounterCreateInfoEXT { 6345 VkStructureType sType; 6346 const void* pNext; 6347 VkSurfaceCounterFlagsEXT surfaceCounters; 6348 } VkSwapchainCounterCreateInfoEXT; 6349 6350 6351 typedef VkResult (VKAPI_PTR *PFN_vkDisplayPowerControlEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo); 6352 typedef VkResult (VKAPI_PTR *PFN_vkRegisterDeviceEventEXT)(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); 6353 typedef VkResult (VKAPI_PTR *PFN_vkRegisterDisplayEventEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); 6354 typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainCounterEXT)(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue); 6355 6356 #ifndef VK_NO_PROTOTYPES 6357 VKAPI_ATTR VkResult VKAPI_CALL vkDisplayPowerControlEXT( 6358 VkDevice device, 6359 VkDisplayKHR display, 6360 const VkDisplayPowerInfoEXT* pDisplayPowerInfo); 6361 6362 VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDeviceEventEXT( 6363 VkDevice device, 6364 const VkDeviceEventInfoEXT* pDeviceEventInfo, 6365 const VkAllocationCallbacks* pAllocator, 6366 VkFence* pFence); 6367 6368 VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDisplayEventEXT( 6369 VkDevice device, 6370 VkDisplayKHR display, 6371 const VkDisplayEventInfoEXT* pDisplayEventInfo, 6372 const VkAllocationCallbacks* pAllocator, 6373 VkFence* pFence); 6374 6375 VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainCounterEXT( 6376 VkDevice device, 6377 VkSwapchainKHR swapchain, 6378 VkSurfaceCounterFlagBitsEXT counter, 6379 uint64_t* pCounterValue); 6380 #endif 6381 6382 #define VK_GOOGLE_display_timing 1 6383 #define VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION 1 6384 #define VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME "VK_GOOGLE_display_timing" 6385 6386 typedef struct VkRefreshCycleDurationGOOGLE { 6387 uint64_t refreshDuration; 6388 } VkRefreshCycleDurationGOOGLE; 6389 6390 typedef struct VkPastPresentationTimingGOOGLE { 6391 uint32_t presentID; 6392 uint64_t desiredPresentTime; 6393 uint64_t actualPresentTime; 6394 uint64_t earliestPresentTime; 6395 uint64_t presentMargin; 6396 } VkPastPresentationTimingGOOGLE; 6397 6398 typedef struct VkPresentTimeGOOGLE { 6399 uint32_t presentID; 6400 uint64_t desiredPresentTime; 6401 } VkPresentTimeGOOGLE; 6402 6403 typedef struct VkPresentTimesInfoGOOGLE { 6404 VkStructureType sType; 6405 const void* pNext; 6406 uint32_t swapchainCount; 6407 const VkPresentTimeGOOGLE* pTimes; 6408 } VkPresentTimesInfoGOOGLE; 6409 6410 6411 typedef VkResult (VKAPI_PTR *PFN_vkGetRefreshCycleDurationGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties); 6412 typedef VkResult (VKAPI_PTR *PFN_vkGetPastPresentationTimingGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings); 6413 6414 #ifndef VK_NO_PROTOTYPES 6415 VKAPI_ATTR VkResult VKAPI_CALL vkGetRefreshCycleDurationGOOGLE( 6416 VkDevice device, 6417 VkSwapchainKHR swapchain, 6418 VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties); 6419 6420 VKAPI_ATTR VkResult VKAPI_CALL vkGetPastPresentationTimingGOOGLE( 6421 VkDevice device, 6422 VkSwapchainKHR swapchain, 6423 uint32_t* pPresentationTimingCount, 6424 VkPastPresentationTimingGOOGLE* pPresentationTimings); 6425 #endif 6426 6427 #define VK_NV_sample_mask_override_coverage 1 6428 #define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION 1 6429 #define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME "VK_NV_sample_mask_override_coverage" 6430 6431 6432 #define VK_NV_geometry_shader_passthrough 1 6433 #define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION 1 6434 #define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME "VK_NV_geometry_shader_passthrough" 6435 6436 6437 #define VK_NV_viewport_array2 1 6438 #define VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION 1 6439 #define VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME "VK_NV_viewport_array2" 6440 6441 6442 #define VK_NVX_multiview_per_view_attributes 1 6443 #define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION 1 6444 #define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME "VK_NVX_multiview_per_view_attributes" 6445 6446 typedef struct VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { 6447 VkStructureType sType; 6448 void* pNext; 6449 VkBool32 perViewPositionAllComponents; 6450 } VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; 6451 6452 6453 6454 #define VK_NV_viewport_swizzle 1 6455 #define VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION 1 6456 #define VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME "VK_NV_viewport_swizzle" 6457 6458 6459 typedef enum VkViewportCoordinateSwizzleNV { 6460 VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV = 0, 6461 VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV = 1, 6462 VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV = 2, 6463 VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV = 3, 6464 VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV = 4, 6465 VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV = 5, 6466 VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV = 6, 6467 VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV = 7, 6468 VK_VIEWPORT_COORDINATE_SWIZZLE_BEGIN_RANGE_NV = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV, 6469 VK_VIEWPORT_COORDINATE_SWIZZLE_END_RANGE_NV = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV, 6470 VK_VIEWPORT_COORDINATE_SWIZZLE_RANGE_SIZE_NV = (VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV - VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV + 1), 6471 VK_VIEWPORT_COORDINATE_SWIZZLE_MAX_ENUM_NV = 0x7FFFFFFF 6472 } VkViewportCoordinateSwizzleNV; 6473 6474 typedef VkFlags VkPipelineViewportSwizzleStateCreateFlagsNV; 6475 6476 typedef struct VkViewportSwizzleNV { 6477 VkViewportCoordinateSwizzleNV x; 6478 VkViewportCoordinateSwizzleNV y; 6479 VkViewportCoordinateSwizzleNV z; 6480 VkViewportCoordinateSwizzleNV w; 6481 } VkViewportSwizzleNV; 6482 6483 typedef struct VkPipelineViewportSwizzleStateCreateInfoNV { 6484 VkStructureType sType; 6485 const void* pNext; 6486 VkPipelineViewportSwizzleStateCreateFlagsNV flags; 6487 uint32_t viewportCount; 6488 const VkViewportSwizzleNV* pViewportSwizzles; 6489 } VkPipelineViewportSwizzleStateCreateInfoNV; 6490 6491 6492 6493 #define VK_EXT_discard_rectangles 1 6494 #define VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION 1 6495 #define VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME "VK_EXT_discard_rectangles" 6496 6497 6498 typedef enum VkDiscardRectangleModeEXT { 6499 VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = 0, 6500 VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = 1, 6501 VK_DISCARD_RECTANGLE_MODE_BEGIN_RANGE_EXT = VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT, 6502 VK_DISCARD_RECTANGLE_MODE_END_RANGE_EXT = VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT, 6503 VK_DISCARD_RECTANGLE_MODE_RANGE_SIZE_EXT = (VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT - VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT + 1), 6504 VK_DISCARD_RECTANGLE_MODE_MAX_ENUM_EXT = 0x7FFFFFFF 6505 } VkDiscardRectangleModeEXT; 6506 6507 typedef VkFlags VkPipelineDiscardRectangleStateCreateFlagsEXT; 6508 6509 typedef struct VkPhysicalDeviceDiscardRectanglePropertiesEXT { 6510 VkStructureType sType; 6511 void* pNext; 6512 uint32_t maxDiscardRectangles; 6513 } VkPhysicalDeviceDiscardRectanglePropertiesEXT; 6514 6515 typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT { 6516 VkStructureType sType; 6517 const void* pNext; 6518 VkPipelineDiscardRectangleStateCreateFlagsEXT flags; 6519 VkDiscardRectangleModeEXT discardRectangleMode; 6520 uint32_t discardRectangleCount; 6521 const VkRect2D* pDiscardRectangles; 6522 } VkPipelineDiscardRectangleStateCreateInfoEXT; 6523 6524 6525 typedef void (VKAPI_PTR *PFN_vkCmdSetDiscardRectangleEXT)(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles); 6526 6527 #ifndef VK_NO_PROTOTYPES 6528 VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEXT( 6529 VkCommandBuffer commandBuffer, 6530 uint32_t firstDiscardRectangle, 6531 uint32_t discardRectangleCount, 6532 const VkRect2D* pDiscardRectangles); 6533 #endif 6534 6535 #define VK_EXT_swapchain_colorspace 1 6536 #define VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION 3 6537 #define VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME "VK_EXT_swapchain_colorspace" 6538 6539 6540 #define VK_EXT_hdr_metadata 1 6541 #define VK_EXT_HDR_METADATA_SPEC_VERSION 1 6542 #define VK_EXT_HDR_METADATA_EXTENSION_NAME "VK_EXT_hdr_metadata" 6543 6544 typedef struct VkXYColorEXT { 6545 float x; 6546 float y; 6547 } VkXYColorEXT; 6548 6549 typedef struct VkHdrMetadataEXT { 6550 VkStructureType sType; 6551 const void* pNext; 6552 VkXYColorEXT displayPrimaryRed; 6553 VkXYColorEXT displayPrimaryGreen; 6554 VkXYColorEXT displayPrimaryBlue; 6555 VkXYColorEXT whitePoint; 6556 float maxLuminance; 6557 float minLuminance; 6558 float maxContentLightLevel; 6559 float maxFrameAverageLightLevel; 6560 } VkHdrMetadataEXT; 6561 6562 6563 typedef void (VKAPI_PTR *PFN_vkSetHdrMetadataEXT)(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata); 6564 6565 #ifndef VK_NO_PROTOTYPES 6566 VKAPI_ATTR void VKAPI_CALL vkSetHdrMetadataEXT( 6567 VkDevice device, 6568 uint32_t swapchainCount, 6569 const VkSwapchainKHR* pSwapchains, 6570 const VkHdrMetadataEXT* pMetadata); 6571 #endif 6572 6573 #ifdef VK_USE_PLATFORM_IOS_MVK 6574 #define VK_MVK_ios_surface 1 6575 #define VK_MVK_IOS_SURFACE_SPEC_VERSION 2 6576 #define VK_MVK_IOS_SURFACE_EXTENSION_NAME "VK_MVK_ios_surface" 6577 6578 typedef VkFlags VkIOSSurfaceCreateFlagsMVK; 6579 6580 typedef struct VkIOSSurfaceCreateInfoMVK { 6581 VkStructureType sType; 6582 const void* pNext; 6583 VkIOSSurfaceCreateFlagsMVK flags; 6584 const void* pView; 6585 } VkIOSSurfaceCreateInfoMVK; 6586 6587 6588 typedef VkResult (VKAPI_PTR *PFN_vkCreateIOSSurfaceMVK)(VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); 6589 6590 #ifndef VK_NO_PROTOTYPES 6591 VKAPI_ATTR VkResult VKAPI_CALL vkCreateIOSSurfaceMVK( 6592 VkInstance instance, 6593 const VkIOSSurfaceCreateInfoMVK* pCreateInfo, 6594 const VkAllocationCallbacks* pAllocator, 6595 VkSurfaceKHR* pSurface); 6596 #endif 6597 #endif /* VK_USE_PLATFORM_IOS_MVK */ 6598 6599 #ifdef VK_USE_PLATFORM_MACOS_MVK 6600 #define VK_MVK_macos_surface 1 6601 #define VK_MVK_MACOS_SURFACE_SPEC_VERSION 2 6602 #define VK_MVK_MACOS_SURFACE_EXTENSION_NAME "VK_MVK_macos_surface" 6603 6604 typedef VkFlags VkMacOSSurfaceCreateFlagsMVK; 6605 6606 typedef struct VkMacOSSurfaceCreateInfoMVK { 6607 VkStructureType sType; 6608 const void* pNext; 6609 VkMacOSSurfaceCreateFlagsMVK flags; 6610 const void* pView; 6611 } VkMacOSSurfaceCreateInfoMVK; 6612 6613 6614 typedef VkResult (VKAPI_PTR *PFN_vkCreateMacOSSurfaceMVK)(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); 6615 6616 #ifndef VK_NO_PROTOTYPES 6617 VKAPI_ATTR VkResult VKAPI_CALL vkCreateMacOSSurfaceMVK( 6618 VkInstance instance, 6619 const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, 6620 const VkAllocationCallbacks* pAllocator, 6621 VkSurfaceKHR* pSurface); 6622 #endif 6623 #endif /* VK_USE_PLATFORM_MACOS_MVK */ 6624 6625 #define VK_EXT_external_memory_dma_buf 1 6626 #define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION 1 6627 #define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME "VK_EXT_external_memory_dma_buf" 6628 6629 6630 #define VK_EXT_queue_family_foreign 1 6631 #define VK_EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION 1 6632 #define VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME "VK_EXT_queue_family_foreign" 6633 #define VK_QUEUE_FAMILY_FOREIGN_EXT (~0U-2) 6634 6635 6636 #define VK_EXT_sampler_filter_minmax 1 6637 #define VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION 1 6638 #define VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME "VK_EXT_sampler_filter_minmax" 6639 6640 6641 typedef enum VkSamplerReductionModeEXT { 6642 VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT = 0, 6643 VK_SAMPLER_REDUCTION_MODE_MIN_EXT = 1, 6644 VK_SAMPLER_REDUCTION_MODE_MAX_EXT = 2, 6645 VK_SAMPLER_REDUCTION_MODE_BEGIN_RANGE_EXT = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT, 6646 VK_SAMPLER_REDUCTION_MODE_END_RANGE_EXT = VK_SAMPLER_REDUCTION_MODE_MAX_EXT, 6647 VK_SAMPLER_REDUCTION_MODE_RANGE_SIZE_EXT = (VK_SAMPLER_REDUCTION_MODE_MAX_EXT - VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT + 1), 6648 VK_SAMPLER_REDUCTION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF 6649 } VkSamplerReductionModeEXT; 6650 6651 typedef struct VkSamplerReductionModeCreateInfoEXT { 6652 VkStructureType sType; 6653 const void* pNext; 6654 VkSamplerReductionModeEXT reductionMode; 6655 } VkSamplerReductionModeCreateInfoEXT; 6656 6657 typedef struct VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT { 6658 VkStructureType sType; 6659 void* pNext; 6660 VkBool32 filterMinmaxSingleComponentFormats; 6661 VkBool32 filterMinmaxImageComponentMapping; 6662 } VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT; 6663 6664 6665 6666 #define VK_AMD_gpu_shader_int16 1 6667 #define VK_AMD_GPU_SHADER_INT16_SPEC_VERSION 1 6668 #define VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME "VK_AMD_gpu_shader_int16" 6669 6670 6671 #define VK_AMD_mixed_attachment_samples 1 6672 #define VK_AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION 1 6673 #define VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME "VK_AMD_mixed_attachment_samples" 6674 6675 6676 #define VK_AMD_shader_fragment_mask 1 6677 #define VK_AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION 1 6678 #define VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME "VK_AMD_shader_fragment_mask" 6679 6680 6681 #define VK_EXT_shader_stencil_export 1 6682 #define VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION 1 6683 #define VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME "VK_EXT_shader_stencil_export" 6684 6685 6686 #define VK_EXT_sample_locations 1 6687 #define VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION 1 6688 #define VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME "VK_EXT_sample_locations" 6689 6690 typedef struct VkSampleLocationEXT { 6691 float x; 6692 float y; 6693 } VkSampleLocationEXT; 6694 6695 typedef struct VkSampleLocationsInfoEXT { 6696 VkStructureType sType; 6697 const void* pNext; 6698 VkSampleCountFlagBits sampleLocationsPerPixel; 6699 VkExtent2D sampleLocationGridSize; 6700 uint32_t sampleLocationsCount; 6701 const VkSampleLocationEXT* pSampleLocations; 6702 } VkSampleLocationsInfoEXT; 6703 6704 typedef struct VkAttachmentSampleLocationsEXT { 6705 uint32_t attachmentIndex; 6706 VkSampleLocationsInfoEXT sampleLocationsInfo; 6707 } VkAttachmentSampleLocationsEXT; 6708 6709 typedef struct VkSubpassSampleLocationsEXT { 6710 uint32_t subpassIndex; 6711 VkSampleLocationsInfoEXT sampleLocationsInfo; 6712 } VkSubpassSampleLocationsEXT; 6713 6714 typedef struct VkRenderPassSampleLocationsBeginInfoEXT { 6715 VkStructureType sType; 6716 const void* pNext; 6717 uint32_t attachmentInitialSampleLocationsCount; 6718 const VkAttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations; 6719 uint32_t postSubpassSampleLocationsCount; 6720 const VkSubpassSampleLocationsEXT* pPostSubpassSampleLocations; 6721 } VkRenderPassSampleLocationsBeginInfoEXT; 6722 6723 typedef struct VkPipelineSampleLocationsStateCreateInfoEXT { 6724 VkStructureType sType; 6725 const void* pNext; 6726 VkBool32 sampleLocationsEnable; 6727 VkSampleLocationsInfoEXT sampleLocationsInfo; 6728 } VkPipelineSampleLocationsStateCreateInfoEXT; 6729 6730 typedef struct VkPhysicalDeviceSampleLocationsPropertiesEXT { 6731 VkStructureType sType; 6732 void* pNext; 6733 VkSampleCountFlags sampleLocationSampleCounts; 6734 VkExtent2D maxSampleLocationGridSize; 6735 float sampleLocationCoordinateRange[2]; 6736 uint32_t sampleLocationSubPixelBits; 6737 VkBool32 variableSampleLocations; 6738 } VkPhysicalDeviceSampleLocationsPropertiesEXT; 6739 6740 typedef struct VkMultisamplePropertiesEXT { 6741 VkStructureType sType; 6742 void* pNext; 6743 VkExtent2D maxSampleLocationGridSize; 6744 } VkMultisamplePropertiesEXT; 6745 6746 6747 typedef void (VKAPI_PTR *PFN_vkCmdSetSampleLocationsEXT)(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo); 6748 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT)(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties); 6749 6750 #ifndef VK_NO_PROTOTYPES 6751 VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleLocationsEXT( 6752 VkCommandBuffer commandBuffer, 6753 const VkSampleLocationsInfoEXT* pSampleLocationsInfo); 6754 6755 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMultisamplePropertiesEXT( 6756 VkPhysicalDevice physicalDevice, 6757 VkSampleCountFlagBits samples, 6758 VkMultisamplePropertiesEXT* pMultisampleProperties); 6759 #endif 6760 6761 #define VK_EXT_blend_operation_advanced 1 6762 #define VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION 2 6763 #define VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME "VK_EXT_blend_operation_advanced" 6764 6765 6766 typedef enum VkBlendOverlapEXT { 6767 VK_BLEND_OVERLAP_UNCORRELATED_EXT = 0, 6768 VK_BLEND_OVERLAP_DISJOINT_EXT = 1, 6769 VK_BLEND_OVERLAP_CONJOINT_EXT = 2, 6770 VK_BLEND_OVERLAP_BEGIN_RANGE_EXT = VK_BLEND_OVERLAP_UNCORRELATED_EXT, 6771 VK_BLEND_OVERLAP_END_RANGE_EXT = VK_BLEND_OVERLAP_CONJOINT_EXT, 6772 VK_BLEND_OVERLAP_RANGE_SIZE_EXT = (VK_BLEND_OVERLAP_CONJOINT_EXT - VK_BLEND_OVERLAP_UNCORRELATED_EXT + 1), 6773 VK_BLEND_OVERLAP_MAX_ENUM_EXT = 0x7FFFFFFF 6774 } VkBlendOverlapEXT; 6775 6776 typedef struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT { 6777 VkStructureType sType; 6778 void* pNext; 6779 VkBool32 advancedBlendCoherentOperations; 6780 } VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT; 6781 6782 typedef struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT { 6783 VkStructureType sType; 6784 void* pNext; 6785 uint32_t advancedBlendMaxColorAttachments; 6786 VkBool32 advancedBlendIndependentBlend; 6787 VkBool32 advancedBlendNonPremultipliedSrcColor; 6788 VkBool32 advancedBlendNonPremultipliedDstColor; 6789 VkBool32 advancedBlendCorrelatedOverlap; 6790 VkBool32 advancedBlendAllOperations; 6791 } VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT; 6792 6793 typedef struct VkPipelineColorBlendAdvancedStateCreateInfoEXT { 6794 VkStructureType sType; 6795 const void* pNext; 6796 VkBool32 srcPremultiplied; 6797 VkBool32 dstPremultiplied; 6798 VkBlendOverlapEXT blendOverlap; 6799 } VkPipelineColorBlendAdvancedStateCreateInfoEXT; 6800 6801 6802 6803 #define VK_NV_fragment_coverage_to_color 1 6804 #define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION 1 6805 #define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME "VK_NV_fragment_coverage_to_color" 6806 6807 typedef VkFlags VkPipelineCoverageToColorStateCreateFlagsNV; 6808 6809 typedef struct VkPipelineCoverageToColorStateCreateInfoNV { 6810 VkStructureType sType; 6811 const void* pNext; 6812 VkPipelineCoverageToColorStateCreateFlagsNV flags; 6813 VkBool32 coverageToColorEnable; 6814 uint32_t coverageToColorLocation; 6815 } VkPipelineCoverageToColorStateCreateInfoNV; 6816 6817 6818 6819 #define VK_NV_framebuffer_mixed_samples 1 6820 #define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION 1 6821 #define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME "VK_NV_framebuffer_mixed_samples" 6822 6823 6824 typedef enum VkCoverageModulationModeNV { 6825 VK_COVERAGE_MODULATION_MODE_NONE_NV = 0, 6826 VK_COVERAGE_MODULATION_MODE_RGB_NV = 1, 6827 VK_COVERAGE_MODULATION_MODE_ALPHA_NV = 2, 6828 VK_COVERAGE_MODULATION_MODE_RGBA_NV = 3, 6829 VK_COVERAGE_MODULATION_MODE_BEGIN_RANGE_NV = VK_COVERAGE_MODULATION_MODE_NONE_NV, 6830 VK_COVERAGE_MODULATION_MODE_END_RANGE_NV = VK_COVERAGE_MODULATION_MODE_RGBA_NV, 6831 VK_COVERAGE_MODULATION_MODE_RANGE_SIZE_NV = (VK_COVERAGE_MODULATION_MODE_RGBA_NV - VK_COVERAGE_MODULATION_MODE_NONE_NV + 1), 6832 VK_COVERAGE_MODULATION_MODE_MAX_ENUM_NV = 0x7FFFFFFF 6833 } VkCoverageModulationModeNV; 6834 6835 typedef VkFlags VkPipelineCoverageModulationStateCreateFlagsNV; 6836 6837 typedef struct VkPipelineCoverageModulationStateCreateInfoNV { 6838 VkStructureType sType; 6839 const void* pNext; 6840 VkPipelineCoverageModulationStateCreateFlagsNV flags; 6841 VkCoverageModulationModeNV coverageModulationMode; 6842 VkBool32 coverageModulationTableEnable; 6843 uint32_t coverageModulationTableCount; 6844 const float* pCoverageModulationTable; 6845 } VkPipelineCoverageModulationStateCreateInfoNV; 6846 6847 6848 6849 #define VK_NV_fill_rectangle 1 6850 #define VK_NV_FILL_RECTANGLE_SPEC_VERSION 1 6851 #define VK_NV_FILL_RECTANGLE_EXTENSION_NAME "VK_NV_fill_rectangle" 6852 6853 6854 #define VK_EXT_post_depth_coverage 1 6855 #define VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION 1 6856 #define VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME "VK_EXT_post_depth_coverage" 6857 6858 6859 #define VK_EXT_validation_cache 1 6860 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkValidationCacheEXT) 6861 6862 #define VK_EXT_VALIDATION_CACHE_SPEC_VERSION 1 6863 #define VK_EXT_VALIDATION_CACHE_EXTENSION_NAME "VK_EXT_validation_cache" 6864 6865 6866 typedef enum VkValidationCacheHeaderVersionEXT { 6867 VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT = 1, 6868 VK_VALIDATION_CACHE_HEADER_VERSION_BEGIN_RANGE_EXT = VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT, 6869 VK_VALIDATION_CACHE_HEADER_VERSION_END_RANGE_EXT = VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT, 6870 VK_VALIDATION_CACHE_HEADER_VERSION_RANGE_SIZE_EXT = (VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT - VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT + 1), 6871 VK_VALIDATION_CACHE_HEADER_VERSION_MAX_ENUM_EXT = 0x7FFFFFFF 6872 } VkValidationCacheHeaderVersionEXT; 6873 6874 typedef VkFlags VkValidationCacheCreateFlagsEXT; 6875 6876 typedef struct VkValidationCacheCreateInfoEXT { 6877 VkStructureType sType; 6878 const void* pNext; 6879 VkValidationCacheCreateFlagsEXT flags; 6880 size_t initialDataSize; 6881 const void* pInitialData; 6882 } VkValidationCacheCreateInfoEXT; 6883 6884 typedef struct VkShaderModuleValidationCacheCreateInfoEXT { 6885 VkStructureType sType; 6886 const void* pNext; 6887 VkValidationCacheEXT validationCache; 6888 } VkShaderModuleValidationCacheCreateInfoEXT; 6889 6890 6891 typedef VkResult (VKAPI_PTR *PFN_vkCreateValidationCacheEXT)(VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache); 6892 typedef void (VKAPI_PTR *PFN_vkDestroyValidationCacheEXT)(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator); 6893 typedef VkResult (VKAPI_PTR *PFN_vkMergeValidationCachesEXT)(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches); 6894 typedef VkResult (VKAPI_PTR *PFN_vkGetValidationCacheDataEXT)(VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData); 6895 6896 #ifndef VK_NO_PROTOTYPES 6897 VKAPI_ATTR VkResult VKAPI_CALL vkCreateValidationCacheEXT( 6898 VkDevice device, 6899 const VkValidationCacheCreateInfoEXT* pCreateInfo, 6900 const VkAllocationCallbacks* pAllocator, 6901 VkValidationCacheEXT* pValidationCache); 6902 6903 VKAPI_ATTR void VKAPI_CALL vkDestroyValidationCacheEXT( 6904 VkDevice device, 6905 VkValidationCacheEXT validationCache, 6906 const VkAllocationCallbacks* pAllocator); 6907 6908 VKAPI_ATTR VkResult VKAPI_CALL vkMergeValidationCachesEXT( 6909 VkDevice device, 6910 VkValidationCacheEXT dstCache, 6911 uint32_t srcCacheCount, 6912 const VkValidationCacheEXT* pSrcCaches); 6913 6914 VKAPI_ATTR VkResult VKAPI_CALL vkGetValidationCacheDataEXT( 6915 VkDevice device, 6916 VkValidationCacheEXT validationCache, 6917 size_t* pDataSize, 6918 void* pData); 6919 #endif 6920 6921 #define VK_EXT_shader_viewport_index_layer 1 6922 #define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION 1 6923 #define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME "VK_EXT_shader_viewport_index_layer" 6924 6925 6926 #define VK_EXT_global_priority 1 6927 #define VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION 2 6928 #define VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME "VK_EXT_global_priority" 6929 6930 6931 typedef enum VkQueueGlobalPriorityEXT { 6932 VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT = 128, 6933 VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT = 256, 6934 VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT = 512, 6935 VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT = 1024, 6936 VK_QUEUE_GLOBAL_PRIORITY_BEGIN_RANGE_EXT = VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT, 6937 VK_QUEUE_GLOBAL_PRIORITY_END_RANGE_EXT = VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT, 6938 VK_QUEUE_GLOBAL_PRIORITY_RANGE_SIZE_EXT = (VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT - VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT + 1), 6939 VK_QUEUE_GLOBAL_PRIORITY_MAX_ENUM_EXT = 0x7FFFFFFF 6940 } VkQueueGlobalPriorityEXT; 6941 6942 typedef struct VkDeviceQueueGlobalPriorityCreateInfoEXT { 6943 VkStructureType sType; 6944 const void* pNext; 6945 VkQueueGlobalPriorityEXT globalPriority; 6946 } VkDeviceQueueGlobalPriorityCreateInfoEXT; 6947 6948 6949 6950 #define VK_EXT_external_memory_host 1 6951 #define VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION 1 6952 #define VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME "VK_EXT_external_memory_host" 6953 6954 typedef struct VkImportMemoryHostPointerInfoEXT { 6955 VkStructureType sType; 6956 const void* pNext; 6957 VkExternalMemoryHandleTypeFlagBitsKHR handleType; 6958 void* pHostPointer; 6959 } VkImportMemoryHostPointerInfoEXT; 6960 6961 typedef struct VkMemoryHostPointerPropertiesEXT { 6962 VkStructureType sType; 6963 void* pNext; 6964 uint32_t memoryTypeBits; 6965 } VkMemoryHostPointerPropertiesEXT; 6966 6967 typedef struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT { 6968 VkStructureType sType; 6969 void* pNext; 6970 VkDeviceSize minImportedHostPointerAlignment; 6971 } VkPhysicalDeviceExternalMemoryHostPropertiesEXT; 6972 6973 6974 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryHostPointerPropertiesEXT)(VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHR handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties); 6975 6976 #ifndef VK_NO_PROTOTYPES 6977 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryHostPointerPropertiesEXT( 6978 VkDevice device, 6979 VkExternalMemoryHandleTypeFlagBitsKHR handleType, 6980 const void* pHostPointer, 6981 VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties); 6982 #endif 6983 6984 #ifdef __cplusplus 6985 } 6986 #endif 6987 6988 #endif 6989
