tiny.sys.vulkan

1pub const vulkan = @import("vulkan.zig");

1//! Vulkan loader bindings: ABI types, the dynamically loaded entry points,2//! and `VkResult` mapped to typed errors.34const std = @import("std");5const capabilities = @import("capabilities.zig");6const dynamic = @import("dynamic.zig");78pub const required_capabilities = capabilities.host(&.{ .allocator, .dynamic_loading });910const log = std.log.scoped(.vulkan_driver);1112pub const VkInstance = ?*opaque {};13pub const VkPhysicalDevice = ?*opaque {};14pub const VkDevice = ?*opaque {};15pub const VkQueue = ?*opaque {};16pub const VkSemaphore = ?*opaque {};17pub const VkCommandPool = ?*opaque {};18pub const VkCommandBuffer = ?*opaque {};19pub const VkFence = ?*opaque {};20pub const VkShaderModule = ?*opaque {};21pub const VkPipeline = ?*opaque {};22pub const VkPipelineLayout = ?*opaque {};23pub const VkPipelineCache = ?*opaque {};24pub const VkDescriptorSet = ?*opaque {};25pub const VkDescriptorSetLayout = ?*opaque {};26pub const VkDescriptorPool = ?*opaque {};27pub const VkBuffer = ?*opaque {};28pub const VkDeviceMemory = ?*opaque {};29pub const VkQueryPool = u64;30pub const VkSurfaceKHR = u64;31pub const VkSwapchainKHR = u64;32pub const VkImage = u64;33pub const VkImageView = u64;34pub const VkSampler = u64;35pub const VkRenderPass = u64;36pub const VkDisplay = ?*opaque {};37pub const VkWindow = u64;38pub const VkVisualID = u64;3940pub const PFN_vkVoidFunction = ?*const fn () callconv(.c) void;4142pub const VkBool32 = u32;43pub const VK_TRUE: VkBool32 = 1;44pub const VK_FALSE: VkBool32 = 0;4546pub const VkStructureType = u32;47pub const VK_STRUCTURE_TYPE_APPLICATION_INFO: VkStructureType = 0;48pub const VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO: VkStructureType = 1;49pub const VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO: VkStructureType = 2;50pub const VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO: VkStructureType = 3;51pub const VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: VkStructureType = 5;52pub const VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE: VkStructureType = 6;53pub const VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO: VkStructureType = 14;54pub const VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO: VkStructureType = 15;55pub const VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO: VkStructureType = 9;56pub const VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO: VkStructureType = 11;57pub const VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO: VkStructureType = 12;58pub const VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: VkStructureType = 16;59pub const VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO: VkStructureType = 18;60pub const VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO: VkStructureType = 19;61pub const VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO: VkStructureType = 20;62pub const VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO: VkStructureType = 22;63pub const VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO: VkStructureType = 23;64pub const VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO: VkStructureType = 24;65pub const VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO: VkStructureType = 25;66pub const VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO: VkStructureType = 26;67pub const VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO: VkStructureType = 27;68pub const VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO: VkStructureType = 28;69pub const VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO: VkStructureType = 29;70pub const VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: VkStructureType = 30;71pub const VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO: VkStructureType = 31;72pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO: VkStructureType = 32;73pub const VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO: VkStructureType = 33;74pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO: VkStructureType = 34;75pub const VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET: VkStructureType = 35;76pub const VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO: VkStructureType = 39;77pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO: VkStructureType = 40;78pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO: VkStructureType = 42;79pub const VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER: VkStructureType = 44;80pub const VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER: VkStructureType = 45;81pub const VK_STRUCTURE_TYPE_MEMORY_BARRIER: VkStructureType = 46;82pub const VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR: VkStructureType = 1000001000;83pub const VK_STRUCTURE_TYPE_PRESENT_INFO_KHR: VkStructureType = 1000001001;84pub const VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR: VkStructureType = 1000004000;85pub const VK_STRUCTURE_TYPE_RENDERING_INFO: VkStructureType = 1000044000;86pub const VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO: VkStructureType = 1000044001;87pub const VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO: VkStructureType = 1000044002;88pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: VkStructureType = 53;89pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: VkStructureType = 1000059000;90pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2: VkStructureType = 1000059001;91pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: VkStructureType = 1000083000;92pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: VkStructureType = 1000094000;93pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: VkStructureType = 1000177000;94pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: VkStructureType = 1000207000;95pub const VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO: VkStructureType = 1000207002;96pub const VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO: VkStructureType = 1000207003;97pub const VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO: VkStructureType = 1000207004;98pub const VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO: VkStructureType = 1000207005;99pub const VK_STRUCTURE_TYPE_SUBMIT_INFO_2: VkStructureType = 1000314004;100pub const VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO: VkStructureType = 1000314005;101pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO: VkStructureType = 1000314006;102pub const VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2: VkStructureType = 1000059002;103pub const VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO: VkStructureType = 1000072001;104pub const VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO: VkStructureType = 1000072002;105pub const VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR: VkStructureType = 1000074002;106pub const VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO: VkStructureType = 1000077000;107pub const VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR: VkStructureType = 1000079001;108pub const VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO: VkStructureType = 1000127001;109pub const VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: VkStructureType = 1000158000;110pub const VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: VkStructureType = 1000158003;111pub const VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT: VkStructureType = 1000158005;112pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT: VkStructureType = 1000353000;113114pub const VkSemaphoreType = u32;115pub const VK_SEMAPHORE_TYPE_BINARY: VkSemaphoreType = 0;116pub const VK_SEMAPHORE_TYPE_TIMELINE: VkSemaphoreType = 1;117118pub const VkQueueFlags = u32;119pub const VK_QUEUE_GRAPHICS_BIT: VkQueueFlags = 0x00000001;120pub const VK_QUEUE_COMPUTE_BIT: VkQueueFlags = 0x00000002;121pub const VK_QUEUE_TRANSFER_BIT: VkQueueFlags = 0x00000004;122pub const VK_QUEUE_SPARSE_BINDING_BIT: VkQueueFlags = 0x00000008;123124pub const VkCommandPoolCreateFlags = u32;125pub const VK_COMMAND_POOL_CREATE_TRANSIENT_BIT: VkCommandPoolCreateFlags = 0x00000001;126pub const VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT: VkCommandPoolCreateFlags = 0x00000002;127128pub const VkDescriptorPoolResetFlags = u32;129130pub const VkCommandBufferLevel = u32;131pub const VK_COMMAND_BUFFER_LEVEL_PRIMARY: VkCommandBufferLevel = 0;132pub const VK_COMMAND_BUFFER_LEVEL_SECONDARY: VkCommandBufferLevel = 1;133134pub const VkCommandBufferUsageFlags = u32;135pub const VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT: VkCommandBufferUsageFlags = 0x00000001;136pub const VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT: VkCommandBufferUsageFlags = 0x00000002;137pub const VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT: VkCommandBufferUsageFlags = 0x00000004;138139pub const VkBufferUsageFlags = u32;140pub const VK_BUFFER_USAGE_TRANSFER_SRC_BIT: VkBufferUsageFlags = 0x00000001;141pub const VK_BUFFER_USAGE_TRANSFER_DST_BIT: VkBufferUsageFlags = 0x00000002;142pub const VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT: VkBufferUsageFlags = 0x00000010;143pub const VK_BUFFER_USAGE_STORAGE_BUFFER_BIT: VkBufferUsageFlags = 0x00000020;144pub const VK_BUFFER_USAGE_INDEX_BUFFER_BIT: VkBufferUsageFlags = 0x00000040;145pub const VK_BUFFER_USAGE_VERTEX_BUFFER_BIT: VkBufferUsageFlags = 0x00000080;146147pub const VkImageUsageFlags = u32;148pub const VK_IMAGE_USAGE_TRANSFER_SRC_BIT: VkImageUsageFlags = 0x00000001;149pub const VK_IMAGE_USAGE_TRANSFER_DST_BIT: VkImageUsageFlags = 0x00000002;150pub const VK_IMAGE_USAGE_SAMPLED_BIT: VkImageUsageFlags = 0x00000004;151pub const VK_IMAGE_USAGE_STORAGE_BIT: VkImageUsageFlags = 0x00000008;152pub const VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT: VkImageUsageFlags = 0x00000010;153pub const VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT: VkImageUsageFlags = 0x00000020;154155pub const VkImageLayout = u32;156pub const VK_IMAGE_LAYOUT_UNDEFINED: VkImageLayout = 0;157pub const VK_IMAGE_LAYOUT_GENERAL: VkImageLayout = 1;158pub const VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL: VkImageLayout = 2;159pub const VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL: VkImageLayout = 5;160pub const VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL: VkImageLayout = 6;161pub const VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL: VkImageLayout = 7;162pub const VK_IMAGE_LAYOUT_PRESENT_SRC_KHR: VkImageLayout = 1000001002;163pub const VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL: VkImageLayout = 1000241000;164165pub const VkAccessFlags = u32;166pub const VK_ACCESS_INDEX_READ_BIT: VkAccessFlags = 0x00000002;167pub const VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT: VkAccessFlags = 0x00000004;168pub const VK_ACCESS_UNIFORM_READ_BIT: VkAccessFlags = 0x00000008;169pub const VK_ACCESS_SHADER_READ_BIT: VkAccessFlags = 0x00000020;170pub const VK_ACCESS_SHADER_WRITE_BIT: VkAccessFlags = 0x00000040;171pub const VK_ACCESS_COLOR_ATTACHMENT_READ_BIT: VkAccessFlags = 0x00000080;172pub const VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT: VkAccessFlags = 0x00000100;173pub const VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT: VkAccessFlags = 0x00000200;174pub const VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT: VkAccessFlags = 0x00000400;175pub const VK_ACCESS_TRANSFER_READ_BIT: VkAccessFlags = 0x00000800;176pub const VK_ACCESS_TRANSFER_WRITE_BIT: VkAccessFlags = 0x00001000;177pub const VK_ACCESS_HOST_READ_BIT: VkAccessFlags = 0x00002000;178pub const VK_ACCESS_HOST_WRITE_BIT: VkAccessFlags = 0x00004000;179pub const VK_ACCESS_MEMORY_READ_BIT: VkAccessFlags = 0x00008000;180pub const VK_ACCESS_MEMORY_WRITE_BIT: VkAccessFlags = 0x00010000;181182pub const VkPipelineStageFlags = u32;183pub const VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT: VkPipelineStageFlags = 0x00000001;184pub const VK_PIPELINE_STAGE_VERTEX_INPUT_BIT: VkPipelineStageFlags = 0x00000004;185pub const VK_PIPELINE_STAGE_VERTEX_SHADER_BIT: VkPipelineStageFlags = 0x00000008;186pub const VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT: VkPipelineStageFlags = 0x00000080;187pub const VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT: VkPipelineStageFlags = 0x00000100;188pub const VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT: VkPipelineStageFlags = 0x00000200;189pub const VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT: VkPipelineStageFlags = 0x00000400;190pub const VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT: VkPipelineStageFlags = 0x00000800;191pub const VK_PIPELINE_STAGE_TRANSFER_BIT: VkPipelineStageFlags = 0x00001000;192pub const VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT: VkPipelineStageFlags = 0x00002000;193pub const VK_PIPELINE_STAGE_HOST_BIT: VkPipelineStageFlags = 0x00004000;194pub const VK_PIPELINE_STAGE_ALL_COMMANDS_BIT: VkPipelineStageFlags = 0x00010000;195196pub const VkDependencyFlags = u32;197198pub const VkQueryType = u32;199pub const VK_QUERY_TYPE_TIMESTAMP: VkQueryType = 2;200201pub const VkQueryResultFlags = u32;202pub const VK_QUERY_RESULT_64_BIT: VkQueryResultFlags = 0x00000001;203204pub const VkImageAspectFlags = u32;205pub const VK_IMAGE_ASPECT_COLOR_BIT: VkImageAspectFlags = 0x00000001;206pub const VK_IMAGE_ASPECT_DEPTH_BIT: VkImageAspectFlags = 0x00000002;207pub const VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT: VkImageAspectFlags = 0x00000080;208pub const VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT: VkImageAspectFlags = 0x00000100;209pub const VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT: VkImageAspectFlags = 0x00000200;210pub const VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT: VkImageAspectFlags = 0x00000400;211212pub 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.214pub const VK_QUEUE_FAMILY_FOREIGN_EXT: u32 = std.math.maxInt(u32) - 2;215216pub const VkExternalMemoryHandleTypeFlags = u32;217pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT: VkExternalMemoryHandleTypeFlags = 0x00000200;218pub const VkExternalSemaphoreHandleTypeFlags = u32;219pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT: VkExternalSemaphoreHandleTypeFlags = 0x00000010;220221pub const VkSharingMode = u32;222pub const VK_SHARING_MODE_EXCLUSIVE: VkSharingMode = 0;223pub const VK_SHARING_MODE_CONCURRENT: VkSharingMode = 1;224225pub const VkMemoryPropertyFlags = u32;226pub const VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT: VkMemoryPropertyFlags = 0x00000001;227pub const VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT: VkMemoryPropertyFlags = 0x00000002;228pub const VK_MEMORY_PROPERTY_HOST_COHERENT_BIT: VkMemoryPropertyFlags = 0x00000004;229pub const VK_MEMORY_PROPERTY_HOST_CACHED_BIT: VkMemoryPropertyFlags = 0x00000008;230pub const VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT: VkMemoryPropertyFlags = 0x00000010;231232pub const VkDescriptorType = u32;233pub const VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: VkDescriptorType = 1;234pub const VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: VkDescriptorType = 6;235pub const VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: VkDescriptorType = 7;236237pub const VkShaderStageFlags = u32;238pub const VK_SHADER_STAGE_VERTEX_BIT: VkShaderStageFlags = 0x00000001;239pub const VK_SHADER_STAGE_FRAGMENT_BIT: VkShaderStageFlags = 0x00000010;240pub const VK_SHADER_STAGE_COMPUTE_BIT: VkShaderStageFlags = 0x00000020;241pub const VK_SHADER_STAGE_ALL: VkShaderStageFlags = 0x7FFFFFFF;242243pub const VkSubgroupFeatureFlags = u32;244pub const VK_SUBGROUP_FEATURE_BASIC_BIT: VkSubgroupFeatureFlags = 0x00000001;245pub const VK_SUBGROUP_FEATURE_VOTE_BIT: VkSubgroupFeatureFlags = 0x00000002;246pub const VK_SUBGROUP_FEATURE_ARITHMETIC_BIT: VkSubgroupFeatureFlags = 0x00000004;247pub const VK_SUBGROUP_FEATURE_BALLOT_BIT: VkSubgroupFeatureFlags = 0x00000008;248pub const VK_SUBGROUP_FEATURE_SHUFFLE_BIT: VkSubgroupFeatureFlags = 0x00000010;249pub const VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT: VkSubgroupFeatureFlags = 0x00000020;250251pub const VkPipelineBindPoint = u32;252pub const VK_PIPELINE_BIND_POINT_GRAPHICS: VkPipelineBindPoint = 0;253pub const VK_PIPELINE_BIND_POINT_COMPUTE: VkPipelineBindPoint = 1;254255pub const VkDescriptorPoolCreateFlags = u32;256pub const VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT: VkDescriptorPoolCreateFlags = 0x00000001;257258pub const VK_MAX_EXTENSION_NAME_SIZE: usize = 256;259pub const VK_MAX_PHYSICAL_DEVICE_NAME_SIZE: usize = 256;260pub const VK_UUID_SIZE: usize = 16;261pub const VK_MAX_MEMORY_TYPES: usize = 32;262pub const VK_MAX_MEMORY_HEAPS: usize = 16;263264pub const VK_WHOLE_TIMEOUT: u64 = std.math.maxInt(u64);265266pub const VK_WHOLE_SIZE: u64 = std.math.maxInt(u64);267268pub const VK_API_VERSION_1_0: u32 = (0 << 22) | (0 << 12) | 0;269pub const VK_API_VERSION_1_1: u32 = (1 << 22) | (1 << 12) | 0;270pub const VK_API_VERSION_1_2: u32 = (1 << 22) | (2 << 12) | 0;271pub const VK_API_VERSION_1_3: u32 = (1 << 22) | (3 << 12) | 0;272273pub const VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME = "VK_KHR_timeline_semaphore";274pub const VK_KHR_SURFACE_EXTENSION_NAME = "VK_KHR_surface";275pub const VK_KHR_XLIB_SURFACE_EXTENSION_NAME = "VK_KHR_xlib_surface";276pub const VK_KHR_SWAPCHAIN_EXTENSION_NAME = "VK_KHR_swapchain";277pub const VK_KHR_16BIT_STORAGE_EXTENSION_NAME = "VK_KHR_16bit_storage";278pub const VK_KHR_8BIT_STORAGE_EXTENSION_NAME = "VK_KHR_8bit_storage";279pub const VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME = "VK_KHR_shader_float16_int8";280pub const VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME = "VK_EXT_image_drm_format_modifier";281pub const VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME = "VK_KHR_external_memory_fd";282pub const VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME = "VK_EXT_external_memory_dma_buf";283pub const VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME = "VK_KHR_external_semaphore_fd";284pub const VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME = "VK_EXT_queue_family_foreign";285pub const VK_EXT_PHYSICAL_DEVICE_DRM_EXTENSION_NAME = "VK_EXT_physical_device_drm";286287pub const VkFormat = u32;288pub const VK_FORMAT_UNDEFINED: VkFormat = 0;289pub const VK_FORMAT_R8G8B8A8_UNORM: VkFormat = 37;290pub const VK_FORMAT_R8G8B8A8_SRGB: VkFormat = 43;291pub const VK_FORMAT_B8G8R8A8_UNORM: VkFormat = 44;292pub const VK_FORMAT_B8G8R8A8_SRGB: VkFormat = 50;293pub const VK_FORMAT_R32_UINT: VkFormat = 98;294pub const VK_FORMAT_R32_SFLOAT: VkFormat = 100;295pub const VK_FORMAT_R32G32_UINT: VkFormat = 101;296pub const VK_FORMAT_R32G32_SFLOAT: VkFormat = 103;297pub const VK_FORMAT_R32G32B32_SFLOAT: VkFormat = 106;298pub const VK_FORMAT_R32G32B32A32_UINT: VkFormat = 107;299pub const VK_FORMAT_R32G32B32A32_SFLOAT: VkFormat = 109;300pub const VK_FORMAT_D32_SFLOAT: VkFormat = 126;301302pub const VkFormatFeatureFlags = u32;303pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT: VkFormatFeatureFlags = 0x00000001;304pub const VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT: VkFormatFeatureFlags = 0x00000080;305pub const VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT: VkFormatFeatureFlags = 0x00000100;306pub const VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT: VkFormatFeatureFlags = 0x00000200;307pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT: VkFormatFeatureFlags = 0x00001000;308pub const VK_FORMAT_FEATURE_TRANSFER_SRC_BIT: VkFormatFeatureFlags = 0x00004000;309pub const VK_FORMAT_FEATURE_TRANSFER_DST_BIT: VkFormatFeatureFlags = 0x00008000;310311pub const VkImageType = u32;312pub const VK_IMAGE_TYPE_2D: VkImageType = 1;313314pub const VkImageViewType = u32;315pub const VK_IMAGE_VIEW_TYPE_2D: VkImageViewType = 1;316317pub const VkImageTiling = u32;318pub const VK_IMAGE_TILING_OPTIMAL: VkImageTiling = 0;319pub const VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT: VkImageTiling = 1000158000;320321pub const VK_SAMPLE_COUNT_1_BIT: VkSampleCountFlags = 0x00000001;322323pub const VkComponentSwizzle = u32;324pub const VK_COMPONENT_SWIZZLE_IDENTITY: VkComponentSwizzle = 0;325326pub const VkFilter = u32;327pub const VK_FILTER_NEAREST: VkFilter = 0;328pub const VK_FILTER_LINEAR: VkFilter = 1;329330pub const VkSamplerMipmapMode = u32;331pub const VK_SAMPLER_MIPMAP_MODE_NEAREST: VkSamplerMipmapMode = 0;332333pub const VkSamplerAddressMode = u32;334pub const VK_SAMPLER_ADDRESS_MODE_REPEAT: VkSamplerAddressMode = 0;335pub const VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE: VkSamplerAddressMode = 2;336337pub const VkBorderColor = u32;338pub const VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK: VkBorderColor = 0;339340pub const VkCompareOp = u32;341pub const VK_COMPARE_OP_NEVER: VkCompareOp = 0;342pub const VK_COMPARE_OP_LESS: VkCompareOp = 1;343pub const VK_COMPARE_OP_EQUAL: VkCompareOp = 2;344pub const VK_COMPARE_OP_LESS_OR_EQUAL: VkCompareOp = 3;345pub const VK_COMPARE_OP_GREATER: VkCompareOp = 4;346pub const VK_COMPARE_OP_NOT_EQUAL: VkCompareOp = 5;347pub const VK_COMPARE_OP_GREATER_OR_EQUAL: VkCompareOp = 6;348pub const VK_COMPARE_OP_ALWAYS: VkCompareOp = 7;349350pub const VkVertexInputRate = u32;351pub const VK_VERTEX_INPUT_RATE_VERTEX: VkVertexInputRate = 0;352pub const VK_VERTEX_INPUT_RATE_INSTANCE: VkVertexInputRate = 1;353354pub const VkPrimitiveTopology = u32;355pub const VK_PRIMITIVE_TOPOLOGY_LINE_LIST: VkPrimitiveTopology = 1;356pub const VK_PRIMITIVE_TOPOLOGY_LINE_STRIP: VkPrimitiveTopology = 2;357pub const VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST: VkPrimitiveTopology = 3;358pub const VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP: VkPrimitiveTopology = 4;359360pub const VkPolygonMode = u32;361pub const VK_POLYGON_MODE_FILL: VkPolygonMode = 0;362363pub const VkCullModeFlags = u32;364pub const VK_CULL_MODE_NONE: VkCullModeFlags = 0;365366pub const VkFrontFace = u32;367pub const VK_FRONT_FACE_COUNTER_CLOCKWISE: VkFrontFace = 0;368pub const VK_FRONT_FACE_CLOCKWISE: VkFrontFace = 1;369370pub const VkBlendFactor = u32;371pub const VK_BLEND_FACTOR_ZERO: VkBlendFactor = 0;372pub const VK_BLEND_FACTOR_ONE: VkBlendFactor = 1;373pub const VK_BLEND_FACTOR_SRC_ALPHA: VkBlendFactor = 6;374pub const VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA: VkBlendFactor = 7;375376pub const VkBlendOp = u32;377pub const VK_BLEND_OP_ADD: VkBlendOp = 0;378379pub const VkColorComponentFlags = u32;380pub const VK_COLOR_COMPONENT_R_BIT: VkColorComponentFlags = 0x00000001;381pub const VK_COLOR_COMPONENT_G_BIT: VkColorComponentFlags = 0x00000002;382pub const VK_COLOR_COMPONENT_B_BIT: VkColorComponentFlags = 0x00000004;383pub const VK_COLOR_COMPONENT_A_BIT: VkColorComponentFlags = 0x00000008;384385pub const VkDynamicState = u32;386pub const VK_DYNAMIC_STATE_VIEWPORT: VkDynamicState = 0;387pub const VK_DYNAMIC_STATE_SCISSOR: VkDynamicState = 1;388389pub const VkAttachmentLoadOp = u32;390pub const VK_ATTACHMENT_LOAD_OP_LOAD: VkAttachmentLoadOp = 0;391pub const VK_ATTACHMENT_LOAD_OP_CLEAR: VkAttachmentLoadOp = 1;392393pub const VkAttachmentStoreOp = u32;394pub const VK_ATTACHMENT_STORE_OP_STORE: VkAttachmentStoreOp = 0;395396pub const VkResolveModeFlags = u32;397pub const VK_RESOLVE_MODE_NONE: VkResolveModeFlags = 0;398399pub const VkIndexType = u32;400pub const VK_INDEX_TYPE_UINT16: VkIndexType = 0;401pub const VK_INDEX_TYPE_UINT32: VkIndexType = 1;402403pub const VkColorSpaceKHR = u32;404pub const VK_COLOR_SPACE_SRGB_NONLINEAR_KHR: VkColorSpaceKHR = 0;405406pub const VkPresentModeKHR = u32;407pub const VK_PRESENT_MODE_IMMEDIATE_KHR: VkPresentModeKHR = 0;408pub const VK_PRESENT_MODE_MAILBOX_KHR: VkPresentModeKHR = 1;409pub const VK_PRESENT_MODE_FIFO_KHR: VkPresentModeKHR = 2;410411pub const VkSurfaceTransformFlagsKHR = u32;412pub const VkSurfaceTransformFlagBitsKHR = u32;413pub const VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR: VkSurfaceTransformFlagBitsKHR = 0x00000001;414pub const VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR: VkSurfaceTransformFlagBitsKHR = 0x00000100;415416pub const VkCompositeAlphaFlagsKHR = u32;417pub const VkCompositeAlphaFlagBitsKHR = u32;418pub const VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR: VkCompositeAlphaFlagBitsKHR = 0x00000001;419pub const VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR: VkCompositeAlphaFlagBitsKHR = 0x00000002;420pub const VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR: VkCompositeAlphaFlagBitsKHR = 0x00000004;421pub const VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR: VkCompositeAlphaFlagBitsKHR = 0x00000008;422423pub 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};450451pub 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};476477pub 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};486487pub 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};497498pub 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};506507pub 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};519520pub const VkSemaphoreCreateInfo = extern struct {521    sType: VkStructureType,522    pNext: ?*const anyopaque,523    flags: u32,524};525526pub const VkQueryPoolCreateInfo = extern struct {527    sType: VkStructureType,528    pNext: ?*const anyopaque,529    flags: u32,530    queryType: VkQueryType,531    queryCount: u32,532    pipelineStatistics: u32,533};534535pub const VkSemaphoreTypeCreateInfo = extern struct {536    sType: VkStructureType,537    pNext: ?*const anyopaque,538    semaphoreType: VkSemaphoreType,539    initialValue: u64,540};541542pub 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};550551pub const VkSemaphoreSignalInfo = extern struct {552    sType: VkStructureType,553    pNext: ?*const anyopaque,554    semaphore: VkSemaphore,555    value: u64,556};557558pub const VkCommandPoolCreateInfo = extern struct {559    sType: VkStructureType,560    pNext: ?*const anyopaque,561    flags: VkCommandPoolCreateFlags,562    queueFamilyIndex: u32,563};564565pub const VkCommandBufferAllocateInfo = extern struct {566    sType: VkStructureType,567    pNext: ?*const anyopaque,568    commandPool: VkCommandPool,569    level: VkCommandBufferLevel,570    commandBufferCount: u32,571};572573pub const VkSemaphoreSubmitInfo = extern struct {574    sType: VkStructureType,575    pNext: ?*const anyopaque,576    semaphore: VkSemaphore,577    value: u64,578    stageMask: u64,579    deviceIndex: u32,580};581582pub const VkCommandBufferSubmitInfo = extern struct {583    sType: VkStructureType,584    pNext: ?*const anyopaque,585    commandBuffer: VkCommandBuffer,586    deviceMask: u32,587};588589pub 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};600601pub const VkExtent3D = extern struct {602    width: u32,603    height: u32,604    depth: u32,605};606607pub const VkOffset3D = extern struct {608    x: i32,609    y: i32,610    z: i32,611};612613pub const VkExtent2D = extern struct {614    width: u32,615    height: u32,616};617618pub const VkImageSubresourceRange = extern struct {619    aspectMask: VkImageAspectFlags,620    baseMipLevel: u32,621    levelCount: u32,622    baseArrayLayer: u32,623    layerCount: u32,624};625626pub const VkImageSubresourceLayers = extern struct {627    aspectMask: VkImageAspectFlags,628    mipLevel: u32,629    baseArrayLayer: u32,630    layerCount: u32,631};632633pub const VkMemoryBarrier = extern struct {634    sType: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_BARRIER,635    pNext: ?*const anyopaque = null,636    srcAccessMask: VkAccessFlags,637    dstAccessMask: VkAccessFlags,638};639640pub 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};652653pub 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};664665pub const VkBufferCopy = extern struct {666    srcOffset: u64,667    dstOffset: u64,668    size: u64,669};670671pub const VkBufferImageCopy = extern struct {672    bufferOffset: u64,673    bufferRowLength: u32,674    bufferImageHeight: u32,675    imageSubresource: VkImageSubresourceLayers,676    imageOffset: VkOffset3D,677    imageExtent: VkExtent3D,678};679680pub const VkClearColorValue = extern union {681    float32: [4]f32,682    int32: [4]i32,683    uint32: [4]u32,684};685686pub 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};698699pub const VkSurfaceFormatKHR = extern struct {700    format: VkFormat,701    colorSpace: VkColorSpaceKHR,702};703704pub const VkXlibSurfaceCreateInfoKHR = extern struct {705    sType: VkStructureType,706    pNext: ?*const anyopaque,707    flags: u32,708    dpy: VkDisplay,709    window: VkWindow,710};711712pub 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};732733pub 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};743744pub const VkQueueFamilyProperties = extern struct {745    queueFlags: VkQueueFlags,746    queueCount: u32,747    timestampValidBits: u32,748    minImageTransferGranularity: VkExtent3D,749};750751pub const VkExtensionProperties = extern struct {752    extensionName: [VK_MAX_EXTENSION_NAME_SIZE]u8,753    specVersion: u32,754755    pub fn name(self: *const VkExtensionProperties) []const u8 {756        return std.mem.sliceTo(self.extensionName[0..], 0);757    }758};759760pub 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};817818pub const VkPhysicalDeviceFeatures2 = extern struct {819    sType: VkStructureType,820    pNext: ?*anyopaque,821    features: VkPhysicalDeviceFeatures,822};823824pub const VkPhysicalDevice16BitStorageFeatures = extern struct {825    sType: VkStructureType,826    pNext: ?*anyopaque,827    storageBuffer16BitAccess: VkBool32,828    uniformAndStorageBuffer16BitAccess: VkBool32,829    storagePushConstant16: VkBool32,830    storageInputOutput16: VkBool32,831};832833pub const VkPhysicalDevice8BitStorageFeatures = extern struct {834    sType: VkStructureType,835    pNext: ?*anyopaque,836    storageBuffer8BitAccess: VkBool32,837    uniformAndStorageBuffer8BitAccess: VkBool32,838    storagePushConstant8: VkBool32,839};840841pub const VkPhysicalDeviceTimelineSemaphoreFeatures = extern struct {842    sType: VkStructureType,843    pNext: ?*anyopaque,844    timelineSemaphore: VkBool32,845};846847pub const VkSampleCountFlags = u32;848849pub 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};957958pub const VkPhysicalDeviceSparseProperties = extern struct {959    residencyStandard2DBlockShape: VkBool32,960    residencyStandard2DMultisampleBlockShape: VkBool32,961    residencyStandard3DBlockShape: VkBool32,962    residencyAlignedMipSize: VkBool32,963    residencyNonResidentStrict: VkBool32,964};965966pub 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};977978pub const VkPhysicalDeviceProperties2 = extern struct {979    sType: VkStructureType,980    pNext: ?*anyopaque,981    properties: VkPhysicalDeviceProperties,982};983984pub const VkPhysicalDeviceSubgroupProperties = extern struct {985    sType: VkStructureType,986    pNext: ?*anyopaque,987    subgroupSize: u32,988    supportedStages: VkShaderStageFlags,989    supportedOperations: VkSubgroupFeatureFlags,990    quadOperationsInAllStages: VkBool32,991};992993pub const VkMemoryType = extern struct {994    propertyFlags: VkMemoryPropertyFlags,995    heapIndex: u32,996};997998pub const VkMemoryHeap = extern struct {999    size: u64,1000    flags: u32,1001    _pad: u32 = 0,1002};10031004pub 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};10101011pub const VkMemoryRequirements = extern struct {1012    size: u64,1013    alignment: u64,1014    memoryTypeBits: u32,1015    _pad: u32 = 0,1016};10171018pub const VkMemoryAllocateInfo = extern struct {1019    sType: VkStructureType,1020    pNext: ?*const anyopaque,1021    allocationSize: u64,1022    memoryTypeIndex: u32,1023    _pad: u32 = 0,1024};10251026pub const VkMappedMemoryRange = extern struct {1027    sType: VkStructureType,1028    pNext: ?*const anyopaque,1029    memory: VkDeviceMemory,1030    offset: u64,1031    size: u64,1032};10331034pub 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};10461047pub 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};10551056pub const VkPushConstantRange = extern struct {1057    stageFlags: VkShaderStageFlags,1058    offset: u32,1059    size: u32,1060};10611062pub 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};10721073pub const VkDescriptorSetLayoutBinding = extern struct {1074    binding: u32,1075    descriptorType: VkDescriptorType,1076    descriptorCount: u32,1077    stageFlags: VkShaderStageFlags,1078    pImmutableSamplers: ?*const anyopaque,1079};10801081pub const VkDescriptorSetLayoutCreateInfo = extern struct {1082    sType: VkStructureType,1083    pNext: ?*const anyopaque,1084    flags: u32,1085    bindingCount: u32,1086    pBindings: ?[*]const VkDescriptorSetLayoutBinding,1087};10881089pub const VkSpecializationMapEntry = extern struct {1090    constantID: u32,1091    offset: u32,1092    size: usize,1093};10941095pub const VkSpecializationInfo = extern struct {1096    mapEntryCount: u32,1097    _pad: u32 = 0,1098    pMapEntries: ?[*]const VkSpecializationMapEntry,1099    dataSize: usize,1100    pData: ?*const anyopaque,1101};11021103pub 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};11121113pub 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};11241125pub const VkDescriptorPoolSize = extern struct {1126    type: VkDescriptorType,1127    descriptorCount: u32,1128};11291130pub 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};11391140pub 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};11481149pub const VkDescriptorBufferInfo = extern struct {1150    buffer: VkBuffer,1151    offset: u64,1152    range: u64,1153};11541155pub 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};11671168pub const VkCommandBufferBeginInfo = extern struct {1169    sType: VkStructureType,1170    pNext: ?*const anyopaque,1171    flags: VkCommandBufferUsageFlags,1172    _pad: u32 = 0,1173    pInheritanceInfo: ?*const anyopaque,1174};11751176pub 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};11951196pub const VkFormatProperties = extern struct {1197    linearTilingFeatures: VkFormatFeatureFlags,1198    optimalTilingFeatures: VkFormatFeatureFlags,1199    bufferFeatures: VkFormatFeatureFlags,1200};12011202pub 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};12071208pub const VkDrmFormatModifierPropertiesEXT = extern struct {1209    drmFormatModifier: u64,1210    drmFormatModifierPlaneCount: u32,1211    drmFormatModifierTilingFeatures: VkFormatFeatureFlags,1212};12131214pub 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};12201221pub 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};12271228pub 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};12331234pub const VkExternalMemoryImageCreateInfo = extern struct {1235    sType: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO,1236    pNext: ?*const anyopaque = null,1237    handleTypes: VkExternalMemoryHandleTypeFlags,1238};12391240pub const VkExportMemoryAllocateInfo = extern struct {1241    sType: VkStructureType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO,1242    pNext: ?*const anyopaque = null,1243    handleTypes: VkExternalMemoryHandleTypeFlags,1244};12451246pub 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};12521253pub 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};12591260pub const VkExportSemaphoreCreateInfo = extern struct {1261    sType: VkStructureType = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO,1262    pNext: ?*const anyopaque = null,1263    handleTypes: VkExternalSemaphoreHandleTypeFlags,1264};12651266pub 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};12721273pub 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};12831284pub const VkImageSubresource = extern struct {1285    aspectMask: VkImageAspectFlags,1286    mipLevel: u32 = 0,1287    arrayLayer: u32 = 0,1288};12891290pub 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};12971298pub 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};13151316pub 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};13221323pub 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};13331334pub 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};13541355pub const VkDescriptorImageInfo = extern struct {1356    sampler: VkSampler,1357    imageView: VkImageView,1358    imageLayout: VkImageLayout,1359};13601361pub const VkVertexInputBindingDescription = extern struct {1362    binding: u32,1363    stride: u32,1364    inputRate: VkVertexInputRate,1365};13661367pub const VkVertexInputAttributeDescription = extern struct {1368    location: u32,1369    binding: u32,1370    format: VkFormat,1371    offset: u32,1372};13731374pub 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};13831384pub const VkPipelineInputAssemblyStateCreateInfo = extern struct {1385    sType: VkStructureType,1386    pNext: ?*const anyopaque,1387    flags: u32,1388    topology: VkPrimitiveTopology,1389    primitiveRestartEnable: VkBool32,1390};13911392pub const VkViewport = extern struct {1393    x: f32,1394    y: f32,1395    width: f32,1396    height: f32,1397    minDepth: f32,1398    maxDepth: f32,1399};14001401pub const VkOffset2D = extern struct {1402    x: i32,1403    y: i32,1404};14051406pub const VkRect2D = extern struct {1407    offset: VkOffset2D,1408    extent: VkExtent2D,1409};14101411pub 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};14201421pub 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};14361437pub 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};14481449pub 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};14581459pub 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};14731474pub 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};14841485pub 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};14951496pub const VkPipelineDynamicStateCreateInfo = extern struct {1497    sType: VkStructureType,1498    pNext: ?*const anyopaque,1499    flags: u32,1500    dynamicStateCount: u32,1501    pDynamicStates: ?[*]const VkDynamicState,1502};15031504pub 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};15131514pub 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};15351536pub const VkClearDepthStencilValue = extern struct {1537    depth: f32,1538    stencil: u32,1539};15401541pub const VkClearValue = extern union {1542    color: VkClearColorValue,1543    depthStencil: VkClearDepthStencilValue,1544};15451546pub 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};15581559pub 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};15711572pub fn platformSupported() bool {1573    return dynamic.hasHostCandidate(dynamic.vulkanLoaderCandidates());1574}15751576fn openLoaderLibrary() Error!dynamic.Library {1577    return dynamic.openVulkanLoader() catch return error.DriverUnavailable;1578}15791580const ResultDiagnostic = enum {1581    none,1582    unexpected_positive,1583    unmapped,1584};15851586fn 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}16171618fn mapResultQuiet(r: VkResult) Error!void {1619    if (r == .success) return;16201621    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}16441645pub const Driver = struct {1646    lib: dynamic.Library,16471648    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,16501651    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,16681669    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,16901691    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,17521753    pub fn open(allocator: std.mem.Allocator) Error!Driver {1754        _ = allocator;17551756        var lib = try openLoaderLibrary();1757        errdefer lib.close();17581759        var driver: Driver = undefined;1760        driver.lib = lib;17611762        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;17671768        driver.vkCreateInstance = try lookupGlobal(1769            &driver,1770            @TypeOf(driver.vkCreateInstance),1771            "vkCreateInstance",1772        );17731774        return driver;1775    }17761777    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    }17841785    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    }17921793    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    }18001801    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    }18211822    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");18441845        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    }19021903    /// Loads the entry points of VK_EXT_image_drm_format_modifier, VK_KHR_external_memory_fd and1904    /// 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    }19101911    pub fn close(self: *Driver) void {1912        self.lib.close();1913    }19141915    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};19291930comptime {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}20252026fn skipIfHostHasDriver() !void {2027    if (!platformSupported()) return error.SkipZigTest;2028    if (dynamic.isVulkanLoaderLoadable()) return error.SkipZigTest;2029}20302031test "Driver.open without libvulkan returns DriverUnavailable" {2032    try skipIfHostHasDriver();2033    try std.testing.expectError(Error.DriverUnavailable, Driver.open(std.testing.allocator));2034}20352036test "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}20622063test "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}20682069test "fromResult on success returns without error" {2070    var stub: Driver = undefined;2071    try stub.fromResult(.success);2072}20732074test "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}21002101test "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}21062107test "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}21112112test "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;22182219    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}22392240test "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}22532254test "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}22822283test "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}23212322test "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}23332334test "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}23402341test "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}23472348test "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}23562357test "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}23662367test "platformSupported reflects the loader-target set" {2368    try std.testing.expectEqual(2369        dynamic.hasHostCandidate(dynamic.vulkanLoaderCandidates()),2370        platformSupported(),2371    );2372}23732374test "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}24262427test "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}