Add the Spiral shape node

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

@@ -1812,6 +1812,7 @@ fn static_node_properties() -> NodeProperties {
 	map.insert("math_properties".to_string(), Box::new(node_properties::math_properties));
 	map.insert("rectangle_properties".to_string(), Box::new(node_properties::rectangle_properties));
 	map.insert("grid_properties".to_string(), Box::new(node_properties::grid_properties));
+	map.insert("spiral_properties".to_string(), Box::new(node_properties::spiral_properties));
 	map.insert("sample_polyline_properties".to_string(), Box::new(node_properties::sample_polyline_properties));
 	map.insert(
 		"identity_properties".to_string(),

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

@@ -23,9 +23,9 @@ use graphene_std::raster_types::{CPU, GPU, RasterDataTable};
 use graphene_std::text::Font;
 use graphene_std::transform::{Footprint, ReferencePoint};
 use graphene_std::vector::VectorDataTable;
-use graphene_std::vector::misc::GridType;
 use graphene_std::vector::misc::{ArcType, MergeByDistanceAlgorithm};
 use graphene_std::vector::misc::{CentroidType, PointSpacingType};
+use graphene_std::vector::misc::{GridType, SpiralType};
 use graphene_std::vector::style::{Fill, FillChoice, FillType, GradientStops};
 use graphene_std::vector::style::{GradientType, PaintOrder, StrokeAlign, StrokeCap, StrokeJoin};
 use graphene_std::{GraphicGroupTable, NodeInputDecleration};
@@ -1202,6 +1202,68 @@ pub(crate) fn grid_properties(node_id: NodeId, context: &mut NodePropertiesConte
 	widgets
 }
 
+pub(crate) fn spiral_properties(node_id: NodeId, context: &mut NodePropertiesContext) -> Vec<LayoutGroup> {
+	use graphene_std::vector::generator_nodes::spiral::*;
+
+	let spiral_type = enum_choice::<SpiralType>()
+		.for_socket(ParameterWidgetsInfo::new(node_id, SpiralTypeInput::INDEX, true, context))
+		.property_row();
+
+	let mut widgets = vec![spiral_type];
+
+	let document_node = match get_document_node(node_id, context) {
+		Ok(document_node) => document_node,
+		Err(err) => {
+			log::error!("Could not get document node in exposure_properties: {err}");
+			return Vec::new();
+		}
+	};
+
+	let Some(spiral_type_input) = document_node.inputs.get(SpiralTypeInput::INDEX) else {
+		log::warn!("A widget failed to be built because its node's input index is invalid.");
+		return vec![];
+	};
+	if let Some(&TaggedValue::SpiralType(spiral_type)) = spiral_type_input.as_non_exposed_value() {
+		match spiral_type {
+			SpiralType::Archimedean => {
+				let inner_radius = LayoutGroup::Row {
+					widgets: number_widget(ParameterWidgetsInfo::new(node_id, InnerRadiusInput::INDEX, true, context), NumberInput::default().min(0.)),
+				};
+
+				let tightness = LayoutGroup::Row {
+					widgets: number_widget(ParameterWidgetsInfo::new(node_id, TightnessInput::INDEX, true, context), NumberInput::default().unit(" px")),
+				};
+
+				widgets.extend([inner_radius, tightness]);
+			}
+			SpiralType::Logarithmic => {
+				let start_radius = LayoutGroup::Row {
+					widgets: number_widget(ParameterWidgetsInfo::new(node_id, StartRadiusInput::INDEX, true, context), NumberInput::default().min(0.)),
+				};
+
+				let growth = LayoutGroup::Row {
+					widgets: number_widget(
+						ParameterWidgetsInfo::new(node_id, GrowthInput::INDEX, true, context),
+						NumberInput::default().max(0.5).min(0.1).increment_behavior(NumberInputIncrementBehavior::Add).increment_step(0.01),
+					),
+				};
+
+				widgets.extend([start_radius, growth]);
+			}
+		}
+	}
+
+	let turns = number_widget(ParameterWidgetsInfo::new(node_id, TurnsInput::INDEX, true, context), NumberInput::default().min(0.1));
+	let angle_offset = number_widget(
+		ParameterWidgetsInfo::new(node_id, AngleOffsetInput::INDEX, true, context),
+		NumberInput::default().min(0.1).max(180.).unit("°"),
+	);
+
+	widgets.extend([LayoutGroup::Row { widgets: turns }, LayoutGroup::Row { widgets: angle_offset }]);
+
+	widgets
+}
+
 pub(crate) const SAMPLE_POLYLINE_TOOLTIP_SPACING: &str = "Use a point sampling density controlled by a distance between, or specific number of, points.";
 pub(crate) const SAMPLE_POLYLINE_TOOLTIP_SEPARATION: &str = "Distance between each instance (exact if 'Adaptive Spacing' is disabled, approximate if enabled).";
 pub(crate) const SAMPLE_POLYLINE_TOOLTIP_QUANTITY: &str = "Number of points to place along the path.";

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

@@ -352,6 +352,10 @@ pub fn get_star_id(layer: LayerNodeIdentifier, network_interface: &NodeNetworkIn
 	NodeGraphLayer::new(layer, network_interface).upstream_node_id_from_name("Star")
 }
 
+pub fn get_spiral_id(layer: LayerNodeIdentifier, network_interface: &NodeNetworkInterface) -> Option<NodeId> {
+	NodeGraphLayer::new(layer, network_interface).upstream_node_id_from_name("Spiral")
+}
+
 pub fn get_text_id(layer: LayerNodeIdentifier, network_interface: &NodeNetworkInterface) -> Option<NodeId> {
 	NodeGraphLayer::new(layer, network_interface).upstream_node_id_from_name("Text")
 }

editor/src/messages/tool/common_functionality/shapes/mod.rs

@@ -3,6 +3,7 @@ pub mod line_shape;
 pub mod polygon_shape;
 pub mod rectangle_shape;
 pub mod shape_utility;
+pub mod spiral_shape;
 pub mod star_shape;
 
 pub use super::shapes::ellipse_shape::Ellipse;

editor/src/messages/tool/common_functionality/shapes/polygon_shape.rs

@@ -11,9 +11,11 @@ use crate::messages::tool::common_functionality::gizmos::shape_gizmos::number_of
 use crate::messages::tool::common_functionality::gizmos::shape_gizmos::point_radius_handle::PointRadiusHandle;
 use crate::messages::tool::common_functionality::gizmos::shape_gizmos::point_radius_handle::PointRadiusHandleState;
 use crate::messages::tool::common_functionality::graph_modification_utils;
+use crate::messages::tool::common_functionality::graph_modification_utils::NodeGraphLayer;
 use crate::messages::tool::common_functionality::shape_editor::ShapeState;
 use crate::messages::tool::common_functionality::shapes::shape_utility::ShapeGizmoHandler;
 use crate::messages::tool::common_functionality::shapes::shape_utility::polygon_outline;
+use crate::messages::tool::tool_messages::shape_tool::ShapeOptionsUpdate;
 use crate::messages::tool::tool_messages::tool_prelude::*;
 use glam::DAffine2;
 use graph_craft::document::NodeInput;
@@ -148,4 +150,37 @@ impl Polygon {
 			});
 		}
 	}
