Iterator Implementations and fixes (#637)

* Refactoring: disentangle kurbo from apply_affine

* Broke boolean operations, refactor in state which compiles

* "fixed" boolean operation refactor related errors

* fixed apply_affine, which would not have applied any type of affine

* implemented transforms for VectorAnchors
implemented Not for VectorControlPointType

* started adding Vector Shape implementations of shape prototypes

* added several useful implemtations to UniqueElements

* added another implemnation for UniqueElements to make working with iterators easier, fixed vector-shape errors

* package-lock.json

* clean up rebase, added back Layer paths

* added deref implementation for VectorShape

* unnecesary variable

* simplify code by removing levels of indirection

* fixed errors

Author: caleb-ad

editor/src/viewport_tools/tools/shape_tool.rs

@@ -161,7 +161,7 @@ impl Fsm for ShapeToolFsmState {
 							path: shape_data.path.clone().unwrap(),
 							insert_index: -1,
 							transform: DAffine2::ZERO.to_cols_array(),
-							sides: data.sides,
+							sides: data.sides.into(),
 							style: style::PathStyle::new(None, Some(style::Fill::new(tool_data.primary_color))),
 						}
 						.into(),

editor/src/viewport_tools/vector_editor/shape_editor.rs

@@ -144,7 +144,7 @@ impl ShapeEditor {
 
 	/// A mutable iterator of all the anchors, regardless of selection
 	pub fn anchors_mut(&mut self) -> impl Iterator<Item = &mut VectorAnchor> {
-		self.copy_of_shapes.iter_mut().flat_map(|shape| shape.anchors_mut())
+		self.copy_of_shapes.iter_mut().flat_map(|shape| shape.iter_mut())
 	}
 
 	/// Select the last anchor in this shape

graphene/src/layers/id_storage.rs

@@ -1,4 +1,7 @@
-use std::collections::HashMap;
+use std::{
+	collections::HashMap,
+	ops::{Deref, DerefMut},
+};
 
 use crate::DocumentError;
 use serde::{Deserialize, Serialize};
@@ -9,7 +12,7 @@ type ElementIndex = i64;
 /// A layer that encapsulates other layers, including potentially more folders.
 /// The contained layers are rendered in the same order they are
 /// stored in the [layers](PathStorage::layers) field.
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, Default)]
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
 
 // TODO: Default is a bit weird because Layer does not implement Default. but we should not care because the empty vec is the default
 pub struct UniqueElements<T> {
@@ -62,17 +65,16 @@ impl<T> UniqueElements<T> {
 				}
 			}
 
-			let id = self.next_assignment_id;
 			self.values.insert(insert_index as usize, element);
-			self.keys.insert(insert_index as usize, id);
-			self.id_to_index.insert(id, insert_index);
+			self.keys.insert(insert_index as usize, self.next_assignment_id);
+			self.id_to_index.insert(self.next_assignment_id, insert_index);
 
 			// Linear probing for collision avoidance
 			while self.id_to_index.contains_key(&self.next_assignment_id) {
 				self.next_assignment_id += 1;
 			}
 
-			Some(id)
+			Some(self.next_assignment_id)
 		} else {
 			None
 		}
@@ -109,15 +111,16 @@ impl<T> UniqueElements<T> {
 		self.keys.as_slice()
 	}
 
-	/// Get references to all the [T]s in the within this container.
-	pub fn values(&self) -> &[T] {
-		self.values.as_slice()
-	}
+	/// These can be replaced by implementing Deref I think
+	// /// Get references to all the [T]s in the within this container.
+	// pub fn values(&self) -> &[T] {
+	// 	self.values.as_slice()
+	// }
 
-	/// Get mutable references to all the [T]s in the within this container.
-	pub fn values_mut(&mut self) -> &mut [T] {
-		self.values.as_mut_slice()
-	}
+	// /// Get mutable references to all the [T]s in the within this container.
+	// pub fn values_mut(&mut self) -> &mut [T] {
+	// 	self.values.as_mut_slice()
+	// }
 
 	/// Get a single element with a given element ID from the within this container.
 	pub fn by_id(&self, id: ElementId) -> Option<&T> {
@@ -216,3 +219,49 @@ impl<T> UniqueElements<T> {
 		Err(DocumentError::LayerNotFound([element_id].into()))
 	}
 }
