WIP

node-graph/gcore/Cargo.toml

@@ -27,13 +27,11 @@ rustc-hash = { workspace = true }
 dyn-any = { workspace = true }
 ctor = { workspace = true }
 rand_chacha = { workspace = true }
-bezier-rs = { workspace = true }
 specta = { workspace = true }
 rustybuzz = { workspace = true }
 image = { workspace = true }
 half = { workspace = true }
 tinyvec = { workspace = true }
-kurbo = { workspace = true }
 log = { workspace = true }
 base64 = { workspace = true }
 

node-graph/gcore/src/blending.rs

@@ -1,4 +1,5 @@
 use dyn_any::DynAny;
+use log::warn;
 use std::hash::Hash;
 
 #[derive(Copy, Clone, Debug, PartialEq, DynAny, specta::Type, serde::Serialize, serde::Deserialize)]

node-graph/gcore/src/bounds.rs

@@ -1,4 +1,4 @@
-use crate::Color;
+use crate::color::Color;
 use glam::{DAffine2, DVec2};
 
 pub trait BoundingBox {

node-graph/gcore/src/color/color_traits.rs

@@ -5,8 +5,6 @@ use std::fmt::Debug;
 #[cfg(target_arch = "spirv")]
 use spirv_std::num_traits::float::Float;
 
-pub use crate::blending::*;
-
 pub trait Linear {
 	fn from_f32(x: f32) -> Self;
 	fn to_f32(self) -> f32;

node-graph/gcore/src/consts.rs

@@ -1,4 +1,4 @@
-use crate::raster::Color;
+use crate::color::Color;
 
 // RENDERING
 pub const LAYER_OUTLINE_STROKE_COLOR: Color = Color::BLACK;

node-graph/gcore/src/debug.rs

@@ -1,5 +1,5 @@
-use crate::raster_types::{CPU, RasterDataTable};
-use crate::{Color, Ctx};
+use crate::color::Color;
+use crate::context::Ctx;
 
 /// Meant for debugging purposes, not general use. Returns the size of the input type in bytes.
 #[node_macro::node(category("Debug"))]
@@ -19,8 +19,4 @@ fn unwrap<T: Default>(_: impl Ctx, #[implementations(Option<f64>, Option<f32>, O
 	input.unwrap_or_default()
 }
 
-/// Meant for debugging purposes, not general use. Clones the input value.
-#[node_macro::node(category("Debug"))]
-fn clone<'i, T: Clone + 'i>(_: impl Ctx, #[implementations(&RasterDataTable<CPU>)] value: &'i T) -> T {
-	value.clone()
-}
+// FIXME am I allowed to just remove clone?

node-graph/gcore/src/extract_xy.rs

@@ -1,4 +1,4 @@
-use crate::Ctx;
+use crate::context::Ctx;
 use dyn_any::DynAny;
 use glam::{DVec2, IVec2, UVec2};
 

node-graph/gcore/src/gradient.rs

@@ -1,4 +1,4 @@
-use crate::Color;
+use crate::color::Color;
 use dyn_any::DynAny;
 use glam::{DAffine2, DVec2};
 

node-graph/gcore/src/graphic_element.rs

@@ -1,370 +0,0 @@
-use crate::blending::AlphaBlending;
-use crate::bounds::BoundingBox;
-use crate::color::Color;
-use crate::instances::{Instance, Instances};
-use crate::math::quad::Quad;
-use crate::raster::image::Image;
-use crate::raster_types::{CPU, GPU, Raster, RasterDataTable};
-use crate::uuid::NodeId;
-use crate::vector::{VectorData, VectorDataTable};
-use dyn_any::DynAny;
-use glam::{DAffine2, DVec2, IVec2};
-use std::hash::Hash;
-
-// TODO: Eventually remove this migration document upgrade code
-pub fn migrate_graphic_group<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Result<GraphicGroupTable, D::Error> {
-	use serde::Deserialize;
-
-	#[derive(Clone, Debug, PartialEq, DynAny, Default, serde::Serialize, serde::Deserialize)]
-	pub struct OldGraphicGroup {
-		elements: Vec<(GraphicElement, Option<NodeId>)>,
-		transform: DAffine2,
-		alpha_blending: AlphaBlending,
-	}
-	#[derive(Clone, Debug, PartialEq, DynAny, Default, serde::Serialize, serde::Deserialize)]
-	pub struct GraphicGroup {
-		elements: Vec<(GraphicElement, Option<NodeId>)>,
-	}
-	pub type OldGraphicGroupTable = Instances<GraphicGroup>;
-
-	#[derive(serde::Serialize, serde::Deserialize)]
-	#[serde(untagged)]
-	enum EitherFormat {
-		OldGraphicGroup(OldGraphicGroup),
-		InstanceTable(serde_json::Value),
-	}
-
-	Ok(match EitherFormat::deserialize(deserializer)? {
-		EitherFormat::OldGraphicGroup(old) => {
-			let mut graphic_group_table = GraphicGroupTable::default();
-			for (graphic_element, source_node_id) in old.elements {
-				graphic_group_table.push(Instance {
-					instance: graphic_element,
-					transform: old.transform,
-					alpha_blending: old.alpha_blending,
-					source_node_id,
-				});
-			}
-			graphic_group_table
-		}
-		EitherFormat::InstanceTable(value) => {
-			// Try to deserialize as either table format
-			if let Ok(old_table) = serde_json::from_value::<OldGraphicGroupTable>(value.clone()) {
-				let mut graphic_group_table = GraphicGroupTable::default();
-				for instance in old_table.instance_ref_iter() {
-					for (graphic_element, source_node_id) in &instance.instance.elements {
-						graphic_group_table.push(Instance {
-							instance: graphic_element.clone(),
-							transform: *instance.transform,
-							alpha_blending: *instance.alpha_blending,
-							source_node_id: *source_node_id,
-						});
-					}
-				}
-				graphic_group_table
-			} else if let Ok(new_table) = serde_json::from_value::<GraphicGroupTable>(value) {
-				new_table
-			} else {
-				return Err(serde::de::Error::custom("Failed to deserialize GraphicGroupTable"));
-			}
-		}
-	})
-}
-
-// TODO: Rename to GraphicElementTable
-pub type GraphicGroupTable = Instances<GraphicElement>;
-
-impl From<VectorData> for GraphicGroupTable {
-	fn from(vector_data: VectorData) -> Self {
-		Self::new(GraphicElement::VectorData(VectorDataTable::new(vector_data)))
-	}
-}
-impl From<VectorDataTable> for GraphicGroupTable {
-	fn from(vector_data: VectorDataTable) -> Self {
-		Self::new(GraphicElement::VectorData(vector_data))
-	}
-}
-impl From<Image<Color>> for GraphicGroupTable {
-	fn from(image: Image<Color>) -> Self {
-		Self::new(GraphicElement::RasterDataCPU(RasterDataTable::<CPU>::new(Raster::new_cpu(image))))
-	}
-}
-impl From<RasterDataTable<CPU>> for GraphicGroupTable {
-	fn from(raster_data_table: RasterDataTable<CPU>) -> Self {
-		Self::new(GraphicElement::RasterDataCPU(raster_data_table))
-	}
-}
-impl From<RasterDataTable<GPU>> for GraphicGroupTable {
-	fn from(raster_data_table: RasterDataTable<GPU>) -> Self {
-		Self::new(GraphicElement::RasterDataGPU(raster_data_table))
-	}
-}
-
-/// The possible forms of graphical content held in a Vec by the `elements` field of [`GraphicElement`].
-#[derive(Clone, Debug, Hash, PartialEq, DynAny, serde::Serialize, serde::Deserialize)]
-pub enum GraphicElement {
-	/// Equivalent to the SVG <g> tag: https://developer.mozilla.org/en-US/docs/Web/SVG/Element/g
-	GraphicGroup(GraphicGroupTable),
-	/// A vector shape, equivalent to the SVG <path> tag: https://developer.mozilla.org/en-US/docs/Web/SVG/Element/path
-	VectorData(VectorDataTable),
-	RasterDataCPU(RasterDataTable<CPU>),
-	RasterDataGPU(RasterDataTable<GPU>),
-}
-
-impl Default for GraphicElement {
-	fn default() -> Self {
-		Self::GraphicGroup(GraphicGroupTable::default())
-	}
-}
-
-impl GraphicElement {
-	pub fn as_group(&self) -> Option<&GraphicGroupTable> {
-		match self {
-			GraphicElement::GraphicGroup(group) => Some(group),
-			_ => None,
-		}
-	}
-
-	pub fn as_group_mut(&mut self) -> Option<&mut GraphicGroupTable> {
-		match self {
-			GraphicElement::GraphicGroup(group) => Some(group),
-			_ => None,
-		}
-	}
-
-	pub fn as_vector_data(&self) -> Option<&VectorDataTable> {
-		match self {
-			GraphicElement::VectorData(data) => Some(data),
-			_ => None,
-		}
-	}
-
-	pub fn as_vector_data_mut(&mut self) -> Option<&mut VectorDataTable> {
-		match self {
-			GraphicElement::VectorData(data) => Some(data),
-			_ => None,
-		}
-	}
-
-	pub fn as_raster(&self) -> Option<&RasterDataTable<CPU>> {
-		match self {
-			GraphicElement::RasterDataCPU(raster) => Some(raster),
-			_ => None,
-		}
-	}
-
-	pub fn as_raster_mut(&mut self) -> Option<&mut RasterDataTable<CPU>> {
-		match self {
-			GraphicElement::RasterDataCPU(raster) => Some(raster),
-			_ => None,
-		}
-	}
-
-	pub fn had_clip_enabled(&self) -> bool {
-		match self {
-			GraphicElement::VectorData(data) => data.instance_ref_iter().all(|instance| instance.alpha_blending.clip),
-			GraphicElement::GraphicGroup(data) => data.instance_ref_iter().all(|instance| instance.alpha_blending.clip),
-			GraphicElement::RasterDataCPU(data) => data.instance_ref_iter().all(|instance| instance.alpha_blending.clip),
-			GraphicElement::RasterDataGPU(data) => data.instance_ref_iter().all(|instance| instance.alpha_blending.clip),
-		}
-	}
-
-	pub fn can_reduce_to_clip_path(&self) -> bool {
-		match self {
-			GraphicElement::VectorData(vector_data_table) => vector_data_table.instance_ref_iter().all(|instance_data| {
-				let style = &instance_data.instance.style;
-				let alpha_blending = &instance_data.alpha_blending;
-				(alpha_blending.opacity > 1. - f32::EPSILON) && style.fill().is_opaque() && style.stroke().is_none_or(|stroke| !stroke.has_renderable_stroke())
-			}),
-			_ => false,
-		}
-	}
-}
-
-impl BoundingBox for GraphicElement {
-	fn bounding_box(&self, transform: DAffine2, include_stroke: bool) -> Option<[DVec2; 2]> {
-		match self {
-			GraphicElement::VectorData(vector_data) => vector_data.bounding_box(transform, include_stroke),
-			GraphicElement::RasterDataCPU(raster) => raster.bounding_box(transform, include_stroke),
-			GraphicElement::RasterDataGPU(raster) => raster.bounding_box(transform, include_stroke),
-			GraphicElement::GraphicGroup(graphic_group) => graphic_group.bounding_box(transform, include_stroke),
-		}
-	}
-}
-
-impl BoundingBox for GraphicGroupTable {
-	fn bounding_box(&self, transform: DAffine2, include_stroke: bool) -> Option<[DVec2; 2]> {
-		self.instance_ref_iter()
-			.filter_map(|element| element.instance.bounding_box(transform * *element.transform, include_stroke))
-			.reduce(Quad::combine_bounds)
-	}
-}
-
-impl<'de> serde::Deserialize<'de> for Raster<CPU> {
-	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-	where
-		D: serde::Deserializer<'de>,
-	{
-		Ok(Raster::new_cpu(Image::deserialize(deserializer)?))
-	}
-}
-
-impl serde::Serialize for Raster<CPU> {
-	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-	where
-		S: serde::Serializer,
-	{
-		self.data().serialize(serializer)
-	}
-}
-impl<'de> serde::Deserialize<'de> for Raster<GPU> {
-	fn deserialize<D>(_deserializer: D) -> Result<Self, D::Error>
-	where
-		D: serde::Deserializer<'de>,
-	{
-		unimplemented!()
-	}
-}
-
-impl serde::Serialize for Raster<GPU> {
-	fn serialize<S>(&self, _serializer: S) -> Result<S::Ok, S::Error>
-	where
-		S: serde::Serializer,
-	{
-		unimplemented!()
-	}
-}
-
-/// Some [`ArtboardData`] with some optional clipping bounds that can be exported.
-#[derive(Clone, Debug, Hash, PartialEq, DynAny, serde::Serialize, serde::Deserialize)]
-pub struct Artboard {
-	pub graphic_group: GraphicGroupTable,
-	pub label: String,
-	pub location: IVec2,
-	pub dimensions: IVec2,
-	pub background: Color,
-	pub clip: bool,
-}
-
-impl Default for Artboard {
-	fn default() -> Self {
-		Self::new(IVec2::ZERO, IVec2::new(1920, 1080))
-	}
-}
-
-impl Artboard {
-	pub fn new(location: IVec2, dimensions: IVec2) -> Self {
-		Self {
-			graphic_group: GraphicGroupTable::default(),
-			label: "Artboard".to_string(),
-			location: location.min(location + dimensions),
-			dimensions: dimensions.abs(),
-			background: Color::WHITE,
-			clip: false,
-		}
-	}
-}
-
-impl BoundingBox for Artboard {
-	fn bounding_box(&self, transform: DAffine2, include_stroke: bool) -> Option<[DVec2; 2]> {
-		let artboard_bounds = (transform * Quad::from_box([self.location.as_dvec2(), self.location.as_dvec2() + self.dimensions.as_dvec2()])).bounding_box();
-		if self.clip {
-			Some(artboard_bounds)
-		} else {
-			[self.graphic_group.bounding_box(transform, include_stroke), Some(artboard_bounds)]
-				.into_iter()
-				.flatten()
-				.reduce(Quad::combine_bounds)
-		}
-	}
-}
-
-// TODO: Eventually remove this migration document upgrade code
-pub fn migrate_artboard_group<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Result<ArtboardGroupTable, D::Error> {
-	use serde::Deserialize;
-
-	#[derive(Clone, Default, Debug, Hash, PartialEq, DynAny, serde::Serialize, serde::Deserialize)]
-	pub struct ArtboardGroup {
-		pub artboards: Vec<(Artboard, Option<NodeId>)>,
-	}
-
-	#[derive(serde::Serialize, serde::Deserialize)]
-	#[serde(untagged)]
-	enum EitherFormat {
-		ArtboardGroup(ArtboardGroup),
-		ArtboardGroupTable(ArtboardGroupTable),
-	}
-
-	Ok(match EitherFormat::deserialize(deserializer)? {
-		EitherFormat::ArtboardGroup(artboard_group) => {
-			let mut table = ArtboardGroupTable::default();
-			for (artboard, source_node_id) in artboard_group.artboards {
-				table.push(Instance {
-					instance: artboard,
-					transform: DAffine2::IDENTITY,
-					alpha_blending: AlphaBlending::default(),
-					source_node_id,
-				});
-			}
-			table
-		}
-		EitherFormat::ArtboardGroupTable(artboard_group_table) => artboard_group_table,
-	})
-}
-
-pub type ArtboardGroupTable = Instances<Artboard>;
-
-impl BoundingBox for ArtboardGroupTable {
-	fn bounding_box(&self, transform: DAffine2, include_stroke: bool) -> Option<[DVec2; 2]> {
-		self.instance_ref_iter()
-			.filter_map(|instance| instance.instance.bounding_box(transform, include_stroke))
-			.reduce(Quad::combine_bounds)
-	}
-}
-
-// TODO: Remove this one
-impl From<Image<Color>> for GraphicElement {
-	fn from(raster_data: Image<Color>) -> Self {
-		GraphicElement::RasterDataCPU(RasterDataTable::<CPU>::new(Raster::new_cpu(raster_data)))
-	}
-}
-impl From<RasterDataTable<CPU>> for GraphicElement {
-	fn from(raster_data: RasterDataTable<CPU>) -> Self {
-		GraphicElement::RasterDataCPU(raster_data)
-	}
-}
-impl From<RasterDataTable<GPU>> for GraphicElement {
-	fn from(raster_data: RasterDataTable<GPU>) -> Self {
-		GraphicElement::RasterDataGPU(raster_data)
-	}
-}
-impl From<Raster<CPU>> for GraphicElement {
-	fn from(raster_data: Raster<CPU>) -> Self {
-		GraphicElement::RasterDataCPU(RasterDataTable::new(raster_data))
-	}
-}
-impl From<Raster<GPU>> for GraphicElement {
-	fn from(raster_data: Raster<GPU>) -> Self {
-		GraphicElement::RasterDataGPU(RasterDataTable::new(raster_data))
-	}
-}
-// TODO: Remove this one
-impl From<VectorData> for GraphicElement {
-	fn from(vector_data: VectorData) -> Self {
-		GraphicElement::VectorData(VectorDataTable::new(vector_data))
-	}
-}
-impl From<VectorDataTable> for GraphicElement {
-	fn from(vector_data: VectorDataTable) -> Self {
-		GraphicElement::VectorData(vector_data)
-	}
-}
-impl From<GraphicGroupTable> for GraphicElement {
-	fn from(graphic_group: GraphicGroupTable) -> Self {
-		GraphicElement::GraphicGroup(graphic_group)
-	}
-}
-
-pub trait ToGraphicElement {
-	fn to_graphic_element(&self) -> GraphicElement;
-}

node-graph/gcore/src/instances.rs

@@ -1,4 +1,4 @@
-use crate::AlphaBlending;
+use crate::blending::AlphaBlending;
 use crate::uuid::NodeId;
 use dyn_any::StaticType;
 use glam::DAffine2;

node-graph/gcore/src/lib.rs

@@ -1,6 +1,3 @@
-#[macro_use]
-extern crate log;
-
 pub mod blending;
 pub mod bounds;
 pub mod color;
@@ -10,35 +7,26 @@ pub mod debug;
 pub mod extract_xy;
 pub mod generic;
 pub mod gradient;
-mod graphic_element;
 pub mod instances;
 pub mod math;
 pub mod memo;
 pub mod misc;
 pub mod ops;
-pub mod raster;
-pub mod raster_types;
 pub mod registry;
 pub mod structural;
-pub mod text;
 pub mod transform;
 pub mod uuid;
 pub mod value;
-pub mod vector;
 
 pub use crate as graphene_core;
-pub use blending::*;
-pub use context::*;
 pub use ctor;
 pub use dyn_any::{StaticTypeSized, WasmNotSend, WasmNotSync};
-pub use graphic_element::*;
 pub use memo::MemoHash;
 pub use num_traits;
-pub use raster::Color;
 use std::any::TypeId;
+pub use std::borrow::Cow;
 use std::future::Future;
 use std::pin::Pin;
-pub use types::Cow;
 
 // pub trait Node: for<'n> NodeIO<'n> {
 /// The node trait allows for defining any node. Nodes can only take one call argument input, however they can store references to other nodes inside the struct.

node-graph/gcore/src/math/math_ext.rs

@@ -1,25 +0,0 @@
-use crate::math::quad::Quad;
-use crate::math::rect::Rect;
-use bezier_rs::Bezier;
-
-pub trait QuadExt {
-	/// Get all the edges in the rect as linear bezier curves
-	fn bezier_lines(&self) -> impl Iterator<Item = Bezier> + '_;
-}
-
-impl QuadExt for Quad {
-	fn bezier_lines(&self) -> impl Iterator<Item = Bezier> + '_ {
-		self.all_edges().into_iter().map(|[start, end]| Bezier::from_linear_dvec2(start, end))
-	}
-}
-
-pub trait RectExt {
-	/// Get all the edges in the quad as linear bezier curves
-	fn bezier_lines(&self) -> impl Iterator<Item = Bezier> + '_;
-}
-
-impl RectExt for Rect {
-	fn bezier_lines(&self) -> impl Iterator<Item = Bezier> + '_ {
-		self.edges().into_iter().map(|[start, end]| Bezier::from_linear_dvec2(start, end))
-	}
-}

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

@@ -1,4 +1,3 @@
 pub mod bbox;
-pub mod math_ext;
 pub mod quad;
 pub mod rect;

node-graph/gcore/src/raster.rs

@@ -1,83 +0,0 @@
-use crate::GraphicGroupTable;
-pub use crate::color::*;
-use crate::raster_types::{CPU, RasterDataTable};
-use crate::vector::VectorDataTable;
-use std::fmt::Debug;
-
-#[cfg(target_arch = "spirv")]
-use spirv_std::num_traits::float::Float;
-
-/// as to not yet rename all references
-pub mod color {
-	pub use super::*;
-}
-
-pub mod image;
-
-pub use self::image::Image;
-
-pub trait Bitmap {
-	type Pixel: Pixel;
-	fn width(&self) -> u32;
-	fn height(&self) -> u32;
-	fn dimensions(&self) -> (u32, u32) {
-		(self.width(), self.height())
-	}
-	fn dim(&self) -> (u32, u32) {
-		self.dimensions()
-	}
-	fn get_pixel(&self, x: u32, y: u32) -> Option<Self::Pixel>;
-}
-
-impl<T: Bitmap> Bitmap for &T {
-	type Pixel = T::Pixel;
-
-	fn width(&self) -> u32 {
-		(**self).width()
-	}
-
-	fn height(&self) -> u32 {
-		(**self).height()
-	}
-
-	fn get_pixel(&self, x: u32, y: u32) -> Option<Self::Pixel> {
-		(**self).get_pixel(x, y)
-	}
-}
-
-impl<T: Bitmap> Bitmap for &mut T {
-	type Pixel = T::Pixel;
-
-	fn width(&self) -> u32 {
-		(**self).width()
-	}
-
-	fn height(&self) -> u32 {
-		(**self).height()
-	}
-
-	fn get_pixel(&self, x: u32, y: u32) -> Option<Self::Pixel> {
-		(**self).get_pixel(x, y)
-	}
-}
-
-pub trait BitmapMut: Bitmap {
-	fn get_pixel_mut(&mut self, x: u32, y: u32) -> Option<&mut Self::Pixel>;
-	fn set_pixel(&mut self, x: u32, y: u32, pixel: Self::Pixel) {
-		*self.get_pixel_mut(x, y).unwrap() = pixel;
-	}
-	fn map_pixels<F: Fn(Self::Pixel) -> Self::Pixel>(&mut self, map_fn: F) {
-		for y in 0..self.height() {
-			for x in 0..self.width() {
-				let pixel = self.get_pixel(x, y).unwrap();
-				self.set_pixel(x, y, map_fn(pixel));
-			}
-		}
-	}
-}
-
-impl<T: BitmapMut + Bitmap> BitmapMut for &mut T {
-	fn get_pixel_mut(&mut self, x: u32, y: u32) -> Option<&mut Self::Pixel> {
-		(*self).get_pixel_mut(x, y)
-	}
-}

node-graph/gcore/src/raster/image.rs

