First native render

Author: adamgerhant

Cargo.lock

@@ -1,6 +1,5 @@
 use crate::dispatcher::Dispatcher;
 use crate::messages::prelude::*;
-use crate::node_graph_ui_executor::EvaluationRequest;
 pub use graphene_std::uuid::*;
 
 // TODO: serialize with serde to save the current editor state
@@ -27,34 +26,6 @@ impl Editor {
 
 		std::mem::take(&mut self.dispatcher.responses)
 	}
-
-	pub fn poll_node_graph_ui_evaluation(&self) -> impl Iterator<Item = FrontendMessage> {
-		if let Some(active_document) = self.dispatcher.message_handlers.portfolio_message_handler.active_document() {
-			let Some(network_metadata) = active_document.network_interface.network_metadata(active_document.breadcrumb_network_path) else {
-				return;
-			};
-
-			let transform = active_document.navigation_handler.calculate_offset_transform(
-				self.dispatcher.message_handlers.input_preprocessor_message_handler.viewport_bounds.center(),
-				&network_metadata.persistent_metadata.navigation_metadata.node_graph_ptz,
-			);
-
-			let transfrom = NodeGraphTransform {
-				scale: transform.matrix2.x_axis.x,
-				x: transform.translation.x,
-				y: transform.translation.y,
-			};
-			let resolution = self.dispatcher.message_handlers.input_preprocessor_message_handler.viewport_bounds.size().as_uvec2();
-			let evaluation_request = EvaluationRequest { transform, resolution };
-			let responses = self
-				.dispatcher
-				.message_handlers
-				.portfolio_message_handler
-				.node_graph_ui_executor
-				.poll_node_graph_ui_evaluation(evaluation_request);
-			responses.into_iter().flat_map(|message| self.handle_message(message))
-		}
-	}
 }
 
 impl Default for Editor {

editor/src/application.rs

@@ -13,19 +13,19 @@ pub struct Dispatcher {
 
 #[derive(Debug, Default)]
 pub struct DispatcherMessageHandlers {
-	animation_message_handler: AnimationMessageHandler,
-	app_window_message_handler: AppWindowMessageHandler,
-	broadcast_message_handler: BroadcastMessageHandler,
-	debug_message_handler: DebugMessageHandler,
-	defer_message_handler: DeferMessageHandler,
-	dialog_message_handler: DialogMessageHandler,
-	globals_message_handler: GlobalsMessageHandler,
+	pub animation_message_handler: AnimationMessageHandler,
+	pub app_window_message_handler: AppWindowMessageHandler,
+	pub broadcast_message_handler: BroadcastMessageHandler,
+	pub debug_message_handler: DebugMessageHandler,
+	pub defer_message_handler: DeferMessageHandler,
+	pub dialog_message_handler: DialogMessageHandler,
+	pub globals_message_handler: GlobalsMessageHandler,
 	pub input_preprocessor_message_handler: InputPreprocessorMessageHandler,
-	key_mapping_message_handler: KeyMappingMessageHandler,
-	layout_message_handler: LayoutMessageHandler,
+	pub key_mapping_message_handler: KeyMappingMessageHandler,
+	pub layout_message_handler: LayoutMessageHandler,
 	pub portfolio_message_handler: PortfolioMessageHandler,
-	preferences_message_handler: PreferencesMessageHandler,
-	tool_message_handler: ToolMessageHandler,
+	pub preferences_message_handler: PreferencesMessageHandler,
+	pub tool_message_handler: ToolMessageHandler,
 }
 
 impl DispatcherMessageHandlers {
@@ -150,7 +150,10 @@ impl Dispatcher {
 				Message::Frontend(message) => {
 					// Handle these messages immediately by returning early
 					if let FrontendMessage::TriggerFontLoad { .. } = message {
-						self.responses.push(message);
+						// Deduplicate the render native node graph messages. TODO: Replace responses with hashset
+						if !(message == FrontendMessage::UpdateNodeGraphNativeRender && self.responses.contains(&FrontendMessage::UpdateNodeGraphNativeRender)) {
+							self.responses.push(message);
+						}
 						self.cleanup_queues(false);
 
 						// Return early to avoid running the code after the match block

editor/src/dispatcher.rs

@@ -12,7 +12,6 @@ pub mod consts;
 pub mod dispatcher;
 pub mod messages;
 pub mod node_graph_executor;
-pub mod node_graph_ui_executor;
 #[cfg(test)]
 pub mod test_utils;
 pub mod utility_traits;

editor/src/lib.rs

@@ -1,13 +1,13 @@
 use super::utility_types::{FrontendDocumentDetails, MouseCursorIcon};
 use crate::messages::app_window::app_window_message_handler::AppWindowPlatform;
 use crate::messages::layout::utility_types::widget_prelude::*;
-use crate::messages::portfolio::document::node_graph::utility_types::{BoxSelection, ContextMenuInformation, FrontendClickTargets, FrontendNodeType, NodeGraphTransform};
+use crate::messages::portfolio::document::node_graph::utility_types::{BoxSelection, ContextMenuInformation, FrontendClickTargets, FrontendNodeType};
 use crate::messages::portfolio::document::utility_types::nodes::{JsRawBuffer, LayerPanelEntry, RawBuffer};
 use crate::messages::portfolio::document::utility_types::wires::WirePathInProgress;
 use crate::messages::prelude::*;
 use crate::messages::tool::utility_types::HintData;
 use graph_craft::document::NodeId;
-use graphene_std::node_graph_overlay::types::{FrontendExports, FrontendImport, FrontendNodeToRender, FrontendXY};
+use graphene_std::node_graph_overlay::types::{FrontendExports, FrontendImport, FrontendNodeToRender, FrontendXY, NodeGraphTransform};
 use graphene_std::raster::Image;
 use graphene_std::raster::color::Color;
 use graphene_std::text::{Font, TextAlign};
@@ -267,7 +267,8 @@ pub enum FrontendMessage {
 	UpdateMouseCursor {
 		cursor: MouseCursorIcon,
 	},
-	UpdateNodeGraphRender {
+	UpdateNodeGraphNativeRender,
+	UpdateNodeGraphSvelteRender {
 		#[serde(rename = "nodesToRender")]
 		nodes_to_render: Vec<FrontendNodeToRender>,
 		open: bool,

editor/src/messages/frontend/frontend_message.rs

@@ -1,5 +1,4 @@
 use super::node_graph::document_node_definitions;
-use super::node_graph::utility_types::NodeGraphTransform;
 use super::overlays::utility_types::Pivot;
 use super::utility_types::error::EditorError;
 use super::utility_types::misc::{GroupFolderType, SNAP_FUNCTIONS_FOR_BOUNDING_BOXES, SNAP_FUNCTIONS_FOR_PATHS, SnappingOptions, SnappingState};
@@ -31,6 +30,7 @@ use glam::{DAffine2, DVec2, IVec2};
 use graph_craft::document::value::TaggedValue;
 use graph_craft::document::{NodeId, NodeInput, NodeNetwork, OldNodeNetwork};
 use graphene_std::math::quad::Quad;
+use graphene_std::node_graph_overlay::types::NodeGraphTransform;
 use graphene_std::path_bool::{boolean_intersect, path_bool_lib};
 use graphene_std::raster::BlendMode;
 use graphene_std::raster_types::Raster;
@@ -122,7 +122,7 @@ pub struct DocumentMessageHandler {
 	pub breadcrumb_network_path: Vec<NodeId>,
 	/// Path to network that is currently selected. Updated based on the most recently clicked panel.
 	#[serde(skip)]
-	selection_network_path: Vec<NodeId>,
+	pub selection_network_path: Vec<NodeId>,
 	/// Stack of document network snapshots for previous history states.
 	#[serde(skip)]
 	document_undo_history: VecDeque<NodeNetworkInterface>,

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

@@ -3,108 +3,133 @@ use graph_craft::{
 	document::{DocumentNode, DocumentNodeImplementation, NodeInput, NodeNetwork, value::TaggedValue},
 };
 use graphene_std::{
-	Context, graphic, memo,
-	node_graph_overlay::{self, types::NodeGraphOverlayData},
+	node_graph_overlay::{types::NodeGraphOverlayData, ui_context::UIContext},
+	table::Table,
 	uuid::NodeId,
 };
 
+/// https://excalidraw.com/#json=LgKS6I4lQvGPmke06ZJyp,D9aON9vVZJAjNnZWfwy_SQ
 pub fn generate_node_graph_overlay(node_graph_overlay_data: NodeGraphOverlayData, opacity: f64) -> DocumentNode {
-	// TODO: Implement as Network and implement finer grained caching for the background, nodes, and exports
+	let generate_nodes_id = NodeId::new();
+	let cache_nodes_id = NodeId::new();
+	let transform_nodes_id = NodeId::new();
+
+	let generate_node_graph_bg = NodeId::new();
+	let cache_node_graph_bg = NodeId::new();
+
+	let merge_nodes_and_bg_id = NodeId::new();
+	let render_overlay_id = NodeId::new();
+	let send_overlay_id = NodeId::new();
+	let _cache_output_id = NodeId::new();
+	// TODO: Replace with new cache node
+	let memo_implementation = DocumentNodeImplementation::ProtoNode(graphene_std::ops::identity::IDENTIFIER);
+
 	DocumentNode {
 		inputs: vec![
-			NodeInput::value(TaggedValue::None, true),
+			NodeInput::value(TaggedValue::Vector(Table::new()), true),
 			NodeInput::value(TaggedValue::NodeGraphOverlayData(node_graph_overlay_data), true),
 			NodeInput::value(TaggedValue::F64(opacity), true),
 		],
+
 		implementation: DocumentNodeImplementation::Network(NodeNetwork {
-			exports: vec![NodeInput::node(NodeId(0), 0)],
+			exports: vec![NodeInput::node(send_overlay_id, 0)],
 			nodes: vec![
-				// Merge the overlay on top of the artwork
+				// Create the nodes
 				(
-					NodeId(0),
+					generate_nodes_id,
 					DocumentNode {
-						call_argument: concrete!(Context),
-						inputs: vec![NodeInput::node(NodeId(2), 0), NodeInput::node(NodeId(1), 0)],
-						implementation: DocumentNodeImplementation::ProtoNode(graphic::extend::IDENTIFIER),
+						call_argument: concrete!(UIContext),
+						inputs: vec![NodeInput::network(concrete!(UIContext), 1)],
+						implementation: DocumentNodeImplementation::ProtoNode("graphene_core::node_graph_overlay::GenerateNodesNode".into()),
 						..Default::default()
 					},
 				),
-				//Wrap Artwork in a table
+				// Cache the nodes
 				(
-					NodeId(1),
+					cache_nodes_id,
 					DocumentNode {
-						inputs: vec![NodeInput::network(concrete!(Context), 0)],
-						implementation: DocumentNodeImplementation::ProtoNode(graphic::wrap_graphic::IDENTIFIER),
-						call_argument: concrete!(Context),
+						call_argument: concrete!(UIContext),
+						inputs: vec![NodeInput::node(generate_nodes_id, 0)],
+						implementation: memo_implementation.clone(),
 						..Default::default()
 					},
 				),
-				// Cache the full node graph so its not rerendered when the artwork changes
+				// Transform the nodes based on the Context
 				(
-					NodeId(2),
+					transform_nodes_id,
 					DocumentNode {
-						call_argument: concrete!(Context),
-						inputs: vec![NodeInput::node(NodeId(3), 0)],
-						implementation: DocumentNodeImplementation::ProtoNode(memo::memo::IDENTIFIER),
+						call_argument: concrete!(UIContext),
+						inputs: vec![NodeInput::node(cache_nodes_id, 0)],
+						implementation: DocumentNodeImplementation::ProtoNode("graphene_core::node_graph_overlay::TransformNodesNode".into()),
 						..Default::default()
 					},
 				),
-				// Merge the nodes on top of the dot grid background
+				// Generate the dot grid background
 				(
-					NodeId(3),
+					generate_node_graph_bg,
 					DocumentNode {
-						call_argument: concrete!(Context),
-						inputs: vec![NodeInput::node(NodeId(5), 0), NodeInput::node(NodeId(4), 0)],
-						implementation: DocumentNodeImplementation::ProtoNode(graphic::extend::IDENTIFIER),
+						inputs: vec![NodeInput::network(concrete!(UIContext), 2)],
+						implementation: DocumentNodeImplementation::ProtoNode("graphene_core::node_graph_overlay::DotGridBackgroundNode".into()),
+						call_argument: concrete!(UIContext),
 						..Default::default()
 					},
 				),
-				// Generate the dot grid background
+				// Cache the dot grid background
 				(
-					NodeId(4),
+					cache_node_graph_bg,
 					DocumentNode {
-						inputs: vec![NodeInput::network(concrete!(Context), 2)],
-						implementation: DocumentNodeImplementation::ProtoNode(node_graph_overlay::dot_grid_background::IDENTIFIER),
-						call_argument: concrete!(Context),
+						call_argument: concrete!(UIContext),
+						inputs: vec![NodeInput::node(generate_node_graph_bg, 0)],
+						implementation: memo_implementation.clone(),
 						..Default::default()
 					},
 				),
-				// Transform the nodes based on the Context
+				// Merge the nodes on top of the dot grid background
 				(
-					NodeId(5),
+					merge_nodes_and_bg_id,
 					DocumentNode {
-						call_argument: concrete!(Context),
-						inputs: vec![NodeInput::node(NodeId(6), 0)],
-						implementation: DocumentNodeImplementation::ProtoNode(node_graph_overlay::transform_nodes::IDENTIFIER),
+						call_argument: concrete!(UIContext),
+						inputs: vec![NodeInput::node(transform_nodes_id, 0), NodeInput::node(cache_node_graph_bg, 0)],
+						implementation: DocumentNodeImplementation::ProtoNode("graphene_core::node_graph_overlay::NodeGraphUiExtendNode".into()),
 						..Default::default()
 					},
 				),
-				// Cache the nodes
+				// Render the node graph UI graphic to an SVG
 				(
-					NodeId(6),
+					render_overlay_id,
 					DocumentNode {
-						call_argument: concrete!(Context),
-						inputs: vec![NodeInput::node(NodeId(7), 0)],
-						implementation: DocumentNodeImplementation::ProtoNode(memo::memo::IDENTIFIER),
+						call_argument: concrete!(UIContext),
+						inputs: vec![NodeInput::node(merge_nodes_and_bg_id, 0)],
+						implementation: DocumentNodeImplementation::ProtoNode("graphene_std::wasm_application_io::RenderNodeGraphUiNode".into()),
 						..Default::default()
 					},
 				),
-				// Create the nodes
+				// Send the overlay to the frontend
 				(
-					NodeId(7),
+					send_overlay_id,
 					DocumentNode {
-						call_argument: concrete!(Context),
-						inputs: vec![NodeInput::network(concrete!(Context), 1)],
-						implementation: DocumentNodeImplementation::ProtoNode(node_graph_overlay::generate_nodes::IDENTIFIER),
+						call_argument: concrete!(UIContext),
+						inputs: vec![NodeInput::node(render_overlay_id, 0)],
+						implementation: DocumentNodeImplementation::ProtoNode("graphene_core::node_graph_overlay::SendRenderNode".into()),
 						..Default::default()
 					},
 				),
+				// Cache the full node graph so its not rerendered when the artwork changes
+				// (
+				// 	cache_nodes_id,
+				// 	DocumentNode {
+				// 		call_argument: concrete!(UIContext),
+				// 		inputs: vec![NodeInput::node(send_overlay_id, 0)],
+				// 		implementation: memo_implementation.clone(),
+				// 		..Default::default()
+				// 	},
+				// ),
 			]
 			.into_iter()
 			.collect(),
 			..Default::default()
 		}),
-		call_argument: concrete!(Context),
+		call_argument: concrete!(UIContext),
 		..Default::default()
 	}
 }

editor/src/messages/portfolio/document/node_graph/generate_node_graph_overlay.rs

@@ -21,7 +21,7 @@ use crate::messages::tool::common_functionality::utility_functions::make_path_ed
 use crate::messages::tool::tool_messages::tool_prelude::{Key, MouseMotion};
 use crate::messages::tool::utility_types::{HintData, HintGroup, HintInfo};
 use glam::{DAffine2, DVec2, IVec2};
-use graph_craft::document::{DocumentNode, DocumentNodeImplementation, NodeId, NodeInput};
+use graph_craft::document::{DocumentNodeImplementation, NodeId, NodeInput};
 use graph_craft::proto::GraphErrors;
 use graphene_std::math::math_ext::QuadExt;
 use graphene_std::node_graph_overlay::types::{FrontendGraphDataType, FrontendXY};
@@ -96,8 +96,6 @@ pub struct NodeGraphMessageHandler {
 	frontend_nodes: Vec<NodeId>,
 	/// Disables rendering nodes in Svelte
 	native_node_graph_render: bool,
-	/// The node which renders the node graph overlay. Inserted after the root export
-	pub node_graph_overlay: Option<DocumentNode>,
 }
 
 /// NodeGraphMessageHandler always modifies the network which the selected nodes are in. No GraphOperationMessages should be added here, since those messages will always affect the document network.
@@ -1626,20 +1624,14 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphMessageContext<'a>> for NodeG
 				responses.add(DocumentMessage::DocumentStructureChanged);
 				responses.add(PropertiesPanelMessage::Refresh);
 				responses.add(NodeGraphMessage::UpdateActionButtons);
-				let nodes_to_render = network_interface.collect_nodes(&self.node_graph_errors, preferences.graph_wire_style, breadcrumb_network_path);
-				self.frontend_nodes = nodes_to_render.iter().map(|node| node.metadata.node_id).collect();
-				let previewed_node = network_interface.previewed_node(breadcrumb_network_path);
+
 				if self.native_node_graph_render {
-					let node_graph_render_data = node_graph_overlay::types::NodeGraphOverlayData {
-						nodes_to_render,
-						open: graph_view_overlay_open,
-						in_selected_network: selection_network_path == breadcrumb_network_path,
-						previewed_node,
-					};
-					self.node_graph_overlay = Some(super::generate_node_graph_overlay::generate_node_graph_overlay(node_graph_render_data, graph_fade_artwork_percentage));
-					responses.add(PortfolioMessage::SubmitActiveGraphRender);
+					responses.add(FrontendMessage::UpdateNodeGraphNativeRender);
 				} else {
-					responses.add(FrontendMessage::UpdateNodeGraphRender {
+					let nodes_to_render = network_interface.collect_nodes(&self.node_graph_errors, preferences.graph_wire_style, breadcrumb_network_path);
+					self.frontend_nodes = nodes_to_render.iter().map(|node| node.metadata.node_id).collect();
+					let previewed_node = network_interface.previewed_node(breadcrumb_network_path);
+					responses.add(FrontendMessage::UpdateNodeGraphSvelteRender {
 						nodes_to_render,
 						open: graph_view_overlay_open,
 						opacity: graph_fade_artwork_percentage,
@@ -1799,7 +1791,9 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphMessageContext<'a>> for NodeG
 			}
 			NodeGraphMessage::ToggleNativeNodeGraphRender => {
 				self.native_node_graph_render = !self.native_node_graph_render;
-				self.node_graph_overlay = None;
+				responses.add(FrontendMessage::UpdateNativeNodeGraphRender {
+					native_node_graph_render: self.native_node_graph_render,
+				});
 				responses.add(NodeGraphMessage::SendGraph);
 			}
 			NodeGraphMessage::ToggleSelectedLocked => {
@@ -2634,7 +2628,6 @@ impl Default for NodeGraphMessageHandler {
 			end_index: None,
 			frontend_nodes: Vec::new(),
 			native_node_graph_render: false,
-			node_graph_overlay: None,
 		}
 	}
 }