Merge branch 'master' into provide-cargo-rust-gpu-to-nix-devs

Author: timon-schelling

editor/src/dispatcher.rs

@@ -143,6 +143,7 @@ impl Dispatcher {
 					let context = DialogMessageContext {
 						portfolio: &self.message_handlers.portfolio_message_handler,
 						preferences: &self.message_handlers.preferences_message_handler,
+						viewport_bounds: &self.message_handlers.input_preprocessor_message_handler.viewport_bounds,
 					};
 					self.message_handlers.dialog_message_handler.process_message(message, &mut queue, context);
 				}

editor/src/messages/defer/defer_message_handler.rs

@@ -19,6 +19,7 @@ impl MessageHandler<DeferMessage, DeferMessageContext<'_>> for DeferMessageHandl
 			DeferMessage::AfterGraphRun { mut messages } => {
 				let after_graph_run = self.after_graph_run.entry(context.portfolio.active_document_id.unwrap_or(DocumentId(0))).or_default();
 				after_graph_run.extend(messages.drain(..).map(|m| (self.current_graph_submission_id, m)));
+				responses.add(NodeGraphMessage::RunDocumentGraph);
 			}
 			DeferMessage::AfterNavigationReady { messages } => {
 				self.after_viewport_resize.extend_from_slice(&messages);
@@ -37,8 +38,10 @@ impl MessageHandler<DeferMessage, DeferMessageContext<'_>> for DeferMessageHandl
 				for (_, message) in elements.rev() {
 					responses.add_front(message);
 				}
-				if !after_graph_run.is_empty() {
-					responses.add(NodeGraphMessage::RunDocumentGraph);
+				for (id, messages) in self.after_graph_run.iter() {
+					if !messages.is_empty() {
+						responses.add(PortfolioMessage::SubmitGraphRender { document_id: *id, ignore_hash: false });
+					}
 				}
 			}
 			DeferMessage::TriggerNavigationReady => {

editor/src/messages/dialog/dialog_message_handler.rs

@@ -1,10 +1,13 @@
+use super::new_document_dialog::NewDocumentDialogMessageContext;
 use super::simple_dialogs::{self, AboutGraphiteDialog, ComingSoonDialog, DemoArtworkDialog, LicensesDialog};
+use crate::messages::input_mapper::utility_types::input_mouse::ViewportBounds;
 use crate::messages::layout::utility_types::widget_prelude::*;
 use crate::messages::prelude::*;
 
 #[derive(ExtractField)]
 pub struct DialogMessageContext<'a> {
 	pub portfolio: &'a PortfolioMessageHandler,
+	pub viewport_bounds: &'a ViewportBounds,
 	pub preferences: &'a PreferencesMessageHandler,
 }
 
@@ -19,11 +22,15 @@ pub struct DialogMessageHandler {
 #[message_handler_data]
 impl MessageHandler<DialogMessage, DialogMessageContext<'_>> for DialogMessageHandler {
 	fn process_message(&mut self, message: DialogMessage, responses: &mut VecDeque<Message>, context: DialogMessageContext) {
-		let DialogMessageContext { portfolio, preferences } = context;
+		let DialogMessageContext {
+			portfolio,
+			preferences,
+			viewport_bounds,
+		} = context;
 
 		match message {
 			DialogMessage::ExportDialog(message) => self.export_dialog.process_message(message, responses, ExportDialogMessageContext { portfolio }),
-			DialogMessage::NewDocumentDialog(message) => self.new_document_dialog.process_message(message, responses, ()),
+			DialogMessage::NewDocumentDialog(message) => self.new_document_dialog.process_message(message, responses, NewDocumentDialogMessageContext { viewport_bounds }),
 			DialogMessage::PreferencesDialog(message) => self.preferences_dialog.process_message(message, responses, PreferencesDialogMessageContext { preferences }),
 
 			DialogMessage::CloseAllDocumentsWithConfirmation => {

editor/src/messages/dialog/new_document_dialog/mod.rs

@@ -4,4 +4,4 @@ mod new_document_dialog_message_handler;
 #[doc(inline)]
 pub use new_document_dialog_message::{NewDocumentDialogMessage, NewDocumentDialogMessageDiscriminant};
 #[doc(inline)]
-pub use new_document_dialog_message_handler::NewDocumentDialogMessageHandler;
+pub use new_document_dialog_message_handler::{NewDocumentDialogMessageContext, NewDocumentDialogMessageHandler};

editor/src/messages/dialog/new_document_dialog/new_document_dialog_message_handler.rs

@@ -1,8 +1,13 @@
-use crate::messages::layout::utility_types::widget_prelude::*;
 use crate::messages::prelude::*;
+use crate::messages::{input_mapper::utility_types::input_mouse::ViewportBounds, layout::utility_types::widget_prelude::*};
 use glam::{IVec2, UVec2};
 use graph_craft::document::NodeId;
 
+#[derive(ExtractField)]
+pub struct NewDocumentDialogMessageContext<'a> {
+	pub viewport_bounds: &'a ViewportBounds,
+}
+
 /// A dialog to allow users to set some initial options about a new document.
 #[derive(Debug, Clone, Default, ExtractField)]
 pub struct NewDocumentDialogMessageHandler {
@@ -12,8 +17,8 @@ pub struct NewDocumentDialogMessageHandler {
 }
 
 #[message_handler_data]
-impl MessageHandler<NewDocumentDialogMessage, ()> for NewDocumentDialogMessageHandler {
-	fn process_message(&mut self, message: NewDocumentDialogMessage, responses: &mut VecDeque<Message>, _: ()) {
+impl<'a> MessageHandler<NewDocumentDialogMessage, NewDocumentDialogMessageContext<'a>> for NewDocumentDialogMessageHandler {
+	fn process_message(&mut self, message: NewDocumentDialogMessage, responses: &mut VecDeque<Message>, context: NewDocumentDialogMessageContext<'a>) {
 		match message {
 			NewDocumentDialogMessage::Name(name) => self.name = name,
 			NewDocumentDialogMessage::Infinite(infinite) => self.infinite = infinite,
@@ -24,21 +29,18 @@ impl MessageHandler<NewDocumentDialogMessage, ()> for NewDocumentDialogMessageHa
 
 				let create_artboard = !self.infinite && self.dimensions.x > 0 && self.dimensions.y > 0;
 				if create_artboard {
-					responses.add(NodeGraphMessage::RunDocumentGraph);
-					responses.add(DeferMessage::AfterGraphRun {
-						messages: vec![
-							GraphOperationMessage::NewArtboard {
-								id: NodeId::new(),
-								artboard: graphene_std::Artboard::new(IVec2::ZERO, self.dimensions.as_ivec2()),
-							}
-							.into(),
-							NodeGraphMessage::ForceRunDocumentGraph.into(),
-							DeferMessage::AfterGraphRun {
-								messages: vec![DeferMessage::TriggerNavigationReady.into()],
-							}
-							.into(),
-						],
+					responses.add(GraphOperationMessage::NewArtboard {
+						id: NodeId::new(),
+						artboard: graphene_std::Artboard::new(IVec2::ZERO, self.dimensions.as_ivec2()),
 					});
+					responses.add(NavigationMessage::CanvasPan { delta: self.dimensions.as_dvec2() });
+					responses.add(NodeGraphMessage::RunDocumentGraph);
+					// If we already have bounds, we won't receive a viewport bounds update so we just fabricate one ourselves
+					if *context.viewport_bounds != ViewportBounds::default() {
+						responses.add(InputPreprocessorMessage::BoundsOfViewports {
+							bounds_of_viewports: vec![context.viewport_bounds.clone()],
+						});
+					}
 					responses.add(DeferMessage::AfterNavigationReady {
 						messages: vec![DocumentMessage::ZoomCanvasToFitAll.into(), DocumentMessage::DeselectAllLayers.into()],
 					});

editor/src/messages/input_preprocessor/input_preprocessor_message_handler.rs

@@ -36,6 +36,14 @@ impl MessageHandler<InputPreprocessorMessage, InputPreprocessorMessageContext> f
 					responses.add(NavigationMessage::CanvasPan { delta: DVec2::ZERO });
 					responses.add(NodeGraphMessage::SetGridAlignedEdges);
 				}
+				responses.add(DeferMessage::AfterGraphRun {
+					messages: vec![
+						DeferMessage::AfterGraphRun {
+							messages: vec![DeferMessage::TriggerNavigationReady.into()],
+						}
+						.into(),
+					],
+				});
 			}
 			InputPreprocessorMessage::DoubleClick { editor_mouse_state, modifier_keys } => {
 				self.update_states_of_modifier_keys(modifier_keys, keyboard_platform, responses);

frontend/package.json

@@ -11,16 +11,18 @@
 		"profiling": "npm run setup && npm run wasm:build-profiling && concurrently -k -n \"VITE,RUST\" \"vite\" \"npm run wasm:watch-profiling\"",
 		"production": "npm run setup && npm run wasm:build-production && concurrently -k -n \"VITE,RUST\" \"vite\" \"npm run wasm:watch-production\"",
 		"---------- BUILDS ----------": "",
+		"build": "npm run wasm:build-production && vite build",
 		"build-dev": "npm run wasm:build-dev && vite build",
-		"build-native": "npm run native:build-dev && vite build",
+		"build-native": "npm run native:build-production && vite build",
+		"build-native-dev": "npm run native:build-dev && vite build",
 		"build-profiling": "npm run wasm:build-profiling && vite build",
-		"build": "npm run wasm:build-production && vite build",
 		"---------- UTILITIES ----------": "",
 		"lint": "eslint . && tsc --noEmit",
 		"lint-fix": "eslint . --fix && tsc --noEmit",
 		"---------- INTERNAL ----------": "",
 		"setup": "node package-installer.js",
 		"native:build-dev": "wasm-pack build ./wasm --dev --target=web --features native",
+		"native:build-production": "wasm-pack build ./wasm --release --target=web --features native",
 		"wasm:build-dev": "wasm-pack build ./wasm --dev --target=web",
 		"wasm:build-profiling": "wasm-pack build ./wasm --profiling --target=web",
 		"wasm:build-production": "wasm-pack build ./wasm --release --target=web",

frontend/wasm/src/editor_api.rs

@@ -5,8 +5,7 @@
 // on the dispatcher messaging system and more complex Rust data types.
 //
 use crate::helpers::translate_key;
-use crate::{EDITOR, EDITOR_HANDLE, EDITOR_HAS_CRASHED, Error, MESSAGE_BUFFER};
-use editor::application::Editor;
+use crate::{EDITOR_HANDLE, EDITOR_HAS_CRASHED, Error, MESSAGE_BUFFER};
 use editor::consts::FILE_SAVE_SUFFIX;
 use editor::messages::input_mapper::utility_types::input_keyboard::ModifierKeys;
 use editor::messages::input_mapper::utility_types::input_mouse::{EditorMouseState, ScrollDelta, ViewportBounds};
@@ -28,6 +27,11 @@ use wasm_bindgen::JsCast;
 use wasm_bindgen::prelude::*;
 use web_sys::{CanvasRenderingContext2d, HtmlCanvasElement, ImageData, window};
 
+#[cfg(not(feature = "native"))]
+use crate::EDITOR;
+#[cfg(not(feature = "native"))]
+use editor::application::Editor;
+
 static IMAGE_DATA_HASH: AtomicU64 = AtomicU64::new(0);
 
 fn calculate_hash<T: std::hash::Hash>(t: &T) -> u64 {
@@ -140,6 +144,7 @@ impl EditorHandle {
 
 #[wasm_bindgen]
 impl EditorHandle {
+	#[cfg(not(feature = "native"))]
 	#[wasm_bindgen(constructor)]
 	pub fn new(frontend_message_handler_callback: js_sys::Function) -> Self {
 		let editor = Editor::new();
@@ -153,6 +158,16 @@ impl EditorHandle {
 		editor_handle
 	}
 
+	#[cfg(feature = "native")]
+	#[wasm_bindgen(constructor)]
+	pub fn new(frontend_message_handler_callback: js_sys::Function) -> Self {
+		let editor_handle = EditorHandle { frontend_message_handler_callback };
+		if EDITOR_HANDLE.with(|handle| handle.lock().ok().map(|mut guard| *guard = Some(editor_handle.clone()))).is_none() {
+			log::error!("Attempted to initialize the editor handle more than once");
+		}
+		editor_handle
+	}
+
 	// Sends a message to the dispatcher in the Editor Backend
 	#[cfg(not(feature = "native"))]
 	fn dispatch<T: Into<Message>>(&self, message: T) {
@@ -247,6 +262,7 @@ impl EditorHandle {
 			let g = f.clone();
 
 			*g.borrow_mut() = Some(Closure::new(move |_timestamp| {
+				#[cfg(not(feature = "native"))]
 				wasm_bindgen_futures::spawn_local(poll_node_graph_evaluation());
 
 				if !EDITOR_HAS_CRASHED.load(Ordering::SeqCst) {
@@ -929,6 +945,7 @@ fn set_timeout(f: &Closure<dyn FnMut()>, delay: Duration) {
 }
 
 /// Provides access to the `Editor` by calling the given closure with it as an argument.
+#[cfg(not(feature = "native"))]
 fn editor<T: Default>(callback: impl FnOnce(&mut editor::application::Editor) -> T) -> T {
 	EDITOR.with(|editor| {
 		let mut guard = editor.try_lock();
@@ -942,6 +959,7 @@ fn editor<T: Default>(callback: impl FnOnce(&mut editor::application::Editor) ->
 }
 
 /// Provides access to the `Editor` and its `EditorHandle` by calling the given closure with them as arguments.
+#[cfg(not(feature = "native"))]
 pub(crate) fn editor_and_handle(callback: impl FnOnce(&mut Editor, &mut EditorHandle)) {
 	handle(|editor_handle| {
 		editor(|editor| {
@@ -964,6 +982,7 @@ pub(crate) fn handle(callback: impl FnOnce(&mut EditorHandle)) {
 	});
 }
 
+#[cfg(not(feature = "native"))]
 async fn poll_node_graph_evaluation() {
 	// Process no further messages after a crash to avoid spamming the console
 	if EDITOR_HAS_CRASHED.load(Ordering::SeqCst) {

frontend/wasm/src/lib.rs

@@ -20,6 +20,7 @@ pub static NODE_GRAPH_ERROR_DISPLAYED: AtomicBool = AtomicBool::new(false);
 pub static LOGGER: WasmLog = WasmLog;
 
 thread_local! {
+	#[cfg(not(feature = "native"))]
 	pub static EDITOR: Mutex<Option<editor::application::Editor>> = const { Mutex::new(None) };
 	pub static MESSAGE_BUFFER: std::cell::RefCell<Vec<Message>> = const { std::cell::RefCell::new(Vec::new()) };
 	pub static EDITOR_HANDLE: Mutex<Option<editor_api::EditorHandle>> = const { Mutex::new(None) };
@@ -50,7 +51,7 @@ pub fn panic_hook(info: &panic::PanicHookInfo) {
 
 		if !NODE_GRAPH_ERROR_DISPLAYED.load(Ordering::SeqCst) {
 			NODE_GRAPH_ERROR_DISPLAYED.store(true, Ordering::SeqCst);
-			editor_api::editor_and_handle(|_, handle| {
+			editor_api::handle(|handle| {
 				let error = r#"
 				<rect x="50%" y="50%" width="600" height="100" transform="translate(-300 -50)" rx="4" fill="var(--color-error-red)" />
 				<text x="50%" y="50%" dominant-baseline="middle" text-anchor="middle" font-size="18" fill="var(--color-2-mildblack)">

frontend/wasm/src/native_communcation.rs

@@ -1,4 +1,4 @@
-use editor::{application::Editor, messages::prelude::FrontendMessage};
+use editor::messages::prelude::FrontendMessage;
 use js_sys::{ArrayBuffer, Uint8Array};
 use wasm_bindgen::prelude::*;
 
@@ -9,12 +9,12 @@ pub fn receive_native_message(buffer: ArrayBuffer) {
 	let buffer = Uint8Array::new(buffer.as_ref()).to_vec();
 	match ron::from_str::<Vec<FrontendMessage>>(str::from_utf8(buffer.as_slice()).unwrap()) {
 		Ok(messages) => {
-			let callback = move |_: &mut Editor, handle: &mut EditorHandle| {
+			let callback = move |handle: &mut EditorHandle| {
 				for message in messages {
 					handle.send_frontend_message_to_js_rust_proxy(message);
 				}
 			};
-			editor_api::editor_and_handle(callback);
+			editor_api::handle(callback);
 		}
 		Err(e) => log::error!("Failed to deserialize frontend messages: {e:?}"),
 	}