Support remote rendering

crates/ecolor/Cargo.toml

@@ -48,3 +48,7 @@ document-features = { version = "0.2", optional = true }
 
 ## Allow serialization using [`serde`](https://docs.rs/serde).
 serde = { version = "1", optional = true, features = ["derive"] }
+
+## Allow diffing with serialization using [`serde-diff`](https://docs.rs/serde-diff/latest/serde_diff/) .
+#serde-diff = { version = "0.4.1", optional = true }
+serde-diff = { git = "https://github.com/linguini11/serde-diff.git", optional = true }

crates/ecolor/src/color32.rs

@@ -10,6 +10,10 @@ use crate::{gamma_u8_from_linear_f32, linear_f32_from_gamma_u8, linear_f32_from_
 #[repr(C)]
 #[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(
+    all(feature = "serde-diff", feature = "serde"),
+    derive(serde_diff::SerdeDiff)
+)]
 #[cfg_attr(feature = "bytemuck", derive(bytemuck::Pod, bytemuck::Zeroable))]
 pub struct Color32(pub(crate) [u8; 4]);
 

crates/eframe/Cargo.toml

@@ -27,7 +27,7 @@ targets = ["x86_64-unknown-linux-gnu", "wasm32-unknown-unknown"]
 
 
 [features]
-default = ["accesskit", "default_fonts", "glow"]
+default = ["accesskit", "default_fonts", "glow", "serde"]
 
 ## Enable platform accessibility API implementations through [AccessKit](https://accesskit.dev/).
 accesskit = ["egui/accesskit", "egui-winit/accesskit"]

crates/eframe/src/epi/mod.rs

@@ -101,6 +101,18 @@ unsafe impl HasRawDisplayHandle for CreationContext<'_> {
     }
 }
 
+/// Message types for client to server communication for remote rendering
+#[derive(Debug)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub enum RemoteRenderingMessageType {
+    /// Initial connection, specifying pixels_per_point as the content
+    Connect(f32),
+    /// Request to update pixels_per_point
+    PixelsPerPoint(f32),
+    /// Send input events to server
+    RawInput(egui::RawInput),
+}
+
 // ----------------------------------------------------------------------------
 
 /// Implement this trait to write apps that can be compiled for both web/wasm and desktop/native using [`eframe`](https://github.com/emilk/egui/tree/master/crates/eframe).
@@ -114,6 +126,17 @@ pub trait App {
     /// To force a repaint, call [`egui::Context::request_repaint`] at any time (e.g. from another thread).
     fn update(&mut self, ctx: &egui::Context, frame: &mut Frame);
 
+    /// Called each time the UI needs repainting when rendering on a remote client, which may be many times per second.
+    ///
+    /// Retrieves the `FullOutput` from the client rather than constructing it internally
+    fn update_remote(
+        &mut self,
+        _raw_input: egui::RawInput,
+        _frame: &Frame,
+    ) -> (egui::output::FullOutput, f32) {
+        (egui::output::FullOutput::default(), 2.0)
+    }
+
     /// Get a handle to the app.
     ///
     /// Can be used from web to interact or other external context.

crates/eframe/src/lib.rs

@@ -15,7 +15,7 @@
 //!
 //! fn main() {
 //!     let native_options = eframe::NativeOptions::default();
-//!     eframe::run_native("My egui App", native_options, Box::new(|cc| Box::new(MyEguiApp::new(cc))));
+//!     eframe::run_native("My egui App", native_options, Box::new(|cc| Box::new(MyEguiApp::new(cc))), false);
 //! }
 //!
 //! #[derive(Default)]
@@ -170,7 +170,7 @@ mod native;
 ///
 /// fn main() -> eframe::Result<()> {
 ///     let native_options = eframe::NativeOptions::default();
-///     eframe::run_native("MyApp", native_options, Box::new(|cc| Box::new(MyEguiApp::new(cc))))
+///     eframe::run_native("MyApp", native_options, Box::new(|cc| Box::new(MyEguiApp::new(cc))), false)
 /// }
 ///
 /// #[derive(Default)]
@@ -204,6 +204,7 @@ pub fn run_native(
     app_name: &str,
     native_options: NativeOptions,
     app_creator: AppCreator,
+    remote_rendering: bool,
 ) -> Result<()> {
     let renderer = native_options.renderer;
 
@@ -217,13 +218,13 @@ pub fn run_native(
         #[cfg(feature = "glow")]
         Renderer::Glow => {
             log::debug!("Using the glow renderer");
-            native::run::run_glow(app_name, native_options, app_creator)
+            native::run::run_glow(app_name, native_options, app_creator, remote_rendering)
         }
 
         #[cfg(feature = "wgpu")]
         Renderer::Wgpu => {
             log::debug!("Using the wgpu renderer");
-            native::run::run_wgpu(app_name, native_options, app_creator)
+            native::run::run_wgpu(app_name, native_options, app_creator, remote_rendering)
         }
     }
 }
@@ -282,6 +283,7 @@ pub fn run_simple_native(
         app_name,
         native_options,
         Box::new(|_cc| Box::new(SimpleApp { update_fun })),
+        false,
     )
 }
 

crates/eframe/src/native/epi_integration.rs

@@ -433,7 +433,7 @@ impl EpiIntegration {
         let saved_memory: egui::Memory = self.egui_ctx.memory(|mem| mem.clone());
         self.egui_ctx
             .memory_mut(|mem| mem.set_everything_is_visible(true));
-        let full_output = self.update(app, window);
+        let full_output = self.update(app, window, false);
         self.pending_full_output.append(full_output); // Handle it next frame
         self.egui_ctx.memory_mut(|mem| *mem = saved_memory); // We don't want to remember that windows were huge.
         self.egui_ctx.clear_animations();
@@ -489,6 +489,7 @@ impl EpiIntegration {
         &mut self,
         app: &mut dyn epi::App,
         window: &winit::window::Window,
+        remote_rendering: bool,
     ) -> egui::FullOutput {
         let frame_start = std::time::Instant::now();
 
@@ -499,12 +500,23 @@ impl EpiIntegration {
         let raw_input = self.egui_winit.take_egui_input(window);
 
         // Run user code:
-        let full_output = self.egui_ctx.run(raw_input, |egui_ctx| {
-            crate::profile_scope!("App::update");
-            app.update(egui_ctx, &mut self.frame);
-        });
+        if remote_rendering {
+            let (full_output, pixels_per_point) = app.update_remote(raw_input, &self.frame);
+            // Tessellate throws error if 'run' hasn't been called, so run and ignore result
+            let raw_input = egui::RawInput {
+                pixels_per_point: Some(pixels_per_point),
+                ..Default::default()
+            };
+            let _ = self.egui_ctx.run(raw_input, |_egui_ctx| {});
+            self.pending_full_output.append(full_output);
+        } else {
+            let full_output = self.egui_ctx.run(raw_input, |egui_ctx| {
+                crate::profile_scope!("App::update");
+                app.update(egui_ctx, &mut self.frame);
+            });
+            self.pending_full_output.append(full_output);
+        }
 
-        self.pending_full_output.append(full_output);
         let full_output = std::mem::take(&mut self.pending_full_output);
 
         {