lib/sys/src/vulkan.zig

daab053ee43316e1809a84551d573ddd1e5bf3d2

   1 //! Vulkan loader bindings: ABI types, the dynamically loaded entry points,
   2 //! and `VkResult` mapped to typed errors.
   3 
   4 const std = @import("std");
   5 const capabilities = @import("capabilities.zig");
   6 const dynamic = @import("dynamic.zig");
   7 
   8 pub const required_capabilities = capabilities.host(&.{ .allocator, .dynamic_loading });
   9 
  10 const log = std.log.scoped(.vulkan_driver);
  11 
  12 pub const VkInstance = ?*opaque {};
  13 pub const VkPhysicalDevice = ?*opaque {};
  14 pub const VkDevice = ?*opaque {};
  15 pub const VkQueue = ?*opaque {};
  16 pub const VkSemaphore = ?*opaque {};
  17 pub const VkCommandPool = ?*opaque {};
  18 pub const VkCommandBuffer = ?*opaque {};
  19 pub const VkFence = ?*opaque {};
  20 pub const VkShaderModule = ?*opaque {};
  21 pub const VkPipeline = ?*opaque {};
  22 pub const VkPipelineLayout = ?*opaque {};
  23 pub const VkPipelineCache = ?*opaque {};
  24 pub const VkDescriptorSet = ?*opaque {};
  25 pub const VkDescriptorSetLayout = ?*opaque {};
  26 pub const VkDescriptorPool = ?*opaque {};
  27 pub const VkBuffer = ?*opaque {};
  28 pub const VkDeviceMemory = ?*opaque {};
  29 pub const VkQueryPool = u64;
  30 pub const VkSurfaceKHR = u64;
  31 pub const VkSwapchainKHR = u64;
  32 pub const VkImage = u64;
  33 pub const VkImageView = u64;
  34 pub const VkSampler = u64;
  35 pub const VkRenderPass = u64;
  36 pub const VkDisplay = ?*opaque {};
  37 pub const VkWindow = u64;
  38 pub const VkVisualID = u64;
  39 
  40 pub const PFN_vkVoidFunction = ?*const fn () callconv(.c) void;
  41 
  42 pub const VkBool32 = u32;
  43 pub const VK_TRUE: VkBool32 = 1;
  44 pub const VK_FALSE: VkBool32 = 0;
  45 
  46 pub const VkStructureType = u32;
  47 pub const VK_STRUCTURE_TYPE_APPLICATION_INFO: VkStructureType = 0;
  48 pub const VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO: VkStructureType = 1;
  49 pub const VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO: VkStructureType = 2;
  50 pub const VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO: VkStructureType = 3;
  51 pub const VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: VkStructureType = 5;
  52 pub const VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE: VkStructureType = 6;
  53 pub const VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO: VkStructureType = 14;
  54 pub const VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO: VkStructureType = 15;
  55 pub const VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO: VkStructureType = 9;
  56 pub const VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO: VkStructureType = 11;
  57 pub const VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO: VkStructureType = 12;
  58 pub const VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: VkStructureType = 16;
  59 pub const VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO: VkStructureType = 18;
  60 pub const VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO: VkStructureType = 19;
  61 pub const VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO: VkStructureType = 20;
  62 pub const VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO: VkStructureType = 22;
  63 pub const VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO: VkStructureType = 23;
  64 pub const VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO: VkStructureType = 24;
  65 pub const VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO: VkStructureType = 25;
  66 pub const VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO: VkStructureType = 26;
  67 pub const VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO: VkStructureType = 27;
  68 pub const VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO: VkStructureType = 28;
  69 pub const VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO: VkStructureType = 29;
  70 pub const VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: VkStructureType = 30;
  71 pub const VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO: VkStructureType = 31;
  72 pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO: VkStructureType = 32;
  73 pub const VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO: VkStructureType = 33;
  74 pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO: VkStructureType = 34;
  75 pub const VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET: VkStructureType = 35;
  76 pub const VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO: VkStructureType = 39;
  77 pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO: VkStructureType = 40;
  78 pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO: VkStructureType = 42;
  79 pub const VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER: VkStructureType = 44;
  80 pub const VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER: VkStructureType = 45;
  81 pub const VK_STRUCTURE_TYPE_MEMORY_BARRIER: VkStructureType = 46;
  82 pub const VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR: VkStructureType = 1000001000;
  83 pub const VK_STRUCTURE_TYPE_PRESENT_INFO_KHR: VkStructureType = 1000001001;
  84 pub const VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR: VkStructureType = 1000004000;
  85 pub const VK_STRUCTURE_TYPE_RENDERING_INFO: VkStructureType = 1000044000;
  86 pub const VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO: VkStructureType = 1000044001;
  87 pub const VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO: VkStructureType = 1000044002;
  88 pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: VkStructureType = 53;
  89 pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: VkStructureType = 1000059000;
  90 pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2: VkStructureType = 1000059001;
  91 pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: VkStructureType = 1000083000;
  92 pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: VkStructureType = 1000094000;
  93 pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: VkStructureType = 1000177000;
  94 pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: VkStructureType = 1000207000;
  95 pub const VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO: VkStructureType = 1000207002;
  96 pub const VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO: VkStructureType = 1000207003;
  97 pub const VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO: VkStructureType = 1000207004;
  98 pub const VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO: VkStructureType = 1000207005;
  99 pub const VK_STRUCTURE_TYPE_SUBMIT_INFO_2: VkStructureType = 1000314004;
 100 pub const VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO: VkStructureType = 1000314005;
 101 pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO: VkStructureType = 1000314006;
 102 pub const VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2: VkStructureType = 1000059002;
 103 pub const VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO: VkStructureType = 1000072001;
 104 pub const VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO: VkStructureType = 1000072002;
 105 pub const VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR: VkStructureType = 1000074002;
 106 pub const VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO: VkStructureType = 1000077000;
 107 pub const VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR: VkStructureType = 1000079001;
 108 pub const VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO: VkStructureType = 1000127001;
 109 pub const VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: VkStructureType = 1000158000;
 110 pub const VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: VkStructureType = 1000158003;
 111 pub const VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT: VkStructureType = 1000158005;
 112 pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT: VkStructureType = 1000353000;
 113 
 114 pub const VkSemaphoreType = u32;
 115 pub const VK_SEMAPHORE_TYPE_BINARY: VkSemaphoreType = 0;
 116 pub const VK_SEMAPHORE_TYPE_TIMELINE: VkSemaphoreType = 1;
 117 
 118 pub const VkQueueFlags = u32;
 119 pub const VK_QUEUE_GRAPHICS_BIT: VkQueueFlags = 0x00000001;
 120 pub const VK_QUEUE_COMPUTE_BIT: VkQueueFlags = 0x00000002;
 121 pub const VK_QUEUE_TRANSFER_BIT: VkQueueFlags = 0x00000004;
 122 pub const VK_QUEUE_SPARSE_BINDING_BIT: VkQueueFlags = 0x00000008;
 123 
 124 pub const VkCommandPoolCreateFlags = u32;
 125 pub const VK_COMMAND_POOL_CREATE_TRANSIENT_BIT: VkCommandPoolCreateFlags = 0x00000001;
 126 pub const VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT: VkCommandPoolCreateFlags = 0x00000002;
 127 
 128 pub const VkDescriptorPoolResetFlags = u32;
 129 
 130 pub const VkCommandBufferLevel = u32;
 131 pub const VK_COMMAND_BUFFER_LEVEL_PRIMARY: VkCommandBufferLevel = 0;
 132 pub const VK_COMMAND_BUFFER_LEVEL_SECONDARY: VkCommandBufferLevel = 1;
 133 
 134 pub const VkCommandBufferUsageFlags = u32;
 135 pub const VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT: VkCommandBufferUsageFlags = 0x00000001;
 136 pub const VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT: VkCommandBufferUsageFlags = 0x00000002;
 137 pub const VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT: VkCommandBufferUsageFlags = 0x00000004;
 138 
 139 pub const VkBufferUsageFlags = u32;
 140 pub const VK_BUFFER_USAGE_TRANSFER_SRC_BIT: VkBufferUsageFlags = 0x00000001;
 141 pub const VK_BUFFER_USAGE_TRANSFER_DST_BIT: VkBufferUsageFlags = 0x00000002;
 142 pub const VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT: VkBufferUsageFlags = 0x00000010;
 143 pub const VK_BUFFER_USAGE_STORAGE_BUFFER_BIT: VkBufferUsageFlags = 0x00000020;
 144 pub const VK_BUFFER_USAGE_INDEX_BUFFER_BIT: VkBufferUsageFlags = 0x00000040;
 145 pub const VK_BUFFER_USAGE_VERTEX_BUFFER_BIT: VkBufferUsageFlags = 0x00000080;
 146 
 147 pub const VkImageUsageFlags = u32;
 148 pub const VK_IMAGE_USAGE_TRANSFER_SRC_BIT: VkImageUsageFlags = 0x00000001;
 149 pub const VK_IMAGE_USAGE_TRANSFER_DST_BIT: VkImageUsageFlags = 0x00000002;
 150 pub const VK_IMAGE_USAGE_SAMPLED_BIT: VkImageUsageFlags = 0x00000004;
 151 pub const VK_IMAGE_USAGE_STORAGE_BIT: VkImageUsageFlags = 0x00000008;
 152 pub const VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT: VkImageUsageFlags = 0x00000010;
 153 pub const VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT: VkImageUsageFlags = 0x00000020;
 154 
 155 pub const VkImageLayout = u32;
 156 pub const VK_IMAGE_LAYOUT_UNDEFINED: VkImageLayout = 0;
 157 pub const VK_IMAGE_LAYOUT_GENERAL: VkImageLayout = 1;
 158 pub const VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL: VkImageLayout = 2;
 159 pub const VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL: VkImageLayout = 5;
 160 pub const VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL: VkImageLayout = 6;
 161 pub const VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL: VkImageLayout = 7;
 162 pub const VK_IMAGE_LAYOUT_PRESENT_SRC_KHR: VkImageLayout = 1000001002;
 163 pub const VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL: VkImageLayout = 1000241000;
 164 
 165 pub const VkAccessFlags = u32;
 166 pub const VK_ACCESS_INDEX_READ_BIT: VkAccessFlags = 0x00000002;
 167 pub const VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT: VkAccessFlags = 0x00000004;
 168 pub const VK_ACCESS_UNIFORM_READ_BIT: VkAccessFlags = 0x00000008;
 169 pub const VK_ACCESS_SHADER_READ_BIT: VkAccessFlags = 0x00000020;
 170 pub const VK_ACCESS_SHADER_WRITE_BIT: VkAccessFlags = 0x00000040;
 171 pub const VK_ACCESS_COLOR_ATTACHMENT_READ_BIT: VkAccessFlags = 0x00000080;
 172 pub const VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT: VkAccessFlags = 0x00000100;
 173 pub const VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT: VkAccessFlags = 0x00000200;
 174 pub const VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT: VkAccessFlags = 0x00000400;
 175 pub const VK_ACCESS_TRANSFER_READ_BIT: VkAccessFlags = 0x00000800;
 176 pub const VK_ACCESS_TRANSFER_WRITE_BIT: VkAccessFlags = 0x00001000;
 177 pub const VK_ACCESS_HOST_READ_BIT: VkAccessFlags = 0x00002000;
 178 pub const VK_ACCESS_HOST_WRITE_BIT: VkAccessFlags = 0x00004000;
 179 pub const VK_ACCESS_MEMORY_READ_BIT: VkAccessFlags = 0x00008000;
 180 pub const VK_ACCESS_MEMORY_WRITE_BIT: VkAccessFlags = 0x00010000;
 181 
 182 pub const VkPipelineStageFlags = u32;
 183 pub const VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT: VkPipelineStageFlags = 0x00000001;
 184 pub const VK_PIPELINE_STAGE_VERTEX_INPUT_BIT: VkPipelineStageFlags = 0x00000004;
 185 pub const VK_PIPELINE_STAGE_VERTEX_SHADER_BIT: VkPipelineStageFlags = 0x00000008;
 186 pub const VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT: VkPipelineStageFlags = 0x00000080;
 187 pub const VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT: VkPipelineStageFlags = 0x00000100;
 188 pub const VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT: VkPipelineStageFlags = 0x00000200;
 189 pub const VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT: VkPipelineStageFlags = 0x00000400;
 190 pub const VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT: VkPipelineStageFlags = 0x00000800;
 191 pub const VK_PIPELINE_STAGE_TRANSFER_BIT: VkPipelineStageFlags = 0x00001000;
 192 pub const VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT: VkPipelineStageFlags = 0x00002000;
 193 pub const VK_PIPELINE_STAGE_HOST_BIT: VkPipelineStageFlags = 0x00004000;
 194 pub const VK_PIPELINE_STAGE_ALL_COMMANDS_BIT: VkPipelineStageFlags = 0x00010000;
 195 
 196 pub const VkDependencyFlags = u32;
 197 
 198 pub const VkQueryType = u32;
 199 pub const VK_QUERY_TYPE_TIMESTAMP: VkQueryType = 2;
 200 
 201 pub const VkQueryResultFlags = u32;
 202 pub const VK_QUERY_RESULT_64_BIT: VkQueryResultFlags = 0x00000001;
 203 
 204 pub const VkImageAspectFlags = u32;
 205 pub const VK_IMAGE_ASPECT_COLOR_BIT: VkImageAspectFlags = 0x00000001;
 206 pub const VK_IMAGE_ASPECT_DEPTH_BIT: VkImageAspectFlags = 0x00000002;
 207 pub const VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT: VkImageAspectFlags = 0x00000080;
 208 pub const VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT: VkImageAspectFlags = 0x00000100;
 209 pub const VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT: VkImageAspectFlags = 0x00000200;
 210 pub const VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT: VkImageAspectFlags = 0x00000400;
 211 
 212 pub const VK_QUEUE_FAMILY_IGNORED: u32 = std.math.maxInt(u32);
 213 /// `~2U`: the queue family of every agent outside this Vulkan instance, such as a compositor.
 214 pub const VK_QUEUE_FAMILY_FOREIGN_EXT: u32 = std.math.maxInt(u32) - 2;
 215 
 216 pub const VkExternalMemoryHandleTypeFlags = u32;
 217 pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT: VkExternalMemoryHandleTypeFlags = 0x00000200;
 218 pub const VkExternalSemaphoreHandleTypeFlags = u32;
 219 pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT: VkExternalSemaphoreHandleTypeFlags = 0x00000010;
 220 
 221 pub const VkSharingMode = u32;
 222 pub const VK_SHARING_MODE_EXCLUSIVE: VkSharingMode = 0;
 223 pub const VK_SHARING_MODE_CONCURRENT: VkSharingMode = 1;
 224 
 225 pub const VkMemoryPropertyFlags = u32;
 226 pub const VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT: VkMemoryPropertyFlags = 0x00000001;
 227 pub const VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT: VkMemoryPropertyFlags = 0x00000002;
 228 pub const VK_MEMORY_PROPERTY_HOST_COHERENT_BIT: VkMemoryPropertyFlags = 0x00000004;
 229 pub const VK_MEMORY_PROPERTY_HOST_CACHED_BIT: VkMemoryPropertyFlags = 0x00000008;
 230 pub const VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT: VkMemoryPropertyFlags = 0x00000010;
 231 
 232 pub const VkDescriptorType = u32;
 233 pub const VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: VkDescriptorType = 1;
 234 pub const VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: VkDescriptorType = 6;
 235 pub const VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: VkDescriptorType = 7;
 236 
 237 pub const VkShaderStageFlags = u32;
 238 pub const VK_SHADER_STAGE_VERTEX_BIT: VkShaderStageFlags = 0x00000001;
 239 pub const VK_SHADER_STAGE_FRAGMENT_BIT: VkShaderStageFlags = 0x00000010;
 240 pub const VK_SHADER_STAGE_COMPUTE_BIT: VkShaderStageFlags = 0x00000020;
 241 pub const VK_SHADER_STAGE_ALL: VkShaderStageFlags = 0x7FFFFFFF;
 242 
 243 pub const VkSubgroupFeatureFlags = u32;
 244 pub const VK_SUBGROUP_FEATURE_BASIC_BIT: VkSubgroupFeatureFlags = 0x00000001;
 245 pub const VK_SUBGROUP_FEATURE_VOTE_BIT: VkSubgroupFeatureFlags = 0x00000002;
 246 pub const VK_SUBGROUP_FEATURE_ARITHMETIC_BIT: VkSubgroupFeatureFlags = 0x00000004;
 247 pub const VK_SUBGROUP_FEATURE_BALLOT_BIT: VkSubgroupFeatureFlags = 0x00000008;
 248 pub const VK_SUBGROUP_FEATURE_SHUFFLE_BIT: VkSubgroupFeatureFlags = 0x00000010;
 249 pub const VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT: VkSubgroupFeatureFlags = 0x00000020;
 250 
 251 pub const VkPipelineBindPoint = u32;
 252 pub const VK_PIPELINE_BIND_POINT_GRAPHICS: VkPipelineBindPoint = 0;
 253 pub const VK_PIPELINE_BIND_POINT_COMPUTE: VkPipelineBindPoint = 1;
 254 
 255 pub const VkDescriptorPoolCreateFlags = u32;
 256 pub const VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT: VkDescriptorPoolCreateFlags = 0x00000001;
 257 
 258 pub const VK_MAX_EXTENSION_NAME_SIZE: usize = 256;
 259 pub const VK_MAX_PHYSICAL_DEVICE_NAME_SIZE: usize = 256;
 260 pub const VK_UUID_SIZE: usize = 16;
 261 pub const VK_MAX_MEMORY_TYPES: usize = 32;
 262 pub const VK_MAX_MEMORY_HEAPS: usize = 16;
 263 
 264 pub const VK_WHOLE_TIMEOUT: u64 = std.math.maxInt(u64);
 265 
 266 pub const VK_WHOLE_SIZE: u64 = std.math.maxInt(u64);
 267 
 268 pub const VK_API_VERSION_1_0: u32 = (0 << 22) | (0 << 12) | 0;
 269 pub const VK_API_VERSION_1_1: u32 = (1 << 22) | (1 << 12) | 0;
 270 pub const VK_API_VERSION_1_2: u32 = (1 << 22) | (2 << 12) | 0;
 271 pub const VK_API_VERSION_1_3: u32 = (1 << 22) | (3 << 12) | 0;
 272 
 273 pub const VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME = "VK_KHR_timeline_semaphore";
 274 pub const VK_KHR_SURFACE_EXTENSION_NAME = "VK_KHR_surface";
 275 pub const VK_KHR_XLIB_SURFACE_EXTENSION_NAME = "VK_KHR_xlib_surface";
 276 pub const VK_KHR_SWAPCHAIN_EXTENSION_NAME = "VK_KHR_swapchain";
 277 pub const VK_KHR_16BIT_STORAGE_EXTENSION_NAME = "VK_KHR_16bit_storage";
 278 pub const VK_KHR_8BIT_STORAGE_EXTENSION_NAME = "VK_KHR_8bit_storage";
 279 pub const VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME = "VK_KHR_shader_float16_int8";
 280 pub const VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME = "VK_EXT_image_drm_format_modifier";
 281 pub const VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME = "VK_KHR_external_memory_fd";
 282 pub const VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME = "VK_EXT_external_memory_dma_buf";
 283 pub const VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME = "VK_KHR_external_semaphore_fd";
 284 pub const VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME = "VK_EXT_queue_family_foreign";
 285 pub const VK_EXT_PHYSICAL_DEVICE_DRM_EXTENSION_NAME = "VK_EXT_physical_device_drm";
 286 
 287 pub const VkFormat = u32;
 288 pub const VK_FORMAT_UNDEFINED: VkFormat = 0;
 289 pub const VK_FORMAT_R8G8B8A8_UNORM: VkFormat = 37;
 290 pub const VK_FORMAT_R8G8B8A8_SRGB: VkFormat = 43;
 291 pub const VK_FORMAT_B8G8R8A8_UNORM: VkFormat = 44;
 292 pub const VK_FORMAT_B8G8R8A8_SRGB: VkFormat = 50;
 293 pub const VK_FORMAT_R32_UINT: VkFormat = 98;
 294 pub const VK_FORMAT_R32_SFLOAT: VkFormat = 100;
 295 pub const VK_FORMAT_R32G32_UINT: VkFormat = 101;
 296 pub const VK_FORMAT_R32G32_SFLOAT: VkFormat = 103;
 297 pub const VK_FORMAT_R32G32B32_SFLOAT: VkFormat = 106;
 298 pub const VK_FORMAT_R32G32B32A32_UINT: VkFormat = 107;
 299 pub const VK_FORMAT_R32G32B32A32_SFLOAT: VkFormat = 109;
 300 pub const VK_FORMAT_D32_SFLOAT: VkFormat = 126;
 301 
 302 pub const VkFormatFeatureFlags = u32;
 303 pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT: VkFormatFeatureFlags = 0x00000001;
 304 pub const VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT: VkFormatFeatureFlags = 0x00000080;
 305 pub const VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT: VkFormatFeatureFlags = 0x00000100;
 306 pub const VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT: VkFormatFeatureFlags = 0x00000200;
 307 pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT: VkFormatFeatureFlags = 0x00001000;
 308 pub const VK_FORMAT_FEATURE_TRANSFER_SRC_BIT: VkFormatFeatureFlags = 0x00004000;
 309 pub const VK_FORMAT_FEATURE_TRANSFER_DST_BIT: VkFormatFeatureFlags = 0x00008000;
 310 
 311 pub const VkImageType = u32;
 312 pub const VK_IMAGE_TYPE_2D: VkImageType = 1;
 313 
 314 pub const VkImageViewType = u32;
 315 pub const VK_IMAGE_VIEW_TYPE_2D: VkImageViewType = 1;
 316 
 317 pub const VkImageTiling = u32;
 318 pub const VK_IMAGE_TILING_OPTIMAL: VkImageTiling = 0;
 319 pub const VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT: VkImageTiling = 1000158000;
 320 
 321 pub const VK_SAMPLE_COUNT_1_BIT: VkSampleCountFlags = 0x00000001;
 322 
 323 pub const VkComponentSwizzle = u32;
 324 pub const VK_COMPONENT_SWIZZLE_IDENTITY: VkComponentSwizzle = 0;
 325 
 326 pub const VkFilter = u32;
 327 pub const VK_FILTER_NEAREST: VkFilter = 0;
 328 pub const VK_FILTER_LINEAR: VkFilter = 1;
 329 
 330 pub const VkSamplerMipmapMode = u32;
 331 pub const VK_SAMPLER_MIPMAP_MODE_NEAREST: VkSamplerMipmapMode = 0;
 332 
 333 pub const VkSamplerAddressMode = u32;
 334 pub const VK_SAMPLER_ADDRESS_MODE_REPEAT: VkSamplerAddressMode = 0;
 335 pub const VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE: VkSamplerAddressMode = 2;
 336 
 337 pub const VkBorderColor = u32;
 338 pub const VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK: VkBorderColor = 0;
 339 
 340 pub const VkCompareOp = u32;
 341 pub const VK_COMPARE_OP_NEVER: VkCompareOp = 0;
 342 pub const VK_COMPARE_OP_LESS: VkCompareOp = 1;
 343 pub const VK_COMPARE_OP_EQUAL: VkCompareOp = 2;
 344 pub const VK_COMPARE_OP_LESS_OR_EQUAL: VkCompareOp = 3;
 345 pub const VK_COMPARE_OP_GREATER: VkCompareOp = 4;
 346 pub const VK_COMPARE_OP_NOT_EQUAL: VkCompareOp = 5;
 347 pub const VK_COMPARE_OP_GREATER_OR_EQUAL: VkCompareOp = 6;
 348 pub const VK_COMPARE_OP_ALWAYS: VkCompareOp = 7;
 349 
 350 pub const VkVertexInputRate = u32;
 351 pub const VK_VERTEX_INPUT_RATE_VERTEX: VkVertexInputRate = 0;
 352 pub const VK_VERTEX_INPUT_RATE_INSTANCE: VkVertexInputRate = 1;
 353 
 354 pub const VkPrimitiveTopology = u32;
 355 pub const VK_PRIMITIVE_TOPOLOGY_LINE_LIST: VkPrimitiveTopology = 1;
 356 pub const VK_PRIMITIVE_TOPOLOGY_LINE_STRIP: VkPrimitiveTopology = 2;
 357 pub const VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST: VkPrimitiveTopology = 3;
 358 pub const VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP: VkPrimitiveTopology = 4;
 359 
 360 pub const VkPolygonMode = u32;
 361 pub const VK_POLYGON_MODE_FILL: VkPolygonMode = 0;
 362 
 363 pub const VkCullModeFlags = u32;
 364 pub const VK_CULL_MODE_NONE: VkCullModeFlags = 0;
 365 
 366 pub const VkFrontFace = u32;
 367 pub const VK_FRONT_FACE_COUNTER_CLOCKWISE: VkFrontFace = 0;
 368 pub const VK_FRONT_FACE_CLOCKWISE: VkFrontFace = 1;
 369 
 370 pub const VkBlendFactor = u32;
 371 pub const VK_BLEND_FACTOR_ZERO: VkBlendFactor = 0;
 372 pub const VK_BLEND_FACTOR_ONE: VkBlendFactor = 1;
 373 pub const VK_BLEND_FACTOR_SRC_ALPHA: VkBlendFactor = 6;
 374 pub const VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA: VkBlendFactor = 7;
 375 
 376 pub const VkBlendOp = u32;
 377 pub const VK_BLEND_OP_ADD: VkBlendOp = 0;
 378 
 379 pub const VkColorComponentFlags = u32;
 380 pub const VK_COLOR_COMPONENT_R_BIT: VkColorComponentFlags = 0x00000001;
 381 pub const VK_COLOR_COMPONENT_G_BIT: VkColorComponentFlags = 0x00000002;
 382 pub const VK_COLOR_COMPONENT_B_BIT: VkColorComponentFlags = 0x00000004;
 383 pub const VK_COLOR_COMPONENT_A_BIT: VkColorComponentFlags = 0x00000008;
 384 
 385 pub const VkDynamicState = u32;
 386 pub const VK_DYNAMIC_STATE_VIEWPORT: VkDynamicState = 0;
 387 pub const VK_DYNAMIC_STATE_SCISSOR: VkDynamicState = 1;
 388 
 389 pub const VkAttachmentLoadOp = u32;
 390 pub const VK_ATTACHMENT_LOAD_OP_LOAD: VkAttachmentLoadOp = 0;
 391 pub const VK_ATTACHMENT_LOAD_OP_CLEAR: VkAttachmentLoadOp = 1;
 392 
 393 pub const VkAttachmentStoreOp = u32;
 394 pub const VK_ATTACHMENT_STORE_OP_STORE: VkAttachmentStoreOp = 0;
 395 
 396 pub const VkResolveModeFlags = u32;
 397 pub const VK_RESOLVE_MODE_NONE: VkResolveModeFlags = 0;
 398 
 399 pub const VkIndexType = u32;
 400 pub const VK_INDEX_TYPE_UINT16: VkIndexType = 0;
 401 pub const VK_INDEX_TYPE_UINT32: VkIndexType = 1;
 402 
 403 pub const VkColorSpaceKHR = u32;
 404 pub const VK_COLOR_SPACE_SRGB_NONLINEAR_KHR: VkColorSpaceKHR = 0;
 405 
 406 pub const VkPresentModeKHR = u32;
 407 pub const VK_PRESENT_MODE_IMMEDIATE_KHR: VkPresentModeKHR = 0;
 408 pub const VK_PRESENT_MODE_MAILBOX_KHR: VkPresentModeKHR = 1;
 409 pub const VK_PRESENT_MODE_FIFO_KHR: VkPresentModeKHR = 2;
 410 
 411 pub const VkSurfaceTransformFlagsKHR = u32;
 412 pub const VkSurfaceTransformFlagBitsKHR = u32;
 413 pub const VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR: VkSurfaceTransformFlagBitsKHR = 0x00000001;
 414 pub const VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR: VkSurfaceTransformFlagBitsKHR = 0x00000100;
 415 
 416 pub const VkCompositeAlphaFlagsKHR = u32;
 417 pub const VkCompositeAlphaFlagBitsKHR = u32;
 418 pub const VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR: VkCompositeAlphaFlagBitsKHR = 0x00000001;
 419 pub const VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR: VkCompositeAlphaFlagBitsKHR = 0x00000002;
 420 pub const VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR: VkCompositeAlphaFlagBitsKHR = 0x00000004;
 421 pub const VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR: VkCompositeAlphaFlagBitsKHR = 0x00000008;
 422 
 423 pub const VkResult = enum(c_int) {
 424     success = 0,
 425     not_ready = 1,
 426     timeout = 2,
 427     event_set = 3,
 428     event_reset = 4,
 429     incomplete = 5,
 430     suboptimal_khr = 1000001003,
 431     error_out_of_host_memory = -1,
 432     error_out_of_device_memory = -2,
 433     error_initialization_failed = -3,
 434     error_device_lost = -4,
 435     error_memory_map_failed = -5,
 436     error_layer_not_present = -6,
 437     error_extension_not_present = -7,
 438     error_feature_not_present = -8,
 439     error_incompatible_driver = -9,
 440     error_too_many_objects = -10,
 441     error_format_not_supported = -11,
 442     error_fragmented_pool = -12,
 443     error_unknown = -13,
 444     error_out_of_pool_memory = -1000069000,
 445     error_surface_lost_khr = -1000000000,
 446     error_native_window_in_use_khr = -1000000001,
 447     error_out_of_date_khr = -1000001004,
 448     _,
 449 };
 450 
 451 pub const Error = error{
 452     DriverUnavailable,
 453     SymbolMissing,
 454     TimelineSemaphoreUnavailable,
 455     DeviceLost,
 456     OutOfHostMemory,
 457     OutOfDeviceMemory,
 458     InitializationFailed,
 459     MemoryMapFailed,
 460     LayerNotPresent,
 461     ExtensionNotPresent,
 462     FeatureNotPresent,
 463     IncompatibleDriver,
 464     TooManyObjects,
 465     FormatNotSupported,
 466     FragmentedPool,
 467     OutOfPoolMemory,
 468     VulkanUnknown,
 469     SurfaceLost,
 470     SurfaceOutOfDate,
 471     NativeWindowInUse,
 472     NoDevice,
 473     InvalidDevice,
 474     StreamPoisoned,
 475 };
 476 
 477 pub const VkApplicationInfo = extern struct {
 478     sType: VkStructureType,
 479     pNext: ?*const anyopaque,
 480     pApplicationName: ?[*:0]const u8,
 481     applicationVersion: u32,
 482     pEngineName: ?[*:0]const u8,
 483     engineVersion: u32,
 484     apiVersion: u32,
 485 };
 486 
 487 pub const VkInstanceCreateInfo = extern struct {
 488     sType: VkStructureType,
 489     pNext: ?*const anyopaque,
 490     flags: u32,
 491     pApplicationInfo: ?*const VkApplicationInfo,
 492     enabledLayerCount: u32,
 493     ppEnabledLayerNames: ?[*]const [*:0]const u8,
 494     enabledExtensionCount: u32,
 495     ppEnabledExtensionNames: ?[*]const [*:0]const u8,
 496 };
 497 
 498 pub const VkDeviceQueueCreateInfo = extern struct {
 499     sType: VkStructureType,
 500     pNext: ?*const anyopaque,
 501     flags: u32,
 502     queueFamilyIndex: u32,
 503     queueCount: u32,
 504     pQueuePriorities: [*]const f32,
 505 };
 506 
 507 pub const VkDeviceCreateInfo = extern struct {
 508     sType: VkStructureType,
 509     pNext: ?*const anyopaque,
 510     flags: u32,
 511     queueCreateInfoCount: u32,
 512     pQueueCreateInfos: [*]const VkDeviceQueueCreateInfo,
 513     enabledLayerCount: u32,
 514     ppEnabledLayerNames: ?[*]const [*:0]const u8,
 515     enabledExtensionCount: u32,
 516     ppEnabledExtensionNames: ?[*]const [*:0]const u8,
 517     pEnabledFeatures: ?*const anyopaque,
 518 };
 519 
 520 pub const VkSemaphoreCreateInfo = extern struct {
 521     sType: VkStructureType,
 522     pNext: ?*const anyopaque,
 523     flags: u32,
 524 };
 525 
 526 pub const VkQueryPoolCreateInfo = extern struct {
 527     sType: VkStructureType,
 528     pNext: ?*const anyopaque,
 529     flags: u32,
 530     queryType: VkQueryType,
 531     queryCount: u32,
 532     pipelineStatistics: u32,
 533 };
 534 
 535 pub const VkSemaphoreTypeCreateInfo = extern struct {
 536     sType: VkStructureType,
 537     pNext: ?*const anyopaque,
 538     semaphoreType: VkSemaphoreType,
 539     initialValue: u64,
 540 };
 541 
 542 pub const VkSemaphoreWaitInfo = extern struct {
 543     sType: VkStructureType,
 544     pNext: ?*const anyopaque,
 545     flags: u32,
 546     semaphoreCount: u32,
 547     pSemaphores: [*]const VkSemaphore,
 548     pValues: [*]const u64,
 549 };
 550 
 551 pub const VkSemaphoreSignalInfo = extern struct {
 552     sType: VkStructureType,
 553     pNext: ?*const anyopaque,
 554     semaphore: VkSemaphore,
 555     value: u64,
 556 };
 557 
 558 pub const VkCommandPoolCreateInfo = extern struct {
 559     sType: VkStructureType,
 560     pNext: ?*const anyopaque,
 561     flags: VkCommandPoolCreateFlags,
 562     queueFamilyIndex: u32,
 563 };
 564 
 565 pub const VkCommandBufferAllocateInfo = extern struct {
 566     sType: VkStructureType,
 567     pNext: ?*const anyopaque,
 568     commandPool: VkCommandPool,
 569     level: VkCommandBufferLevel,
 570     commandBufferCount: u32,
 571 };
 572 
 573 pub const VkSemaphoreSubmitInfo = extern struct {
 574     sType: VkStructureType,
 575     pNext: ?*const anyopaque,
 576     semaphore: VkSemaphore,
 577     value: u64,
 578     stageMask: u64,
 579     deviceIndex: u32,
 580 };
 581 
 582 pub const VkCommandBufferSubmitInfo = extern struct {
 583     sType: VkStructureType,
 584     pNext: ?*const anyopaque,
 585     commandBuffer: VkCommandBuffer,
 586     deviceMask: u32,
 587 };
 588 
 589 pub const VkSubmitInfo2 = extern struct {
 590     sType: VkStructureType,
 591     pNext: ?*const anyopaque,
 592     flags: u32,
 593     waitSemaphoreInfoCount: u32,
 594     pWaitSemaphoreInfos: ?[*]const VkSemaphoreSubmitInfo,
 595     commandBufferInfoCount: u32,
 596     pCommandBufferInfos: ?[*]const VkCommandBufferSubmitInfo,
 597     signalSemaphoreInfoCount: u32,
 598     pSignalSemaphoreInfos: ?[*]const VkSemaphoreSubmitInfo,
 599 };
 600 
 601 pub const VkExtent3D = extern struct {
 602     width: u32,
 603     height: u32,
 604     depth: u32,
 605 };
 606 
 607 pub const VkOffset3D = extern struct {
 608     x: i32,
 609     y: i32,
 610     z: i32,
 611 };
 612 
 613 pub const VkExtent2D = extern struct {
 614     width: u32,
 615     height: u32,
 616 };
 617 
 618 pub const VkImageSubresourceRange = extern struct {
 619     aspectMask: VkImageAspectFlags,
 620     baseMipLevel: u32,
 621     levelCount: u32,
 622     baseArrayLayer: u32,
 623     layerCount: u32,
 624 };
 625 
 626 pub const VkImageSubresourceLayers = extern struct {
 627     aspectMask: VkImageAspectFlags,
 628     mipLevel: u32,
 629     baseArrayLayer: u32,
 630     layerCount: u32,
 631 };
 632 
 633 pub const VkMemoryBarrier = extern struct {
 634     sType: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_BARRIER,
 635     pNext: ?*const anyopaque = null,
 636     srcAccessMask: VkAccessFlags,
 637     dstAccessMask: VkAccessFlags,
 638 };
 639 
 640 pub const VkImageMemoryBarrier = extern struct {
 641     sType: VkStructureType,
 642     pNext: ?*const anyopaque,
 643     srcAccessMask: VkAccessFlags,
 644     dstAccessMask: VkAccessFlags,
 645     oldLayout: VkImageLayout,
 646     newLayout: VkImageLayout,
 647     srcQueueFamilyIndex: u32,
 648     dstQueueFamilyIndex: u32,
 649     image: VkImage,
 650     subresourceRange: VkImageSubresourceRange,
 651 };
 652 
 653 pub const VkBufferMemoryBarrier = extern struct {
 654     sType: VkStructureType,
 655     pNext: ?*const anyopaque,
 656     srcAccessMask: VkAccessFlags,
 657     dstAccessMask: VkAccessFlags,
 658     srcQueueFamilyIndex: u32,
 659     dstQueueFamilyIndex: u32,
 660     buffer: VkBuffer,
 661     offset: u64,
 662     size: u64,
 663 };
 664 
 665 pub const VkBufferCopy = extern struct {
 666     srcOffset: u64,
 667     dstOffset: u64,
 668     size: u64,
 669 };
 670 
 671 pub const VkBufferImageCopy = extern struct {
 672     bufferOffset: u64,
 673     bufferRowLength: u32,
 674     bufferImageHeight: u32,
 675     imageSubresource: VkImageSubresourceLayers,
 676     imageOffset: VkOffset3D,
 677     imageExtent: VkExtent3D,
 678 };
 679 
 680 pub const VkClearColorValue = extern union {
 681     float32: [4]f32,
 682     int32: [4]i32,
 683     uint32: [4]u32,
 684 };
 685 
 686 pub const VkSurfaceCapabilitiesKHR = extern struct {
 687     minImageCount: u32,
 688     maxImageCount: u32,
 689     currentExtent: VkExtent2D,
 690     minImageExtent: VkExtent2D,
 691     maxImageExtent: VkExtent2D,
 692     maxImageArrayLayers: u32,
 693     supportedTransforms: VkSurfaceTransformFlagsKHR,
 694     currentTransform: VkSurfaceTransformFlagBitsKHR,
 695     supportedCompositeAlpha: VkCompositeAlphaFlagsKHR,
 696     supportedUsageFlags: VkImageUsageFlags,
 697 };
 698 
 699 pub const VkSurfaceFormatKHR = extern struct {
 700     format: VkFormat,
 701     colorSpace: VkColorSpaceKHR,
 702 };
 703 
 704 pub const VkXlibSurfaceCreateInfoKHR = extern struct {
 705     sType: VkStructureType,
 706     pNext: ?*const anyopaque,
 707     flags: u32,
 708     dpy: VkDisplay,
 709     window: VkWindow,
 710 };
 711 
 712 pub const VkSwapchainCreateInfoKHR = extern struct {
 713     sType: VkStructureType,
 714     pNext: ?*const anyopaque,
 715     flags: u32,
 716     surface: VkSurfaceKHR,
 717     minImageCount: u32,
 718     imageFormat: VkFormat,
 719     imageColorSpace: VkColorSpaceKHR,
 720     imageExtent: VkExtent2D,
 721     imageArrayLayers: u32,
 722     imageUsage: VkImageUsageFlags,
 723     imageSharingMode: VkSharingMode,
 724     queueFamilyIndexCount: u32,
 725     pQueueFamilyIndices: ?[*]const u32,
 726     preTransform: VkSurfaceTransformFlagBitsKHR,
 727     compositeAlpha: VkCompositeAlphaFlagBitsKHR,
 728     presentMode: VkPresentModeKHR,
 729     clipped: VkBool32,
 730     oldSwapchain: VkSwapchainKHR,
 731 };
 732 
 733 pub const VkPresentInfoKHR = extern struct {
 734     sType: VkStructureType,
 735     pNext: ?*const anyopaque,
 736     waitSemaphoreCount: u32,
 737     pWaitSemaphores: ?[*]const VkSemaphore,
 738     swapchainCount: u32,
 739     pSwapchains: [*]const VkSwapchainKHR,
 740     pImageIndices: [*]const u32,
 741     pResults: ?[*]VkResult,
 742 };
 743 
 744 pub const VkQueueFamilyProperties = extern struct {
 745     queueFlags: VkQueueFlags,
 746     queueCount: u32,
 747     timestampValidBits: u32,
 748     minImageTransferGranularity: VkExtent3D,
 749 };
 750 
 751 pub const VkExtensionProperties = extern struct {
 752     extensionName: [VK_MAX_EXTENSION_NAME_SIZE]u8,
 753     specVersion: u32,
 754 
 755     pub fn name(self: *const VkExtensionProperties) []const u8 {
 756         return std.mem.sliceTo(self.extensionName[0..], 0);
 757     }
 758 };
 759 
 760 pub const VkPhysicalDeviceFeatures = extern struct {
 761     robustBufferAccess: VkBool32,
 762     fullDrawIndexUint32: VkBool32,
 763     imageCubeArray: VkBool32,
 764     independentBlend: VkBool32,
 765     geometryShader: VkBool32,
 766     tessellationShader: VkBool32,
 767     sampleRateShading: VkBool32,
 768     dualSrcBlend: VkBool32,
 769     logicOp: VkBool32,
 770     multiDrawIndirect: VkBool32,
 771     drawIndirectFirstInstance: VkBool32,
 772     depthClamp: VkBool32,
 773     depthBiasClamp: VkBool32,
 774     fillModeNonSolid: VkBool32,
 775     depthBounds: VkBool32,
 776     wideLines: VkBool32,
 777     largePoints: VkBool32,
 778     alphaToOne: VkBool32,
 779     multiViewport: VkBool32,
 780     samplerAnisotropy: VkBool32,
 781     textureCompressionETC2: VkBool32,
 782     textureCompressionASTC_LDR: VkBool32,
 783     textureCompressionBC: VkBool32,
 784     occlusionQueryPrecise: VkBool32,
 785     pipelineStatisticsQuery: VkBool32,
 786     vertexPipelineStoresAndAtomics: VkBool32,
 787     fragmentStoresAndAtomics: VkBool32,
 788     shaderTessellationAndGeometryPointSize: VkBool32,
 789     shaderImageGatherExtended: VkBool32,
 790     shaderStorageImageExtendedFormats: VkBool32,
 791     shaderStorageImageMultisample: VkBool32,
 792     shaderStorageImageReadWithoutFormat: VkBool32,
 793     shaderStorageImageWriteWithoutFormat: VkBool32,
 794     shaderUniformBufferArrayDynamicIndexing: VkBool32,
 795     shaderSampledImageArrayDynamicIndexing: VkBool32,
 796     shaderStorageBufferArrayDynamicIndexing: VkBool32,
 797     shaderStorageImageArrayDynamicIndexing: VkBool32,
 798     shaderClipDistance: VkBool32,
 799     shaderCullDistance: VkBool32,
 800     shaderFloat64: VkBool32,
 801     shaderInt64: VkBool32,
 802     shaderInt16: VkBool32,
 803     shaderResourceResidency: VkBool32,
 804     shaderResourceMinLod: VkBool32,
 805     sparseBinding: VkBool32,
 806     sparseResidencyBuffer: VkBool32,
 807     sparseResidencyImage2D: VkBool32,
 808     sparseResidencyImage3D: VkBool32,
 809     sparseResidency2Samples: VkBool32,
 810     sparseResidency4Samples: VkBool32,
 811     sparseResidency8Samples: VkBool32,
 812     sparseResidency16Samples: VkBool32,
 813     sparseResidencyAliased: VkBool32,
 814     variableMultisampleRate: VkBool32,
 815     inheritedQueries: VkBool32,
 816 };
 817 
 818 pub const VkPhysicalDeviceFeatures2 = extern struct {
 819     sType: VkStructureType,
 820     pNext: ?*anyopaque,
 821     features: VkPhysicalDeviceFeatures,
 822 };
 823 
 824 pub const VkPhysicalDevice16BitStorageFeatures = extern struct {
 825     sType: VkStructureType,
 826     pNext: ?*anyopaque,
 827     storageBuffer16BitAccess: VkBool32,
 828     uniformAndStorageBuffer16BitAccess: VkBool32,
 829     storagePushConstant16: VkBool32,
 830     storageInputOutput16: VkBool32,
 831 };
 832 
 833 pub const VkPhysicalDevice8BitStorageFeatures = extern struct {
 834     sType: VkStructureType,
 835     pNext: ?*anyopaque,
 836     storageBuffer8BitAccess: VkBool32,
 837     uniformAndStorageBuffer8BitAccess: VkBool32,
 838     storagePushConstant8: VkBool32,
 839 };
 840 
 841 pub const VkPhysicalDeviceTimelineSemaphoreFeatures = extern struct {
 842     sType: VkStructureType,
 843     pNext: ?*anyopaque,
 844     timelineSemaphore: VkBool32,
 845 };
 846 
 847 pub const VkSampleCountFlags = u32;
 848 
 849 pub const VkPhysicalDeviceLimits = extern struct {
 850     maxImageDimension1D: u32,
 851     maxImageDimension2D: u32,
 852     maxImageDimension3D: u32,
 853     maxImageDimensionCube: u32,
 854     maxImageArrayLayers: u32,
 855     maxTexelBufferElements: u32,
 856     maxUniformBufferRange: u32,
 857     maxStorageBufferRange: u32,
 858     maxPushConstantsSize: u32,
 859     maxMemoryAllocationCount: u32,
 860     maxSamplerAllocationCount: u32,
 861     bufferImageGranularity: u64,
 862     sparseAddressSpaceSize: u64,
 863     maxBoundDescriptorSets: u32,
 864     maxPerStageDescriptorSamplers: u32,
 865     maxPerStageDescriptorUniformBuffers: u32,
 866     maxPerStageDescriptorStorageBuffers: u32,
 867     maxPerStageDescriptorSampledImages: u32,
 868     maxPerStageDescriptorStorageImages: u32,
 869     maxPerStageDescriptorInputAttachments: u32,
 870     maxPerStageResources: u32,
 871     maxDescriptorSetSamplers: u32,
 872     maxDescriptorSetUniformBuffers: u32,
 873     maxDescriptorSetUniformBuffersDynamic: u32,
 874     maxDescriptorSetStorageBuffers: u32,
 875     maxDescriptorSetStorageBuffersDynamic: u32,
 876     maxDescriptorSetSampledImages: u32,
 877     maxDescriptorSetStorageImages: u32,
 878     maxDescriptorSetInputAttachments: u32,
 879     maxVertexInputAttributes: u32,
 880     maxVertexInputBindings: u32,
 881     maxVertexInputAttributeOffset: u32,
 882     maxVertexInputBindingStride: u32,
 883     maxVertexOutputComponents: u32,
 884     maxTessellationGenerationLevel: u32,
 885     maxTessellationPatchSize: u32,
 886     maxTessellationControlPerVertexInputComponents: u32,
 887     maxTessellationControlPerVertexOutputComponents: u32,
 888     maxTessellationControlPerPatchOutputComponents: u32,
 889     maxTessellationControlTotalOutputComponents: u32,
 890     maxTessellationEvaluationInputComponents: u32,
 891     maxTessellationEvaluationOutputComponents: u32,
 892     maxGeometryShaderInvocations: u32,
 893     maxGeometryInputComponents: u32,
 894     maxGeometryOutputComponents: u32,
 895     maxGeometryOutputVertices: u32,
 896     maxGeometryTotalOutputComponents: u32,
 897     maxFragmentInputComponents: u32,
 898     maxFragmentOutputAttachments: u32,
 899     maxFragmentDualSrcAttachments: u32,
 900     maxFragmentCombinedOutputResources: u32,
 901     maxComputeSharedMemorySize: u32,
 902     maxComputeWorkGroupCount: [3]u32,
 903     maxComputeWorkGroupInvocations: u32,
 904     maxComputeWorkGroupSize: [3]u32,
 905     subPixelPrecisionBits: u32,
 906     subTexelPrecisionBits: u32,
 907     mipmapPrecisionBits: u32,
 908     maxDrawIndexedIndexValue: u32,
 909     maxDrawIndirectCount: u32,
 910     maxSamplerLodBias: f32,
 911     maxSamplerAnisotropy: f32,
 912     maxViewports: u32,
 913     maxViewportDimensions: [2]u32,
 914     viewportBoundsRange: [2]f32,
 915     viewportSubPixelBits: u32,
 916     minMemoryMapAlignment: usize,
 917     minTexelBufferOffsetAlignment: u64,
 918     minUniformBufferOffsetAlignment: u64,
 919     minStorageBufferOffsetAlignment: u64,
 920     minTexelOffset: i32,
 921     maxTexelOffset: u32,
 922     minTexelGatherOffset: i32,
 923     maxTexelGatherOffset: u32,
 924     minInterpolationOffset: f32,
 925     maxInterpolationOffset: f32,
 926     subPixelInterpolationOffsetBits: u32,
 927     maxFramebufferWidth: u32,
 928     maxFramebufferHeight: u32,
 929     maxFramebufferLayers: u32,
 930     framebufferColorSampleCounts: VkSampleCountFlags,
 931     framebufferDepthSampleCounts: VkSampleCountFlags,
 932     framebufferStencilSampleCounts: VkSampleCountFlags,
 933     framebufferNoAttachmentsSampleCounts: VkSampleCountFlags,
 934     maxColorAttachments: u32,
 935     sampledImageColorSampleCounts: VkSampleCountFlags,
 936     sampledImageIntegerSampleCounts: VkSampleCountFlags,
 937     sampledImageDepthSampleCounts: VkSampleCountFlags,
 938     sampledImageStencilSampleCounts: VkSampleCountFlags,
 939     storageImageSampleCounts: VkSampleCountFlags,
 940     maxSampleMaskWords: u32,
 941     timestampComputeAndGraphics: VkBool32,
 942     timestampPeriod: f32,
 943     maxClipDistances: u32,
 944     maxCullDistances: u32,
 945     maxCombinedClipAndCullDistances: u32,
 946     discreteQueuePriorities: u32,
 947     pointSizeRange: [2]f32,
 948     lineWidthRange: [2]f32,
 949     pointSizeGranularity: f32,
 950     lineWidthGranularity: f32,
 951     strictLines: VkBool32,
 952     standardSampleLocations: VkBool32,
 953     optimalBufferCopyOffsetAlignment: u64,
 954     optimalBufferCopyRowPitchAlignment: u64,
 955     nonCoherentAtomSize: u64,
 956 };
 957 
 958 pub const VkPhysicalDeviceSparseProperties = extern struct {
 959     residencyStandard2DBlockShape: VkBool32,
 960     residencyStandard2DMultisampleBlockShape: VkBool32,
 961     residencyStandard3DBlockShape: VkBool32,
 962     residencyAlignedMipSize: VkBool32,
 963     residencyNonResidentStrict: VkBool32,
 964 };
 965 
 966 pub const VkPhysicalDeviceProperties = extern struct {
 967     apiVersion: u32,
 968     driverVersion: u32,
 969     vendorID: u32,
 970     deviceID: u32,
 971     deviceType: u32,
 972     deviceName: [VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]u8,
 973     pipelineCacheUUID: [VK_UUID_SIZE]u8,
 974     limits: VkPhysicalDeviceLimits,
 975     sparseProperties: VkPhysicalDeviceSparseProperties,
 976 };
 977 
 978 pub const VkPhysicalDeviceProperties2 = extern struct {
 979     sType: VkStructureType,
 980     pNext: ?*anyopaque,
 981     properties: VkPhysicalDeviceProperties,
 982 };
 983 
 984 pub const VkPhysicalDeviceSubgroupProperties = extern struct {
 985     sType: VkStructureType,
 986     pNext: ?*anyopaque,
 987     subgroupSize: u32,
 988     supportedStages: VkShaderStageFlags,
 989     supportedOperations: VkSubgroupFeatureFlags,
 990     quadOperationsInAllStages: VkBool32,
 991 };
 992 
 993 pub const VkMemoryType = extern struct {
 994     propertyFlags: VkMemoryPropertyFlags,
 995     heapIndex: u32,
 996 };
 997 
 998 pub const VkMemoryHeap = extern struct {
 999     size: u64,
1000     flags: u32,
1001     _pad: u32 = 0,
1002 };
1003 
1004 pub const VkPhysicalDeviceMemoryProperties = extern struct {
1005     memoryTypeCount: u32,
1006     memoryTypes: [VK_MAX_MEMORY_TYPES]VkMemoryType,
1007     memoryHeapCount: u32,
1008     memoryHeaps: [VK_MAX_MEMORY_HEAPS]VkMemoryHeap align(8),
1009 };
1010 
1011 pub const VkMemoryRequirements = extern struct {
1012     size: u64,
1013     alignment: u64,
1014     memoryTypeBits: u32,
1015     _pad: u32 = 0,
1016 };
1017 
1018 pub const VkMemoryAllocateInfo = extern struct {
1019     sType: VkStructureType,
1020     pNext: ?*const anyopaque,
1021     allocationSize: u64,
1022     memoryTypeIndex: u32,
1023     _pad: u32 = 0,
1024 };
1025 
1026 pub const VkMappedMemoryRange = extern struct {
1027     sType: VkStructureType,
1028     pNext: ?*const anyopaque,
1029     memory: VkDeviceMemory,
1030     offset: u64,
1031     size: u64,
1032 };
1033 
1034 pub const VkBufferCreateInfo = extern struct {
1035     sType: VkStructureType,
1036     pNext: ?*const anyopaque,
1037     flags: u32,
1038     _pad_flags: u32 = 0,
1039     size: u64,
1040     usage: VkBufferUsageFlags,
1041     sharingMode: VkSharingMode,
1042     queueFamilyIndexCount: u32,
1043     _pad_qfi: u32 = 0,
1044     pQueueFamilyIndices: ?[*]const u32,
1045 };
1046 
1047 pub const VkShaderModuleCreateInfo = extern struct {
1048     sType: VkStructureType,
1049     pNext: ?*const anyopaque,
1050     flags: u32,
1051     _pad: u32 = 0,
1052     codeSize: usize,
1053     pCode: [*]const u32,
1054 };
1055 
1056 pub const VkPushConstantRange = extern struct {
1057     stageFlags: VkShaderStageFlags,
1058     offset: u32,
1059     size: u32,
1060 };
1061 
1062 pub const VkPipelineLayoutCreateInfo = extern struct {
1063     sType: VkStructureType,
1064     pNext: ?*const anyopaque,
1065     flags: u32,
1066     setLayoutCount: u32,
1067     pSetLayouts: ?[*]const VkDescriptorSetLayout,
1068     pushConstantRangeCount: u32,
1069     _pad_pcrc: u32 = 0,
1070     pPushConstantRanges: ?[*]const VkPushConstantRange,
1071 };
1072 
1073 pub const VkDescriptorSetLayoutBinding = extern struct {
1074     binding: u32,
1075     descriptorType: VkDescriptorType,
1076     descriptorCount: u32,
1077     stageFlags: VkShaderStageFlags,
1078     pImmutableSamplers: ?*const anyopaque,
1079 };
1080 
1081 pub const VkDescriptorSetLayoutCreateInfo = extern struct {
1082     sType: VkStructureType,
1083     pNext: ?*const anyopaque,
1084     flags: u32,
1085     bindingCount: u32,
1086     pBindings: ?[*]const VkDescriptorSetLayoutBinding,
1087 };
1088 
1089 pub const VkSpecializationMapEntry = extern struct {
1090     constantID: u32,
1091     offset: u32,
1092     size: usize,
1093 };
1094 
1095 pub const VkSpecializationInfo = extern struct {
1096     mapEntryCount: u32,
1097     _pad: u32 = 0,
1098     pMapEntries: ?[*]const VkSpecializationMapEntry,
1099     dataSize: usize,
1100     pData: ?*const anyopaque,
1101 };
1102 
1103 pub const VkPipelineShaderStageCreateInfo = extern struct {
1104     sType: VkStructureType,
1105     pNext: ?*const anyopaque,
1106     flags: u32,
1107     stage: VkShaderStageFlags,
1108     module: VkShaderModule,
1109     pName: [*:0]const u8,
1110     pSpecializationInfo: ?*const VkSpecializationInfo,
1111 };
1112 
1113 pub const VkComputePipelineCreateInfo = extern struct {
1114     sType: VkStructureType,
1115     pNext: ?*const anyopaque,
1116     flags: u32,
1117     _pad_flags: u32 = 0,
1118     stage: VkPipelineShaderStageCreateInfo,
1119     layout: VkPipelineLayout,
1120     basePipelineHandle: VkPipeline,
1121     basePipelineIndex: i32,
1122     _pad_bpi: u32 = 0,
1123 };
1124 
1125 pub const VkDescriptorPoolSize = extern struct {
1126     type: VkDescriptorType,
1127     descriptorCount: u32,
1128 };
1129 
1130 pub const VkDescriptorPoolCreateInfo = extern struct {
1131     sType: VkStructureType,
1132     pNext: ?*const anyopaque,
1133     flags: VkDescriptorPoolCreateFlags,
1134     maxSets: u32,
1135     poolSizeCount: u32,
1136     _pad_psc: u32 = 0,
1137     pPoolSizes: ?[*]const VkDescriptorPoolSize,
1138 };
1139 
1140 pub const VkDescriptorSetAllocateInfo = extern struct {
1141     sType: VkStructureType,
1142     pNext: ?*const anyopaque,
1143     descriptorPool: VkDescriptorPool,
1144     descriptorSetCount: u32,
1145     _pad_dsc: u32 = 0,
1146     pSetLayouts: ?[*]const VkDescriptorSetLayout,
1147 };
1148 
1149 pub const VkDescriptorBufferInfo = extern struct {
1150     buffer: VkBuffer,
1151     offset: u64,
1152     range: u64,
1153 };
1154 
1155 pub const VkWriteDescriptorSet = extern struct {
1156     sType: VkStructureType,
1157     pNext: ?*const anyopaque,
1158     dstSet: VkDescriptorSet,
1159     dstBinding: u32,
1160     dstArrayElement: u32,
1161     descriptorCount: u32,
1162     descriptorType: VkDescriptorType,
1163     pImageInfo: ?*const anyopaque,
1164     pBufferInfo: ?[*]const VkDescriptorBufferInfo,
1165     pTexelBufferView: ?*const anyopaque,
1166 };
1167 
1168 pub const VkCommandBufferBeginInfo = extern struct {
1169     sType: VkStructureType,
1170     pNext: ?*const anyopaque,
1171     flags: VkCommandBufferUsageFlags,
1172     _pad: u32 = 0,
1173     pInheritanceInfo: ?*const anyopaque,
1174 };
1175 
1176 pub const VkPhysicalDeviceVulkan13Features = extern struct {
1177     sType: VkStructureType,
1178     pNext: ?*anyopaque,
1179     robustImageAccess: VkBool32 = VK_FALSE,
1180     inlineUniformBlock: VkBool32 = VK_FALSE,
1181     descriptorBindingInlineUniformBlockUpdateAfterBind: VkBool32 = VK_FALSE,
1182     pipelineCreationCacheControl: VkBool32 = VK_FALSE,
1183     privateData: VkBool32 = VK_FALSE,
1184     shaderDemoteToHelperInvocation: VkBool32 = VK_FALSE,
1185     shaderTerminateInvocation: VkBool32 = VK_FALSE,
1186     subgroupSizeControl: VkBool32 = VK_FALSE,
1187     computeFullSubgroups: VkBool32 = VK_FALSE,
1188     synchronization2: VkBool32 = VK_FALSE,
1189     textureCompressionASTC_HDR: VkBool32 = VK_FALSE,
1190     shaderZeroInitializeWorkgroupMemory: VkBool32 = VK_FALSE,
1191     dynamicRendering: VkBool32 = VK_FALSE,
1192     shaderIntegerDotProduct: VkBool32 = VK_FALSE,
1193     maintenance4: VkBool32 = VK_FALSE,
1194 };
1195 
1196 pub const VkFormatProperties = extern struct {
1197     linearTilingFeatures: VkFormatFeatureFlags,
1198     optimalTilingFeatures: VkFormatFeatureFlags,
1199     bufferFeatures: VkFormatFeatureFlags,
1200 };
1201 
1202 pub const VkFormatProperties2 = extern struct {
1203     sType: VkStructureType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2,
1204     pNext: ?*anyopaque = null,
1205     formatProperties: VkFormatProperties = std.mem.zeroes(VkFormatProperties),
1206 };
1207 
1208 pub const VkDrmFormatModifierPropertiesEXT = extern struct {
1209     drmFormatModifier: u64,
1210     drmFormatModifierPlaneCount: u32,
1211     drmFormatModifierTilingFeatures: VkFormatFeatureFlags,
1212 };
1213 
1214 pub const VkDrmFormatModifierPropertiesListEXT = extern struct {
1215     sType: VkStructureType = VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT,
1216     pNext: ?*anyopaque = null,
1217     drmFormatModifierCount: u32 = 0,
1218     pDrmFormatModifierProperties: ?[*]VkDrmFormatModifierPropertiesEXT = null,
1219 };
1220 
1221 pub const VkImageDrmFormatModifierListCreateInfoEXT = extern struct {
1222     sType: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT,
1223     pNext: ?*const anyopaque = null,
1224     drmFormatModifierCount: u32,
1225     pDrmFormatModifiers: [*]const u64,
1226 };
1227 
1228 pub const VkImageDrmFormatModifierPropertiesEXT = extern struct {
1229     sType: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT,
1230     pNext: ?*anyopaque = null,
1231     drmFormatModifier: u64 = 0,
1232 };
1233 
1234 pub const VkExternalMemoryImageCreateInfo = extern struct {
1235     sType: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
1236     pNext: ?*const anyopaque = null,
1237     handleTypes: VkExternalMemoryHandleTypeFlags,
1238 };
1239 
1240 pub const VkExportMemoryAllocateInfo = extern struct {
1241     sType: VkStructureType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO,
1242     pNext: ?*const anyopaque = null,
1243     handleTypes: VkExternalMemoryHandleTypeFlags,
1244 };
1245 
1246 pub const VkMemoryDedicatedAllocateInfo = extern struct {
1247     sType: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
1248     pNext: ?*const anyopaque = null,
1249     image: VkImage,
1250     buffer: VkBuffer = null,
1251 };
1252 
1253 pub const VkMemoryGetFdInfoKHR = extern struct {
1254     sType: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR,
1255     pNext: ?*const anyopaque = null,
1256     memory: VkDeviceMemory,
1257     handleType: VkExternalMemoryHandleTypeFlags,
1258 };
1259 
1260 pub const VkExportSemaphoreCreateInfo = extern struct {
1261     sType: VkStructureType = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO,
1262     pNext: ?*const anyopaque = null,
1263     handleTypes: VkExternalSemaphoreHandleTypeFlags,
1264 };
1265 
1266 pub const VkSemaphoreGetFdInfoKHR = extern struct {
1267     sType: VkStructureType = VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR,
1268     pNext: ?*const anyopaque = null,
1269     semaphore: VkSemaphore,
1270     handleType: VkExternalSemaphoreHandleTypeFlags,
1271 };
1272 
1273 pub const VkPhysicalDeviceDrmPropertiesEXT = extern struct {
1274     sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT,
1275     pNext: ?*anyopaque = null,
1276     hasPrimary: VkBool32 = VK_FALSE,
1277     hasRender: VkBool32 = VK_FALSE,
1278     primaryMajor: i64 = 0,
1279     primaryMinor: i64 = 0,
1280     renderMajor: i64 = 0,
1281     renderMinor: i64 = 0,
1282 };
1283 
1284 pub const VkImageSubresource = extern struct {
1285     aspectMask: VkImageAspectFlags,
1286     mipLevel: u32 = 0,
1287     arrayLayer: u32 = 0,
1288 };
1289 
1290 pub const VkSubresourceLayout = extern struct {
1291     offset: u64 = 0,
1292     size: u64 = 0,
1293     rowPitch: u64 = 0,
1294     arrayPitch: u64 = 0,
1295     depthPitch: u64 = 0,
1296 };
1297 
1298 pub const VkImageCreateInfo = extern struct {
1299     sType: VkStructureType,
1300     pNext: ?*const anyopaque,
1301     flags: u32,
1302     imageType: VkImageType,
1303     format: VkFormat,
1304     extent: VkExtent3D,
1305     mipLevels: u32,
1306     arrayLayers: u32,
1307     samples: VkSampleCountFlags,
1308     tiling: VkImageTiling,
1309     usage: VkImageUsageFlags,
1310     sharingMode: VkSharingMode,
1311     queueFamilyIndexCount: u32,
1312     pQueueFamilyIndices: ?[*]const u32,
1313     initialLayout: VkImageLayout,
1314 };
1315 
1316 pub const VkComponentMapping = extern struct {
1317     r: VkComponentSwizzle = VK_COMPONENT_SWIZZLE_IDENTITY,
1318     g: VkComponentSwizzle = VK_COMPONENT_SWIZZLE_IDENTITY,
1319     b: VkComponentSwizzle = VK_COMPONENT_SWIZZLE_IDENTITY,
1320     a: VkComponentSwizzle = VK_COMPONENT_SWIZZLE_IDENTITY,
1321 };
1322 
1323 pub const VkImageViewCreateInfo = extern struct {
1324     sType: VkStructureType,
1325     pNext: ?*const anyopaque,
1326     flags: u32,
1327     image: VkImage,
1328     viewType: VkImageViewType,
1329     format: VkFormat,
1330     components: VkComponentMapping,
1331     subresourceRange: VkImageSubresourceRange,
1332 };
1333 
1334 pub const VkSamplerCreateInfo = extern struct {
1335     sType: VkStructureType,
1336     pNext: ?*const anyopaque,
1337     flags: u32,
1338     magFilter: VkFilter,
1339     minFilter: VkFilter,
1340     mipmapMode: VkSamplerMipmapMode,
1341     addressModeU: VkSamplerAddressMode,
1342     addressModeV: VkSamplerAddressMode,
1343     addressModeW: VkSamplerAddressMode,
1344     mipLodBias: f32,
1345     anisotropyEnable: VkBool32,
1346     maxAnisotropy: f32,
1347     compareEnable: VkBool32,
1348     compareOp: VkCompareOp,
1349     minLod: f32,
1350     maxLod: f32,
1351     borderColor: VkBorderColor,
1352     unnormalizedCoordinates: VkBool32,
1353 };
1354 
1355 pub const VkDescriptorImageInfo = extern struct {
1356     sampler: VkSampler,
1357     imageView: VkImageView,
1358     imageLayout: VkImageLayout,
1359 };
1360 
1361 pub const VkVertexInputBindingDescription = extern struct {
1362     binding: u32,
1363     stride: u32,
1364     inputRate: VkVertexInputRate,
1365 };
1366 
1367 pub const VkVertexInputAttributeDescription = extern struct {
1368     location: u32,
1369     binding: u32,
1370     format: VkFormat,
1371     offset: u32,
1372 };
1373 
1374 pub const VkPipelineVertexInputStateCreateInfo = extern struct {
1375     sType: VkStructureType,
1376     pNext: ?*const anyopaque,
1377     flags: u32,
1378     vertexBindingDescriptionCount: u32,
1379     pVertexBindingDescriptions: ?[*]const VkVertexInputBindingDescription,
1380     vertexAttributeDescriptionCount: u32,
1381     pVertexAttributeDescriptions: ?[*]const VkVertexInputAttributeDescription,
1382 };
1383 
1384 pub const VkPipelineInputAssemblyStateCreateInfo = extern struct {
1385     sType: VkStructureType,
1386     pNext: ?*const anyopaque,
1387     flags: u32,
1388     topology: VkPrimitiveTopology,
1389     primitiveRestartEnable: VkBool32,
1390 };
1391 
1392 pub const VkViewport = extern struct {
1393     x: f32,
1394     y: f32,
1395     width: f32,
1396     height: f32,
1397     minDepth: f32,
1398     maxDepth: f32,
1399 };
1400 
1401 pub const VkOffset2D = extern struct {
1402     x: i32,
1403     y: i32,
1404 };
1405 
1406 pub const VkRect2D = extern struct {
1407     offset: VkOffset2D,
1408     extent: VkExtent2D,
1409 };
1410 
1411 pub const VkPipelineViewportStateCreateInfo = extern struct {
1412     sType: VkStructureType,
1413     pNext: ?*const anyopaque,
1414     flags: u32,
1415     viewportCount: u32,
1416     pViewports: ?[*]const VkViewport,
1417     scissorCount: u32,
1418     pScissors: ?[*]const VkRect2D,
1419 };
1420 
1421 pub const VkPipelineRasterizationStateCreateInfo = extern struct {
1422     sType: VkStructureType,
1423     pNext: ?*const anyopaque,
1424     flags: u32,
1425     depthClampEnable: VkBool32,
1426     rasterizerDiscardEnable: VkBool32,
1427     polygonMode: VkPolygonMode,
1428     cullMode: VkCullModeFlags,
1429     frontFace: VkFrontFace,
1430     depthBiasEnable: VkBool32,
1431     depthBiasConstantFactor: f32,
1432     depthBiasClamp: f32,
1433     depthBiasSlopeFactor: f32,
1434     lineWidth: f32,
1435 };
1436 
1437 pub const VkPipelineMultisampleStateCreateInfo = extern struct {
1438     sType: VkStructureType,
1439     pNext: ?*const anyopaque,
1440     flags: u32,
1441     rasterizationSamples: VkSampleCountFlags,
1442     sampleShadingEnable: VkBool32,
1443     minSampleShading: f32,
1444     pSampleMask: ?[*]const u32,
1445     alphaToCoverageEnable: VkBool32,
1446     alphaToOneEnable: VkBool32,
1447 };
1448 
1449 pub const VkStencilOpState = extern struct {
1450     failOp: u32 = 0,
1451     passOp: u32 = 0,
1452     depthFailOp: u32 = 0,
1453     compareOp: VkCompareOp = VK_COMPARE_OP_NEVER,
1454     compareMask: u32 = 0,
1455     writeMask: u32 = 0,
1456     reference: u32 = 0,
1457 };
1458 
1459 pub const VkPipelineDepthStencilStateCreateInfo = extern struct {
1460     sType: VkStructureType,
1461     pNext: ?*const anyopaque,
1462     flags: u32,
1463     depthTestEnable: VkBool32,
1464     depthWriteEnable: VkBool32,
1465     depthCompareOp: VkCompareOp,
1466     depthBoundsTestEnable: VkBool32,
1467     stencilTestEnable: VkBool32,
1468     front: VkStencilOpState,
1469     back: VkStencilOpState,
1470     minDepthBounds: f32,
1471     maxDepthBounds: f32,
1472 };
1473 
1474 pub const VkPipelineColorBlendAttachmentState = extern struct {
1475     blendEnable: VkBool32,
1476     srcColorBlendFactor: VkBlendFactor,
1477     dstColorBlendFactor: VkBlendFactor,
1478     colorBlendOp: VkBlendOp,
1479     srcAlphaBlendFactor: VkBlendFactor,
1480     dstAlphaBlendFactor: VkBlendFactor,
1481     alphaBlendOp: VkBlendOp,
1482     colorWriteMask: VkColorComponentFlags,
1483 };
1484 
1485 pub const VkPipelineColorBlendStateCreateInfo = extern struct {
1486     sType: VkStructureType,
1487     pNext: ?*const anyopaque,
1488     flags: u32,
1489     logicOpEnable: VkBool32,
1490     logicOp: u32,
1491     attachmentCount: u32,
1492     pAttachments: ?[*]const VkPipelineColorBlendAttachmentState,
1493     blendConstants: [4]f32,
1494 };
1495 
1496 pub const VkPipelineDynamicStateCreateInfo = extern struct {
1497     sType: VkStructureType,
1498     pNext: ?*const anyopaque,
1499     flags: u32,
1500     dynamicStateCount: u32,
1501     pDynamicStates: ?[*]const VkDynamicState,
1502 };
1503 
1504 pub const VkPipelineRenderingCreateInfo = extern struct {
1505     sType: VkStructureType,
1506     pNext: ?*const anyopaque,
1507     viewMask: u32,
1508     colorAttachmentCount: u32,
1509     pColorAttachmentFormats: ?[*]const VkFormat,
1510     depthAttachmentFormat: VkFormat,
1511     stencilAttachmentFormat: VkFormat,
1512 };
1513 
1514 pub const VkGraphicsPipelineCreateInfo = extern struct {
1515     sType: VkStructureType,
1516     pNext: ?*const anyopaque,
1517     flags: u32,
1518     stageCount: u32,
1519     pStages: [*]const VkPipelineShaderStageCreateInfo,
1520     pVertexInputState: ?*const VkPipelineVertexInputStateCreateInfo,
1521     pInputAssemblyState: ?*const VkPipelineInputAssemblyStateCreateInfo,
1522     pTessellationState: ?*const anyopaque,
1523     pViewportState: ?*const VkPipelineViewportStateCreateInfo,
1524     pRasterizationState: ?*const VkPipelineRasterizationStateCreateInfo,
1525     pMultisampleState: ?*const VkPipelineMultisampleStateCreateInfo,
1526     pDepthStencilState: ?*const VkPipelineDepthStencilStateCreateInfo,
1527     pColorBlendState: ?*const VkPipelineColorBlendStateCreateInfo,
1528     pDynamicState: ?*const VkPipelineDynamicStateCreateInfo,
1529     layout: VkPipelineLayout,
1530     renderPass: VkRenderPass,
1531     subpass: u32,
1532     basePipelineHandle: VkPipeline,
1533     basePipelineIndex: i32,
1534 };
1535 
1536 pub const VkClearDepthStencilValue = extern struct {
1537     depth: f32,
1538     stencil: u32,
1539 };
1540 
1541 pub const VkClearValue = extern union {
1542     color: VkClearColorValue,
1543     depthStencil: VkClearDepthStencilValue,
1544 };
1545 
1546 pub const VkRenderingAttachmentInfo = extern struct {
1547     sType: VkStructureType,
1548     pNext: ?*const anyopaque,
1549     imageView: VkImageView,
1550     imageLayout: VkImageLayout,
1551     resolveMode: VkResolveModeFlags,
1552     resolveImageView: VkImageView,
1553     resolveImageLayout: VkImageLayout,
1554     loadOp: VkAttachmentLoadOp,
1555     storeOp: VkAttachmentStoreOp,
1556     clearValue: VkClearValue,
1557 };
1558 
1559 pub const VkRenderingInfo = extern struct {
1560     sType: VkStructureType,
1561     pNext: ?*const anyopaque,
1562     flags: u32,
1563     renderArea: VkRect2D,
1564     layerCount: u32,
1565     viewMask: u32,
1566     colorAttachmentCount: u32,
1567     pColorAttachments: ?[*]const VkRenderingAttachmentInfo,
1568     pDepthAttachment: ?*const VkRenderingAttachmentInfo,
1569     pStencilAttachment: ?*const VkRenderingAttachmentInfo,
1570 };
1571 
1572 pub fn platformSupported() bool {
1573     return dynamic.hasHostCandidate(dynamic.vulkanLoaderCandidates());
1574 }
1575 
1576 fn openLoaderLibrary() Error!dynamic.Library {
1577     return dynamic.openVulkanLoader() catch return error.DriverUnavailable;
1578 }
1579 
1580 const ResultDiagnostic = enum {
1581     none,
1582     unexpected_positive,
1583     unmapped,
1584 };
1585 
1586 fn resultDiagnostic(r: VkResult) ResultDiagnostic {
1587     return switch (r) {
1588         .success,
1589         .error_out_of_host_memory,
1590         .error_out_of_device_memory,
1591         .error_initialization_failed,
1592         .error_device_lost,
1593         .error_memory_map_failed,
1594         .error_layer_not_present,
1595         .error_extension_not_present,
1596         .error_feature_not_present,
1597         .error_incompatible_driver,
1598         .error_too_many_objects,
1599         .error_format_not_supported,
1600         .error_fragmented_pool,
1601         .error_unknown,
1602         .error_out_of_pool_memory,
1603         .error_surface_lost_khr,
1604         .error_native_window_in_use_khr,
1605         .error_out_of_date_khr,
1606         .suboptimal_khr,
1607         => .none,
1608         .not_ready,
1609         .timeout,
1610         .event_set,
1611         .event_reset,
1612         .incomplete,
1613         => .unexpected_positive,
1614         _ => .unmapped,
1615     };
1616 }
1617 
1618 fn mapResultQuiet(r: VkResult) Error!void {
1619     if (r == .success) return;
1620 
1621     return switch (r) {
1622         .success => unreachable,
1623         .error_out_of_host_memory => Error.OutOfHostMemory,
1624         .error_out_of_device_memory => Error.OutOfDeviceMemory,
1625         .error_initialization_failed => Error.InitializationFailed,
1626         .error_device_lost => Error.DeviceLost,
1627         .error_memory_map_failed => Error.MemoryMapFailed,
1628         .error_layer_not_present => Error.LayerNotPresent,
1629         .error_extension_not_present => Error.ExtensionNotPresent,
1630         .error_feature_not_present => Error.FeatureNotPresent,
1631         .error_incompatible_driver => Error.IncompatibleDriver,
1632         .error_too_many_objects => Error.TooManyObjects,
1633         .error_format_not_supported => Error.FormatNotSupported,
1634         .error_fragmented_pool => Error.FragmentedPool,
1635         .error_out_of_pool_memory => Error.OutOfPoolMemory,
1636         .error_unknown => Error.VulkanUnknown,
1637         .error_surface_lost_khr => Error.SurfaceLost,
1638         .error_native_window_in_use_khr => Error.NativeWindowInUse,
1639         .error_out_of_date_khr, .suboptimal_khr => Error.SurfaceOutOfDate,
1640         .not_ready, .timeout, .event_set, .event_reset, .incomplete => Error.VulkanUnknown,
1641         _ => Error.VulkanUnknown,
1642     };
1643 }
1644 
1645 pub const Driver = struct {
1646     lib: dynamic.Library,
1647 
1648     vkGetInstanceProcAddr: *const fn (instance: VkInstance, pName: [*:0]const u8) callconv(.c) PFN_vkVoidFunction,
1649     vkCreateInstance: *const fn (pCreateInfo: *const VkInstanceCreateInfo, pAllocator: ?*const anyopaque, pInstance: *VkInstance) callconv(.c) VkResult,
1650 
1651     vkDestroyInstance: *const fn (instance: VkInstance, pAllocator: ?*const anyopaque) callconv(.c) void,
1652     vkEnumeratePhysicalDevices: *const fn (instance: VkInstance, pCount: *u32, pDevices: ?[*]VkPhysicalDevice) callconv(.c) VkResult,
1653     vkGetPhysicalDeviceProperties: *const fn (physicalDevice: VkPhysicalDevice, pProperties: *VkPhysicalDeviceProperties) callconv(.c) void,
1654     vkGetPhysicalDeviceProperties2: *const fn (physicalDevice: VkPhysicalDevice, pProperties: *VkPhysicalDeviceProperties2) callconv(.c) void,
1655     vkGetPhysicalDeviceFeatures2: *const fn (physicalDevice: VkPhysicalDevice, pFeatures: *VkPhysicalDeviceFeatures2) callconv(.c) void,
1656     vkEnumerateDeviceExtensionProperties: *const fn (physicalDevice: VkPhysicalDevice, pLayerName: ?[*:0]const u8, pCount: *u32, pProperties: ?[*]VkExtensionProperties) callconv(.c) VkResult,
1657     vkGetPhysicalDeviceQueueFamilyProperties: *const fn (physicalDevice: VkPhysicalDevice, pCount: *u32, pProperties: ?[*]VkQueueFamilyProperties) callconv(.c) void,
1658     vkGetPhysicalDeviceMemoryProperties: *const fn (physicalDevice: VkPhysicalDevice, pMemoryProperties: *VkPhysicalDeviceMemoryProperties) callconv(.c) void,
1659     vkGetPhysicalDeviceFormatProperties: *const fn (physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: *VkFormatProperties) callconv(.c) void,
1660     vkCreateXlibSurfaceKHR: *const fn (instance: VkInstance, pCreateInfo: *const VkXlibSurfaceCreateInfoKHR, pAllocator: ?*const anyopaque, pSurface: *VkSurfaceKHR) callconv(.c) VkResult,
1661     vkDestroySurfaceKHR: *const fn (instance: VkInstance, surface: VkSurfaceKHR, pAllocator: ?*const anyopaque) callconv(.c) void,
1662     vkGetPhysicalDeviceSurfaceSupportKHR: *const fn (physicalDevice: VkPhysicalDevice, queueFamilyIndex: u32, surface: VkSurfaceKHR, pSupported: *VkBool32) callconv(.c) VkResult,
1663     vkGetPhysicalDeviceSurfaceCapabilitiesKHR: *const fn (physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceCapabilities: *VkSurfaceCapabilitiesKHR) callconv(.c) VkResult,
1664     vkGetPhysicalDeviceSurfaceFormatsKHR: *const fn (physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceFormatCount: *u32, pSurfaceFormats: ?[*]VkSurfaceFormatKHR) callconv(.c) VkResult,
1665     vkGetPhysicalDeviceSurfacePresentModesKHR: *const fn (physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pPresentModeCount: *u32, pPresentModes: ?[*]VkPresentModeKHR) callconv(.c) VkResult,
1666     vkCreateDevice: *const fn (physicalDevice: VkPhysicalDevice, pCreateInfo: *const VkDeviceCreateInfo, pAllocator: ?*const anyopaque, pDevice: *VkDevice) callconv(.c) VkResult,
1667     vkGetDeviceProcAddr: *const fn (device: VkDevice, pName: [*:0]const u8) callconv(.c) PFN_vkVoidFunction,
1668 
1669     vkDestroyDevice: *const fn (device: VkDevice, pAllocator: ?*const anyopaque) callconv(.c) void,
1670     vkGetDeviceQueue: *const fn (device: VkDevice, queueFamilyIndex: u32, queueIndex: u32, pQueue: *VkQueue) callconv(.c) void,
1671     vkCreateCommandPool: *const fn (device: VkDevice, pCreateInfo: *const VkCommandPoolCreateInfo, pAllocator: ?*const anyopaque, pCommandPool: *VkCommandPool) callconv(.c) VkResult,
1672     vkDestroyCommandPool: *const fn (device: VkDevice, commandPool: VkCommandPool, pAllocator: ?*const anyopaque) callconv(.c) void,
1673     vkAllocateCommandBuffers: *const fn (device: VkDevice, pAllocateInfo: *const VkCommandBufferAllocateInfo, pCommandBuffers: [*]VkCommandBuffer) callconv(.c) VkResult,
1674     vkFreeCommandBuffers: *const fn (device: VkDevice, commandPool: VkCommandPool, commandBufferCount: u32, pCommandBuffers: [*]const VkCommandBuffer) callconv(.c) void,
1675     vkCreateSemaphore: *const fn (device: VkDevice, pCreateInfo: *const VkSemaphoreCreateInfo, pAllocator: ?*const anyopaque, pSemaphore: *VkSemaphore) callconv(.c) VkResult,
1676     vkDestroySemaphore: *const fn (device: VkDevice, semaphore: VkSemaphore, pAllocator: ?*const anyopaque) callconv(.c) void,
1677     vkCreateQueryPool: *const fn (device: VkDevice, pCreateInfo: *const VkQueryPoolCreateInfo, pAllocator: ?*const anyopaque, pQueryPool: *VkQueryPool) callconv(.c) VkResult,
1678     vkDestroyQueryPool: *const fn (device: VkDevice, queryPool: VkQueryPool, pAllocator: ?*const anyopaque) callconv(.c) void,
1679     vkGetQueryPoolResults: *const fn (device: VkDevice, queryPool: VkQueryPool, firstQuery: u32, queryCount: u32, dataSize: usize, pData: *anyopaque, stride: u64, flags: VkQueryResultFlags) callconv(.c) VkResult,
1680     vkGetSemaphoreCounterValue: *const fn (device: VkDevice, semaphore: VkSemaphore, pValue: *u64) callconv(.c) VkResult,
1681     vkWaitSemaphores: *const fn (device: VkDevice, pWaitInfo: *const VkSemaphoreWaitInfo, timeout: u64) callconv(.c) VkResult,
1682     vkSignalSemaphore: *const fn (device: VkDevice, pSignalInfo: *const VkSemaphoreSignalInfo) callconv(.c) VkResult,
1683     vkQueueSubmit2: *const fn (queue: VkQueue, submitCount: u32, pSubmits: ?[*]const VkSubmitInfo2, fence: VkFence) callconv(.c) VkResult,
1684     vkDeviceWaitIdle: *const fn (device: VkDevice) callconv(.c) VkResult,
1685     vkCreateSwapchainKHR: *const fn (device: VkDevice, pCreateInfo: *const VkSwapchainCreateInfoKHR, pAllocator: ?*const anyopaque, pSwapchain: *VkSwapchainKHR) callconv(.c) VkResult,
1686     vkDestroySwapchainKHR: *const fn (device: VkDevice, swapchain: VkSwapchainKHR, pAllocator: ?*const anyopaque) callconv(.c) void,
1687     vkGetSwapchainImagesKHR: *const fn (device: VkDevice, swapchain: VkSwapchainKHR, pSwapchainImageCount: *u32, pSwapchainImages: ?[*]VkImage) callconv(.c) VkResult,
1688     vkAcquireNextImageKHR: *const fn (device: VkDevice, swapchain: VkSwapchainKHR, timeout: u64, semaphore: VkSemaphore, fence: VkFence, pImageIndex: *u32) callconv(.c) VkResult,
1689     vkQueuePresentKHR: *const fn (queue: VkQueue, pPresentInfo: *const VkPresentInfoKHR) callconv(.c) VkResult,
1690 
1691     vkCreateShaderModule: *const fn (device: VkDevice, pCreateInfo: *const VkShaderModuleCreateInfo, pAllocator: ?*const anyopaque, pShaderModule: *VkShaderModule) callconv(.c) VkResult,
1692     vkDestroyShaderModule: *const fn (device: VkDevice, shaderModule: VkShaderModule, pAllocator: ?*const anyopaque) callconv(.c) void,
1693     vkCreatePipelineLayout: *const fn (device: VkDevice, pCreateInfo: *const VkPipelineLayoutCreateInfo, pAllocator: ?*const anyopaque, pPipelineLayout: *VkPipelineLayout) callconv(.c) VkResult,
1694     vkDestroyPipelineLayout: *const fn (device: VkDevice, pipelineLayout: VkPipelineLayout, pAllocator: ?*const anyopaque) callconv(.c) void,
1695     vkCreateDescriptorSetLayout: *const fn (device: VkDevice, pCreateInfo: *const VkDescriptorSetLayoutCreateInfo, pAllocator: ?*const anyopaque, pSetLayout: *VkDescriptorSetLayout) callconv(.c) VkResult,
1696     vkDestroyDescriptorSetLayout: *const fn (device: VkDevice, descriptorSetLayout: VkDescriptorSetLayout, pAllocator: ?*const anyopaque) callconv(.c) void,
1697     vkCreateComputePipelines: *const fn (device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: u32, pCreateInfos: [*]const VkComputePipelineCreateInfo, pAllocator: ?*const anyopaque, pPipelines: [*]VkPipeline) callconv(.c) VkResult,
1698     vkDestroyPipeline: *const fn (device: VkDevice, pipeline: VkPipeline, pAllocator: ?*const anyopaque) callconv(.c) void,
1699     vkCreateDescriptorPool: *const fn (device: VkDevice, pCreateInfo: *const VkDescriptorPoolCreateInfo, pAllocator: ?*const anyopaque, pDescriptorPool: *VkDescriptorPool) callconv(.c) VkResult,
1700     vkDestroyDescriptorPool: *const fn (device: VkDevice, descriptorPool: VkDescriptorPool, pAllocator: ?*const anyopaque) callconv(.c) void,
1701     vkResetDescriptorPool: *const fn (device: VkDevice, descriptorPool: VkDescriptorPool, flags: VkDescriptorPoolResetFlags) callconv(.c) VkResult,
1702     vkAllocateDescriptorSets: *const fn (device: VkDevice, pAllocateInfo: *const VkDescriptorSetAllocateInfo, pDescriptorSets: [*]VkDescriptorSet) callconv(.c) VkResult,
1703     vkFreeDescriptorSets: *const fn (device: VkDevice, descriptorPool: VkDescriptorPool, descriptorSetCount: u32, pDescriptorSets: [*]const VkDescriptorSet) callconv(.c) VkResult,
1704     vkUpdateDescriptorSets: *const fn (device: VkDevice, descriptorWriteCount: u32, pDescriptorWrites: [*]const VkWriteDescriptorSet, descriptorCopyCount: u32, pDescriptorCopies: ?*const anyopaque) callconv(.c) void,
1705     vkCmdBindPipeline: *const fn (commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline) callconv(.c) void,
1706     vkCmdBindDescriptorSets: *const fn (commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, firstSet: u32, descriptorSetCount: u32, pDescriptorSets: [*]const VkDescriptorSet, dynamicOffsetCount: u32, pDynamicOffsets: ?[*]const u32) callconv(.c) void,
1707     vkCmdDispatch: *const fn (commandBuffer: VkCommandBuffer, groupCountX: u32, groupCountY: u32, groupCountZ: u32) callconv(.c) void,
1708     vkCmdPipelineBarrier: *const fn (commandBuffer: VkCommandBuffer, srcStageMask: VkPipelineStageFlags, dstStageMask: VkPipelineStageFlags, dependencyFlags: VkDependencyFlags, memoryBarrierCount: u32, pMemoryBarriers: ?*const anyopaque, bufferMemoryBarrierCount: u32, pBufferMemoryBarriers: ?[*]const VkBufferMemoryBarrier, imageMemoryBarrierCount: u32, pImageMemoryBarriers: ?[*]const VkImageMemoryBarrier) callconv(.c) void,
1709     vkCmdClearColorImage: *const fn (commandBuffer: VkCommandBuffer, image: VkImage, imageLayout: VkImageLayout, pColor: *const VkClearColorValue, rangeCount: u32, pRanges: [*]const VkImageSubresourceRange) callconv(.c) void,
1710     vkCmdCopyBuffer: *const fn (commandBuffer: VkCommandBuffer, srcBuffer: VkBuffer, dstBuffer: VkBuffer, regionCount: u32, pRegions: [*]const VkBufferCopy) callconv(.c) void,
1711     vkCmdCopyBufferToImage: *const fn (commandBuffer: VkCommandBuffer, srcBuffer: VkBuffer, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: u32, pRegions: [*]const VkBufferImageCopy) callconv(.c) void,
1712     vkCmdResetQueryPool: *const fn (commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, firstQuery: u32, queryCount: u32) callconv(.c) void,
1713     vkCmdWriteTimestamp: *const fn (commandBuffer: VkCommandBuffer, pipelineStage: VkPipelineStageFlags, queryPool: VkQueryPool, query: u32) callconv(.c) void,
1714     vkCmdPushConstants: *const fn (commandBuffer: VkCommandBuffer, layout: VkPipelineLayout, stageFlags: VkShaderStageFlags, offset: u32, size: u32, pValues: *const anyopaque) callconv(.c) void,
1715     vkBeginCommandBuffer: *const fn (commandBuffer: VkCommandBuffer, pBeginInfo: *const VkCommandBufferBeginInfo) callconv(.c) VkResult,
1716     vkEndCommandBuffer: *const fn (commandBuffer: VkCommandBuffer) callconv(.c) VkResult,
1717     vkResetCommandBuffer: *const fn (commandBuffer: VkCommandBuffer, flags: u32) callconv(.c) VkResult,
1718     vkAllocateMemory: *const fn (device: VkDevice, pAllocateInfo: *const VkMemoryAllocateInfo, pAllocator: ?*const anyopaque, pMemory: *VkDeviceMemory) callconv(.c) VkResult,
1719     vkFreeMemory: *const fn (device: VkDevice, memory: VkDeviceMemory, pAllocator: ?*const anyopaque) callconv(.c) void,
1720     vkBindBufferMemory: *const fn (device: VkDevice, buffer: VkBuffer, memory: VkDeviceMemory, memoryOffset: u64) callconv(.c) VkResult,
1721     vkCreateBuffer: *const fn (device: VkDevice, pCreateInfo: *const VkBufferCreateInfo, pAllocator: ?*const anyopaque, pBuffer: *VkBuffer) callconv(.c) VkResult,
1722     vkDestroyBuffer: *const fn (device: VkDevice, buffer: VkBuffer, pAllocator: ?*const anyopaque) callconv(.c) void,
1723     vkMapMemory: *const fn (device: VkDevice, memory: VkDeviceMemory, offset: u64, size: u64, flags: u32, ppData: *?*anyopaque) callconv(.c) VkResult,
1724     vkUnmapMemory: *const fn (device: VkDevice, memory: VkDeviceMemory) callconv(.c) void,
1725     vkGetBufferMemoryRequirements: *const fn (device: VkDevice, buffer: VkBuffer, pMemoryRequirements: *VkMemoryRequirements) callconv(.c) void,
1726     vkFlushMappedMemoryRanges: *const fn (device: VkDevice, memoryRangeCount: u32, pMemoryRanges: [*]const VkMappedMemoryRange) callconv(.c) VkResult,
1727     vkInvalidateMappedMemoryRanges: *const fn (device: VkDevice, memoryRangeCount: u32, pMemoryRanges: [*]const VkMappedMemoryRange) callconv(.c) VkResult,
1728     vkCreateImage: *const fn (device: VkDevice, pCreateInfo: *const VkImageCreateInfo, pAllocator: ?*const anyopaque, pImage: *VkImage) callconv(.c) VkResult,
1729     vkDestroyImage: *const fn (device: VkDevice, image: VkImage, pAllocator: ?*const anyopaque) callconv(.c) void,
1730     vkGetImageMemoryRequirements: *const fn (device: VkDevice, image: VkImage, pMemoryRequirements: *VkMemoryRequirements) callconv(.c) void,
1731     vkBindImageMemory: *const fn (device: VkDevice, image: VkImage, memory: VkDeviceMemory, memoryOffset: u64) callconv(.c) VkResult,
1732     vkCreateImageView: *const fn (device: VkDevice, pCreateInfo: *const VkImageViewCreateInfo, pAllocator: ?*const anyopaque, pView: *VkImageView) callconv(.c) VkResult,
1733     vkDestroyImageView: *const fn (device: VkDevice, imageView: VkImageView, pAllocator: ?*const anyopaque) callconv(.c) void,
1734     vkCreateSampler: *const fn (device: VkDevice, pCreateInfo: *const VkSamplerCreateInfo, pAllocator: ?*const anyopaque, pSampler: *VkSampler) callconv(.c) VkResult,
1735     vkDestroySampler: *const fn (device: VkDevice, sampler: VkSampler, pAllocator: ?*const anyopaque) callconv(.c) void,
1736     vkCreateGraphicsPipelines: *const fn (device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: u32, pCreateInfos: [*]const VkGraphicsPipelineCreateInfo, pAllocator: ?*const anyopaque, pPipelines: [*]VkPipeline) callconv(.c) VkResult,
1737     vkCmdBeginRendering: *const fn (commandBuffer: VkCommandBuffer, pRenderingInfo: *const VkRenderingInfo) callconv(.c) void,
1738     vkCmdEndRendering: *const fn (commandBuffer: VkCommandBuffer) callconv(.c) void,
1739     vkCmdBindVertexBuffers: *const fn (commandBuffer: VkCommandBuffer, firstBinding: u32, bindingCount: u32, pBuffers: [*]const VkBuffer, pOffsets: [*]const u64) callconv(.c) void,
1740     vkCmdBindIndexBuffer: *const fn (commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: u64, indexType: VkIndexType) callconv(.c) void,
1741     vkCmdDraw: *const fn (commandBuffer: VkCommandBuffer, vertexCount: u32, instanceCount: u32, firstVertex: u32, firstInstance: u32) callconv(.c) void,
1742     vkCmdDrawIndexed: *const fn (commandBuffer: VkCommandBuffer, indexCount: u32, instanceCount: u32, firstIndex: u32, vertexOffset: i32, firstInstance: u32) callconv(.c) void,
1743     vkCmdSetViewport: *const fn (commandBuffer: VkCommandBuffer, firstViewport: u32, viewportCount: u32, pViewports: [*]const VkViewport) callconv(.c) void,
1744     vkCmdSetScissor: *const fn (commandBuffer: VkCommandBuffer, firstScissor: u32, scissorCount: u32, pScissors: [*]const VkRect2D) callconv(.c) void,
1745     vkCmdCopyImageToBuffer: *const fn (commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstBuffer: VkBuffer, regionCount: u32, pRegions: [*]const VkBufferImageCopy) callconv(.c) void,
1746     vkGetPhysicalDeviceFormatProperties2: *const fn (physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: *VkFormatProperties2) callconv(.c) void,
1747     vkGetImageSubresourceLayout: *const fn (device: VkDevice, image: VkImage, pSubresource: *const VkImageSubresource, pLayout: *VkSubresourceLayout) callconv(.c) void,
1748     /// Loaded by `loadDmabufFunctions`, once the device enables the extensions that define them.
1749     vkGetImageDrmFormatModifierPropertiesEXT: ?*const fn (device: VkDevice, image: VkImage, pProperties: *VkImageDrmFormatModifierPropertiesEXT) callconv(.c) VkResult = null,
1750     vkGetMemoryFdKHR: ?*const fn (device: VkDevice, pGetFdInfo: *const VkMemoryGetFdInfoKHR, pFd: *c_int) callconv(.c) VkResult = null,
1751     vkGetSemaphoreFdKHR: ?*const fn (device: VkDevice, pGetFdInfo: *const VkSemaphoreGetFdInfoKHR, pFd: *c_int) callconv(.c) VkResult = null,
1752 
1753     pub fn open(allocator: std.mem.Allocator) Error!Driver {
1754         _ = allocator;
1755 
1756         var lib = try openLoaderLibrary();
1757         errdefer lib.close();
1758 
1759         var driver: Driver = undefined;
1760         driver.lib = lib;
1761 
1762         const gipa = lib.lookup(@TypeOf(driver.vkGetInstanceProcAddr), "vkGetInstanceProcAddr") orelse {
1763             log.err("vulkan symbol missing from loader: vkGetInstanceProcAddr", .{});
1764             return error.SymbolMissing;
1765         };
1766         driver.vkGetInstanceProcAddr = gipa;
1767 
1768         driver.vkCreateInstance = try lookupGlobal(
1769             &driver,
1770             @TypeOf(driver.vkCreateInstance),
1771             "vkCreateInstance",
1772         );
1773 
1774         return driver;
1775     }
1776 
1777     fn lookupGlobal(self: *Driver, comptime T: type, comptime name: [:0]const u8) Error!T {
1778         const raw = self.vkGetInstanceProcAddr(null, name.ptr) orelse {
1779             log.err("vulkan global symbol missing: {s}", .{name});
1780             return error.SymbolMissing;
1781         };
1782         return @ptrCast(@alignCast(raw));
1783     }
1784 
1785     fn lookupInstance(self: *Driver, instance: VkInstance, comptime T: type, comptime name: [:0]const u8) Error!T {
1786         const raw = self.vkGetInstanceProcAddr(instance, name.ptr) orelse {
1787             log.err("vulkan instance symbol missing: {s}", .{name});
1788             return error.SymbolMissing;
1789         };
1790         return @ptrCast(@alignCast(raw));
1791     }
1792 
1793     fn lookupDevice(self: *Driver, device: VkDevice, comptime T: type, comptime name: [:0]const u8) Error!T {
1794         const raw = self.vkGetDeviceProcAddr(device, name.ptr) orelse {
1795             log.err("vulkan device symbol missing: {s}", .{name});
1796             return error.SymbolMissing;
1797         };
1798         return @ptrCast(@alignCast(raw));
1799     }
1800 
1801     pub fn loadInstanceFunctions(self: *Driver, instance: VkInstance) Error!void {
1802         self.vkDestroyInstance = try self.lookupInstance(instance, @TypeOf(self.vkDestroyInstance), "vkDestroyInstance");
1803         self.vkEnumeratePhysicalDevices = try self.lookupInstance(instance, @TypeOf(self.vkEnumeratePhysicalDevices), "vkEnumeratePhysicalDevices");
1804         self.vkGetPhysicalDeviceProperties = try self.lookupInstance(instance, @TypeOf(self.vkGetPhysicalDeviceProperties), "vkGetPhysicalDeviceProperties");
1805         self.vkGetPhysicalDeviceProperties2 = try self.lookupInstance(instance, @TypeOf(self.vkGetPhysicalDeviceProperties2), "vkGetPhysicalDeviceProperties2");
1806         self.vkGetPhysicalDeviceFeatures2 = try self.lookupInstance(instance, @TypeOf(self.vkGetPhysicalDeviceFeatures2), "vkGetPhysicalDeviceFeatures2");
1807         self.vkEnumerateDeviceExtensionProperties = try self.lookupInstance(instance, @TypeOf(self.vkEnumerateDeviceExtensionProperties), "vkEnumerateDeviceExtensionProperties");
1808         self.vkGetPhysicalDeviceQueueFamilyProperties = try self.lookupInstance(instance, @TypeOf(self.vkGetPhysicalDeviceQueueFamilyProperties), "vkGetPhysicalDeviceQueueFamilyProperties");
1809         self.vkGetPhysicalDeviceMemoryProperties = try self.lookupInstance(instance, @TypeOf(self.vkGetPhysicalDeviceMemoryProperties), "vkGetPhysicalDeviceMemoryProperties");
1810         self.vkGetPhysicalDeviceFormatProperties = try self.lookupInstance(instance, @TypeOf(self.vkGetPhysicalDeviceFormatProperties), "vkGetPhysicalDeviceFormatProperties");
1811         self.vkGetPhysicalDeviceFormatProperties2 = try self.lookupInstance(instance, @TypeOf(self.vkGetPhysicalDeviceFormatProperties2), "vkGetPhysicalDeviceFormatProperties2");
1812         self.vkCreateXlibSurfaceKHR = try self.lookupInstance(instance, @TypeOf(self.vkCreateXlibSurfaceKHR), "vkCreateXlibSurfaceKHR");
1813         self.vkDestroySurfaceKHR = try self.lookupInstance(instance, @TypeOf(self.vkDestroySurfaceKHR), "vkDestroySurfaceKHR");
1814         self.vkGetPhysicalDeviceSurfaceSupportKHR = try self.lookupInstance(instance, @TypeOf(self.vkGetPhysicalDeviceSurfaceSupportKHR), "vkGetPhysicalDeviceSurfaceSupportKHR");
1815         self.vkGetPhysicalDeviceSurfaceCapabilitiesKHR = try self.lookupInstance(instance, @TypeOf(self.vkGetPhysicalDeviceSurfaceCapabilitiesKHR), "vkGetPhysicalDeviceSurfaceCapabilitiesKHR");
1816         self.vkGetPhysicalDeviceSurfaceFormatsKHR = try self.lookupInstance(instance, @TypeOf(self.vkGetPhysicalDeviceSurfaceFormatsKHR), "vkGetPhysicalDeviceSurfaceFormatsKHR");
1817         self.vkGetPhysicalDeviceSurfacePresentModesKHR = try self.lookupInstance(instance, @TypeOf(self.vkGetPhysicalDeviceSurfacePresentModesKHR), "vkGetPhysicalDeviceSurfacePresentModesKHR");
1818         self.vkCreateDevice = try self.lookupInstance(instance, @TypeOf(self.vkCreateDevice), "vkCreateDevice");
1819         self.vkGetDeviceProcAddr = try self.lookupInstance(instance, @TypeOf(self.vkGetDeviceProcAddr), "vkGetDeviceProcAddr");
1820     }
1821 
1822     pub fn loadDeviceFunctions(self: *Driver, device: VkDevice) Error!void {
1823         self.vkDestroyDevice = try self.lookupDevice(device, @TypeOf(self.vkDestroyDevice), "vkDestroyDevice");
1824         self.vkGetDeviceQueue = try self.lookupDevice(device, @TypeOf(self.vkGetDeviceQueue), "vkGetDeviceQueue");
1825         self.vkCreateCommandPool = try self.lookupDevice(device, @TypeOf(self.vkCreateCommandPool), "vkCreateCommandPool");
1826         self.vkDestroyCommandPool = try self.lookupDevice(device, @TypeOf(self.vkDestroyCommandPool), "vkDestroyCommandPool");
1827         self.vkAllocateCommandBuffers = try self.lookupDevice(device, @TypeOf(self.vkAllocateCommandBuffers), "vkAllocateCommandBuffers");
1828         self.vkFreeCommandBuffers = try self.lookupDevice(device, @TypeOf(self.vkFreeCommandBuffers), "vkFreeCommandBuffers");
1829         self.vkCreateSemaphore = try self.lookupDevice(device, @TypeOf(self.vkCreateSemaphore), "vkCreateSemaphore");
1830         self.vkDestroySemaphore = try self.lookupDevice(device, @TypeOf(self.vkDestroySemaphore), "vkDestroySemaphore");
1831         self.vkCreateQueryPool = try self.lookupDevice(device, @TypeOf(self.vkCreateQueryPool), "vkCreateQueryPool");
1832         self.vkDestroyQueryPool = try self.lookupDevice(device, @TypeOf(self.vkDestroyQueryPool), "vkDestroyQueryPool");
1833         self.vkGetQueryPoolResults = try self.lookupDevice(device, @TypeOf(self.vkGetQueryPoolResults), "vkGetQueryPoolResults");
1834         self.vkGetSemaphoreCounterValue = try self.lookupDevice(device, @TypeOf(self.vkGetSemaphoreCounterValue), "vkGetSemaphoreCounterValue");
1835         self.vkWaitSemaphores = try self.lookupDevice(device, @TypeOf(self.vkWaitSemaphores), "vkWaitSemaphores");
1836         self.vkSignalSemaphore = try self.lookupDevice(device, @TypeOf(self.vkSignalSemaphore), "vkSignalSemaphore");
1837         self.vkQueueSubmit2 = try self.lookupDevice(device, @TypeOf(self.vkQueueSubmit2), "vkQueueSubmit2");
1838         self.vkDeviceWaitIdle = try self.lookupDevice(device, @TypeOf(self.vkDeviceWaitIdle), "vkDeviceWaitIdle");
1839         self.vkCreateSwapchainKHR = try self.lookupDevice(device, @TypeOf(self.vkCreateSwapchainKHR), "vkCreateSwapchainKHR");
1840         self.vkDestroySwapchainKHR = try self.lookupDevice(device, @TypeOf(self.vkDestroySwapchainKHR), "vkDestroySwapchainKHR");
1841         self.vkGetSwapchainImagesKHR = try self.lookupDevice(device, @TypeOf(self.vkGetSwapchainImagesKHR), "vkGetSwapchainImagesKHR");
1842         self.vkAcquireNextImageKHR = try self.lookupDevice(device, @TypeOf(self.vkAcquireNextImageKHR), "vkAcquireNextImageKHR");
1843         self.vkQueuePresentKHR = try self.lookupDevice(device, @TypeOf(self.vkQueuePresentKHR), "vkQueuePresentKHR");
1844 
1845         self.vkCreateShaderModule = try self.lookupDevice(device, @TypeOf(self.vkCreateShaderModule), "vkCreateShaderModule");
1846         self.vkDestroyShaderModule = try self.lookupDevice(device, @TypeOf(self.vkDestroyShaderModule), "vkDestroyShaderModule");
1847         self.vkCreatePipelineLayout = try self.lookupDevice(device, @TypeOf(self.vkCreatePipelineLayout), "vkCreatePipelineLayout");
1848         self.vkDestroyPipelineLayout = try self.lookupDevice(device, @TypeOf(self.vkDestroyPipelineLayout), "vkDestroyPipelineLayout");
1849         self.vkCreateDescriptorSetLayout = try self.lookupDevice(device, @TypeOf(self.vkCreateDescriptorSetLayout), "vkCreateDescriptorSetLayout");
1850         self.vkDestroyDescriptorSetLayout = try self.lookupDevice(device, @TypeOf(self.vkDestroyDescriptorSetLayout), "vkDestroyDescriptorSetLayout");
1851         self.vkCreateComputePipelines = try self.lookupDevice(device, @TypeOf(self.vkCreateComputePipelines), "vkCreateComputePipelines");
1852         self.vkDestroyPipeline = try self.lookupDevice(device, @TypeOf(self.vkDestroyPipeline), "vkDestroyPipeline");
1853         self.vkCreateDescriptorPool = try self.lookupDevice(device, @TypeOf(self.vkCreateDescriptorPool), "vkCreateDescriptorPool");
1854         self.vkDestroyDescriptorPool = try self.lookupDevice(device, @TypeOf(self.vkDestroyDescriptorPool), "vkDestroyDescriptorPool");
1855         self.vkResetDescriptorPool = try self.lookupDevice(device, @TypeOf(self.vkResetDescriptorPool), "vkResetDescriptorPool");
1856         self.vkAllocateDescriptorSets = try self.lookupDevice(device, @TypeOf(self.vkAllocateDescriptorSets), "vkAllocateDescriptorSets");
1857         self.vkFreeDescriptorSets = try self.lookupDevice(device, @TypeOf(self.vkFreeDescriptorSets), "vkFreeDescriptorSets");
1858         self.vkUpdateDescriptorSets = try self.lookupDevice(device, @TypeOf(self.vkUpdateDescriptorSets), "vkUpdateDescriptorSets");
1859         self.vkCmdBindPipeline = try self.lookupDevice(device, @TypeOf(self.vkCmdBindPipeline), "vkCmdBindPipeline");
1860         self.vkCmdBindDescriptorSets = try self.lookupDevice(device, @TypeOf(self.vkCmdBindDescriptorSets), "vkCmdBindDescriptorSets");
1861         self.vkCmdDispatch = try self.lookupDevice(device, @TypeOf(self.vkCmdDispatch), "vkCmdDispatch");
1862         self.vkCmdPipelineBarrier = try self.lookupDevice(device, @TypeOf(self.vkCmdPipelineBarrier), "vkCmdPipelineBarrier");
1863         self.vkCmdClearColorImage = try self.lookupDevice(device, @TypeOf(self.vkCmdClearColorImage), "vkCmdClearColorImage");
1864         self.vkCmdCopyBuffer = try self.lookupDevice(device, @TypeOf(self.vkCmdCopyBuffer), "vkCmdCopyBuffer");
1865         self.vkCmdCopyBufferToImage = try self.lookupDevice(device, @TypeOf(self.vkCmdCopyBufferToImage), "vkCmdCopyBufferToImage");
1866         self.vkCmdResetQueryPool = try self.lookupDevice(device, @TypeOf(self.vkCmdResetQueryPool), "vkCmdResetQueryPool");
1867         self.vkCmdWriteTimestamp = try self.lookupDevice(device, @TypeOf(self.vkCmdWriteTimestamp), "vkCmdWriteTimestamp");
1868         self.vkCmdPushConstants = try self.lookupDevice(device, @TypeOf(self.vkCmdPushConstants), "vkCmdPushConstants");
1869         self.vkBeginCommandBuffer = try self.lookupDevice(device, @TypeOf(self.vkBeginCommandBuffer), "vkBeginCommandBuffer");
1870         self.vkEndCommandBuffer = try self.lookupDevice(device, @TypeOf(self.vkEndCommandBuffer), "vkEndCommandBuffer");
1871         self.vkResetCommandBuffer = try self.lookupDevice(device, @TypeOf(self.vkResetCommandBuffer), "vkResetCommandBuffer");
1872         self.vkAllocateMemory = try self.lookupDevice(device, @TypeOf(self.vkAllocateMemory), "vkAllocateMemory");
1873         self.vkFreeMemory = try self.lookupDevice(device, @TypeOf(self.vkFreeMemory), "vkFreeMemory");
1874         self.vkBindBufferMemory = try self.lookupDevice(device, @TypeOf(self.vkBindBufferMemory), "vkBindBufferMemory");
1875         self.vkCreateBuffer = try self.lookupDevice(device, @TypeOf(self.vkCreateBuffer), "vkCreateBuffer");
1876         self.vkDestroyBuffer = try self.lookupDevice(device, @TypeOf(self.vkDestroyBuffer), "vkDestroyBuffer");
1877         self.vkMapMemory = try self.lookupDevice(device, @TypeOf(self.vkMapMemory), "vkMapMemory");
1878         self.vkUnmapMemory = try self.lookupDevice(device, @TypeOf(self.vkUnmapMemory), "vkUnmapMemory");
1879         self.vkGetBufferMemoryRequirements = try self.lookupDevice(device, @TypeOf(self.vkGetBufferMemoryRequirements), "vkGetBufferMemoryRequirements");
1880         self.vkFlushMappedMemoryRanges = try self.lookupDevice(device, @TypeOf(self.vkFlushMappedMemoryRanges), "vkFlushMappedMemoryRanges");
1881         self.vkInvalidateMappedMemoryRanges = try self.lookupDevice(device, @TypeOf(self.vkInvalidateMappedMemoryRanges), "vkInvalidateMappedMemoryRanges");
1882         self.vkCreateImage = try self.lookupDevice(device, @TypeOf(self.vkCreateImage), "vkCreateImage");
1883         self.vkDestroyImage = try self.lookupDevice(device, @TypeOf(self.vkDestroyImage), "vkDestroyImage");
1884         self.vkGetImageMemoryRequirements = try self.lookupDevice(device, @TypeOf(self.vkGetImageMemoryRequirements), "vkGetImageMemoryRequirements");
1885         self.vkBindImageMemory = try self.lookupDevice(device, @TypeOf(self.vkBindImageMemory), "vkBindImageMemory");
1886         self.vkCreateImageView = try self.lookupDevice(device, @TypeOf(self.vkCreateImageView), "vkCreateImageView");
1887         self.vkDestroyImageView = try self.lookupDevice(device, @TypeOf(self.vkDestroyImageView), "vkDestroyImageView");
1888         self.vkCreateSampler = try self.lookupDevice(device, @TypeOf(self.vkCreateSampler), "vkCreateSampler");
1889         self.vkDestroySampler = try self.lookupDevice(device, @TypeOf(self.vkDestroySampler), "vkDestroySampler");
1890         self.vkCreateGraphicsPipelines = try self.lookupDevice(device, @TypeOf(self.vkCreateGraphicsPipelines), "vkCreateGraphicsPipelines");
1891         self.vkCmdBeginRendering = try self.lookupDevice(device, @TypeOf(self.vkCmdBeginRendering), "vkCmdBeginRendering");
1892         self.vkCmdEndRendering = try self.lookupDevice(device, @TypeOf(self.vkCmdEndRendering), "vkCmdEndRendering");
1893         self.vkCmdBindVertexBuffers = try self.lookupDevice(device, @TypeOf(self.vkCmdBindVertexBuffers), "vkCmdBindVertexBuffers");
1894         self.vkCmdBindIndexBuffer = try self.lookupDevice(device, @TypeOf(self.vkCmdBindIndexBuffer), "vkCmdBindIndexBuffer");
1895         self.vkCmdDraw = try self.lookupDevice(device, @TypeOf(self.vkCmdDraw), "vkCmdDraw");
1896         self.vkCmdDrawIndexed = try self.lookupDevice(device, @TypeOf(self.vkCmdDrawIndexed), "vkCmdDrawIndexed");
1897         self.vkCmdSetViewport = try self.lookupDevice(device, @TypeOf(self.vkCmdSetViewport), "vkCmdSetViewport");
1898         self.vkCmdSetScissor = try self.lookupDevice(device, @TypeOf(self.vkCmdSetScissor), "vkCmdSetScissor");
1899         self.vkCmdCopyImageToBuffer = try self.lookupDevice(device, @TypeOf(self.vkCmdCopyImageToBuffer), "vkCmdCopyImageToBuffer");
1900         self.vkGetImageSubresourceLayout = try self.lookupDevice(device, @TypeOf(self.vkGetImageSubresourceLayout), "vkGetImageSubresourceLayout");
1901     }
1902 
1903     /// Loads the entry points of VK_EXT_image_drm_format_modifier, VK_KHR_external_memory_fd and
1904     /// VK_KHR_external_semaphore_fd, which exist only on a device that enabled those extensions.
1905     pub fn loadDmabufFunctions(self: *Driver, device: VkDevice) Error!void {
1906         self.vkGetImageDrmFormatModifierPropertiesEXT = try self.lookupDevice(device, @typeInfo(@TypeOf(self.vkGetImageDrmFormatModifierPropertiesEXT)).optional.child, "vkGetImageDrmFormatModifierPropertiesEXT");
1907         self.vkGetMemoryFdKHR = try self.lookupDevice(device, @typeInfo(@TypeOf(self.vkGetMemoryFdKHR)).optional.child, "vkGetMemoryFdKHR");
1908         self.vkGetSemaphoreFdKHR = try self.lookupDevice(device, @typeInfo(@TypeOf(self.vkGetSemaphoreFdKHR)).optional.child, "vkGetSemaphoreFdKHR");
1909     }
1910 
1911     pub fn close(self: *Driver) void {
1912         self.lib.close();
1913     }
1914 
1915     pub fn fromResult(self: *const Driver, r: VkResult) Error!void {
1916         _ = self;
1917         switch (resultDiagnostic(r)) {
1918             .none => {},
1919             .unexpected_positive => {
1920                 log.warn("unexpected positive VkResult {d} at fromResult boundary", .{@backingInt(r)});
1921             },
1922             .unmapped => {
1923                 log.warn("unmapped VkResult {d}", .{@backingInt(r)});
1924             },
1925         }
1926         return mapResultQuiet(r);
1927     }
1928 };
1929 
1930 comptime {
1931     if (@sizeOf(VkResult) != @sizeOf(c_int)) {
1932         @compileError("VkResult ABI drift: storage must be c_int");
1933     }
1934     if (@sizeOf(VkQueueFamilyProperties) != 24) {
1935         @compileError("VkQueueFamilyProperties must be 24 bytes");
1936     }
1937     if (@sizeOf(VkExtensionProperties) != 260) {
1938         @compileError("VkExtensionProperties must be 260 bytes (256-byte name + u32 specVersion)");
1939     }
1940     if (@sizeOf(VkPhysicalDeviceProperties) != 824) {
1941         @compileError("VkPhysicalDeviceProperties must be 824 bytes (Vulkan ABI)");
1942     }
1943     if (@sizeOf(?*anyopaque) == 8 and @sizeOf(VkPhysicalDeviceProperties2) != 840) {
1944         @compileError("VkPhysicalDeviceProperties2 must be 840 bytes on 64-bit");
1945     }
1946     if (@sizeOf(?*anyopaque) == 8 and @sizeOf(VkPhysicalDeviceSubgroupProperties) != 32) {
1947         @compileError("VkPhysicalDeviceSubgroupProperties must be 32 bytes on 64-bit");
1948     }
1949     if (@sizeOf(VkPhysicalDeviceFeatures) != 220) {
1950         @compileError("VkPhysicalDeviceFeatures must be 220 bytes");
1951     }
1952     if (@sizeOf(?*anyopaque) == 8 and @sizeOf(VkPhysicalDeviceFeatures2) != 240) {
1953         @compileError("VkPhysicalDeviceFeatures2 must be 240 bytes on 64-bit");
1954     }
1955     if (@sizeOf(?*anyopaque) == 8 and @sizeOf(VkPhysicalDevice16BitStorageFeatures) != 32) {
1956         @compileError("VkPhysicalDevice16BitStorageFeatures must be 32 bytes on 64-bit");
1957     }
1958     if (@sizeOf(?*anyopaque) == 8 and @sizeOf(VkPhysicalDevice8BitStorageFeatures) != 32) {
1959         @compileError("VkPhysicalDevice8BitStorageFeatures must be 32 bytes on 64-bit");
1960     }
1961     if (@sizeOf(?*anyopaque) == 8 and @sizeOf(VkPhysicalDeviceTimelineSemaphoreFeatures) != 24) {
1962         @compileError("VkPhysicalDeviceTimelineSemaphoreFeatures must be 24 bytes on 64-bit");
1963     }
1964     if (@sizeOf(?*anyopaque) == 8 and @sizeOf(VkQueryPoolCreateInfo) != 32) {
1965         @compileError("VkQueryPoolCreateInfo must be 32 bytes on 64-bit");
1966     }
1967     if (@sizeOf(?*anyopaque) == 8 and @sizeOf(VkPhysicalDeviceLimits) != 504) {
1968         @compileError("VkPhysicalDeviceLimits must be 504 bytes on 64-bit");
1969     }
1970     if (@sizeOf(VkPhysicalDeviceSparseProperties) != 20) {
1971         @compileError("VkPhysicalDeviceSparseProperties must be 20 bytes");
1972     }
1973     if (@sizeOf(VkMemoryType) != 8) {
1974         @compileError("VkMemoryType must be 8 bytes (two u32 members)");
1975     }
1976     if (@sizeOf(VkMemoryHeap) != 16) {
1977         @compileError("VkMemoryHeap must be 16 bytes (u64 size + u32 flags + 4-byte pad)");
1978     }
1979     if (@sizeOf(VkPhysicalDeviceMemoryProperties) != 520) {
1980         @compileError("VkPhysicalDeviceMemoryProperties must be 520 bytes (Vulkan ABI)");
1981     }
1982     if (@sizeOf(VkMemoryRequirements) != 24) {
1983         @compileError("VkMemoryRequirements must be 24 bytes (u64 size + u64 align + u32 bits + pad)");
1984     }
1985     if (@sizeOf(VkSurfaceCapabilitiesKHR) != 52) {
1986         @compileError("VkSurfaceCapabilitiesKHR must be 52 bytes");
1987     }
1988     if (@sizeOf(VkSurfaceFormatKHR) != 8) {
1989         @compileError("VkSurfaceFormatKHR must be 8 bytes");
1990     }
1991     if (@sizeOf(?*anyopaque) == 8 and @sizeOf(VkXlibSurfaceCreateInfoKHR) != 40) {
1992         @compileError("VkXlibSurfaceCreateInfoKHR must be 40 bytes on 64-bit");
1993     }
1994     if (@sizeOf(?*anyopaque) == 8 and @sizeOf(VkSwapchainCreateInfoKHR) != 104) {
1995         @compileError("VkSwapchainCreateInfoKHR must be 104 bytes on 64-bit");
1996     }
1997     if (@sizeOf(?*anyopaque) == 8 and @sizeOf(VkPresentInfoKHR) != 64) {
1998         @compileError("VkPresentInfoKHR must be 64 bytes on 64-bit");
1999     }
2000     if (@sizeOf(VkImageSubresourceRange) != 20) {
2001         @compileError("VkImageSubresourceRange must be 20 bytes");
2002     }
2003     if (@sizeOf(VkImageSubresourceLayers) != 16) {
2004         @compileError("VkImageSubresourceLayers must be 16 bytes");
2005     }
2006     if (@sizeOf(VkOffset3D) != 12) {
2007         @compileError("VkOffset3D must be 12 bytes");
2008     }
2009     if (@sizeOf(?*anyopaque) == 8 and @sizeOf(VkImageMemoryBarrier) != 72) {
2010         @compileError("VkImageMemoryBarrier must be 72 bytes");
2011     }
2012     if (@sizeOf(?*anyopaque) == 8 and @sizeOf(VkBufferMemoryBarrier) != 56) {
2013         @compileError("VkBufferMemoryBarrier must be 56 bytes");
2014     }
2015     if (@sizeOf(VkBufferCopy) != 24) {
2016         @compileError("VkBufferCopy must be 24 bytes");
2017     }
2018     if (@sizeOf(VkBufferImageCopy) != 56) {
2019         @compileError("VkBufferImageCopy must be 56 bytes");
2020     }
2021     if (@sizeOf(VkClearColorValue) != 16) {
2022         @compileError("VkClearColorValue must be 16 bytes");
2023     }
2024 }
2025 
2026 fn skipIfHostHasDriver() !void {
2027     if (!platformSupported()) return error.SkipZigTest;
2028     if (dynamic.isVulkanLoaderLoadable()) return error.SkipZigTest;
2029 }
2030 
2031 test "Driver.open without libvulkan returns DriverUnavailable" {
2032     try skipIfHostHasDriver();
2033     try std.testing.expectError(Error.DriverUnavailable, Driver.open(std.testing.allocator));
2034 }
2035 
2036 test "VkResult pins the documented ABI values" {
2037     try std.testing.expectEqual(@as(c_int, 0), @backingInt(VkResult.success));
2038     try std.testing.expectEqual(@as(c_int, 1), @backingInt(VkResult.not_ready));
2039     try std.testing.expectEqual(@as(c_int, 2), @backingInt(VkResult.timeout));
2040     try std.testing.expectEqual(@as(c_int, 3), @backingInt(VkResult.event_set));
2041     try std.testing.expectEqual(@as(c_int, 4), @backingInt(VkResult.event_reset));
2042     try std.testing.expectEqual(@as(c_int, 5), @backingInt(VkResult.incomplete));
2043     try std.testing.expectEqual(@as(c_int, 1000001003), @backingInt(VkResult.suboptimal_khr));
2044     try std.testing.expectEqual(@as(c_int, -1), @backingInt(VkResult.error_out_of_host_memory));
2045     try std.testing.expectEqual(@as(c_int, -2), @backingInt(VkResult.error_out_of_device_memory));
2046     try std.testing.expectEqual(@as(c_int, -3), @backingInt(VkResult.error_initialization_failed));
2047     try std.testing.expectEqual(@as(c_int, -4), @backingInt(VkResult.error_device_lost));
2048     try std.testing.expectEqual(@as(c_int, -5), @backingInt(VkResult.error_memory_map_failed));
2049     try std.testing.expectEqual(@as(c_int, -6), @backingInt(VkResult.error_layer_not_present));
2050     try std.testing.expectEqual(@as(c_int, -7), @backingInt(VkResult.error_extension_not_present));
2051     try std.testing.expectEqual(@as(c_int, -8), @backingInt(VkResult.error_feature_not_present));
2052     try std.testing.expectEqual(@as(c_int, -9), @backingInt(VkResult.error_incompatible_driver));
2053     try std.testing.expectEqual(@as(c_int, -10), @backingInt(VkResult.error_too_many_objects));
2054     try std.testing.expectEqual(@as(c_int, -11), @backingInt(VkResult.error_format_not_supported));
2055     try std.testing.expectEqual(@as(c_int, -12), @backingInt(VkResult.error_fragmented_pool));
2056     try std.testing.expectEqual(@as(c_int, -1000069000), @backingInt(VkResult.error_out_of_pool_memory));
2057     try std.testing.expectEqual(@as(c_int, -13), @backingInt(VkResult.error_unknown));
2058     try std.testing.expectEqual(@as(c_int, -1000000000), @backingInt(VkResult.error_surface_lost_khr));
2059     try std.testing.expectEqual(@as(c_int, -1000000001), @backingInt(VkResult.error_native_window_in_use_khr));
2060     try std.testing.expectEqual(@as(c_int, -1000001004), @backingInt(VkResult.error_out_of_date_khr));
2061 }
2062 
2063 test "VkResult is storage-compatible with c_int and non-exhaustive" {
2064     try std.testing.expectEqual(@sizeOf(c_int), @sizeOf(VkResult));
2065     const unknown_code: VkResult = @fromBackingInt(@intCast(1_000_000_000));
2066     try std.testing.expectEqual(@as(c_int, 1_000_000_000), @backingInt(unknown_code));
2067 }
2068 
2069 test "fromResult on success returns without error" {
2070     var stub: Driver = undefined;
2071     try stub.fromResult(.success);
2072 }
2073 
2074 test "fromResult maps documented error codes onto the typed Error set" {
2075     var stub: Driver = undefined;
2076     const cases = [_]struct { r: VkResult, err: Error }{
2077         .{ .r = .error_out_of_host_memory, .err = Error.OutOfHostMemory },
2078         .{ .r = .error_out_of_device_memory, .err = Error.OutOfDeviceMemory },
2079         .{ .r = .error_initialization_failed, .err = Error.InitializationFailed },
2080         .{ .r = .error_device_lost, .err = Error.DeviceLost },
2081         .{ .r = .error_memory_map_failed, .err = Error.MemoryMapFailed },
2082         .{ .r = .error_layer_not_present, .err = Error.LayerNotPresent },
2083         .{ .r = .error_extension_not_present, .err = Error.ExtensionNotPresent },
2084         .{ .r = .error_feature_not_present, .err = Error.FeatureNotPresent },
2085         .{ .r = .error_incompatible_driver, .err = Error.IncompatibleDriver },
2086         .{ .r = .error_too_many_objects, .err = Error.TooManyObjects },
2087         .{ .r = .error_format_not_supported, .err = Error.FormatNotSupported },
2088         .{ .r = .error_fragmented_pool, .err = Error.FragmentedPool },
2089         .{ .r = .error_unknown, .err = Error.VulkanUnknown },
2090         .{ .r = .error_out_of_pool_memory, .err = Error.OutOfPoolMemory },
2091         .{ .r = .error_surface_lost_khr, .err = Error.SurfaceLost },
2092         .{ .r = .error_native_window_in_use_khr, .err = Error.NativeWindowInUse },
2093         .{ .r = .error_out_of_date_khr, .err = Error.SurfaceOutOfDate },
2094         .{ .r = .suboptimal_khr, .err = Error.SurfaceOutOfDate },
2095     };
2096     for (cases) |c| {
2097         try std.testing.expectError(c.err, stub.fromResult(c.r));
2098     }
2099 }
2100 
2101 test "VkResult quiet mapping collapses unmapped positive codes to VulkanUnknown" {
2102     try std.testing.expectError(Error.VulkanUnknown, mapResultQuiet(.not_ready));
2103     try std.testing.expectError(Error.VulkanUnknown, mapResultQuiet(.timeout));
2104     try std.testing.expectError(Error.VulkanUnknown, mapResultQuiet(.incomplete));
2105 }
2106 
2107 test "VkResult quiet mapping collapses unknown codes to VulkanUnknown" {
2108     const unknown_code: VkResult = @fromBackingInt(@intCast(-1337));
2109     try std.testing.expectError(Error.VulkanUnknown, mapResultQuiet(unknown_code));
2110 }
2111 
2112 test "Driver field signatures match the Vulkan loader ABI" {
2113     const vkGetInstanceProcAddrT = *const fn (
2114         instance: VkInstance,
2115         pName: [*:0]const u8,
2116     ) callconv(.c) PFN_vkVoidFunction;
2117     const vkCreateInstanceT = *const fn (
2118         pCreateInfo: *const VkInstanceCreateInfo,
2119         pAllocator: ?*const anyopaque,
2120         pInstance: *VkInstance,
2121     ) callconv(.c) VkResult;
2122     const vkEnumeratePhysicalDevicesT = *const fn (
2123         instance: VkInstance,
2124         pCount: *u32,
2125         pDevices: ?[*]VkPhysicalDevice,
2126     ) callconv(.c) VkResult;
2127     const vkCreateDeviceT = *const fn (
2128         physicalDevice: VkPhysicalDevice,
2129         pCreateInfo: *const VkDeviceCreateInfo,
2130         pAllocator: ?*const anyopaque,
2131         pDevice: *VkDevice,
2132     ) callconv(.c) VkResult;
2133     const vkGetSemaphoreCounterValueT = *const fn (
2134         device: VkDevice,
2135         semaphore: VkSemaphore,
2136         pValue: *u64,
2137     ) callconv(.c) VkResult;
2138     const vkWaitSemaphoresT = *const fn (
2139         device: VkDevice,
2140         pWaitInfo: *const VkSemaphoreWaitInfo,
2141         timeout: u64,
2142     ) callconv(.c) VkResult;
2143     const vkCreateXlibSurfaceKHRT = *const fn (
2144         instance: VkInstance,
2145         pCreateInfo: *const VkXlibSurfaceCreateInfoKHR,
2146         pAllocator: ?*const anyopaque,
2147         pSurface: *VkSurfaceKHR,
2148     ) callconv(.c) VkResult;
2149     const vkGetPhysicalDeviceSurfaceSupportKHRT = *const fn (
2150         physicalDevice: VkPhysicalDevice,
2151         queueFamilyIndex: u32,
2152         surface: VkSurfaceKHR,
2153         pSupported: *VkBool32,
2154     ) callconv(.c) VkResult;
2155     const vkCreateSwapchainKHRT = *const fn (
2156         device: VkDevice,
2157         pCreateInfo: *const VkSwapchainCreateInfoKHR,
2158         pAllocator: ?*const anyopaque,
2159         pSwapchain: *VkSwapchainKHR,
2160     ) callconv(.c) VkResult;
2161     const vkAcquireNextImageKHRT = *const fn (
2162         device: VkDevice,
2163         swapchain: VkSwapchainKHR,
2164         timeout: u64,
2165         semaphore: VkSemaphore,
2166         fence: VkFence,
2167         pImageIndex: *u32,
2168     ) callconv(.c) VkResult;
2169     const vkQueuePresentKHRT = *const fn (
2170         queue: VkQueue,
2171         pPresentInfo: *const VkPresentInfoKHR,
2172     ) callconv(.c) VkResult;
2173     const vkCmdPipelineBarrierT = *const fn (
2174         commandBuffer: VkCommandBuffer,
2175         srcStageMask: VkPipelineStageFlags,
2176         dstStageMask: VkPipelineStageFlags,
2177         dependencyFlags: VkDependencyFlags,
2178         memoryBarrierCount: u32,
2179         pMemoryBarriers: ?*const anyopaque,
2180         bufferMemoryBarrierCount: u32,
2181         pBufferMemoryBarriers: ?[*]const VkBufferMemoryBarrier,
2182         imageMemoryBarrierCount: u32,
2183         pImageMemoryBarriers: ?[*]const VkImageMemoryBarrier,
2184     ) callconv(.c) void;
2185     const vkResetDescriptorPoolT = *const fn (
2186         device: VkDevice,
2187         descriptorPool: VkDescriptorPool,
2188         flags: VkDescriptorPoolResetFlags,
2189     ) callconv(.c) VkResult;
2190     const vkCmdCopyBufferT = *const fn (
2191         commandBuffer: VkCommandBuffer,
2192         srcBuffer: VkBuffer,
2193         dstBuffer: VkBuffer,
2194         regionCount: u32,
2195         pRegions: [*]const VkBufferCopy,
2196     ) callconv(.c) void;
2197     const vkInvalidateMappedMemoryRangesT = *const fn (
2198         device: VkDevice,
2199         memoryRangeCount: u32,
2200         pMemoryRanges: [*]const VkMappedMemoryRange,
2201     ) callconv(.c) VkResult;
2202     const vkCmdClearColorImageT = *const fn (
2203         commandBuffer: VkCommandBuffer,
2204         image: VkImage,
2205         imageLayout: VkImageLayout,
2206         pColor: *const VkClearColorValue,
2207         rangeCount: u32,
2208         pRanges: [*]const VkImageSubresourceRange,
2209     ) callconv(.c) void;
2210     const vkCmdCopyBufferToImageT = *const fn (
2211         commandBuffer: VkCommandBuffer,
2212         srcBuffer: VkBuffer,
2213         dstImage: VkImage,
2214         dstImageLayout: VkImageLayout,
2215         regionCount: u32,
2216         pRegions: [*]const VkBufferImageCopy,
2217     ) callconv(.c) void;
2218 
2219     comptime {
2220         std.debug.assert(@FieldType(Driver, "vkGetInstanceProcAddr") == vkGetInstanceProcAddrT);
2221         std.debug.assert(@FieldType(Driver, "vkCreateInstance") == vkCreateInstanceT);
2222         std.debug.assert(@FieldType(Driver, "vkEnumeratePhysicalDevices") == vkEnumeratePhysicalDevicesT);
2223         std.debug.assert(@FieldType(Driver, "vkCreateDevice") == vkCreateDeviceT);
2224         std.debug.assert(@FieldType(Driver, "vkGetSemaphoreCounterValue") == vkGetSemaphoreCounterValueT);
2225         std.debug.assert(@FieldType(Driver, "vkWaitSemaphores") == vkWaitSemaphoresT);
2226         std.debug.assert(@FieldType(Driver, "vkCreateXlibSurfaceKHR") == vkCreateXlibSurfaceKHRT);
2227         std.debug.assert(@FieldType(Driver, "vkGetPhysicalDeviceSurfaceSupportKHR") == vkGetPhysicalDeviceSurfaceSupportKHRT);
2228         std.debug.assert(@FieldType(Driver, "vkCreateSwapchainKHR") == vkCreateSwapchainKHRT);
2229         std.debug.assert(@FieldType(Driver, "vkAcquireNextImageKHR") == vkAcquireNextImageKHRT);
2230         std.debug.assert(@FieldType(Driver, "vkQueuePresentKHR") == vkQueuePresentKHRT);
2231         std.debug.assert(@FieldType(Driver, "vkCmdPipelineBarrier") == vkCmdPipelineBarrierT);
2232         std.debug.assert(@FieldType(Driver, "vkResetDescriptorPool") == vkResetDescriptorPoolT);
2233         std.debug.assert(@FieldType(Driver, "vkCmdCopyBuffer") == vkCmdCopyBufferT);
2234         std.debug.assert(@FieldType(Driver, "vkInvalidateMappedMemoryRanges") == vkInvalidateMappedMemoryRangesT);
2235         std.debug.assert(@FieldType(Driver, "vkCmdClearColorImage") == vkCmdClearColorImageT);
2236         std.debug.assert(@FieldType(Driver, "vkCmdCopyBufferToImage") == vkCmdCopyBufferToImageT);
2237     }
2238 }
2239 
2240 test "opaque handle widths match the documented ABI" {
2241     try std.testing.expectEqual(@sizeOf(*anyopaque), @sizeOf(VkInstance));
2242     try std.testing.expectEqual(@sizeOf(*anyopaque), @sizeOf(VkPhysicalDevice));
2243     try std.testing.expectEqual(@sizeOf(*anyopaque), @sizeOf(VkDevice));
2244     try std.testing.expectEqual(@sizeOf(*anyopaque), @sizeOf(VkQueue));
2245     try std.testing.expectEqual(@sizeOf(*anyopaque), @sizeOf(VkSemaphore));
2246     try std.testing.expectEqual(@sizeOf(*anyopaque), @sizeOf(VkCommandPool));
2247     try std.testing.expectEqual(@sizeOf(*anyopaque), @sizeOf(VkCommandBuffer));
2248     try std.testing.expectEqual(@sizeOf(*anyopaque), @sizeOf(VkFence));
2249     try std.testing.expectEqual(@as(usize, 8), @sizeOf(VkSurfaceKHR));
2250     try std.testing.expectEqual(@as(usize, 8), @sizeOf(VkSwapchainKHR));
2251     try std.testing.expectEqual(@as(usize, 8), @sizeOf(VkImage));
2252 }
2253 
2254 test "structure-type sTypes match the spec" {
2255     try std.testing.expectEqual(@as(u32, 0), VK_STRUCTURE_TYPE_APPLICATION_INFO);
2256     try std.testing.expectEqual(@as(u32, 1), VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO);
2257     try std.testing.expectEqual(@as(u32, 2), VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO);
2258     try std.testing.expectEqual(@as(u32, 3), VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO);
2259     try std.testing.expectEqual(@as(u32, 9), VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO);
2260     try std.testing.expectEqual(@as(u32, 11), VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO);
2261     try std.testing.expectEqual(@as(u32, 39), VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO);
2262     try std.testing.expectEqual(@as(u32, 40), VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO);
2263     try std.testing.expectEqual(@as(u32, 44), VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER);
2264     try std.testing.expectEqual(@as(u32, 45), VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER);
2265     try std.testing.expectEqual(@as(u32, 1000001000), VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR);
2266     try std.testing.expectEqual(@as(u32, 1000001001), VK_STRUCTURE_TYPE_PRESENT_INFO_KHR);
2267     try std.testing.expectEqual(@as(u32, 1000004000), VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR);
2268     try std.testing.expectEqual(@as(u32, 1000059000), VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2);
2269     try std.testing.expectEqual(@as(u32, 1000059001), VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2);
2270     try std.testing.expectEqual(@as(u32, 1000083000), VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES);
2271     try std.testing.expectEqual(@as(u32, 1000094000), VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES);
2272     try std.testing.expectEqual(@as(u32, 1000177000), VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES);
2273     try std.testing.expectEqual(@as(u32, 1000207000), VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES);
2274     try std.testing.expectEqual(@as(u32, 1000207002), VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO);
2275     try std.testing.expectEqual(@as(u32, 1000207004), VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO);
2276     try std.testing.expectEqual(@as(u32, 1000207005), VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO);
2277     try std.testing.expectEqual(@as(u32, 1000314004), VK_STRUCTURE_TYPE_SUBMIT_INFO_2);
2278     try std.testing.expectEqual(@as(u32, 1000314005), VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO);
2279     try std.testing.expectEqual(@as(u32, 1000314006), VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO);
2280     try std.testing.expectEqual(@as(u32, 1), VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT);
2281 }
2282 
2283 test "surface and swapchain constants match the spec" {
2284     try std.testing.expectEqual(@as(u32, 37), VK_FORMAT_R8G8B8A8_UNORM);
2285     try std.testing.expectEqual(@as(u32, 44), VK_FORMAT_B8G8R8A8_UNORM);
2286     try std.testing.expectEqual(@as(u32, 0), VK_COLOR_SPACE_SRGB_NONLINEAR_KHR);
2287     try std.testing.expectEqual(@as(u32, 0), VK_PRESENT_MODE_IMMEDIATE_KHR);
2288     try std.testing.expectEqual(@as(u32, 1), VK_PRESENT_MODE_MAILBOX_KHR);
2289     try std.testing.expectEqual(@as(u32, 2), VK_PRESENT_MODE_FIFO_KHR);
2290     try std.testing.expectEqual(@as(u32, 0x1), VK_IMAGE_USAGE_TRANSFER_SRC_BIT);
2291     try std.testing.expectEqual(@as(u32, 0x2), VK_IMAGE_USAGE_TRANSFER_DST_BIT);
2292     try std.testing.expectEqual(@as(u32, 0x4), VK_IMAGE_USAGE_SAMPLED_BIT);
2293     try std.testing.expectEqual(@as(u32, 0x8), VK_IMAGE_USAGE_STORAGE_BIT);
2294     try std.testing.expectEqual(@as(u32, 0x10), VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT);
2295     try std.testing.expectEqual(@as(u32, 0), VK_IMAGE_LAYOUT_UNDEFINED);
2296     try std.testing.expectEqual(@as(u32, 7), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
2297     try std.testing.expectEqual(@as(u32, 1000001002), VK_IMAGE_LAYOUT_PRESENT_SRC_KHR);
2298     try std.testing.expectEqual(@as(u32, 0x1000), VK_ACCESS_TRANSFER_WRITE_BIT);
2299     try std.testing.expectEqual(@as(u32, 0x20), VK_ACCESS_SHADER_READ_BIT);
2300     try std.testing.expectEqual(@as(u32, 0x40), VK_ACCESS_SHADER_WRITE_BIT);
2301     try std.testing.expectEqual(@as(u32, 0x800), VK_ACCESS_TRANSFER_READ_BIT);
2302     try std.testing.expectEqual(@as(u32, 0x1), VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT);
2303     try std.testing.expectEqual(@as(u32, 0x800), VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
2304     try std.testing.expectEqual(@as(u32, 0x1000), VK_PIPELINE_STAGE_TRANSFER_BIT);
2305     try std.testing.expectEqual(@as(u32, 0x2000), VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT);
2306     try std.testing.expectEqual(@as(u32, 0x1), VK_IMAGE_ASPECT_COLOR_BIT);
2307     try std.testing.expectEqual(std.math.maxInt(u32), VK_QUEUE_FAMILY_IGNORED);
2308     try std.testing.expectEqual(@as(u32, 0x1), VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR);
2309     try std.testing.expectEqual(@as(u32, 0x100), VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR);
2310     try std.testing.expectEqual(@as(u32, 0x1), VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR);
2311     try std.testing.expectEqual(@as(u32, 0x2), VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR);
2312     try std.testing.expectEqual(@as(u32, 0x4), VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR);
2313     try std.testing.expectEqual(@as(u32, 0x8), VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR);
2314     try std.testing.expectEqualStrings("VK_KHR_surface", VK_KHR_SURFACE_EXTENSION_NAME);
2315     try std.testing.expectEqualStrings("VK_KHR_xlib_surface", VK_KHR_XLIB_SURFACE_EXTENSION_NAME);
2316     try std.testing.expectEqualStrings("VK_KHR_swapchain", VK_KHR_SWAPCHAIN_EXTENSION_NAME);
2317     try std.testing.expectEqualStrings("VK_KHR_16bit_storage", VK_KHR_16BIT_STORAGE_EXTENSION_NAME);
2318     try std.testing.expectEqualStrings("VK_KHR_8bit_storage", VK_KHR_8BIT_STORAGE_EXTENSION_NAME);
2319     try std.testing.expectEqualStrings("VK_KHR_shader_float16_int8", VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME);
2320 }
2321 
2322 test "timeline-semaphore constants match the spec" {
2323     try std.testing.expectEqual(@as(u32, 0), VK_SEMAPHORE_TYPE_BINARY);
2324     try std.testing.expectEqual(@as(u32, 1), VK_SEMAPHORE_TYPE_TIMELINE);
2325     try std.testing.expectEqual(@as(u32, 1), VK_TRUE);
2326     try std.testing.expectEqual(@as(u32, 0), VK_FALSE);
2327     try std.testing.expectEqual(std.math.maxInt(u64), VK_WHOLE_TIMEOUT);
2328     try std.testing.expectEqualStrings(
2329         "VK_KHR_timeline_semaphore",
2330         VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME,
2331     );
2332 }
2333 
2334 test "API-version constants encode the VK_MAKE_API_VERSION packing" {
2335     try std.testing.expectEqual(@as(u32, (1 << 22) | (2 << 12)), VK_API_VERSION_1_2);
2336     try std.testing.expectEqual(@as(u32, (1 << 22) | (3 << 12)), VK_API_VERSION_1_3);
2337     try std.testing.expect(VK_API_VERSION_1_2 > VK_API_VERSION_1_1);
2338     try std.testing.expect(VK_API_VERSION_1_1 > VK_API_VERSION_1_0);
2339 }
2340 
2341 test "queue-flag bits match the spec" {
2342     try std.testing.expectEqual(@as(u32, 0x1), VK_QUEUE_GRAPHICS_BIT);
2343     try std.testing.expectEqual(@as(u32, 0x2), VK_QUEUE_COMPUTE_BIT);
2344     try std.testing.expectEqual(@as(u32, 0x4), VK_QUEUE_TRANSFER_BIT);
2345     try std.testing.expectEqual(@as(u32, 0x8), VK_QUEUE_SPARSE_BINDING_BIT);
2346 }
2347 
2348 test "subgroup operation bits match the spec" {
2349     try std.testing.expectEqual(@as(u32, 0x01), VK_SUBGROUP_FEATURE_BASIC_BIT);
2350     try std.testing.expectEqual(@as(u32, 0x02), VK_SUBGROUP_FEATURE_VOTE_BIT);
2351     try std.testing.expectEqual(@as(u32, 0x04), VK_SUBGROUP_FEATURE_ARITHMETIC_BIT);
2352     try std.testing.expectEqual(@as(u32, 0x08), VK_SUBGROUP_FEATURE_BALLOT_BIT);
2353     try std.testing.expectEqual(@as(u32, 0x10), VK_SUBGROUP_FEATURE_SHUFFLE_BIT);
2354     try std.testing.expectEqual(@as(u32, 0x20), VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT);
2355 }
2356 
2357 test "extension-name helper reads up to the first null byte" {
2358     var ext = VkExtensionProperties{
2359         .extensionName = @as([VK_MAX_EXTENSION_NAME_SIZE]u8, @splat(0)),
2360         .specVersion = 42,
2361     };
2362     const src = "VK_KHR_timeline_semaphore";
2363     @memcpy(ext.extensionName[0..src.len], src);
2364     try std.testing.expectEqualStrings(src, ext.name());
2365 }
2366 
2367 test "platformSupported reflects the loader-target set" {
2368     try std.testing.expectEqual(
2369         dynamic.hasHostCandidate(dynamic.vulkanLoaderCandidates()),
2370         platformSupported(),
2371     );
2372 }
2373 
2374 test "graphics structures match the C layouts of vulkan_core.h 1.4.341" {
2375     try std.testing.expectEqual(@as(usize, 80), @sizeOf(VkPhysicalDeviceVulkan13Features));
2376     try std.testing.expectEqual(@as(usize, 64), @offsetOf(VkPhysicalDeviceVulkan13Features, "dynamicRendering"));
2377     try std.testing.expectEqual(@as(usize, 12), @sizeOf(VkFormatProperties));
2378     try std.testing.expectEqual(@as(usize, 24), @sizeOf(VkMemoryBarrier));
2379     try std.testing.expectEqual(@as(usize, 20), @offsetOf(VkMemoryBarrier, "dstAccessMask"));
2380     try std.testing.expectEqual(@as(usize, 88), @sizeOf(VkImageCreateInfo));
2381     try std.testing.expectEqual(@as(usize, 80), @offsetOf(VkImageCreateInfo, "initialLayout"));
2382     try std.testing.expectEqual(@as(usize, 72), @offsetOf(VkImageCreateInfo, "pQueueFamilyIndices"));
2383     try std.testing.expectEqual(@as(usize, 16), @sizeOf(VkComponentMapping));
2384     try std.testing.expectEqual(@as(usize, 80), @sizeOf(VkImageViewCreateInfo));
2385     try std.testing.expectEqual(@as(usize, 56), @offsetOf(VkImageViewCreateInfo, "subresourceRange"));
2386     try std.testing.expectEqual(@as(usize, 24), @offsetOf(VkImageViewCreateInfo, "image"));
2387     try std.testing.expectEqual(@as(usize, 80), @sizeOf(VkSamplerCreateInfo));
2388     try std.testing.expectEqual(@as(usize, 76), @offsetOf(VkSamplerCreateInfo, "unnormalizedCoordinates"));
2389     try std.testing.expectEqual(@as(usize, 24), @sizeOf(VkDescriptorImageInfo));
2390     try std.testing.expectEqual(@as(usize, 12), @sizeOf(VkVertexInputBindingDescription));
2391     try std.testing.expectEqual(@as(usize, 16), @sizeOf(VkVertexInputAttributeDescription));
2392     try std.testing.expectEqual(@as(usize, 48), @sizeOf(VkPipelineVertexInputStateCreateInfo));
2393     try std.testing.expectEqual(@as(usize, 40), @offsetOf(VkPipelineVertexInputStateCreateInfo, "pVertexAttributeDescriptions"));
2394     try std.testing.expectEqual(@as(usize, 32), @sizeOf(VkPipelineInputAssemblyStateCreateInfo));
2395     try std.testing.expectEqual(@as(usize, 24), @sizeOf(VkViewport));
2396     try std.testing.expectEqual(@as(usize, 8), @sizeOf(VkOffset2D));
2397     try std.testing.expectEqual(@as(usize, 16), @sizeOf(VkRect2D));
2398     try std.testing.expectEqual(@as(usize, 48), @sizeOf(VkPipelineViewportStateCreateInfo));
2399     try std.testing.expectEqual(@as(usize, 40), @offsetOf(VkPipelineViewportStateCreateInfo, "pScissors"));
2400     try std.testing.expectEqual(@as(usize, 64), @sizeOf(VkPipelineRasterizationStateCreateInfo));
2401     try std.testing.expectEqual(@as(usize, 56), @offsetOf(VkPipelineRasterizationStateCreateInfo, "lineWidth"));
2402     try std.testing.expectEqual(@as(usize, 48), @sizeOf(VkPipelineMultisampleStateCreateInfo));
2403     try std.testing.expectEqual(@as(usize, 32), @offsetOf(VkPipelineMultisampleStateCreateInfo, "pSampleMask"));
2404     try std.testing.expectEqual(@as(usize, 44), @offsetOf(VkPipelineMultisampleStateCreateInfo, "alphaToOneEnable"));
2405     try std.testing.expectEqual(@as(usize, 28), @sizeOf(VkStencilOpState));
2406     try std.testing.expectEqual(@as(usize, 104), @sizeOf(VkPipelineDepthStencilStateCreateInfo));
2407     try std.testing.expectEqual(@as(usize, 100), @offsetOf(VkPipelineDepthStencilStateCreateInfo, "maxDepthBounds"));
2408     try std.testing.expectEqual(@as(usize, 32), @sizeOf(VkPipelineColorBlendAttachmentState));
2409     try std.testing.expectEqual(@as(usize, 56), @sizeOf(VkPipelineColorBlendStateCreateInfo));
2410     try std.testing.expectEqual(@as(usize, 40), @offsetOf(VkPipelineColorBlendStateCreateInfo, "blendConstants"));
2411     try std.testing.expectEqual(@as(usize, 32), @sizeOf(VkPipelineDynamicStateCreateInfo));
2412     try std.testing.expectEqual(@as(usize, 40), @sizeOf(VkPipelineRenderingCreateInfo));
2413     try std.testing.expectEqual(@as(usize, 32), @offsetOf(VkPipelineRenderingCreateInfo, "depthAttachmentFormat"));
2414     try std.testing.expectEqual(@as(usize, 144), @sizeOf(VkGraphicsPipelineCreateInfo));
2415     try std.testing.expectEqual(@as(usize, 104), @offsetOf(VkGraphicsPipelineCreateInfo, "layout"));
2416     try std.testing.expectEqual(@as(usize, 136), @offsetOf(VkGraphicsPipelineCreateInfo, "basePipelineIndex"));
2417     try std.testing.expectEqual(@as(usize, 8), @sizeOf(VkClearDepthStencilValue));
2418     try std.testing.expectEqual(@as(usize, 16), @sizeOf(VkClearValue));
2419     try std.testing.expectEqual(@as(usize, 72), @sizeOf(VkRenderingAttachmentInfo));
2420     try std.testing.expectEqual(@as(usize, 52), @offsetOf(VkRenderingAttachmentInfo, "clearValue"));
2421     try std.testing.expectEqual(@as(usize, 44), @offsetOf(VkRenderingAttachmentInfo, "loadOp"));
2422     try std.testing.expectEqual(@as(usize, 72), @sizeOf(VkRenderingInfo));
2423     try std.testing.expectEqual(@as(usize, 48), @offsetOf(VkRenderingInfo, "pColorAttachments"));
2424     try std.testing.expectEqual(@as(usize, 64), @offsetOf(VkRenderingInfo, "pStencilAttachment"));
2425 }
2426 
2427 test "dmabuf export structures match the C layouts of vulkan_core.h 1.4.341" {
2428     try std.testing.expectEqual(@as(usize, 32), @sizeOf(VkFormatProperties2));
2429     try std.testing.expectEqual(@as(usize, 16), @offsetOf(VkFormatProperties2, "formatProperties"));
2430     try std.testing.expectEqual(@as(usize, 16), @sizeOf(VkDrmFormatModifierPropertiesEXT));
2431     try std.testing.expectEqual(@as(usize, 12), @offsetOf(VkDrmFormatModifierPropertiesEXT, "drmFormatModifierTilingFeatures"));
2432     try std.testing.expectEqual(@as(usize, 32), @sizeOf(VkDrmFormatModifierPropertiesListEXT));
2433     try std.testing.expectEqual(@as(usize, 24), @offsetOf(VkDrmFormatModifierPropertiesListEXT, "pDrmFormatModifierProperties"));
2434     try std.testing.expectEqual(@as(usize, 32), @sizeOf(VkImageDrmFormatModifierListCreateInfoEXT));
2435     try std.testing.expectEqual(@as(usize, 24), @offsetOf(VkImageDrmFormatModifierListCreateInfoEXT, "pDrmFormatModifiers"));
2436     try std.testing.expectEqual(@as(usize, 24), @sizeOf(VkImageDrmFormatModifierPropertiesEXT));
2437     try std.testing.expectEqual(@as(usize, 16), @offsetOf(VkImageDrmFormatModifierPropertiesEXT, "drmFormatModifier"));
2438     try std.testing.expectEqual(@as(usize, 24), @sizeOf(VkExternalMemoryImageCreateInfo));
2439     try std.testing.expectEqual(@as(usize, 16), @offsetOf(VkExternalMemoryImageCreateInfo, "handleTypes"));
2440     try std.testing.expectEqual(@as(usize, 24), @sizeOf(VkExportMemoryAllocateInfo));
2441     try std.testing.expectEqual(@as(usize, 32), @sizeOf(VkMemoryDedicatedAllocateInfo));
2442     try std.testing.expectEqual(@as(usize, 24), @offsetOf(VkMemoryDedicatedAllocateInfo, "buffer"));
2443     try std.testing.expectEqual(@as(usize, 32), @sizeOf(VkMemoryGetFdInfoKHR));
2444     try std.testing.expectEqual(@as(usize, 24), @offsetOf(VkMemoryGetFdInfoKHR, "handleType"));
2445     try std.testing.expectEqual(@as(usize, 24), @sizeOf(VkExportSemaphoreCreateInfo));
2446     try std.testing.expectEqual(@as(usize, 32), @sizeOf(VkSemaphoreGetFdInfoKHR));
2447     try std.testing.expectEqual(@as(usize, 24), @offsetOf(VkSemaphoreGetFdInfoKHR, "handleType"));
2448     try std.testing.expectEqual(@as(usize, 56), @sizeOf(VkPhysicalDeviceDrmPropertiesEXT));
2449     try std.testing.expectEqual(@as(usize, 48), @offsetOf(VkPhysicalDeviceDrmPropertiesEXT, "renderMinor"));
2450     try std.testing.expectEqual(@as(usize, 12), @sizeOf(VkImageSubresource));
2451     try std.testing.expectEqual(@as(usize, 40), @sizeOf(VkSubresourceLayout));
2452     try std.testing.expectEqual(@as(usize, 32), @offsetOf(VkSubresourceLayout, "depthPitch"));
2453     try std.testing.expectEqual(@as(u32, 0xFFFF_FFFD), VK_QUEUE_FAMILY_FOREIGN_EXT);
2454     try std.testing.expectEqual(@as(u32, 1000158000), VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT);
2455 }