Merge branch 'master' into spacing-type-radio-button

Author: Ripper53

demo-artwork/parametric-dunescape.graphite

@@ -218,7 +218,7 @@ pub fn input_mappings() -> Mapping {
 		entry!(KeyDown(KeyG); action_dispatch=PathToolMessage::GRS { key: KeyG }),
 		entry!(KeyDown(KeyR); action_dispatch=PathToolMessage::GRS { key: KeyR }),
 		entry!(KeyDown(KeyS); action_dispatch=PathToolMessage::GRS { key: KeyS }),
-		entry!(PointerMove; refresh_keys=[KeyC, Space, Control, Shift, Alt], action_dispatch=PathToolMessage::PointerMove { toggle_colinear: KeyC, equidistant: Alt, move_anchor_with_handles: Space, snap_angle: Shift, lock_angle: Control, delete_segment: Alt }),
+		entry!(PointerMove; refresh_keys=[KeyC, Space, Control, Shift, Alt], action_dispatch=PathToolMessage::PointerMove { toggle_colinear: KeyC, equidistant: Alt, move_anchor_with_handles: Space, snap_angle: Shift, lock_angle: Control, delete_segment: Alt, break_colinear_molding: Alt }),
 		entry!(KeyDown(Delete); action_dispatch=PathToolMessage::Delete),
 		entry!(KeyDown(KeyA); modifiers=[Accel], action_dispatch=PathToolMessage::SelectAllAnchors),
 		entry!(KeyDown(KeyA); modifiers=[Accel, Shift], action_dispatch=PathToolMessage::DeselectAllPoints),

editor/src/messages/input_mapper/input_mappings.rs

@@ -951,7 +951,7 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 			properties: None,
 		},
 		DocumentNodeDefinition {
-			identifier: "Split Vector2",
+			identifier: "Split Coordinate",
 			category: "Math: Vector",
 			node_template: NodeTemplate {
 				document_node: DocumentNode {
@@ -982,7 +982,7 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 					..Default::default()
 				},
 				persistent_node_metadata: DocumentNodePersistentMetadata {
-					input_properties: vec![("Vector2", "TODO").into()],
+					input_properties: vec![("Coordinate", "TODO").into()],
 					output_names: vec!["X".to_string(), "Y".to_string()],
 					has_primary_output: false,
 					network_metadata: Some(NodeNetworkMetadata {
@@ -2913,7 +2913,7 @@ fn static_input_properties() -> InputProperties {
 				.input_metadata(&node_id, index, "min", context.selection_network_path)
 				.and_then(|value| value.as_f64());
 
-			Ok(vec![node_properties::vector2_widget(
+			Ok(vec![node_properties::coordinate_widget(
 				ParameterWidgetsInfo::new(document_node, node_id, index, input_name, input_description, true),
 				x,
 				y,
@@ -3190,7 +3190,7 @@ fn static_input_properties() -> InputProperties {
 		Box::new(|node_id, index, context| {
 			let (document_node, input_name, input_description) = node_properties::query_node_and_input_info(node_id, index, context)?;
 			Ok(vec![LayoutGroup::Row {
-				widgets: node_properties::array_of_vector2_widget(
+				widgets: node_properties::array_of_coordinates_widget(
 					ParameterWidgetsInfo::new(document_node, node_id, index, input_name, input_description, true),
 					TextInput::default().centered(true),
 				),

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

@@ -154,6 +154,15 @@ pub(crate) fn property_from_type(
 		number_max = Some(range_end);
 		number_input = number_input.mode_range().min(range_start).max(range_end);
 	}
+	if let Some(unit) = unit {
+		number_input = number_input.unit(unit);
+	}
+	if let Some(display_decimal_places) = display_decimal_places {
+		number_input = number_input.display_decimal_places(display_decimal_places);
+	}
+	if let Some(step) = step {
+		number_input = number_input.step(step);
+	}
 
 	let min = |x: f64| number_min.unwrap_or(x);
 	let max = |x: f64| number_max.unwrap_or(x);
@@ -167,15 +176,15 @@ pub(crate) fn property_from_type(
 				// Aliased types (ambiguous values)
 				Some("Percentage") => number_widget(default_info, number_input.percentage().min(min(0.)).max(max(100.))).into(),
 				Some("SignedPercentage") => number_widget(default_info, number_input.percentage().min(min(-100.)).max(max(100.))).into(),
-				Some("Angle") => number_widget(default_info, number_input.mode_range().min(min(-180.)).max(max(180.)).unit("°")).into(),
-				Some("Multiplier") => number_widget(default_info, number_input.unit("x")).into(),
-				Some("PixelLength") => number_widget(default_info, number_input.min(min(0.)).unit(" px")).into(),
+				Some("Angle") => number_widget(default_info, number_input.mode_range().min(min(-180.)).max(max(180.)).unit(unit.unwrap_or("°"))).into(),
+				Some("Multiplier") => number_widget(default_info, number_input.unit(unit.unwrap_or("x"))).into(),
+				Some("PixelLength") => number_widget(default_info, number_input.min(min(0.)).unit(unit.unwrap_or(" px"))).into(),
 				Some("Length") => number_widget(default_info, number_input.min(min(0.))).into(),
 				Some("Fraction") => number_widget(default_info, number_input.mode_range().min(min(0.)).max(max(1.))).into(),
 				Some("IntegerCount") => number_widget(default_info, number_input.int().min(min(1.))).into(),
 				Some("SeedValue") => number_widget(default_info, number_input.int().min(min(0.))).into(),
-				Some("Resolution") => vector2_widget(default_info, "W", "H", " px", Some(64.)),
-				Some("PixelSize") => vector2_widget(default_info, "X", "Y", " px", None),
+				Some("Resolution") => coordinate_widget(default_info, "W", "H", unit.unwrap_or(" px"), Some(64.)),
+				Some("PixelSize") => coordinate_widget(default_info, "X", "Y", unit.unwrap_or(" px"), None),
 
 				// For all other types, use TypeId-based matching
 				_ => {
@@ -189,14 +198,14 @@ pub(crate) fn property_from_type(
 						Some(x) if x == TypeId::of::<u64>() => number_widget(default_info, number_input.int().min(min(0.))).into(),
 						Some(x) if x == TypeId::of::<bool>() => bool_widget(default_info, CheckboxInput::default()).into(),
 						Some(x) if x == TypeId::of::<String>() => text_widget(default_info).into(),
-						Some(x) if x == TypeId::of::<DVec2>() => vector2_widget(default_info, "X", "Y", "", None),
-						Some(x) if x == TypeId::of::<UVec2>() => vector2_widget(default_info, "X", "Y", "", Some(0.)),
-						Some(x) if x == TypeId::of::<IVec2>() => vector2_widget(default_info, "X", "Y", "", None),
+						Some(x) if x == TypeId::of::<DVec2>() => coordinate_widget(default_info, "X", "Y", "", None),
+						Some(x) if x == TypeId::of::<UVec2>() => coordinate_widget(default_info, "X", "Y", "", Some(0.)),
+						Some(x) if x == TypeId::of::<IVec2>() => coordinate_widget(default_info, "X", "Y", "", None),
 						// ==========================
 						// PRIMITIVE COLLECTION TYPES
 						// ==========================
 						Some(x) if x == TypeId::of::<Vec<f64>>() => array_of_number_widget(default_info, TextInput::default()).into(),
-						Some(x) if x == TypeId::of::<Vec<DVec2>>() => array_of_vector2_widget(default_info, TextInput::default()).into(),
+						Some(x) if x == TypeId::of::<Vec<DVec2>>() => array_of_coordinates_widget(default_info, TextInput::default()).into(),
 						// ====================
 						// GRAPHICAL DATA TYPES
 						// ====================
@@ -512,7 +521,7 @@ pub fn footprint_widget(parameter_widgets_info: ParameterWidgetsInfo, extra_widg
 	last.clone()
 }
 
-pub fn vector2_widget(parameter_widgets_info: ParameterWidgetsInfo, x: &str, y: &str, unit: &str, min: Option<f64>) -> LayoutGroup {
+pub fn coordinate_widget(parameter_widgets_info: ParameterWidgetsInfo, x: &str, y: &str, unit: &str, min: Option<f64>) -> LayoutGroup {
 	let ParameterWidgetsInfo { document_node, node_id, index, .. } = parameter_widgets_info;
 
 	let mut widgets = start_widgets(parameter_widgets_info, FrontendGraphDataType::Number);
@@ -655,7 +664,7 @@ pub fn array_of_number_widget(parameter_widgets_info: ParameterWidgetsInfo, text
 	widgets
 }
 
-pub fn array_of_vector2_widget(parameter_widgets_info: ParameterWidgetsInfo, text_props: TextInput) -> Vec<WidgetHolder> {
+pub fn array_of_coordinates_widget(parameter_widgets_info: ParameterWidgetsInfo, text_props: TextInput) -> Vec<WidgetHolder> {
 	let ParameterWidgetsInfo { document_node, node_id, index, .. } = parameter_widgets_info;
 
 	let mut widgets = start_widgets(parameter_widgets_info, FrontendGraphDataType::Number);
@@ -1195,7 +1204,7 @@ pub(crate) fn grid_properties(node_id: NodeId, context: &mut NodePropertiesConte
 	if let Some(&TaggedValue::GridType(grid_type)) = grid_type_input.as_non_exposed_value() {
 		match grid_type {
 			GridType::Rectangular => {
-				let spacing = vector2_widget(ParameterWidgetsInfo::from_index(document_node, node_id, spacing_index, true, context), "W", "H", " px", Some(0.));
+				let spacing = coordinate_widget(ParameterWidgetsInfo::from_index(document_node, node_id, spacing_index, true, context), "W", "H", " px", Some(0.));
 				widgets.push(spacing);
 			}
 			GridType::Isometric => {
@@ -1205,7 +1214,7 @@ pub(crate) fn grid_properties(node_id: NodeId, context: &mut NodePropertiesConte
 						NumberInput::default().label("H").min(0.).unit(" px"),
 					),
 				};
-				let angles = vector2_widget(ParameterWidgetsInfo::from_index(document_node, node_id, angles_index, true, context), "", "", "°", None);
+				let angles = coordinate_widget(ParameterWidgetsInfo::from_index(document_node, node_id, angles_index, true, context), "", "", "°", None);
 				widgets.extend([spacing, angles]);
 			}
 		}
@@ -1424,6 +1433,9 @@ pub(crate) fn generate_node_properties(node_id: NodeId, context: &mut NodeProper
 							unit_suffix = field.unit;
 							step = field.number_step;
 							number_options = (field.number_min, field.number_max, field.number_mode_range);
+							display_decimal_places = field.number_display_decimal_places;
+							unit_suffix = field.unit;
+							step = field.number_step;
 							if let Some(ref default) = field.default_type {
 								break 'early_return default.clone();
 							}

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

@@ -467,15 +467,16 @@ impl MessageHandler<PortfolioMessage, PortfolioMessageData<'_>> for PortfolioMes
 					}
 				};
 
-				const REPLACEMENTS: [(&str, &str); 37] = [
+				const REPLACEMENTS: [(&str, &str); 40] = [
 					("graphene_core::AddArtboardNode", "graphene_core::graphic_element::AppendArtboardNode"),
 					("graphene_core::ConstructArtboardNode", "graphene_core::graphic_element::ToArtboardNode"),
 					("graphene_core::ToGraphicElementNode", "graphene_core::graphic_element::ToElementNode"),
 					("graphene_core::ToGraphicGroupNode", "graphene_core::graphic_element::ToGroupNode"),
 					("graphene_core::logic::LogicAndNode", "graphene_core::ops::LogicAndNode"),
 					("graphene_core::logic::LogicNotNode", "graphene_core::ops::LogicNotNode"),
 					("graphene_core::logic::LogicOrNode", "graphene_core::ops::LogicOrNode"),
-					("graphene_core::ops::ConstructVector2", "graphene_core::ops::Vector2ValueNode"),
+					("graphene_core::ops::ConstructVector2", "graphene_core::ops::CoordinateValueNode"),
+					("graphene_core::ops::Vector2ValueNode", "graphene_core::ops::CoordinateValueNode"),
 					("graphene_core::raster::BlackAndWhiteNode", "graphene_core::raster::adjustments::BlackAndWhiteNode"),
 					("graphene_core::raster::BlendNode", "graphene_core::raster::adjustments::BlendNode"),
 					("graphene_core::raster::ChannelMixerNode", "graphene_core::raster::adjustments::ChannelMixerNode"),
@@ -484,6 +485,8 @@ impl MessageHandler<PortfolioMessage, PortfolioMessageData<'_>> for PortfolioMes
 					("graphene_core::raster::ExtractChannelNode", "graphene_core::raster::adjustments::ExtractChannelNode"),
 					("graphene_core::raster::GradientMapNode", "graphene_core::raster::adjustments::GradientMapNode"),
 					("graphene_core::raster::HueSaturationNode", "graphene_core::raster::adjustments::HueSaturationNode"),
+					("graphene_core::vector::GenerateHandlesNode", "graphene_core::vector::AutoTangentsNode"),
+					("graphene_core::vector::RemoveHandlesNode", "graphene_core::vector::AutoTangentsNode"),
 					("graphene_core::raster::InvertNode", "graphene_core::raster::adjustments::InvertNode"),
 					("graphene_core::raster::InvertRGBNode", "graphene_core::raster::adjustments::InvertNode"),
 					("graphene_core::raster::LevelsNode", "graphene_core::raster::adjustments::LevelsNode"),
@@ -963,6 +966,48 @@ impl MessageHandler<PortfolioMessage, PortfolioMessageData<'_>> for PortfolioMes
 
 						document.network_interface.replace_reference_name(node_id, network_path, "Flatten Path".to_string());
 					}
+
+					if reference == "Remove Handles" {
+						let node_definition = resolve_document_node_type("Auto-Tangents").unwrap();
+						let new_node_template = node_definition.default_node_template();
+						let document_node = new_node_template.document_node;
+						document.network_interface.replace_implementation(node_id, network_path, document_node.implementation.clone());
+						document
+							.network_interface
+							.replace_implementation_metadata(node_id, network_path, new_node_template.persistent_node_metadata);
+
+						let old_inputs = document.network_interface.replace_inputs(node_id, document_node.inputs.clone(), network_path);
+
+						document.network_interface.set_input(&InputConnector::node(*node_id, 0), old_inputs[0].clone(), network_path);
+						document
+							.network_interface
+							.set_input(&InputConnector::node(*node_id, 1), NodeInput::value(TaggedValue::F64(0.), false), network_path);
+						document
+							.network_interface
+							.set_input(&InputConnector::node(*node_id, 2), NodeInput::value(TaggedValue::Bool(false), false), network_path);
+
+						document.network_interface.replace_reference_name(node_id, network_path, "Auto-Tangents".to_string());
+					}
+
+					if reference == "Generate Handles" {
+						let node_definition = resolve_document_node_type("Auto-Tangents").unwrap();
+						let new_node_template = node_definition.default_node_template();
+						let document_node = new_node_template.document_node;
+						document.network_interface.replace_implementation(node_id, network_path, document_node.implementation.clone());
+						document
+							.network_interface
+							.replace_implementation_metadata(node_id, network_path, new_node_template.persistent_node_metadata);
+
+						let old_inputs = document.network_interface.replace_inputs(node_id, document_node.inputs.clone(), network_path);
+
+						document.network_interface.set_input(&InputConnector::node(*node_id, 0), old_inputs[0].clone(), network_path);
+						document.network_interface.set_input(&InputConnector::node(*node_id, 1), old_inputs[1].clone(), network_path);
+						document
+							.network_interface
+							.set_input(&InputConnector::node(*node_id, 2), NodeInput::value(TaggedValue::Bool(true), false), network_path);
+
+						document.network_interface.replace_reference_name(node_id, network_path, "Auto-Tangents".to_string());
+					}
 				}
 
 				// TODO: Eventually remove this document upgrade code

editor/src/messages/portfolio/portfolio_message_handler.rs

@@ -57,8 +57,10 @@ pub fn merge_layers(document: &DocumentMessageHandler, first_layer: LayerNodeIde
 	}
 
 	// Move the `second_layer` below the `first_layer` for positioning purposes
-	let first_layer_parent = first_layer.parent(document.metadata()).unwrap();
-	let first_layer_index = first_layer_parent.children(document.metadata()).position(|child| child == first_layer).unwrap();
+	let Some(first_layer_parent) = first_layer.parent(document.metadata()) else { return };
+	let Some(first_layer_index) = first_layer_parent.children(document.metadata()).position(|child| child == first_layer) else {
+		return;
+	};
 	responses.add(NodeGraphMessage::MoveLayerToStack {
 		layer: second_layer,
 		parent: first_layer_parent,

editor/src/messages/tool/common_functionality/graph_modification_utils.rs

@@ -1,6 +1,6 @@
 use super::graph_modification_utils::merge_layers;
 use super::snapping::{SnapCache, SnapCandidatePoint, SnapData, SnapManager, SnappedPoint};
-use super::utility_functions::calculate_segment_angle;
+use super::utility_functions::{adjust_handle_colinearity, calculate_segment_angle, restore_g1_continuity, restore_previous_handle_position};
 use crate::consts::HANDLE_LENGTH_FACTOR;
 use crate::messages::portfolio::document::overlays::utility_functions::selected_segments;
 use crate::messages::portfolio::document::utility_types::document_metadata::{DocumentMetadata, LayerNodeIdentifier};
@@ -107,11 +107,7 @@ impl SelectedLayerState {
 	}
 
 	pub fn selected_points_count(&self) -> usize {
-		let count = self.selected_points.iter().fold(0, |acc, point| {
-			let is_ignored = (point.as_handle().is_some() && self.ignore_handles) || (point.as_anchor().is_some() && self.ignore_anchors);
-			acc + if is_ignored { 0 } else { 1 }
-		});
-		count
+		self.selected_points.len()
 	}
 }
 
@@ -163,6 +159,10 @@ impl ClosestSegment {
 		self.points
 	}
 
+	pub fn closest_point_document(&self) -> DVec2 {
+		self.bezier.evaluate(TValue::Parametric(self.t))
+	}
+
 	pub fn closest_point_to_viewport(&self) -> DVec2 {
 		self.bezier_point_to_viewport
 	}
@@ -208,7 +208,7 @@ impl ClosestSegment {
 		(first_handle, second_handle)
 	}
 
-	pub fn adjusted_insert(&self, responses: &mut VecDeque<Message>) -> PointId {
+	pub fn adjusted_insert(&self, responses: &mut VecDeque<Message>) -> (PointId, [SegmentId; 2]) {
 		let layer = self.layer;
 		let [first, second] = self.bezier.split(TValue::Parametric(self.t));
 
@@ -253,11 +253,11 @@ impl ClosestSegment {
 			responses.add(GraphOperationMessage::Vector { layer, modification_type });
 		}
 
-		midpoint
+		(midpoint, segment_ids)
 	}
 
 	pub fn adjusted_insert_and_select(&self, shape_editor: &mut ShapeState, responses: &mut VecDeque<Message>, extend_selection: bool) {
-		let id = self.adjusted_insert(responses);
+		let (id, _) = self.adjusted_insert(responses);
 		shape_editor.select_anchor_point_by_id(self.layer, id, extend_selection)
 	}
 
@@ -282,6 +282,71 @@ impl ClosestSegment {
 		.unwrap_or(DVec2::ZERO);
 		tangent.perp()
 	}
+
+	/// Molding the bezier curve.
+	/// Returns adjacent handles' [`HandleId`] if colinearity is broken temporarily.
+	pub fn mold_handle_positions(
+		&self,
+		document: &DocumentMessageHandler,
+		responses: &mut VecDeque<Message>,
+		(c1, c2): (DVec2, DVec2),
+		new_b: DVec2,
+		break_colinear_molding: bool,
+		temporary_adjacent_handles_while_molding: Option<[Option<HandleId>; 2]>,
+	) -> Option<[Option<HandleId>; 2]> {
+		let transform = document.metadata().transform_to_viewport(self.layer);
+
+		let start = self.bezier.start;
+		let end = self.bezier.end;
+
+		// Apply the drag delta to the segment's handles
+		let b = self.bezier_point_to_viewport;
+		let delta = transform.inverse().transform_vector2(new_b - b);
+		let (nc1, nc2) = (c1 + delta, c2 + delta);
+
+		let handle1 = HandleId::primary(self.segment);
+		let handle2 = HandleId::end(self.segment);
+		let layer = self.layer;
+
+		let modification_type = handle1.set_relative_position(nc1 - start);
+		responses.add(GraphOperationMessage::Vector { layer, modification_type });
+
+		let modification_type = handle2.set_relative_position(nc2 - end);
+		responses.add(GraphOperationMessage::Vector { layer, modification_type });
+
+		// If adjacent segments have colinear handles, their direction is changed but their handle lengths is preserved
+		// TODO: Find something which is more appropriate
+		let vector_data = document.network_interface.compute_modified_vector(self.layer())?;
+
+		if break_colinear_molding {
+			// Disable G1 continuity
+			let other_handles = [
+				restore_previous_handle_position(handle1, c1, start, &vector_data, layer, responses),
+				restore_previous_handle_position(handle2, c2, end, &vector_data, layer, responses),
+			];
+
+			// Store other HandleId in tool data to regain colinearity later
+			if temporary_adjacent_handles_while_molding.is_some() {
+				temporary_adjacent_handles_while_molding
+			} else {
+				Some(other_handles)
+			}
+		} else {
+			// Move the colinear handles so that colinearity is maintained
+			adjust_handle_colinearity(handle1, start, nc1, &vector_data, layer, responses);
+			adjust_handle_colinearity(handle2, end, nc2, &vector_data, layer, responses);
+
+			if let Some(adjacent_handles) = temporary_adjacent_handles_while_molding {
+				if let Some(other_handle1) = adjacent_handles[0] {
+					restore_g1_continuity(handle1, other_handle1, nc1, start, &vector_data, layer, responses);
+				}
+				if let Some(other_handle2) = adjacent_handles[1] {
+					restore_g1_continuity(handle2, other_handle2, nc2, end, &vector_data, layer, responses);
+				}
+			}
+			None
+		}
+	}
 }
 
 // TODO Consider keeping a list of selected manipulators to minimize traversals of the layers