@@ -1,503 +0,0 @@
-use super::Color;
-use crate::AlphaBlending;
-use crate::color::float_to_srgb_u8;
-use crate::instances::{Instance, Instances};
-use crate::raster_types::Raster;
-use core::hash::{Hash, Hasher};
-use dyn_any::{DynAny, StaticType};
-use glam::{DAffine2, DVec2};
-use std::vec::Vec;
-
-mod base64_serde {
-	//! Basic wrapper for [`serde`] to perform [`base64`] encoding
-
-	use super::super::Pixel;
-	use base64::Engine;
-	use serde::{Deserialize, Deserializer, Serialize, Serializer};
-
-	pub fn as_base64<S: Serializer, P: Pixel>(key: &[P], serializer: S) -> Result<S::Ok, S::Error> {
-		let u8_data = bytemuck::cast_slice(key);
-		let string = base64::engine::general_purpose::STANDARD.encode(u8_data);
-		(key.len() as u64, string).serialize(serializer)
-	}
-
-	pub fn from_base64<'a, D: Deserializer<'a>, P: Pixel>(deserializer: D) -> Result<Vec<P>, D::Error> {
-		use serde::de::Error;
-		<(u64, &[u8])>::deserialize(deserializer)
-			.and_then(|(len, str)| {
-				let mut output: Vec<P> = vec![P::zeroed(); len as usize];
-				base64::engine::general_purpose::STANDARD
-					.decode_slice(str, bytemuck::cast_slice_mut(output.as_mut_slice()))
-					.map_err(|err| Error::custom(err.to_string()))?;
-
-				Ok(output)
-			})
-			.map_err(serde::de::Error::custom)
-	}
-}
-
-#[derive(Clone, PartialEq, Default, specta::Type, serde::Serialize, serde::Deserialize)]
-pub struct Image<P: Pixel> {
-	pub width: u32,
-	pub height: u32,
-	#[serde(serialize_with = "base64_serde::as_base64", deserialize_with = "base64_serde::from_base64")]
-	pub data: Vec<P>,
-	/// Optional: Stores a base64 string representation of the image which can be used to speed up the conversion
-	/// to an svg string. This is used as a cache in order to not have to encode the data on every graph evaluation.
-	#[serde(skip)]
-	pub base64_string: Option<String>,
-	// TODO: Add an `origin` field to store where in the local space the image is anchored.
-	// TODO: Currently it is always anchored at the top left corner at (0, 0). The bottom right corner of the new origin field would correspond to (1, 1).
-}
-
-impl<P: Pixel + Debug> Debug for Image<P> {
-	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-		let length = self.data.len();
-		f.debug_struct("Image")
-			.field("width", &self.width)
-			.field("height", &self.height)
-			.field("data", if length < 100 { &self.data } else { &length })
-			.finish()
-	}
-}
-
-unsafe impl<P> StaticType for Image<P>
-where
-	P: dyn_any::StaticTypeSized + Pixel,
-	P::Static: Pixel,
-{
-	type Static = Image<P::Static>;
-}
-
-impl<P: Copy + Pixel> Bitmap for Image<P> {
-	type Pixel = P;
-	#[inline(always)]
-	fn get_pixel(&self, x: u32, y: u32) -> Option<P> {
-		self.data.get((x + y * self.width) as usize).copied()
-	}
-	#[inline(always)]
-	fn width(&self) -> u32 {
-		self.width
-	}
-	#[inline(always)]
-	fn height(&self) -> u32 {
-		self.height
-	}
-}
-
-impl<P: Copy + Pixel> BitmapMut for Image<P> {
-	fn get_pixel_mut(&mut self, x: u32, y: u32) -> Option<&mut P> {
-		self.data.get_mut((x + y * self.width) as usize)
-	}
-}
-
-// TODO: Evaluate if this will be a problem for our use case.
-/// Warning: This is an approximation of a hash, and is not guaranteed to not collide.
-impl<P: Hash + Pixel> Hash for Image<P> {
-	fn hash<H: Hasher>(&self, state: &mut H) {
-		const HASH_SAMPLES: u64 = 1000;
-		let data_length = self.data.len() as u64;
-		self.width.hash(state);
-		self.height.hash(state);
-		for i in 0..HASH_SAMPLES.min(data_length) {
-			self.data[(i * data_length / HASH_SAMPLES) as usize].hash(state);
-		}
-	}
-}
-
-impl<P: Pixel> Image<P> {
-	pub fn new(width: u32, height: u32, color: P) -> Self {
-		Self {
-			width,
-			height,
-			data: vec![color; (width * height) as usize],
-			base64_string: None,
-		}
-	}
-}
-
-impl Image<Color> {
-	/// Generate Image from some frontend image data (the canvas pixels as u8s in a flat array)
-	pub fn from_image_data(image_data: &[u8], width: u32, height: u32) -> Self {
-		let data = image_data.chunks_exact(4).map(|v| Color::from_rgba8_srgb(v[0], v[1], v[2], v[3])).collect();
-		Image {
-			width,
-			height,
-			data,
-			base64_string: None,
-		}
-	}
-
-	pub fn to_png(&self) -> Vec<u8> {
-		use ::image::ImageEncoder;
-		let (data, width, height) = self.to_flat_u8();
-		let mut png = Vec::new();
-		let encoder = ::image::codecs::png::PngEncoder::new(&mut png);
-		encoder.write_image(&data, width, height, ::image::ExtendedColorType::Rgba8).expect("failed to encode image as png");
-		png
-	}
-}
-
-use super::*;
-impl<P: Alpha + RGB + AssociatedAlpha> Image<P>
-where
-	P::ColorChannel: Linear,
-	<P as Alpha>::AlphaChannel: Linear,
-{
-	/// Flattens each channel cast to a u8
-	pub fn to_flat_u8(&self) -> (Vec<u8>, u32, u32) {
-		let Image { width, height, data, .. } = self;
-		assert_eq!(data.len(), *width as usize * *height as usize);
-
-		// Cache the last sRGB value we computed, speeds up fills.
-		let mut last_r = 0.;
-		let mut last_r_srgb = 0u8;
-		let mut last_g = 0.;
-		let mut last_g_srgb = 0u8;
-		let mut last_b = 0.;
-		let mut last_b_srgb = 0u8;
-
-		let mut result = vec![0; data.len() * 4];
-		let mut i = 0;
-		for color in data {
-			let a = color.a().to_f32();
-			// Smaller alpha values than this would map to fully transparent
-			// anyway, avoid expensive encoding.
-			if a >= 0.5 / 255. {
-				let undo_premultiply = 1. / a;
-				let r = color.r().to_f32() * undo_premultiply;
-				let g = color.g().to_f32() * undo_premultiply;
-				let b = color.b().to_f32() * undo_premultiply;
-
-				// Compute new sRGB value if necessary.
-				if r != last_r {
-					last_r = r;
-					last_r_srgb = float_to_srgb_u8(r);
-				}
-				if g != last_g {
-					last_g = g;
-					last_g_srgb = float_to_srgb_u8(g);
-				}
-				if b != last_b {
-					last_b = b;
-					last_b_srgb = float_to_srgb_u8(b);
-				}
-
-				result[i] = last_r_srgb;
-				result[i + 1] = last_g_srgb;
-				result[i + 2] = last_b_srgb;
-				result[i + 3] = (a * 255. + 0.5) as u8;
-			}
-
-			i += 4;
-		}
-
-		(result, *width, *height)
-	}
-}
-
-impl<P: Pixel> IntoIterator for Image<P> {
-	type Item = P;
-	type IntoIter = std::vec::IntoIter<P>;
-	fn into_iter(self) -> Self::IntoIter {
-		self.data.into_iter()
-	}
-}
-
-// TODO: Eventually remove this migration document upgrade code
-pub fn migrate_image_frame<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Result<RasterDataTable<CPU>, D::Error> {
-	use serde::Deserialize;
-
-	type ImageFrameTable<P> = Instances<Image<P>>;
-
-	#[derive(Clone, Debug, Hash, PartialEq, DynAny)]
-	enum RasterFrame {
-		/// A CPU-based bitmap image with a finite position and extent, equivalent to the SVG <image> tag: https://developer.mozilla.org/en-US/docs/Web/SVG/Element/image
-		ImageFrame(ImageFrameTable<Color>),
-	}
-	impl<'de> serde::Deserialize<'de> for RasterFrame {
-		fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
-			Ok(RasterFrame::ImageFrame(ImageFrameTable::new(Image::deserialize(deserializer)?)))
-		}
-	}
-	impl serde::Serialize for RasterFrame {
-		fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-			match self {
-				RasterFrame::ImageFrame(image_instances) => image_instances.serialize(serializer),
-			}
-		}
-	}
-
-	#[derive(Clone, Debug, Hash, PartialEq, DynAny, serde::Serialize, serde::Deserialize)]
-	pub enum GraphicElement {
-		/// Equivalent to the SVG <g> tag: https://developer.mozilla.org/en-US/docs/Web/SVG/Element/g
-		GraphicGroup(GraphicGroupTable),
-		/// A vector shape, equivalent to the SVG <path> tag: https://developer.mozilla.org/en-US/docs/Web/SVG/Element/path
-		VectorData(VectorDataTable),
-		RasterFrame(RasterFrame),
-	}
-
-	#[derive(Clone, Default, Debug, PartialEq, specta::Type, serde::Serialize, serde::Deserialize)]
-	pub struct ImageFrame<P: Pixel> {
-		pub image: Image<P>,
-	}
-	impl From<ImageFrame<Color>> for GraphicElement {
-		fn from(image_frame: ImageFrame<Color>) -> Self {
-			GraphicElement::RasterFrame(RasterFrame::ImageFrame(ImageFrameTable::new(image_frame.image)))
-		}
-	}
-	impl From<GraphicElement> for ImageFrame<Color> {
-		fn from(element: GraphicElement) -> Self {
-			match element {
-				GraphicElement::RasterFrame(RasterFrame::ImageFrame(image)) => Self {
-					image: image.instance_ref_iter().next().unwrap().instance.clone(),
-				},
-				_ => panic!("Expected Image, found {:?}", element),
-			}
-		}
-	}
-
-	unsafe impl<P> StaticType for ImageFrame<P>
-	where
-		P: dyn_any::StaticTypeSized + Pixel,
-		P::Static: Pixel,
-	{
-		type Static = ImageFrame<P::Static>;
-	}
-
-	#[derive(Clone, Default, Debug, PartialEq, specta::Type, serde::Serialize, serde::Deserialize)]
-	pub struct OldImageFrame<P: Pixel> {
-		image: Image<P>,
-		transform: DAffine2,
-		alpha_blending: AlphaBlending,
-	}
-
-	#[derive(serde::Serialize, serde::Deserialize)]
-	#[serde(untagged)]
-	enum FormatVersions {
-		Image(Image<Color>),
-		OldImageFrame(OldImageFrame<Color>),
-		ImageFrame(Instances<ImageFrame<Color>>),
-		ImageFrameTable(ImageFrameTable<Color>),
-		RasterDataTable(RasterDataTable<CPU>),
-	}
-
-	Ok(match FormatVersions::deserialize(deserializer)? {
-		FormatVersions::Image(image) => RasterDataTable::new(Raster::new_cpu(image)),
-		FormatVersions::OldImageFrame(image_frame_with_transform_and_blending) => {
-			let OldImageFrame { image, transform, alpha_blending } = image_frame_with_transform_and_blending;
-			let mut image_frame_table = RasterDataTable::new(Raster::new_cpu(image));
-			*image_frame_table.instance_mut_iter().next().unwrap().transform = transform;
-			*image_frame_table.instance_mut_iter().next().unwrap().alpha_blending = alpha_blending;
-			image_frame_table
-		}
-		FormatVersions::ImageFrame(image_frame) => RasterDataTable::new(Raster::new_cpu(
-			image_frame
-				.instance_ref_iter()
-				.next()
-				.unwrap_or(Instances::new(ImageFrame::default()).instance_ref_iter().next().unwrap())
-				.instance
-				.image
-				.clone(),
-		)),
-		FormatVersions::ImageFrameTable(image_frame_table) => RasterDataTable::new(Raster::new_cpu(image_frame_table.instance_ref_iter().next().unwrap().instance.clone())),
-		FormatVersions::RasterDataTable(raster_data_table) => raster_data_table,
-	})
-}
-
-// TODO: Eventually remove this migration document upgrade code
-pub fn migrate_image_frame_instance<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Result<Instance<Raster<CPU>>, D::Error> {
-	use serde::Deserialize;
-
-	type ImageFrameTable<P> = Instances<Image<P>>;
-
-	#[derive(Clone, Debug, Hash, PartialEq, DynAny)]
-	enum RasterFrame {
-		/// A CPU-based bitmap image with a finite position and extent, equivalent to the SVG <image> tag: https://developer.mozilla.org/en-US/docs/Web/SVG/Element/image
-		ImageFrame(ImageFrameTable<Color>),
-	}
-	impl<'de> serde::Deserialize<'de> for RasterFrame {
-		fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
-			Ok(RasterFrame::ImageFrame(ImageFrameTable::new(Image::deserialize(deserializer)?)))
-		}
-	}
-	impl serde::Serialize for RasterFrame {
-		fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-			match self {
-				RasterFrame::ImageFrame(image_instances) => image_instances.serialize(serializer),
-			}
-		}
-	}
-
-	#[derive(Clone, Debug, Hash, PartialEq, DynAny, serde::Serialize, serde::Deserialize)]
-	pub enum GraphicElement {
-		/// Equivalent to the SVG <g> tag: https://developer.mozilla.org/en-US/docs/Web/SVG/Element/g
-		GraphicGroup(GraphicGroupTable),
-		/// A vector shape, equivalent to the SVG <path> tag: https://developer.mozilla.org/en-US/docs/Web/SVG/Element/path
-		VectorData(VectorDataTable),
-		RasterFrame(RasterFrame),
-	}
-
-	#[derive(Clone, Default, Debug, PartialEq, specta::Type, serde::Serialize, serde::Deserialize)]
-	pub struct ImageFrame<P: Pixel> {
-		pub image: Image<P>,
-	}
-	impl From<ImageFrame<Color>> for GraphicElement {
-		fn from(image_frame: ImageFrame<Color>) -> Self {
-			GraphicElement::RasterFrame(RasterFrame::ImageFrame(ImageFrameTable::new(image_frame.image)))
-		}
-	}
-	impl From<GraphicElement> for ImageFrame<Color> {
-		fn from(element: GraphicElement) -> Self {
-			match element {
-				GraphicElement::RasterFrame(RasterFrame::ImageFrame(image)) => Self {
-					image: image.instance_ref_iter().next().unwrap().instance.clone(),
-				},
-				_ => panic!("Expected Image, found {:?}", element),
-			}
-		}
-	}
-
-	unsafe impl<P> StaticType for ImageFrame<P>
-	where
-		P: dyn_any::StaticTypeSized + Pixel,
-		P::Static: Pixel,
-	{
-		type Static = ImageFrame<P::Static>;
-	}
-
-	#[derive(Clone, Default, Debug, PartialEq, specta::Type, serde::Serialize, serde::Deserialize)]
-	pub struct OldImageFrame<P: Pixel> {
-		image: Image<P>,
-		transform: DAffine2,
-		alpha_blending: AlphaBlending,
-	}
-
-	#[derive(serde::Serialize, serde::Deserialize)]
-	#[serde(untagged)]
-	enum FormatVersions {
-		Image(Image<Color>),
-		OldImageFrame(OldImageFrame<Color>),
-		ImageFrame(Instances<ImageFrame<Color>>),
-		RasterDataTable(RasterDataTable<CPU>),
-		ImageInstance(Instance<Raster<CPU>>),
-	}
-
-	Ok(match FormatVersions::deserialize(deserializer)? {
-		FormatVersions::Image(image) => Instance {
-			instance: Raster::new_cpu(image),
-			..Default::default()
-		},
-		FormatVersions::OldImageFrame(image_frame_with_transform_and_blending) => Instance {
-			instance: Raster::new_cpu(image_frame_with_transform_and_blending.image),
-			transform: image_frame_with_transform_and_blending.transform,
-			alpha_blending: image_frame_with_transform_and_blending.alpha_blending,
-			source_node_id: None,
-		},
-		FormatVersions::ImageFrame(image_frame) => Instance {
-			instance: Raster::new_cpu(image_frame.instance_ref_iter().next().unwrap().instance.image.clone()),
-			..Default::default()
-		},
-		FormatVersions::RasterDataTable(image_frame_table) => image_frame_table.instance_iter().next().unwrap_or_default(),
-		FormatVersions::ImageInstance(image_instance) => image_instance,
-	})
-}
-
-// pub type RasterDataTable<P> = Instances<Image<P>>;
-
-impl<P: Debug + Copy + Pixel> Sample for Image<P> {
-	type Pixel = P;
-
-	// TODO: Improve sampling logic
-	#[inline(always)]
-	fn sample(&self, pos: DVec2, _area: DVec2) -> Option<Self::Pixel> {
-		let image_size = DVec2::new(self.width() as f64, self.height() as f64);
-		if pos.x < 0. || pos.y < 0. || pos.x >= image_size.x || pos.y >= image_size.y {
-			return None;
-		}
-		self.get_pixel(pos.x as u32, pos.y as u32)
-	}
-}
-
-impl<P: Copy + Pixel> Image<P> {
-	pub fn get_mut(&mut self, x: usize, y: usize) -> &mut P {
-		&mut self.data[y * (self.width as usize) + x]
-	}
-
-	/// Clamps the provided point to ((0, 0), (ImageSize.x, ImageSize.y)) and returns the closest pixel
-	pub fn sample(&self, position: DVec2) -> P {
-		let x = position.x.clamp(0., self.width as f64 - 1.) as usize;
-		let y = position.y.clamp(0., self.height as f64 - 1.) as usize;
-
-		self.data[x + y * self.width as usize]
-	}
-}
-
-impl<P: Pixel> AsRef<Image<P>> for Image<P> {
-	fn as_ref(&self) -> &Image<P> {
-		self
-	}
-}
-
-impl From<Image<Color>> for Image<SRGBA8> {
-	fn from(image: Image<Color>) -> Self {
-		let data = image.data.into_iter().map(|x| x.into()).collect();
-		Self {
-			data,
-			width: image.width,
-			height: image.height,
-			base64_string: None,
-		}
-	}
-}
-
-// impl From<RasterDataTable<CPU>> for RasterDataTable<SRGBA8> {
-// 	fn from(image_frame_table: RasterDataTable<CPU>) -> Self {
-// 		let mut result_table = RasterDataTable::<SRGBA8>::default();
-
-// 		for image_frame_instance in image_frame_table.instance_iter() {
-// 			result_table.push(Instance {
-// 				instance: image_frame_instance.instance,
-// 				transform: image_frame_instance.transform,
-// 				alpha_blending: image_frame_instance.alpha_blending,
-// 				source_node_id: image_frame_instance.source_node_id,
-// 			});
-// 		}
-
-// 		result_table
-// 	}
-// }
-
-impl From<Image<SRGBA8>> for Image<Color> {
-	fn from(image: Image<SRGBA8>) -> Self {
-		let data = image.data.into_iter().map(|x| x.into()).collect();
-		Self {
-			data,
-			width: image.width,
-			height: image.height,
-			base64_string: None,
-		}
-	}
-}
-
-#[cfg(test)]
-mod test {
-	#[test]
-	fn test_image_serialization_roundtrip() {
-		use super::*;
-		use crate::Color;
-		let image = Image {
-			width: 2,
-			height: 2,
-			data: vec![Color::WHITE, Color::BLACK, Color::RED, Color::GREEN],
-			base64_string: None,
-		};
-
-		let serialized = serde_json::to_string(&image).unwrap();
-		println!("{}", serialized);
-		let deserialized: Image<Color> = serde_json::from_str(&serialized).unwrap();
-		println!("{:?}", deserialized);
-
-		assert_eq!(image, deserialized);
-	}
-}

node-graph/gcore/src/raster_types.rs

@@ -1,138 +0,0 @@
-use crate::Color;
-use crate::bounds::BoundingBox;
-use crate::instances::Instances;
-use crate::math::quad::Quad;
-use crate::raster::Image;
-use core::ops::Deref;
-use dyn_any::DynAny;
-use glam::{DAffine2, DVec2};
-#[cfg(feature = "wgpu")]
-use std::sync::Arc;
-
-#[derive(Clone, Debug, Hash, PartialEq, Eq, Copy)]
-pub struct CPU;
-#[derive(Clone, Debug, Hash, PartialEq, Eq, Copy)]
-pub struct GPU;
-
-trait Storage: 'static {}
-impl Storage for CPU {}
-impl Storage for GPU {}
-
-#[derive(Clone, Debug, Hash, PartialEq)]
-#[allow(private_bounds)]
-pub struct Raster<T: Storage> {
-	data: RasterStorage,
-	storage: T,
-}
-
-unsafe impl<T: Storage> dyn_any::StaticType for Raster<T> {
-	type Static = Raster<T>;
-}
-#[derive(Clone, Debug, Hash, PartialEq, DynAny)]
-pub enum RasterStorage {
-	Cpu(Image<Color>),
-	#[cfg(feature = "wgpu")]
-	Gpu(Arc<wgpu::Texture>),
-	#[cfg(not(feature = "wgpu"))]
-	Gpu(()),
-}
-
-impl RasterStorage {}
-impl Raster<CPU> {
-	pub fn new_cpu(image: Image<Color>) -> Self {
-		Self {
-			data: RasterStorage::Cpu(image),
-			storage: CPU,
-		}
-	}
-	pub fn data(&self) -> &Image<Color> {
-		let RasterStorage::Cpu(cpu) = &self.data else { unreachable!() };
-		cpu
-	}
-	pub fn data_mut(&mut self) -> &mut Image<Color> {
-		let RasterStorage::Cpu(cpu) = &mut self.data else { unreachable!() };
-		cpu
-	}
-	pub fn into_data(self) -> Image<Color> {
-		let RasterStorage::Cpu(cpu) = self.data else { unreachable!() };
-		cpu
-	}
-	pub fn is_empty(&self) -> bool {
-		let data = self.data();
-		data.height == 0 || data.width == 0
-	}
-}
-impl Default for Raster<CPU> {
-	fn default() -> Self {
-		Self {
-			data: RasterStorage::Cpu(Image::default()),
-			storage: CPU,
-		}
-	}
-}
-impl Deref for Raster<CPU> {
-	type Target = Image<Color>;
-
-	fn deref(&self) -> &Self::Target {
-		self.data()
-	}
-}
-#[cfg(feature = "wgpu")]
-impl Raster<GPU> {
-	pub fn new_gpu(image: Arc<wgpu::Texture>) -> Self {
-		Self {
-			data: RasterStorage::Gpu(image),
-			storage: GPU,
-		}
-	}
-	pub fn data(&self) -> &wgpu::Texture {
-		let RasterStorage::Gpu(gpu) = &self.data else { unreachable!() };
-		gpu
-	}
-	pub fn data_mut(&mut self) -> &mut Arc<wgpu::Texture> {
-		let RasterStorage::Gpu(gpu) = &mut self.data else { unreachable!() };
-		gpu
-	}
-	pub fn data_owned(&self) -> Arc<wgpu::Texture> {
-		let RasterStorage::Gpu(gpu) = &self.data else { unreachable!() };
-		gpu.clone()
-	}
-	pub fn is_empty(&self) -> bool {
-		let data = self.data();
-		data.width() == 0 || data.height() == 0
-	}
-}
-#[cfg(feature = "wgpu")]
-impl Deref for Raster<GPU> {
-	type Target = wgpu::Texture;
-
-	fn deref(&self) -> &Self::Target {
-		self.data()
-	}
-}
-pub type RasterDataTable<Storage> = Instances<Raster<Storage>>;
-
-// TODO: Make this not dupliated
-impl BoundingBox for RasterDataTable<CPU> {
-	fn bounding_box(&self, transform: DAffine2, _include_stroke: bool) -> Option<[DVec2; 2]> {
-		self.instance_ref_iter()
-			.filter(|instance| !instance.instance.is_empty()) // Eliminate empty images
-			.flat_map(|instance| {
-				let transform = transform * *instance.transform;
-				(transform.matrix2.determinant() != 0.).then(|| (transform * Quad::from_box([DVec2::ZERO, DVec2::ONE])).bounding_box())
-			})
-			.reduce(Quad::combine_bounds)
-	}
-}
-
-impl BoundingBox for RasterDataTable<GPU> {
-	fn bounding_box(&self, transform: DAffine2, _include_stroke: bool) -> Option<[DVec2; 2]> {
-		self.instance_ref_iter()
-			.filter(|instance| !instance.instance.is_empty()) // Eliminate empty images
-			.flat_map(|instance| {
-				let transform = transform * *instance.transform;
-				(transform.matrix2.determinant() != 0.).then(|| (transform * Quad::from_box([DVec2::ZERO, DVec2::ONE])).bounding_box())
-			})
-			.reduce(Quad::combine_bounds)
-	}
-}

node-graph/gcore/src/text.rs

@@ -1,5 +0,0 @@
-mod font_cache;
-mod to_path;
-
-pub use font_cache::*;
-pub use to_path::*;

node-graph/gcore/src/text/font_cache.rs

@@ -1,80 +0,0 @@
-use dyn_any::DynAny;
-use std::collections::HashMap;
-
-/// A font type (storing font family and font style and an optional preview URL)
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, Hash, PartialEq, Eq, DynAny, specta::Type)]
-pub struct Font {
-	#[serde(rename = "fontFamily")]
-	pub font_family: String,
-	#[serde(rename = "fontStyle", deserialize_with = "migrate_font_style")]
-	pub font_style: String,
-}
-impl Font {
-	pub fn new(font_family: String, font_style: String) -> Self {
-		Self { font_family, font_style }
-	}
-}
-impl Default for Font {
-	fn default() -> Self {
-		Self::new(crate::consts::DEFAULT_FONT_FAMILY.into(), crate::consts::DEFAULT_FONT_STYLE.into())
-	}
-}
-/// A cache of all loaded font data and preview urls along with the default font (send from `init_app` in `editor_api.rs`)
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, Default, PartialEq, DynAny)]
-pub struct FontCache {
-	/// Actual font file data used for rendering a font with ttf_parser and rustybuzz
-	font_file_data: HashMap<Font, Vec<u8>>,
-	/// Web font preview URLs used for showing fonts when live editing
-	preview_urls: HashMap<Font, String>,
-}
-impl FontCache {
-	/// Returns the font family name if the font is cached, otherwise returns the fallback font family name if that is cached
-	pub fn resolve_font<'a>(&'a self, font: &'a Font) -> Option<&'a Font> {
-		if self.font_file_data.contains_key(font) {
-			Some(font)
-		} else {
-			self.font_file_data
-				.keys()
-				.find(|font| font.font_family == crate::consts::DEFAULT_FONT_FAMILY && font.font_style == crate::consts::DEFAULT_FONT_STYLE)
-		}
-	}
-
-	/// Try to get the bytes for a font
-	pub fn get<'a>(&'a self, font: &Font) -> Option<&'a Vec<u8>> {
-		self.resolve_font(font).and_then(|font| self.font_file_data.get(font))
-	}
-
-	/// Check if the font is already loaded
-	pub fn loaded_font(&self, font: &Font) -> bool {
-		self.font_file_data.contains_key(font)
-	}
-
-	/// Insert a new font into the cache
-	pub fn insert(&mut self, font: Font, perview_url: String, data: Vec<u8>) {
-		self.font_file_data.insert(font.clone(), data);
-		self.preview_urls.insert(font, perview_url);
-	}
-
-	/// Gets the preview URL for showing in text field when live editing
-	pub fn get_preview_url(&self, font: &Font) -> Option<&String> {
-		self.preview_urls.get(font)
-	}
-}
-
-impl std::hash::Hash for FontCache {
-	fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-		self.preview_urls.len().hash(state);
-		self.preview_urls.iter().for_each(|(font, url)| {
-			font.hash(state);
-			url.hash(state)
-		});
-		self.font_file_data.len().hash(state);
-		self.font_file_data.keys().for_each(|font| font.hash(state));
-	}
-}
-
-// TODO: Eventually remove this migration document upgrade code
-fn migrate_font_style<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Result<String, D::Error> {
-	use serde::Deserialize;
-	String::deserialize(deserializer).map(|name| if name == "Normal (400)" { "Regular (400)".to_string() } else { name })
-}

node-graph/gcore/src/text/to_path.rs

