merge

node-graph/gcore/Cargo.toml

@@ -29,10 +29,11 @@ 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 }
+parley = { workspace = true }
+skrifa = { workspace = true }
 kurbo = { workspace = true }
 log = { workspace = true }
 base64 = { workspace = true }

node-graph/gcore/src/debug.rs

@@ -1,5 +1,14 @@
 use crate::raster_types::{CPU, RasterDataTable};
+use crate::vector::VectorDataTable;
 use crate::{Color, Ctx};
+use glam::{DAffine2, DVec2};
+
+#[node_macro::node(category("Debug"), name("Log to Console"))]
+fn log_to_console<T: std::fmt::Debug>(_: impl Ctx, #[implementations(String, bool, f64, u32, u64, DVec2, VectorDataTable, DAffine2, Color, Option<Color>)] value: T) -> T {
+	// KEEP THIS `debug!()` - It acts as the output for the debug node itself
+	log::debug!("{:#?}", value);
+	value
+}
 
 /// Meant for debugging purposes, not general use. Returns the size of the input type in bytes.
 #[node_macro::node(category("Debug"))]

node-graph/gcore/src/extract_xy.rs

@@ -2,7 +2,9 @@ use crate::Ctx;
 use dyn_any::DynAny;
 use glam::{DVec2, IVec2, UVec2};
 
