Restructure node crates (#3384)

* Restructure node-graph folder

* Fix wasm compilation

* Move node definitions out of *-types crates

* Cleanup

* Fix warnings

* Fix warnings

* Start adding migrations

* Add migrations and move memo nodes to gcore

* Move nodes/gsvg-render -> rendering

* Replace some hard coded identifiers and fix automatic conversion

* Fix Vec2Value node migration

* Fix formatting

* Add more migrations

* Cleanup features

* Fix core_types::raster import

* Update demo artwork (to make profile ci work)

* Move *-types to node-graph/libraries folder

* Add missing node migrations

* Migrate more nodes

* Remove impure memo node

* More fixes and remove warning

* Migrate context and add a few missing migrations

---------

Co-authored-by: Keavon Chambers <keavon@keavon.com>

node-graph/libraries/rendering/Cargo.toml

@@ -0,0 +1,27 @@
+[package]
+name = "rendering"
+version = "0.1.0"
+edition = "2024"
+description = "SVG rendering for Graphene"
+authors = ["Graphite Authors <contact@graphite.rs>"]
+license = "MIT OR Apache-2.0"
+
+[dependencies]
+# Local dependencies
+dyn-any = { workspace = true }
+core-types = { workspace = true }
+
+# Workspace dependencies
+glam = { workspace = true }
+serde = { workspace = true }
+base64 = { workspace = true }
+log = { workspace = true }
+num-traits = { workspace = true }
+usvg = { workspace = true }
+kurbo = { workspace = true }
+vector-types = { workspace = true }
+graphic-types = { workspace = true }
+
+
+# Workspace dependencies
+vello = { workspace = true }

node-graph/libraries/rendering/src/convert_usvg_path.rs

@@ -0,0 +1,47 @@
+use glam::DVec2;
+use vector_types::subpath::{ManipulatorGroup, Subpath};
+use vector_types::vector::PointId;
+
+pub fn convert_usvg_path(path: &usvg::Path) -> Vec<Subpath<PointId>> {
+	let mut subpaths = Vec::new();
+	let mut manipulators_list = Vec::new();
+
+	let mut points = path.data().points().iter();
+	let to_vec = |p: &usvg::tiny_skia_path::Point| DVec2::new(p.x as f64, p.y as f64);
+
+	for verb in path.data().verbs() {
+		match verb {
+			usvg::tiny_skia_path::PathVerb::Move => {
+				subpaths.push(Subpath::new(std::mem::take(&mut manipulators_list), false));
+				let Some(start) = points.next().map(to_vec) else { continue };
+				manipulators_list.push(ManipulatorGroup::new(start, Some(start), Some(start)));
+			}
+			usvg::tiny_skia_path::PathVerb::Line => {
+				let Some(end) = points.next().map(to_vec) else { continue };
+				manipulators_list.push(ManipulatorGroup::new(end, Some(end), Some(end)));
+			}
+			usvg::tiny_skia_path::PathVerb::Quad => {
+				let Some(handle) = points.next().map(to_vec) else { continue };
+				let Some(end) = points.next().map(to_vec) else { continue };
+				if let Some(last) = manipulators_list.last_mut() {
+					last.out_handle = Some(last.anchor + (2. / 3.) * (handle - last.anchor));
+				}
+				manipulators_list.push(ManipulatorGroup::new(end, Some(end + (2. / 3.) * (handle - end)), Some(end)));
+			}
+			usvg::tiny_skia_path::PathVerb::Cubic => {
+				let Some(first_handle) = points.next().map(to_vec) else { continue };
+				let Some(second_handle) = points.next().map(to_vec) else { continue };
+				let Some(end) = points.next().map(to_vec) else { continue };
+				if let Some(last) = manipulators_list.last_mut() {
+					last.out_handle = Some(first_handle);
+				}
+				manipulators_list.push(ManipulatorGroup::new(end, Some(second_handle), Some(end)));
+			}
+			usvg::tiny_skia_path::PathVerb::Close => {
+				subpaths.push(Subpath::new(std::mem::take(&mut manipulators_list), true));
+			}
+		}
+	}
+	subpaths.push(Subpath::new(manipulators_list, false));
+	subpaths
+}

node-graph/libraries/rendering/src/lib.rs

@@ -0,0 +1,6 @@
+pub mod convert_usvg_path;
+pub mod render_ext;
+mod renderer;
+pub mod to_peniko;
+
+pub use renderer::*;

node-graph/libraries/rendering/src/render_ext.rs

@@ -0,0 +1,187 @@
+use crate::renderer::{RenderParams, format_transform_matrix};
+use core_types::consts::{LAYER_OUTLINE_STROKE_COLOR, LAYER_OUTLINE_STROKE_WEIGHT};
+use core_types::uuid::generate_uuid;
+use glam::DAffine2;
+use graphic_types::vector_types::gradient::{Gradient, GradientType};
+use graphic_types::vector_types::vector::style::{Fill, PaintOrder, PathStyle, RenderMode, Stroke, StrokeAlign, StrokeCap, StrokeJoin};
+use std::fmt::Write;
+
+pub trait RenderExt {
+	type Output;
+	fn render(&self, svg_defs: &mut String, element_transform: DAffine2, stroke_transform: DAffine2, bounds: DAffine2, transformed_bounds: DAffine2, render_params: &RenderParams) -> Self::Output;
+}
+
+impl RenderExt for Gradient {
+	type Output = u64;
+
+	// /// Adds the gradient def through mutating the first argument, returning the gradient ID.
+	fn render(&self, svg_defs: &mut String, element_transform: DAffine2, stroke_transform: DAffine2, bounds: DAffine2, transformed_bounds: DAffine2, _render_params: &RenderParams) -> Self::Output {
+		let mut stop = String::new();
+		for (position, color) in self.stops.0.iter() {
+			stop.push_str("<stop");
+			if *position != 0. {
+				let _ = write!(stop, r#" offset="{}""#, (position * 1_000_000.).round() / 1_000_000.);
+			}
+			let _ = write!(stop, r##" stop-color="#{}""##, color.to_rgb_hex_srgb_from_gamma());
+			if color.a() < 1. {
+				let _ = write!(stop, r#" stop-opacity="{}""#, (color.a() * 1000.).round() / 1000.);
+			}
+			stop.push_str(" />")
+		}
+
+		let transform_points = element_transform * stroke_transform * bounds;
+		let start = transform_points.transform_point2(self.start);
+		let end = transform_points.transform_point2(self.end);
+
+		let gradient_transform = if transformed_bounds.matrix2.determinant() != 0. {
+			transformed_bounds.inverse()
+		} else {
+			DAffine2::IDENTITY // Ignore if the transform cannot be inverted (the bounds are zero). See issue #1944.
+		};
+		let gradient_transform = format_transform_matrix(gradient_transform);
+		let gradient_transform = if gradient_transform.is_empty() {
+			String::new()
+		} else {
+			format!(r#" gradientTransform="{gradient_transform}""#)
+		};
+
+		let gradient_id = generate_uuid();
+
+		match self.gradient_type {
+			GradientType::Linear => {
+				let _ = write!(
+					svg_defs,
+					r#"<linearGradient id="{}" x1="{}" y1="{}" x2="{}" y2="{}"{gradient_transform}>{}</linearGradient>"#,
+					gradient_id, start.x, start.y, end.x, end.y, stop
+				);
+			}
+			GradientType::Radial => {
+				let radius = (f64::powi(start.x - end.x, 2) + f64::powi(start.y - end.y, 2)).sqrt();
+				let _ = write!(
+					svg_defs,
+					r#"<radialGradient id="{}" cx="{}" cy="{}" r="{}"{gradient_transform}>{}</radialGradient>"#,
+					gradient_id, start.x, start.y, radius, stop
+				);
+			}
+		}
+
+		gradient_id
+	}
+}
+
+impl RenderExt for Fill {
+	type Output = String;
+
+	/// Renders the fill, adding necessary defs through mutating the first argument.
+	fn render(&self, svg_defs: &mut String, element_transform: DAffine2, stroke_transform: DAffine2, bounds: DAffine2, transformed_bounds: DAffine2, render_params: &RenderParams) -> Self::Output {
+		match self {
+			Self::None => r#" fill="none""#.to_string(),
+			Self::Solid(color) => {
+				let mut result = format!(r##" fill="#{}""##, color.to_rgb_hex_srgb_from_gamma());
+				if color.a() < 1. {
+					let _ = write!(result, r#" fill-opacity="{}""#, (color.a() * 1000.).round() / 1000.);
+				}
+				result
+			}
+			Self::Gradient(gradient) => {
+				let gradient_id = gradient.render(svg_defs, element_transform, stroke_transform, bounds, transformed_bounds, render_params);
+				format!(r##" fill="url('#{gradient_id}')""##)
+			}
+		}
+	}
+}
+
+impl RenderExt for Stroke {
+	type Output = String;
+
+	/// Provide the SVG attributes for the stroke.
+	fn render(
+		&self,
+		_svg_defs: &mut String,
+		_element_transform: DAffine2,
+		_stroke_transform: DAffine2,
+		_bounds: DAffine2,
+		_transformed_bounds: DAffine2,
+		render_params: &RenderParams,
+	) -> Self::Output {
+		// Don't render a stroke at all if it would be invisible
+		let Some(color) = self.color else { return String::new() };
+		if !self.has_renderable_stroke() {
+			return String::new();
+		}
+
+		// Set to None if the value is the SVG default
+		let weight = (self.weight != 1.).then_some(self.weight);
+		let dash_array = (!self.dash_lengths.is_empty()).then_some(self.dash_lengths());
+		let dash_offset = (self.dash_offset != 0.).then_some(self.dash_offset);
+		let stroke_cap = (self.cap != StrokeCap::Butt).then_some(self.cap);
+		let stroke_join = (self.join != StrokeJoin::Miter).then_some(self.join);
+		let stroke_join_miter_limit = (self.join_miter_limit != 4.).then_some(self.join_miter_limit);
+		let stroke_align = (self.align != StrokeAlign::Center).then_some(self.align);
+		let paint_order = (self.paint_order != PaintOrder::StrokeAbove || render_params.override_paint_order).then_some(PaintOrder::StrokeBelow);
+
+		// Render the needed stroke attributes
+		let mut attributes = format!(r##" stroke="#{}""##, color.to_rgb_hex_srgb_from_gamma());
+		if color.a() < 1. {
+			let _ = write!(&mut attributes, r#" stroke-opacity="{}""#, (color.a() * 1000.).round() / 1000.);
+		}
+		if let Some(mut weight) = weight {
+			if stroke_align.is_some() && render_params.aligned_strokes {
+				weight *= 2.;
+			}
+			let _ = write!(&mut attributes, r#" stroke-width="{weight}""#);
+		}
+		if let Some(dash_array) = dash_array {
+			let _ = write!(&mut attributes, r#" stroke-dasharray="{dash_array}""#);
+		}
+		if let Some(dash_offset) = dash_offset {
+			let _ = write!(&mut attributes, r#" stroke-dashoffset="{dash_offset}""#);
+		}
+		if let Some(stroke_cap) = stroke_cap {
+			let _ = write!(&mut attributes, r#" stroke-linecap="{}""#, stroke_cap.svg_name());
+		}
+		if let Some(stroke_join) = stroke_join {
+			let _ = write!(&mut attributes, r#" stroke-linejoin="{}""#, stroke_join.svg_name());
+		}
+		if let Some(stroke_join_miter_limit) = stroke_join_miter_limit {
+			let _ = write!(&mut attributes, r#" stroke-miterlimit="{stroke_join_miter_limit}""#);
+		}
+		// Add vector-effect attribute to make strokes non-scaling
+		if self.non_scaling {
+			let _ = write!(&mut attributes, r#" vector-effect="non-scaling-stroke""#);
+		}
+		if paint_order.is_some() {
+			let _ = write!(&mut attributes, r#" style="paint-order: stroke;" "#);
+		}
+		attributes
+	}
+}
+
+impl RenderExt for PathStyle {
+	type Output = String;
+
+	/// Renders the shape's fill and stroke attributes as a string with them concatenated together.
+	#[allow(clippy::too_many_arguments)]
+	fn render(&self, svg_defs: &mut String, element_transform: DAffine2, stroke_transform: DAffine2, bounds: DAffine2, transformed_bounds: DAffine2, render_params: &RenderParams) -> String {
+		let render_mode = render_params.render_mode;
+		match render_mode {
+			RenderMode::Outline => {
+				let fill_attribute = Fill::None.render(svg_defs, element_transform, stroke_transform, bounds, transformed_bounds, render_params);
+				let mut outline_stroke = Stroke::new(Some(LAYER_OUTLINE_STROKE_COLOR), LAYER_OUTLINE_STROKE_WEIGHT);
+				// Outline strokes should be non-scaling by default
+				outline_stroke.non_scaling = true;
+				let stroke_attribute = outline_stroke.render(svg_defs, element_transform, stroke_transform, bounds, transformed_bounds, render_params);
+				format!("{fill_attribute}{stroke_attribute}")
+			}
+			_ => {
+				let fill_attribute = self.fill.render(svg_defs, element_transform, stroke_transform, bounds, transformed_bounds, render_params);
+				let stroke_attribute = self
+					.stroke
+					.as_ref()
+					.map(|stroke| stroke.render(svg_defs, element_transform, stroke_transform, bounds, transformed_bounds, render_params))
+					.unwrap_or_default();
+				format!("{fill_attribute}{stroke_attribute}")
+			}
+		}
+	}
+}

node-graph/libraries/rendering/src/to_peniko.rs

@@ -0,0 +1,36 @@
+use core_types::BlendMode;
+use vello::peniko;
+
+pub trait BlendModeExt {
+	fn to_peniko(&self) -> peniko::Mix;
+}
+
+impl BlendModeExt for BlendMode {
+	fn to_peniko(&self) -> peniko::Mix {
+		match self {
+			// Normal group
+			BlendMode::Normal => peniko::Mix::Normal,
+			// Darken group
+			BlendMode::Darken => peniko::Mix::Darken,
+			BlendMode::Multiply => peniko::Mix::Multiply,
+			BlendMode::ColorBurn => peniko::Mix::ColorBurn,
+			// Lighten group
+			BlendMode::Lighten => peniko::Mix::Lighten,
+			BlendMode::Screen => peniko::Mix::Screen,
+			BlendMode::ColorDodge => peniko::Mix::ColorDodge,
+			// Contrast group
+			BlendMode::Overlay => peniko::Mix::Overlay,
+			BlendMode::SoftLight => peniko::Mix::SoftLight,
+			BlendMode::HardLight => peniko::Mix::HardLight,
+			// Inversion group
+			BlendMode::Difference => peniko::Mix::Difference,
+			BlendMode::Exclusion => peniko::Mix::Exclusion,
+			// Component group
+			BlendMode::Hue => peniko::Mix::Hue,
+			BlendMode::Saturation => peniko::Mix::Saturation,
+			BlendMode::Color => peniko::Mix::Color,
+			BlendMode::Luminosity => peniko::Mix::Luminosity,
+			_ => todo!(),
+		}
+	}
+}