@@ -1,253 +0,0 @@
-use crate::vector::PointId;
-use bezier_rs::{ManipulatorGroup, Subpath};
-use glam::DVec2;
-use rustybuzz::ttf_parser::{GlyphId, OutlineBuilder};
-use rustybuzz::{GlyphBuffer, UnicodeBuffer};
-
-struct Builder {
-	current_subpath: Subpath<PointId>,
-	other_subpaths: Vec<Subpath<PointId>>,
-	text_cursor: DVec2,
-	offset: DVec2,
-	ascender: f64,
-	scale: f64,
-	id: PointId,
-}
-
-impl Builder {
-	fn point(&self, x: f32, y: f32) -> DVec2 {
-		self.text_cursor + self.offset + DVec2::new(x as f64, self.ascender - y as f64) * self.scale
-	}
-}
-
-impl OutlineBuilder for Builder {
-	fn move_to(&mut self, x: f32, y: f32) {
-		if !self.current_subpath.is_empty() {
-			self.other_subpaths.push(std::mem::replace(&mut self.current_subpath, Subpath::new(Vec::new(), false)));
-		}
-		self.current_subpath.push_manipulator_group(ManipulatorGroup::new_anchor_with_id(self.point(x, y), self.id.next_id()));
-	}
-
-	fn line_to(&mut self, x: f32, y: f32) {
-		self.current_subpath.push_manipulator_group(ManipulatorGroup::new_anchor_with_id(self.point(x, y), self.id.next_id()));
-	}
-
-	fn quad_to(&mut self, x1: f32, y1: f32, x2: f32, y2: f32) {
-		let [handle, anchor] = [self.point(x1, y1), self.point(x2, y2)];
-		self.current_subpath.last_manipulator_group_mut().unwrap().out_handle = Some(handle);
-		self.current_subpath.push_manipulator_group(ManipulatorGroup::new_with_id(anchor, None, None, self.id.next_id()));
-	}
-
-	fn curve_to(&mut self, x1: f32, y1: f32, x2: f32, y2: f32, x3: f32, y3: f32) {
-		let [handle1, handle2, anchor] = [self.point(x1, y1), self.point(x2, y2), self.point(x3, y3)];
-		self.current_subpath.last_manipulator_group_mut().unwrap().out_handle = Some(handle1);
-		self.current_subpath
-			.push_manipulator_group(ManipulatorGroup::new_with_id(anchor, Some(handle2), None, self.id.next_id()));
-	}
-
-	fn close(&mut self) {
-		self.current_subpath.set_closed(true);
-		self.other_subpaths.push(std::mem::replace(&mut self.current_subpath, Subpath::new(Vec::new(), false)));
-	}
-}
-
-fn font_properties(buzz_face: &rustybuzz::Face, font_size: f64, line_height_ratio: f64) -> (f64, f64, UnicodeBuffer) {
-	let scale = (buzz_face.units_per_em() as f64).recip() * font_size;
-	let line_height = font_size * line_height_ratio;
-	let buffer = UnicodeBuffer::new();
-	(scale, line_height, buffer)
-}
-
-fn push_str(buffer: &mut UnicodeBuffer, word: &str) {
-	buffer.push_str(word);
-}
-
-fn wrap_word(max_width: Option<f64>, glyph_buffer: &GlyphBuffer, font_size: f64, character_spacing: f64, x_pos: f64, space_glyph: Option<GlyphId>) -> bool {
-	if let Some(max_width) = max_width {
-		// We don't word wrap spaces (to match the browser)
-		let all_glyphs = glyph_buffer.glyph_positions().iter().zip(glyph_buffer.glyph_infos());
-		let non_space_glyphs = all_glyphs.take_while(|(_, info)| space_glyph != Some(GlyphId(info.glyph_id as u16)));
-		let word_length: f64 = non_space_glyphs.map(|(pos, _)| pos.x_advance as f64 * character_spacing).sum();
-		let scaled_word_length = word_length * font_size;
-
-		if scaled_word_length + x_pos > max_width {
-			return true;
-		}
-	}
-	false
-}
-
-#[derive(PartialEq, Clone, Copy, Debug, serde::Serialize, serde::Deserialize)]
-pub struct TypesettingConfig {
-	pub font_size: f64,
-	pub line_height_ratio: f64,
-	pub character_spacing: f64,
-	pub max_width: Option<f64>,
-	pub max_height: Option<f64>,
-}
-
-impl Default for TypesettingConfig {
-	fn default() -> Self {
-		Self {
-			font_size: 24.,
-			line_height_ratio: 1.2,
-			character_spacing: 1.,
-			max_width: None,
-			max_height: None,
-		}
-	}
-}
-
-pub fn to_path(str: &str, buzz_face: Option<rustybuzz::Face>, typesetting: TypesettingConfig) -> Vec<Subpath<PointId>> {
-	let Some(buzz_face) = buzz_face else { return vec![] };
-	let space_glyph = buzz_face.glyph_index(' ');
-
-	let (scale, line_height, mut buffer) = font_properties(&buzz_face, typesetting.font_size, typesetting.line_height_ratio);
-
-	let mut builder = Builder {
-		current_subpath: Subpath::new(Vec::new(), false),
-		other_subpaths: Vec::new(),
-		text_cursor: DVec2::ZERO,
-		offset: DVec2::ZERO,
-		ascender: (buzz_face.ascender() as f64 / buzz_face.height() as f64) * typesetting.font_size / scale,
-		scale,
-		id: PointId::ZERO,
-	};
-
-	for line in str.split('\n') {
-		for (index, word) in SplitWordsIncludingSpaces::new(line).enumerate() {
-			push_str(&mut buffer, word);
-			let glyph_buffer = rustybuzz::shape(&buzz_face, &[], buffer);
-
-			// Don't wrap the first word
-			if index != 0 && wrap_word(typesetting.max_width, &glyph_buffer, scale, typesetting.character_spacing, builder.text_cursor.x, space_glyph) {
-				builder.text_cursor = DVec2::new(0., builder.text_cursor.y + line_height);
-			}
-
-			for (glyph_position, glyph_info) in glyph_buffer.glyph_positions().iter().zip(glyph_buffer.glyph_infos()) {
-				let glyph_id = GlyphId(glyph_info.glyph_id as u16);
-				if let Some(max_width) = typesetting.max_width {
-					if space_glyph != Some(glyph_id) && builder.text_cursor.x + (glyph_position.x_advance as f64 * builder.scale * typesetting.character_spacing) >= max_width {
-						builder.text_cursor = DVec2::new(0., builder.text_cursor.y + line_height);
-					}
-				}
-				// Clip when the height is exceeded
-				if typesetting.max_height.is_some_and(|max_height| builder.text_cursor.y > max_height - line_height) {
-					return builder.other_subpaths;
-				}
-
-				builder.offset = DVec2::new(glyph_position.x_offset as f64, glyph_position.y_offset as f64) * builder.scale;
-				buzz_face.outline_glyph(glyph_id, &mut builder);
-				if !builder.current_subpath.is_empty() {
-					builder.other_subpaths.push(std::mem::replace(&mut builder.current_subpath, Subpath::new(Vec::new(), false)));
-				}
-
-				builder.text_cursor += DVec2::new(glyph_position.x_advance as f64 * typesetting.character_spacing, glyph_position.y_advance as f64) * builder.scale;
-			}
-
-			buffer = glyph_buffer.clear();
-		}
-
-		builder.text_cursor = DVec2::new(0., builder.text_cursor.y + line_height);
-	}
-
-	builder.other_subpaths
-}
-
-pub fn bounding_box(str: &str, buzz_face: Option<&rustybuzz::Face>, typesetting: TypesettingConfig, for_clipping_test: bool) -> DVec2 {
-	// Show blank layer if font has not loaded
-	let Some(buzz_face) = buzz_face else { return DVec2::ZERO };
-	let space_glyph = buzz_face.glyph_index(' ');
-
-	let (scale, line_height, mut buffer) = font_properties(buzz_face, typesetting.font_size, typesetting.line_height_ratio);
-
-	let [mut text_cursor, mut bounds] = [DVec2::ZERO; 2];
-	if !for_clipping_test {
-		if let (Some(max_height), Some(max_width)) = (typesetting.max_height, typesetting.max_width) {
-			return DVec2::new(max_width, max_height);
-		}
-	}
-
-	for line in str.split('\n') {
-		for (index, word) in SplitWordsIncludingSpaces::new(line).enumerate() {
-			push_str(&mut buffer, word);
-
-			let glyph_buffer = rustybuzz::shape(buzz_face, &[], buffer);
-
-			// Don't wrap the first word
-			if index != 0 && wrap_word(typesetting.max_width, &glyph_buffer, scale, typesetting.character_spacing, text_cursor.x, space_glyph) {
-				text_cursor = DVec2::new(0., text_cursor.y + line_height);
-			}
-
-			for (glyph_position, glyph_info) in glyph_buffer.glyph_positions().iter().zip(glyph_buffer.glyph_infos()) {
-				let glyph_id = GlyphId(glyph_info.glyph_id as u16);
-				if let Some(max_width) = typesetting.max_width {
-					if space_glyph != Some(glyph_id) && text_cursor.x + (glyph_position.x_advance as f64 * scale * typesetting.character_spacing) >= max_width {
-						text_cursor = DVec2::new(0., text_cursor.y + line_height);
-					}
-				}
-				text_cursor += DVec2::new(glyph_position.x_advance as f64 * typesetting.character_spacing, glyph_position.y_advance as f64) * scale;
-				bounds = bounds.max(text_cursor + DVec2::new(0., line_height));
-			}
-
-			buffer = glyph_buffer.clear();
-		}
-		text_cursor = DVec2::new(0., text_cursor.y + line_height);
-		bounds = bounds.max(text_cursor);
-	}
-
-	if !for_clipping_test {
-		if let Some(max_width) = typesetting.max_width {
-			bounds.x = max_width;
-		}
-		if let Some(max_height) = typesetting.max_height {
-			bounds.y = max_height;
-		}
-	}
-
-	bounds
-}
-
-pub fn load_face(data: &[u8]) -> rustybuzz::Face<'_> {
-	rustybuzz::Face::from_slice(data, 0).expect("Loading font failed")
-}
-
-pub fn lines_clipping(str: &str, buzz_face: Option<rustybuzz::Face>, typesetting: TypesettingConfig) -> bool {
-	let Some(max_height) = typesetting.max_height else { return false };
-	let bounds = bounding_box(str, buzz_face.as_ref(), typesetting, true);
-	max_height < bounds.y
-}
-
-struct SplitWordsIncludingSpaces<'a> {
-	text: &'a str,
-	start_byte: usize,
-}
-
-impl<'a> SplitWordsIncludingSpaces<'a> {
-	pub fn new(text: &'a str) -> Self {
-		Self { text, start_byte: 0 }
-	}
-}
-
-impl<'a> Iterator for SplitWordsIncludingSpaces<'a> {
-	type Item = &'a str;
-	fn next(&mut self) -> Option<Self::Item> {
-		let mut eaten_chars = self.text[self.start_byte..].char_indices().skip_while(|(_, c)| *c != ' ').skip_while(|(_, c)| *c == ' ');
-		let start_byte = self.start_byte;
-		self.start_byte = eaten_chars.next().map_or(self.text.len(), |(offset, _)| self.start_byte + offset);
-		(self.start_byte > start_byte).then(|| self.text.get(start_byte..self.start_byte)).flatten()
-	}
-}
-
-#[cfg(test)]
-mod tests {
-	use super::*;
-	#[test]
-	fn split_words_including_spaces() {
-		let mut split_words = SplitWordsIncludingSpaces::new("hello  world     .");
-		assert_eq!(split_words.next(), Some("hello  "));
-		assert_eq!(split_words.next(), Some("world     "));
-		assert_eq!(split_words.next(), Some("."));
-		assert_eq!(split_words.next(), None);
-	}
-}

node-graph/gcore/src/transform.rs

@@ -1,7 +1,3 @@
-use crate::Artboard;
-use crate::math::bbox::AxisAlignedBbox;
-pub use crate::vector::ReferencePoint;
-use core::f64;
 use glam::{DAffine2, DMat2, DVec2};
 
 pub trait Transform {
@@ -31,16 +27,6 @@ impl<T: Transform> Transform for &T {
 	}
 }
 