+
+impl<T> Default for UniqueElements<T> {
+	fn default() -> Self {
+		UniqueElements {
+			keys: vec![],
+			values: vec![],
+			next_assignment_id: 0,
+			id_to_index: HashMap::new(),
+		}
+	}
+}
+
+impl<T> Deref for UniqueElements<T> {
+	type Target = [T];
+	fn deref(&self) -> &Self::Target {
+		&self.values
+	}
+}
+
+impl<T> DerefMut for UniqueElements<T> {
+	fn deref_mut(&mut self) -> &mut Self::Target {
+		&mut self.values
+	}
+}
+
+/// allows use with iterators
+/// also allows constructing UniqueElements with collect
+impl<A> FromIterator<A> for UniqueElements<A> {
+	fn from_iter<T: IntoIterator<Item = A>>(iter: T) -> Self {
+		let mut new = UniqueElements::default();
+		iter.into_iter().for_each(|element| match new.add(element, None, -1) {
+			_ => (), // attempt to add all elements, even if one fails
+		});
+		new
+	}
+}
+
+impl<'b, 'a: 'b, A: 'a + Clone> FromIterator<&'b A> for UniqueElements<A> {
+	fn from_iter<T: IntoIterator<Item = &'b A>>(iter: T) -> Self {
+		let mut new = UniqueElements::default();
+		iter.into_iter().for_each(|element| match new.add(element.clone(), None, -1) {
+			_ => (), // attempt to add all elements, even if one fails
+		});
+		new
+	}
+}

graphene/src/layers/shape_layer.rs

@@ -78,33 +78,10 @@ impl ShapeLayer {
 		}
 	}
 
