implement snapping for point-handle gizmo and implement no of point gizmo need to refactor

Author: 0SlowPoke0

Cargo.lock

@@ -47,6 +47,7 @@ serde_json = { workspace = true }
 bezier-rs = { workspace = true }
 futures = { workspace = true }
 glam = { workspace = true, features = ["serde", "debug-glam-assert"] }
+kurbo = { workspace = true }
 derivative = { workspace = true }
 specta = { workspace = true }
 image = { workspace = true, features = ["bmp", "png"] }

editor/Cargo.toml

@@ -119,6 +119,10 @@ pub const DEFAULT_BRUSH_SIZE: f64 = 20.;
 
 // STAR GIZMOS
 pub const POINT_RADIUS_HANDLE_SNAP_THRESHOLD: f64 = 8.;
+pub const POINT_RADIUS_HANDLE_SEGMENT_THRESHOLD: f64 = 7.9;
+pub const NUMBER_OF_POINTS_HANDLE_SPOKE_EXTENSION: f64 = 1.2;
+pub const NUMBER_OF_POINTS_HANDLE_SPOKE_LENGTH: f64 = 10.;
+pub const GIZMO_HIDE_THRESHOLD: f64 = 20.;
 
 // SCROLLBARS
 pub const SCROLLBAR_SPACING: f64 = 0.1;

editor/src/consts.rs

@@ -7,9 +7,11 @@ use crate::messages::tool::common_functionality::graph_modification_utils::{self
 use crate::messages::tool::common_functionality::transformation_cage::BoundingBoxManager;
 use crate::messages::tool::tool_messages::tool_prelude::Key;
 use crate::messages::tool::utility_types::*;
+use bezier_rs::Subpath;
 use glam::{DMat2, DVec2};
 use graph_craft::document::NodeInput;
 use graph_craft::document::value::TaggedValue;
+use graphene_std::vector::PointId;
 use std::collections::VecDeque;
 use std::f64::consts::PI;
 
@@ -151,36 +153,31 @@ pub fn anchor_overlays(document: &DocumentMessageHandler, overlay_context: &mut
 	}
 }
 
-pub fn points_on_inner_circle(document: &DocumentMessageHandler, mouse_position: DVec2) -> Option<(LayerNodeIdentifier, u32, usize, f64)> {
-	for layer in document
-		.network_interface
-		.selected_nodes()
-		.selected_visible_and_unlocked_layers(&document.network_interface)
-		.filter(|layer| graph_modification_utils::get_star_id(*layer, &document.network_interface).is_some())
-	{
-		let Some(node_inputs) = NodeGraphLayer::new(layer, &document.network_interface).find_node_inputs("Star") else {
-			continue;
-		};
+pub fn star_outline(layer: LayerNodeIdentifier, document: &DocumentMessageHandler, overlay_context: &mut OverlayContext) {
+	let mut anchors = Vec::new();
 
-		let viewport = document.network_interface.document_metadata().transform_to_viewport(layer);
+	let Some(node_inputs) = NodeGraphLayer::new(layer, &document.network_interface).find_node_inputs("Star") else {
+		return;
+	};
 
-		let (Some(&TaggedValue::U32(n)), Some(&TaggedValue::F64(outer)), Some(&TaggedValue::F64(inner))) = (node_inputs[1].as_value(), node_inputs[2].as_value(), node_inputs[3].as_value()) else {
-			continue;
-		};
+	let (Some(&TaggedValue::U32(n)), Some(&TaggedValue::F64(radius1)), Some(&TaggedValue::F64(radius2))) = (node_inputs[1].as_value(), node_inputs[2].as_value(), node_inputs[3].as_value()) else {
+		return;
+	};
 
-		for i in 0..(2 * n) {
-			let angle = i as f64 * PI / n as f64;
-			let (radius, index) = if i % 2 == 0 { (outer, 2) } else { (inner, 3) };
+	let viewport = document.metadata().transform_to_viewport(layer);
+	for i in 0..(2 * n) {
+		let angle = i as f64 * PI / n as f64;
+		let radius = if i % 2 == 0 { radius1 } else { radius2 };
 
-			let point = viewport.transform_point2(DVec2 {
-				x: radius * angle.sin(),
-				y: -radius * angle.cos(),
-			});
+		let point = DVec2 {
+			x: radius * angle.sin(),
+			y: -radius * angle.cos(),
+		};
 
-			if point.distance(mouse_position) < 5.0 {
-				return Some((layer, i, index, radius));
-			};
-		}
+		anchors.push(point);
 	}
-	None
+
+	let subpath: Vec<Subpath<PointId>> = vec![Subpath::from_anchors_linear(anchors, true)];
+
+	overlay_context.outline(subpath.iter(), viewport, None);
 }