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