merge onto master

Author: adamgerhant

editor/src/dispatcher.rs

@@ -5,7 +5,8 @@ use crate::messages::prelude::*;
 
 #[derive(Debug, Default)]
 pub struct Dispatcher {
-	buffered_queue: Option<Vec<VecDeque<Message>>>,
+	buffered_queue: Vec<Message>,
+	queueing_messages: bool,
 	message_queues: Vec<VecDeque<Message>>,
 	pub responses: Vec<FrontendMessage>,
 	pub message_handlers: DispatcherMessageHandlers,
@@ -90,11 +91,10 @@ impl Dispatcher {
 
 	pub fn handle_message<T: Into<Message>>(&mut self, message: T, process_after_all_current: bool) {
 		let message = message.into();
-		// Add all additional messages to the buffer if it exists (except from the end buffer message)
-		if !matches!(message, Message::EndBuffer(_)) {
-			if let Some(buffered_queue) = &mut self.buffered_queue {
-				Self::schedule_execution(buffered_queue, true, [message]);
-
+		// Add all additional messages to the queue if it exists (except from the end queue message)
+		if !matches!(message, Message::EndQueue) {
+			if self.queueing_messages {
+				self.buffered_queue.push(message);
 				return;
 			}
 		}
@@ -126,36 +126,22 @@ impl Dispatcher {
 
 			// Process the action by forwarding it to the relevant message handler, or saving the FrontendMessage to be sent to the frontend
 			match message {
-				Message::StartBuffer => {
-					self.buffered_queue = Some(std::mem::take(&mut self.message_queues));
+				Message::StartQueue => {
+					self.queueing_messages = true;
 				}
-				Message::EndBuffer(render_metadata) => {
-					// Assign the message queue to the currently buffered queue
-					if let Some(buffered_queue) = self.buffered_queue.take() {
-						self.cleanup_queues(false);
-						assert!(self.message_queues.is_empty(), "message queues are always empty when ending a buffer");
-						self.message_queues = buffered_queue;
+				Message::EndQueue => {
+					self.queueing_messages = false;
+				}
+				Message::ProcessQueue((render_output_metadata, introspected_inputs)) => {
+					let message = PortfolioMessage::ProcessEvaluationResponse {
+						evaluation_metadata: render_output_metadata,
+						introspected_inputs,
 					};
+					// Add the message to update the state with the render output
+					Self::schedule_execution(&mut self.message_queues, true, [message]);
 
-					let graphene_std::renderer::RenderMetadata {
-						upstream_footprints: footprints,
-						local_transforms,
-						first_instance_source_id,
-						click_targets,
-						clip_targets,
-					} = render_metadata;
-
-					// Run these update state messages immediately
-					let messages = [
-						DocumentMessage::UpdateUpstreamTransforms {
-							upstream_footprints: footprints,
-							local_transforms,
-							first_instance_source_id,
-						},
-						DocumentMessage::UpdateClickTargets { click_targets },
-						DocumentMessage::UpdateClipTargets { clip_targets },
-					];
-					Self::schedule_execution(&mut self.message_queues, false, messages.map(Message::from));
+					// Schedule all queued messages to be run (in the order they were added)
+					Self::schedule_execution(&mut self.message_queues, true, std::mem::take(&mut self.buffered_queue));
 				}
 				Message::NoOp => {}
 				Message::Init => {

editor/src/messages/animation/animation_message_handler.rs

@@ -84,7 +84,7 @@ impl MessageHandler<AnimationMessage, ()> for AnimationMessageHandler {
 			}
 			AnimationMessage::SetFrameIndex(frame) => {
 				self.frame_index = frame;
-				responses.add(PortfolioMessage::SubmitActiveGraphRender);
+				responses.add(PortfolioMessage::EvaluateActiveDocument);
 				// Update the restart and pause/play buttons
 				responses.add(PortfolioMessage::UpdateDocumentWidgets);
 			}
@@ -100,7 +100,7 @@ impl MessageHandler<AnimationMessage, ()> for AnimationMessageHandler {
 			}
 			AnimationMessage::UpdateTime => {
 				if self.is_playing() {
-					responses.add(PortfolioMessage::SubmitActiveGraphRender);
+					responses.add(PortfolioMessage::EvaluateActiveDocument);
 
 					if self.live_preview_recently_zero {
 						// Update the restart and pause/play buttons
@@ -116,7 +116,7 @@ impl MessageHandler<AnimationMessage, ()> for AnimationMessageHandler {
 					_ => AnimationState::Stopped,
 				};
 				self.live_preview_recently_zero = true;
-				responses.add(PortfolioMessage::SubmitActiveGraphRender);
+				responses.add(PortfolioMessage::EvaluateActiveDocument);
 				// Update the restart and pause/play buttons
 				responses.add(PortfolioMessage::UpdateDocumentWidgets);
 			}

editor/src/messages/dialog/export_dialog/export_dialog_message_handler.rs

@@ -43,7 +43,7 @@ impl MessageHandler<ExportDialogMessage, ExportDialogMessageData<'_>> for Export
 			ExportDialogMessage::TransparentBackground(transparent_background) => self.transparent_background = transparent_background,
 			ExportDialogMessage::ExportBounds(export_area) => self.bounds = export_area,
 
-			ExportDialogMessage::Submit => responses.add_front(PortfolioMessage::SubmitDocumentExport {
+			ExportDialogMessage::Submit => responses.add_front(PortfolioMessage::ActiveDocumentExport {
 				file_name: portfolio.active_document().map(|document| document.name.clone()).unwrap_or_default(),
 				file_type: self.file_type,
 				scale_factor: self.scale_factor,

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

@@ -24,7 +24,7 @@ impl MessageHandler<NewDocumentDialogMessage, ()> for NewDocumentDialogMessageHa
 
 				let create_artboard = !self.infinite && self.dimensions.x > 0 && self.dimensions.y > 0;
 				if create_artboard {
-					responses.add(Message::StartBuffer);
+					responses.add(Message::StartQueue);
 					responses.add(GraphOperationMessage::NewArtboard {
 						id: NodeId::new(),
 						artboard: graphene_std::Artboard::new(IVec2::ZERO, self.dimensions.as_ivec2()),
@@ -33,7 +33,7 @@ impl MessageHandler<NewDocumentDialogMessage, ()> for NewDocumentDialogMessageHa
 
 				// TODO: Figure out how to get StartBuffer to work here so we can delete this and use `DocumentMessage::ZoomCanvasToFitAll` instead
 				// Currently, it is necessary to use `FrontendMessage::TriggerDelayedZoomCanvasToFitAll` rather than `DocumentMessage::ZoomCanvasToFitAll` because the size of the viewport is not yet populated
-				responses.add(Message::StartBuffer);
+				responses.add(Message::StartQueue);
 				responses.add(FrontendMessage::TriggerDelayedZoomCanvasToFitAll);
 				responses.add(DocumentMessage::DeselectAllLayers);
 			}

editor/src/messages/dialog/preferences_dialog/preferences_dialog_message_handler.rs

@@ -174,7 +174,7 @@ impl PreferencesDialogMessageHandler {
 		let use_vello = vec![
 			Separator::new(SeparatorType::Unrelated).widget_holder(),
 			Separator::new(SeparatorType::Unrelated).widget_holder(),
-			CheckboxInput::new(preferences.use_vello && preferences.supports_wgpu())
+			CheckboxInput::new(preferences.use_vello())
 				.tooltip(vello_tooltip)
 				.disabled(!preferences.supports_wgpu())
 				.on_update(|checkbox_input: &CheckboxInput| PreferencesMessage::UseVello { use_vello: checkbox_input.checked }.into())

editor/src/messages/frontend/frontend_message.rs

@@ -14,6 +14,9 @@ use graphene_std::text::Font;
 #[impl_message(Message, Frontend)]
 #[derive(PartialEq, Clone, Debug, serde::Serialize, serde::Deserialize, specta::Type)]
 pub enum FrontendMessage {
+	ClearNodeThumbnail {
+		sni: NodeId,
+	},
 	// Display prefix: make the frontend show something, like a dialog
 	DisplayDialog {
 		title: String,
@@ -272,10 +275,6 @@ pub enum FrontendMessage {
 	UpdateNodeGraphTransform {
 		transform: Transform,
 	},
-	UpdateNodeThumbnail {
-		id: NodeId,
-		value: String,
-	},
 	UpdateOpenDocumentsList {
 		#[serde(rename = "openDocuments")]
 		open_documents: Vec<FrontendDocumentDetails>,
@@ -285,6 +284,11 @@ pub enum FrontendMessage {
 		layout_target: LayoutTarget,
 		diff: Vec<WidgetDiff>,
 	},
+	UpdateThumbnails {
+		add: Vec<(NodeId, String)>,
+		clear: Vec<NodeId>,
+		// remove: Vec<NodeId>,
+	},
 	UpdateToolOptionsLayout {
 		#[serde(rename = "layoutTarget")]
 		layout_target: LayoutTarget,

editor/src/messages/input_preprocessor/input_preprocessor_message_handler.rs

@@ -14,7 +14,7 @@ pub struct InputPreprocessorMessageData {
 #[derive(Debug, Default, ExtractField)]
 pub struct InputPreprocessorMessageHandler {
 	pub frame_time: FrameTimeInfo,
-	pub time: u64,
+	pub time: f64,
 	pub keyboard: KeyStates,
 	pub mouse: MouseState,
 	pub viewport_bounds: ViewportBounds,
@@ -98,9 +98,7 @@ impl MessageHandler<InputPreprocessorMessage, InputPreprocessorMessageData> for
 				self.translate_mouse_event(mouse_state, false, responses);
 			}
 			InputPreprocessorMessage::CurrentTime { timestamp } => {
-				responses.add(AnimationMessage::SetTime(timestamp as f64));
-				self.time = timestamp;
-				self.frame_time.advance_timestamp(Duration::from_millis(timestamp));
+				self.time = timestamp as f64;
 			}
 			InputPreprocessorMessage::WheelScroll { editor_mouse_state, modifier_keys } => {
 				self.update_states_of_modifier_keys(modifier_keys, keyboard_platform, responses);
@@ -187,10 +185,19 @@ impl InputPreprocessorMessageHandler {
 		}
 	}
 
-	pub fn document_bounds(&self) -> [DVec2; 2] {
+	pub fn viewport_bounds(&self) -> [DVec2; 2] {
 		// IPP bounds are relative to the entire application
 		[(0., 0.).into(), self.viewport_bounds.bottom_right - self.viewport_bounds.top_left]
 	}
+
+	pub fn document_bounds(&self, document_to_viewport: DAffine2) -> [DVec2; 2] {
+		// IPP bounds are relative to the entire application
+		let mut bounds = self.viewport_bounds();
+		for point in &mut bounds {
+			*point = document_to_viewport.transform_point2(*point);
+		}
+		bounds
+	}
 }
 
 #[cfg(test)]

editor/src/messages/message.rs

@@ -1,14 +1,26 @@
+use std::sync::Arc;
+
 use crate::messages::prelude::*;
+use graphene_std::{IntrospectMode, uuid::CompiledProtonodeInput};
 use graphite_proc_macros::*;
 
 #[impl_message]
-#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Debug, PartialEq)]
 pub enum Message {
 	NoOp,
 	Init,
 	Batched(Box<[Message]>),
-	StartBuffer,
-	EndBuffer(graphene_std::renderer::RenderMetadata),
+	// Adds any subsequent messages to the queue
+	StartQueue,
+	// Stop adding messages to the queue.
+	EndQueue,
+	// Processes all messages that are queued, which occurs on the evaluation response. This allows a message to be run with data from after the evaluation is complete
+	ProcessQueue(
+		(
+			graphene_std::renderer::RenderMetadata,
+			Vec<(CompiledProtonodeInput, IntrospectMode, Box<dyn std::any::Any + Send + Sync>)>,
+		),
+	),
 
 	#[child]
 	Animation(AnimationMessage),

editor/src/messages/portfolio/document/document_message.rs

@@ -7,12 +7,13 @@ use crate::messages::portfolio::document::utility_types::misc::{AlignAggregate,
 use crate::messages::portfolio::utility_types::PanelType;
 use crate::messages::prelude::*;
 use glam::DAffine2;
-use graph_craft::document::NodeId;
+use graphene_std::uuid::CompiledProtonodeInput;
 use graphene_std::Color;
 use graphene_std::raster::BlendMode;
 use graphene_std::raster::Image;
+use graphene_std::renderer::ClickTarget;
 use graphene_std::transform::Footprint;
-use graphene_std::vector::click_target::ClickTarget;
+use graphene_std::uuid::NodeId;
 use graphene_std::vector::style::ViewMode;
 
 #[impl_message(Message, PortfolioMessage, Document)]