Improve transforms

Author: 0HyperCube

editor/src/messages/portfolio/document/graph_operation/utility_types.rs

@@ -244,38 +244,38 @@ impl<'a> ModifyInputsContext<'a> {
 		// Start from the layer node or export
 		let output_layer = self.get_output_layer()?;
 
-		let upstream = self
-			.network_interface
-			.upstream_flow_back_from_nodes(vec![output_layer.to_node()], &[], network_interface::FlowType::HorizontalFlow);
+		let existing_node_id = Self::locate_existing_id(output_layer, self.network_interface, reference);
 
-		// Take until another layer node is found (but not the first layer node)
-		let mut existing_node_id = None;
-		for upstream_node in upstream.collect::<Vec<_>>() {
+		// Create a new node if the node does not exist and update its inputs
+		if create_if_nonexistent {
+			return existing_node_id.or_else(|| self.create_node(reference));
+		}
+
+		existing_node_id
+	}
+
+	/// Gets the node id of a node with a specific reference that is upstream from the layer node.
+	pub fn locate_existing_id(output_layer: LayerNodeIdentifier, network_interface: &NodeNetworkInterface, reference: &str) -> Option<NodeId> {
+		let upstream = network_interface.upstream_flow_back_from_nodes(vec![output_layer.to_node()], &[], network_interface::FlowType::HorizontalFlow);
+
+		// Look at all of the upstream nodes
+		for upstream_node in upstream {
 			// Check if this is the node we have been searching for.
-			if self
-				.network_interface
+			if network_interface
 				.reference(&upstream_node, &[])
 				.is_some_and(|node_reference| *node_reference == Some(reference.to_string()))
 			{
-				existing_node_id = Some(upstream_node);
-				break;
+				return Some(upstream_node);
 			}
 
-			let is_traversal_start = |node_id: NodeId| {
-				self.layer_node.map(|layer| layer.to_node()) == Some(node_id) || self.network_interface.document_network().exports.iter().any(|export| export.as_node() == Some(node_id))
-			};
+			let is_traversal_start = |node_id: NodeId| output_layer.to_node() == node_id || network_interface.document_network().exports.iter().any(|export| export.as_node() == Some(node_id));
 
-			if !is_traversal_start(upstream_node) && (self.network_interface.is_layer(&upstream_node, &[])) {
-				break;
+			// Take until another layer node is found (but not the first layer node)
+			if !is_traversal_start(upstream_node) && (network_interface.is_layer(&upstream_node, &[])) {
+				return None;
 			}
 		}
-
-		// Create a new node if the node does not exist and update its inputs
-		if create_if_nonexistent {
-			return existing_node_id.or_else(|| self.create_node(reference));
-		}
-
-		existing_node_id
+		None
 	}
 
 	/// Create a new node inside the layer

editor/src/messages/portfolio/document/utility_types/transformation.rs

@@ -1,6 +1,7 @@
 use super::network_interface::NodeNetworkInterface;
 use crate::consts::{ROTATE_INCREMENT, SCALE_INCREMENT};
-use crate::messages::portfolio::document::graph_operation::utility_types::TransformIn;
+use crate::messages::portfolio::document::graph_operation::transform_utils;
+use crate::messages::portfolio::document::graph_operation::utility_types::{ModifyInputsContext, TransformIn};
 use crate::messages::portfolio::document::utility_types::document_metadata::{DocumentMetadata, LayerNodeIdentifier};
 use crate::messages::prelude::*;
 use crate::messages::tool::common_functionality::graph_modification_utils;
@@ -54,17 +55,24 @@ impl OriginalTransforms {
 		}
 	}
 
-	pub fn update<'a>(&mut self, selected: &'a [LayerNodeIdentifier], network_interface: &NodeNetworkInterface, shape_editor: Option<&'a ShapeState>) {
-		let document_metadata = network_interface.document_metadata();
+	/// Gets the transform from the most downstream transform node
+	fn get_layer_transform(layer: LayerNodeIdentifier, network_interface: &NodeNetworkInterface) -> Option<DAffine2> {
+		let transform_node_id = ModifyInputsContext::locate_existing_id(layer, network_interface, "Transform")?;
+
+		let document_node = network_interface.document_network().nodes.get(&transform_node_id)?;
+		Some(transform_utils::get_current_transform(&document_node.inputs))
+	}
 
+	pub fn update<'a>(&mut self, selected: &'a [LayerNodeIdentifier], network_interface: &NodeNetworkInterface, shape_editor: Option<&'a ShapeState>) {
 		match self {
 			OriginalTransforms::Layer(layer_map) => {
 				layer_map.retain(|layer, _| selected.contains(layer));
 				for &layer in selected {
 					if layer == LayerNodeIdentifier::ROOT_PARENT {
 						continue;
 					}
-					layer_map.entry(layer).or_insert_with(|| document_metadata.upstream_transform(layer.to_node()));
+
+					layer_map.entry(layer).or_insert_with(|| Self::get_layer_transform(layer, network_interface).unwrap_or_default());
 				}
 			}
 			OriginalTransforms::Path(path_map) => {