Output group from copy to points, add repeat for graphic groups, fix …

…editor freeze on render fail

editor/src/messages/portfolio/portfolio_message_handler.rs

@@ -963,6 +963,7 @@ impl PortfolioMessageHandler {
 				/text>"#
 				// It's a mystery why the `/text>` tag above needs to be missing its `<`, but when it exists it prints the `<` character in the text. However this works with it removed.
 				.to_string();
+			responses.add(Message::EndBuffer(graphene_std::renderer::RenderMetadata::default()));
 			responses.add(FrontendMessage::UpdateDocumentArtwork { svg: error });
 		}
 		result

editor/src/node_graph_executor.rs

@@ -15,7 +15,7 @@ use graphene_core::renderer::{RenderSvgSegmentList, SvgSegment};
 use graphene_core::text::FontCache;
 use graphene_core::transform::Footprint;
 use graphene_core::vector::style::ViewMode;
-use graphene_std::renderer::format_transform_matrix;
+use graphene_std::renderer::{format_transform_matrix, RenderMetadata};
 use graphene_std::vector::VectorData;
 use graphene_std::wasm_application_io::{WasmApplicationIo, WasmEditorApi};
 use interpreted_executor::dynamic_executor::{DynamicExecutor, IntrospectError, ResolvedDocumentNodeTypesDelta};
@@ -630,6 +630,7 @@ impl NodeGraphExecutor {
 	}
 
 	fn process_node_graph_output(&mut self, node_graph_output: TaggedValue, transform: DAffine2, responses: &mut VecDeque<Message>) -> Result<(), String> {
+		let mut render_output_metadata = RenderMetadata::default();
 		match node_graph_output {
 			TaggedValue::RenderOutput(render_output) => {
 				match render_output.data {
@@ -651,10 +652,7 @@ impl NodeGraphExecutor {
 					}
 				}
 
-				responses.add(Message::EndBuffer(render_output.metadata));
-				responses.add(DocumentMessage::RenderScrollbars);
-				responses.add(DocumentMessage::RenderRulers);
-				responses.add(OverlaysMessage::Draw);
+				render_output_metadata = render_output.metadata;
 			}
 			TaggedValue::Bool(render_object) => Self::debug_render(render_object, transform, responses),
 			TaggedValue::String(render_object) => Self::debug_render(render_object, transform, responses),
@@ -669,6 +667,10 @@ impl NodeGraphExecutor {
 				return Err(format!("Invalid node graph output type: {node_graph_output:#?}"));
 			}
 		};
+		responses.add(Message::EndBuffer(render_output_metadata));
+		responses.add(DocumentMessage::RenderScrollbars);
+		responses.add(DocumentMessage::RenderRulers);
+		responses.add(OverlaysMessage::Draw);
 		Ok(())
 	}
 }

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

@@ -272,7 +272,7 @@ pub fn to_transform(transform: DAffine2) -> usvg::Transform {
 
 // TODO: Click targets can be removed from the render output, since the vector data is available in the vector modify data from Monitor nodes.
 // This will require that the transform for child layers into that layer space be calculated, or it could be returned from the RenderOutput instead of click targets.
-#[derive(Debug, Clone, PartialEq, DynAny)]
+#[derive(Debug, Default, Clone, PartialEq, DynAny)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct RenderMetadata {
 	pub footprints: HashMap<NodeId, (Footprint, DAffine2)>,
@@ -306,6 +306,12 @@ pub trait GraphicElementRendered {
 	fn contains_artboard(&self) -> bool {
 		false
 	}
+
+	fn new_ids_from_hash(&mut self, _reference: Option<NodeId>) {}
+
+	fn to_graphic_element(&self) -> GraphicElement {
+		GraphicElement::default()
+	}
 }
 
 impl GraphicElementRendered for GraphicGroup {
@@ -398,6 +404,16 @@ impl GraphicElementRendered for GraphicGroup {
 	fn contains_artboard(&self) -> bool {
 		self.iter().any(|(element, _)| element.contains_artboard())
 	}
+
+	fn new_ids_from_hash(&mut self, _reference: Option<NodeId>) {
+		for (element, node_id) in self.elements.iter_mut() {
+			element.new_ids_from_hash(*node_id);
+		}
+	}
+
+	fn to_graphic_element(&self) -> GraphicElement {
+		GraphicElement::GraphicGroup(self.clone())
+	}
 }
 
 impl GraphicElementRendered for VectorData {
@@ -587,6 +603,14 @@ impl GraphicElementRendered for VectorData {
 			scene.pop_layer();
 		}
 	}
+
+	fn new_ids_from_hash(&mut self, reference: Option<NodeId>) {
+		self.vector_new_ids_from_hash(reference.map(|id| id.0).unwrap_or_default());
+	}
+
+	fn to_graphic_element(&self) -> GraphicElement {
+		GraphicElement::VectorData(Box::new(self.clone()))
+	}
 }
 
 impl GraphicElementRendered for Artboard {
@@ -968,6 +992,14 @@ impl GraphicElementRendered for GraphicElement {
 			GraphicElement::Raster(raster) => raster.contains_artboard(),
 		}
 	}
+
+	fn new_ids_from_hash(&mut self, reference: Option<NodeId>) {
+		match self {
+			GraphicElement::VectorData(vector_data) => vector_data.new_ids_from_hash(reference),
+			GraphicElement::GraphicGroup(graphic_group) => graphic_group.new_ids_from_hash(reference),
+			GraphicElement::Raster(_) => (),
+		}
+	}
 }
 
 /// Used to stop rust complaining about upstream traits adding display implementations to `Option<Color>`. This would not be an issue as we control that crate.

node-graph/gcore/src/vector/vector_data/attributes.rs

@@ -23,8 +23,9 @@ macro_rules! create_ids {
 					Self(crate::uuid::generate_uuid())
 				}
 
-				pub fn generate_from_hash(self) -> Self {
+				pub fn generate_from_hash(self, node_id: u64) -> Self {
 					let mut hasher = std::hash::DefaultHasher::new();
+					node_id.hash(&mut hasher);
 					self.hash(&mut hasher);
 					let hash_value = hasher.finish();
 					Self(hash_value)
@@ -614,10 +615,10 @@ impl super::VectorData {
 		self.segment_domain.transform(transform);
 	}
 
-	pub fn new_ids_from_hash(&mut self) {
-		let point_map = self.point_domain.ids().iter().map(|&old| (old, old.generate_from_hash())).collect::<HashMap<_, _>>();
-		let segment_map = self.segment_domain.ids().iter().map(|&old| (old, old.generate_from_hash())).collect::<HashMap<_, _>>();
-		let region_map = self.region_domain.ids().iter().map(|&old| (old, old.generate_from_hash())).collect::<HashMap<_, _>>();
+	pub fn vector_new_ids_from_hash(&mut self, node_id: u64) {
+		let point_map = self.point_domain.ids().iter().map(|&old| (old, old.generate_from_hash(node_id))).collect::<HashMap<_, _>>();
+		let segment_map = self.segment_domain.ids().iter().map(|&old| (old, old.generate_from_hash(node_id))).collect::<HashMap<_, _>>();
+		let region_map = self.region_domain.ids().iter().map(|&old| (old, old.generate_from_hash(node_id))).collect::<HashMap<_, _>>();
 
 		let id_map = IdMap {
 			point_offset: self.point_domain.ids().len(),