Merge branch 'master' into 2558-free-floating-anchors-overlays

Author: seam0s-dev

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

@@ -1214,11 +1214,6 @@ impl<'a> MessageHandler<NodeGraphMessage, NodeGraphHandlerData<'a>> for NodeGrap
 									if is_stack_wire(&wire) { stack_wires.push(wire) } else { node_wires.push(wire) }
 								}
 
-								// Auto convert node to layer when inserting on a single stack wire
-								if stack_wires.len() == 1 && node_wires.is_empty() {
-									network_interface.set_to_node_or_layer(&selected_node_id, selection_network_path, true)
-								}
-
 								let overlapping_wire = if network_interface.is_layer(&selected_node_id, selection_network_path) {
 									if stack_wires.len() == 1 {
 										stack_wires.first()

editor/src/messages/portfolio/portfolio_message_handler.rs

@@ -1003,6 +1003,7 @@ impl MessageHandler<PortfolioMessage, PortfolioMessageData<'_>> for PortfolioMes
 			}
 			PortfolioMessage::PasteSerializedData { data } => {
 				if let Some(document) = self.active_document() {
+					let mut all_new_ids = Vec::new();
 					if let Ok(data) = serde_json::from_str::<Vec<CopyBufferEntry>>(&data) {
 						let parent = document.new_layer_parent(false);
 						let mut layers = Vec::new();
@@ -1019,12 +1020,15 @@ impl MessageHandler<PortfolioMessage, PortfolioMessageData<'_>> for PortfolioMes
 							document.load_layer_resources(responses);
 							let new_ids: HashMap<_, _> = entry.nodes.iter().map(|(id, _)| (*id, NodeId::new())).collect();
 							let layer = LayerNodeIdentifier::new_unchecked(new_ids[&NodeId(0)]);
+							all_new_ids.extend(new_ids.values().cloned());
+
 							responses.add(NodeGraphMessage::AddNodes { nodes: entry.nodes, new_ids });
 							responses.add(NodeGraphMessage::MoveLayerToStack { layer, parent, insert_index: 0 });
 							layers.push(layer);
 						}
 
 						responses.add(NodeGraphMessage::RunDocumentGraph);
+						responses.add(NodeGraphMessage::SelectedNodesSet { nodes: all_new_ids });
 						responses.add(Message::StartBuffer);
 						responses.add(PortfolioMessage::CenterPastedLayers { layers });
 					}

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

@@ -6,7 +6,7 @@ use crate::consts::{
 };
 use crate::messages::portfolio::document::overlays::utility_functions::{path_overlays, selected_segments};
 use crate::messages::portfolio::document::overlays::utility_types::{DrawHandles, OverlayContext};
-use crate::messages::portfolio::document::utility_types::document_metadata::LayerNodeIdentifier;
+use crate::messages::portfolio::document::utility_types::document_metadata::{DocumentMetadata, LayerNodeIdentifier};
 use crate::messages::portfolio::document::utility_types::network_interface::NodeNetworkInterface;
 use crate::messages::portfolio::document::utility_types::transformation::Axis;
 use crate::messages::preferences::SelectionMode;
@@ -392,13 +392,13 @@ impl PathToolData {
 		self.saved_points_before_anchor_select_toggle.clear();
 	}
 
-	pub fn selection_quad(&self) -> Quad {
-		let bbox = self.selection_box();
+	pub fn selection_quad(&self, metadata: &DocumentMetadata) -> Quad {
+		let bbox = self.selection_box(metadata);
 		Quad::from_box(bbox)
 	}
 
-	pub fn calculate_selection_mode_from_direction(&mut self) -> SelectionMode {
-		let bbox = self.selection_box();
+	pub fn calculate_selection_mode_from_direction(&mut self, metadata: &DocumentMetadata) -> SelectionMode {
+		let bbox = self.selection_box(metadata);
 		let above_threshold = bbox[1].distance_squared(bbox[0]) > DRAG_DIRECTION_MODE_DETERMINATION_THRESHOLD.powi(2);
 
 		if self.selection_mode.is_none() && above_threshold {
@@ -414,12 +414,15 @@ impl PathToolData {
 		self.selection_mode.unwrap_or(SelectionMode::Touched)
 	}
 
-	pub fn selection_box(&self) -> [DVec2; 2] {
-		if self.previous_mouse_position == self.drag_start_pos {
+	pub fn selection_box(&self, metadata: &DocumentMetadata) -> [DVec2; 2] {
+		// Convert previous mouse position to viewport space first
+		let document_to_viewport = metadata.document_to_viewport;
+		let previous_mouse = document_to_viewport.transform_point2(self.previous_mouse_position);
+		if previous_mouse == self.drag_start_pos {
 			let tolerance = DVec2::splat(SELECTION_TOLERANCE);
 			[self.drag_start_pos - tolerance, self.drag_start_pos + tolerance]
 		} else {
-			[self.drag_start_pos, self.previous_mouse_position]
+			[self.drag_start_pos, previous_mouse]
 		}
 	}
 
@@ -464,6 +467,7 @@ impl PathToolData {
 
 		// Check if the point is already selected; if not, select the first point within the threshold (in pixels)
 		if let Some((already_selected, mut selection_info)) = shape_editor.get_point_selection_state(&document.network_interface, input.mouse.position, SELECTION_THRESHOLD) {
+			log::info!("entered the part where tool identifies a near point");
 			responses.add(DocumentMessage::StartTransaction);
 
 			self.last_clicked_point_was_selected = already_selected;
@@ -1129,11 +1133,11 @@ impl Fsm for PathToolFsmState {
 						let fill_color = Some(fill_color.as_str());
 
 						let selection_mode = match tool_action_data.preferences.get_selection_mode() {
-							SelectionMode::Directional => tool_data.calculate_selection_mode_from_direction(),
+							SelectionMode::Directional => tool_data.calculate_selection_mode_from_direction(document.metadata()),
 							selection_mode => selection_mode,
 						};
 
-						let quad = tool_data.selection_quad();
+						let quad = tool_data.selection_quad(document.metadata());
 						let polygon = &tool_data.lasso_polygon;
 
 						match (selection_shape, selection_mode) {
@@ -1207,7 +1211,7 @@ impl Fsm for PathToolFsmState {
 					delete_segment,
 				},
 			) => {
-				tool_data.previous_mouse_position = input.mouse.position;
+				tool_data.previous_mouse_position = document.metadata().document_to_viewport.inverse().transform_point2(input.mouse.position);
 
 				if selection_shape == SelectionShapeType::Lasso {
 					extend_lasso(&mut tool_data.lasso_polygon, input.mouse.position);
@@ -1435,12 +1439,14 @@ impl Fsm for PathToolFsmState {
 					SelectionChange::Clear
 				};
 
-				if tool_data.drag_start_pos == tool_data.previous_mouse_position {
+				let document_to_viewport = document.metadata().document_to_viewport;
+				let previous_mouse = document_to_viewport.transform_point2(tool_data.previous_mouse_position);
+				if tool_data.drag_start_pos == previous_mouse {
 					responses.add(NodeGraphMessage::SelectedNodesSet { nodes: vec![] });
 				} else {
 					match selection_shape {
 						SelectionShapeType::Box => {
-							let bbox = [tool_data.drag_start_pos, tool_data.previous_mouse_position];
+							let bbox = [tool_data.drag_start_pos, previous_mouse];
 							shape_editor.select_all_in_shape(&document.network_interface, SelectionShape::Box(bbox), selection_change);
 						}
 						SelectionShapeType::Lasso => shape_editor.select_all_in_shape(&document.network_interface, SelectionShape::Lasso(&tool_data.lasso_polygon), selection_change),
@@ -1481,12 +1487,14 @@ impl Fsm for PathToolFsmState {
 					SelectionChange::Clear
 				};
 
-				if tool_data.drag_start_pos == tool_data.previous_mouse_position {
+				let document_to_viewport = document.metadata().document_to_viewport;
+				let previous_mouse = document_to_viewport.transform_point2(tool_data.previous_mouse_position);
+				if tool_data.drag_start_pos == previous_mouse {
 					responses.add(NodeGraphMessage::SelectedNodesSet { nodes: vec![] });
 				} else {
 					match selection_shape {
 						SelectionShapeType::Box => {
-							let bbox = [tool_data.drag_start_pos, tool_data.previous_mouse_position];
+							let bbox = [tool_data.drag_start_pos, previous_mouse];
 							shape_editor.select_all_in_shape(&document.network_interface, SelectionShape::Box(bbox), select_kind);
 						}
 						SelectionShapeType::Lasso => shape_editor.select_all_in_shape(&document.network_interface, SelectionShape::Lasso(&tool_data.lasso_polygon), select_kind),

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

@@ -2,7 +2,7 @@ mod attributes;
 mod indexed;
 mod modification;
 
-use super::misc::point_to_dvec2;
+use super::misc::{dvec2_to_point, point_to_dvec2};
 use super::style::{PathStyle, Stroke};
 use crate::instances::Instances;
 use crate::renderer::{ClickTargetType, FreePoint};
@@ -13,6 +13,7 @@ use core::borrow::Borrow;
 use dyn_any::DynAny;
 use glam::{DAffine2, DVec2};
 pub use indexed::VectorDataIndex;
+use kurbo::{Affine, Shape};
 pub use modification::*;
 use std::collections::HashMap;
 
@@ -216,6 +217,23 @@ impl VectorData {
 			}
 		}
 		vector_data
+  }
+
+	pub fn close_subpaths(&mut self) {
+		let segments_to_add: Vec<_> = self
+			.stroke_bezier_paths()
+			.filter(|subpath| !subpath.closed)
+			.filter_map(|subpath| {
+				let (first, last) = subpath.manipulator_groups().first().zip(subpath.manipulator_groups().last())?;
+				let (start, end) = self.point_domain.resolve_id(first.id).zip(self.point_domain.resolve_id(last.id))?;
+				Some((start, end))
+			})
+			.collect();
+
+		for (start, end) in segments_to_add {
+			let segment_id = self.segment_domain.next_id().next_id();
+			self.segment_domain.push(segment_id, start, end, bezier_rs::BezierHandles::Linear, StrokeId::ZERO);
+		}
 	}
 
 	/// Compute the bounding boxes of the subpaths without any transform
@@ -341,6 +359,34 @@ impl VectorData {
 		self.point_domain.resolve_id(point).map_or(0, |point| self.segment_domain.connected_count(point))
 	}
 
+	pub fn check_point_inside_shape(&self, vector_data_transform: DAffine2, point: DVec2) -> bool {
+		let bez_paths: Vec<_> = self
+			.stroke_bezpath_iter()
+			.map(|mut bezpath| {
+				// TODO: apply transform to points instead of modifying the paths
+				bezpath.apply_affine(Affine::new(vector_data_transform.to_cols_array()));
+				bezpath.close_path();
+				let bbox = bezpath.bounding_box();
+				(bezpath, bbox)
+			})
+			.collect();
+
+		// Check against all paths the point is contained in to compute the correct winding number
+		let mut number = 0;
+
+		for (shape, bbox) in bez_paths {
+			if bbox.x0 > point.x || bbox.y0 > point.y || bbox.x1 < point.x || bbox.y1 < point.y {
+				continue;
+			}
+
+			let winding = shape.winding(dvec2_to_point(point));
+			number += winding;
+		}
+
+		// Non-zero fill rule
+		number != 0
+	}
+
 	/// Points that can be extended from.
 	///
 	/// This is usually only points with exactly one connection unless vector meshes are enabled.

node-graph/gcore/src/vector/vector_nodes.rs

@@ -1715,6 +1715,23 @@ fn bevel(_: impl Ctx, source: VectorDataTable, #[default(10.)] distance: Length)
 	result
 }
 
+#[node_macro::node(category("Vector"), path(graphene_core::vector))]
+fn close_path(_: impl Ctx, source: VectorDataTable) -> VectorDataTable {
+	let mut new_table = VectorDataTable::empty();
+
+	for mut source_instance in source.instance_iter() {
+		source_instance.instance.close_subpaths();
+		new_table.push(source_instance);
+	}
+
+	new_table
+}
+
+#[node_macro::node(category("Vector"), path(graphene_core::vector))]
+fn point_inside(_: impl Ctx, source: VectorDataTable, point: DVec2) -> bool {
+	source.instance_iter().any(|instance| instance.instance.check_point_inside_shape(instance.transform, point))
+}
+
 #[node_macro::node(name("Merge by Distance"), category("Vector"), path(graphene_core::vector))]
 fn merge_by_distance(_: impl Ctx, source: VectorDataTable, #[default(10.)] distance: Length) -> VectorDataTable {
 	let source_transform = source.transform();