Do not transform layers when transforming a parent folder (#481)

* Modify all message enum data to use named struct values, not tuples (#479)

* Massively reorganize and clean up the whole Rust codebase

* Modify all message enum data to use named struct values, not tuples

* Do not transform layers when transforming parent

* Reduce complexity to O(nlogn)

* Add TODO comment about performance

Co-authored-by: Keavon Chambers <[email protected]>
Co-authored-by: Dennis <[email protected]>

Author: 3 people

editor/src/document/document_message_handler.rs

@@ -181,7 +181,7 @@ impl DocumentMessageHandler {
 	}
 
 	pub fn selected_layers_without_children(&self) -> Vec<&[LayerId]> {
-		let unique_layers = self.graphene_document.shallowest_unique_layers(self.selected_layers());
+		let unique_layers = GrapheneDocument::shallowest_unique_layers(self.selected_layers());
 
 		// We need to maintain layer ordering
 		self.sort_layers(unique_layers.iter().copied())

editor/src/document/transformation.rs

@@ -241,7 +241,8 @@ impl<'a> Selected<'a> {
 			let pivot = DAffine2::from_translation(*self.pivot);
 			let transformation = pivot * delta * pivot.inverse();
 
-			for layer_path in &self.selected {
+			// TODO: Cache the result of `shallowest_unique_layers` to avoid this heavy computation every frame of movement, see https://github.com/GraphiteEditor/Graphite/pull/481
+			for layer_path in Document::shallowest_unique_layers(self.selected.iter().map(|path| path.as_slice())) {
 				let parent_folder_path = &layer_path[..layer_path.len() - 1];
 				let original_layer_transforms = *self.original_transforms.get(layer_path).unwrap();
 

editor/src/viewport_tools/tools/select.rs

@@ -10,6 +10,7 @@ use crate::misc::{HintData, HintGroup, HintInfo, KeysGroup};
 use crate::viewport_tools::snapping::SnapHandler;
 use crate::viewport_tools::tool::{DocumentToolData, Fsm, ToolActionHandlerData};
 
+use graphene::document::Document;
 use graphene::intersection::Quad;
 use graphene::layers::style::{self, Fill, Stroke};
 use graphene::Operation;
@@ -225,10 +226,11 @@ impl Fsm for SelectToolFsmState {
 					let mouse_delta = mouse_position - data.drag_current;
 
 					let closest_move = data.snap_handler.snap_layers(document, &data.layers_dragging, mouse_delta);
-					for path in data.layers_dragging.iter() {
+					// TODO: Cache the result of `shallowest_unique_layers` to avoid this heavy computation every frame of movement, see https://github.com/GraphiteEditor/Graphite/pull/481
+					for path in Document::shallowest_unique_layers(data.layers_dragging.iter().map(|path| path.as_slice())) {
 						responses.push_front(
 							Operation::TransformLayerInViewport {
-								path: path.clone(),
+								path: path.to_vec(),
 								transform: DAffine2::from_translation(mouse_delta + closest_move).to_cols_array(),
 							}
 							.into(),

graphene/src/document.rs

@@ -114,11 +114,11 @@ impl Document {
 
 	// Return returns all folders that are not contained in any other of the given folders
 	pub fn shallowest_folders<'a>(&'a self, layers: impl Iterator<Item = &'a [LayerId]>) -> Vec<&[LayerId]> {
-		self.shallowest_unique_layers(self.folders(layers))
+		Self::shallowest_unique_layers(self.folders(layers))
 	}
 
 	// Return returns all layers that are not contained in any other of the given folders
-	pub fn shallowest_unique_layers<'a>(&'a self, layers: impl Iterator<Item = &'a [LayerId]>) -> Vec<&[LayerId]> {
+	pub fn shallowest_unique_layers<'a>(layers: impl Iterator<Item = &'a [LayerId]>) -> Vec<&'a [LayerId]> {
 		let mut sorted_layers: Vec<_> = layers.collect();
 		sorted_layers.sort();
 		// Sorting here creates groups of similar UUID paths