-// Implementations for Artboard
-impl Transform for Artboard {
-	fn transform(&self) -> DAffine2 {
-		DAffine2::from_translation(self.location.as_dvec2())
-	}
-	fn local_pivot(&self, pivot: DVec2) -> DVec2 {
-		self.location.as_dvec2() + self.dimensions.as_dvec2() * pivot
-	}
-}
-
 // Implementations for DAffine2
 impl Transform for DAffine2 {
 	fn transform(&self) -> DAffine2 {
@@ -110,13 +96,6 @@ impl Footprint {
 		quality: RenderQuality::Full,
 	};
 
-	pub fn viewport_bounds_in_local_space(&self) -> AxisAlignedBbox {
-		let inverse = self.transform.inverse();
-		let start = inverse.transform_point2((0., 0.).into());
-		let end = inverse.transform_point2(self.resolution.as_dvec2());
-		AxisAlignedBbox { start, end }
-	}
-
 	pub fn scale(&self) -> DVec2 {
 		self.transform.decompose_scale()
 	}

node-graph/gcore/src/vector/algorithms/bezpath_algorithms.rs

@@ -1,316 +0,0 @@
-use super::poisson_disk::poisson_disk_sample;
-use crate::vector::misc::{PointSpacingType, dvec2_to_point};
-use glam::DVec2;
-use kurbo::{BezPath, DEFAULT_ACCURACY, Line, ParamCurve, ParamCurveDeriv, PathEl, PathSeg, Point, Rect, Shape};
-
-/// Splits the [`BezPath`] at `t` value which lie in the range of [0, 1].
-/// Returns [`None`] if the given [`BezPath`] has no segments or `t` is within f64::EPSILON of 0 or 1.
-pub fn split_bezpath(bezpath: &BezPath, t: f64, euclidian: bool) -> Option<(BezPath, BezPath)> {
-	if t <= f64::EPSILON || (1. - t) <= f64::EPSILON || bezpath.segments().count() == 0 {
-		return None;
-	}
-
-	// Get the segment which lies at the split.
-	let (segment_index, t) = t_value_to_parametric(bezpath, t, euclidian, None);
-	let segment = bezpath.get_seg(segment_index + 1).unwrap();
-
-	// Divide the segment.
-	let first_segment = segment.subsegment(0.0..t);
-	let second_segment = segment.subsegment(t..1.);
-
-	let mut first_bezpath = BezPath::new();
-	let mut second_bezpath = BezPath::new();
-
-	// Append the segments up to the subdividing segment from original bezpath to first bezpath.
-	for segment in bezpath.segments().take(segment_index) {
-		if first_bezpath.elements().is_empty() {
-			first_bezpath.move_to(segment.start());
-		}
-		first_bezpath.push(segment.as_path_el());
-	}
-
-	// Append the first segment of the subdivided segment.
-	if first_bezpath.elements().is_empty() {
-		first_bezpath.move_to(first_segment.start());
-	}
-	first_bezpath.push(first_segment.as_path_el());
-
-	// Append the second segment of the subdivided segment in the second bezpath.
-	if second_bezpath.elements().is_empty() {
-		second_bezpath.move_to(second_segment.start());
-	}
-	second_bezpath.push(second_segment.as_path_el());
-
-	// Append the segments after the subdividing segment from original bezpath to second bezpath.
-	for segment in bezpath.segments().skip(segment_index + 1) {
-		if second_bezpath.elements().is_empty() {
-			second_bezpath.move_to(segment.start());
-		}
-		second_bezpath.push(segment.as_path_el());
-	}
-
-	Some((first_bezpath, second_bezpath))
-}
-
-pub fn position_on_bezpath(bezpath: &BezPath, t: f64, euclidian: bool, segments_length: Option<&[f64]>) -> Point {
-	let (segment_index, t) = t_value_to_parametric(bezpath, t, euclidian, segments_length);
-	bezpath.get_seg(segment_index + 1).unwrap().eval(t)
-}
-
-pub fn tangent_on_bezpath(bezpath: &BezPath, t: f64, euclidian: bool, segments_length: Option<&[f64]>) -> Point {
-	let (segment_index, t) = t_value_to_parametric(bezpath, t, euclidian, segments_length);
-	let segment = bezpath.get_seg(segment_index + 1).unwrap();
-	match segment {
-		PathSeg::Line(line) => line.deriv().eval(t),
-		PathSeg::Quad(quad_bez) => quad_bez.deriv().eval(t),
-		PathSeg::Cubic(cubic_bez) => cubic_bez.deriv().eval(t),
-	}
-}
-
-pub fn sample_polyline_on_bezpath(
-	bezpath: BezPath,
-	point_spacing_type: PointSpacingType,
-	amount: f64,
-	start_offset: f64,
-	stop_offset: f64,
-	adaptive_spacing: bool,
-	segments_length: &[f64],
-) -> Option<BezPath> {
-	let mut sample_bezpath = BezPath::new();
-
-	let was_closed = matches!(bezpath.elements().last(), Some(PathEl::ClosePath));
-
-	// Calculate the total length of the collected segments.
-	let total_length: f64 = segments_length.iter().sum();
-
-	// Adjust the usable length by subtracting start and stop offsets.
-	let mut used_length = total_length - start_offset - stop_offset;
-
-	// Sanity check that the usable length is positive.
-	if used_length <= 0. {
-		return None;
-	}
-
-	const SAFETY_MAX_COUNT: f64 = 10_000. - 1.;
-
-	// Determine the number of points to generate along the path.
-	let sample_count = match point_spacing_type {
-		PointSpacingType::Separation => {
-			let spacing = amount.min(used_length - f64::EPSILON);
-
-			if adaptive_spacing {
-				// Calculate point count to evenly distribute points while covering the entire path.
-				// With adaptive spacing, we widen or narrow the points as necessary to ensure the last point is always at the end of the path.
-				(used_length / spacing).round().min(SAFETY_MAX_COUNT)
-			} else {
-				// Calculate point count based on exact spacing, which may not cover the entire path.
-				// Without adaptive spacing, we just evenly space the points at the exact specified spacing, usually falling short before the end of the path.
-				let count = (used_length / spacing + f64::EPSILON).floor().min(SAFETY_MAX_COUNT);
-				if count != SAFETY_MAX_COUNT {
-					used_length -= used_length % spacing;
-				}
-				count
-			}
-		}
-		PointSpacingType::Quantity => (amount - 1.).floor().clamp(1., SAFETY_MAX_COUNT),
-	};
-
-	// Skip if there are no points to generate.
-	if sample_count < 1. {
-		return None;
-	}
-
-	// Decide how many loop-iterations: if closed, skip the last duplicate point
-	let sample_count_usize = sample_count as usize;
-	let max_i = if was_closed { sample_count_usize } else { sample_count_usize + 1 };
-
-	// Generate points along the path based on calculated intervals.
-	let mut length_up_to_previous_segment = 0.;
-	let mut next_segment_index = 0;
-
-	for count in 0..max_i {
-		let fraction = count as f64 / sample_count;
-		let length_up_to_next_sample_point = fraction * used_length + start_offset;
-		let mut next_length = length_up_to_next_sample_point - length_up_to_previous_segment;
-		let mut next_segment_length = segments_length[next_segment_index];
-
-		// Keep moving to the next segment while the length up to the next sample point is greater than the length up to the current segment.
-		while next_length > next_segment_length {
-			if next_segment_index == segments_length.len() - 1 {
-				break;
-			}
-			length_up_to_previous_segment += next_segment_length;
-			next_length = length_up_to_next_sample_point - length_up_to_previous_segment;
-			next_segment_index += 1;
-			next_segment_length = segments_length[next_segment_index];
-		}
-
-		let t = (next_length / next_segment_length).clamp(0., 1.);
-
-		let segment = bezpath.get_seg(next_segment_index + 1).unwrap();
-		let t = eval_pathseg_euclidean(segment, t, DEFAULT_ACCURACY);
-		let point = segment.eval(t);
-
-		if sample_bezpath.elements().is_empty() {
-			sample_bezpath.move_to(point)
-		} else {
-			sample_bezpath.line_to(point)
-		}
-	}
-
-	if was_closed {
-		sample_bezpath.close_path();
-	}
-
-	Some(sample_bezpath)
-}
-
-pub fn t_value_to_parametric(bezpath: &BezPath, t: f64, euclidian: bool, segments_length: Option<&[f64]>) -> (usize, f64) {
-	if euclidian {
-		let (segment_index, t) = bezpath_t_value_to_parametric(bezpath, BezPathTValue::GlobalEuclidean(t), segments_length);
-		let segment = bezpath.get_seg(segment_index + 1).unwrap();
-		return (segment_index, eval_pathseg_euclidean(segment, t, DEFAULT_ACCURACY));
-	}
-	bezpath_t_value_to_parametric(bezpath, BezPathTValue::GlobalParametric(t), segments_length)
-}
-
-/// Finds the t value of point on the given path segment i.e fractional distance along the segment's total length.
-/// It uses a binary search to find the value `t` such that the ratio `length_up_to_t / total_length` approximates the input `distance`.
-pub fn eval_pathseg_euclidean(path_segment: PathSeg, distance: f64, accuracy: f64) -> f64 {
-	let mut low_t = 0.;
-	let mut mid_t = 0.5;
-	let mut high_t = 1.;
-
-	let total_length = path_segment.perimeter(accuracy);
-
-	if !total_length.is_finite() || total_length <= f64::EPSILON {
-		return 0.;
-	}
-
-	let distance = distance.clamp(0., 1.);
-
-	while high_t - low_t > accuracy {
-		let current_length = path_segment.subsegment(0.0..mid_t).perimeter(accuracy);
-		let current_distance = current_length / total_length;
-
-		if current_distance > distance {
-			high_t = mid_t;
-		} else {
-			low_t = mid_t;
-		}
-		mid_t = (high_t + low_t) / 2.;
-	}
-
-	mid_t
-}
-
-/// Converts from a bezpath (composed of multiple segments) to a point along a certain segment represented.
-/// The returned tuple represents the segment index and the `t` value along that segment.
-/// Both the input global `t` value and the output `t` value are in euclidean space, meaning there is a constant rate of change along the arc length.
-fn global_euclidean_to_local_euclidean(bezpath: &BezPath, global_t: f64, lengths: &[f64], total_length: f64) -> (usize, f64) {
-	let mut accumulator = 0.;
-	for (index, length) in lengths.iter().enumerate() {
-		let length_ratio = length / total_length;
-		if (index == 0 || accumulator <= global_t) && global_t <= accumulator + length_ratio {
-			return (index, ((global_t - accumulator) / length_ratio).clamp(0., 1.));
-		}
-		accumulator += length_ratio;
-	}
-	(bezpath.segments().count() - 1, 1.)
-}
-
-enum BezPathTValue {
-	GlobalEuclidean(f64),
-	GlobalParametric(f64),
-}
-
-/// Convert a [BezPathTValue] to a parametric `(segment_index, t)` tuple.
-/// - Asserts that `t` values contained within the `SubpathTValue` argument lie in the range [0, 1].
-fn bezpath_t_value_to_parametric(bezpath: &BezPath, t: BezPathTValue, precomputed_segments_length: Option<&[f64]>) -> (usize, f64) {
-	let segment_count = bezpath.segments().count();
-	assert!(segment_count >= 1);
-
-	match t {
-		BezPathTValue::GlobalEuclidean(t) => {
-			let computed_segments_length;
-
-			let segments_length = if let Some(segments_length) = precomputed_segments_length {
-				segments_length
-			} else {
-				computed_segments_length = bezpath.segments().map(|segment| segment.perimeter(DEFAULT_ACCURACY)).collect::<Vec<f64>>();
-				computed_segments_length.as_slice()
-			};
-
-			let total_length = segments_length.iter().sum();
-
-			global_euclidean_to_local_euclidean(bezpath, t, segments_length, total_length)
-		}
-		BezPathTValue::GlobalParametric(global_t) => {
-			assert!((0.0..=1.).contains(&global_t));
-
-			if global_t == 1. {
-				return (segment_count - 1, 1.);
-			}
-
-			let scaled_t = global_t * segment_count as f64;
-			let segment_index = scaled_t.floor() as usize;
-			let t = scaled_t - segment_index as f64;
-
-			(segment_index, t)
-		}
-	}
-}
-
-/// Randomly places points across the filled surface of this subpath (which is assumed to be closed).
-/// The `separation_disk_diameter` determines the minimum distance between all points from one another.
-/// Conceptually, this works by "throwing a dart" at the subpath's bounding box and keeping the dart only if:
-/// - It's inside the shape
-/// - It's not closer than `separation_disk_diameter` to any other point from a previous accepted dart throw
-///
-/// This repeats until accepted darts fill all possible areas between one another.
-///
-/// While the conceptual process described above asymptotically slows down and is never guaranteed to produce a maximal set in finite time,
-/// this is implemented with an algorithm that produces a maximal set in O(n) time. The slowest part is actually checking if points are inside the subpath shape.
-pub fn poisson_disk_points(bezpath_index: usize, bezpaths: &[(BezPath, Rect)], separation_disk_diameter: f64, rng: impl FnMut() -> f64) -> Vec<DVec2> {
-	let (this_bezpath, this_bbox) = bezpaths[bezpath_index].clone();
-
-	if this_bezpath.elements().is_empty() {
-		return Vec::new();
-	}
-
-	let point_in_shape_checker = |point: DVec2| {
-		// Check against all paths the point is contained in to compute the correct winding number
-		let mut number = 0;
-
-		for (i, (shape, bbox)) in bezpaths.iter().enumerate() {
-			if bbox.x0 > point.x || bbox.y0 > point.y || bbox.x1 < point.x || bbox.y1 < point.y {
-				continue;
-			}
-
-			let winding = shape.winding(dvec2_to_point(point));
-			if winding == 0 && i == bezpath_index {
-				return false;
-			}
-			number += winding;
-		}
-
-		// Non-zero fill rule
-		number != 0
-	};
-
-	let line_intersect_shape_checker = |p0: (f64, f64), p1: (f64, f64)| {
-		for segment in this_bezpath.segments() {
-			if !segment.intersect_line(Line::new(p0, p1)).is_empty() {
-				return true;
-			}
-		}
-
-		false
-	};
-
-	let offset = DVec2::new(this_bbox.x0, this_bbox.y0);
-	let width = this_bbox.width();
-	let height = this_bbox.height();
-
-	poisson_disk_sample(offset, width, height, separation_disk_diameter, point_in_shape_checker, line_intersect_shape_checker, rng)
-}

node-graph/gcore/src/vector/algorithms/merge_by_distance.rs

@@ -1,214 +0,0 @@
-use crate::vector::{PointDomain, PointId, SegmentDomain, VectorData, VectorDataIndex};
-use glam::{DAffine2, DVec2};
-use petgraph::prelude::UnGraphMap;
-use rustc_hash::FxHashSet;
-
-pub trait MergeByDistanceExt {
-	/// Collapse all points with edges shorter than the specified distance
-	fn merge_by_distance_topological(&mut self, distance: f64);
-	fn merge_by_distance_spatial(&mut self, transform: DAffine2, distance: f64);
-}
-
-impl MergeByDistanceExt for VectorData {
-	fn merge_by_distance_topological(&mut self, distance: f64) {
-		// Treat self as an undirected graph
-		let indices = VectorDataIndex::build_from(self);
-
-		// TODO: We lose information on the winding order by using an undirected graph. Switch to a directed graph and fix the algorithm to handle that.
-		// Graph containing only short edges, referencing the data graph
-		let mut short_edges = UnGraphMap::new();
-
-		for segment_id in self.segment_ids().iter().copied() {
-			let length = indices.segment_chord_length(segment_id);
-			if length < distance {
-				let [start, end] = indices.segment_ends(segment_id);
-				let start = indices.point_graph.node_weight(start).unwrap().id;
-				let end = indices.point_graph.node_weight(end).unwrap().id;
-
-				short_edges.add_node(start);
-				short_edges.add_node(end);
-				short_edges.add_edge(start, end, segment_id);
-			}
-		}
-
-		// Group connected segments to collapse them into a single point
-		// TODO: there are a few possible algorithms for this - perhaps test empirically to find fastest
-		let collapse: Vec<FxHashSet<PointId>> = petgraph::algo::tarjan_scc(&short_edges).into_iter().map(|connected| connected.into_iter().collect()).collect();
-		let average_position = collapse
-			.iter()
-			.map(|collapse_set| {
-				let sum: DVec2 = collapse_set.iter().map(|&id| indices.point_position(id, self)).sum();
-				sum / collapse_set.len() as f64
-			})
-			.collect::<Vec<_>>();
-
-		// Collect points and segments to delete at the end to avoid invalidating indices
-		let mut points_to_delete = FxHashSet::default();
-		let mut segments_to_delete = FxHashSet::default();
-		for (mut collapse_set, average_pos) in collapse.into_iter().zip(average_position.into_iter()) {
-			// Remove any segments where both endpoints are in the collapse set
-			segments_to_delete.extend(self.segment_domain.iter().filter_map(|(id, start_offset, end_offset, _)| {
-				let start = self.point_domain.ids()[start_offset];
-				let end = self.point_domain.ids()[end_offset];
-				if collapse_set.contains(&start) && collapse_set.contains(&end) { Some(id) } else { None }
-			}));
-
-			// Delete all points but the first, set its position to the average, and update segments
-			let first_id = collapse_set.iter().copied().next().unwrap();
-			collapse_set.remove(&first_id);
-			let first_offset = indices.point_to_offset[&first_id];
-
-			// Look for segments with endpoints in `collapse_set` and replace them with the point we are collapsing to
-			for (_, start_offset, end_offset, handles) in self.segment_domain.iter_mut() {
-				let start_id = self.point_domain.ids()[*start_offset];
-				let end_id = self.point_domain.ids()[*end_offset];
-
-				// Update Bezier handles for moved points
-				if start_id == first_id {
-					let point_position = self.point_domain.position[*start_offset];
-					handles.move_start(average_pos - point_position);
-				}
-				if end_id == first_id {
-					let point_position = self.point_domain.position[*end_offset];
-					handles.move_end(average_pos - point_position);
-				}
-
-				// Replace removed points with the collapsed point
-				if collapse_set.contains(&start_id) {
-					let point_position = self.point_domain.position[*start_offset];
-					*start_offset = first_offset;
-					handles.move_start(average_pos - point_position);
-				}
-				if collapse_set.contains(&end_id) {
-					let point_position = self.point_domain.position[*end_offset];
-					*end_offset = first_offset;
-					handles.move_end(average_pos - point_position);
-				}
-			}
-
-			// Update the position of the collapsed point
-			self.point_domain.position[first_offset] = average_pos;
-
-			points_to_delete.extend(collapse_set)
-		}
-
-		// Remove faces whose start or end segments are removed
-		// TODO: Adjust faces and only delete if all (or all but one) segments are removed
-		self.region_domain
-			.retain_with_region(|_, segment_range| segments_to_delete.contains(segment_range.start()) || segments_to_delete.contains(segment_range.end()));
-		self.segment_domain.retain(|id| !segments_to_delete.contains(id), usize::MAX);
-		self.point_domain.retain(&mut self.segment_domain, |id| !points_to_delete.contains(id));
-	}
-
-	fn merge_by_distance_spatial(&mut self, transform: DAffine2, distance: f64) {
-		let point_count = self.point_domain.positions().len();
-
-		// Find min x and y for grid cell normalization
-		let mut min_x = f64::MAX;
-		let mut min_y = f64::MAX;
-
-		// Calculate mins without collecting all positions
-		for &pos in self.point_domain.positions() {
-			let transformed_pos = transform.transform_point2(pos);
-			min_x = min_x.min(transformed_pos.x);
-			min_y = min_y.min(transformed_pos.y);
-		}
-
-		// Create a spatial grid with cell size of 'distance'
-		use std::collections::HashMap;
-		let mut grid: HashMap<(i32, i32), Vec<usize>> = HashMap::new();
-
-		// Add points to grid cells without collecting all positions first
-		for i in 0..point_count {
-			let pos = transform.transform_point2(self.point_domain.positions()[i]);
-			let grid_x = ((pos.x - min_x) / distance).floor() as i32;
-			let grid_y = ((pos.y - min_y) / distance).floor() as i32;
-
-			grid.entry((grid_x, grid_y)).or_default().push(i);
-		}
-
-		// Create point index mapping for merged points
-		let mut point_index_map = vec![None; point_count];
-		let mut merged_positions = Vec::new();
-		let mut merged_indices = Vec::new();
-
-		// Process each point
-		for i in 0..point_count {
-			// Skip points that have already been processed
-			if point_index_map[i].is_some() {
-				continue;
-			}
-
-			let pos_i = transform.transform_point2(self.point_domain.positions()[i]);
-			let grid_x = ((pos_i.x - min_x) / distance).floor() as i32;
-			let grid_y = ((pos_i.y - min_y) / distance).floor() as i32;
-
-			let mut group = vec![i];
-
-			// Check only neighboring cells (3x3 grid around current cell)
-			for dx in -1..=1 {
-				for dy in -1..=1 {
-					let neighbor_cell = (grid_x + dx, grid_y + dy);
-
-					if let Some(indices) = grid.get(&neighbor_cell) {
-						for &j in indices {
-							if j > i && point_index_map[j].is_none() {
-								let pos_j = transform.transform_point2(self.point_domain.positions()[j]);
-								if pos_i.distance(pos_j) <= distance {
-									group.push(j);
-								}
-							}
-						}
-					}
-				}
-			}
-
-			// Create merged point - calculate positions as needed
-			let merged_position = group
-				.iter()
-				.map(|&idx| transform.transform_point2(self.point_domain.positions()[idx]))
-				.fold(DVec2::ZERO, |sum, pos| sum + pos)
-				/ group.len() as f64;
-
-			let merged_position = transform.inverse().transform_point2(merged_position);
-			let merged_index = merged_positions.len();
-
-			merged_positions.push(merged_position);
-			merged_indices.push(self.point_domain.ids()[group[0]]);
-
-			// Update mapping for all points in the group
-			for &idx in &group {
-				point_index_map[idx] = Some(merged_index);
-			}
-		}
-
-		// Create new point domain with merged points
-		let mut new_point_domain = PointDomain::new();
-		for (idx, pos) in merged_indices.into_iter().zip(merged_positions) {
-			new_point_domain.push(idx, pos);
-		}
-
-		// Update segment domain
-		let mut new_segment_domain = SegmentDomain::new();
-		for segment_idx in 0..self.segment_domain.ids().len() {
-			let id = self.segment_domain.ids()[segment_idx];
-			let start = self.segment_domain.start_point()[segment_idx];
-			let end = self.segment_domain.end_point()[segment_idx];
-			let handles = self.segment_domain.handles()[segment_idx];
-			let stroke = self.segment_domain.stroke()[segment_idx];
-
-			// Get new indices for start and end points
-			let new_start = point_index_map[start].unwrap();
-			let new_end = point_index_map[end].unwrap();
-
-			// Skip segments where start and end points were merged
-			if new_start != new_end {
-				new_segment_domain.push(id, new_start, new_end, handles, stroke);
-			}
-		}
-
-		// Create new vector data
-		self.point_domain = new_point_domain;
-		self.segment_domain = new_segment_domain;
-	}
-}

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

@@ -1,5 +0,0 @@
-pub mod bezpath_algorithms;
-pub mod merge_by_distance;
-pub mod offset_subpath;
-pub mod poisson_disk;
-pub mod spline;

node-graph/gcore/src/vector/algorithms/offset_subpath.rs

@@ -1,173 +0,0 @@
-use crate::vector::PointId;
-use bezier_rs::{Bezier, BezierHandles, Join, Subpath, TValue};
-
-/// Value to control smoothness and mathematical accuracy to offset a cubic Bezier.
-const CUBIC_REGULARIZATION_ACCURACY: f64 = 0.5;
-/// Accuracy of fitting offset curve to Bezier paths.
-const CUBIC_TO_BEZPATH_ACCURACY: f64 = 1e-3;
-/// Constant used to determine if `f64`s are equivalent.
-pub const MAX_ABSOLUTE_DIFFERENCE: f64 = 1e-3;
-
-fn segment_to_bezier(seg: kurbo::PathSeg) -> Bezier {
-	match seg {
-		kurbo::PathSeg::Line(line) => Bezier::from_linear_coordinates(line.p0.x, line.p0.y, line.p1.x, line.p1.y),
-		kurbo::PathSeg::Quad(quad_bez) => Bezier::from_quadratic_coordinates(quad_bez.p0.x, quad_bez.p0.y, quad_bez.p1.x, quad_bez.p1.y, quad_bez.p1.x, quad_bez.p1.y),
-		kurbo::PathSeg::Cubic(cubic_bez) => Bezier::from_cubic_coordinates(
-			cubic_bez.p0.x,
-			cubic_bez.p0.y,
-			cubic_bez.p1.x,
-			cubic_bez.p1.y,
-			cubic_bez.p2.x,
-			cubic_bez.p2.y,
-			cubic_bez.p3.x,
-			cubic_bez.p3.y,
-		),
-	}
-}
-
-// TODO: Replace the implementation to use only Kurbo API.
-/// Reduces the segments of the subpath into simple subcurves, then offset each subcurve a set `distance` away.
-/// The intersections of segments of the subpath are joined using the method specified by the `join` argument.
-pub fn offset_subpath(subpath: &Subpath<PointId>, distance: f64, join: Join) -> Subpath<PointId> {
-	// An offset at a distance 0 from the curve is simply the same curve.
-	// An offset of a single point is not defined.
-	if distance == 0. || subpath.len() <= 1 || subpath.len_segments() < 1 {
-		return subpath.clone();
-	}
-
-	let mut subpaths = subpath
-			.iter()
-			.filter(|bezier| !bezier.is_point())
-			.map(|bezier| bezier.to_cubic())
-			.map(|cubic| {
-				let Bezier { start, end, handles } = cubic;
-				let BezierHandles::Cubic { handle_start, handle_end } = handles else { unreachable!()};
-
-				let cubic_bez = kurbo::CubicBez::new((start.x, start.y), (handle_start.x, handle_start.y), (handle_end.x, handle_end.y), (end.x, end.y));
-				let cubic_offset = kurbo::offset::CubicOffset::new_regularized(cubic_bez, distance, CUBIC_REGULARIZATION_ACCURACY);
-				let offset_bezpath = kurbo::fit_to_bezpath(&cubic_offset, CUBIC_TO_BEZPATH_ACCURACY);
-
-				let beziers = offset_bezpath.segments().fold(Vec::new(), |mut acc, seg| {
-					acc.push(segment_to_bezier(seg));
-					acc
-				});
-
-				Subpath::from_beziers(&beziers, false)
-			})
-			.filter(|subpath| subpath.len() >= 2) // In some cases the reduced and scaled bézier is marked by is_point (so the subpath is empty).
-			.collect::<Vec<Subpath<PointId>>>();
-
-	let mut drop_common_point = vec![true; subpath.len()];
-
-	// Clip or join consecutive Subpaths
-	for i in 0..subpaths.len() - 1 {
-		let j = i + 1;
-		let subpath1 = &subpaths[i];
-		let subpath2 = &subpaths[j];
-
-		let last_segment = subpath1.get_segment(subpath1.len_segments() - 1).unwrap();
-		let first_segment = subpath2.get_segment(0).unwrap();
-
-		// If the anchors are approximately equal, there is no need to clip / join the segments
-		if last_segment.end().abs_diff_eq(first_segment.start(), MAX_ABSOLUTE_DIFFERENCE) {
-			continue;
-		}
-
-		// Calculate the angle formed between two consecutive Subpaths
-		let out_tangent = subpath.get_segment(i).unwrap().tangent(TValue::Parametric(1.));
-		let in_tangent = subpath.get_segment(j).unwrap().tangent(TValue::Parametric(0.));
-		let angle = out_tangent.angle_to(in_tangent);
-
-		// The angle is concave. The Subpath overlap and must be clipped
-		let mut apply_join = true;
-		if (angle > 0. && distance > 0.) || (angle < 0. && distance < 0.) {
-			// If the distance is large enough, there may still be no intersections. Also, if the angle is close enough to zero,
-			// subpath intersections may find no intersections. In this case, the points are likely close enough that we can approximate
-			// the points as being on top of one another.
-			if let Some((clipped_subpath1, clipped_subpath2)) = Subpath::clip_simple_subpaths(subpath1, subpath2) {
-				subpaths[i] = clipped_subpath1;
-				subpaths[j] = clipped_subpath2;
-				apply_join = false;
-			}
-		}
-		// The angle is convex. The Subpath must be joined using the specified join type
-		if apply_join {
-			drop_common_point[j] = false;
-			match join {
-				Join::Bevel => {}
-				Join::Miter(miter_limit) => {
-					let miter_manipulator_group = subpaths[i].miter_line_join(&subpaths[j], miter_limit);
-					if let Some(miter_manipulator_group) = miter_manipulator_group {
-						subpaths[i].manipulator_groups_mut().push(miter_manipulator_group);
-					}
-				}
-				Join::Round => {
-					let (out_handle, round_point, in_handle) = subpaths[i].round_line_join(&subpaths[j], subpath.manipulator_groups()[j].anchor);
-					let last_index = subpaths[i].manipulator_groups().len() - 1;
-					subpaths[i].manipulator_groups_mut()[last_index].out_handle = Some(out_handle);
-					subpaths[i].manipulator_groups_mut().push(round_point);
-					subpaths[j].manipulator_groups_mut()[0].in_handle = Some(in_handle);
-				}
-			}
-		}
-	}
-
-	// Clip any overlap in the last segment
-	if subpath.closed {
-		let out_tangent = subpath.get_segment(subpath.len_segments() - 1).unwrap().tangent(TValue::Parametric(1.));
-		let in_tangent = subpath.get_segment(0).unwrap().tangent(TValue::Parametric(0.));
-		let angle = out_tangent.angle_to(in_tangent);
-
-		let mut apply_join = true;
-		if (angle > 0. && distance > 0.) || (angle < 0. && distance < 0.) {
-			if let Some((clipped_subpath1, clipped_subpath2)) = Subpath::clip_simple_subpaths(&subpaths[subpaths.len() - 1], &subpaths[0]) {
-				// Merge the clipped subpaths
-				let last_index = subpaths.len() - 1;
-				subpaths[last_index] = clipped_subpath1;
-				subpaths[0] = clipped_subpath2;
-				apply_join = false;
-			}
-		}
-		if apply_join {
-			drop_common_point[0] = false;
-			match join {
-				Join::Bevel => {}
-				Join::Miter(miter_limit) => {
-					let last_subpath_index = subpaths.len() - 1;
-					let miter_manipulator_group = subpaths[last_subpath_index].miter_line_join(&subpaths[0], miter_limit);
-					if let Some(miter_manipulator_group) = miter_manipulator_group {
-						subpaths[last_subpath_index].manipulator_groups_mut().push(miter_manipulator_group);
-					}
-				}
-				Join::Round => {
-					let last_subpath_index = subpaths.len() - 1;
-					let (out_handle, round_point, in_handle) = subpaths[last_subpath_index].round_line_join(&subpaths[0], subpath.manipulator_groups()[0].anchor);
-					let last_index = subpaths[last_subpath_index].manipulator_groups().len() - 1;
-					subpaths[last_subpath_index].manipulator_groups_mut()[last_index].out_handle = Some(out_handle);
-					subpaths[last_subpath_index].manipulator_groups_mut().push(round_point);
-					subpaths[0].manipulator_groups_mut()[0].in_handle = Some(in_handle);
-				}
-			}
-		}
-	}
-
-	// Merge the subpaths. Drop points which overlap with one another.
-	let mut manipulator_groups = subpaths[0].manipulator_groups().to_vec();
-	for i in 1..subpaths.len() {
-		if drop_common_point[i] {
-			let last_group = manipulator_groups.pop().unwrap();
-			let mut manipulators_copy = subpaths[i].manipulator_groups().to_vec();
-			manipulators_copy[0].in_handle = last_group.in_handle;
-
-			manipulator_groups.append(&mut manipulators_copy);
-		} else {
-			manipulator_groups.append(&mut subpaths[i].manipulator_groups().to_vec());
-		}
-	}
-	if subpath.closed && drop_common_point[0] {
-		let last_group = manipulator_groups.pop().unwrap();
-		manipulator_groups[0].in_handle = last_group.in_handle;
-	}
-
-	Subpath::new(manipulator_groups, subpath.closed)
-}

node-graph/gcore/src/vector/algorithms/poisson_disk.rs

@@ -1,422 +0,0 @@
-use glam::DVec2;
-use std::collections::HashMap;
-use std::f64;
-
-const DEEPEST_SUBDIVISION_LEVEL_BEFORE_DISCARDING: usize = 8;
-
-/// Fast (O(n) with respect to time and memory) algorithm for generating a maximal set of points using Poisson-disk sampling.
-/// Based on the paper:
-/// "Poisson Disk Point Sets by Hierarchical Dart Throwing"
-/// <https://scholarsarchive.byu.edu/facpub/237/>
-pub fn poisson_disk_sample(
-	offset: DVec2,
-	width: f64,
-	height: f64,
-	diameter: f64,
-	point_in_shape_checker: impl Fn(DVec2) -> bool,
-	line_intersect_shape_checker: impl Fn((f64, f64), (f64, f64)) -> bool,
-	rng: impl FnMut() -> f64,
-) -> Vec<DVec2> {
-	let mut rng = rng;
-	let diameter_squared = diameter.powi(2);
-
-	// Initialize a place to store the generated points within a spatial acceleration structure
-	let mut points_grid = AccelerationGrid::new(width, height, diameter);
-
-	// Pick a grid size for the base-level domain that's as large as possible, while also:
-	// - Dividing into an integer number of cells across the dartboard domain, to avoid wastefully throwing darts beyond the width and height of the dartboard domain
-	// - Being fully covered by the radius around a dart thrown anywhere in its area, where the worst-case is a corner which has a distance of sqrt(2) to the opposite corner
-	let greater_dimension = width.max(height);
-	let base_level_grid_size = greater_dimension / (greater_dimension * f64::consts::SQRT_2 / (diameter / 2.)).ceil();
-
-	// Initialize the problem by including all base-level squares in the active list since they're all part of the yet-to-be-targetted dartboard domain
-	let base_level = ActiveListLevel::new_filled(base_level_grid_size, offset, width, height, &point_in_shape_checker, &line_intersect_shape_checker);
-	// In the future, if necessary, this could be turned into a fixed-length array with worst-case length `f64::MANTISSA_DIGITS`
-	let mut active_list_levels = vec![base_level];
-
-	// Loop until all active squares have been processed, meaning all of the dartboard domain has been checked
-	while active_list_levels.iter().any(|active_list| active_list.not_empty()) {
-		// Randomly pick a square in the dartboard domain, with probability proportional to its area
-		let (active_square_level, active_square_index_in_level) = target_active_square(&active_list_levels, &mut rng);
-
-		// The level contains the list of all active squares at this target square's subdivision depth
-		let level = &mut active_list_levels[active_square_level];
-
-		// Take the targetted active square out of the list and get its size
-		let active_square = level.take_square(active_square_index_in_level);
-		let active_square_size = level.square_size();
-
-		// Skip this target square if it's within range of any current points, since more nearby points could have been added after this square was included in the active list
-		if !square_not_covered_by_poisson_points(active_square.top_left_corner(), active_square_size / 2., diameter_squared, &points_grid) {
-			continue;
-		}
-
-		// Throw a dart by picking a random point within this target square
-		let point = {
-			let active_top_left_corner = active_square.top_left_corner();
-			let x = active_top_left_corner.x + rng() * active_square_size;
-			let y = active_top_left_corner.y + rng() * active_square_size;
-			(x, y).into()
-		};
-
-		// If the dart hit a valid spot, save that point (we're now permanently done with this target square's region)
-		if point_not_covered_by_poisson_points(point, diameter_squared, &points_grid) {
-			// Silently reject the point if it lies outside the shape
-			if active_square.fully_in_shape() || point_in_shape_checker(point + offset) {
-				points_grid.insert(point);
-			}
-		}
-		// Otherwise, subdivide this target square and add valid sub-squares back to the active list for later targetting
-		else {
-			// Discard any targetable domain smaller than this limited number of subdivision levels since it's too small to matter
-			let next_level_deeper_level = active_square_level + 1;
-			if next_level_deeper_level > DEEPEST_SUBDIVISION_LEVEL_BEFORE_DISCARDING {
-				continue;
-			}
-
-			// If necessary for the following step, add another layer of depth to store squares at the next subdivision level
-			if active_list_levels.len() <= next_level_deeper_level {
-				active_list_levels.push(ActiveListLevel::new(active_square_size / 2.))
-			}
-
-			// Get the list of active squares at the level of depth beneath this target square's level
-			let next_level_deeper = &mut active_list_levels[next_level_deeper_level];
-
-			// Subdivide this target square into four sub-squares; running out of numerical precision will make this terminate at very small scales
-			let subdivided_size = active_square_size / 2.;
-			let active_top_left_corner = active_square.top_left_corner();
-			let subdivided = [
-				active_top_left_corner + DVec2::new(0., 0.),
-				active_top_left_corner + DVec2::new(subdivided_size, 0.),
-				active_top_left_corner + DVec2::new(0., subdivided_size),
-				active_top_left_corner + DVec2::new(subdivided_size, subdivided_size),
-			];
-
-			// Add the sub-squares which aren't within the radius of a nearby point to the sub-level's active list
-			let half_subdivided_size = subdivided_size / 2.;
-			let new_sub_squares = subdivided.into_iter().filter_map(|sub_square| {
-				// Any sub-squares within the radius of a nearby point are filtered out
-				if !square_not_covered_by_poisson_points(sub_square, half_subdivided_size, diameter_squared, &points_grid) {
-					return None;
-				}
-
-				// Fully inside the shape
-				if active_square.fully_in_shape() {
-					Some(ActiveSquare::new(sub_square, true))
-				}
-				// Intersecting the shape's border
-				else {
-					// The sub-square is fully inside the shape if its top-left corner is inside and its edges don't intersect the shape border
-					let point_with_offset = sub_square + offset;
-					let square_edges_intersect_shape = {
-						let min = point_with_offset;
-						let max = min + DVec2::splat(subdivided_size);
-
-						// Top edge line
-						line_intersect_shape_checker((min.x, min.y), (max.x, min.y)) ||
-						// Right edge line
-						line_intersect_shape_checker((max.x, min.y), (max.x, max.y)) ||
-						// Bottom edge line
-						line_intersect_shape_checker((max.x, max.y), (min.x, max.y)) ||
-						// Left edge line
-						line_intersect_shape_checker((min.x, max.y), (min.x, min.y))
-					};
-					let sub_square_fully_inside_shape = !square_edges_intersect_shape && point_in_shape_checker(point_with_offset) && point_in_shape_checker(point_with_offset + subdivided_size);
-
-					Some(ActiveSquare::new(sub_square, sub_square_fully_inside_shape))
-				}
-			});
-			next_level_deeper.add_squares(new_sub_squares);
-		}
-	}
-
-	points_grid.final_points(offset)
-}
-
-/// Randomly pick a square in the dartboard domain, with probability proportional to its area.
-/// Returns a tuple with the subdivision level depth and the square index at that depth.
-fn target_active_square(active_list_levels: &[ActiveListLevel], rng: &mut impl FnMut() -> f64) -> (usize, usize) {
-	let active_squares_total_area: f64 = active_list_levels.iter().map(|active_list| active_list.total_area()).sum();
-	let mut index_into_area = rng() * active_squares_total_area;
-
-	for (level, active_list_level) in active_list_levels.iter().enumerate() {
-		let subtracted = index_into_area - active_list_level.total_area();
-		if subtracted > 0. {
-			index_into_area = subtracted;
-			continue;
-		}
-
-		let active_square_index_in_level = (index_into_area / active_list_levels[level].square_area()).floor() as usize;
-		return (level, active_square_index_in_level);
-	}
-
-	panic!("index_into_area couldn't be be mapped to a square in any level of the active lists");
-}
-
-fn point_not_covered_by_poisson_points(point: DVec2, diameter_squared: f64, points_grid: &AccelerationGrid) -> bool {
-	points_grid.nearby_points(point).all(|nearby_point| {
-		let x_separation = nearby_point.x - point.x;
-		let y_separation = nearby_point.y - point.y;
-
-		x_separation.powi(2) + y_separation.powi(2) > diameter_squared
-	})
-}
-
-fn square_not_covered_by_poisson_points(point: DVec2, half_square_size: f64, diameter_squared: f64, points_grid: &AccelerationGrid) -> bool {
-	let square_center_x = point.x + half_square_size;
-	let square_center_y = point.y + half_square_size;
-
-	points_grid.nearby_points(point).all(|nearby_point| {
-		let x_distance = (square_center_x - nearby_point.x).abs() + half_square_size;
-		let y_distance = (square_center_y - nearby_point.y).abs() + half_square_size;
-
-		x_distance.powi(2) + y_distance.powi(2) > diameter_squared
-	})
-}
-
-#[inline(always)]
-fn cartesian_product<A, B>(a: A, b: B) -> impl Iterator<Item = (A::Item, B::Item)>
-where
-	A: Iterator + Clone,
-	B: Iterator + Clone,
-	A::Item: Clone,
-	B::Item: Clone,
-{
-	a.flat_map(move |i| (b.clone().map(move |j| (i.clone(), j))))
-}
-
-/// A square (represented by its top left corner position and width/height of `square_size`) that is currently a candidate for targetting by the dart throwing process.
-/// The positive sign bit encodes if the square is contained entirely within the masking shape, or negative if it's outside or intersects the shape path.
-pub struct ActiveSquare(DVec2);
-
-impl ActiveSquare {
-	pub fn new(top_left_corner: DVec2, fully_in_shape: bool) -> Self {
-		Self(if fully_in_shape { top_left_corner } else { -top_left_corner })
-	}
-
-	pub fn top_left_corner(&self) -> DVec2 {
-		self.0.abs()
-	}
-
-	pub fn fully_in_shape(&self) -> bool {
-		self.0.x.is_sign_positive()
-	}
-}
-
-pub struct ActiveListLevel {
-	/// List of all subdivided squares of the same size that are currently candidates for targetting by the dart throwing process
-	active_squares: Vec<ActiveSquare>,
-	/// Width and height of the squares in this level of subdivision
-	square_size: f64,
-	/// Current sum of the area in all active squares in this subdivision level
-	total_area: f64,
-}
-
-impl ActiveListLevel {
-	#[inline(always)]
-	pub fn new(square_size: f64) -> Self {
-		Self {
-			active_squares: Vec::new(),
-			square_size,
-			total_area: 0.,
-		}
-	}
-
-	pub fn new_filled(
-		square_size: f64,
-		offset: DVec2,
-		width: f64,
-		height: f64,
-		point_in_shape_checker: impl Fn(DVec2) -> bool,
-		line_intersect_shape_checker: impl Fn((f64, f64), (f64, f64)) -> bool,
-	) -> Self {
-		// These should divide evenly but rounding is to protect against small numerical imprecision errors
-		let x_squares = (width / square_size).round() as usize;
-		let y_squares = (height / square_size).round() as usize;
-
-		// Hashes based on the grid cell coordinates and direction of the line: (x, y, is_vertical)
-		let mut line_intersection_cache: HashMap<(usize, usize, bool), bool> = HashMap::new();
-
-		// Populate each square with its top-left corner coordinate
-		let active_squares: Vec<_> = cartesian_product(0..x_squares, 0..y_squares)
-			.filter_map(|(x, y)| {
-				let corner = DVec2::new(x as f64 * square_size, y as f64 * square_size);
-				let corner_with_offset = corner + offset;
-
-				// Lazily check (and cache) if the square's edges intersect the shape, which is an expensive operation
-				let mut square_edges_intersect_shape_value = None;
-				let mut square_edges_intersect_shape = || {
-					square_edges_intersect_shape_value.unwrap_or_else(|| {
-						let square_edges_intersect_shape = {
-							let min = corner_with_offset;
-							let max = min + DVec2::splat(square_size);
-
-							// Top edge line
-							*line_intersection_cache.entry((x, y, false)).or_insert_with(|| line_intersect_shape_checker((min.x, min.y), (max.x, min.y))) ||
-							// Right edge line
-							*line_intersection_cache.entry((x + 1, y, true)).or_insert_with(|| line_intersect_shape_checker((max.x, min.y), (max.x, max.y))) ||
-							// Bottom edge line
-							*line_intersection_cache.entry((x, y + 1, false)).or_insert_with(|| line_intersect_shape_checker((max.x, max.y), (min.x, max.y))) ||
-							// Left edge line
-							*line_intersection_cache.entry((x, y, true)).or_insert_with(|| line_intersect_shape_checker((min.x, max.y), (min.x, min.y)))
-						};
-						square_edges_intersect_shape_value = Some(square_edges_intersect_shape);
-						square_edges_intersect_shape
-					})
-				};
-
-				// Check if this cell's top-left corner is inside the shape
-				let point_in_shape = point_in_shape_checker(corner_with_offset);
-
-				// Determine if the square is inside the shape
-				let square_not_outside_shape = point_in_shape || square_edges_intersect_shape();
-				if square_not_outside_shape {
-					// Check if this cell's bottom-right corner is inside the shape
-					let opposite_corner_with_offset = DVec2::new((x + 1) as f64 * square_size, (y + 1) as f64 * square_size) + offset;
-					let opposite_corner_in_shape = point_in_shape_checker(opposite_corner_with_offset);
-
-					let square_in_shape = opposite_corner_in_shape && !square_edges_intersect_shape();
-					Some(ActiveSquare::new(corner, square_in_shape))
-				} else {
-					None
-				}
-			})
-			.collect();
-
-		// Sum every square's area to get the total
-		let total_area = square_size.powi(2) * active_squares.len() as f64;
-
-		Self {
-			active_squares,
-			square_size,
-			total_area,
-		}
-	}
-
-	#[must_use]
-	#[inline(always)]
-	pub fn take_square(&mut self, active_square_index: usize) -> ActiveSquare {
-		let targetted_square = self.active_squares.swap_remove(active_square_index);
-		self.total_area = self.square_size.powi(2) * self.active_squares.len() as f64;
-		targetted_square
-	}
-
-	#[inline(always)]
-	pub fn add_squares(&mut self, new_squares: impl Iterator<Item = ActiveSquare>) {
-		for new_square in new_squares {
-			self.active_squares.push(new_square);
-		}
-		self.total_area = self.square_size.powi(2) * self.active_squares.len() as f64;
-	}
-
-	#[inline(always)]
-	pub fn square_size(&self) -> f64 {
-		self.square_size
-	}
-
-	#[inline(always)]
-	pub fn square_area(&self) -> f64 {
-		self.square_size.powi(2)
-	}
-
-	#[inline(always)]
-	pub fn total_area(&self) -> f64 {
-		self.total_area
-	}
-
-	#[inline(always)]
-	pub fn not_empty(&self) -> bool {
-		!self.active_squares.is_empty()
-	}
-}
-
-#[derive(Clone, Default)]
-pub struct PointsList {
-	// The worst-case number of points in a 3x3 grid is 16 (one at each intersection of the four gridlines per axis)
-	storage_slots: [DVec2; 16],
-	length: usize,
-}
-
-impl PointsList {
-	#[inline(always)]
-	pub fn push(&mut self, point: DVec2) {
-		self.storage_slots[self.length] = point;
-		self.length += 1;
-	}
-
-	#[inline(always)]
-	pub fn list_cell_and_neighbors(&self) -> impl Iterator<Item = DVec2> {
-		// The negative bit is used to store whether a point belongs to a neighboring cell
-		self.storage_slots.into_iter().take(self.length).map(|point| (point.x.abs(), point.y.abs()).into())
-	}
-
-	#[inline(always)]
-	pub fn list_cell(&self) -> impl Iterator<Item = DVec2> {
-		// The negative bit is used to store whether a point belongs to a neighboring cell
-		self.storage_slots
-			.into_iter()
-			.take(self.length)
-			.filter(|point| point.x.is_sign_positive() && point.y.is_sign_positive())
-	}
-}
-
-pub struct AccelerationGrid {
-	size: f64,
-	dimension_x: usize,
-	dimension_y: usize,
-	cells: Vec<PointsList>,
-}
-
-impl AccelerationGrid {
-	#[inline(always)]
-	pub fn new(width: f64, height: f64, size: f64) -> Self {
-		let dimension_x = (width / size).ceil() as usize + 1;
-		let dimension_y = (height / size).ceil() as usize + 1;
-
-		Self {
-			size,
-			dimension_x,
-			dimension_y,
-			cells: vec![PointsList::default(); dimension_x * dimension_y],
-		}
-	}
-
-	#[inline(always)]
-	pub fn insert(&mut self, point: DVec2) {
-		let x = (point.x / self.size).floor() as usize;
-		let y = (point.y / self.size).floor() as usize;
-
-		// Insert this point at this cell and the surrounding cells in a 3x3 patch
-		for (x_offset, y_offset) in cartesian_product((-1)..=1, (-1)..=1) {
-			// Avoid going negative
-			let (x, y) = (x as isize + x_offset, y as isize + y_offset);
-			if x < 0 || y < 0 {
-				continue;
-			}
-			// Avoid going beyond the width or height
-			let (x, y) = (x as usize, y as usize);
-			if x > self.dimension_x - 1 || y > self.dimension_y - 1 {
-				continue;
-			}
-
-			// Get the cell corresponding to the (x, y) index
-			let cell = &mut self.cells[y * self.dimension_x + x];
-
-			// Store the given point in this grid cell, and use the negative bit to indicate if this belongs to a neighboring cell
-			cell.push(if x_offset == 0 && y_offset == 0 { point } else { -point });
-		}
-	}
-
-	#[inline(always)]
-	pub fn nearby_points(&self, point: DVec2) -> impl Iterator<Item = DVec2> {
-		let x = (point.x / self.size).floor() as usize;
-		let y = (point.y / self.size).floor() as usize;
-
-		self.cells[y * self.dimension_x + x].list_cell_and_neighbors()
-	}
-
-	#[inline(always)]
-	pub fn final_points(&self, offset: DVec2) -> Vec<DVec2> {
-		self.cells.iter().flat_map(|cell| cell.list_cell()).map(|point| point + offset).collect()
-	}
-}

node-graph/gcore/src/vector/algorithms/spline.rs

@@ -1,182 +0,0 @@
-use glam::DVec2;
-
-/// Solve for the first handle of an open spline. (The opposite handle can be found by mirroring the result about the anchor.)
-pub fn solve_spline_first_handle_open(points: &[DVec2]) -> Vec<DVec2> {
-	let len_points = points.len();
-	if len_points == 0 {
-		return Vec::new();
-	}
-	if len_points == 1 {
-		return vec![points[0]];
-	}
-
-	// Matrix coefficients a, b and c (see https://mathworld.wolfram.com/CubicSpline.html).
-	// Because the `a` coefficients are all 1, they need not be stored.
-	// This algorithm does a variation of the above algorithm.
-	// Instead of using the traditional cubic (a + bt + ct^2 + dt^3), we use the bezier cubic.
-
-	let mut b = vec![DVec2::new(4., 4.); len_points];
-	b[0] = DVec2::new(2., 2.);
-	b[len_points - 1] = DVec2::new(2., 2.);
-
-	let mut c = vec![DVec2::new(1., 1.); len_points];
-
-	// 'd' is the the second point in a cubic bezier, which is what we solve for
-	let mut d = vec![DVec2::ZERO; len_points];
-
-	d[0] = DVec2::new(2. * points[1].x + points[0].x, 2. * points[1].y + points[0].y);
-	d[len_points - 1] = DVec2::new(3. * points[len_points - 1].x, 3. * points[len_points - 1].y);
-	for idx in 1..(len_points - 1) {
-		d[idx] = DVec2::new(4. * points[idx].x + 2. * points[idx + 1].x, 4. * points[idx].y + 2. * points[idx + 1].y);
-	}
-
-	// Solve with Thomas algorithm (see https://en.wikipedia.org/wiki/Tridiagonal_matrix_algorithm)
-	// Now we do row operations to eliminate `a` coefficients.
-	c[0] /= -b[0];
-	d[0] /= -b[0];
-	#[allow(clippy::assign_op_pattern)]
-	for i in 1..len_points {
-		b[i] += c[i - 1];
-		// For some reason this `+=` version makes the borrow checker mad:
-		// d[i] += d[i-1]
-		d[i] = d[i] + d[i - 1];
-		c[i] /= -b[i];
-		d[i] /= -b[i];
-	}
-
-	// At this point b[i] == -a[i + 1] and a[i] == 0.
-	// Now we do row operations to eliminate 'c' coefficients and solve.
-	d[len_points - 1] *= -1.;
-	#[allow(clippy::assign_op_pattern)]
-	for i in (0..len_points - 1).rev() {
-		d[i] = d[i] - (c[i] * d[i + 1]);
-		d[i] *= -1.; // d[i] /= b[i]
-	}
-
-	d
-}
-
-/// Solve for the first handle of a closed spline. (The opposite handle can be found by mirroring the result about the anchor.)
-/// If called with fewer than 3 points, this function will return an empty result.
-pub fn solve_spline_first_handle_closed(points: &[DVec2]) -> Vec<DVec2> {
-	let len_points = points.len();
-	if len_points < 3 {
-		return Vec::new();
-	}
-
-	// Matrix coefficients `a`, `b` and `c` (see https://mathworld.wolfram.com/CubicSpline.html).
-	// We don't really need to allocate them but it keeps the maths understandable.
-	let a = vec![DVec2::ONE; len_points];
-	let b = vec![DVec2::splat(4.); len_points];
-	let c = vec![DVec2::ONE; len_points];
-
-	let mut cmod = vec![DVec2::ZERO; len_points];
-	let mut u = vec![DVec2::ZERO; len_points];
-
-	// `x` is initially the output of the matrix multiplication, but is converted to the second value.
-	let mut x = vec![DVec2::ZERO; len_points];
-
-	for (i, point) in x.iter_mut().enumerate() {
-		let previous_i = i.checked_sub(1).unwrap_or(len_points - 1);
-		let next_i = (i + 1) % len_points;
-		*point = 3. * (points[next_i] - points[previous_i]);
-	}
-
-	// Solve using https://en.wikipedia.org/wiki/Tridiagonal_matrix_algorithm#Variants (the variant using periodic boundary conditions).
-	// This code below is based on the reference C language implementation provided in that section of the article.
-	let alpha = a[0];
-	let beta = c[len_points - 1];
-
-	// Arbitrary, but chosen such that division by zero is avoided.
-	let gamma = -b[0];
-
-	cmod[0] = alpha / (b[0] - gamma);
-	u[0] = gamma / (b[0] - gamma);
-	x[0] /= b[0] - gamma;
-
-	// Handle from from `1` to `len_points - 2` (inclusive).
-	for ix in 1..=(len_points - 2) {
-		let m = 1.0 / (b[ix] - a[ix] * cmod[ix - 1]);
-		cmod[ix] = c[ix] * m;
-		u[ix] = (0.0 - a[ix] * u[ix - 1]) * m;
-		x[ix] = (x[ix] - a[ix] * x[ix - 1]) * m;
-	}
-
-	// Handle `len_points - 1`.
-	let m = 1.0 / (b[len_points - 1] - alpha * beta / gamma - beta * cmod[len_points - 2]);
-	u[len_points - 1] = (alpha - a[len_points - 1] * u[len_points - 2]) * m;
-	x[len_points - 1] = (x[len_points - 1] - a[len_points - 1] * x[len_points - 2]) * m;
-
-	// Loop from `len_points - 2` to `0` (inclusive).
-	for ix in (0..=(len_points - 2)).rev() {
-		u[ix] = u[ix] - cmod[ix] * u[ix + 1];
-		x[ix] = x[ix] - cmod[ix] * x[ix + 1];
-	}
-
-	let fact = (x[0] + x[len_points - 1] * beta / gamma) / (1.0 + u[0] + u[len_points - 1] * beta / gamma);
-
-	for ix in 0..(len_points) {
-		x[ix] -= fact * u[ix];
-	}
-
-	let mut real = vec![DVec2::ZERO; len_points];
-	for i in 0..len_points {
-		let previous = i.checked_sub(1).unwrap_or(len_points - 1);
-		let next = (i + 1) % len_points;
-		real[i] = x[previous] * a[next] + x[i] * b[i] + x[next] * c[i];
-	}
-
-	// The matrix is now solved.
-
-	// Since we have computed the derivative, work back to find the start handle.
-	for i in 0..len_points {
-		x[i] = (x[i] / 3.) + points[i];
-	}
-
-	x
-}
-
-#[cfg(test)]
-mod tests {
-	use super::*;
-	#[test]
-	fn closed_spline() {
-		use crate::vector::misc::{dvec2_to_point, point_to_dvec2};
-		use kurbo::{BezPath, ParamCurve, ParamCurveDeriv};
-
-		// These points are just chosen arbitrary
-		let points = [DVec2::new(0., 0.), DVec2::new(0., 0.), DVec2::new(6., 5.), DVec2::new(7., 9.), DVec2::new(2., 3.)];
-
-		// List of first handle or second point in a cubic bezier curve.
-		let first_handles = solve_spline_first_handle_closed(&points);
-
-		// Construct the Subpath
-		let mut bezpath = BezPath::new();
-		bezpath.move_to(dvec2_to_point(points[0]));
-
-		for i in 0..first_handles.len() {
-			let next_i = i + 1;
-			let next_i = if next_i == first_handles.len() { 0 } else { next_i };
-
-			// First handle or second point of a cubic Bezier curve.
-			let p1 = dvec2_to_point(first_handles[i]);
-			// Second handle or third point of a cubic Bezier curve.
-			let p2 = dvec2_to_point(2. * points[next_i] - first_handles[next_i]);
-			// Endpoint or fourth point of a cubic Bezier curve.
-			let p3 = dvec2_to_point(points[next_i]);
-
-			bezpath.curve_to(p1, p2, p3);
-		}
-
-		// For each pair of bézier curves, ensure that the second derivative is continuous
-		for (bézier_a, bézier_b) in bezpath.segments().zip(bezpath.segments().skip(1).chain(bezpath.segments().take(1))) {
-			let derivative2_end_a = point_to_dvec2(bézier_a.to_cubic().deriv().eval(1.));
-			let derivative2_start_b = point_to_dvec2(bézier_b.to_cubic().deriv().eval(0.));
-
-			assert!(
-				derivative2_end_a.abs_diff_eq(derivative2_start_b, 1e-10),
-				"second derivative at the end of a {derivative2_end_a} is equal to the second derivative at the start of b {derivative2_start_b}"
-			);
-		}
-	}
-}

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

@@ -1,162 +0,0 @@
-use crate::math::math_ext::QuadExt;
-use crate::math::quad::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/generator_nodes.rs

@@ -1,283 +0,0 @@
-use super::misc::{ArcType, AsU64, GridType};
-use super::{PointId, SegmentId, StrokeId};
-use crate::Ctx;
-use crate::registry::types::{Angle, PixelSize};
-use crate::vector::{HandleId, VectorData, VectorDataTable};
-use bezier_rs::Subpath;
-use glam::DVec2;
-
-trait CornerRadius {
-	fn generate(self, size: DVec2, clamped: bool) -> VectorDataTable;
-}
-impl CornerRadius for f64 {
-	fn generate(self, size: DVec2, clamped: bool) -> VectorDataTable {
-		let clamped_radius = if clamped { self.clamp(0., size.x.min(size.y).max(0.) / 2.) } else { self };
-		VectorDataTable::new(VectorData::from_subpath(Subpath::new_rounded_rect(size / -2., size / 2., [clamped_radius; 4])))
-	}
-}
-impl CornerRadius for [f64; 4] {
-	fn generate(self, size: DVec2, clamped: bool) -> VectorDataTable {
-		let clamped_radius = if clamped {
-			// Algorithm follows the CSS spec: <https://drafts.csswg.org/css-backgrounds/#corner-overlap>
-
-			let mut scale_factor: f64 = 1.;
-			for i in 0..4 {
-				let side_length = if i % 2 == 0 { size.x } else { size.y };
-				let adjacent_corner_radius_sum = self[i] + self[(i + 1) % 4];
-				if side_length < adjacent_corner_radius_sum {
-					scale_factor = scale_factor.min(side_length / adjacent_corner_radius_sum);
-				}
-			}
-			self.map(|x| x * scale_factor)
-		} else {
-			self
-		};
-		VectorDataTable::new(VectorData::from_subpath(Subpath::new_rounded_rect(size / -2., size / 2., clamped_radius)))
-	}
-}
-
-#[node_macro::node(category("Vector: Shape"))]
-fn circle(_: impl Ctx, _primary: (), #[default(50.)] radius: f64) -> VectorDataTable {
-	let radius = radius.abs();
-	VectorDataTable::new(VectorData::from_subpath(Subpath::new_ellipse(DVec2::splat(-radius), DVec2::splat(radius))))
-}
-
-#[node_macro::node(category("Vector: Shape"))]
-fn arc(
-	_: impl Ctx,
-	_primary: (),
-	#[default(50.)] radius: f64,
-	start_angle: Angle,
-	#[default(270.)]
-	#[range((0., 360.))]
-	sweep_angle: Angle,
-	arc_type: ArcType,
-) -> VectorDataTable {
-	VectorDataTable::new(VectorData::from_subpath(Subpath::new_arc(
-		radius,
-		start_angle / 360. * std::f64::consts::TAU,
-		sweep_angle / 360. * std::f64::consts::TAU,
-		match arc_type {
-			ArcType::Open => bezier_rs::ArcType::Open,
-			ArcType::Closed => bezier_rs::ArcType::Closed,
-			ArcType::PieSlice => bezier_rs::ArcType::PieSlice,
-		},
-	)))
-}
-
-#[node_macro::node(category("Vector: Shape"))]
-fn ellipse(_: impl Ctx, _primary: (), #[default(50)] radius_x: f64, #[default(25)] radius_y: f64) -> VectorDataTable {
-	let radius = DVec2::new(radius_x, radius_y);
-	let corner1 = -radius;
-	let corner2 = radius;
-
-	let mut ellipse = VectorData::from_subpath(Subpath::new_ellipse(corner1, corner2));
-
-	let len = ellipse.segment_domain.ids().len();
-	for i in 0..len {
-		ellipse
-			.colinear_manipulators
-			.push([HandleId::end(ellipse.segment_domain.ids()[i]), HandleId::primary(ellipse.segment_domain.ids()[(i + 1) % len])]);
-	}
-
-	VectorDataTable::new(ellipse)
-}
-
-#[node_macro::node(category("Vector: Shape"), properties("rectangle_properties"))]
-fn rectangle<T: CornerRadius>(
-	_: impl Ctx,
-	_primary: (),
-	#[default(100)] width: f64,
-	#[default(100)] height: f64,
-	_individual_corner_radii: bool, // TODO: Move this to the bottom once we have a migration capability
-	#[implementations(f64, [f64; 4])] corner_radius: T,
-	#[default(true)] clamped: bool,
-) -> VectorDataTable {
-	corner_radius.generate(DVec2::new(width, height), clamped)
-}
-
-#[node_macro::node(category("Vector: Shape"))]
-fn regular_polygon<T: AsU64>(
-	_: impl Ctx,
-	_primary: (),
-	#[default(6)]
-	#[hard_min(3.)]
-	#[implementations(u32, u64, f64)]
-	sides: T,
-	#[default(50)] radius: f64,
-) -> VectorDataTable {
-	let points = sides.as_u64();
-	let radius: f64 = radius * 2.;
-	VectorDataTable::new(VectorData::from_subpath(Subpath::new_regular_polygon(DVec2::splat(-radius), points, radius)))
-}
-
-#[node_macro::node(category("Vector: Shape"))]
-fn star<T: AsU64>(
-	_: impl Ctx,
-	_primary: (),
-	#[default(5)]
-	#[hard_min(2.)]
-	#[implementations(u32, u64, f64)]
-	sides: T,
-	#[default(50)] radius_1: f64,
-	#[default(25)] radius_2: f64,
-) -> VectorDataTable {
-	let points = sides.as_u64();
-	let diameter: f64 = radius_1 * 2.;
-	let inner_diameter = radius_2 * 2.;
-
-	VectorDataTable::new(VectorData::from_subpath(Subpath::new_star_polygon(DVec2::splat(-diameter), points, diameter, inner_diameter)))
-}
-
-#[node_macro::node(category("Vector: Shape"))]
-fn line(_: impl Ctx, _primary: (), #[default((0., -50.))] start: PixelSize, #[default((0., 50.))] end: PixelSize) -> VectorDataTable {
-	VectorDataTable::new(VectorData::from_subpath(Subpath::new_line(start, end)))
-}
-
-trait GridSpacing {
-	fn as_dvec2(&self) -> DVec2;
-}
-impl GridSpacing for f64 {
-	fn as_dvec2(&self) -> DVec2 {
-		DVec2::splat(*self)
-	}
-}
-impl GridSpacing for DVec2 {
-	fn as_dvec2(&self) -> DVec2 {
-		*self
-	}
-}
-
-#[node_macro::node(category("Vector: Shape"), properties("grid_properties"))]
-fn grid<T: GridSpacing>(
-	_: impl Ctx,
-	_primary: (),
-	grid_type: GridType,
-	#[hard_min(0.)]
-	#[default(10)]
-	#[implementations(f64, DVec2)]
-	spacing: T,
-	#[default(30., 30.)] angles: DVec2,
-	#[default(10)] columns: u32,
-	#[default(10)] rows: u32,
-) -> VectorDataTable {
-	let (x_spacing, y_spacing) = spacing.as_dvec2().into();
-	let (angle_a, angle_b) = angles.into();
-
-	let mut vector_data = VectorData::default();
-	let mut segment_id = SegmentId::ZERO;
-	let mut point_id = PointId::ZERO;
-
-	match grid_type {
-		GridType::Rectangular => {
-			// Create rectangular grid points and connect them with line segments
-			for y in 0..rows {
-				for x in 0..columns {
-					// Add current point to the grid
-					let current_index = vector_data.point_domain.ids().len();
-					vector_data.point_domain.push(point_id.next_id(), DVec2::new(x_spacing * x as f64, y_spacing * y as f64));
-
-					// Helper function to connect points with line segments
-					let mut push_segment = |to_index: Option<usize>| {
-						if let Some(other_index) = to_index {
-							vector_data
-								.segment_domain
-								.push(segment_id.next_id(), other_index, current_index, bezier_rs::BezierHandles::Linear, StrokeId::ZERO);
-						}
-					};
-
-					// Connect to the point to the left (horizontal connection)
-					push_segment((x > 0).then(|| current_index - 1));
-
-					// Connect to the point above (vertical connection)
-					push_segment(current_index.checked_sub(columns as usize));
-				}
-			}
-		}
-		GridType::Isometric => {
-			// Calculate isometric grid spacing based on angles
-			let tan_a = angle_a.to_radians().tan();
-			let tan_b = angle_b.to_radians().tan();
-			let spacing = DVec2::new(y_spacing / (tan_a + tan_b), y_spacing);
-
-			// Create isometric grid points and connect them with line segments
-			for y in 0..rows {
-				for x in 0..columns {
-					// Add current point to the grid with offset for odd columns
-					let current_index = vector_data.point_domain.ids().len();
-
-					let a_angles_eaten = x.div_ceil(2) as f64;
-					let b_angles_eaten = (x / 2) as f64;
-
-					let offset_y_fraction = b_angles_eaten * tan_b - a_angles_eaten * tan_a;
-
-					let position = DVec2::new(spacing.x * x as f64, spacing.y * y as f64 + offset_y_fraction * spacing.x);
-					vector_data.point_domain.push(point_id.next_id(), position);
-
-					// Helper function to connect points with line segments
-					let mut push_segment = |to_index: Option<usize>| {
-						if let Some(other_index) = to_index {
-							vector_data
-								.segment_domain
-								.push(segment_id.next_id(), other_index, current_index, bezier_rs::BezierHandles::Linear, StrokeId::ZERO);
-						}
-					};
-
-					// Connect to the point to the left
-					push_segment((x > 0).then(|| current_index - 1));
-
-					// Connect to the point directly above
-					push_segment(current_index.checked_sub(columns as usize));
-
-					// Additional diagonal connections for odd columns (creates hexagonal pattern)
-					if x % 2 == 1 {
-						// Connect to the point diagonally up-right (if not at right edge)
-						push_segment(current_index.checked_sub(columns as usize - 1).filter(|_| x + 1 < columns));
-
-						// Connect to the point diagonally up-left
-						push_segment(current_index.checked_sub(columns as usize + 1));
-					}
-				}
-			}
-		}
-	}
-
-	VectorDataTable::new(vector_data)
-}
-
-#[cfg(test)]
-mod tests {
-	use super::*;
-	#[test]
-	fn isometric_grid_test() {
-		// Doesn't crash with weird angles
-		grid((), (), GridType::Isometric, 0., (0., 0.).into(), 5, 5);
-		grid((), (), GridType::Isometric, 90., (90., 90.).into(), 5, 5);
-
-		// Works properly
-		let grid = grid((), (), GridType::Isometric, 10., (30., 30.).into(), 5, 5);
-		assert_eq!(grid.instance_ref_iter().next().unwrap().instance.point_domain.ids().len(), 5 * 5);
-		assert_eq!(grid.instance_ref_iter().next().unwrap().instance.segment_bezier_iter().count(), 4 * 5 + 4 * 9);
-		for (_, bezier, _, _) in grid.instance_ref_iter().next().unwrap().instance.segment_bezier_iter() {
-			assert_eq!(bezier.handles, bezier_rs::BezierHandles::Linear);
-			assert!(
-				((bezier.start - bezier.end).length() - 10.).abs() < 1e-5,
-				"Length of {} should be 10",
-				(bezier.start - bezier.end).length()
-			);
-		}
-	}
-
-	#[test]
-	fn skew_isometric_grid_test() {
-		let grid = grid((), (), GridType::Isometric, 10., (40., 30.).into(), 5, 5);
-		assert_eq!(grid.instance_ref_iter().next().unwrap().instance.point_domain.ids().len(), 5 * 5);
-		assert_eq!(grid.instance_ref_iter().next().unwrap().instance.segment_bezier_iter().count(), 4 * 5 + 4 * 9);
-		for (_, bezier, _, _) in grid.instance_ref_iter().next().unwrap().instance.segment_bezier_iter() {
-			assert_eq!(bezier.handles, bezier_rs::BezierHandles::Linear);
-			let vector = bezier.start - bezier.end;
-			let angle = (vector.angle_to(DVec2::X).to_degrees() + 180.) % 180.;
-			assert!([90., 150., 40.].into_iter().any(|target| (target - angle).abs() < 1e-10), "unexpected angle of {}", angle)
-		}
-	}
-}

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

@@ -1,98 +0,0 @@
-use dyn_any::DynAny;
-use glam::DVec2;
-use kurbo::Point;
-
-/// Represents different ways of calculating the centroid.
-#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize, Hash, DynAny, specta::Type, node_macro::ChoiceType)]
-#[widget(Radio)]
-pub enum CentroidType {
-	/// The center of mass for the area of a solid shape's interior, as if made out of an infinitely flat material.
-	#[default]
-	Area,
-	/// The center of mass for the arc length of a curved shape's perimeter, as if made out of an infinitely thin wire.
-	Length,
-}
-
-pub trait AsU64 {
-	fn as_u64(&self) -> u64;
-}
-impl AsU64 for u32 {
-	fn as_u64(&self) -> u64 {
-		*self as u64
-	}
-}
-impl AsU64 for u64 {
-	fn as_u64(&self) -> u64 {
-		*self
-	}
-}
-impl AsU64 for f64 {
-	fn as_u64(&self) -> u64 {
-		*self as u64
-	}
-}
-
-pub trait AsI64 {
-	fn as_i64(&self) -> i64;
-}
-impl AsI64 for u32 {
-	fn as_i64(&self) -> i64 {
-		*self as i64
-	}
-}
-impl AsI64 for u64 {
-	fn as_i64(&self) -> i64 {
-		*self as i64
-	}
-}
-impl AsI64 for f64 {
-	fn as_i64(&self) -> i64 {
-		*self as i64
-	}
-}
-
-#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize, Hash, DynAny, specta::Type, node_macro::ChoiceType)]
-#[widget(Radio)]
-pub enum GridType {
-	#[default]
-	Rectangular,
-	Isometric,
-}
-
-#[repr(C)]
-#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize, Hash, DynAny, specta::Type, node_macro::ChoiceType)]
-#[widget(Radio)]
-pub enum ArcType {
-	#[default]
-	Open,
-	Closed,
-	PieSlice,
-}
-
-#[repr(C)]
-#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize, Hash, DynAny, specta::Type, node_macro::ChoiceType)]
-#[widget(Radio)]
-pub enum MergeByDistanceAlgorithm {
-	#[default]
-	Spatial,
-	Topological,
-}
-
-#[repr(C)]
-#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize, Hash, DynAny, specta::Type, node_macro::ChoiceType)]
-#[widget(Radio)]
-pub enum PointSpacingType {
-	#[default]
-	/// The desired spacing distance between points.
-	Separation,
-	/// The exact number of points to span the path.
-	Quantity,
-}
-
-pub fn point_to_dvec2(point: Point) -> DVec2 {
-	DVec2 { x: point.x, y: point.y }
-}
-
-pub fn dvec2_to_point(value: DVec2) -> Point {
-	Point { x: value.x, y: value.y }
-}

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

@@ -1,14 +0,0 @@
-pub mod algorithms;
-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

@@ -1,103 +0,0 @@
-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

@@ -1,648 +0,0 @@
-//! Contains stylistic options for SVG elements.
-
-use crate::Color;
-pub use crate::gradient::*;
-use dyn_any::DynAny;
-use glam::DAffine2;
-
-/// Describes the fill of a layer.
-///
-/// Can be None, a solid [Color], or a linear/radial [Gradient].
-///
-/// In the future we'll probably also add a pattern fill. This will probably be named "Paint" in the future.
-#[repr(C)]
-#[derive(Default, Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, DynAny, Hash, specta::Type)]
-pub enum Fill {
-	#[default]
-	None,
-	Solid(Color),
-	Gradient(Gradient),
-}
-
-impl std::fmt::Display for Fill {
-	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-		match self {
-			Self::None => write!(f, "None"),
-			Self::Solid(color) => write!(f, "#{} (Alpha: {}%)", color.to_rgb_hex_srgb(), color.a() * 100.),
-			Self::Gradient(gradient) => write!(f, "{}", gradient),
-		}
-	}
-}
-
-impl Fill {
-	/// Construct a new [Fill::Solid] from a [Color].
-	pub fn solid(color: Color) -> Self {
-		Self::Solid(color)
-	}
-
-	/// Construct a new [Fill::Solid] or [Fill::None] from an optional [Color].
-	pub fn solid_or_none(color: Option<Color>) -> Self {
-		match color {
-			Some(color) => Self::Solid(color),
-			None => Self::None,
-		}
-	}
-
-	/// Evaluate the color at some point on the fill. Doesn't currently work for Gradient.
-	pub fn color(&self) -> Color {
-		match self {
-			Self::None => Color::BLACK,
-			Self::Solid(color) => *color,
-			// TODO: Should correctly sample the gradient the equation here: https://svgwg.org/svg2-draft/pservers.html#Gradients
-			Self::Gradient(Gradient { stops, .. }) => stops.0[0].1,
-		}
-	}
-
-	pub fn lerp(&self, other: &Self, time: f64) -> Self {
-		let transparent = Self::solid(Color::TRANSPARENT);
-		let a = if *self == Self::None { &transparent } else { self };
-		let b = if *other == Self::None { &transparent } else { other };
-
-		match (a, b) {
-			(Self::Solid(a), Self::Solid(b)) => Self::Solid(a.lerp(b, time as f32)),
-			(Self::Solid(a), Self::Gradient(b)) => {
-				let mut solid_to_gradient = b.clone();
-				solid_to_gradient.stops.0.iter_mut().for_each(|(_, color)| *color = *a);
-				let a = &solid_to_gradient;
-				Self::Gradient(a.lerp(b, time))
-			}
-			(Self::Gradient(a), Self::Solid(b)) => {
-				let mut gradient_to_solid = a.clone();
-				gradient_to_solid.stops.0.iter_mut().for_each(|(_, color)| *color = *b);
-				let b = &gradient_to_solid;
-				Self::Gradient(a.lerp(b, time))
-			}
-			(Self::Gradient(a), Self::Gradient(b)) => Self::Gradient(a.lerp(b, time)),
-			_ => Self::None,
-		}
-	}
-
-	/// Extract a gradient from the fill
-	pub fn as_gradient(&self) -> Option<&Gradient> {
-		match self {
-			Self::Gradient(gradient) => Some(gradient),
-			_ => None,
-		}
-	}
-
-	/// Extract a solid color from the fill
-	pub fn as_solid(&self) -> Option<Color> {
-		match self {
-			Self::Solid(color) => Some(*color),
-			_ => None,
-		}
-	}
-
-	/// Find if fill can be represented with only opaque colors
-	pub fn is_opaque(&self) -> bool {
-		match self {
-			Fill::Solid(color) => color.is_opaque(),
-			Fill::Gradient(gradient) => gradient.stops.iter().all(|(_, color)| color.is_opaque()),
-			Fill::None => true,
-		}
-	}
-
-	/// Returns if fill is none
-	pub fn is_none(&self) -> bool {
-		*self == Self::None
-	}
-}
-
-impl From<Color> for Fill {
-	fn from(color: Color) -> Fill {
-		Fill::Solid(color)
-	}
-}
-
-impl From<Option<Color>> for Fill {
-	fn from(color: Option<Color>) -> Fill {
-		Fill::solid_or_none(color)
-	}
-}
-
-impl From<Gradient> for Fill {
-	fn from(gradient: Gradient) -> Fill {
-		Fill::Gradient(gradient)
-	}
-}
-
-/// Describes the fill of a layer, but unlike [`Fill`], this doesn't store a [`Gradient`] directly but just its [`GradientStops`].
-///
-/// Can be None, a solid [Color], or a linear/radial [Gradient].
-///
-/// In the future we'll probably also add a pattern fill.
-#[repr(C)]
-#[derive(Default, Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, DynAny, Hash, specta::Type)]
-pub enum FillChoice {
-	#[default]
-	None,
-	/// WARNING: Color is gamma, not linear!
-	Solid(Color),
-	/// WARNING: Color stops are gamma, not linear!
-	Gradient(GradientStops),
-}
-
-impl FillChoice {
-	pub fn as_solid(&self) -> Option<Color> {
-		let Self::Solid(color) = self else { return None };
-		Some(*color)
-	}
-
-	pub fn as_gradient(&self) -> Option<&GradientStops> {
-		let Self::Gradient(gradient) = self else { return None };
-		Some(gradient)
-	}
-
-	/// Convert this [`FillChoice`] to a [`Fill`] using the provided [`Gradient`] as a base for the positional information of the gradient.
-	/// If a gradient isn't provided, default gradient positional information is used in cases where the [`FillChoice`] is a [`Gradient`].
-	pub fn to_fill(&self, existing_gradient: Option<&Gradient>) -> Fill {
-		match self {
-			Self::None => Fill::None,
-			Self::Solid(color) => Fill::Solid(*color),
-			Self::Gradient(stops) => {
-				let mut fill = existing_gradient.cloned().unwrap_or_default();
-				fill.stops = stops.clone();
-				Fill::Gradient(fill)
-			}
-		}
-	}
-}
-
-impl From<Fill> for FillChoice {
-	fn from(fill: Fill) -> Self {
-		match fill {
-			Fill::None => FillChoice::None,
-			Fill::Solid(color) => FillChoice::Solid(color),
-			Fill::Gradient(gradient) => FillChoice::Gradient(gradient.stops),
-		}
-	}
-}
-
-/// Enum describing the type of [Fill].
-#[repr(C)]
-#[derive(Debug, Clone, Copy, Default, PartialEq, serde::Serialize, serde::Deserialize, DynAny, Hash, specta::Type, node_macro::ChoiceType)]
-#[widget(Radio)]
-pub enum FillType {
-	#[default]
-	Solid,
-	Gradient,
-}
-
-/// The stroke (outline) style of an SVG element.
-#[repr(C)]
-#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize, Hash, DynAny, specta::Type, node_macro::ChoiceType)]
-#[widget(Radio)]
-pub enum StrokeCap {
-	#[default]
-	Butt,
-	Round,
-	Square,
-}
-
-impl StrokeCap {
-	pub fn svg_name(&self) -> &'static str {
-		match self {
-			StrokeCap::Butt => "butt",
-			StrokeCap::Round => "round",
-			StrokeCap::Square => "square",
-		}
-	}
-}
-
-#[repr(C)]
-#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize, Hash, DynAny, specta::Type, node_macro::ChoiceType)]
-#[widget(Radio)]
-pub enum StrokeJoin {
-	#[default]
-	Miter,
-	Bevel,
-	Round,
-}
-
-impl StrokeJoin {
-	pub fn svg_name(&self) -> &'static str {
-		match self {
-			StrokeJoin::Bevel => "bevel",
-			StrokeJoin::Miter => "miter",
-			StrokeJoin::Round => "round",
-		}
-	}
-}
-
-#[repr(C)]
-#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize, Hash, DynAny, specta::Type, node_macro::ChoiceType)]
-#[widget(Radio)]
-pub enum StrokeAlign {
-	#[default]
-	Center,
-	Inside,
-	Outside,
-}
-
-impl StrokeAlign {
-	pub fn is_not_centered(self) -> bool {
-		self != Self::Center
-	}
-}
-
-#[repr(C)]
-#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize, Hash, DynAny, specta::Type, node_macro::ChoiceType)]
-#[widget(Radio)]
-pub enum PaintOrder {
-	#[default]
-	StrokeAbove,
-	StrokeBelow,
-}
-
-impl PaintOrder {
-	pub fn is_default(self) -> bool {
-		self == Self::default()
-	}
-}
-
-fn daffine2_identity() -> DAffine2 {
-	DAffine2::IDENTITY
-}
-
-#[repr(C)]
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, DynAny, specta::Type)]
-#[serde(default)]
-pub struct Stroke {
-	/// Stroke color
-	pub color: Option<Color>,
-	/// Line thickness
-	pub weight: f64,
-	pub dash_lengths: Vec<f64>,
-	pub dash_offset: f64,
-	#[serde(alias = "line_cap")]
-	pub cap: StrokeCap,
-	#[serde(alias = "line_join")]
-	pub join: StrokeJoin,
-	#[serde(alias = "line_join_miter_limit")]
-	pub join_miter_limit: f64,
-	#[serde(default)]
-	pub align: StrokeAlign,
-	#[serde(default = "daffine2_identity")]
-	pub transform: DAffine2,
-	#[serde(default)]
-	pub non_scaling: bool,
-	#[serde(default)]
-	pub paint_order: PaintOrder,
-}
-
-impl std::hash::Hash for Stroke {
-	fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-		self.color.hash(state);
-		self.weight.to_bits().hash(state);
-		{
-			self.dash_lengths.len().hash(state);
-			self.dash_lengths.iter().for_each(|length| length.to_bits().hash(state));
-		}
-		self.dash_offset.to_bits().hash(state);
-		self.cap.hash(state);
-		self.join.hash(state);
-		self.join_miter_limit.to_bits().hash(state);
-		self.align.hash(state);
-		self.transform.to_cols_array().iter().for_each(|x| x.to_bits().hash(state));
-		self.non_scaling.hash(state);
-		self.paint_order.hash(state);
-	}
-}
-
-impl From<Color> for Stroke {
-	fn from(color: Color) -> Self {
-		Self::new(Some(color), 1.)
-	}
-}
-impl From<Option<Color>> for Stroke {
-	fn from(color: Option<Color>) -> Self {
-		Self::new(color, 1.)
-	}
-}
-
-impl Stroke {
-	pub const fn new(color: Option<Color>, weight: f64) -> Self {
-		Self {
-			color,
-			weight,
-			dash_lengths: Vec::new(),
-			dash_offset: 0.,
-			cap: StrokeCap::Butt,
-			join: StrokeJoin::Miter,
-			join_miter_limit: 4.,
-			align: StrokeAlign::Center,
-			transform: DAffine2::IDENTITY,
-			non_scaling: false,
-			paint_order: PaintOrder::StrokeAbove,
-		}
-	}
-
-	pub fn lerp(&self, other: &Self, time: f64) -> Self {
-		Self {
-			color: self.color.map(|color| color.lerp(&other.color.unwrap_or(color), time as f32)),
-			weight: self.weight + (other.weight - self.weight) * time,
-			dash_lengths: self.dash_lengths.iter().zip(other.dash_lengths.iter()).map(|(a, b)| a + (b - a) * time).collect(),
-			dash_offset: self.dash_offset + (other.dash_offset - self.dash_offset) * time,
-			cap: if time < 0.5 { self.cap } else { other.cap },
-			join: if time < 0.5 { self.join } else { other.join },
-			join_miter_limit: self.join_miter_limit + (other.join_miter_limit - self.join_miter_limit) * time,
-			align: if time < 0.5 { self.align } else { other.align },
-			transform: DAffine2::from_mat2_translation(
-				time * self.transform.matrix2 + (1. - time) * other.transform.matrix2,
-				self.transform.translation * time + other.transform.translation * (1. - time),
-			),
-			non_scaling: if time < 0.5 { self.non_scaling } else { other.non_scaling },
-			paint_order: if time < 0.5 { self.paint_order } else { other.paint_order },
-		}
-	}
-
-	/// Get the current stroke color.
-	pub fn color(&self) -> Option<Color> {
-		self.color
-	}
-
-	/// Get the current stroke weight.
-	pub fn weight(&self) -> f64 {
-		self.weight
-	}
-
-	pub fn dash_lengths(&self) -> String {
-		if self.dash_lengths.is_empty() {
-			"none".to_string()
-		} else {
-			self.dash_lengths.iter().map(|v| v.to_string()).collect::<Vec<_>>().join(", ")
-		}
-	}
-
-	pub fn dash_offset(&self) -> f64 {
-		self.dash_offset
-	}
-
-	pub fn cap_index(&self) -> u32 {
-		self.cap as u32
-	}
-
-	pub fn join_index(&self) -> u32 {
-		self.join as u32
-	}
-
-	pub fn join_miter_limit(&self) -> f32 {
-		self.join_miter_limit as f32
-	}
-
-	pub fn with_color(mut self, color: &Option<Color>) -> Option<Self> {
-		self.color = *color;
-
-		Some(self)
-	}
-
-	pub fn with_weight(mut self, weight: f64) -> Self {
-		self.weight = weight;
-		self
-	}
-
-	pub fn with_dash_lengths(mut self, dash_lengths: &str) -> Option<Self> {
-		dash_lengths
-			.split(&[',', ' '])
-			.filter(|x| !x.is_empty())
-			.map(str::parse::<f64>)
-			.collect::<Result<Vec<_>, _>>()
-			.ok()
-			.map(|lengths| {
-				self.dash_lengths = lengths;
-				self
-			})
-	}
-
-	pub fn with_dash_offset(mut self, dash_offset: f64) -> Self {
-		self.dash_offset = dash_offset;
-		self
-	}
-
-	pub fn with_stroke_cap(mut self, stroke_cap: StrokeCap) -> Self {
-		self.cap = stroke_cap;
-		self
-	}
-
-	pub fn with_stroke_join(mut self, stroke_join: StrokeJoin) -> Self {
-		self.join = stroke_join;
-		self
-	}
-
-	pub fn with_stroke_join_miter_limit(mut self, limit: f64) -> Self {
-		self.join_miter_limit = limit;
-		self
-	}
-
-	pub fn with_stroke_align(mut self, stroke_align: StrokeAlign) -> Self {
-		self.align = stroke_align;
-		self
-	}
-
-	pub fn with_non_scaling(mut self, non_scaling: bool) -> Self {
-		self.non_scaling = non_scaling;
-		self
-	}
-
-	pub fn has_renderable_stroke(&self) -> bool {
-		self.weight > 0. && self.color.is_some_and(|color| color.a() != 0.)
-	}
-}
-
-// Having an alpha of 1 to start with leads to a better experience with the properties panel
-impl Default for Stroke {
-	fn default() -> Self {
-		Self {
-			weight: 0.,
-			color: Some(Color::from_rgba8_srgb(0, 0, 0, 255)),
-			dash_lengths: Vec::new(),
-			dash_offset: 0.,
-			cap: StrokeCap::Butt,
-			join: StrokeJoin::Miter,
-			join_miter_limit: 4.,
-			align: StrokeAlign::Center,
-			transform: DAffine2::IDENTITY,
-			non_scaling: false,
-			paint_order: PaintOrder::default(),
-		}
-	}
-}
-
-#[repr(C)]
-#[derive(Debug, Clone, PartialEq, Default, serde::Serialize, serde::Deserialize, DynAny, specta::Type)]
-pub struct PathStyle {
-	pub stroke: Option<Stroke>,
-	pub fill: Fill,
-}
-
-impl std::hash::Hash for PathStyle {
-	fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-		self.stroke.hash(state);
-		self.fill.hash(state);
-	}
-}
-
-impl std::fmt::Display for PathStyle {
-	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-		let fill = &self.fill;
-
-		let stroke = match &self.stroke {
-			Some(stroke) => format!("#{} (Weight: {} px)", stroke.color.map_or("None".to_string(), |c| c.to_rgba_hex_srgb()), stroke.weight),
-			None => "None".to_string(),
-		};
-
-		write!(f, "Fill: {fill}\nStroke: {stroke}")
-	}
-}
-
-impl PathStyle {
-	pub const fn new(stroke: Option<Stroke>, fill: Fill) -> Self {
-		Self { stroke, fill }
-	}
-
-	pub fn lerp(&self, other: &Self, time: f64) -> Self {
-		Self {
-			fill: self.fill.lerp(&other.fill, time),
-			stroke: match (self.stroke.as_ref(), other.stroke.as_ref()) {
-				(Some(a), Some(b)) => Some(a.lerp(b, time)),
-				(Some(a), None) => {
-					if time < 0.5 {
-						Some(a.clone())
-					} else {
-						None
-					}
-				}
-				(None, Some(b)) => {
-					if time < 0.5 {
-						Some(b.clone())
-					} else {
-						None
-					}
-				}
-				(None, None) => None,
-			},
-		}
-	}
-
-	/// Get the current path's [Fill].
-	///
-	/// # Example
-	/// ```
-	/// # use graphene_core::vector::style::{Fill, PathStyle};
-	/// # use graphene_core::raster::color::Color;
-	/// let fill = Fill::solid(Color::RED);
-	/// let style = PathStyle::new(None, fill.clone());
-	///
-	/// assert_eq!(*style.fill(), fill);
-	/// ```
-	pub fn fill(&self) -> &Fill {
-		&self.fill
-	}
-
-	/// Get the current path's [Stroke].
-	///
-	/// # Example
-	/// ```
-	/// # use graphene_core::vector::style::{Fill, Stroke, PathStyle};
-	/// # use graphene_core::raster::color::Color;
-	/// let stroke = Stroke::new(Some(Color::GREEN), 42.);
-	/// let style = PathStyle::new(Some(stroke.clone()), Fill::None);
-	///
-	/// assert_eq!(style.stroke(), Some(stroke));
-	/// ```
-	pub fn stroke(&self) -> Option<Stroke> {
-		self.stroke.clone()
-	}
-
-	/// Replace the path's [Fill] with a provided one.
-	///
-	/// # Example
-	/// ```
-	/// # use graphene_core::vector::style::{Fill, PathStyle};
-	/// # use graphene_core::raster::color::Color;
-	/// let mut style = PathStyle::default();
-	///
-	/// assert_eq!(*style.fill(), Fill::None);
-	///
-	/// let fill = Fill::solid(Color::RED);
-	/// style.set_fill(fill.clone());
-	///
-	/// assert_eq!(*style.fill(), fill);
-	/// ```
-	pub fn set_fill(&mut self, fill: Fill) {
-		self.fill = fill;
-	}
-
-	pub fn set_stroke_transform(&mut self, transform: DAffine2) {
-		if let Some(stroke) = &mut self.stroke {
-			stroke.transform = transform;
-		}
-	}
-
-	/// Replace the path's [Stroke] with a provided one.
-	///
-	/// # Example
-	/// ```
-	/// # use graphene_core::vector::style::{Stroke, PathStyle};
-	/// # use graphene_core::raster::color::Color;
-	/// let mut style = PathStyle::default();
-	///
-	/// assert_eq!(style.stroke(), None);
-	///
-	/// let stroke = Stroke::new(Some(Color::GREEN), 42.);
-	/// style.set_stroke(stroke.clone());
-	///
-	/// assert_eq!(style.stroke(), Some(stroke));
-	/// ```
-	pub fn set_stroke(&mut self, stroke: Stroke) {
-		self.stroke = Some(stroke);
-	}
-
-	/// Set the path's fill to None.
-	///
-	/// # Example
-	/// ```
-	/// # use graphene_core::vector::style::{Fill, PathStyle};
-	/// # use graphene_core::raster::color::Color;
-	/// let mut style = PathStyle::new(None, Fill::Solid(Color::RED));
-	///
-	/// assert_ne!(*style.fill(), Fill::None);
-	///
-	/// style.clear_fill();
-	///
-	/// assert_eq!(*style.fill(), Fill::None);
-	/// ```
-	pub fn clear_fill(&mut self) {
-		self.fill = Fill::None;
-	}
-
-	/// Set the path's stroke to None.
-	///
-	/// # Example
-	/// ```
-	/// # use graphene_core::vector::style::{Fill, Stroke, PathStyle};
-	/// # use graphene_core::raster::color::Color;
-	/// let mut style = PathStyle::new(Some(Stroke::new(Some(Color::GREEN), 42.)), Fill::None);
-	///
-	/// assert!(style.stroke().is_some());
-	///
-	/// style.clear_stroke();
-	///
-	/// assert!(!style.stroke().is_some());
-	/// ```
-	pub fn clear_stroke(&mut self) {
-		self.stroke = None;
-	}
-}
-
-/// Represents different ways of rendering an object
-#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize, Hash, DynAny, specta::Type)]
-pub enum ViewMode {
-	/// Render with normal coloration at the current viewport resolution
-	#[default]
-	Normal,
-	/// Render only the outlines of shapes at the current viewport resolution
-	Outline,
-	/// Render with normal coloration at the document resolution, showing the pixels when the current viewport resolution is higher
-	Pixels,
-}

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

