Prep gcore splitup: move various symbols into their own modules (#2746)

* move `trait AsU32` from `gcore::vector::misc` to `gcore`

* move blending and gradient to their own modules

* fix unused warnings

* move `Quad`, `Rect` and `BBox` to `gcore::math`

* extract `ReferencePoint` and transform nodes from `transform`

* move color-related code to `mod color`

* fix unused warning in test code

* move blending-related nodes and code to `mod blending_nodes`

* move ClickTarget code to `mod vector::click_target`

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

@@ -1,6 +1,6 @@
 use crate::Color;
+use crate::math::bbox::AxisAlignedBbox;
 use crate::raster::BlendMode;
-use crate::raster::bbox::AxisAlignedBbox;
 use dyn_any::DynAny;
 use glam::DVec2;
 use std::hash::{Hash, Hasher};

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

@@ -0,0 +1,162 @@
+use crate::math::math_ext::QuadExt;
+use crate::renderer::Quad;
+use crate::vector::PointId;
+use bezier_rs::Subpath;
+use glam::{DAffine2, DMat2, DVec2};
+
+#[derive(Copy, Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct FreePoint {
+	pub id: PointId,
+	pub position: DVec2,
+}
+
+impl FreePoint {
+	pub fn new(id: PointId, position: DVec2) -> Self {
+		Self { id, position }
+	}
+
+	pub fn apply_transform(&mut self, transform: DAffine2) {
+		self.position = transform.transform_point2(self.position);
+	}
+}
+
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub enum ClickTargetType {
+	Subpath(Subpath<PointId>),
+	FreePoint(FreePoint),
+}
+
+/// Represents a clickable target for the layer
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct ClickTarget {
+	target_type: ClickTargetType,
+	stroke_width: f64,
+	bounding_box: Option<[DVec2; 2]>,
+}
+
+impl ClickTarget {
+	pub fn new_with_subpath(subpath: Subpath<PointId>, stroke_width: f64) -> Self {
+		let bounding_box = subpath.loose_bounding_box();
+		Self {
+			target_type: ClickTargetType::Subpath(subpath),
+			stroke_width,
+			bounding_box,
+		}
+	}
+
+	pub fn new_with_free_point(point: FreePoint) -> Self {
+		const MAX_LENGTH_FOR_NO_WIDTH_OR_HEIGHT: f64 = 1e-4 / 2.;
+		let stroke_width = 10.;
+		let bounding_box = Some([
+			point.position - DVec2::splat(MAX_LENGTH_FOR_NO_WIDTH_OR_HEIGHT),
+			point.position + DVec2::splat(MAX_LENGTH_FOR_NO_WIDTH_OR_HEIGHT),
+		]);
+
+		Self {
+			target_type: ClickTargetType::FreePoint(point),
+			stroke_width,
+			bounding_box,
+		}
+	}
+
+	pub fn target_type(&self) -> &ClickTargetType {
+		&self.target_type
+	}
+
+	pub fn bounding_box(&self) -> Option<[DVec2; 2]> {
+		self.bounding_box
+	}
+
+	pub fn bounding_box_with_transform(&self, transform: DAffine2) -> Option<[DVec2; 2]> {
+		self.bounding_box.map(|[a, b]| [transform.transform_point2(a), transform.transform_point2(b)])
+	}
+
+	pub fn apply_transform(&mut self, affine_transform: DAffine2) {
+		match self.target_type {
+			ClickTargetType::Subpath(ref mut subpath) => {
+				subpath.apply_transform(affine_transform);
+			}
+			ClickTargetType::FreePoint(ref mut point) => {
+				point.apply_transform(affine_transform);
+			}
+		}
+		self.update_bbox();
+	}
+
+	fn update_bbox(&mut self) {
+		match self.target_type {
+			ClickTargetType::Subpath(ref subpath) => {
+				self.bounding_box = subpath.bounding_box();
+			}
+			ClickTargetType::FreePoint(ref point) => {
+				self.bounding_box = Some([point.position - DVec2::splat(self.stroke_width / 2.), point.position + DVec2::splat(self.stroke_width / 2.)]);
+			}
+		}
+	}
+
+	/// Does the click target intersect the path
+	pub fn intersect_path<It: Iterator<Item = bezier_rs::Bezier>>(&self, mut bezier_iter: impl FnMut() -> It, layer_transform: DAffine2) -> bool {
+		// Check if the matrix is not invertible
+		let mut layer_transform = layer_transform;
+		if layer_transform.matrix2.determinant().abs() <= f64::EPSILON {
+			layer_transform.matrix2 += DMat2::IDENTITY * 1e-4; // TODO: Is this the cleanest way to handle this?
+		}
+
+		let inverse = layer_transform.inverse();
+		let mut bezier_iter = || bezier_iter().map(|bezier| bezier.apply_transformation(|point| inverse.transform_point2(point)));
+
+		match self.target_type() {
+			ClickTargetType::Subpath(subpath) => {
+				// Check if outlines intersect
+				let outline_intersects = |path_segment: bezier_rs::Bezier| bezier_iter().any(|line| !path_segment.intersections(&line, None, None).is_empty());
+				if subpath.iter().any(outline_intersects) {
+					return true;
+				}
+				// Check if selection is entirely within the shape
+				if subpath.closed() && bezier_iter().next().is_some_and(|bezier| subpath.contains_point(bezier.start)) {
+					return true;
+				}
+
+				// Check if shape is entirely within selection
+				let any_point_from_subpath = subpath.manipulator_groups().first().map(|group| group.anchor);
+				any_point_from_subpath.is_some_and(|shape_point| bezier_iter().map(|bezier| bezier.winding(shape_point)).sum::<i32>() != 0)
+			}
+			ClickTargetType::FreePoint(point) => bezier_iter().map(|bezier: bezier_rs::Bezier| bezier.winding(point.position)).sum::<i32>() != 0,
+		}
+	}
+
+	/// Does the click target intersect the point (accounting for stroke size)
+	pub fn intersect_point(&self, point: DVec2, layer_transform: DAffine2) -> bool {
+		let target_bounds = [point - DVec2::splat(self.stroke_width / 2.), point + DVec2::splat(self.stroke_width / 2.)];
+		let intersects = |a: [DVec2; 2], b: [DVec2; 2]| a[0].x <= b[1].x && a[1].x >= b[0].x && a[0].y <= b[1].y && a[1].y >= b[0].y;
+		// This bounding box is not very accurate as it is the axis aligned version of the transformed bounding box. However it is fast.
+		if !self
+			.bounding_box
+			.is_some_and(|loose| (loose[0] - loose[1]).abs().cmpgt(DVec2::splat(1e-4)).any() && intersects((layer_transform * Quad::from_box(loose)).bounding_box(), target_bounds))
+		{
+			return false;
+		}
+
+		// Allows for selecting lines
+		// TODO: actual intersection of stroke
+		let inflated_quad = Quad::from_box(target_bounds);
+		self.intersect_path(|| inflated_quad.bezier_lines(), layer_transform)
+	}
+
+	/// Does the click target intersect the point (not accounting for stroke size)
+	pub fn intersect_point_no_stroke(&self, point: DVec2) -> bool {
+		// Check if the point is within the bounding box
+		if self
+			.bounding_box
+			.is_some_and(|bbox| bbox[0].x <= point.x && point.x <= bbox[1].x && bbox[0].y <= point.y && point.y <= bbox[1].y)
+		{
+			// Check if the point is within the shape
+			match self.target_type() {
+				ClickTargetType::Subpath(subpath) => subpath.closed() && subpath.contains_point(point),
+				ClickTargetType::FreePoint(free_point) => free_point.position == point,
+			}
+		} else {
+			false
+		}
+	}
+}

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

