move ClickTarget code to mod vector::click_target

Author: Firestar99

editor/src/messages/portfolio/document/document_message.rs

@@ -11,8 +11,8 @@ use graph_craft::document::NodeId;
 use graphene_std::Color;
 use graphene_std::raster::BlendMode;
 use graphene_std::raster::Image;
-use graphene_std::renderer::ClickTarget;
 use graphene_std::transform::Footprint;
+use graphene_std::vector::click_target::ClickTarget;
 use graphene_std::vector::style::ViewMode;
 
 #[impl_message(Message, PortfolioMessage, Document)]

editor/src/messages/portfolio/document/document_message_handler.rs

@@ -29,9 +29,10 @@ use bezier_rs::Subpath;
 use glam::{DAffine2, DVec2, IVec2};
 use graph_craft::document::value::TaggedValue;
 use graph_craft::document::{NodeId, NodeInput, NodeNetwork, OldNodeNetwork};
+use graphene_std::math::quad::Quad;
 use graphene_std::raster::BlendMode;
 use graphene_std::raster_types::{Raster, RasterDataTable};
-use graphene_std::renderer::{ClickTarget, ClickTargetType, Quad};
+use graphene_std::vector::click_target::{ClickTarget, ClickTargetType};
 use graphene_std::vector::style::ViewMode;
 use graphene_std::vector::{PointId, path_bool_lib};
 use std::time::Duration;

editor/src/messages/portfolio/document/overlays/utility_types.rs

@@ -9,8 +9,8 @@ use core::borrow::Borrow;
 use core::f64::consts::{FRAC_PI_2, TAU};
 use glam::{DAffine2, DVec2};
 use graphene_std::Color;
-use graphene_std::renderer::ClickTargetType;
-use graphene_std::renderer::Quad;
+use graphene_std::math::quad::Quad;
+use graphene_std::vector::click_target::ClickTargetType;
 use graphene_std::vector::{PointId, SegmentId, VectorData};
 use std::collections::HashMap;
 use wasm_bindgen::{JsCast, JsValue};

editor/src/messages/portfolio/document/utility_types/document_metadata.rs

@@ -3,8 +3,9 @@ use crate::messages::portfolio::document::graph_operation::transform_utils;
 use crate::messages::portfolio::document::graph_operation::utility_types::ModifyInputsContext;
 use glam::{DAffine2, DVec2};
 use graph_craft::document::NodeId;
-use graphene_std::renderer::{ClickTarget, ClickTargetType, Quad};
+use graphene_std::math::quad::Quad;
 use graphene_std::transform::Footprint;
+use graphene_std::vector::click_target::{ClickTarget, ClickTargetType};
 use graphene_std::vector::{PointId, VectorData};
 use std::collections::{HashMap, HashSet};
 use std::num::NonZeroU64;

editor/src/messages/portfolio/document/utility_types/network_interface.rs

@@ -12,8 +12,9 @@ use glam::{DAffine2, DVec2, IVec2};
 use graph_craft::document::value::TaggedValue;
 use graph_craft::document::{DocumentNode, DocumentNodeImplementation, NodeId, NodeInput, NodeNetwork, OldDocumentNodeImplementation, OldNodeNetwork};
 use graph_craft::{Type, concrete};
-use graphene_std::renderer::{ClickTarget, ClickTargetType, Quad};
+use graphene_std::math::quad::Quad;
 use graphene_std::transform::Footprint;
+use graphene_std::vector::click_target::{ClickTarget, ClickTargetType};
 use graphene_std::vector::{PointId, VectorData, VectorModificationType};
 use interpreted_executor::dynamic_executor::ResolvedDocumentNodeTypes;
 use interpreted_executor::node_registry::NODE_REGISTRY;

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

@@ -13,7 +13,7 @@ use bezier_rs::Subpath;
 use glam::{DAffine2, DMat2, DVec2};
 use graph_craft::document::NodeInput;
 use graph_craft::document::value::TaggedValue;
-use graphene_std::renderer::ClickTargetType;
+use graphene_std::vector::click_target::ClickTargetType;
 use graphene_std::vector::misc::dvec2_to_point;
 use kurbo::{BezPath, PathEl, Shape};
 use std::collections::VecDeque;

node-graph/gcore/src/graphic_element/renderer.rs

@@ -1,53 +1,23 @@
 use crate::instances::Instance;
-use crate::math::math_ext::QuadExt;
 pub use crate::math::quad::Quad;
 pub use crate::math::rect::Rect;
 use crate::raster::{BlendMode, Image};
 use crate::raster_types::{CPU, GPU, RasterDataTable};
 use crate::transform::{Footprint, Transform};
 use crate::uuid::{NodeId, generate_uuid};
+use crate::vector::VectorDataTable;
+use crate::vector::click_target::{ClickTarget, FreePoint};
 use crate::vector::style::{Fill, Stroke, StrokeAlign, ViewMode};
-use crate::vector::{PointId, VectorDataTable};
 use crate::{Artboard, ArtboardGroupTable, Color, GraphicElement, GraphicGroupTable};
 use bezier_rs::Subpath;
 use dyn_any::DynAny;
-use glam::{DAffine2, DMat2, DVec2};
+use glam::{DAffine2, DVec2};
 use num_traits::Zero;
 use std::collections::{HashMap, HashSet};
 use std::fmt::Write;
 #[cfg(feature = "vello")]
 use vello::*;
 
-#[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]>,
-}
-
 #[derive(Clone, Copy, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
 enum MaskType {
 	Clip,
@@ -71,133 +41,6 @@ impl MaskType {
 	}
 }
 
-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
-		}
-	}
-}
-
 /// Mutable state used whilst rendering to an SVG
 pub struct SvgRender {
 	pub svg: Vec<SvgSegment>,