+
+	/// Updates the number of sides of a polygon or star node and syncs the Shape Tool UI widget accordingly.
+	/// Increases or decreases the side count based on user input, clamped to a minimum of 3.
+	pub fn update_sides(decrease: bool, layer: LayerNodeIdentifier, document: &DocumentMessageHandler, responses: &mut VecDeque<Message>) {
+		let Some(node_id) = graph_modification_utils::get_polygon_id(layer, &document.network_interface).or(graph_modification_utils::get_star_id(layer, &document.network_interface)) else {
+			return;
+		};
+
+		let Some(node_inputs) = NodeGraphLayer::new(layer, &document.network_interface)
+			.find_node_inputs("Regular Polygon")
+			.or(NodeGraphLayer::new(layer, &document.network_interface).find_node_inputs("Star"))
+		else {
+			return;
+		};
+
+		let Some(&TaggedValue::U32(n)) = node_inputs.get(1).unwrap().as_value() else { return };
+
+		responses.add(ShapeToolMessage::UpdateOptions(ShapeOptionsUpdate::Vertices(n + 1)));
+
+		let input: NodeInput;
+		if decrease {
+			input = NodeInput::value(TaggedValue::U32((n - 1).max(3)), false);
+			responses.add(ShapeToolMessage::UpdateOptions(ShapeOptionsUpdate::Vertices((n - 1).max(3))));
+		} else {
+			input = NodeInput::value(TaggedValue::U32(n + 1), false);
+			responses.add(ShapeToolMessage::UpdateOptions(ShapeOptionsUpdate::Vertices(n + 1)));
+		}
+
+		responses.add(NodeGraphMessage::SetInput {
+			input_connector: InputConnector::node(node_id, 1),
+			input,
+		});
+	}
 }

