Skip to content

The animation engine for agents: blazingly fast math and 3D videos with Manim's Python API, on a Rust GPU core.

Python

Package Lavapipe for Linux

apoogdk87ef4d5a519b
diff --git a/rust/engine/src/lavapipe.rs b/rust/engine/src/lavapipe.rs
new file mode 100644
index 00000000..7fe2638b
--- /dev/null
+++ b/rust/engine/src/lavapipe.rs
@@ -0,0 +1,65 @@
+//! Mesa's lavapipe, Vulkan on the CPU, for a Linux machine with no GPU driver: the Linux wheels
+//! bundle it beside the engine (`manimgx/lavapipe/libvulkan_lvp.so`, made by
+//! `scripts/build_lavapipe.sh`). The engine loads it itself, as Vulkan's loader loads a driver,
+//! and gives wgpu an instance of it: neither the system's loader nor the environment is involved.
+
+/// An instance of the bundled lavapipe; None where there is none (not Linux, or an engine built
+/// from source); an error saying why, when it is there but cannot be used.
+#[cfg(target_os = "linux")]
+pub fn instance() -> Result<Option<wgpu::Instance>, String> {
+ use std::ffi::{CStr, CString, OsStr};
+ use std::os::unix::ffi::{OsStrExt, OsStringExt};
+
+ use ash::vk;
+ use wgpu::hal::{api::Vulkan, vulkan};
+
+ unsafe {
+ // the engine's folder, then the driver in it
+ let mut engine: libc::Dl_info = std::mem::zeroed();
+ if libc::dladdr(instance as *const libc::c_void, &mut engine) == 0 || engine.dli_fname.is_null() {
+ return Err("the engine cannot find its own file".into());
+ }
+ let engine = std::path::Path::new(OsStr::from_bytes(CStr::from_ptr(engine.dli_fname).to_bytes()));
+ let path = engine.with_file_name("lavapipe").join("libvulkan_lvp.so");
+ if !path.exists() {
+ return Ok(None);
+ }
+ let name = CString::new(path.into_os_string().into_vec()).map_err(|e| e.to_string())?;
+ let library = libc::dlopen(name.as_ptr(), libc::RTLD_NOW | libc::RTLD_LOCAL);
+ if library.is_null() {
+ return Err(CStr::from_ptr(libc::dlerror()).to_string_lossy().into_owned());
+ }
+ // a driver's entry points, as the loader finds them: its interface version agreed first
+ let negotiate = libc::dlsym(library, c"vk_icdNegotiateLoaderICDInterfaceVersion".as_ptr());
+ let get_instance_proc_addr = libc::dlsym(library, c"vk_icdGetInstanceProcAddr".as_ptr());
+ if negotiate.is_null() || get_instance_proc_addr.is_null() {
+ return Err(format!("{} is no Vulkan driver", name.to_string_lossy()));
+ }
+ let negotiate: unsafe extern "system" fn(*mut u32) -> vk::Result = std::mem::transmute(negotiate);
+ let mut version = 7;
+ let negotiated = negotiate(&mut version);
+ if negotiated != vk::Result::SUCCESS {
+ return Err(format!("its loader interface: {negotiated}"));
+ }
+ let get_instance_proc_addr: vk::PFN_vkGetInstanceProcAddr = std::mem::transmute(get_instance_proc_addr);
+ let entry = ash::Entry::from_static_fn(ash::StaticFn { get_instance_proc_addr });
+ // the instance wgpu-hal would make (Instance::init_with_callback), from this entry
+ let api = entry.try_enumerate_instance_version().map_err(|e| e.to_string())?.unwrap_or(vk::API_VERSION_1_0);
+ let flags = wgpu::InstanceFlags::default();
+ let extensions = vulkan::Instance::desired_extensions(&entry, api, flags).map_err(|e| e.to_string())?;
+ let names: Vec<_> = extensions.iter().map(|name| name.as_ptr()).collect();
+ let app = vk::ApplicationInfo::default()
+ .engine_name(c"wgpu-hal")
+ .engine_version(2)
+ .api_version(if api < vk::API_VERSION_1_1 { vk::API_VERSION_1_0 } else { vk::API_VERSION_1_3 });
+ let create = vk::InstanceCreateInfo::default().application_info(&app).enabled_extension_names(&names);
+ let raw = entry.create_instance(&create, None).map_err(|e| format!("vkCreateInstance: {e}"))?;
+ let hal = vulkan::Instance::from_raw(entry, raw, api, 0, None, extensions, flags, Default::default(), false, None).map_err(|e| e.to_string())?;
+ Ok(Some(wgpu::Instance::from_hal::<Vulkan>(hal)))
+ }
+}
+
+#[cfg(not(target_os = "linux"))]
+pub fn instance() -> Result<Option<wgpu::Instance>, String> {
+ Ok(None)
+}