Render Output footprints

Author: adamgerhant

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

@@ -13,6 +13,7 @@ use graphene_core::vector::style::ViewMode;
 use graphene_core::Color;
 
 use glam::DAffine2;
+use graphene_std::transform::Footprint;
 
 #[impl_message(Message, PortfolioMessage, Document)]
 #[derive(PartialEq, Clone, Debug, serde::Serialize, serde::Deserialize)]
@@ -155,6 +156,9 @@ pub enum DocumentMessage {
 	ToggleGridVisibility,
 	ToggleOverlaysVisibility,
 	ToggleSnapping,
+	UpdateUpstreamTransforms {
+		upstream_transforms: HashMap<NodeId, (Footprint, DAffine2)>,
+	},
 	Undo,
 	UngroupSelectedLayers,
 	UngroupLayer {

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

@@ -1039,6 +1039,9 @@ impl MessageHandler<DocumentMessage, DocumentMessageData<'_>> for DocumentMessag
 				self.snapping_state.snapping_enabled = !self.snapping_state.snapping_enabled;
 				responses.add(PortfolioMessage::UpdateDocumentWidgets);
 			}
+			DocumentMessage::UpdateUpstreamTransforms { upstream_transforms } => {
+				self.network_interface.document_metadata_mut().update_transforms(upstream_transforms);
+			}
 			DocumentMessage::Undo => {
 				if self.network_interface.transaction_status() != TransactionStatus::Finished {
 					return;

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

@@ -359,8 +359,9 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 								inputs: vec![
 									NodeInput::network(graphene_core::Type::Fn(Box::new(concrete!(Footprint)), Box::new(concrete!(ArtboardGroup))), 0),
 									NodeInput::node(NodeId(1), 0),
+									NodeInput::value(TaggedValue::OptionalNodeId(None), false),
 								],
-								implementation: DocumentNodeImplementation::proto("graphene_core::AddArtboardNode<_, _>"),
+								implementation: DocumentNodeImplementation::proto("graphene_core::AddArtboardNode<_, _, _>"),
 								..Default::default()
 							},
 						]

editor/src/messages/tool/tool_messages/select_tool.rs

@@ -528,7 +528,6 @@ impl Fsm for SelectToolFsmState {
 
 					edges
 				});
-
 				let rotating_bounds = tool_data
 					.bounding_box_manager
 					.as_ref()
@@ -634,7 +633,6 @@ impl Fsm for SelectToolFsmState {
 					tool_data.layers_dragging = selected;
 
 					tool_data.get_snap_candidates(document, input);
-
 					SelectToolFsmState::Dragging
 				}
 				// Dragging a selection box
@@ -656,7 +654,6 @@ impl Fsm for SelectToolFsmState {
 							_ => drag_deepest_manipulation(responses, selected, tool_data, document),
 						}
 						tool_data.get_snap_candidates(document, input);