-	pub fn ngon(sides: u8, style: PathStyle) -> Self {
-		use std::f64::consts::{FRAC_PI_2, TAU};
-
-		fn unit_rotation(theta: f64) -> DVec2 {
-			DVec2::new(theta.sin(), theta.cos())
-		}
-
-		let mut path = kurbo::BezPath::new();
-
-		let apothem_offset_angle = TAU / (sides as f64);
-		// Rotate odd sided shapes by 90 degrees
-		let offset = ((sides + 1) % 2) as f64 * FRAC_PI_2;
-
-		let relative_points = (0..sides).map(|i| apothem_offset_angle * i as f64 + offset).map(unit_rotation);
-
-		let min = relative_points.clone().reduce(|a, b| a.min(b)).unwrap_or_default();
-		let transform = DAffine2::from_scale_angle_translation(DVec2::ONE / 2., 0., -min / 2.);
-		let point = |vec: DVec2| kurbo::Point::new(vec.x, vec.y);
-
-		let mut relative_points = relative_points.map(|p| point(transform.transform_point2(p)));
-		path.move_to(relative_points.next().expect("Tried to create an ngon with 0 sides"));
-		relative_points.for_each(|p| path.line_to(p));
-
-		path.close_path();
-
+	/// TODO The behavior of ngon changed from the previous iteration slightly
+	pub fn ngon(sides: u64, style: PathStyle) -> Self {
 		Self {
-			shape: path.iter().into(),
+			shape: VectorShape::new_ngon(DVec2::new(0., 0.), sides, 1.),
 			style,
 			render_index: 1,
 			closed: true,
@@ -113,7 +90,7 @@ impl ShapeLayer {
 
 	pub fn rectangle(style: PathStyle) -> Self {
 		Self {
-			shape: VectorShape::from_kurbo_shape(&kurbo::Rect::new(0., 0., 1., 1.).to_path(0.01)),
+			shape: VectorShape::new_rect(DVec2::new(0., 0.), DVec2::new(1., 1.)),
 			style,
 			render_index: 1,
 			closed: true,
@@ -131,24 +108,16 @@ impl ShapeLayer {
 
 	pub fn line(style: PathStyle) -> Self {
 		Self {
-			shape: VectorShape::from_kurbo_shape(&kurbo::Line::new((0., 0.), (1., 0.)).to_path(0.01)),
+			shape: VectorShape::new_line(DVec2::new(0., 0.), DVec2::new(1., 0.)),
 			style,
 			render_index: 1,
 			closed: false,
 		}
 	}
 
 	pub fn poly_line(points: Vec<impl Into<glam::DVec2>>, style: PathStyle) -> Self {
-		let mut path = kurbo::BezPath::new();
-		points
-			.into_iter()
-			.map(|v| v.into())
-			.map(|v: DVec2| kurbo::Point { x: v.x, y: v.y })
-			.enumerate()
-			.for_each(|(i, p)| if i == 0 { path.move_to(p) } else { path.line_to(p) });
-
 		Self {
-			shape: path.iter().into(),
+			shape: VectorShape::new_poly_line(points),
 			style,
 			render_index: 0,
 			closed: false,

graphene/src/layers/vector/constants.rs

@@ -1,4 +1,7 @@
-use std::ops::{Index, IndexMut};
+use std::{
+	ops::{Index, IndexMut, Not},
+	thread::JoinHandle,
+};
 
 use serde::{Deserialize, Serialize};
 
@@ -10,7 +13,18 @@ pub enum ControlPointType {
 	Handle2 = 2,
 }
 
-// Allows us to use ControlPointType for indexing
+impl Not for ControlPointType {
+	type Output = Self;
+	fn not(self) -> Self::Output {
+		match self {
+			ControlPointType::Handle1 => ControlPointType::Handle2,
+			ControlPointType::Handle2 => ControlPointType::Handle1,
+			_ => ControlPointType::Anchor,
+		}
+	}
+}
+
+// Allows us to use ManipulatorType for indexing
 impl<T> Index<ControlPointType> for [T; 3] {
 	type Output = T;
 	fn index(&self, mt: ControlPointType) -> &T {

graphene/src/layers/vector/vector_anchor.rs

@@ -68,11 +68,17 @@ impl VectorAnchor {
 		closest_index
 	}
 
-	// TODO change relative to an enum (relative, absolute)
-	/// Move the selected points by the provided delta
-	pub fn move_selected_points(&mut self, translation: DVec2, relative: bool, transform: &DAffine2) {
-		// TODO This needs to be rebuilt without usage of kurbo
-		// Move associated handles
+	/// Move the selected points by the provided transform
+	/// if relative is false the point is transformed and its original position is subtracted
+	pub fn move_selected_points(&mut self, relative: bool, transform: &DAffine2) {
+		for point in self.selected_points_mut() {
+			if !relative {
+				let copy = point.clone().position;
+				point.transform(transform);
+				point.move_by(&(-copy));
+			}
+			point.transform(transform);
+		}
 	}
 
 	/// Returns true if any points in this anchor are selected
@@ -104,12 +110,12 @@ impl VectorAnchor {
 		}
 	}
 
-	/// Provides the selected points in this anchor
+	/// Provides the points in this anchor
 	pub fn points(&self) -> impl Iterator<Item = &VectorControlPoint> {
 		self.points.iter().flatten()
 	}
 
-	/// Returns
+	/// Provides the selected points in this anchor
 	pub fn selected_points(&self) -> impl Iterator<Item = &VectorControlPoint> {
 		self.points.iter().flatten().filter(|pnt| pnt.is_selected)
 	}
@@ -128,19 +134,9 @@ impl VectorAnchor {
 	}
 
 	/// Returns the opposing handle to the handle provided
+	/// Returns the anchor handle if the anchor is provided
 	pub fn opposing_handle(&self, handle: &VectorControlPoint) -> &Option<VectorControlPoint> {
-		if let Some(point) = &self.points[ControlPointType::Handle1] {
-			if point == handle {
-				return &self.points[ControlPointType::Handle2];
-			}
-		};
-
-		if let Some(point) = &self.points[ControlPointType::Handle2] {
-			if point == handle {
-				return &self.points[ControlPointType::Handle1];
-			}
-		};
-		&None
+		&self.points[!handle.manipulator_type]
 	}
 
 	/// Set the mirroring state

graphene/src/layers/vector/vector_control_point.rs

@@ -1,5 +1,5 @@
 use super::constants::ControlPointType;
-use glam::DVec2;
+use glam::{DAffine2, DVec2};
 use serde::{Deserialize, Serialize};
 
 /// VectorControlPoint represents any grabbable point, anchor or handle
@@ -44,8 +44,13 @@ impl VectorControlPoint {
 		self.is_selected = selected;
 	}
 
+	/// apply given transform
+	pub fn transform(&mut self, delta: &DAffine2) {
+		self.position = delta.transform_point2(self.position);
+	}
+
 	/// Move by a delta amount
-	pub fn move_by(&mut self, delta: DVec2) {
-		self.position += delta;
+	pub fn move_by(&mut self, delta: &DVec2) {
+		self.position += *delta;
 	}
 }