libprocessing ffi error handling (#1293)

* FFI error setup

* Clear before init.

Author: tychedelia

Cargo.lock

@@ -1,8 +1,3 @@
-[package]
-name = "libProcessing"
-version = "0.1.0"
-edition = "2024"
-
 [workspace]
 resolver = "3"
 members = ["ffi","renderer"]

Cargo.toml

@@ -0,0 +1,49 @@
+use std::cell::RefCell;
+use std::ffi::{c_char, CString};
+use renderer::error::ProcessingError;
+
+thread_local! {
+    static LAST_ERROR: RefCell<Option<CString>> = RefCell::new(None);
+}
+
+/// Check if the last operation resulted in an error. Returns a pointer to an error message, or null
+/// if there was no error.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_check_error() -> *const c_char {
+    LAST_ERROR.with(|last| {
+        last.borrow()
+            .as_ref()
+            .map(|s| s.as_ptr())
+            .unwrap_or(std::ptr::null())
+    })
+}
+
+/// Set the last error message.
+pub fn set_error(error_msg: &str) {
+    LAST_ERROR.with(|last| {
+        *last.borrow_mut() = Some(CString::new(error_msg).unwrap_or_else(|_| {
+            CString::new("Failed to allocate error message".to_string()).unwrap()
+        }));
+    });
+}
+
+/// Clear the last error message.
+pub fn clear_error() {
+    LAST_ERROR.with(|last| {
+        *last.borrow_mut() = None;
+    });
+}
+
+
+/// Check the result of an operation, setting the last error if there was one.
+pub fn check<T>(result: Result<T, ProcessingError>) -> Option<T> {
+    match result {
+        Ok(value) => {
+            Some(value)
+        }
+        Err(err) => {
+            set_error(&err.to_string());
+            None
+        }
+    }
+}

ffi/src/error.rs

@@ -1,4 +1,7 @@
+mod error;
+
 #[unsafe(no_mangle)]
-pub extern "C" fn processing_add(left: u64, right: u64) -> u64 {
-    renderer::add(left, right)
+pub extern "C" fn processing_init() {
+    error::clear_error();
+    error::check(renderer::init());
 }

ffi/src/lib.rs

@@ -4,3 +4,9 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
+tracing = "0.1"
+tracing-subscriber = "0.3"
+bevy = { version = "0.16", no-default-features = true, features = [
+    "bevy_render"
+] }
+thiserror = "2"

renderer/Cargo.toml

@@ -0,0 +1,12 @@
+use thiserror::Error;
+
+pub type Result<T> = std::result::Result<T, ProcessingError>;
+
+
+#[derive(Error, Debug)]
+pub enum ProcessingError {
+    #[error("App was accessed from multiple threads")]
+    AppAccess,
+    #[error("Error initializing tracing: {0}")]
+    Tracing(#[from] tracing::subscriber::SetGlobalDefaultError),
+}

renderer/src/error.rs

@@ -1,4 +1,50 @@
-pub fn add(left: u64, right: u64) -> u64 {
-   println!("Adding {} and {} in Rust", left, right);
-    left + right
-}
+pub mod error;
+
+// Once-cell for our app
+use crate::error::Result;
+use bevy::app::App;
+use bevy::log::tracing_subscriber;
+use std::sync::{Arc, Mutex, OnceLock};
+use tracing::{debug, info};
+
+static IS_INIT: OnceLock<()> = OnceLock::new();
+
+thread_local! {
+    static APP: OnceLock<App> = OnceLock::default();
+}
+
+/// Initialize the app, if not already initialized. Must be called from the main thread and cannot
+/// be called concurrently from multiple threads.
+pub fn init() -> Result<()> {
+    setup_tracing()?;
+    info!("Initializing libprocessing");
+
+    let is_init = IS_INIT.get().is_some();
+    let thread_has_app = APP.with(|app_lock| app_lock.get().is_some());
+    if is_init && !thread_has_app {
+        return Err(error::ProcessingError::AppAccess);
+    }
+    if is_init && thread_has_app {
+        debug!("App already initialized");
+        return Ok(());
+    }
+
+    APP.with(|app_lock| {
+        app_lock.get_or_init(|| {
+            IS_INIT.get_or_init(|| ());
+            let mut app = App::new();
+
+            app.add_plugins(bevy::MinimalPlugins);
+
+            app
+        });
+    });
+
+    Ok(())
+}
+
+fn setup_tracing() -> Result<()> {
+    let subscriber = tracing_subscriber::FmtSubscriber::new();
+    tracing::subscriber::set_global_default(subscriber)?;
+    Ok(())
+}