Desktop: Execute editor and node graph natively (#2955)

* Desktop: Execute editor and node graph natively

* Remove decouple execution feature

* Disable feature gate for native communication functions

* Avoid ininite message loop on an infinite canvas

* Add any lint exception

* Build evaluation loop

* Fix texture passing message

* Cleanup

* More cleanup

---------

Co-authored-by: Timon Schelling <me@timon.zip>

desktop/src/app.rs

@@ -2,6 +2,9 @@ use crate::CustomEvent;
 use crate::WindowSize;
 use crate::render::GraphicsState;
 use crate::render::WgpuContext;
+use graph_craft::wasm_application_io::WasmApplicationIo;
+use graphite_editor::application::Editor;
+use graphite_editor::messages::prelude::*;
 use std::sync::Arc;
 use std::sync::mpsc::Sender;
 use std::time::Duration;
@@ -21,11 +24,10 @@ pub(crate) struct WinitApp {
 	pub(crate) cef_context: cef::Context<cef::Initialized>,
 	pub(crate) window: Option<Arc<Window>>,
 	cef_schedule: Option<Instant>,
-	_ui_frame_buffer: Option<wgpu::Texture>,
 	window_size_sender: Sender<WindowSize>,
-	_viewport_frame_buffer: Option<wgpu::Texture>,
 	graphics_state: Option<GraphicsState>,
 	wgpu_context: WgpuContext,
+	pub(crate) editor: Editor,
 }
 
 impl WinitApp {
@@ -34,13 +36,28 @@ impl WinitApp {
 			cef_context,
 			window: None,
 			cef_schedule: Some(Instant::now()),
-			_viewport_frame_buffer: None,
-			_ui_frame_buffer: None,
 			graphics_state: None,
 			window_size_sender,
 			wgpu_context,
+			editor: Editor::new(),
 		}
 	}
+
+	fn dispatch_message(&mut self, message: Message) {
+		let responses = self.editor.handle_message(message);
+		self.send_messages_to_editor(responses);
+	}
+
+	fn send_messages_to_editor(&mut self, responses: Vec<FrontendMessage>) {
+		if responses.is_empty() {
+			return;
+		}
+		let Ok(message) = ron::to_string(&responses) else {
+			tracing::error!("Failed to serialize Messages");
+			return;
+		};
+		self.cef_context.send_web_message(message.as_bytes());
+	}
 }
 
 impl ApplicationHandler<CustomEvent> for WinitApp {
@@ -49,16 +66,22 @@ impl ApplicationHandler<CustomEvent> for WinitApp {
 		let timeout = Instant::now() + Duration::from_millis(10);
 		let wait_until = timeout.min(self.cef_schedule.unwrap_or(timeout));
 		self.cef_context.work();
+
 		event_loop.set_control_flow(ControlFlow::WaitUntil(wait_until));
 	}
 
-	fn new_events(&mut self, _event_loop: &ActiveEventLoop, _cause: StartCause) {
+	fn new_events(&mut self, _event_loop: &ActiveEventLoop, cause: StartCause) {
 		if let Some(schedule) = self.cef_schedule
 			&& schedule < Instant::now()
 		{
 			self.cef_schedule = None;
 			self.cef_context.work();
 		}
+		if let StartCause::ResumeTimeReached { .. } = cause {
+			if let Some(window) = &self.window {
+				window.request_redraw();
+			}
+		}
 	}
 
 	fn resumed(&mut self, event_loop: &ActiveEventLoop) {
@@ -77,6 +100,10 @@ impl ApplicationHandler<CustomEvent> for WinitApp {
 		self.graphics_state = Some(graphics_state);
 
 		tracing::info!("Winit window created and ready");
+
+		let application_io = WasmApplicationIo::new_with_context(self.wgpu_context.clone());
+
+		futures::executor::block_on(graphite_editor::node_graph_executor::replace_application_io(application_io));
 	}
 
 	fn user_event(&mut self, _: &ActiveEventLoop, event: CustomEvent) {
@@ -97,6 +124,46 @@ impl ApplicationHandler<CustomEvent> for WinitApp {
 					self.cef_schedule = Some(instant);
 				}
 			}
+			CustomEvent::MessageReceived { message } => {
+				if let Message::InputPreprocessor(ipp_message) = &message {
+					if let Some(window) = &self.window {
+						window.request_redraw();
+					}
+				}
+				if let Message::InputPreprocessor(InputPreprocessorMessage::BoundsOfViewports { bounds_of_viewports }) = &message {
+					if let Some(graphic_state) = &mut self.graphics_state {
+						let window_size = self.window.as_ref().unwrap().inner_size();
+						let window_size = glam::Vec2::new(window_size.width as f32, window_size.height as f32);
+						let top_left = bounds_of_viewports[0].top_left.as_vec2() / window_size;
+						let bottom_right = bounds_of_viewports[0].bottom_right.as_vec2() / window_size;
+						let offset = top_left.to_array();
+						let scale = (bottom_right - top_left).recip();
+						graphic_state.set_viewport_offset(offset);
+						graphic_state.set_viewport_scale(scale.to_array());
+					} else {
+						panic!("graphics state not intialized, viewport offset might be lost");
+					}
+				}
+				self.dispatch_message(message);
+			}
+			CustomEvent::NodeGraphRan { texture } => {
+				if let Some(texture) = texture
+					&& let Some(graphics_state) = &mut self.graphics_state
+				{
+					graphics_state.bind_viewport_texture(&texture);
+				}
+				let mut responses = VecDeque::new();
+				let err = self.editor.poll_node_graph_evaluation(&mut responses);
+				if let Err(e) = err {
+					if e != "No active document" {
+						tracing::error!("Error poling node graph: {}", e);
+					}
+				}
+
+				for message in responses {
+					self.dispatch_message(message);
+				}
+			}
 		}
 	}