-
 						responses.add(DocumentMessage::StartTransaction);
 						SelectToolFsmState::Dragging
 					} else {
@@ -1200,9 +1197,12 @@ fn drag_shallowest_manipulation(responses: &mut VecDeque<Message>, selected: Vec
 }
 
 fn drag_deepest_manipulation(responses: &mut VecDeque<Message>, selected: Vec<LayerNodeIdentifier>, tool_data: &mut SelectToolData, document: &DocumentMessageHandler) {
-	tool_data.layers_dragging.append(&mut vec![document
-		.find_deepest(&selected)
-		.unwrap_or(LayerNodeIdentifier::ROOT_PARENT.children(document.metadata()).next().expect("Child should exist when dragging deepest"))]);
+	tool_data.layers_dragging.append(&mut vec![document.find_deepest(&selected).unwrap_or(
+		LayerNodeIdentifier::ROOT_PARENT
+			.children(document.metadata())
+			.next()
+			.expect("ROOT_PARENT should have a layer child when clicking"),
+	)]);
 	responses.add(NodeGraphMessage::SelectedNodesSet {
 		nodes: tool_data
 			.layers_dragging

editor/src/node_graph_executor.rs

@@ -536,7 +536,7 @@ impl NodeGraphExecutor {
 	}
 
 	fn export(&self, node_graph_output: TaggedValue, export_config: ExportConfig, responses: &mut VecDeque<Message>) -> Result<(), String> {
-		let TaggedValue::RenderOutput(graphene_std::wasm_application_io::RenderOutput::Svg(svg)) = node_graph_output else {
+		let TaggedValue::RenderOutput(graphene_std::wasm_application_io::RenderOutput::Svg((svg, _))) = node_graph_output else {
 			return Err("Incorrect render type for exportign (expected RenderOutput::Svg)".to_string());
 		};
 
@@ -592,7 +592,7 @@ impl NodeGraphExecutor {
 					};
 
 					responses.extend(existing_responses.into_iter().map(Into::into));
-					document.network_interface.document_metadata_mut().update_transforms(new_upstream_transforms);
+					//document.network_interface.document_metadata_mut().update_transforms(new_upstream_transforms);
 					document.network_interface.document_metadata_mut().update_from_monitor(new_click_targets, new_vector_modify);
 
 					let execution_context = self.futures.remove(&execution_id).ok_or_else(|| "Invalid generation ID".to_string())?;
@@ -657,12 +657,16 @@ impl NodeGraphExecutor {
 			TaggedValue::SurfaceFrame(SurfaceFrame { .. }) => {
 				// TODO: Reimplement this now that document-legacy is gone
 			}
-			TaggedValue::RenderOutput(graphene_std::wasm_application_io::RenderOutput::Svg(svg)) => {
+			TaggedValue::RenderOutput(graphene_std::wasm_application_io::RenderOutput::Svg((svg, footprints))) => {
 				// Send to frontend
+				log::debug!("Render output footprints: {footprints:?}");
 				responses.add(FrontendMessage::UpdateDocumentArtwork { svg });
 				responses.add(DocumentMessage::RenderScrollbars);
 				responses.add(DocumentMessage::RenderRulers);
+				responses.add(DocumentMessage::UpdateUpstreamTransforms { upstream_transforms: footprints });
+				responses.add(OverlaysMessage::Draw);
 			}
+
 			TaggedValue::RenderOutput(graphene_std::wasm_application_io::RenderOutput::CanvasFrame(frame)) => {
 				let matrix = format_transform_matrix(frame.transform);
 				let transform = if matrix.is_empty() { String::new() } else { format!(" transform=\"{}\"", matrix) };

node-graph/gcore/src/graphic_element.rs

@@ -1,6 +1,7 @@
 use crate::application_io::TextureFrame;
 use crate::raster::{BlendMode, ImageFrame};
 use crate::transform::{Footprint, Transform, TransformMut};
+use crate::uuid::NodeId;
 use crate::vector::VectorData;
 use crate::{Color, Node};
 
@@ -43,7 +44,7 @@ impl AlphaBlending {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct GraphicGroup {
 	// TODO:  Separate into multiple Vecs in a spread sheet format.
-	elements: Vec<(GraphicElement, Option<(u64, Footprint)>)>,
+	elements: Vec<(GraphicElement, Option<NodeId>)>,
 	// TODO: Convert to Vec<DAffine2>
 	pub transform: DAffine2,
 	// TODO: Convert to Vec<AlphaBlending>
@@ -219,7 +220,7 @@ impl Artboard {
 #[derive(Clone, Default, Debug, Hash, PartialEq, DynAny)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct ArtboardGroup {
-	pub artboards: Vec<Artboard>,
+	pub artboards: Vec<(Artboard, Option<NodeId>)>,
 }
 
 impl ArtboardGroup {
@@ -229,8 +230,8 @@ impl ArtboardGroup {
 		Default::default()
 	}
 
-	fn add_artboard(&mut self, artboard: Artboard) {
-		self.artboards.push(artboard);
+	fn add_artboard(&mut self, artboard: Artboard, node_id: Option<NodeId>) {
+		self.artboards.push((artboard, node_id));
 	}
 }
 
@@ -245,15 +246,11 @@ async fn construct_layer<Data: Into<GraphicElement> + Send>(
 	footprint: crate::transform::Footprint,
 	mut stack: impl Node<crate::transform::Footprint, Output = GraphicGroup>,
 	graphic_element: impl Node<crate::transform::Footprint, Output = Data>,
-	node_id: Option<u64>,
+	node_id: Option<NodeId>,
 ) -> GraphicGroup {
 	let graphic_element = self.graphic_element.eval(footprint).await;
 	let mut stack = self.stack.eval(footprint).await;
-	if let Some(node_id) = node_id {
-		stack.push((graphic_element.into(), Some((node_id, footprint))));
-	} else {
-		stack.push((graphic_element.into(), None));
-	}
+	stack.push((graphic_element.into(), node_id));
 	stack
 }
 
@@ -302,17 +299,23 @@ async fn construct_artboard(
 		clip,
 	}
 }
-pub struct AddArtboardNode<ArtboardGroup, Artboard> {
+pub struct AddArtboardNode<ArtboardGroup, Artboard, OptionalNodeId> {
 	artboards: ArtboardGroup,
 	artboard: Artboard,
+	node_id: OptionalNodeId,
 }
 
 #[node_fn(AddArtboardNode)]
-async fn add_artboard<Data: Into<Artboard> + Send>(footprint: Footprint, artboards: impl Node<Footprint, Output = ArtboardGroup>, artboard: impl Node<Footprint, Output = Data>) -> ArtboardGroup {
+async fn add_artboard<Data: Into<Artboard> + Send>(
+	footprint: Footprint,
+	artboards: impl Node<Footprint, Output = ArtboardGroup>,
+	artboard: impl Node<Footprint, Output = Data>,
+	node_id: Option<NodeId>,
+) -> ArtboardGroup {
 	let artboard = self.artboard.eval(footprint).await;
 	let mut artboards = self.artboards.eval(footprint).await;
 
-	artboards.add_artboard(artboard.into());
+	artboards.add_artboard(artboard.into(), node_id);
 
 	artboards
 }
@@ -339,7 +342,7 @@ impl From<GraphicGroup> for GraphicElement {
 }
 
 impl Deref for GraphicGroup {
-	type Target = Vec<(GraphicElement, Option<(u64, Footprint)>)>;
+	type Target = Vec<(GraphicElement, Option<NodeId>)>;
 	fn deref(&self) -> &Self::Target {
 		&self.elements
 	}

node-graph/gcore/src/graphic_element/renderer.rs

@@ -4,8 +4,8 @@ pub use quad::Quad;
 pub use rect::Rect;
 
 use crate::raster::{BlendMode, Image, ImageFrame};
-use crate::transform::Transform;
-use crate::uuid::generate_uuid;
+use crate::transform::{self, Footprint, Transform};
+use crate::uuid::{generate_uuid, NodeId};
 use crate::vector::style::{Fill, Stroke, ViewMode};
 use crate::vector::PointId;
 use crate::Raster;
@@ -16,6 +16,7 @@ use bezier_rs::Subpath;
 use base64::Engine;
 use glam::{DAffine2, DVec2};
 use num_traits::Zero;
+use std::collections::HashMap;
 use std::fmt::Write;
 #[cfg(feature = "vello")]
 use vello::*;
@@ -272,7 +273,7 @@ pub trait GraphicElementRendered {
 	fn render_svg(&self, render: &mut SvgRender, render_params: &RenderParams);
 	fn bounding_box(&self, transform: DAffine2) -> Option<[DVec2; 2]>;
 	fn add_click_targets(&self, click_targets: &mut Vec<ClickTarget>);
-	fn add_footprints(&self, footprints: &mut HashMap<NodeId, Footprint>)
+	fn add_footprints(&self, footprints: &mut HashMap<NodeId, (Footprint, DAffine2)>, footprint: Footprint, element_id: Option<NodeId>);
 	#[cfg(feature = "vello")]
 	fn to_vello_scene(&self, transform: DAffine2, context: &mut RenderContext) -> Scene {
 		let mut scene = vello::Scene::new();
@@ -328,6 +329,19 @@ impl GraphicElementRendered for GraphicGroup {
 		}
 	}
 
+	fn add_footprints(&self, footprints: &mut HashMap<NodeId, (Footprint, DAffine2)>, mut footprint: Footprint, _: Option<NodeId>) {
+		log::debug!("Transform for graphic group: {:?}", self.transform);
+		footprint.transform *= self.transform;
+		for (element, optional_node_id) in self.elements.iter() {
+			log::debug!("Optional node id: {:?}", optional_node_id);
+			if let Some(element_id) = optional_node_id {
+				let mut new_footprints = HashMap::new();
+				element.add_footprints(&mut new_footprints, footprint, Some(*element_id));
+				footprints.extend(new_footprints);
+			}
+		}
+	}
+
 	#[cfg(feature = "vello")]
 	fn render_to_vello(&self, scene: &mut Scene, transform: DAffine2, context: &mut RenderContext) {
 		let child_transform = transform * self.transform;
@@ -411,6 +425,8 @@ impl GraphicElementRendered for VectorData {
 		click_targets.extend(self.stroke_bezier_paths().map(fill).map(|subpath| ClickTarget::new(subpath, stroke_width)));
 	}
 
+	fn add_footprints(&self, footprints: &mut HashMap<NodeId, (Footprint, DAffine2)>, footprint: Footprint, _: Option<NodeId>) {}
+
 	#[cfg(feature = "vello")]
 	fn render_to_vello(&self, scene: &mut Scene, transform: DAffine2, _: &mut RenderContext) {
 		use crate::vector::style::GradientType;
@@ -626,35 +642,52 @@ impl GraphicElementRendered for Artboard {
 		click_targets.push(ClickTarget::new(subpath, 0.));
 	}
 
+	fn add_footprints(&self, footprints: &mut HashMap<NodeId, (Footprint, DAffine2)>, mut footprint: Footprint, node_id: Option<NodeId>) {
+		log::debug!("Adding footprints for artboard");
+		let mut graphic_group_footprint = footprint.clone();
+		graphic_group_footprint.transform *= self.transform();
+		self.graphic_group.add_footprints(footprints, graphic_group_footprint, None);
+		// footprint.transform *= self.transform();
+		if let Some(node_id) = node_id {
+			footprints.insert(node_id, (footprint, DAffine2::from_translation(self.location.as_dvec2())));
+		}
+	}
+
 	fn contains_artboard(&self) -> bool {
 		true
 	}
 }
 
 impl GraphicElementRendered for crate::ArtboardGroup {
 	fn render_svg(&self, render: &mut SvgRender, render_params: &RenderParams) {
-		for artboard in &self.artboards {
+		for (artboard, _) in &self.artboards {
 			artboard.render_svg(render, render_params);
 		}
 	}
 
 	fn bounding_box(&self, transform: DAffine2) -> Option<[DVec2; 2]> {
-		self.artboards.iter().filter_map(|element| element.bounding_box(transform)).reduce(Quad::combine_bounds)
+		self.artboards.iter().filter_map(|(element, _)| element.bounding_box(transform)).reduce(Quad::combine_bounds)
 	}
 
 	fn add_click_targets(&self, click_targets: &mut Vec<ClickTarget>) {
-		for artboard in &self.artboards {
+		for (artboard, _) in &self.artboards {
 			artboard.add_click_targets(click_targets);
 		}
 	}
 
 	#[cfg(feature = "vello")]
 	fn render_to_vello(&self, scene: &mut Scene, transform: DAffine2, context: &mut RenderContext) {
-		for artboard in &self.artboards {
+		for (artboard, _) in &self.artboards {
 			artboard.render_to_vello(scene, transform, context)
 		}
 	}
 
+	fn add_footprints(&self, footprints: &mut HashMap<NodeId, (Footprint, DAffine2)>, footprint: Footprint, _: Option<NodeId>) {
+		for (artboard, node_id) in &self.artboards {
+			artboard.add_footprints(footprints, footprint, *node_id)
+		}
+	}
+
 	fn contains_artboard(&self) -> bool {
 		!self.artboards.is_empty()
 	}
@@ -706,6 +739,12 @@ impl GraphicElementRendered for ImageFrame<Color> {
 		click_targets.push(ClickTarget::new(subpath, 0.));
 	}
 
+	fn add_footprints(&self, footprints: &mut HashMap<NodeId, (Footprint, DAffine2)>, footprint: Footprint, element_id: Option<NodeId>) {
+		if let Some(element_id) = element_id {
+			footprints.insert(element_id, (footprint, self.transform));
+		}
+	}
+
 	#[cfg(feature = "vello")]
 	fn render_to_vello(&self, scene: &mut Scene, transform: DAffine2, _: &mut RenderContext) {
 		use vello::peniko;
@@ -776,6 +815,10 @@ impl GraphicElementRendered for Raster {
 		click_targets.push(ClickTarget::new(subpath, 0.));
 	}
 
+	fn add_footprints(&self, footprints: &mut HashMap<NodeId, (Footprint, DAffine2)>, footprint: Footprint, element_id: Option<NodeId>) {
+		//footprints.insert(element_id, (transform, self.transform));
+	}
+
 	#[cfg(feature = "vello")]
 	fn render_to_vello(&self, scene: &mut Scene, transform: DAffine2, context: &mut RenderContext) {
 		use vello::peniko;
@@ -841,6 +884,17 @@ impl GraphicElementRendered for GraphicElement {
 		}
 	}
 
+	fn add_footprints(&self, footprints: &mut HashMap<NodeId, (Footprint, DAffine2)>, footprint: Footprint, element_id: Option<NodeId>) {
+		if let Some(element_id) = element_id {
+			footprints.insert(element_id, (footprint, self.transform()));
+		}
+		match self {
+			GraphicElement::VectorData(vector_data) => vector_data.add_footprints(footprints, footprint, None),
+			GraphicElement::Raster(raster) => raster.add_footprints(footprints, footprint, None),
+			GraphicElement::GraphicGroup(graphic_group) => graphic_group.add_footprints(footprints, footprint, None),
+		}
+	}
+
 	#[cfg(feature = "vello")]
 	fn render_to_vello(&self, scene: &mut Scene, transform: DAffine2, context: &mut RenderContext) {
 		match self {
@@ -883,6 +937,7 @@ impl<T: Primitive> GraphicElementRendered for T {
 	}
 
 	fn add_click_targets(&self, _click_targets: &mut Vec<ClickTarget>) {}
+	fn add_footprints(&self, footprints: &mut HashMap<NodeId, (Footprint, DAffine2)>, footprint: Footprint, element_id: Option<NodeId>) {}
 }
 
 impl GraphicElementRendered for Option<Color> {
@@ -910,6 +965,8 @@ impl GraphicElementRendered for Option<Color> {
 	}
 
 	fn add_click_targets(&self, _click_targets: &mut Vec<ClickTarget>) {}
+
+	fn add_footprints(&self, footprints: &mut HashMap<NodeId, (Footprint, DAffine2)>, footprint: Footprint, element_id: Option<NodeId>) {}
 }
 
 impl GraphicElementRendered for Vec<Color> {
@@ -933,6 +990,8 @@ impl GraphicElementRendered for Vec<Color> {
 	}
 
 	fn add_click_targets(&self, _click_targets: &mut Vec<ClickTarget>) {}
+
+	fn add_footprints(&self, footprints: &mut HashMap<NodeId, (Footprint, DAffine2)>, footprint: Footprint, element_id: Option<NodeId>) {}
 }
 
 /// A segment of an svg string to allow for embedding blob urls