@@ -1,738 +0,0 @@
-mod attributes;
-mod indexed;
-mod modification;
-
-use super::misc::{dvec2_to_point, point_to_dvec2};
-use super::style::{PathStyle, Stroke};
-use crate::bounds::BoundingBox;
-use crate::instances::Instances;
-use crate::math::quad::Quad;
-use crate::transform::Transform;
-use crate::vector::click_target::{ClickTargetType, FreePoint};
-use crate::{AlphaBlending, Color, GraphicGroupTable};
-pub use attributes::*;
-use bezier_rs::{BezierHandles, ManipulatorGroup};
-use core::borrow::Borrow;
-use core::hash::Hash;
-use dyn_any::DynAny;
-use glam::{DAffine2, DVec2};
-pub use indexed::VectorDataIndex;
-use kurbo::{Affine, Rect, Shape};
-pub use modification::*;
-use std::collections::HashMap;
-
-// TODO: Eventually remove this migration document upgrade code
-pub fn migrate_vector_data<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Result<VectorDataTable, D::Error> {
-	use serde::Deserialize;
-
-	#[derive(Clone, Debug, PartialEq, DynAny, serde::Serialize, serde::Deserialize)]
-	pub struct OldVectorData {
-		pub transform: DAffine2,
-		pub alpha_blending: AlphaBlending,
-
-		pub style: PathStyle,
-
-		/// A list of all manipulator groups (referenced in `subpaths`) that have colinear handles (where they're locked at 180° angles from one another).
-		/// This gets read in `graph_operation_message_handler.rs` by calling `inputs.as_mut_slice()` (search for the string `"Shape does not have both `subpath` and `colinear_manipulators` inputs"` to find it).
-		pub colinear_manipulators: Vec<[HandleId; 2]>,
-
-		pub point_domain: PointDomain,
-		pub segment_domain: SegmentDomain,
-		pub region_domain: RegionDomain,
-
-		// Used to store the upstream graphic group during destructive Boolean Operations (and other nodes with a similar effect) so that click targets can be preserved.
-		pub upstream_graphic_group: Option<GraphicGroupTable>,
-	}
-
-	#[derive(serde::Serialize, serde::Deserialize)]
-	#[serde(untagged)]
-	#[allow(clippy::large_enum_variant)]
-	enum EitherFormat {
-		VectorData(VectorData),
-		OldVectorData(OldVectorData),
-		VectorDataTable(VectorDataTable),
-	}
-
-	Ok(match EitherFormat::deserialize(deserializer)? {
-		EitherFormat::VectorData(vector_data) => VectorDataTable::new(vector_data),
-		EitherFormat::OldVectorData(old) => {
-			let mut vector_data_table = VectorDataTable::new(VectorData {
-				style: old.style,
-				colinear_manipulators: old.colinear_manipulators,
-				point_domain: old.point_domain,
-				segment_domain: old.segment_domain,
-				region_domain: old.region_domain,
-				upstream_graphic_group: old.upstream_graphic_group,
-			});
-			*vector_data_table.instance_mut_iter().next().unwrap().transform = old.transform;
-			*vector_data_table.instance_mut_iter().next().unwrap().alpha_blending = old.alpha_blending;
-			vector_data_table
-		}
-		EitherFormat::VectorDataTable(vector_data_table) => vector_data_table,
-	})
-}
-
-pub type VectorDataTable = Instances<VectorData>;
-
-/// [VectorData] is passed between nodes.
-/// It contains a list of subpaths (that may be open or closed), a transform, and some style information.
-///
-/// Segments are connected if they share endpoints.
-#[derive(Clone, Debug, PartialEq, DynAny, serde::Serialize, serde::Deserialize)]
-pub struct VectorData {
-	pub style: PathStyle,
-
-	/// A list of all manipulator groups (referenced in `subpaths`) that have colinear handles (where they're locked at 180° angles from one another).
-	/// This gets read in `graph_operation_message_handler.rs` by calling `inputs.as_mut_slice()` (search for the string `"Shape does not have both `subpath` and `colinear_manipulators` inputs"` to find it).
-	pub colinear_manipulators: Vec<[HandleId; 2]>,
-
-	pub point_domain: PointDomain,
-	pub segment_domain: SegmentDomain,
-	pub region_domain: RegionDomain,
-
-	// Used to store the upstream graphic group during destructive Boolean Operations (and other nodes with a similar effect) so that click targets can be preserved.
-	pub upstream_graphic_group: Option<GraphicGroupTable>,
-}
-
-impl Default for VectorData {
-	fn default() -> Self {
-		Self {
-			style: PathStyle::new(Some(Stroke::new(Some(Color::BLACK), 0.)), super::style::Fill::None),
-			colinear_manipulators: Vec::new(),
-			point_domain: PointDomain::new(),
-			segment_domain: SegmentDomain::new(),
-			region_domain: RegionDomain::new(),
-			upstream_graphic_group: None,
-		}
-	}
-}
-
-impl std::hash::Hash for VectorData {
-	fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-		self.point_domain.hash(state);
-		self.segment_domain.hash(state);
-		self.region_domain.hash(state);
-		self.style.hash(state);
-		self.colinear_manipulators.hash(state);
-	}
-}
-
-impl VectorData {
-	/// Push a subpath to the vector data
-	pub fn append_subpath(&mut self, subpath: impl Borrow<bezier_rs::Subpath<PointId>>, preserve_id: bool) {
-		let subpath: &bezier_rs::Subpath<PointId> = subpath.borrow();
-		let stroke_id = StrokeId::ZERO;
-		let mut point_id = self.point_domain.next_id();
-
-		let handles = |a: &ManipulatorGroup<_>, b: &ManipulatorGroup<_>| match (a.out_handle, b.in_handle) {
-			(None, None) => bezier_rs::BezierHandles::Linear,
-			(Some(handle), None) | (None, Some(handle)) => bezier_rs::BezierHandles::Quadratic { handle },
-			(Some(handle_start), Some(handle_end)) => bezier_rs::BezierHandles::Cubic { handle_start, handle_end },
-		};
-		let [mut first_seg, mut last_seg] = [None, None];
-		let mut segment_id = self.segment_domain.next_id();
-		let mut last_point = None;
-		let mut first_point = None;
-
-		// Construct a bezier segment from the two manipulators on the subpath.
-		for pair in subpath.manipulator_groups().windows(2) {
-			let start = last_point.unwrap_or_else(|| {
-				let id = if preserve_id && !self.point_domain.ids().contains(&pair[0].id) {
-					pair[0].id
-				} else {
-					point_id.next_id()
-				};
-				self.point_domain.push(id, pair[0].anchor);
-				self.point_domain.ids().len() - 1
-			});
-			first_point = Some(first_point.unwrap_or(start));
-			let end = if preserve_id && !self.point_domain.ids().contains(&pair[1].id) {
-				pair[1].id
-			} else {
-				point_id.next_id()
-			};
-			let end_index = self.point_domain.ids().len();
-			self.point_domain.push(end, pair[1].anchor);
-
-			let id = segment_id.next_id();
-			first_seg = Some(first_seg.unwrap_or(id));
-			last_seg = Some(id);
-			self.segment_domain.push(id, start, end_index, handles(&pair[0], &pair[1]), stroke_id);
-
-			last_point = Some(end_index);
-		}
-
-		let fill_id = FillId::ZERO;
-
-		if subpath.closed() {
-			if let (Some(last), Some(first), Some(first_id), Some(last_id)) = (subpath.manipulator_groups().last(), subpath.manipulator_groups().first(), first_point, last_point) {
-				let id = segment_id.next_id();
-				first_seg = Some(first_seg.unwrap_or(id));
-				last_seg = Some(id);
-				self.segment_domain.push(id, last_id, first_id, handles(last, first), stroke_id);
-			}
-
-			if let [Some(first_seg), Some(last_seg)] = [first_seg, last_seg] {
-				self.region_domain.push(self.region_domain.next_id(), first_seg..=last_seg, fill_id);
-			}
-		}
-	}
-
-	pub fn append_free_point(&mut self, point: &FreePoint, preserve_id: bool) {
-		let mut point_id = self.point_domain.next_id();
-
-		// Use the current point ID if it's not already in the domain, otherwise generate a new one
-		let id = if preserve_id && !self.point_domain.ids().contains(&point.id) {
-			point.id
-		} else {
-			point_id.next_id()
-		};
-		self.point_domain.push(id, point.position);
-	}
-
-	/// Construct some new vector data from a single subpath with an identity transform and black fill.
-	pub fn from_subpath(subpath: impl Borrow<bezier_rs::Subpath<PointId>>) -> Self {
-		Self::from_subpaths([subpath], false)
-	}
-
-	/// Construct some new vector data from subpaths with an identity transform and black fill.
-	pub fn from_subpaths(subpaths: impl IntoIterator<Item = impl Borrow<bezier_rs::Subpath<PointId>>>, preserve_id: bool) -> Self {
-		let mut vector_data = Self::default();
-
-		for subpath in subpaths.into_iter() {
-			vector_data.append_subpath(subpath, preserve_id);
-		}
-
-		vector_data
-	}
-
-	pub fn from_target_types(target_types: impl IntoIterator<Item = impl Borrow<ClickTargetType>>, preserve_id: bool) -> Self {
-		let mut vector_data = Self::default();
-
-		for target_type in target_types.into_iter() {
-			match target_type.borrow() {
-				ClickTargetType::Subpath(subpath) => vector_data.append_subpath(subpath, preserve_id),
-				ClickTargetType::FreePoint(point) => vector_data.append_free_point(point, preserve_id),
-			}
-		}
-
-		vector_data
-	}
-
-	/// Compute the bounding boxes of the bezpaths without any transform
-	pub fn bounding_box_rect(&self) -> Option<Rect> {
-		self.bounding_box_with_transform_rect(DAffine2::IDENTITY)
-	}
-
-	pub fn close_subpaths(&mut self) {
-		let segments_to_add: Vec<_> = self
-			.stroke_bezier_paths()
-			.filter(|subpath| !subpath.closed)
-			.filter_map(|subpath| {
-				let (first, last) = subpath.manipulator_groups().first().zip(subpath.manipulator_groups().last())?;
-				let (start, end) = self.point_domain.resolve_id(first.id).zip(self.point_domain.resolve_id(last.id))?;
-				Some((start, end))
-			})
-			.collect();
-
-		for (start, end) in segments_to_add {
-			let segment_id = self.segment_domain.next_id().next_id();
-			self.segment_domain.push(segment_id, start, end, bezier_rs::BezierHandles::Linear, StrokeId::ZERO);
-		}
-	}
-
-	/// Compute the bounding boxes of the subpaths without any transform
-	pub fn bounding_box(&self) -> Option<[DVec2; 2]> {
-		self.bounding_box_with_transform_rect(DAffine2::IDENTITY)
-			.map(|rect| [DVec2::new(rect.x0, rect.y0), DVec2::new(rect.x1, rect.y1)])
-	}
-
-	/// Compute the bounding boxes of the subpaths with the specified transform
-	pub fn bounding_box_with_transform(&self, transform: DAffine2) -> Option<[DVec2; 2]> {
-		self.bounding_box_with_transform_rect(transform)
-			.map(|rect| [DVec2::new(rect.x0, rect.y0), DVec2::new(rect.x1, rect.y1)])
-	}
-
-	/// Compute the bounding boxes of the bezpaths with the specified transform
-	pub fn bounding_box_with_transform_rect(&self, transform: DAffine2) -> Option<Rect> {
-		let combine = |r1: Rect, r2: Rect| r1.union(r2);
-		self.stroke_bezpath_iter()
-			.map(|mut bezpath| {
-				bezpath.apply_affine(Affine::new(transform.to_cols_array()));
-				bezpath.bounding_box()
-			})
-			.reduce(combine)
-	}
-
-	/// Calculate the corners of the bounding box but with a nonzero size.
-	///
-	/// If the layer bounds are `0` in either axis then they are changed to be `1`.
-	pub fn nonzero_bounding_box(&self) -> [DVec2; 2] {
-		let [bounds_min, mut bounds_max] = self.bounding_box().unwrap_or_default();
-
-		let bounds_size = bounds_max - bounds_min;
-		if bounds_size.x < 1e-10 {
-			bounds_max.x = bounds_min.x + 1.;
-		}
-		if bounds_size.y < 1e-10 {
-			bounds_max.y = bounds_min.y + 1.;
-		}
-
-		[bounds_min, bounds_max]
-	}
-
-	/// Compute the pivot of the layer in layerspace (the coordinates of the subpaths)
-	pub fn layerspace_pivot(&self, normalized_pivot: DVec2) -> DVec2 {
-		let [bounds_min, bounds_max] = self.nonzero_bounding_box();
-		let bounds_size = bounds_max - bounds_min;
-		bounds_min + bounds_size * normalized_pivot
-	}
-
-	pub fn start_point(&self) -> impl Iterator<Item = PointId> + '_ {
-		self.segment_domain.start_point().iter().map(|&index| self.point_domain.ids()[index])
-	}
-
-	pub fn end_point(&self) -> impl Iterator<Item = PointId> + '_ {
-		self.segment_domain.end_point().iter().map(|&index| self.point_domain.ids()[index])
-	}
-
-	pub fn push(&mut self, id: SegmentId, start: PointId, end: PointId, handles: bezier_rs::BezierHandles, stroke: StrokeId) {
-		let [Some(start), Some(end)] = [start, end].map(|id| self.point_domain.resolve_id(id)) else {
-			return;
-		};
-		self.segment_domain.push(id, start, end, handles, stroke)
-	}
-
-	pub fn handles_mut(&mut self) -> impl Iterator<Item = (SegmentId, &mut bezier_rs::BezierHandles, PointId, PointId)> {
-		self.segment_domain
-			.handles_mut()
-			.map(|(id, handles, start, end)| (id, handles, self.point_domain.ids()[start], self.point_domain.ids()[end]))
-	}
-
-	pub fn segment_start_from_id(&self, segment: SegmentId) -> Option<PointId> {
-		self.segment_domain.segment_start_from_id(segment).map(|index| self.point_domain.ids()[index])
-	}
-
-	pub fn segment_end_from_id(&self, segment: SegmentId) -> Option<PointId> {
-		self.segment_domain.segment_end_from_id(segment).map(|index| self.point_domain.ids()[index])
-	}
-
-	/// Returns an array for the start and end points of a segment.
-	pub fn points_from_id(&self, segment: SegmentId) -> Option<[PointId; 2]> {
-		self.segment_domain.points_from_id(segment).map(|val| val.map(|index| self.point_domain.ids()[index]))
-	}
-
-	/// Attempts to find another point in the segment that is not the one passed in.
-	pub fn other_point(&self, segment: SegmentId, current: PointId) -> Option<PointId> {
-		let index = self.point_domain.resolve_id(current);
-		index.and_then(|index| self.segment_domain.other_point(segment, index)).map(|index| self.point_domain.ids()[index])
-	}
-
-	/// Gets all points connected to the current one but not including the current one.
-	pub fn connected_points(&self, current: PointId) -> impl Iterator<Item = PointId> + '_ {
-		let index = [self.point_domain.resolve_id(current)].into_iter().flatten();
-		index.flat_map(|index| self.segment_domain.connected_points(index).map(|index| self.point_domain.ids()[index]))
-	}
-
-	/// Returns the number of linear segments connected to the given point.
-	pub fn connected_linear_segments(&self, point_id: PointId) -> usize {
-		self.segment_bezier_iter()
-			.filter(|(_, bez, start, end)| ((*start == point_id || *end == point_id) && matches!(bez.handles, BezierHandles::Linear)))
-			.count()
-	}
-
-	/// Get an array slice of all segment IDs.
-	pub fn segment_ids(&self) -> &[SegmentId] {
-		self.segment_domain.ids()
-	}
-
-	/// Enumerate all segments that start at the point.
-	pub fn start_connected(&self, point: PointId) -> impl Iterator<Item = SegmentId> + '_ {
-		let index = [self.point_domain.resolve_id(point)].into_iter().flatten();
-		index.flat_map(|index| self.segment_domain.start_connected(index))
-	}
-
-	/// Enumerate all segments that end at the point.
-	pub fn end_connected(&self, point: PointId) -> impl Iterator<Item = SegmentId> + '_ {
-		let index = [self.point_domain.resolve_id(point)].into_iter().flatten();
-		index.flat_map(|index| self.segment_domain.end_connected(index))
-	}
-
-	/// Enumerate all segments that start or end at a point, converting them to [`HandleId`s]. Note that the handles may not exist e.g. for a linear segment.
-	pub fn all_connected(&self, point: PointId) -> impl Iterator<Item = HandleId> + '_ {
-		let index = [self.point_domain.resolve_id(point)].into_iter().flatten();
-		index.flat_map(|index| self.segment_domain.all_connected(index))
-	}
-
-	/// Enumerate the number of segments connected to a point. If a segment starts and ends at a point then it is counted twice.
-	pub fn connected_count(&self, point: PointId) -> usize {
-		self.point_domain.resolve_id(point).map_or(0, |point| self.segment_domain.connected_count(point))
-	}
-
-	pub fn check_point_inside_shape(&self, vector_data_transform: DAffine2, point: DVec2) -> bool {
-		let bez_paths: Vec<_> = self
-			.stroke_bezpath_iter()
-			.map(|mut bezpath| {
-				// TODO: apply transform to points instead of modifying the paths
-				bezpath.apply_affine(Affine::new(vector_data_transform.to_cols_array()));
-				bezpath.close_path();
-				let bbox = bezpath.bounding_box();
-				(bezpath, bbox)
-			})
-			.collect();
-
-		// Check against all paths the point is contained in to compute the correct winding number
-		let mut number = 0;
-
-		for (shape, bbox) in bez_paths {
-			if bbox.x0 > point.x || bbox.y0 > point.y || bbox.x1 < point.x || bbox.y1 < point.y {
-				continue;
-			}
-
-			let winding = shape.winding(dvec2_to_point(point));
-			number += winding;
-		}
-
-		// Non-zero fill rule
-		number != 0
-	}
-
-	/// Points that can be extended from.
-	///
-	/// This is usually only points with exactly one connection unless vector meshes are enabled.
-	pub fn extendable_points(&self, vector_meshes: bool) -> impl Iterator<Item = PointId> + '_ {
-		let point_ids = self.point_domain.ids().iter().enumerate();
-		point_ids.filter(move |(index, _)| vector_meshes || self.segment_domain.connected_count(*index) == 1).map(|(_, &id)| id)
-	}
-
-	/// Computes if all the connected handles are colinear for an anchor, or if that handle is colinear for a handle.
-	pub fn colinear(&self, point: ManipulatorPointId) -> bool {
-		let has_handle = |target| self.colinear_manipulators.iter().flatten().any(|&handle| handle == target);
-		match point {
-			ManipulatorPointId::Anchor(id) => {
-				self.start_connected(id).all(|segment| has_handle(HandleId::primary(segment))) && self.end_connected(id).all(|segment| has_handle(HandleId::end(segment)))
-			}
-			ManipulatorPointId::PrimaryHandle(segment) => has_handle(HandleId::primary(segment)),
-			ManipulatorPointId::EndHandle(segment) => has_handle(HandleId::end(segment)),
-		}
-	}
-
-	pub fn other_colinear_handle(&self, handle: HandleId) -> Option<HandleId> {
-		let pair = self.colinear_manipulators.iter().find(|pair| pair.contains(&handle))?;
-		let other = pair.iter().copied().find(|&val| val != handle)?;
-		if handle.to_manipulator_point().get_anchor(self) == other.to_manipulator_point().get_anchor(self) {
-			Some(other)
-		} else {
-			None
-		}
-	}
-
-	pub fn adjacent_segment(&self, manipulator_id: &ManipulatorPointId) -> Option<(PointId, SegmentId)> {
-		match manipulator_id {
-			ManipulatorPointId::PrimaryHandle(segment_id) => {
-				// For start handle, find segments ending at our start point
-				let (start_point_id, _, _) = self.segment_points_from_id(*segment_id)?;
-				let start_index = self.point_domain.resolve_id(start_point_id)?;
-
-				self.segment_domain.end_connected(start_index).find(|&id| id != *segment_id).map(|id| (start_point_id, id)).or(self
-					.segment_domain
-					.start_connected(start_index)
-					.find(|&id| id != *segment_id)
-					.map(|id| (start_point_id, id)))
-			}
-			ManipulatorPointId::EndHandle(segment_id) => {
-				// For end handle, find segments starting at our end point
-				let (_, end_point_id, _) = self.segment_points_from_id(*segment_id)?;
-				let end_index = self.point_domain.resolve_id(end_point_id)?;
-
-				self.segment_domain.start_connected(end_index).find(|&id| id != *segment_id).map(|id| (end_point_id, id)).or(self
-					.segment_domain
-					.end_connected(end_index)
-					.find(|&id| id != *segment_id)
-					.map(|id| (end_point_id, id)))
-			}
-			ManipulatorPointId::Anchor(_) => None,
-		}
-	}
-
-	pub fn concat(&mut self, additional: &Self, transform_of_additional: DAffine2, collision_hash_seed: u64) {
-		let point_map = additional
-			.point_domain
-			.ids()
-			.iter()
-			.filter(|id| self.point_domain.ids().contains(id))
-			.map(|&old| (old, old.generate_from_hash(collision_hash_seed)))
-			.collect::<HashMap<_, _>>();
-
-		let segment_map = additional
-			.segment_domain
-			.ids()
-			.iter()
-			.filter(|id| self.segment_domain.ids().contains(id))
-			.map(|&old| (old, old.generate_from_hash(collision_hash_seed)))
-			.collect::<HashMap<_, _>>();
-
-		let region_map = additional
-			.region_domain
-			.ids()
-			.iter()
-			.filter(|id| self.region_domain.ids().contains(id))
-			.map(|&old| (old, old.generate_from_hash(collision_hash_seed)))
-			.collect::<HashMap<_, _>>();
-
-		let id_map = IdMap {
-			point_offset: self.point_domain.ids().len(),
-			point_map,
-			segment_map,
-			region_map,
-		};
-
-		self.point_domain.concat(&additional.point_domain, transform_of_additional, &id_map);
-		self.segment_domain.concat(&additional.segment_domain, transform_of_additional, &id_map);
-		self.region_domain.concat(&additional.region_domain, transform_of_additional, &id_map);
-
-		// TODO: properly deal with fills such as gradients
-		self.style = additional.style.clone();
-
-		self.colinear_manipulators.extend(additional.colinear_manipulators.iter().copied());
-	}
-}
-
-impl BoundingBox for VectorDataTable {
-	fn bounding_box(&self, transform: DAffine2, include_stroke: bool) -> Option<[DVec2; 2]> {
-		self.instance_ref_iter()
-			.flat_map(|instance| {
-				if !include_stroke {
-					return instance.instance.bounding_box_with_transform(transform * *instance.transform);
-				}
-
-				let stroke_width = instance.instance.style.stroke().map(|s| s.weight()).unwrap_or_default();
-
-				let miter_limit = instance.instance.style.stroke().map(|s| s.join_miter_limit).unwrap_or(1.);
-
-				let scale = transform.decompose_scale();
-
-				// We use the full line width here to account for different styles of stroke caps
-				let offset = DVec2::splat(stroke_width * scale.x.max(scale.y) * miter_limit);
-
-				instance.instance.bounding_box_with_transform(transform * *instance.transform).map(|[a, b]| [a - offset, b + offset])
-			})
-			.reduce(Quad::combine_bounds)
-	}
-}
-
-/// A selectable part of a curve, either an anchor (start or end of a bézier) or a handle (doesn't necessarily go through the bézier but influences curvature).
-#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, DynAny, serde::Serialize, serde::Deserialize)]
-pub enum ManipulatorPointId {
-	/// A control anchor - the start or end point of a bézier.
-	Anchor(PointId),
-	/// The handle for a bézier - the first handle on a cubic and the only handle on a quadratic.
-	PrimaryHandle(SegmentId),
-	/// The end handle on a cubic bézier.
-	EndHandle(SegmentId),
-}
-
-impl ManipulatorPointId {
-	/// Attempt to retrieve the manipulator position in layer space (no transformation applied).
-	#[must_use]
-	#[track_caller]
-	pub fn get_position(&self, vector_data: &VectorData) -> Option<DVec2> {
-		match self {
-			ManipulatorPointId::Anchor(id) => vector_data.point_domain.position_from_id(*id),
-			ManipulatorPointId::PrimaryHandle(id) => vector_data.segment_from_id(*id).and_then(|bezier| bezier.handle_start()),
-			ManipulatorPointId::EndHandle(id) => vector_data.segment_from_id(*id).and_then(|bezier| bezier.handle_end()),
-		}
-	}
-
-	pub fn get_anchor_position(&self, vector_data: &VectorData) -> Option<DVec2> {
-		match self {
-			ManipulatorPointId::EndHandle(_) | ManipulatorPointId::PrimaryHandle(_) => self.get_anchor(vector_data).and_then(|id| vector_data.point_domain.position_from_id(id)),
-			_ => self.get_position(vector_data),
-		}
-	}
-
-	/// Attempt to get a pair of handles. For an anchor this is the first two handles connected. For a handle it is self and the first opposing handle.
-	#[must_use]
-	pub fn get_handle_pair(self, vector_data: &VectorData) -> Option<[HandleId; 2]> {
-		match self {
-			ManipulatorPointId::Anchor(point) => vector_data.all_connected(point).take(2).collect::<Vec<_>>().try_into().ok(),
-			ManipulatorPointId::PrimaryHandle(segment) => {
-				let point = vector_data.segment_domain.segment_start_from_id(segment)?;
-				let current = HandleId::primary(segment);
-				let other = vector_data.segment_domain.all_connected(point).find(|&value| value != current);
-				other.map(|other| [current, other])
-			}
-			ManipulatorPointId::EndHandle(segment) => {
-				let point = vector_data.segment_domain.segment_end_from_id(segment)?;
-				let current = HandleId::end(segment);
-				let other = vector_data.segment_domain.all_connected(point).find(|&value| value != current);
-				other.map(|other| [current, other])
-			}
-		}
-	}
-
-	/// Attempt to find the closest anchor. If self is already an anchor then it is just self. If it is a start or end handle, then the start or end point is chosen.
-	#[must_use]
-	pub fn get_anchor(self, vector_data: &VectorData) -> Option<PointId> {
-		match self {
-			ManipulatorPointId::Anchor(point) => Some(point),
-			ManipulatorPointId::PrimaryHandle(segment) => vector_data.segment_start_from_id(segment),
-			ManipulatorPointId::EndHandle(segment) => vector_data.segment_end_from_id(segment),
-		}
-	}
-
-	/// Attempt to convert self to a [`HandleId`], returning none for an anchor.
-	#[must_use]
-	pub fn as_handle(self) -> Option<HandleId> {
-		match self {
-			ManipulatorPointId::PrimaryHandle(segment) => Some(HandleId::primary(segment)),
-			ManipulatorPointId::EndHandle(segment) => Some(HandleId::end(segment)),
-			ManipulatorPointId::Anchor(_) => None,
-		}
-	}
-
-	/// Attempt to convert self to an anchor, returning None for a handle.
-	#[must_use]
-	pub fn as_anchor(self) -> Option<PointId> {
-		match self {
-			ManipulatorPointId::Anchor(point) => Some(point),
-			_ => None,
-		}
-	}
-
-	pub fn get_segment(self) -> Option<SegmentId> {
-		match self {
-			ManipulatorPointId::PrimaryHandle(segment) | ManipulatorPointId::EndHandle(segment) => Some(segment),
-			_ => None,
-		}
-	}
-}
-
-/// The type of handle found on a bézier curve.
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, DynAny, serde::Serialize, serde::Deserialize)]
-pub enum HandleType {
-	/// The first handle on a cubic bézier or the only handle on a quadratic bézier.
-	Primary,
-	/// The second handle on a cubic bézier.
-	End,
-}
-
-/// Represents a primary or end handle found in a particular segment.
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, DynAny, serde::Serialize, serde::Deserialize)]
-pub struct HandleId {
-	pub ty: HandleType,
-	pub segment: SegmentId,
-}
-
-impl std::fmt::Display for HandleId {
-	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-		match self.ty {
-			// I haven't checked if "out" and "in" are reversed, or are accurate translations of the "primary" and "end" terms used in the `HandleType` enum, so this naming is an assumption.
-			HandleType::Primary => write!(f, "{} out", self.segment.inner()),
-			HandleType::End => write!(f, "{} in", self.segment.inner()),
-		}
-	}
-}
-
-impl HandleId {
-	/// Construct a handle for the first handle on a cubic bézier or the only handle on a quadratic bézier.
-	#[must_use]
-	pub const fn primary(segment: SegmentId) -> Self {
-		Self { ty: HandleType::Primary, segment }
-	}
-
-	/// Construct a handle for the end handle on a cubic bézier.
-	#[must_use]
-	pub const fn end(segment: SegmentId) -> Self {
-		Self { ty: HandleType::End, segment }
-	}
-
-	/// Convert to [`ManipulatorPointId`].
-	#[must_use]
-	pub fn to_manipulator_point(self) -> ManipulatorPointId {
-		match self.ty {
-			HandleType::Primary => ManipulatorPointId::PrimaryHandle(self.segment),
-			HandleType::End => ManipulatorPointId::EndHandle(self.segment),
-		}
-	}
-
-	/// Calculate the magnitude of the handle from the anchor.
-	pub fn length(self, vector_data: &VectorData) -> f64 {
-		let Some(anchor_position) = self.to_manipulator_point().get_anchor_position(vector_data) else {
-			// TODO: This was previously an unwrap which was encountered, so this is a temporary way to avoid a crash
-			return 0.;
-		};
-		let handle_position = self.to_manipulator_point().get_position(vector_data);
-		handle_position.map(|pos| (pos - anchor_position).length()).unwrap_or(f64::MAX)
-	}
-
-	/// Convert an end handle to the primary handle and a primary handle to an end handle. Note that the new handle may not exist (e.g. for a quadratic bézier).
-	#[must_use]
-	pub fn opposite(self) -> Self {
-		match self.ty {
-			HandleType::Primary => Self::end(self.segment),
-			HandleType::End => Self::primary(self.segment),
-		}
-	}
-}
-
-#[cfg(test)]
-fn assert_subpath_eq(generated: &[bezier_rs::Subpath<PointId>], expected: &[bezier_rs::Subpath<PointId>]) {
-	assert_eq!(generated.len(), expected.len());
-	for (generated, expected) in generated.iter().zip(expected) {
-		assert_eq!(generated.manipulator_groups().len(), expected.manipulator_groups().len());
-		assert_eq!(generated.closed(), expected.closed());
-		for (generated, expected) in generated.manipulator_groups().iter().zip(expected.manipulator_groups()) {
-			assert_eq!(generated.in_handle, expected.in_handle);
-			assert_eq!(generated.out_handle, expected.out_handle);
-			assert_eq!(generated.anchor, expected.anchor);
-		}
-	}
-}
-
-#[cfg(test)]
-mod tests {
-	use super::*;
-	#[test]
-	fn construct_closed_subpath() {
-		let circle = bezier_rs::Subpath::new_ellipse(DVec2::NEG_ONE, DVec2::ONE);
-		let vector_data = VectorData::from_subpath(&circle);
-		assert_eq!(vector_data.point_domain.ids().len(), 4);
-		let bezier_paths = vector_data.segment_bezier_iter().map(|(_, bezier, _, _)| bezier).collect::<Vec<_>>();
-		assert_eq!(bezier_paths.len(), 4);
-		assert!(bezier_paths.iter().all(|&bezier| circle.iter().any(|original_bezier| original_bezier == bezier)));
-
-		let generated = vector_data.stroke_bezier_paths().collect::<Vec<_>>();
-		assert_subpath_eq(&generated, &[circle]);
-	}
-
-	#[test]
-	fn construct_open_subpath() {
-		let bezier = bezier_rs::Bezier::from_cubic_dvec2(DVec2::ZERO, DVec2::NEG_ONE, DVec2::ONE, DVec2::X);
-		let subpath = bezier_rs::Subpath::from_bezier(&bezier);
-		let vector_data = VectorData::from_subpath(&subpath);
-		assert_eq!(vector_data.point_domain.ids().len(), 2);
-		let bezier_paths = vector_data.segment_bezier_iter().map(|(_, bezier, _, _)| bezier).collect::<Vec<_>>();
-		assert_eq!(bezier_paths, vec![bezier]);
-
-		let generated = vector_data.stroke_bezier_paths().collect::<Vec<_>>();
-		assert_subpath_eq(&generated, &[subpath]);
-	}
-
-	#[test]
-	fn construct_many_subpath() {
-		let curve = bezier_rs::Bezier::from_cubic_dvec2(DVec2::ZERO, DVec2::NEG_ONE, DVec2::ONE, DVec2::X);
-		let curve = bezier_rs::Subpath::from_bezier(&curve);
-		let circle = bezier_rs::Subpath::new_ellipse(DVec2::NEG_ONE, DVec2::ONE);
-
-		let vector_data = VectorData::from_subpaths([&curve, &circle], false);
-		assert_eq!(vector_data.point_domain.ids().len(), 6);
-
-		let bezier_paths = vector_data.segment_bezier_iter().map(|(_, bezier, _, _)| bezier).collect::<Vec<_>>();
-		assert_eq!(bezier_paths.len(), 5);
-		assert!(bezier_paths.iter().all(|&bezier| circle.iter().chain(curve.iter()).any(|original_bezier| original_bezier == bezier)));
-
-		let generated = vector_data.stroke_bezier_paths().collect::<Vec<_>>();
-		assert_subpath_eq(&generated, &[curve, circle]);
-	}
-}

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