@@ -29,15 +29,6 @@ pub enum BooleanOperation {
 	Difference,
 }
 
-pub trait AsU32 {
-	fn as_u32(&self) -> u32;
-}
-impl AsU32 for u32 {
-	fn as_u32(&self) -> u32 {
-		*self
-	}
-}
-
 pub trait AsU64 {
 	fn as_u64(&self) -> u64;
 }

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

@@ -1,12 +1,15 @@
 mod algorithms;
 pub mod brush_stroke;
+pub mod click_target;
 pub mod generator_nodes;
 pub mod misc;
+mod reference_point;
 pub mod style;
 mod vector_data;
 mod vector_nodes;
 
 pub use bezier_rs;
+pub use reference_point::*;
 pub use style::PathStyle;
 pub use vector_data::*;
 pub use vector_nodes::*;

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

@@ -0,0 +1,103 @@
+use crate::math::bbox::AxisAlignedBbox;
+use glam::DVec2;
+
+#[derive(Clone, Copy, Debug, Default, Hash, Eq, PartialEq, dyn_any::DynAny, serde::Serialize, serde::Deserialize, specta::Type)]
+pub enum ReferencePoint {
+	#[default]
+	None,
+	TopLeft,
+	TopCenter,
+	TopRight,
+	CenterLeft,
+	Center,
+	CenterRight,
+	BottomLeft,
+	BottomCenter,
+	BottomRight,
+}
+
+impl ReferencePoint {
+	pub fn point_in_bounding_box(&self, bounding_box: AxisAlignedBbox) -> Option<DVec2> {
+		let size = bounding_box.size();
+		let offset = match self {
+			ReferencePoint::None => return None,
+			ReferencePoint::TopLeft => DVec2::ZERO,
+			ReferencePoint::TopCenter => DVec2::new(size.x / 2., 0.),
+			ReferencePoint::TopRight => DVec2::new(size.x, 0.),
+			ReferencePoint::CenterLeft => DVec2::new(0., size.y / 2.),
+			ReferencePoint::Center => DVec2::new(size.x / 2., size.y / 2.),
+			ReferencePoint::CenterRight => DVec2::new(size.x, size.y / 2.),
+			ReferencePoint::BottomLeft => DVec2::new(0., size.y),
+			ReferencePoint::BottomCenter => DVec2::new(size.x / 2., size.y),
+			ReferencePoint::BottomRight => DVec2::new(size.x, size.y),
+		};
+		Some(bounding_box.start + offset)
+	}
+}
+
+impl From<&str> for ReferencePoint {
+	fn from(input: &str) -> Self {
+		match input {
+			"None" => ReferencePoint::None,
+			"TopLeft" => ReferencePoint::TopLeft,
+			"TopCenter" => ReferencePoint::TopCenter,
+			"TopRight" => ReferencePoint::TopRight,
+			"CenterLeft" => ReferencePoint::CenterLeft,
+			"Center" => ReferencePoint::Center,
+			"CenterRight" => ReferencePoint::CenterRight,
+			"BottomLeft" => ReferencePoint::BottomLeft,
+			"BottomCenter" => ReferencePoint::BottomCenter,
+			"BottomRight" => ReferencePoint::BottomRight,
+			_ => panic!("Failed parsing unrecognized ReferencePosition enum value '{input}'"),
+		}
+	}
+}
+
+impl From<ReferencePoint> for Option<DVec2> {
+	fn from(input: ReferencePoint) -> Self {
+		match input {
+			ReferencePoint::None => None,
+			ReferencePoint::TopLeft => Some(DVec2::new(0., 0.)),
+			ReferencePoint::TopCenter => Some(DVec2::new(0.5, 0.)),
+			ReferencePoint::TopRight => Some(DVec2::new(1., 0.)),
+			ReferencePoint::CenterLeft => Some(DVec2::new(0., 0.5)),
+			ReferencePoint::Center => Some(DVec2::new(0.5, 0.5)),
+			ReferencePoint::CenterRight => Some(DVec2::new(1., 0.5)),
+			ReferencePoint::BottomLeft => Some(DVec2::new(0., 1.)),
+			ReferencePoint::BottomCenter => Some(DVec2::new(0.5, 1.)),
+			ReferencePoint::BottomRight => Some(DVec2::new(1., 1.)),
+		}
+	}
+}
+
+impl From<DVec2> for ReferencePoint {
+	fn from(input: DVec2) -> Self {
+		const TOLERANCE: f64 = 1e-5_f64;
+		if input.y.abs() < TOLERANCE {
+			if input.x.abs() < TOLERANCE {
+				return ReferencePoint::TopLeft;
+			} else if (input.x - 0.5).abs() < TOLERANCE {
+				return ReferencePoint::TopCenter;
+			} else if (input.x - 1.).abs() < TOLERANCE {
+				return ReferencePoint::TopRight;
+			}
+		} else if (input.y - 0.5).abs() < TOLERANCE {
+			if input.x.abs() < TOLERANCE {
+				return ReferencePoint::CenterLeft;
+			} else if (input.x - 0.5).abs() < TOLERANCE {
+				return ReferencePoint::Center;
+			} else if (input.x - 1.).abs() < TOLERANCE {
+				return ReferencePoint::CenterRight;
+			}
+		} else if (input.y - 1.).abs() < TOLERANCE {
+			if input.x.abs() < TOLERANCE {
+				return ReferencePoint::BottomLeft;
+			} else if (input.x - 0.5).abs() < TOLERANCE {
+				return ReferencePoint::BottomCenter;
+			} else if (input.x - 1.).abs() < TOLERANCE {
+				return ReferencePoint::BottomRight;
+			}
+		}
+		ReferencePoint::None
+	}
+}

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