-/// Obtain the X or Y component of a coordinate.
+/// Obtains the X or Y component of a coordinate point.
+///
+/// The inverse of this node is "Coordinate Value", which can have either or both its X and Y exposed as graph inputs.
 #[node_macro::node(name("Extract XY"), category("Math: Vector"))]
 fn extract_xy<T: Into<DVec2>>(_: impl Ctx, #[implementations(DVec2, IVec2, UVec2)] vector: T, axis: XY) -> f64 {
 	match axis {

node-graph/gcore/src/graphic_element.rs

@@ -558,3 +558,53 @@ impl From<GraphicGroupTable> for GraphicElement {
 pub trait ToGraphicElement {
 	fn to_graphic_element(&self) -> GraphicElement;
 }
+
+/// Returns the value at the specified index in the collection.
+/// If that index has no value, the type's default value is returned.
+#[node_macro::node(category("General"))]
+fn index<T: AtIndex + Clone + Default>(
+	_: impl Ctx,
+	/// The collection of data, such as a list or table.
+	#[implementations(
+		Vec<Color>,
+		Vec<Option<Color>>,
+		Vec<f64>, Vec<u64>,
+		Vec<DVec2>,
+		VectorDataTable,
+		RasterDataTable<CPU>,
+		GraphicGroupTable,
+	)]
+	collection: T,
+	/// The index of the item to retrieve, starting from 0 for the first item.
+	index: u32,
+) -> T::Output
+where
+	T::Output: Clone + Default,
+{
+	collection.at_index(index as usize).unwrap_or_default()
+}
+
+pub trait AtIndex {
+	type Output;
+	fn at_index(&self, index: usize) -> Option<Self::Output>;
+}
+impl<T: Clone> AtIndex for Vec<T> {
+	type Output = T;
+
+	fn at_index(&self, index: usize) -> Option<Self::Output> {
+		self.get(index).cloned()
+	}
+}
+impl<T: Clone> AtIndex for Instances<T> {
+	type Output = Instances<T>;
+
+	fn at_index(&self, index: usize) -> Option<Self::Output> {
+		let mut result_table = Self::default();
+		if let Some(row) = self.instance_ref_iter().nth(index) {
+			result_table.push(row.to_instance_cloned());
+			Some(result_table)
+		} else {
+			None
+		}
+	}
+}

node-graph/gcore/src/logic.rs

@@ -1,26 +1,26 @@
+use crate::ArtboardGroupTable;
+use crate::Color;
+use crate::GraphicElement;
+use crate::GraphicGroupTable;
+use crate::gradient::GradientStops;
+use crate::graphene_core::registry::types::TextArea;
+use crate::raster_types::{CPU, GPU, RasterDataTable};
 use crate::vector::VectorDataTable;
-use crate::{Color, Context, Ctx};
+use crate::{Context, Ctx};
 use glam::{DAffine2, DVec2};
 
-#[node_macro::node(category("Debug"), name("Log to Console"))]
-fn log_to_console<T: std::fmt::Debug>(_: impl Ctx, #[implementations(String, bool, f64, u32, u64, DVec2, VectorDataTable, DAffine2, Color, Option<Color>)] value: T) -> T {
-	// KEEP THIS `debug!()` - It acts as the output for the debug node itself
-	log::debug!("{:#?}", value);
-	value
-}
-
 #[node_macro::node(category("Text"))]
 fn to_string<T: std::fmt::Debug>(_: impl Ctx, #[implementations(String, bool, f64, u32, u64, DVec2, VectorDataTable, DAffine2)] value: T) -> String {
 	format!("{:?}", value)
 }
 
 #[node_macro::node(category("Text"))]
-fn string_concatenate(_: impl Ctx, #[implementations(String)] first: String, #[implementations(String)] second: String) -> String {
+fn string_concatenate(_: impl Ctx, #[implementations(String)] first: String, second: TextArea) -> String {
 	first.clone() + &second
 }
 
 #[node_macro::node(category("Text"))]
-fn string_replace(_: impl Ctx, #[implementations(String)] string: String, from: String, to: String) -> String {
+fn string_replace(_: impl Ctx, #[implementations(String)] string: String, from: TextArea, to: TextArea) -> String {
 	string.replace(&from, &to)
 }
 
@@ -45,24 +45,42 @@ async fn switch<T, C: Send + 'n + Clone>(
 	#[implementations(
 		Context -> String,
 		Context -> bool,
+		Context -> f32,
 		Context -> f64,
 		Context -> u32,
 		Context -> u64,
 		Context -> DVec2,
-		Context -> VectorDataTable,
 		Context -> DAffine2,
+		Context -> ArtboardGroupTable,
+		Context -> VectorDataTable,
+		Context -> GraphicGroupTable,
+		Context -> RasterDataTable<CPU>,
+		Context -> RasterDataTable<GPU>,
+		Context -> GraphicElement,
+		Context -> Color,
+		Context -> Option<Color>,
+		Context -> GradientStops,
 	)]
 	if_true: impl Node<C, Output = T>,
 	#[expose]
 	#[implementations(
 		Context -> String,
 		Context -> bool,
+		Context -> f32,
 		Context -> f64,
 		Context -> u32,
 		Context -> u64,
 		Context -> DVec2,
-		Context -> VectorDataTable,
 		Context -> DAffine2,
+		Context -> ArtboardGroupTable,
+		Context -> VectorDataTable,
+		Context -> GraphicGroupTable,
+		Context -> RasterDataTable<CPU>,
+		Context -> RasterDataTable<GPU>,
+		Context -> GraphicElement,
+		Context -> Color,
+		Context -> Option<Color>,
+		Context -> GradientStops,
 	)]
 	if_false: impl Node<C, Output = T>,
 ) -> T {

node-graph/gcore/src/ops.rs

@@ -73,9 +73,17 @@ pub trait Convert<T>: Sized {
 	fn convert(self) -> T;
 }
 
+impl<T: ToString> Convert<String> for T {
+	/// Converts this type into a `String` using its `ToString` implementation.
+	#[inline]
+	fn convert(self) -> String {
+		self.to_string()
+	}
+}
+
 /// Implements the [`Convert`] trait for conversion between the cartesian product of Rust's primitive numeric types.
 macro_rules! impl_convert {
-	($from:ty,$to:ty) => {
+	($from:ty, $to:ty) => {
 		impl Convert<$to> for $from {
 			fn convert(self) -> $to {
 				self as $to

node-graph/gcore/src/raster.rs

@@ -12,13 +12,9 @@ pub mod color {
 	pub use super::*;
 }
 
-pub mod adjustments;
-pub mod brush_cache;
-pub mod curve;
 pub mod image;
 
 pub use self::image::Image;
-pub use adjustments::*;
 
 pub trait Bitmap {
 	type Pixel: Pixel;

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

@@ -1,184 +0,0 @@
-use crate::instances::Instance;
-use crate::raster_types::CPU;
-use crate::raster_types::Raster;
-use crate::vector::brush_stroke::BrushStroke;
-use crate::vector::brush_stroke::BrushStyle;
-use dyn_any::DynAny;
-use std::collections::HashMap;
-use std::hash::Hash;
-use std::sync::Arc;
-use std::sync::Mutex;
-
-#[derive(Clone, Debug, PartialEq, DynAny, Default, serde::Serialize, serde::Deserialize)]
-struct BrushCacheImpl {
-	// The full previous input that was cached.
-	prev_input: Vec<BrushStroke>,
-
-	// The strokes that have been fully processed and blended into the background.
-	#[serde(deserialize_with = "crate::graphene_core::raster::image::migrate_image_frame_instance")]
-	background: Instance<Raster<CPU>>,
-	#[serde(deserialize_with = "crate::graphene_core::raster::image::migrate_image_frame_instance")]
-	blended_image: Instance<Raster<CPU>>,
-	#[serde(deserialize_with = "crate::graphene_core::raster::image::migrate_image_frame_instance")]
-	last_stroke_texture: Instance<Raster<CPU>>,
-
-	// A cache for brush textures.
-	#[serde(skip)]
-	brush_texture_cache: HashMap<BrushStyle, Raster<CPU>>,
-}
-
-impl BrushCacheImpl {
-	fn compute_brush_plan(&mut self, mut background: Instance<Raster<CPU>>, input: &[BrushStroke]) -> BrushPlan {
-		// Do background invalidation.
-		if background != self.background {
-			self.background = background.clone();
-			return BrushPlan {
-				strokes: input.to_vec(),
-				background,
-				..Default::default()
-			};
-		}
-
-		// Do blended_image invalidation.
-		let blended_strokes = &self.prev_input[..self.prev_input.len().saturating_sub(1)];
-		let num_blended_strokes = blended_strokes.len();
-		if input.get(..num_blended_strokes) != Some(blended_strokes) {
-			return BrushPlan {
-				strokes: input.to_vec(),
-				background,
-				..Default::default()
-			};
-		}
-
-		// Take our previous blended image (and invalidate the cache).
-		// Since we're about to replace our cache anyway, this saves a clone.
-		background = std::mem::take(&mut self.blended_image);
-
-		// Check if the first non-blended stroke is an extension of the last one.
-		let mut first_stroke_texture = Instance {
-			instance: Raster::<CPU>::default(),
-			transform: glam::DAffine2::ZERO,
-			..Default::default()
-		};
-		let mut first_stroke_point_skip = 0;
-		let strokes = input[num_blended_strokes..].to_vec();
-		if !strokes.is_empty() && self.prev_input.len() > num_blended_strokes {
-			let last_stroke = &self.prev_input[num_blended_strokes];
-			let same_style = strokes[0].style == last_stroke.style;
-			let prev_points = last_stroke.compute_blit_points();
-			let new_points = strokes[0].compute_blit_points();
-			let is_point_prefix = new_points.get(..prev_points.len()) == Some(&prev_points);
-			if same_style && is_point_prefix {
-				first_stroke_texture = std::mem::take(&mut self.last_stroke_texture);
-				first_stroke_point_skip = prev_points.len();
-			}
-		}
-
-		self.prev_input = Vec::new();
-		BrushPlan {
-			strokes,
-			background,
-			first_stroke_texture,
-			first_stroke_point_skip,
-		}
-	}
-
-	pub fn cache_results(&mut self, input: Vec<BrushStroke>, blended_image: Instance<Raster<CPU>>, last_stroke_texture: Instance<Raster<CPU>>) {
-		self.prev_input = input;
-		self.blended_image = blended_image;
-		self.last_stroke_texture = last_stroke_texture;
-	}
-}
-
-impl Hash for BrushCacheImpl {
-	// Zero hash.
-	fn hash<H: std::hash::Hasher>(&self, _state: &mut H) {}
-}
-
-#[derive(Clone, Debug, Default)]
-pub struct BrushPlan {
-	pub strokes: Vec<BrushStroke>,
-	pub background: Instance<Raster<CPU>>,
-	pub first_stroke_texture: Instance<Raster<CPU>>,
-	pub first_stroke_point_skip: usize,
-}
-
-#[derive(Debug, DynAny, serde::Serialize, serde::Deserialize)]
-pub struct BrushCache {
-	inner: Arc<Mutex<BrushCacheImpl>>,
-	proto: bool,
-}
-
-impl Default for BrushCache {
-	fn default() -> Self {
-		Self::new_proto()
-	}
-}
-
-// A bit of a cursed implementation to work around the current node system.
-// The original object is a 'prototype' that when cloned gives you a independent
-// new object. Any further clones however are all the same underlying cache object.
-impl Clone for BrushCache {
-	fn clone(&self) -> Self {
-		if self.proto {
-			let inner_val = self.inner.lock().unwrap();
-			Self {
-				inner: Arc::new(Mutex::new(inner_val.clone())),
-				proto: false,
-			}
-		} else {
-			Self {
-				inner: Arc::clone(&self.inner),
-				proto: false,
-			}
-		}
-	}
-}
-
-impl PartialEq for BrushCache {
-	fn eq(&self, other: &Self) -> bool {
-		if Arc::ptr_eq(&self.inner, &other.inner) {
-			return true;
-		}
-
-		let s = self.inner.lock().unwrap();
-		let o = other.inner.lock().unwrap();
-
-		*s == *o
-	}
-}
-
-impl Hash for BrushCache {
-	fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-		self.inner.lock().unwrap().hash(state);
-	}
-}
-
-impl BrushCache {
-	pub fn new_proto() -> Self {
-		Self {
-			inner: Default::default(),
-			proto: true,
-		}
-	}
-
-	pub fn compute_brush_plan(&self, background: Instance<Raster<CPU>>, input: &[BrushStroke]) -> BrushPlan {
-		let mut inner = self.inner.lock().unwrap();
-		inner.compute_brush_plan(background, input)
-	}
-
-	pub fn cache_results(&self, input: Vec<BrushStroke>, blended_image: Instance<Raster<CPU>>, last_stroke_texture: Instance<Raster<CPU>>) {
-		let mut inner = self.inner.lock().unwrap();
-		inner.cache_results(input, blended_image, last_stroke_texture)
-	}
-
-	pub fn get_cached_brush(&self, style: &BrushStyle) -> Option<Raster<CPU>> {
-		let inner = self.inner.lock().unwrap();
-		inner.brush_texture_cache.get(style).cloned()
-	}
-
-	pub fn store_brush(&self, style: BrushStyle, brush: Raster<CPU>) {
-		let mut inner = self.inner.lock().unwrap();
-		inner.brush_texture_cache.insert(style, brush);
-	}
-}

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

@@ -1,199 +0,0 @@
-use super::{Channel, Linear, LuminanceMut};
-use crate::Node;
-use dyn_any::{DynAny, StaticType, StaticTypeSized};
-use std::ops::{Add, Mul, Sub};
-
-#[derive(Debug, Clone, PartialEq, DynAny, specta::Type, serde::Serialize, serde::Deserialize)]
-pub struct Curve {
-	#[serde(rename = "manipulatorGroups")]
-	pub manipulator_groups: Vec<CurveManipulatorGroup>,
-	#[serde(rename = "firstHandle")]
-	pub first_handle: [f32; 2],
-	#[serde(rename = "lastHandle")]
-	pub last_handle: [f32; 2],
-}
-
-impl Default for Curve {
-	fn default() -> Self {
-		Self {
-			manipulator_groups: vec![],
-			first_handle: [0.2; 2],
-			last_handle: [0.8; 2],
-		}
-	}
-}
-
-impl std::hash::Hash for Curve {
-	fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-		self.manipulator_groups.hash(state);
-		[self.first_handle, self.last_handle].iter().flatten().for_each(|f| f.to_bits().hash(state));
-	}
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, DynAny, specta::Type, serde::Serialize, serde::Deserialize)]
-pub struct CurveManipulatorGroup {
-	pub anchor: [f32; 2],
-	pub handles: [[f32; 2]; 2],
-}
-
-impl std::hash::Hash for CurveManipulatorGroup {
-	fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-		for c in self.handles.iter().chain([&self.anchor]).flatten() {
-			c.to_bits().hash(state);
-		}
-	}
-}
-
-#[derive(Debug)]
-pub struct CubicSplines {
-	pub x: [f32; 4],
-	pub y: [f32; 4],
-}
-
-impl CubicSplines {
-	pub fn solve(&self) -> [f32; 4] {
-		let (x, y) = (&self.x, &self.y);
-
-		// Build an augmented matrix to solve the system of equations using Gaussian elimination
-		let mut augmented_matrix = [
-			[
-				2. / (x[1] - x[0]),
-				1. / (x[1] - x[0]),
-				0.,
-				0.,
-				// |
-				3. * (y[1] - y[0]) / ((x[1] - x[0]) * (x[1] - x[0])),
-			],
-			[
-				1. / (x[1] - x[0]),
-				2. * (1. / (x[1] - x[0]) + 1. / (x[2] - x[1])),
-				1. / (x[2] - x[1]),
-				0.,
-				// |
-				3. * ((y[1] - y[0]) / ((x[1] - x[0]) * (x[1] - x[0])) + (y[2] - y[1]) / ((x[2] - x[1]) * (x[2] - x[1]))),
-			],
-			[
-				0.,
-				1. / (x[2] - x[1]),
-				2. * (1. / (x[2] - x[1]) + 1. / (x[3] - x[2])),
-				1. / (x[3] - x[2]),
-				// |
-				3. * ((y[2] - y[1]) / ((x[2] - x[1]) * (x[2] - x[1])) + (y[3] - y[2]) / ((x[3] - x[2]) * (x[3] - x[2]))),
-			],
-			[
-				0.,
-				0.,
-				1. / (x[3] - x[2]),
-				2. / (x[3] - x[2]),
-				// |
-				3. * (y[3] - y[2]) / ((x[3] - x[2]) * (x[3] - x[2])),
-			],
-		];
-
-		// Gaussian elimination: forward elimination
-		for row in 0..4 {
-			let pivot_row_index = (row..4)
-				.max_by(|&a_row, &b_row| augmented_matrix[a_row][row].abs().partial_cmp(&augmented_matrix[b_row][row].abs()).unwrap_or(std::cmp::Ordering::Equal))
-				.unwrap();
-
-			// Swap the current row with the row that has the largest pivot element
-			augmented_matrix.swap(row, pivot_row_index);
-
-			// Eliminate the current column in all rows below the current one
-			for row_below_current in row + 1..4 {
-				assert!(augmented_matrix[row][row].abs() > f32::EPSILON);
-
-				let scale_factor = augmented_matrix[row_below_current][row] / augmented_matrix[row][row];
-				for col in row..5 {
-					augmented_matrix[row_below_current][col] -= augmented_matrix[row][col] * scale_factor
-				}
-			}
-		}
-
-		// Gaussian elimination: back substitution
-		let mut solutions = [0.; 4];
-		for col in (0..4).rev() {
-			assert!(augmented_matrix[col][col].abs() > f32::EPSILON);
-
-			solutions[col] = augmented_matrix[col][4] / augmented_matrix[col][col];
-
-			for row in (0..col).rev() {
-				augmented_matrix[row][4] -= augmented_matrix[row][col] * solutions[col];
-				augmented_matrix[row][col] = 0.;
-			}
-		}
-
-		solutions
-	}
-
-	pub fn interpolate(&self, input: f32, solutions: &[f32]) -> f32 {
-		if input <= self.x[0] {
-			return self.y[0];
-		}
-		if input >= self.x[self.x.len() - 1] {
-			return self.y[self.x.len() - 1];
-		}
-
-		// Find the segment that the input falls between
-		let mut segment = 1;
-		while self.x[segment] < input {
-			segment += 1;
-		}
-		let segment_start = segment - 1;
-		let segment_end = segment;
-
-		// Calculate the output value using quadratic interpolation
-		let input_value = self.x[segment_start];
-		let input_value_prev = self.x[segment_end];
-		let output_value = self.y[segment_start];
-		let output_value_prev = self.y[segment_end];
-		let solutions_value = solutions[segment_start];
-		let solutions_value_prev = solutions[segment_end];
-
-		let output_delta = solutions_value_prev * (input_value - input_value_prev) - (output_value - output_value_prev);
-		let solution_delta = (output_value - output_value_prev) - solutions_value * (input_value - input_value_prev);
-
-		let input_ratio = (input - input_value_prev) / (input_value - input_value_prev);
-		let prev_output_ratio = (1. - input_ratio) * output_value_prev;
-		let output_ratio = input_ratio * output_value;
-		let quadratic_ratio = input_ratio * (1. - input_ratio) * (output_delta * (1. - input_ratio) + solution_delta * input_ratio);
-
-		let result = prev_output_ratio + output_ratio + quadratic_ratio;
-		result.clamp(0., 1.)
-	}
-}
-
-pub struct ValueMapperNode<C> {
-	lut: Vec<C>,
-}
-
-unsafe impl<C: StaticTypeSized> StaticType for ValueMapperNode<C> {
-	type Static = ValueMapperNode<C::Static>;
-}
-
-impl<C> ValueMapperNode<C> {
-	pub const fn new(lut: Vec<C>) -> Self {
-		Self { lut }
-	}
-}
-
-impl<'i, L: LuminanceMut + 'i> Node<'i, L> for ValueMapperNode<L::LuminanceChannel>
-where
-	L::LuminanceChannel: Linear + Copy,
-	L::LuminanceChannel: Add<Output = L::LuminanceChannel>,
-	L::LuminanceChannel: Sub<Output = L::LuminanceChannel>,
-	L::LuminanceChannel: Mul<Output = L::LuminanceChannel>,
-{
-	type Output = L;
-
-	fn eval(&'i self, mut val: L) -> L {
-		let luminance: f32 = val.luminance().to_linear();
-		let floating_sample_index = luminance * (self.lut.len() - 1) as f32;
-		let index_in_lut = floating_sample_index.floor() as usize;
-		let a = self.lut[index_in_lut];
-		let b = self.lut[(index_in_lut + 1).clamp(0, self.lut.len() - 1)];
-		let result = a.lerp(b, L::LuminanceChannel::from_linear(floating_sample_index.fract()));
-		val.set_luminance(result);
-		val
-	}
-}

node-graph/gcore/src/raster_types.rs

@@ -97,11 +97,20 @@ impl Raster<GPU> {
 		let RasterStorage::Gpu(gpu) = &self.data else { unreachable!() };
 		gpu.clone()
 	}
+}
+
+impl Raster<GPU> {
+	#[cfg(feature = "wgpu")]
 	pub fn is_empty(&self) -> bool {
 		let data = self.data();
 		data.width() == 0 || data.height() == 0
 	}
+	#[cfg(not(feature = "wgpu"))]
+	pub fn is_empty(&self) -> bool {
+		true
+	}
 }
+
 #[cfg(feature = "wgpu")]
 impl Deref for Raster<GPU> {
 	type Target = wgpu::Texture;
@@ -110,6 +119,7 @@ impl Deref for Raster<GPU> {
 		self.data()
 	}
 }
+
 pub type RasterDataTable<Storage> = Instances<Raster<Storage>>;
 
 // TODO: Make this not dupliated

node-graph/gcore/src/registry.rs

@@ -30,6 +30,8 @@ pub mod types {
 	pub type Resolution = glam::UVec2;
 	/// DVec2 with px unit
 	pub type PixelSize = glam::DVec2;
+	/// String with one or more than one line
+	pub type TextArea = String;
 }
 
 // Translation struct between macro and definition

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

@@ -22,11 +22,12 @@ impl Default for Font {
 /// 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
+	/// Actual font file data used for rendering a font
 	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> {
@@ -40,7 +41,7 @@ impl FontCache {
 	}
 
 	/// Try to get the bytes for a font
-	pub fn get<'a>(&'a self, font: &Font) -> Option<&'a Vec<u8>> {
+	pub fn get(&self, font: &Font) -> Option<&Vec<u8>> {
 		self.resolve_font(font).and_then(|font| self.font_file_data.get(font))
 	}
 

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

@@ -1,29 +1,67 @@
 use crate::vector::PointId;
 use bezier_rs::{ManipulatorGroup, Subpath};
-use glam::DVec2;
-use rustybuzz::ttf_parser::{GlyphId, OutlineBuilder};
-use rustybuzz::{GlyphBuffer, UnicodeBuffer};
+use core::cell::RefCell;
+use glam::{DAffine2, DVec2};
+use parley::fontique::Blob;
+use parley::{Alignment, AlignmentOptions, FontContext, GlyphRun, Layout, LayoutContext, LineHeight, PositionedLayoutItem, StyleProperty};
+use skrifa::GlyphId;
+use skrifa::instance::{LocationRef, NormalizedCoord, Size};
+use skrifa::outline::{DrawSettings, OutlinePen};
+use skrifa::raw::FontRef as ReadFontsRef;
+use skrifa::{MetadataProvider, OutlineGlyph};
+use std::sync::Arc;
 
-struct Builder {
+// Thread-local storage avoids expensive re-initialization of font and layout contexts
+// across multiple text rendering operations within the same thread
+thread_local! {
+	static FONT_CONTEXT: RefCell<FontContext> = RefCell::new(FontContext::new());
+	static LAYOUT_CONTEXT: RefCell<LayoutContext<()>> = RefCell::new(LayoutContext::new());
+}
+
+struct PathBuilder {
 	current_subpath: Subpath<PointId>,
+	glyph_subpaths: Vec<Subpath<PointId>>,
 	other_subpaths: Vec<Subpath<PointId>>,
-	text_cursor: DVec2,
-	offset: DVec2,
-	ascender: f64,
+	origin: DVec2,
 	scale: f64,
 	id: PointId,
 }
 
-impl Builder {
+impl PathBuilder {
 	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
+		// Y-axis inversion converts from font coordinate system (Y-up) to graphics coordinate system (Y-down)
+		DVec2::new(self.origin.x + x as f64, self.origin.y - y as f64) * self.scale
+	}
+
+	fn set_origin(&mut self, x: f64, y: f64) {
+		self.origin = DVec2::new(x, y);
+	}
+
+	fn draw_glyph(&mut self, glyph: &OutlineGlyph<'_>, size: f32, normalized_coords: &[NormalizedCoord], style_skew: Option<DAffine2>, skew: DAffine2) {
+		let location_ref = LocationRef::new(normalized_coords);
+		let settings = DrawSettings::unhinted(Size::new(size), location_ref);
+		glyph.draw(settings, self).unwrap();
+
+		// Apply transforms in correct order: style-based skew first, then user-requested skew
+		// This ensures font synthesis (italic) is applied before user transformations
+		for glyph_subpath in &mut self.glyph_subpaths {
+			if let Some(style_skew) = style_skew {
+				glyph_subpath.apply_transform(style_skew);
+			}
+
+			glyph_subpath.apply_transform(skew);
+		}
+
+		if !self.glyph_subpaths.is_empty() {
+			self.other_subpaths.extend(core::mem::take(&mut self.glyph_subpaths));
+		}
 	}
 }
 
-impl OutlineBuilder for Builder {
+impl OutlinePen for PathBuilder {
 	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.glyph_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()));
 	}
@@ -47,36 +85,10 @@ impl OutlineBuilder for Builder {
 
 	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)));
+		self.glyph_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,
@@ -84,6 +96,7 @@ pub struct TypesettingConfig {
 	pub character_spacing: f64,
 	pub max_width: Option<f64>,
 	pub max_height: Option<f64>,
+	pub tilt: f64,
 }
 
 impl Default for TypesettingConfig {
@@ -91,163 +104,130 @@ impl Default for TypesettingConfig {
 		Self {
 			font_size: 24.,
 			line_height_ratio: 1.2,
-			character_spacing: 1.,
+			character_spacing: 0.,
 			max_width: None,
 			max_height: None,
+			tilt: 0.,
 		}
 	}
 }
 
-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(' ');
+fn render_glyph_run(glyph_run: &GlyphRun<'_, ()>, path_builder: &mut PathBuilder, tilt: f64) {
+	let mut run_x = glyph_run.offset();
+	let run_y = glyph_run.baseline();
 
-	let (scale, line_height, mut buffer) = font_properties(&buzz_face, typesetting.font_size, typesetting.line_height_ratio);
+	let run = glyph_run.run();
 
-	let mut builder = Builder {
+	// User-requested tilt applied around baseline to avoid vertical displacement
+	// Translation ensures rotation point is at the baseline, not origin
+	let skew = DAffine2::from_translation(DVec2::new(0., run_y as f64))
+		* DAffine2::from_cols_array(&[1., 0., -tilt.to_radians().tan(), 1., 0., 0.])
+		* DAffine2::from_translation(DVec2::new(0., -run_y as f64));
+
+	let synthesis = run.synthesis();
+
+	// Font synthesis (e.g., synthetic italic) applied separately from user transforms
+	// This preserves the distinction between font styling and user transformations
+	let style_skew = synthesis.skew().map(|angle| {
+		DAffine2::from_translation(DVec2::new(0., run_y as f64))
+			* DAffine2::from_cols_array(&[1., 0., -angle.to_radians().tan() as f64, 1., 0., 0.])
+			* DAffine2::from_translation(DVec2::new(0., -run_y as f64))
+	});
+
+	let font = run.font();
+	let font_size = run.font_size();
+
+	let normalized_coords = run.normalized_coords().iter().map(|coord| NormalizedCoord::from_bits(*coord)).collect::<Vec<_>>();
+
+	// TODO: This can be cached for better performance
+	let font_collection_ref = font.data.as_ref();
+	let font_ref = ReadFontsRef::from_index(font_collection_ref, font.index).unwrap();
+	let outlines = font_ref.outline_glyphs();
+
+	for glyph in glyph_run.glyphs() {
+		let glyph_x = run_x + glyph.x;
+		let glyph_y = run_y - glyph.y;
+		run_x += glyph.advance;
+
+		let glyph_id = GlyphId::from(glyph.id);
+		if let Some(glyph_outline) = outlines.get(glyph_id) {
+			path_builder.set_origin(glyph_x as f64, glyph_y as f64);
+			path_builder.draw_glyph(&glyph_outline, font_size, &normalized_coords, style_skew, skew);
+		}
+	}
+}
+
+fn layout_text(str: &str, font_data: Option<Blob<u8>>, typesetting: TypesettingConfig) -> Option<Layout<()>> {
+	let font_cx = FONT_CONTEXT.with(Clone::clone);
+	let mut font_cx = font_cx.borrow_mut();
+	let layout_cx = LAYOUT_CONTEXT.with(Clone::clone);
+	let mut layout_cx = layout_cx.borrow_mut();
+
+	let font_family = font_data.and_then(|font_data| {
+		font_cx
+			.collection
+			.register_fonts(font_data, None)
+			.first()
+			.and_then(|(family_id, _)| font_cx.collection.family_name(*family_id).map(String::from))
+	})?;
+
+	const DISPLAY_SCALE: f32 = 1.;
+	let mut builder = layout_cx.ranged_builder(&mut font_cx, str, DISPLAY_SCALE, true);
+
+	builder.push_default(StyleProperty::FontSize(typesetting.font_size as f32));
+	builder.push_default(StyleProperty::LetterSpacing(typesetting.character_spacing as f32));
+	builder.push_default(StyleProperty::FontStack(parley::FontStack::Single(parley::FontFamily::Named(std::borrow::Cow::Owned(font_family)))));
+	builder.push_default(LineHeight::FontSizeRelative(typesetting.line_height_ratio as f32));
+
+	let mut layout: Layout<()> = builder.build(str);
+
+	layout.break_all_lines(typesetting.max_width.map(|mw| mw as f32));
+	layout.align(typesetting.max_width.map(|max_w| max_w as f32), Alignment::Left, AlignmentOptions::default());
+
+	Some(layout)
+}
+
+pub fn to_path(str: &str, font_data: Option<Blob<u8>>, typesetting: TypesettingConfig) -> Vec<Subpath<PointId>> {
+	let Some(layout) = layout_text(str, font_data, typesetting) else { return Vec::new() };
+
+	let mut path_builder = PathBuilder {
 		current_subpath: Subpath::new(Vec::new(), false),
+		glyph_subpaths: Vec::new(),
 		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,
+		origin: DVec2::ZERO,
+		scale: layout.scale() as f64,
 		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 line in layout.lines() {
+		for item in line.items() {
+			if let PositionedLayoutItem::GlyphRun(glyph_run) = item {
+				render_glyph_run(&glyph_run, &mut path_builder, typesetting.tilt);
 			}
-
-			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
+	path_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];
+pub fn bounding_box(str: &str, font_data: Option<Blob<u8>>, typesetting: TypesettingConfig, for_clipping_test: bool) -> DVec2 {
 	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 Some(layout) = layout_text(str, font_data, typesetting) else { return DVec2::ZERO };
 
-			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
+	DVec2::new(layout.full_width() as f64, layout.height() as f64)
 }
 
-pub fn load_face(data: &[u8]) -> rustybuzz::Face<'_> {
-	rustybuzz::Face::from_slice(data, 0).expect("Loading font failed")
+pub fn load_font(data: &[u8]) -> Blob<u8> {
+	Blob::new(Arc::new(data.to_vec()))
 }
 
-pub fn lines_clipping(str: &str, buzz_face: Option<rustybuzz::Face>, typesetting: TypesettingConfig) -> bool {
+pub fn lines_clipping(str: &str, font_data: Option<Blob<u8>>, typesetting: TypesettingConfig) -> bool {
 	let Some(max_height) = typesetting.max_height else { return false };
-	let bounds = bounding_box(str, buzz_face.as_ref(), typesetting, true);
+	let bounds = bounding_box(str, font_data, 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_nodes.rs

@@ -19,10 +19,10 @@ async fn transform<T: 'n + 'static>(
 	translate: DVec2,
 	rotate: f64,
 	scale: DVec2,
-	shear: DVec2,
+	skew: DVec2,
 	_pivot: DVec2,
 ) -> Instances<T> {
-	let matrix = DAffine2::from_scale_angle_translation(scale, rotate, translate) * DAffine2::from_cols_array(&[1., shear.y, shear.x, 1., 0., 0.]);
+	let matrix = DAffine2::from_scale_angle_translation(scale, rotate, translate) * DAffine2::from_cols_array(&[1., skew.y, skew.x, 1., 0., 0.]);
 
 	let footprint = ctx.try_footprint().copied();
 
@@ -70,6 +70,7 @@ async fn boundless_footprint<T: 'n + 'static>(
 
 	transform_target.eval(ctx.into_context()).await
 }
+
 #[node_macro::node(category("Debug"))]
 async fn freeze_real_time<T: 'n + 'static>(
 	ctx: impl Ctx + CloneVarArgs + ExtractAll,

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

@@ -86,6 +86,7 @@ async fn instance_position(ctx: impl Ctx + ExtractVarArgs) -> DVec2 {
 	Default::default()
 }
 
+// TODO: Make this return a u32 instead of an f64, but we ned to improve math-related compatibility with integer types first.
 #[node_macro::node(category("Instancing"), path(graphene_core::vector))]
 async fn instance_index(ctx: impl Ctx + ExtractIndex) -> f64 {
 	match ctx.try_index() {

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

@@ -1,127 +0,0 @@
-use crate::Color;
-use crate::math::bbox::AxisAlignedBbox;
-use crate::raster::BlendMode;
-use dyn_any::DynAny;
-use glam::DVec2;
-use std::hash::{Hash, Hasher};
-
-/// The style of a brush.
-#[derive(Clone, Debug, DynAny, serde::Serialize, serde::Deserialize)]
-pub struct BrushStyle {
-	pub color: Color,
-	pub diameter: f64,
-	pub hardness: f64,
-	pub flow: f64,
-	pub spacing: f64, // Spacing as a fraction of the diameter.
-	pub blend_mode: BlendMode,
-}
-
-impl Default for BrushStyle {
-	fn default() -> Self {
-		Self {
-			color: Color::BLACK,
-			diameter: 40.,
-			hardness: 50.,
-			flow: 100.,
-			spacing: 50., // Percentage of diameter.
-			blend_mode: BlendMode::Normal,
-		}
-	}
-}
-
-impl Hash for BrushStyle {
-	fn hash<H: Hasher>(&self, state: &mut H) {
-		self.color.hash(state);
-		self.diameter.to_bits().hash(state);
-		self.hardness.to_bits().hash(state);
-		self.flow.to_bits().hash(state);
-		self.spacing.to_bits().hash(state);
-		self.blend_mode.hash(state);
-	}
-}
-
-impl Eq for BrushStyle {}
-
-impl PartialEq for BrushStyle {
-	fn eq(&self, other: &Self) -> bool {
-		self.color == other.color
-			&& self.diameter.to_bits() == other.diameter.to_bits()
-			&& self.hardness.to_bits() == other.hardness.to_bits()
-			&& self.flow.to_bits() == other.flow.to_bits()
-			&& self.spacing.to_bits() == other.spacing.to_bits()
-			&& self.blend_mode == other.blend_mode
-	}
-}
-
-/// A single sample of brush parameters across the brush stroke.
-#[derive(Clone, Debug, PartialEq, DynAny, serde::Serialize, serde::Deserialize)]
-pub struct BrushInputSample {
-	// The position of the sample in layer space, in pixels.
-	// The origin of layer space is not specified.
-	pub position: DVec2,
-	// Future work: pressure, stylus angle, etc.
-}
-
-impl Hash for BrushInputSample {
-	fn hash<H: Hasher>(&self, state: &mut H) {
-		self.position.x.to_bits().hash(state);
-		self.position.y.to_bits().hash(state);
-	}
-}
-
-/// The parameters for a single stroke brush.
-#[derive(Clone, Debug, PartialEq, Hash, Default, DynAny, serde::Serialize, serde::Deserialize)]
-pub struct BrushStroke {
-	pub style: BrushStyle,
-	pub trace: Vec<BrushInputSample>,
-}
-
-impl BrushStroke {
-	pub fn bounding_box(&self) -> AxisAlignedBbox {
-		let radius = self.style.diameter / 2.;
-		self.compute_blit_points()
-			.iter()
-			.map(|pos| AxisAlignedBbox {
-				start: *pos + DVec2::new(-radius, -radius),
-				end: *pos + DVec2::new(radius, radius),
-			})
-			.reduce(|a, b| a.union(&b))
-			.unwrap_or(AxisAlignedBbox::ZERO)
-	}
-
-	pub fn compute_blit_points(&self) -> Vec<DVec2> {
-		// We always travel in a straight line towards the next user input,
-		// placing a blit point every time we travelled our spacing distance.
-		let spacing_dist = self.style.spacing / 100. * self.style.diameter;
-
-		let Some(first_sample) = self.trace.first() else {
-			return Vec::new();
-		};
-
-		let mut cur_pos = first_sample.position;
-		let mut result = vec![cur_pos];
-		let mut dist_until_next_blit = spacing_dist;
-		for sample in &self.trace[1..] {
-			// Travel to the next sample.
-			let delta = sample.position - cur_pos;
-			let mut dist_left = delta.length();
-			let unit_step = delta / dist_left;
-
-			while dist_left >= dist_until_next_blit {
-				// Take a step to the next blit point.
-				cur_pos += dist_until_next_blit * unit_step;
-				dist_left -= dist_until_next_blit;
-
-				// Blit.
-				result.push(cur_pos);
-				dist_until_next_blit = spacing_dist;
-			}
-
-			// Take the partial step to land at the sample.
-			dist_until_next_blit -= dist_left;
-			cur_pos = sample.position;
-		}
-
-		result
-	}
-}

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

@@ -67,6 +67,10 @@ impl ClickTarget {
 		self.bounding_box
 	}
 
+	pub fn bounding_box_center(&self) -> Option<DVec2> {
+		self.bounding_box.map(|bbox| bbox[0] + (bbox[1] - bbox[0]) / 2.)
+	}
+
 	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)])
 	}

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

@@ -37,7 +37,13 @@ impl CornerRadius for [f64; 4] {
 }
 
 #[node_macro::node(category("Vector: Shape"))]
-fn circle(_: impl Ctx, _primary: (), #[default(50.)] radius: f64) -> VectorDataTable {
+fn circle(
+	_: impl Ctx,
+	_primary: (),
+	#[unit(" px")]
+	#[default(50.)]
+	radius: f64,
+) -> VectorDataTable {
 	let radius = radius.abs();
 	VectorDataTable::new(VectorData::from_subpath(Subpath::new_ellipse(DVec2::splat(-radius), DVec2::splat(radius))))
 }
@@ -46,7 +52,9 @@ fn circle(_: impl Ctx, _primary: (), #[default(50.)] radius: f64) -> VectorDataT
 fn arc(
 	_: impl Ctx,
 	_primary: (),
-	#[default(50.)] radius: f64,
+	#[unit(" px")]
+	#[default(50.)]
+	radius: f64,
 	start_angle: Angle,
 	#[default(270.)]
 	#[range((0., 360.))]
@@ -66,7 +74,16 @@ fn arc(
 }
 
 #[node_macro::node(category("Vector: Shape"))]
-fn ellipse(_: impl Ctx, _primary: (), #[default(50)] radius_x: f64, #[default(25)] radius_y: f64) -> VectorDataTable {
+fn ellipse(
+	_: impl Ctx,
+	_primary: (),
+	#[unit(" px")]
+	#[default(50)]
+	radius_x: f64,
+	#[unit(" px")]
+	#[default(25)]
+	radius_y: f64,
+) -> VectorDataTable {
 	let radius = DVec2::new(radius_x, radius_y);
 	let corner1 = -radius;
 	let corner2 = radius;
@@ -87,8 +104,12 @@ fn ellipse(_: impl Ctx, _primary: (), #[default(50)] radius_x: f64, #[default(25
 fn rectangle<T: CornerRadius>(
 	_: impl Ctx,
 	_primary: (),
-	#[default(100)] width: f64,
-	#[default(100)] height: f64,
+	#[unit(" px")]
+	#[default(100)]
+	width: f64,
+	#[unit(" px")]
+	#[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,
@@ -104,7 +125,9 @@ fn regular_polygon<T: AsU64>(
 	#[hard_min(3.)]
 	#[implementations(u32, u64, f64)]
 	sides: T,
-	#[default(50)] radius: f64,
+	#[unit(" px")]
+	#[default(50)]
+	radius: f64,
 ) -> VectorDataTable {
 	let points = sides.as_u64();
 	let radius: f64 = radius * 2.;
@@ -119,8 +142,12 @@ fn star<T: AsU64>(
 	#[hard_min(2.)]
 	#[implementations(u32, u64, f64)]
 	sides: T,
-	#[default(50)] radius_1: f64,
-	#[default(25)] radius_2: f64,
+	#[unit(" px")]
+	#[default(50)]
+	radius_1: f64,
+	#[unit(" px")]
+	#[default(25)]
+	radius_2: f64,
 ) -> VectorDataTable {
 	let points = sides.as_u64();
 	let diameter: f64 = radius_1 * 2.;
@@ -130,7 +157,7 @@ fn star<T: AsU64>(
 }
 
 #[node_macro::node(category("Vector: Shape"))]
-fn line(_: impl Ctx, _primary: (), #[default((0., -50.))] start: PixelSize, #[default((0., 50.))] end: PixelSize) -> VectorDataTable {
+fn line(_: impl Ctx, _primary: (), #[default(0., 0.)] start: PixelSize, #[default(100., 100.)] end: PixelSize) -> VectorDataTable {
 	VectorDataTable::new(VectorData::from_subpath(Subpath::new_line(start, end)))
 }
 
@@ -153,13 +180,14 @@ fn grid<T: GridSpacing>(
 	_: impl Ctx,
 	_primary: (),
 	grid_type: GridType,
+	#[unit(" px")]
 	#[hard_min(0.)]
 	#[default(10)]
 	#[implementations(f64, DVec2)]
 	spacing: T,
-	#[default(30., 30.)] angles: DVec2,
 	#[default(10)] columns: u32,
 	#[default(10)] rows: u32,
+	#[default(30., 30.)] angles: DVec2,
 ) -> VectorDataTable {
 	let (x_spacing, y_spacing) = spacing.as_dvec2().into();
 	let (angle_a, angle_b) = angles.into();
@@ -251,11 +279,11 @@ mod tests {
 	#[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);
+		grid((), (), GridType::Isometric, 0., 5, 5, (0., 0.).into());
+		grid((), (), GridType::Isometric, 90., 5, 5, (90., 90.).into());
 
 		// Works properly
-		let grid = grid((), (), GridType::Isometric, 10., (30., 30.).into(), 5, 5);
+		let grid = grid((), (), GridType::Isometric, 10., 5, 5, (30., 30.).into());
 		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() {
@@ -270,7 +298,7 @@ mod tests {
 
 	#[test]
 	fn skew_isometric_grid_test() {
-		let grid = grid((), (), GridType::Isometric, 10., (40., 30.).into(), 5, 5);
+		let grid = grid((), (), GridType::Isometric, 10., 5, 5, (40., 30.).into());
 		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() {

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

@@ -1,5 +1,4 @@
 pub mod algorithms;
-pub mod brush_stroke;
 pub mod click_target;
 pub mod generator_nodes;
 pub mod misc;

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

@@ -65,6 +65,7 @@ async fn assign_colors<T>(
 	randomize: bool,
 	#[widget(ParsedWidgetOverride::Custom = "assign_colors_seed")]
 	/// The seed used for randomization.
+	/// Seed to determine unique variations on the randomized color selection.
 	seed: SeedValue,
 	#[widget(ParsedWidgetOverride::Custom = "assign_colors_repeat_every")]
 	/// The number of elements to span across the gradient before repeating. A 0 value will span the entire gradient once.
@@ -165,6 +166,7 @@ async fn stroke<C: Into<Option<Color>> + 'n + Send, V>(
 	#[default(Color::BLACK)]
 	/// The stroke color.
 	color: C,
+	#[unit(" px")]
 	#[default(2.)]
 	/// The stroke weight.
 	weight: f64,
@@ -183,6 +185,7 @@ async fn stroke<C: Into<Option<Color>> + 'n + Send, V>(
 	/// The stroke dash lengths. Each length forms a distance in a pattern where the first length is a dash, the second is a gap, and so on. If the list is an odd length, the pattern repeats with solid-gap roles reversed.
 	dash_lengths: Vec<f64>,
 	/// The phase offset distance from the starting point of the dash pattern.
+	#[unit(" px")]
 	dash_offset: f64,
 ) -> Instances<V>
 where
@@ -253,7 +256,9 @@ async fn circular_repeat<I: 'n + Send + Clone>(
 	// TODO: Implement other GraphicElementRendered types.
 	#[implementations(GraphicGroupTable, VectorDataTable, RasterDataTable<CPU>)] instance: Instances<I>,
 	angle_offset: Angle,
-	#[default(5)] radius: f64,
+	#[unit(" px")]
+	#[default(5)]
+	radius: f64,
 	#[default(5)] instances: IntegerCount,
 ) -> Instances<I> {
 	let count = instances.max(1);
@@ -363,7 +368,7 @@ async fn mirror<I: 'n + Send + Clone>(
 	_: impl Ctx,
 	#[implementations(GraphicGroupTable, VectorDataTable, RasterDataTable<CPU>)] instance: Instances<I>,
 	#[default(ReferencePoint::Center)] relative_to_bounds: ReferencePoint,
-	offset: f64,
+	#[unit(" px")] offset: f64,
 	#[range((-90., 90.))] angle: Angle,
 	#[default(true)] keep_original: bool,
 ) -> Instances<I>
@@ -1143,10 +1148,10 @@ async fn sample_polyline(
 	_: impl Ctx,
 	vector_data: VectorDataTable,
 	spacing: PointSpacingType,
-	separation: f64,
-	quantity: f64,
-	start_offset: f64,
-	stop_offset: f64,
+	#[unit(" px")] separation: f64,
+	quantity: u32,
+	#[unit(" px")] start_offset: f64,
+	#[unit(" px")] stop_offset: f64,
 	adaptive_spacing: bool,
 	subpath_segment_lengths: Vec<f64>,
 ) -> VectorDataTable {
@@ -1186,7 +1191,7 @@ async fn sample_polyline(
 
 			let amount = match spacing {
 				PointSpacingType::Separation => separation,
-				PointSpacingType::Quantity => quantity,
+				PointSpacingType::Quantity => quantity as f64,
 			};
 			let Some(mut sample_bezpath) = sample_polyline_on_bezpath(bezpath, spacing, amount, start_offset, stop_offset, adaptive_spacing, current_bezpath_segments_length) else {
 				continue;
@@ -1392,6 +1397,7 @@ async fn tangent_on_path(
 async fn poisson_disk_points(
 	_: impl Ctx,
 	vector_data: VectorDataTable,
+	#[unit(" px")]
 	#[default(10.)]
 	#[hard_min(0.01)]
 	separation_disk_diameter: f64,
@@ -1502,7 +1508,14 @@ async fn spline(_: impl Ctx, vector_data: VectorDataTable) -> VectorDataTable {
 }
 
 #[node_macro::node(category("Vector: Modifier"), path(graphene_core::vector))]
-async fn jitter_points(_: impl Ctx, vector_data: VectorDataTable, #[default(5.)] amount: f64, seed: SeedValue) -> VectorDataTable {
+async fn jitter_points(
+	_: impl Ctx,
+	vector_data: VectorDataTable,
+	#[unit(" px")]
+	#[default(5.)]
+	amount: f64,
+	seed: SeedValue,
+) -> VectorDataTable {
 	let mut result_table = VectorDataTable::default();
 
 	for mut vector_data_instance in vector_data.instance_iter() {
@@ -2084,7 +2097,7 @@ mod test {
 	#[tokio::test]
 	async fn sample_polyline() {
 		let path = Subpath::from_bezier(&Bezier::from_cubic_dvec2(DVec2::ZERO, DVec2::ZERO, DVec2::X * 100., DVec2::X * 100.));
-		let sample_polyline = super::sample_polyline(Footprint::default(), vector_node(path), PointSpacingType::Separation, 30., 0., 0., 0., false, vec![100.]).await;
+		let sample_polyline = super::sample_polyline(Footprint::default(), vector_node(path), PointSpacingType::Separation, 30., 0, 0., 0., false, vec![100.]).await;
 		let sample_polyline = sample_polyline.instance_ref_iter().next().unwrap().instance;
 		assert_eq!(sample_polyline.point_domain.positions().len(), 4);
 		for (pos, expected) in sample_polyline.point_domain.positions().iter().zip([DVec2::X * 0., DVec2::X * 30., DVec2::X * 60., DVec2::X * 90.]) {
@@ -2094,7 +2107,7 @@ mod test {
 	#[tokio::test]
 	async fn sample_polyline_adaptive_spacing() {
 		let path = Subpath::from_bezier(&Bezier::from_cubic_dvec2(DVec2::ZERO, DVec2::ZERO, DVec2::X * 100., DVec2::X * 100.));
-		let sample_polyline = super::sample_polyline(Footprint::default(), vector_node(path), PointSpacingType::Separation, 18., 0., 45., 10., true, vec![100.]).await;
+		let sample_polyline = super::sample_polyline(Footprint::default(), vector_node(path), PointSpacingType::Separation, 18., 0, 45., 10., true, vec![100.]).await;
 		let sample_polyline = sample_polyline.instance_ref_iter().next().unwrap().instance;
 		assert_eq!(sample_polyline.point_domain.positions().len(), 4);
 		for (pos, expected) in sample_polyline.point_domain.positions().iter().zip([DVec2::X * 45., DVec2::X * 60., DVec2::X * 75., DVec2::X * 90.]) {