@@ -1,90 +0,0 @@
-use super::{PointId, SegmentId, VectorData};
-use glam::DVec2;
-use petgraph::graph::{EdgeIndex, NodeIndex, UnGraph};
-use rustc_hash::FxHashMap;
-
-/// All the fixed fields of a point from the point domain.
-pub struct Point {
-	pub id: PointId,
-	pub position: DVec2,
-}
-
-/// Useful indexes to speed up various operations on `VectorData`.
-///
-/// Important: It is the user's responsibility to ensure the indexes remain valid after mutations to the data.
-pub struct VectorDataIndex {
-	/// Points and segments form a graph. Store it here in a form amenable to graph algorithms.
-	///
-	/// Currently, segment data is not stored as it is not used, but it could easily be added.
-	pub(crate) point_graph: UnGraph<Point, ()>,
-	pub(crate) segment_to_edge: FxHashMap<SegmentId, EdgeIndex>,
-	/// Get the offset from the point ID.
-	pub(crate) point_to_offset: FxHashMap<PointId, usize>,
-	// TODO: faces
-}
-
-impl VectorDataIndex {
-	/// Construct a [`VectorDataIndex`] by building indexes from the given [`VectorData`]. Takes `O(n)` time.
-	pub fn build_from(data: &VectorData) -> Self {
-		let point_to_offset = data.point_domain.ids().iter().copied().enumerate().map(|(a, b)| (b, a)).collect::<FxHashMap<_, _>>();
-
-		let mut point_to_node = FxHashMap::default();
-		let mut segment_to_edge = FxHashMap::default();
-
-		let mut graph = UnGraph::new_undirected();
-
-		for (point_id, position) in data.point_domain.iter() {
-			let idx = graph.add_node(Point { id: point_id, position });
-			point_to_node.insert(point_id, idx);
-		}
-
-		for (segment_id, start_offset, end_offset, ..) in data.segment_domain.iter() {
-			let start_id = data.point_domain.ids()[start_offset];
-			let end_id = data.point_domain.ids()[end_offset];
-			let edge = graph.add_edge(point_to_node[&start_id], point_to_node[&end_id], ());
-
-			segment_to_edge.insert(segment_id, edge);
-		}
-
-		Self {
-			point_graph: graph,
-			segment_to_edge,
-			point_to_offset,
-		}
-	}
-
-	/// Fetch the length of given segment's chord. Takes `O(1)` time.
-	///
-	/// # Panics
-	///
-	/// Will panic if no segment with the given ID is found.
-	pub fn segment_chord_length(&self, id: SegmentId) -> f64 {
-		let edge_idx = self.segment_to_edge[&id];
-		let (start, end) = self.point_graph.edge_endpoints(edge_idx).unwrap();
-		let start_position = self.point_graph.node_weight(start).unwrap().position;
-		let end_position = self.point_graph.node_weight(end).unwrap().position;
-		(start_position - end_position).length()
-	}
-
-	/// Get the ends of a segment. Takes `O(1)` time.
-	///
-	/// The IDs will be ordered [smallest, largest] so they can be used to find other segments with the same endpoints, regardless of direction.
-	///
-	/// # Panics
-	///
-	/// This function will panic if the ID is not present.
-	pub fn segment_ends(&self, id: SegmentId) -> [NodeIndex; 2] {
-		let (start, end) = self.point_graph.edge_endpoints(self.segment_to_edge[&id]).unwrap();
-		if start < end { [start, end] } else { [end, start] }
-	}
-
-	/// Get the physical location of a point. Takes `O(1)` time.
-	///
-	/// # Panics
-	///
-	/// Will panic if `id` isn't in the data.
-	pub fn point_position(&self, id: PointId, data: &VectorData) -> DVec2 {
-		let offset = self.point_to_offset[&id];
-		data.point_domain.positions()[offset]
-	}
-}

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

