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