editor/src/messages/tool/common_functionality/shapes/shape_utility.rs

@@ -24,16 +24,18 @@ pub enum ShapeType {
 	#[default]
 	Polygon = 0,
 	Star = 1,
-	Rectangle = 2,
-	Ellipse = 3,
-	Line = 4,
+	Spiral = 2,
+	Rectangle = 3,
+	Ellipse = 4,
+	Line = 5,
 }
 
 impl ShapeType {
 	pub fn name(&self) -> String {
 		(match self {
 			Self::Polygon => "Polygon",
 			Self::Star => "Star",
+			Self::Spiral => "Spiral",
 			Self::Rectangle => "Rectangle",
 			Self::Ellipse => "Ellipse",
 			Self::Line => "Line",

editor/src/messages/tool/common_functionality/shapes/spiral_shape.rs

@@ -0,0 +1,121 @@
+use super::*;
+use crate::messages::portfolio::document::graph_operation::utility_types::TransformIn;
+use crate::messages::portfolio::document::node_graph::document_node_definitions::resolve_document_node_type;
+use crate::messages::portfolio::document::utility_types::document_metadata::LayerNodeIdentifier;
+use crate::messages::portfolio::document::utility_types::network_interface::{InputConnector, NodeTemplate};
+use crate::messages::tool::common_functionality::graph_modification_utils;
+use crate::messages::tool::common_functionality::graph_modification_utils::NodeGraphLayer;
+use crate::messages::tool::common_functionality::snapping::{SnapCandidatePoint, SnapData, SnapTypeConfiguration};
+use crate::messages::tool::tool_messages::shape_tool::ShapeOptionsUpdate;
+use crate::messages::tool::tool_messages::tool_prelude::*;
+use glam::DAffine2;
+use graph_craft::document::NodeId;
+use graph_craft::document::NodeInput;
+use graph_craft::document::value::TaggedValue;
+use graphene_std::vector::misc::SpiralType;
+use std::collections::VecDeque;
+use std::f64::consts::TAU;
+
+#[derive(Default)]
+pub struct Spiral;
+
+impl Spiral {
+	pub fn create_node(spiral_type: SpiralType, turns: f64) -> NodeTemplate {
+		let node_type = resolve_document_node_type("Spiral").expect("Spiral node can't be found");
+		node_type.node_template_input_override([
+			None,
+			Some(NodeInput::value(TaggedValue::SpiralType(spiral_type), false)),
+			Some(NodeInput::value(TaggedValue::F64(0.001), false)),
+			Some(NodeInput::value(TaggedValue::F64(0.1), false)),
+			None,
+			Some(NodeInput::value(TaggedValue::F64(0.1), false)),
+			Some(NodeInput::value(TaggedValue::F64(turns), false)),
+		])
+	}
+
+	pub fn update_shape(document: &DocumentMessageHandler, ipp: &InputPreprocessorMessageHandler, layer: LayerNodeIdentifier, shape_tool_data: &mut ShapeToolData, responses: &mut VecDeque<Message>) {
+		let viewport_drag_start = shape_tool_data.data.viewport_drag_start(document);
+
+		let ignore = vec![layer];
+		let snap_data = SnapData::ignore(document, ipp, &ignore);
+		let config = SnapTypeConfiguration::default();
+		let document_mouse = document.metadata().document_to_viewport.inverse().transform_point2(ipp.mouse.position);
+		let snapped = shape_tool_data.data.snap_manager.free_snap(&snap_data, &SnapCandidatePoint::handle(document_mouse), config);
+		let snapped_viewport_point = document.metadata().document_to_viewport.transform_point2(snapped.snapped_point_document);
+		shape_tool_data.data.snap_manager.update_indicator(snapped);
+
+		let dragged_distance = (viewport_drag_start - snapped_viewport_point).length();
+
+		let Some(node_id) = graph_modification_utils::get_spiral_id(layer, &document.network_interface) else {
+			return;
+		};
+
+		let Some(node_inputs) = NodeGraphLayer::new(layer, &document.network_interface).find_node_inputs("Spiral") else {
+			return;
+		};
+
+		let Some(&TaggedValue::F64(turns)) = node_inputs.get(6).unwrap().as_value() else {
+			return;
+		};
+
+		Self::update_radius(node_id, dragged_distance, turns, responses);
+
+		responses.add(GraphOperationMessage::TransformSet {
+			layer,
+			transform: DAffine2::from_scale_angle_translation(DVec2::ONE, 0., viewport_drag_start),
+			transform_in: TransformIn::Viewport,
+			skip_rerender: false,
+		});
+	}
+
+	pub fn update_radius(node_id: NodeId, drag_length: f64, turns: f64, responses: &mut VecDeque<Message>) {
+		let archimedean_radius = drag_length / (turns * TAU);
+		responses.add(NodeGraphMessage::SetInput {
+			input_connector: InputConnector::node(node_id, 5),
+			input: NodeInput::value(TaggedValue::F64(archimedean_radius), false),
+		});
+
+		// 0.2 is the default parameter
+		let factor = (0.2 * turns * TAU).exp();
+		let logarithmic_radius = drag_length / factor;
+		responses.add(NodeGraphMessage::SetInput {
+			input_connector: InputConnector::node(node_id, 2),
+			input: NodeInput::value(TaggedValue::F64(logarithmic_radius), false),
+		});
+	}
+
+	/// Updates the number of turns of a spiral node and recalculates its radius based on drag distance.
+	/// Also updates the Shape Tool's turns UI widget to reflect the change.
+	pub fn update_turns(drag_start: DVec2, decrease: bool, layer: LayerNodeIdentifier, document: &DocumentMessageHandler, ipp: &InputPreprocessorMessageHandler, responses: &mut VecDeque<Message>) {
+		let Some(node_id) = graph_modification_utils::get_spiral_id(layer, &document.network_interface) else {
+			return;
+		};
+
+		let Some(node_inputs) = NodeGraphLayer::new(layer, &document.network_interface).find_node_inputs("Spiral") else {
+			return;
+		};
+
+		let Some(&TaggedValue::F64(n)) = node_inputs.get(6).unwrap().as_value() else { return };
+
+		let input: NodeInput;
+		let turns: f64;
+		if decrease {
+			turns = (n - 1.).max(1.);
+			input = NodeInput::value(TaggedValue::F64(turns), false);
+			responses.add(ShapeToolMessage::UpdateOptions(ShapeOptionsUpdate::Turns(turns)));
+		} else {
+			turns = n + 1.;
+			input = NodeInput::value(TaggedValue::F64(turns), false);
+			responses.add(ShapeToolMessage::UpdateOptions(ShapeOptionsUpdate::Turns(turns)));
+		}
+
+		let drag_length = drag_start.distance(ipp.mouse.position);
+
+		Self::update_radius(node_id, drag_length, turns, responses);
+
+		responses.add(NodeGraphMessage::SetInput {
+			input_connector: InputConnector::node(node_id, 6),
+			input,
+		});
+	}
+}