msfs 2024 gauge support

Author: Saschl

msfs/src/msfs.rs

@@ -1,5 +1,26 @@
 use crate::{executor, sys};
 
+impl sys::sGaugeInstallData {
+    /// Get the width of the target gauge texture.
+    pub fn width(&self) -> usize {
+        self.iSizeX as usize
+    }
+
+    /// Get the height of the target gauge texture.
+    pub fn height(&self) -> usize {
+        self.iSizeY as usize
+    }
+
+    /// Get the optional parameter string passed to the gauge.
+    pub fn parameters(&self) -> Option<&std::ffi::CStr> {
+        if self.strParameters.is_null() {
+            None
+        } else {
+            Some(unsafe { std::ffi::CStr::from_ptr(self.strParameters) })
+        }
+    }
+}
+
 impl sys::sGaugeDrawData {
     /// Get the width of the target instrument texture.
     pub fn width(&self) -> usize {
@@ -18,7 +39,7 @@ impl sys::sGaugeDrawData {
 }
 
 use crate::sim_connect::{SimConnect, SimConnectRecv};
-pub use msfs_derive::{gauge, standalone_module, system};
+pub use msfs_derive::{gauge, gauge2024, standalone_module, system};
 
 /// Used in Gauges to dispatch lifetime events, mouse events, and SimConnect events.
 #[derive(Debug)]
@@ -243,6 +264,152 @@ impl GaugeExecutor {
     }
 }
 
+/// Event data for MSFS 2024 gauges, containing delta time and the event type.
+pub struct Gauge2024Data<'a> {
+    pub delta_time: f32,
+    pub event: Gauge2024Event<'a>,
+}
+
+/// Events dispatched to MSFS 2024 gauges.
+#[derive(Debug)]
+pub enum Gauge2024Event<'a> {
+    /// Gauge initialization event with install data.
+    Init(&'a sys::sGaugeInstallData),
+    /// Gauge update event (called each frame, no drawing allowed).
+    Update,
+    /// Gauge draw event (called each frame, drawing is allowed).
+    Draw(&'a sys::sGaugeDrawData),
+    /// Gauge kill/cleanup event.
+    Kill,
+    /// Mouse input event.
+    Mouse { x: f32, y: f32, flags: i32 },
+    /// SimConnect event.
+    SimConnect(SimConnectRecv<'a>),
+}
+
+/// Handle to an MSFS 2024 gauge used in async gauge callbacks.
+pub struct Gauge2024 {
+    executor: *mut Gauge2024Executor,
+    rx: futures::channel::mpsc::Receiver<Gauge2024Data<'static>>,
+}
+
+impl Gauge2024 {
+    /// Send a request to the Microsoft Flight Simulator server to open up communications with a new client.
+    pub fn open_simconnect<'a>(
+        &self,
+        name: &str,
+    ) -> Result<std::pin::Pin<Box<crate::sim_connect::SimConnect<'a>>>, Box<dyn std::error::Error>>
+    {
+        let executor = self.executor;
+        let sim = crate::sim_connect::SimConnect::open(name, move |_sim, recv| {
+            let executor = unsafe { &mut *executor };
+            let recv =
+                unsafe { std::mem::transmute::<SimConnectRecv<'_>, SimConnectRecv<'static>>(recv) };
+            let data = Gauge2024Data {
+                delta_time: 0.,
+                event: Gauge2024Event::SimConnect(recv),
+            };
+            executor
+                .executor
+                .send(Some(data))
+                .unwrap();
+        })?;
+        Ok(sim)
+    }
+
+    /// Create a NanoVG rendering context. See `Context` for more details.
+    #[cfg(any(target_arch = "wasm32", doc))]
+    pub fn create_nanovg(&self) -> Option<crate::nvg::Context> {
+        crate::nvg::Context::create(unsafe { (*self.executor).fs_ctx.unwrap() })
+    }
+
+    /// Consume the next event from MSFS.
+    pub fn next_event(&mut self) -> impl futures::Future<Output = Option<Gauge2024Data<'_>>> + '_ {
+        use futures::stream::StreamExt;
+        async move { self.rx.next().await }
+    }
+}
+
+#[doc(hidden)]
+pub struct Gauge2024Executor {
+    pub fs_ctx: Option<sys::FsContext>,
+    pub executor: executor::Executor<Gauge2024, Gauge2024Data<'static>>,
+}
+
+#[doc(hidden)]
+impl Gauge2024Executor {
+    pub fn handle_gauge_init(
+        &mut self,
+        ctx: sys::FsContext,
+        p_install_data: *const sys::sGaugeInstallData,
+    ) -> bool {
+        let executor = self as *mut Gauge2024Executor;
+        self.fs_ctx = Some(ctx);
+        if self.executor
+            .start(Box::new(move |rx| Gauge2024 { executor, rx }))
+            .is_err()
+        {
+            return false;
+        }
+        let data = Gauge2024Data {
+            delta_time: 0.,
+            event: Gauge2024Event::Init(unsafe { &*p_install_data }),
+        };
+        // Transmute to static lifetime - safe because we process synchronously
+        let data = unsafe { std::mem::transmute::<Gauge2024Data<'_>, Gauge2024Data<'static>>(data) };
+        self.executor.send(Some(data)).is_ok()
+    }
+
+    pub fn handle_gauge_update(
+        &mut self,
+        ctx: sys::FsContext,
+        delta_time: f32,
+    ) -> bool {
+        self.fs_ctx = Some(ctx);
+        let data = Gauge2024Data {
+            delta_time,
+            event: Gauge2024Event::Update,
+        };
+        self.executor.send(Some(data)).is_ok()
+    }
+
+    pub fn handle_gauge_draw(
+        &mut self,
+        ctx: sys::FsContext,
+        p_draw_data: *const sys::sGaugeDrawData,
+    ) -> bool {
+        self.fs_ctx = Some(ctx);
+        let data = Gauge2024Data {
+            delta_time: unsafe { (*p_draw_data).dt as f32 },
+            event: Gauge2024Event::Draw(unsafe { &*p_draw_data }),
+        };
+        // Transmute to static lifetime - safe because we process synchronously
+        let data = unsafe { std::mem::transmute::<Gauge2024Data<'_>, Gauge2024Data<'static>>(data) };
+        self.executor.send(Some(data)).is_ok()
+    }
+
+    pub fn handle_gauge_kill(&mut self, ctx: sys::FsContext) -> bool {
+        self.fs_ctx = Some(ctx);
+        let data = Gauge2024Data {
+            delta_time: 0.,
+            event: Gauge2024Event::Kill,
+        };
+        if !self.executor.send(Some(data)).is_ok() {
+            return false;
+        }
+        self.executor.send(None).is_ok()
+    }
+
+    pub fn handle_mouse(&mut self, ctx: sys::FsContext, x: f32, y: f32, flags: i32) {
+        self.fs_ctx = Some(ctx);
+        let data = Gauge2024Data {
+            delta_time: 0.,
+            event: Gauge2024Event::Mouse { x, y, flags },
+        };
+        let _ = self.executor.send(Some(data));
+    }
+}
+
 pub struct StandaloneModule {
     executor: *mut StandaloneModuleExecutor,
     rx: futures::channel::mpsc::Receiver<SimConnectRecv<'static>>,

msfs_derive/src/lib.rs

@@ -221,6 +221,128 @@ pub fn gauge(args: TokenStream, item: TokenStream) -> TokenStream {
     TokenStream::from(output)
 }
 
+/// Declare a gauge callback using the new MSFS 2024 gauge API.
+/// This generates the new-style callbacks: `NAME_gauge_init`, `NAME_gauge_update`,
+/// `NAME_gauge_draw`, `NAME_gauge_kill`, and `NAME_gauge_mouse_handler`.
+///
+/// ```rs
+/// use futures::stream::{Stream, StreamExt};
+/// // Declare and export MSFS 2024 gauge callbacks
+/// #[msfs::gauge2024]
+/// async fn FOO(mut gauge: msfs::Gauge2024) -> Result<(), Box<dyn std::error::Error>> {
+///   while let Some(event) = gauge.next_event().await {
+///     match event.event {
+///       msfs::Gauge2024Event::Init(install_data) => { /* initialization */ }
+///       msfs::Gauge2024Event::Update => { /* update logic, no drawing */ }
+///       msfs::Gauge2024Event::Draw(draw_data) => { /* drawing */ }
+///       msfs::Gauge2024Event::Kill => { /* cleanup */ }
+///       msfs::Gauge2024Event::Mouse { x, y, flags } => { /* mouse input */ }
+///       _ => {}
+///     }
+///   }
+///   Ok(())
+/// }
+/// ```
+///
+/// The macro can also be given a parameter, `name`, to rename the exported functions.
+/// ```rs
+/// // Declare and export FOO_gauge_init, FOO_gauge_update, etc.
+/// #[msfs::gauge2024(name=FOO)]
+/// async fn xyz(...) {}
+/// ```
+#[proc_macro_attribute]
+pub fn gauge2024(args: TokenStream, item: TokenStream) -> TokenStream {
+    let args = parse_macro_input!(args as GaugeArgs);
+    let input = parse_macro_input!(item as ItemFn);
+
+    let rusty_name = input.sig.ident.clone();
+    let executor_name = format_ident!(
+        "{}_executor_do_not_use_or_you_will_be_fired",
+        input.sig.ident
+    );
+
+    let extern_name = args.name.unwrap_or_else(|| input.sig.ident.to_string());
+    let extern_gauge_init = format_ident!("{}_gauge_init", extern_name);
+    let extern_gauge_update = format_ident!("{}_gauge_update", extern_name);
+    let extern_gauge_draw = format_ident!("{}_gauge_draw", extern_name);
+    let extern_gauge_kill = format_ident!("{}_gauge_kill", extern_name);
+    let extern_mouse_handler = format_ident!("{}_gauge_mouse_handler", extern_name);
+
+    let output = quote! {
+        #input
+
+        // SAFETY: it is safe to create references of this static since all WASM modules are single threaded
+        // and there is only 1 reference in use at all times
+        #[allow(non_upper_case_globals)]
+        static mut #executor_name: ::msfs::Gauge2024Executor = ::msfs::Gauge2024Executor {
+            fs_ctx: None,
+            executor: ::msfs::executor::Executor {
+                handle: |gauge| std::boxed::Box::pin(#rusty_name(gauge)),
+                tx: None,
+                future: None,
+            },
+        };
+
+        #[doc(hidden)]
+        #[no_mangle]
+        pub extern "C" fn #extern_gauge_init(
+            ctx: ::msfs::sys::FsContext,
+            p_install_data: *const ::msfs::sys::sGaugeInstallData,
+        ) -> bool {
+            unsafe {
+                ::msfs::wrap_executor(&raw mut #executor_name, |e| e.handle_gauge_init(ctx, p_install_data))
+            }
+        }
+
+        #[doc(hidden)]
+        #[no_mangle]
+        pub extern "C" fn #extern_gauge_update(
+            ctx: ::msfs::sys::FsContext,
+            d_time: std::os::raw::c_float,
+        ) -> bool {
+            unsafe {
+                ::msfs::wrap_executor(&raw mut #executor_name, |e| e.handle_gauge_update(ctx, d_time))
+            }
+        }
+
+        #[doc(hidden)]
+        #[no_mangle]
+        pub extern "C" fn #extern_gauge_draw(
+            ctx: ::msfs::sys::FsContext,
+            p_draw_data: *const ::msfs::sys::sGaugeDrawData,
+        ) -> bool {
+            unsafe {
+                ::msfs::wrap_executor(&raw mut #executor_name, |e| e.handle_gauge_draw(ctx, p_draw_data))
+            }
+        }
+
+        #[doc(hidden)]
+        #[no_mangle]
+        pub extern "C" fn #extern_gauge_kill(
+            ctx: ::msfs::sys::FsContext,
+        ) -> bool {
+            unsafe {
+                ::msfs::wrap_executor(&raw mut #executor_name, |e| e.handle_gauge_kill(ctx))
+            }
+        }
+
+        #[doc(hidden)]
+        #[no_mangle]
+        pub extern "C" fn #extern_mouse_handler(
+            ctx: ::msfs::sys::FsContext,
+            fx: std::os::raw::c_float,
+            fy: std::os::raw::c_float,
+            i_flags: std::os::raw::c_int,
+        ) {
+            unsafe {
+                ::msfs::wrap_executor(&raw mut #executor_name, |e| e.handle_mouse(ctx, fx, fy, i_flags));
+            }
+        }
+    };
+
+    TokenStream::from(output)
+}
+
 fn parse_struct_fields(
     input: &mut ItemStruct,
     attributes: &[&str],