Wrapper for dynamically loaded plugins that can have their own Ui!

[zanciks]

Hey all! I've recently been working on an app, and I'm using egui/eframe. However, one requirement of my app was that it must have dynamically linked runtime plugins, and those plugins have to be able to modify the ui/have their own ui.
I believe I've found a solution for this, and figured I'd share it.

Before I paste a ton of code that you might skip over, I mention this here because I am considering moving the plugin/wrapper code into their own crates, so that people can import them and use it themselves. However, this will be a lot of work, as I have to write wrappers for a lot of egui structs/functions, so I am curious if others would be interested in this.

Inside of the host app, I have main.rs and plugin_instance.rs. There are some other files, but nothing relevant to this topic. Inside of plugin_instance.rs is, well, a PluginInstance struct.

// app/plugin_instance.rs
pub struct PluginInstance {
    pub title: String,
    ptr: *mut c_void,
    render: Symbol<'static, unsafe fn(*mut c_void, &UiWrapper)>,
    _lib: Arc<Library>, // needed to keep in scope for the render symbol
}

I'm using *mut c_void as pointers to Plugins, which for now, are just structs that:

1. Implement a Plugin trait
2. Derive a Plugin proc-macro I created

First, I'll show off the crate with the Plugin trait, and how that works, since it's the most interesting part of this all.
Currently, this crate only has a plugin.rs, lib.rs, and a ui.rs. Plugin.rs looks like this:

// plugin_api/plugin.rs
use super::ui::UiWrapper;
use abi_stable::std_types::RString;
pub trait Plugin {
    // we are using RString so it can be sent between the host app and plugins! Doesn't have to be this way though!
    fn title(&self) -> RString; 
    fn render(&mut self, ui: &UiWrapper);
}

As you can see, it's a very simple trait at the moment. There may be more requirements in the future, but this is all that I have implemented. More interestingly, we have ui.rs!

// plugin_api/ui.rs 
use eframe::egui;

// repr(C) is VERY important! This is what allows us to pass the UiWrapper 
// from the host program into our plugins! 
#[repr(C)]
pub struct UiWrapper {
    ui: *mut egui::Ui,
}

impl UiWrapper {
    pub fn new(ui: &mut egui::Ui) -> Self {
        let ui = ui as *mut egui::Ui;
        UiWrapper { ui }
    }
    pub fn label(&self, text: &str) {
        let ui = unsafe { self.ui.as_mut().unwrap() };
        ui.label(text);
    }
    // ... there is a lot more here
}

This means that, while it would be a lot of work, one could implement wrapper functions for all egui Ui functions that are important to them (along with wrapper structs for things like Response, Grid, Layout, etc)!
Now, to put it to use, I have a little template plugin here:

// template_plugin/lib.rs
use abi_stable::std_types::RString;
use plugin_api::{plugin::Plugin, ui::UiWrapper, Plugin};

#[derive(Default, Plugin)]
struct TemplatePlugin;

impl Plugin for TemplatePlugin {
    fn title(&self) -> RString {
        RString::from("Template Plugin")
    }
    fn render(&mut self, ui: &UiWrapper) {
        ui.label("This is a label from a dll!")
    }
}

Then we just load the plugin in our main app using libloading (or anything else, if you prefer).

// app/plugin_instance.rs
impl PluginInstance {
    pub fn load(path: &str) -> PluginInstance {
        unsafe {
            let library = Arc::new(Library::new(path).unwrap());
            let lib_ref: &'static Library = &*Box::leak(Box::new(Arc::clone(&library)));

            let init: Symbol<unsafe fn() -> *mut c_void> = lib_ref.get(b"init").unwrap();
            let render: Symbol<unsafe fn(*mut c_void, &UiWrapper)> =
                lib_ref.get(b"render").unwrap();
            let title_function: Symbol<unsafe fn(*mut c_void) -> RString> =
                lib_ref.get(b"title").unwrap();

            let ptr = init();
            let title = title_function(ptr).to_string();

            PluginInstance {
                title,
                ptr,
                render,
                _lib: library,
            }
        }
    }
}

Thanks for reading, and please let me know if you have any thoughts, or if you would find runtime plugins for egui useful!

[zanciks]

I've only now realized what I fool I was :P
You don't even have to reimplement the Ui functions, you can just get the UiWrapper's internal Ui and call directly from there lol.