@@ -1,725 +0,0 @@
-use super::*;
-use crate::Ctx;
-use crate::instances::Instance;
-use crate::uuid::generate_uuid;
-use bezier_rs::BezierHandles;
-use dyn_any::DynAny;
-use kurbo::{BezPath, PathEl, Point};
-use std::collections::{HashMap, HashSet};
-use std::hash::BuildHasher;
-
-/// Represents a procedural change to the [`PointDomain`] in [`VectorData`].
-#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
-pub struct PointModification {
-	add: Vec<PointId>,
-	remove: HashSet<PointId>,
-	#[serde(serialize_with = "serialize_hashmap", deserialize_with = "deserialize_hashmap")]
-	delta: HashMap<PointId, DVec2>,
-}
-
-impl Hash for PointModification {
-	fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-		generate_uuid().hash(state)
-	}
-}
-
-impl PointModification {
-	/// Apply this modification to the specified [`PointDomain`].
-	pub fn apply(&self, point_domain: &mut PointDomain, segment_domain: &mut SegmentDomain) {
-		point_domain.retain(segment_domain, |id| !self.remove.contains(id));
-
-		for (index, (id, position)) in point_domain.positions_mut().enumerate() {
-			let Some(&delta) = self.delta.get(&id) else { continue };
-			if !delta.is_finite() {
-				warn!("Invalid delta when applying a point modification");
-				continue;
-			}
-
-			*position += delta;
-
-			for (_, handles, start, end) in segment_domain.handles_mut() {
-				if start == index {
-					handles.move_start(delta);
-				}
-				if end == index {
-					handles.move_end(delta);
-				}
-			}
-		}
-
-		for &add_id in &self.add {
-			let Some(&position) = self.delta.get(&add_id) else { continue };
-			if !position.is_finite() {
-				warn!("Invalid position when applying a point modification");
-				continue;
-			}
-
-			point_domain.push(add_id, position);
-		}
-	}
-
-	/// Create a new modification that will convert an empty [`VectorData`] into the target [`VectorData`].
-	pub fn create_from_vector(vector_data: &VectorData) -> Self {
-		Self {
-			add: vector_data.point_domain.ids().to_vec(),
-			remove: HashSet::new(),
-			delta: vector_data.point_domain.ids().iter().copied().zip(vector_data.point_domain.positions().iter().cloned()).collect(),
-		}
-	}
-
-	fn push(&mut self, id: PointId, position: DVec2) {
-		self.add.push(id);
-		self.delta.insert(id, position);
-	}
-
-	fn remove(&mut self, id: PointId) {
-		self.remove.insert(id);
-		self.add.retain(|&add| add != id);
-		self.delta.remove(&id);
-	}
-}
-
-/// Represents a procedural change to the [`SegmentDomain`] in [`VectorData`].
-#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
-pub struct SegmentModification {
-	add: Vec<SegmentId>,
-	remove: HashSet<SegmentId>,
-	#[serde(serialize_with = "serialize_hashmap", deserialize_with = "deserialize_hashmap")]
-	start_point: HashMap<SegmentId, PointId>,
-	#[serde(serialize_with = "serialize_hashmap", deserialize_with = "deserialize_hashmap")]
-	end_point: HashMap<SegmentId, PointId>,
-	#[serde(serialize_with = "serialize_hashmap", deserialize_with = "deserialize_hashmap")]
-	handle_primary: HashMap<SegmentId, Option<DVec2>>,
-	#[serde(serialize_with = "serialize_hashmap", deserialize_with = "deserialize_hashmap")]
-	handle_end: HashMap<SegmentId, Option<DVec2>>,
-	#[serde(serialize_with = "serialize_hashmap", deserialize_with = "deserialize_hashmap")]
-	stroke: HashMap<SegmentId, StrokeId>,
-}
-
-impl SegmentModification {
-	/// Apply this modification to the specified [`SegmentDomain`].
-	pub fn apply(&self, segment_domain: &mut SegmentDomain, point_domain: &PointDomain) {
-		segment_domain.retain(|id| !self.remove.contains(id), point_domain.ids().len());
-
-		for (id, point) in segment_domain.start_point_mut() {
-			let Some(&new) = self.start_point.get(&id) else { continue };
-			let Some(index) = point_domain.resolve_id(new) else {
-				warn!("Invalid start ID when applying a segment modification");
-				continue;
-			};
-
-			*point = index;
-		}
-
-		for (id, point) in segment_domain.end_point_mut() {
-			let Some(&new) = self.end_point.get(&id) else { continue };
-			let Some(index) = point_domain.resolve_id(new) else {
-				warn!("Invalid end ID when applying a segment modification");
-				continue;
-			};
-
-			*point = index;
-		}
-
-		for (id, handles, start, end) in segment_domain.handles_mut() {
-			let Some(&start) = point_domain.positions().get(start) else { continue };
-			let Some(&end) = point_domain.positions().get(end) else { continue };
-
-			// Compute the actual start and end position based on the offset from the anchor
-			let start = self.handle_primary.get(&id).copied().map(|handle| handle.map(|handle| handle + start));
-			let end = self.handle_end.get(&id).copied().map(|handle| handle.map(|handle| handle + end));
-
-			if !start.unwrap_or_default().is_none_or(|start| start.is_finite()) || !end.unwrap_or_default().is_none_or(|end| end.is_finite()) {
-				warn!("Invalid handles when applying a segment modification");
-				continue;
-			}
-
-			match (start, end) {
-				// The new handles are fully specified by the modification
-				(Some(Some(handle_start)), Some(Some(handle_end))) => *handles = BezierHandles::Cubic { handle_start, handle_end },
-				(Some(Some(handle)), Some(None)) | (Some(None), Some(Some(handle))) => *handles = BezierHandles::Quadratic { handle },
-				(Some(None), Some(None)) => *handles = BezierHandles::Linear,
-				// Remove the end handle
-				(None, Some(None)) => {
-					if let BezierHandles::Cubic { handle_start, .. } = *handles {
-						*handles = BezierHandles::Quadratic { handle: handle_start }
-					}
-				}
-				// Change the end handle
-				(None, Some(Some(handle_end))) => match *handles {
-					BezierHandles::Linear => *handles = BezierHandles::Quadratic { handle: handle_end },
-					BezierHandles::Quadratic { handle: handle_start } => *handles = BezierHandles::Cubic { handle_start, handle_end },
-					BezierHandles::Cubic { handle_start, .. } => *handles = BezierHandles::Cubic { handle_start, handle_end },
-				},
-				// Remove the start handle
-				(Some(None), None) => *handles = BezierHandles::Linear,
-				// Change the start handle
-				(Some(Some(handle_start)), None) => match *handles {
-					BezierHandles::Linear => *handles = BezierHandles::Quadratic { handle: handle_start },
-					BezierHandles::Quadratic { .. } => *handles = BezierHandles::Quadratic { handle: handle_start },
-					BezierHandles::Cubic { handle_end, .. } => *handles = BezierHandles::Cubic { handle_start, handle_end },
-				},
-				// No change
-				(None, None) => {}
-			};
-		}
-
-		for (id, stroke) in segment_domain.stroke_mut() {
-			let Some(&new) = self.stroke.get(&id) else { continue };
-			*stroke = new;
-		}
-
-		for &add_id in &self.add {
-			let Some(&start) = self.start_point.get(&add_id) else { continue };
-			let Some(&end) = self.end_point.get(&add_id) else { continue };
-			let Some(&handle_start) = self.handle_primary.get(&add_id) else { continue };
-			let Some(&handle_end) = self.handle_end.get(&add_id) else { continue };
-			let Some(&stroke) = self.stroke.get(&add_id) else { continue };
-
-			let Some(start_index) = point_domain.resolve_id(start) else {
-				warn!("invalid start id: {:#?}", start);
-				continue;
-			};
-			let Some(end_index) = point_domain.resolve_id(end) else {
-				warn!("invalid end id: {:#?}", end);
-				continue;
-			};
-
-			let start_position = point_domain.positions()[start_index];
-			let end_position = point_domain.positions()[end_index];
-			let handles = match (handle_start, handle_end) {
-				(Some(handle_start), Some(handle_end)) => BezierHandles::Cubic {
-					handle_start: handle_start + start_position,
-					handle_end: handle_end + end_position,
-				},
-				(Some(handle), None) | (None, Some(handle)) => BezierHandles::Quadratic { handle: handle + start_position },
-				(None, None) => BezierHandles::Linear,
-			};
-
-			if !handles.is_finite() {
-				warn!("invalid handles");
-				continue;
-			}
-
-			segment_domain.push(add_id, start_index, end_index, handles, stroke);
-		}
-
-		assert!(
-			segment_domain.start_point().iter().all(|&index| index < point_domain.ids().len()),
-			"index should be in range {:#?}",
-			segment_domain
-		);
-		assert!(
-			segment_domain.end_point().iter().all(|&index| index < point_domain.ids().len()),
-			"index should be in range {:#?}",
-			segment_domain
-		);
-	}
-
-	/// Create a new modification that will convert an empty [`VectorData`] into the target [`VectorData`].
-	pub fn create_from_vector(vector_data: &VectorData) -> Self {
-		let point_id = |(&segment, &index)| (segment, vector_data.point_domain.ids()[index]);
-		Self {
-			add: vector_data.segment_domain.ids().to_vec(),
-			remove: HashSet::new(),
-			start_point: vector_data.segment_domain.ids().iter().zip(vector_data.segment_domain.start_point()).map(point_id).collect(),
-			end_point: vector_data.segment_domain.ids().iter().zip(vector_data.segment_domain.end_point()).map(point_id).collect(),
-			handle_primary: vector_data.segment_bezier_iter().map(|(id, b, _, _)| (id, b.handle_start().map(|handle| handle - b.start))).collect(),
-			handle_end: vector_data.segment_bezier_iter().map(|(id, b, _, _)| (id, b.handle_end().map(|handle| handle - b.end))).collect(),
-			stroke: vector_data.segment_domain.ids().iter().copied().zip(vector_data.segment_domain.stroke().iter().cloned()).collect(),
-		}
-	}
-
-	fn push(&mut self, id: SegmentId, points: [PointId; 2], handles: [Option<DVec2>; 2], stroke: StrokeId) {
-		self.remove.remove(&id);
-		self.add.push(id);
-		self.start_point.insert(id, points[0]);
-		self.end_point.insert(id, points[1]);
-		self.handle_primary.insert(id, handles[0]);
-		self.handle_end.insert(id, handles[1]);
-		self.stroke.insert(id, stroke);
-	}
-
-	fn remove(&mut self, id: SegmentId) {
-		self.remove.insert(id);
-		self.add.retain(|&add| add != id);
-		self.start_point.remove(&id);
-		self.end_point.remove(&id);
-		self.handle_primary.remove(&id);
-		self.handle_end.remove(&id);
-		self.stroke.remove(&id);
-	}
-}
-
-/// Represents a procedural change to the [`RegionDomain`] in [`VectorData`].
-#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
-pub struct RegionModification {
-	add: Vec<RegionId>,
-	remove: HashSet<RegionId>,
-	#[serde(serialize_with = "serialize_hashmap", deserialize_with = "deserialize_hashmap")]
-	segment_range: HashMap<RegionId, std::ops::RangeInclusive<SegmentId>>,
-	#[serde(serialize_with = "serialize_hashmap", deserialize_with = "deserialize_hashmap")]
-	fill: HashMap<RegionId, FillId>,
-}
-
-impl RegionModification {
-	/// Apply this modification to the specified [`RegionDomain`].
-	pub fn apply(&self, region_domain: &mut RegionDomain) {
-		region_domain.retain(|id| !self.remove.contains(id));
-
-		for (id, segment_range) in region_domain.segment_range_mut() {
-			let Some(new) = self.segment_range.get(&id) else { continue };
-			*segment_range = new.clone(); // Range inclusive is not copy
-		}
-
-		for (id, fill) in region_domain.fill_mut() {
-			let Some(&new) = self.fill.get(&id) else { continue };
-			*fill = new;
-		}
-
-		for &add_id in &self.add {
-			let Some(segment_range) = self.segment_range.get(&add_id) else { continue };
-			let Some(&fill) = self.fill.get(&add_id) else { continue };
-			region_domain.push(add_id, segment_range.clone(), fill);
-		}
-	}
-
-	/// Create a new modification that will convert an empty [`VectorData`] into the target [`VectorData`].
-	pub fn create_from_vector(vector_data: &VectorData) -> Self {
-		Self {
-			add: vector_data.region_domain.ids().to_vec(),
-			remove: HashSet::new(),
-			segment_range: vector_data.region_domain.ids().iter().copied().zip(vector_data.region_domain.segment_range().iter().cloned()).collect(),
-			fill: vector_data.region_domain.ids().iter().copied().zip(vector_data.region_domain.fill().iter().cloned()).collect(),
-		}
-	}
-}
-
-/// Represents a procedural change to the [`VectorData`].
-#[derive(Clone, Debug, Default, PartialEq, DynAny, serde::Serialize, serde::Deserialize)]
-pub struct VectorModification {
-	points: PointModification,
-	segments: SegmentModification,
-	regions: RegionModification,
-	add_g1_continuous: HashSet<[HandleId; 2]>,
-	remove_g1_continuous: HashSet<[HandleId; 2]>,
-}
-
-/// A modification type that can be added to a [`VectorModification`].
-#[derive(PartialEq, Clone, Debug, serde::Serialize, serde::Deserialize)]
-pub enum VectorModificationType {
-	InsertSegment { id: SegmentId, points: [PointId; 2], handles: [Option<DVec2>; 2] },
-	InsertPoint { id: PointId, position: DVec2 },
-
-	RemoveSegment { id: SegmentId },
-	RemovePoint { id: PointId },
-
-	SetG1Continuous { handles: [HandleId; 2], enabled: bool },
-	SetHandles { segment: SegmentId, handles: [Option<DVec2>; 2] },
-	SetPrimaryHandle { segment: SegmentId, relative_position: DVec2 },
-	SetEndHandle { segment: SegmentId, relative_position: DVec2 },
-	SetStartPoint { segment: SegmentId, id: PointId },
-	SetEndPoint { segment: SegmentId, id: PointId },
-
-	ApplyPointDelta { point: PointId, delta: DVec2 },
-	ApplyPrimaryDelta { segment: SegmentId, delta: DVec2 },
-	ApplyEndDelta { segment: SegmentId, delta: DVec2 },
-}
-
-impl VectorModification {
-	/// Apply this modification to the specified [`VectorData`].
-	pub fn apply(&self, vector_data: &mut VectorData) {
-		self.points.apply(&mut vector_data.point_domain, &mut vector_data.segment_domain);
-		self.segments.apply(&mut vector_data.segment_domain, &vector_data.point_domain);
-		self.regions.apply(&mut vector_data.region_domain);
-
-		let valid = |val: &[HandleId; 2]| vector_data.segment_domain.ids().contains(&val[0].segment) && vector_data.segment_domain.ids().contains(&val[1].segment);
-		vector_data
-			.colinear_manipulators
-			.retain(|val| !self.remove_g1_continuous.contains(val) && !self.remove_g1_continuous.contains(&[val[1], val[0]]) && valid(val));
-
-		for handles in &self.add_g1_continuous {
-			if !vector_data.colinear_manipulators.iter().any(|test| test == handles || test == &[handles[1], handles[0]]) && valid(handles) {
-				vector_data.colinear_manipulators.push(*handles);
-			}
-		}
-	}
-
-	/// Add a [`VectorModificationType`] to this modification.
-	pub fn modify(&mut self, vector_data_modification: &VectorModificationType) {
-		match vector_data_modification {
-			VectorModificationType::InsertSegment { id, points, handles } => self.segments.push(*id, *points, *handles, StrokeId::ZERO),
-			VectorModificationType::InsertPoint { id, position } => self.points.push(*id, *position),
-
-			VectorModificationType::RemoveSegment { id } => self.segments.remove(*id),
-			VectorModificationType::RemovePoint { id } => self.points.remove(*id),
-
-			VectorModificationType::SetG1Continuous { handles, enabled } => {
-				if *enabled {
-					if !self.add_g1_continuous.contains(&[handles[1], handles[0]]) {
-						self.add_g1_continuous.insert(*handles);
-					}
-					self.remove_g1_continuous.remove(handles);
-					self.remove_g1_continuous.remove(&[handles[1], handles[0]]);
-				} else {
-					if !self.remove_g1_continuous.contains(&[handles[1], handles[0]]) {
-						self.remove_g1_continuous.insert(*handles);
-					}
-					self.add_g1_continuous.remove(handles);
-					self.add_g1_continuous.remove(&[handles[1], handles[0]]);
-				}
-			}
-			VectorModificationType::SetHandles { segment, handles } => {
-				self.segments.handle_primary.insert(*segment, handles[0]);
-				self.segments.handle_end.insert(*segment, handles[1]);
-			}
-			VectorModificationType::SetPrimaryHandle { segment, relative_position } => {
-				self.segments.handle_primary.insert(*segment, Some(*relative_position));
-			}
-			VectorModificationType::SetEndHandle { segment, relative_position } => {
-				self.segments.handle_end.insert(*segment, Some(*relative_position));
-			}
-			VectorModificationType::SetStartPoint { segment, id } => {
-				self.segments.start_point.insert(*segment, *id);
-			}
-			VectorModificationType::SetEndPoint { segment, id } => {
-				self.segments.end_point.insert(*segment, *id);
-			}
-
-			VectorModificationType::ApplyPointDelta { point, delta } => {
-				*self.points.delta.entry(*point).or_default() += *delta;
-			}
-			VectorModificationType::ApplyPrimaryDelta { segment, delta } => {
-				let position = self.segments.handle_primary.entry(*segment).or_default();
-				*position = Some(position.unwrap_or_default() + *delta);
-			}
-			VectorModificationType::ApplyEndDelta { segment, delta } => {
-				let position = self.segments.handle_end.entry(*segment).or_default();
-				*position = Some(position.unwrap_or_default() + *delta);
-			}
-		}
-	}
-
-	/// Create a new modification that will convert an empty [`VectorData`] into the target [`VectorData`].
-	pub fn create_from_vector(vector_data: &VectorData) -> Self {
-		Self {
-			points: PointModification::create_from_vector(vector_data),
-			segments: SegmentModification::create_from_vector(vector_data),
-			regions: RegionModification::create_from_vector(vector_data),
-			add_g1_continuous: vector_data.colinear_manipulators.iter().copied().collect(),
-			remove_g1_continuous: HashSet::new(),
-		}
-	}
-}
-
-impl Hash for VectorModification {
-	fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-		generate_uuid().hash(state)
-	}
-}
-
-/// A node that applies a procedural modification to some [`VectorData`].
-#[node_macro::node(category(""))]
-async fn path_modify(_ctx: impl Ctx, mut vector_data: VectorDataTable, modification: Box<VectorModification>) -> VectorDataTable {
-	if vector_data.is_empty() {
-		vector_data.push(Instance::default());
-	}
-	let vector_data_instance = vector_data.get_mut(0).expect("push should give one item");
-	modification.apply(vector_data_instance.instance);
-	if vector_data.len() > 1 {
-		warn!("The path modify ran on {} instances of vector data. Only the first can be modified.", vector_data.len());
-	}
-	vector_data
-}
-
-// Do we want to enforce that all serialized/deserialized hashmaps are a vec of tuples?
-// TODO: Eventually remove this document upgrade code
-use serde::de::{SeqAccess, Visitor};
-use serde::ser::SerializeSeq;
-use serde::{Deserialize, Deserializer, Serialize, Serializer};
-use std::fmt;
-use std::hash::Hash;
-pub fn serialize_hashmap<K, V, S, H>(hashmap: &HashMap<K, V, H>, serializer: S) -> Result<S::Ok, S::Error>
-where
-	K: Serialize + Eq + Hash,
-	V: Serialize,
-	S: Serializer,
-	H: BuildHasher,
-{
-	let mut seq = serializer.serialize_seq(Some(hashmap.len()))?;
-	for (key, value) in hashmap {
-		seq.serialize_element(&(key, value))?;
-	}
-	seq.end()
-}
-
-pub fn deserialize_hashmap<'de, K, V, D, H>(deserializer: D) -> Result<HashMap<K, V, H>, D::Error>
-where
-	K: Deserialize<'de> + Eq + Hash,
-	V: Deserialize<'de>,
-	D: Deserializer<'de>,
-	H: BuildHasher + Default,
-{
-	struct HashMapVisitor<K, V, H> {
-		#[allow(clippy::type_complexity)]
-		marker: std::marker::PhantomData<fn() -> HashMap<K, V, H>>,
-	}
-
-	impl<'de, K, V, H> Visitor<'de> for HashMapVisitor<K, V, H>
-	where
-		K: Deserialize<'de> + Eq + Hash,
-		V: Deserialize<'de>,
-		H: BuildHasher + Default,
-	{
-		type Value = HashMap<K, V, H>;
-
-		fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-			formatter.write_str("a sequence of tuples")
-		}
-
-		fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
-		where
-			A: SeqAccess<'de>,
-		{
-			let mut hashmap = HashMap::default();
-			while let Some((key, value)) = seq.next_element()? {
-				hashmap.insert(key, value);
-			}
-			Ok(hashmap)
-		}
-	}
-
-	let visitor = HashMapVisitor { marker: std::marker::PhantomData };
-	deserializer.deserialize_seq(visitor)
-}
-
-pub struct AppendBezpath<'a> {
-	first_point: Option<Point>,
-	last_point: Option<Point>,
-	first_point_index: Option<usize>,
-	last_point_index: Option<usize>,
-	first_segment_id: Option<SegmentId>,
-	last_segment_id: Option<SegmentId>,
-	point_id: PointId,
-	segment_id: SegmentId,
-	vector_data: &'a mut VectorData,
-}
-
-impl<'a> AppendBezpath<'a> {
-	fn new(vector_data: &'a mut VectorData) -> Self {
-		Self {
-			first_point: None,
-			last_point: None,
-			first_point_index: None,
-			last_point_index: None,
-			first_segment_id: None,
-			last_segment_id: None,
-			point_id: vector_data.point_domain.next_id(),
-			segment_id: vector_data.segment_domain.next_id(),
-			vector_data,
-		}
-	}
-
-	fn append_segment_and_close_path(&mut self, point: Point, handle: BezierHandles) {
-		let handle = if self.first_point.unwrap() != point {
-			// If the first point is not the same as the last point of the path then we append the segment
-			// with given handle and point and then close the path with linear handle.
-			self.append_segment(point, handle);
-			BezierHandles::Linear
-		} else {
-			// if the endpoints are the same then we close the path with given handle.
-			handle
-		};
-
-		// Create a new segment.
-		let next_segment_id = self.segment_id.next_id();
-		self.vector_data
-			.segment_domain
-			.push(next_segment_id, self.last_point_index.unwrap(), self.first_point_index.unwrap(), handle, StrokeId::ZERO);
-
-		// Create a new region.
-		let next_region_id = self.vector_data.region_domain.next_id();
-		let first_segment_id = self.first_segment_id.unwrap_or(next_segment_id);
-		let last_segment_id = next_segment_id;
-
-		self.vector_data.region_domain.push(next_region_id, first_segment_id..=last_segment_id, FillId::ZERO);
-	}
-
-	fn append_segment(&mut self, end_point: Point, handle: BezierHandles) {
-		// Append the point.
-		let next_point_index = self.vector_data.point_domain.ids().len();
-		let next_point_id = self.point_id.next_id();
-
-		self.vector_data.point_domain.push(next_point_id, point_to_dvec2(end_point));
-
-		// Append the segment.
-		let next_segment_id = self.segment_id.next_id();
-		self.vector_data
-			.segment_domain
-			.push(next_segment_id, self.last_point_index.unwrap(), next_point_index, handle, StrokeId::ZERO);
-
-		// Update the states.
-		self.last_point = Some(end_point);
-		self.last_point_index = Some(next_point_index);
-
-		self.first_segment_id = Some(self.first_segment_id.unwrap_or(next_segment_id));
-		self.last_segment_id = Some(next_segment_id);
-	}
-
-	fn append_first_point(&mut self, point: Point) {
-		self.first_point = Some(point);
-		self.last_point = Some(point);
-
-		// Append the first point.
-		let next_point_index = self.vector_data.point_domain.ids().len();
-		self.vector_data.point_domain.push(self.point_id.next_id(), point_to_dvec2(point));
-
-		// Update the state.
-		self.first_point_index = Some(next_point_index);
-		self.last_point_index = Some(next_point_index);
-	}
-
-	fn reset(&mut self) {
-		self.first_point = None;
-		self.last_point = None;
-		self.first_point_index = None;
-		self.last_point_index = None;
-		self.first_segment_id = None;
-		self.last_segment_id = None;
-	}
-
-	pub fn append_bezpath(vector_data: &'a mut VectorData, bezpath: BezPath) {
-		let mut this = Self::new(vector_data);
-		let mut elements = bezpath.elements().iter().peekable();
-
-		while let Some(element) = elements.next() {
-			let close_path = elements.peek().is_some_and(|elm| **elm == PathEl::ClosePath);
-
-			match *element {
-				PathEl::MoveTo(point) => this.append_first_point(point),
-				PathEl::LineTo(point) => {
-					let handle = BezierHandles::Linear;
-					if close_path {
-						this.append_segment_and_close_path(point, handle);
-					} else {
-						this.append_segment(point, handle);
-					}
-				}
-				PathEl::QuadTo(point, point1) => {
-					let handle = BezierHandles::Quadratic { handle: point_to_dvec2(point) };
-					if close_path {
-						this.append_segment_and_close_path(point1, handle);
-					} else {
-						this.append_segment(point1, handle);
-					}
-				}
-				PathEl::CurveTo(point, point1, point2) => {
-					let handle = BezierHandles::Cubic {
-						handle_start: point_to_dvec2(point),
-						handle_end: point_to_dvec2(point1),
-					};
-
-					if close_path {
-						this.append_segment_and_close_path(point2, handle);
-					} else {
-						this.append_segment(point2, handle);
-					}
-				}
-				PathEl::ClosePath => {
-					// Already handled using `append_segment_and_close_path()` hence we reset state and continue.
-					this.reset();
-				}
-			}
-		}
-	}
-}
-
-pub trait VectorDataExt {
-	/// Appends a Kurbo BezPath to the vector data.
-	fn append_bezpath(&mut self, bezpath: BezPath);
-}
-
-impl VectorDataExt for VectorData {
-	fn append_bezpath(&mut self, bezpath: BezPath) {
-		AppendBezpath::append_bezpath(self, bezpath);
-	}
-}
-
-pub trait HandleExt {
-	/// Set the handle's position relative to the anchor which is the start anchor for the primary handle and end anchor for the end handle.
-	#[must_use]
-	fn set_relative_position(self, relative_position: DVec2) -> VectorModificationType;
-}
-
-impl HandleExt for HandleId {
-	fn set_relative_position(self, relative_position: DVec2) -> VectorModificationType {
-		let Self { ty, segment } = self;
-		match ty {
-			HandleType::Primary => VectorModificationType::SetPrimaryHandle { segment, relative_position },
-			HandleType::End => VectorModificationType::SetEndHandle { segment, relative_position },
-		}
-	}
-}
-
-#[cfg(test)]
-mod tests {
-	use super::*;
-
-	#[test]
-	fn modify_new() {
-		let vector_data = VectorData::from_subpaths(
-			[bezier_rs::Subpath::new_ellipse(DVec2::ZERO, DVec2::ONE), bezier_rs::Subpath::new_rect(DVec2::NEG_ONE, DVec2::ZERO)],
-			false,
-		);
-
-		let modify = VectorModification::create_from_vector(&vector_data);
-
-		let mut new = VectorData::default();
-		modify.apply(&mut new);
-		assert_eq!(vector_data, new);
-	}
-
-	#[test]
-	fn modify_existing() {
-		use bezier_rs::{Bezier, Subpath};
-		let subpaths = [
-			Subpath::new_ellipse(DVec2::ZERO, DVec2::ONE),
-			Subpath::new_rect(DVec2::NEG_ONE, DVec2::ZERO),
-			Subpath::from_beziers(
-				&[
-					Bezier::from_quadratic_dvec2(DVec2::new(0., 0.), DVec2::new(5., 10.), DVec2::new(10., 0.)),
-					Bezier::from_quadratic_dvec2(DVec2::new(10., 0.), DVec2::new(15., 10.), DVec2::new(20., 0.)),
-				],
-				false,
-			),
-		];
-		let mut vector_data = VectorData::from_subpaths(subpaths, false);
-
-		let mut modify_new = VectorModification::create_from_vector(&vector_data);
-		let mut modify_original = VectorModification::default();
-
-		for modification in [&mut modify_new, &mut modify_original] {
-			let point = vector_data.point_domain.ids()[0];
-			modification.modify(&VectorModificationType::ApplyPointDelta { point, delta: DVec2::X * 0.5 });
-			let point = vector_data.point_domain.ids()[9];
-			modification.modify(&VectorModificationType::ApplyPointDelta { point, delta: DVec2::X });
-		}
-
-		let mut new = VectorData::default();
-		modify_new.apply(&mut new);
-
-		modify_original.apply(&mut vector_data);
-
-		assert_eq!(vector_data, new);
-		assert_eq!(vector_data.point_domain.positions()[0], DVec2::X);
-		assert_eq!(vector_data.point_domain.positions()[9], DVec2::new(11., 0.));
-		assert_eq!(
-			vector_data.segment_bezier_iter().nth(8).unwrap().1,
-			Bezier::from_quadratic_dvec2(DVec2::new(0., 0.), DVec2::new(5., 10.), DVec2::new(11., 0.))
-		);
-		assert_eq!(
-			vector_data.segment_bezier_iter().nth(9).unwrap().1,
-			Bezier::from_quadratic_dvec2(DVec2::new(11., 0.), DVec2::new(16., 10.), DVec2::new(20., 0.))
-		);
-	}
-}