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