@@ -2,217 +2,13 @@
 
 use crate::Color;
 use crate::consts::{LAYER_OUTLINE_STROKE_COLOR, LAYER_OUTLINE_STROKE_WEIGHT};
+pub use crate::gradient::*;
 use crate::renderer::{RenderParams, format_transform_matrix};
 use dyn_any::DynAny;
 use glam::{DAffine2, DVec2};
 use std::fmt::Write;
 
-#[derive(Default, PartialEq, Eq, Clone, Copy, Debug, Hash, serde::Serialize, serde::Deserialize, DynAny, specta::Type, node_macro::ChoiceType)]
-#[widget(Radio)]
-pub enum GradientType {
-	#[default]
-	Linear,
-	Radial,
-}
-
-// TODO: Someday we could switch this to a Box[T] to avoid over-allocation
-// TODO: Use linear not gamma colors
-/// A list of colors associated with positions (in the range 0 to 1) along a gradient.
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, DynAny, specta::Type)]
-pub struct GradientStops(Vec<(f64, Color)>);
-
-impl std::hash::Hash for GradientStops {
-	fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-		self.0.len().hash(state);
-		self.0.iter().for_each(|(position, color)| {
-			position.to_bits().hash(state);
-			color.hash(state);
-		});
-	}
-}
-
-impl Default for GradientStops {
-	fn default() -> Self {
-		Self(vec![(0., Color::BLACK), (1., Color::WHITE)])
-	}
-}
-
-impl IntoIterator for GradientStops {
-	type Item = (f64, Color);
-	type IntoIter = std::vec::IntoIter<(f64, Color)>;
-
-	fn into_iter(self) -> Self::IntoIter {
-		self.0.into_iter()
-	}
-}
-
-impl<'a> IntoIterator for &'a GradientStops {
-	type Item = &'a (f64, Color);
-	type IntoIter = std::slice::Iter<'a, (f64, Color)>;
-
-	fn into_iter(self) -> Self::IntoIter {
-		self.0.iter()
-	}
-}
-
-impl std::ops::Index<usize> for GradientStops {
-	type Output = (f64, Color);
-
-	fn index(&self, index: usize) -> &Self::Output {
-		&self.0[index]
-	}
-}
-
-impl std::ops::Deref for GradientStops {
-	type Target = Vec<(f64, Color)>;
-
-	fn deref(&self) -> &Self::Target {
-		&self.0
-	}
-}
-
-impl std::ops::DerefMut for GradientStops {
-	fn deref_mut(&mut self) -> &mut Self::Target {
-		&mut self.0
-	}
-}
-
-impl GradientStops {
-	pub fn new(stops: Vec<(f64, Color)>) -> Self {
-		let mut stops = Self(stops);
-		stops.sort();
-		stops
-	}
-
-	pub fn evaluate(&self, t: f64) -> Color {
-		if self.0.is_empty() {
-			return Color::BLACK;
-		}
-
-		if t <= self.0[0].0 {
-			return self.0[0].1;
-		}
-		if t >= self.0[self.0.len() - 1].0 {
-			return self.0[self.0.len() - 1].1;
-		}
-
-		for i in 0..self.0.len() - 1 {
-			let (t1, c1) = self.0[i];
-			let (t2, c2) = self.0[i + 1];
-			if t >= t1 && t <= t2 {
-				let normalized_t = (t - t1) / (t2 - t1);
-				return c1.lerp(&c2, normalized_t as f32);
-			}
-		}
-
-		Color::BLACK
-	}
-
-	pub fn sort(&mut self) {
-		self.0.sort_unstable_by(|a, b| a.0.partial_cmp(&b.0).unwrap());
-	}
-
-	pub fn reversed(&self) -> Self {
-		Self(self.0.iter().rev().map(|(position, color)| (1. - position, *color)).collect())
-	}
-
-	pub fn map_colors<F: Fn(&Color) -> Color>(&self, f: F) -> Self {
-		Self(self.0.iter().map(|(position, color)| (*position, f(color))).collect())
-	}
-}
-
-/// A gradient fill.
-///
-/// Contains the start and end points, along with the colors at varying points along the length.
-#[repr(C)]
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, DynAny, specta::Type)]
-pub struct Gradient {
-	pub stops: GradientStops,
-	pub gradient_type: GradientType,
-	pub start: DVec2,
-	pub end: DVec2,
-	pub transform: DAffine2,
-}
-
-impl Default for Gradient {
-	fn default() -> Self {
-		Self {
-			stops: GradientStops::default(),
-			gradient_type: GradientType::Linear,
-			start: DVec2::new(0., 0.5),
-			end: DVec2::new(1., 0.5),
-			transform: DAffine2::IDENTITY,
-		}
-	}
-}
-
-impl std::hash::Hash for Gradient {
-	fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-		self.stops.0.len().hash(state);
-		[].iter()
-			.chain(self.start.to_array().iter())
-			.chain(self.end.to_array().iter())
-			.chain(self.transform.to_cols_array().iter())
-			.chain(self.stops.0.iter().map(|(position, _)| position))
-			.for_each(|x| x.to_bits().hash(state));
-		self.stops.0.iter().for_each(|(_, color)| color.hash(state));
-		self.gradient_type.hash(state);
-	}
-}
-
-impl std::fmt::Display for Gradient {
-	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-		let round = |x: f64| (x * 1e3).round() / 1e3;
-		let stops = self
-			.stops
-			.0
-			.iter()
-			.map(|(position, color)| format!("[{}%: #{}]", round(position * 100.), color.to_rgba_hex_srgb()))
-			.collect::<Vec<_>>()
-			.join(", ");
-		write!(f, "{} Gradient: {stops}", self.gradient_type)
-	}
-}
-
 impl Gradient {
-	/// Constructs a new gradient with the colors at 0 and 1 specified.
-	pub fn new(start: DVec2, start_color: Color, end: DVec2, end_color: Color, transform: DAffine2, gradient_type: GradientType) -> Self {
-		Gradient {
-			start,
-			end,
-			stops: GradientStops::new(vec![(0., start_color.to_gamma_srgb()), (1., end_color.to_gamma_srgb())]),
-			transform,
-			gradient_type,
-		}
-	}
-
-	pub fn lerp(&self, other: &Self, time: f64) -> Self {
-		let start = self.start + (other.start - self.start) * time;
-		let end = self.end + (other.end - self.end) * time;
-		let transform = self.transform;
-		let stops = self
-			.stops
-			.0
-			.iter()
-			.zip(other.stops.0.iter())
-			.map(|((a_pos, a_color), (b_pos, b_color))| {
-				let position = a_pos + (b_pos - a_pos) * time;
-				let color = a_color.lerp(b_color, time as f32);
-				(position, color)
-			})
-			.collect::<Vec<_>>();
-		let stops = GradientStops::new(stops);
-		let gradient_type = if time < 0.5 { self.gradient_type } else { other.gradient_type };
-
-		Self {
-			start,
-			end,
-			transform,
-			stops,
-			gradient_type,
-		}
-	}
-
 	/// Adds the gradient def through mutating the first argument, returning the gradient ID.
 	fn render_defs(&self, svg_defs: &mut String, element_transform: DAffine2, stroke_transform: DAffine2, bounds: [DVec2; 2], transformed_bounds: [DVec2; 2], _render_params: &RenderParams) -> u64 {
 		// TODO: Figure out how to use `self.transform` as part of the gradient transform, since that field (`Gradient::transform`) is currently never read from, it's only written to.
@@ -268,44 +64,6 @@ impl Gradient {
 
 		gradient_id
 	}
-
-	/// Insert a stop into the gradient, the index if successful
-	pub fn insert_stop(&mut self, mouse: DVec2, transform: DAffine2) -> Option<usize> {
-		// Transform the start and end positions to the same coordinate space as the mouse.
-		let (start, end) = (transform.transform_point2(self.start), transform.transform_point2(self.end));
-
-		// Calculate the new position by finding the closest point on the line
-		let new_position = ((end - start).angle_to(mouse - start)).cos() * start.distance(mouse) / start.distance(end);
-
-		// Don't insert point past end of line
-		if !(0. ..=1.).contains(&new_position) {
-			return None;
-		}
-
-		// Compute the color of the inserted stop
-		let get_color = |index: usize, time: f64| match (self.stops.0[index].1, self.stops.0.get(index + 1).map(|(_, c)| *c)) {
-			// Lerp between the nearest colors if applicable
-			(a, Some(b)) => a.lerp(
-				&b,
-				((time - self.stops.0[index].0) / self.stops.0.get(index + 1).map(|end| end.0 - self.stops.0[index].0).unwrap_or_default()) as f32,
-			),
-			// Use the start or the end color if applicable
-			(v, _) => v,
-		};
-
-		// Compute the correct index to keep the positions in order
-		let mut index = 0;
-		while self.stops.0.len() > index && self.stops.0[index].0 <= new_position {
-			index += 1;
-		}
-
-		let new_color = get_color(index - 1, new_position);
-
-		// Insert the new stop
-		self.stops.0.insert(index, (new_position, new_color));
-
-		Some(index)
-	}
 }
 
 /// Describes the fill of a layer.

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

@@ -5,7 +5,7 @@ mod modification;
 use super::misc::{dvec2_to_point, point_to_dvec2};
 use super::style::{PathStyle, Stroke};
 use crate::instances::Instances;
-use crate::renderer::{ClickTargetType, FreePoint};
+use crate::vector::click_target::{ClickTargetType, FreePoint};
 use crate::{AlphaBlending, Color, GraphicGroupTable};
 pub use attributes::*;
 use bezier_rs::ManipulatorGroup;