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