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/nodes/gcore/src/animation.rs

@@ -0,0 +1,58 @@
+use core_types::{Ctx, ExtractAnimationTime, ExtractRealTime};
+
+const DAY: f64 = 1000. * 3600. * 24.;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, dyn_any::DynAny, Default, Hash, node_macro::ChoiceType, serde::Serialize, serde::Deserialize)]
+pub enum RealTimeMode {
+	#[label("UTC")]
+	Utc,
+	Year,
+	Hour,
+	Minute,
+	#[default]
+	Second,
+	Millisecond,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum AnimationTimeMode {
+	AnimationTime,
+	FrameNumber,
+}
+
+/// Produces a chosen representation of the current real time and date (in UTC) based on the system clock.
+#[node_macro::node(category("Animation"))]
+fn real_time(
+	ctx: impl Ctx + ExtractRealTime,
+	_primary: (),
+	/// The time and date component to be produced as a number.
+	component: RealTimeMode,
+) -> f64 {
+	let real_time = ctx.try_real_time().unwrap_or_default();
+	// TODO: Implement proper conversion using and existing time implementation
+	match component {
+		RealTimeMode::Utc => real_time,
+		RealTimeMode::Year => (real_time / DAY / 365.25).floor() + 1970., // TODO: Factor in a chosen timezone
+		RealTimeMode::Hour => (real_time / 1000. / 3600.).floor() % 24.,  // TODO: Factor in a chosen timezone
+		RealTimeMode::Minute => (real_time / 1000. / 60.).floor() % 60.,  // TODO: Factor in a chosen timezone
+
+		RealTimeMode::Second => (real_time / 1000.).floor() % 60.,
+		RealTimeMode::Millisecond => real_time % 1000.,
+	}
+}
+
+/// Produces the time, in seconds on the timeline, since the beginning of animation playback.
+#[node_macro::node(category("Animation"))]
+fn animation_time(ctx: impl Ctx + ExtractAnimationTime) -> f64 {
+	ctx.try_animation_time().unwrap_or_default()
+}
+
+// TODO: These nodes require more sophisticated algorithms for giving the correct result
+// #[node_macro::node(category("Animation"))]
+// fn month(ctx: impl Ctx + ExtractRealTime) -> f64 {
+// 	((ctx.try_real_time().unwrap_or_default() / DAY / 365.25 % 1.) * 12.).floor()
+// }
+// #[node_macro::node(category("Animation"))]
+// fn day(ctx: impl Ctx + ExtractRealTime) -> f64 {
+// 	(ctx.try_real_time().unwrap_or_default() / DAY
+// }

node-graph/nodes/gcore/src/context_modification.rs

@@ -0,0 +1,123 @@
+use core::f64;
+use core_types::context::{CloneVarArgs, Context, ContextFeatures, Ctx, ExtractAll};
+use core_types::table::Table;
+use core_types::transform::Footprint;
+use core_types::uuid::NodeId;
+use core_types::{Color, OwnedContextImpl};
+use glam::{DAffine2, DVec2};
+use graphic_types::{Artboard, Graphic, Vector, vector_types::GradientStops};
+use raster_types::{CPU, GPU, Raster};
+
+/// Filters out what should be unused components of the context based on the specified requirements.
+/// This node is inserted by the compiler to "zero out" unused context components.
+#[node_macro::node(category("Internal"))]
+async fn context_modification<T>(
+	ctx: impl Ctx + CloneVarArgs + ExtractAll,
+	/// The data to pass through, evaluated with the stripped down context.
+	#[implementations(
+		Context -> (),
+		Context -> bool,
+		Context -> u32,
+		Context -> u64,
+		Context -> f32,
+		Context -> f64,
+		Context -> String,
+		Context -> DAffine2,
+		Context -> Footprint,
+		Context -> DVec2,
+		Context -> Vec<DVec2>,
+		Context -> Vec<NodeId>,
+		Context -> Vec<f64>,
+		Context -> Vec<f32>,
+		Context -> Vec<String>,
+		Context -> Table<Vector>,
+		Context -> Table<Graphic>,
+		Context -> Table<Raster<CPU>>,
+		Context -> Table<Raster<GPU>>,
+		Context -> Table<Color>,
+		Context -> Table<Artboard>,
+		Context -> Table<GradientStops>,
+		Context -> GradientStops,
+	)]
+	value: impl Node<Context<'static>, Output = T>,
+	/// The parts of the context to keep when evaluating the input value. All other parts are nullified.
+	features_to_keep: ContextFeatures,
+) -> T {
+	let new_context = OwnedContextImpl::from_flags(ctx, features_to_keep);
+
+	value.eval(Some(new_context.into())).await
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use core_types::transform::Footprint;
+	use std::collections::hash_map::DefaultHasher;
+	use std::hash::{Hash, Hasher};
+
+	/// Test that the hash of a nullified context remains stable even when nullified inputs change
+	#[test]
+	fn test_nullified_context_hash_stability() {
+		use core_types::Context;
+		use std::sync::Arc;
+
+		// Create original contexts using the Context type (Option<Arc<OwnedContextImpl>>)
+		let original_ctx: Context = Some(Arc::new(
+			OwnedContextImpl::empty()
+				.with_footprint(Footprint::default())
+				.with_index(1)
+				.with_real_time(10.5)
+				.with_vararg(Box::new("test"))
+				.with_animation_time(20.25),
+		));
+
+		// Test nullifying different features - hash should remain stable for each nullification
+		let features_to_keep = ContextFeatures::empty(); // Nullify everything
+
+		// Create nullified context - this should only keep features specified in features_to_keep
+		let nullified_ctx = OwnedContextImpl::from_flags(original_ctx.clone().unwrap(), features_to_keep);
+
+		// Calculate hash of nullified context
+		let mut hasher1 = DefaultHasher::new();
+		nullified_ctx.hash(&mut hasher1);
+		let hash1 = hasher1.finish();
+
+		// Create a different original context with changed values
+		let changed_ctx: Context = Some(Arc::new(
+			OwnedContextImpl::empty()
+				.with_footprint(Footprint::default()) // Same footprint
+				.with_index(2)
+				.with_real_time(999.9) // Different real time
+				.with_vararg(Box::new("test"))
+				.with_animation_time(888.8), // Different animation time
+		));
+
+		// Create nullified context from the changed original - should have same hash since everything is nullified
+		let nullified_changed_ctx = OwnedContextImpl::from_flags(changed_ctx.clone().unwrap(), features_to_keep);
+
+		let mut hasher2 = DefaultHasher::new();
+		nullified_changed_ctx.hash(&mut hasher2);
+		let hash2 = hasher2.finish();
+
+		// Hash should be the same because all features were nullified
+		assert_eq!(hash1, hash2, "Hash of nullified context should remain stable regardless of input changes when features are nullified");
+
+		// Test partial nullification - keep only footprint
+		let partial_features = ContextFeatures::FOOTPRINT | ContextFeatures::VARARGS;
+
+		let partial_nullified1 = OwnedContextImpl::from_flags(original_ctx.clone().unwrap(), partial_features);
+		let partial_nullified2 = OwnedContextImpl::from_flags(changed_ctx.clone().unwrap(), partial_features);
+
+		let mut hasher3 = DefaultHasher::new();
+		partial_nullified1.hash(&mut hasher3);
+		let hash3 = hasher3.finish();
+
+		let mut hasher4 = DefaultHasher::new();
+		partial_nullified2.hash(&mut hasher4);
+		let hash4 = hasher4.finish();
+
+		// These should be the same because both have the same footprint (Footprint::default()) and varargs
+		// and other features are nullified
+		assert_eq!(hash3, hash4, "Hash should be stable when keeping only footprint and footprint values are the same");
+	}
+}

node-graph/nodes/gcore/src/debug.rs

@@ -0,0 +1,36 @@
+use core_types::Ctx;
+use core_types::table::Table;
+use glam::{DAffine2, DVec2};
+use raster_types::{CPU, Raster};
+
+/// Meant for debugging purposes, not general use. Logs the input value to the console and passes it through unchanged.
+#[node_macro::node(category("Debug"), name("Log to Console"))]
+fn log_to_console<T: std::fmt::Debug>(_: impl Ctx, #[implementations(bool, f64, u32, u64, DVec2, DAffine2, String)] 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"))]
+fn size_of(_: impl Ctx, ty: core_types::Type) -> Option<usize> {
+	ty.size()
+}
+
+/// Meant for debugging purposes, not general use. Wraps the input value in the Some variant of an Option.
+#[node_macro::node(category("Debug"))]
+fn some<T>(_: impl Ctx, #[implementations(f64, f32, u32, u64, String)] input: T) -> Option<T> {
+	Some(input)
+}
+
+/// Meant for debugging purposes, not general use. Unwraps the input value from an Option, returning the default value if the input is None.
+#[node_macro::node(category("Debug"))]
+fn unwrap_option<T: Default>(_: impl Ctx, #[implementations(Option<f64>, Option<u32>, Option<u64>, Option<String>)] input: Option<T>) -> T {
+	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(&Table<Raster<CPU>>)] value: &'i T) -> T {
+	value.clone()
+}

node-graph/nodes/gcore/src/extract_xy.rs

@@ -0,0 +1,23 @@
+use core_types::Ctx;
+use dyn_any::DynAny;
+use glam::{DVec2, IVec2, UVec2};
+
+/// Obtains the X or Y component of a vec2.
+///
+/// The inverse of this node is "Vec2 Value", which can have either or both its X and Y parameters 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 {
+		XY::X => vector.into().x,
+		XY::Y => vector.into().y,
+	}
+}
+
+/// The X or Y component of a vec2.
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, DynAny, node_macro::ChoiceType, specta::Type, serde::Serialize, serde::Deserialize)]
+#[widget(Radio)]
+pub enum XY {
+	#[default]
+	X,
+	Y,
+}

node-graph/nodes/gcore/src/lib.rs

@@ -0,0 +1,16 @@
+pub mod animation;
+pub mod context_modification;
+pub mod debug;
+pub mod extract_xy;
+pub mod logic;
+pub mod memo;
+pub mod ops;
+
+// Re-export all nodes
+pub use animation::*;
+pub use context_modification::*;
+pub use debug::*;
+pub use extract_xy::*;
+pub use logic::*;
+pub use memo::*;
+pub use ops::*;

node-graph/nodes/gcore/src/logic.rs

@@ -0,0 +1,138 @@
+use core_types::Color;
+use core_types::registry::types::TextArea;
+use core_types::table::Table;
+use core_types::{Context, Ctx};
+use glam::{DAffine2, DVec2};
+use graphic_types::{Artboard, Graphic, Vector, vector_types::GradientStops};
+use raster_types::{CPU, GPU, Raster};
+
+/// Type-asserts a value to be a string.
+#[node_macro::node(category("Debug"))]
+fn to_string(_: impl Ctx, value: String) -> String {
+	value
+}
+
+/// Converts a value to a JSON string representation.
+#[node_macro::node(category("Text"))]
+fn serialize<T: serde::Serialize>(
+	_: impl Ctx,
+	#[implementations(String, bool, f64, u32, u64, DVec2, DAffine2, /* Table<Artboard>, Table<Graphic>, Table<Vector>, */ Table<Raster<CPU>>, Table<Color> /* , Table<GradientStops> */)] value: T,
+) -> String {
+	serde_json::to_string(&value).unwrap_or_else(|_| "Serialization Error".to_string())
+}
+
+/// Joins two strings together.
+#[node_macro::node(category("Text"))]
+fn string_concatenate(_: impl Ctx, #[implementations(String)] first: String, second: TextArea) -> String {
+	first.clone() + &second
+}
+
+/// Replaces all occurrences of "From" with "To" in the input string.
+#[node_macro::node(category("Text"))]
+fn string_replace(_: impl Ctx, string: String, from: TextArea, to: TextArea) -> String {
+	string.replace(&from, &to)
+}
+
+/// Extracts a substring from the input string, starting at "Start" and ending before "End".
+/// Negative indices count from the end of the string.
+/// If "Start" equals or exceeds "End", the result is an empty string.
+#[node_macro::node(category("Text"))]
+fn string_slice(_: impl Ctx, string: String, start: f64, end: f64) -> String {
+	let total_chars = string.chars().count();
+
+	let start = if start < 0. {
+		total_chars.saturating_sub(start.abs() as usize)
+	} else {
+		(start as usize).min(total_chars)
+	};
+	let end = if end <= 0. {
+		total_chars.saturating_sub(end.abs() as usize)
+	} else {
+		(end as usize).min(total_chars)
+	};
+
+	if start >= end {
+		return String::new();
+	}
+
+	string.chars().skip(start).take(end - start).collect()
+}
+
+// TODO: Return u32, u64, or usize instead of f64 after #1621 is resolved and has allowed us to implement automatic type conversion in the node graph for nodes with generic type inputs.
+// TODO: (Currently automatic type conversion only works for concrete types, via the Graphene preprocessor and not the full Graphene type system.)
+/// Counts the number of characters in a string.
+#[node_macro::node(category("Text"))]
+fn string_length(_: impl Ctx, string: String) -> f64 {
+	string.chars().count() as f64
+}
+
+/// Splits a string into a list of substrings based on the specified delimeter.
+/// For example, the delimeter "," will split "a,b,c" into the strings "a", "b", and "c".
+#[node_macro::node(category("Text"))]
+fn string_split(
+	_: impl Ctx,
+	/// The string to split into substrings.
+	string: String,
+	/// The character(s) that separate the substrings. These are not included in the outputs.
+	#[default("\\n")]
+	delimeter: String,
+	/// Whether to convert escape sequences found in the delimeter into their corresponding characters:
+	/// "\n" (newline), "\r" (carriage return), "\t" (tab), "\0" (null), and "\\" (backslash)
+	#[default(true)]
+	delimeter_escaping: bool,
+) -> Vec<String> {
+	let delimeter = if delimeter_escaping {
+		delimeter.replace("\\n", "\n").replace("\\r", "\r").replace("\\t", "\t").replace("\\0", "\0").replace("\\\\", "\\")
+	} else {
+		delimeter
+	};
+
+	string.split(&delimeter).map(str::to_string).collect()
+}
+
+/// Evaluates either the "If True" or "If False" input branch based on whether the input condition is true or false.
+#[node_macro::node(category("Math: Logic"))]
+async fn switch<T, C: Send + 'n + Clone>(
+	#[implementations(Context)] ctx: C,
+	condition: bool,
+	#[expose]
+	#[implementations(
+		Context -> String,
+		Context -> bool,
+		Context -> f32,
+		Context -> f64,
+		Context -> u32,
+		Context -> u64,
+		Context -> DVec2,
+		Context -> DAffine2,
+		Context -> Table<Artboard>,
+		Context -> Table<Graphic>,
+		Context -> Table<Vector>,
+		Context -> Table<Raster<CPU>>,
+		Context -> Table<Raster<GPU>>,
+		Context -> Table<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 -> DAffine2,
+		Context -> Table<Artboard>,
+		Context -> Table<Graphic>,
+		Context -> Table<Vector>,
+		Context -> Table<Raster<CPU>>,
+		Context -> Table<Raster<GPU>>,
+		Context -> Table<Color>,
+		Context -> GradientStops,
+	)]
+	if_false: impl Node<C, Output = T>,
+) -> T {
+	if condition { if_true.eval(ctx).await } else { if_false.eval(ctx).await }
+}

node-graph/nodes/gcore/src/memo.rs

@@ -0,0 +1,107 @@
+use core_types::memo::*;
+use core_types::{Node, WasmNotSend};
+use dyn_any::DynFuture;
+use std::future::Future;
+use std::hash::DefaultHasher;
+use std::hash::{Hash, Hasher};
+use std::sync::Arc;
+use std::sync::Mutex;
+
+/// Caches the output of a given node called with a specific input.
+///
+/// A cache miss occurs when the Option is None. In this case, the node evaluates the inner node and memoizes (stores) the result.
+///
+/// A cache hit occurs when the Option is Some and has a stored hash matching the hash of the call argument. In this case, the node returns the cached value without re-evaluating the inner node.
+///
+/// Currently, only one input-output pair is cached. Subsequent calls with different inputs will overwrite the previous cache.
+#[derive(Default)]
+pub struct MemoNode<T, CachedNode> {
+	cache: Arc<Mutex<Option<(u64, T)>>>,
+	node: CachedNode,
+}
+impl<'i, I: Hash + 'i, T: 'i + Clone + WasmNotSend, CachedNode: 'i> Node<'i, I> for MemoNode<T, CachedNode>
+where
+	CachedNode: for<'any_input> Node<'any_input, I>,
+	for<'a> <CachedNode as Node<'a, I>>::Output: Future<Output = T> + WasmNotSend,
+{
+	// TODO: This should return a reference to the cached cached_value
+	// but that requires a lot of lifetime magic <- This was suggested by copilot but is pretty accurate xD
+	type Output = DynFuture<'i, T>;
+	fn eval(&'i self, input: I) -> Self::Output {
+		let mut hasher = DefaultHasher::new();
+		input.hash(&mut hasher);
+		let hash = hasher.finish();
+
+		if let Some(data) = self.cache.lock().as_ref().unwrap().as_ref().and_then(|data| (data.0 == hash).then_some(data.1.clone())) {
+			Box::pin(async move { data })
+		} else {
+			let fut = self.node.eval(input);
+			let cache = self.cache.clone();
+			Box::pin(async move {
+				let value = fut.await;
+				*cache.lock().unwrap() = Some((hash, value.clone()));
+				value
+			})
+		}
+	}
+
+	fn reset(&self) {
+		self.cache.lock().unwrap().take();
+	}
+}
+
+impl<T, CachedNode> MemoNode<T, CachedNode> {
+	pub fn new(node: CachedNode) -> MemoNode<T, CachedNode> {
+		MemoNode { cache: Default::default(), node }
+	}
+}
+
+#[allow(clippy::module_inception)]
+pub mod memo {
+	use core_types::ProtoNodeIdentifier;
+
+	pub const IDENTIFIER: ProtoNodeIdentifier = ProtoNodeIdentifier::new("graphene_core::memo::MemoNode");
+}
+
+/// Caches the output of the last graph evaluation for introspection
+#[derive(Default)]
+pub struct MonitorNode<I, T, N> {
+	#[allow(clippy::type_complexity)]
+	io: Arc<Mutex<Option<Arc<IORecord<I, T>>>>>,
+	node: N,
+}
+
+impl<'i, T, I, N> Node<'i, I> for MonitorNode<I, T, N>
+where
+	I: Clone + 'static + Send + Sync,
+	T: Clone + 'static + Send + Sync,
+	for<'a> N: Node<'a, I, Output: Future<Output = T> + WasmNotSend> + 'i,
+{
+	type Output = DynFuture<'i, T>;
+	fn eval(&'i self, input: I) -> Self::Output {
+		let io = self.io.clone();
+		let output_fut = self.node.eval(input.clone());
+		Box::pin(async move {
+			let output = output_fut.await;
+			*io.lock().unwrap() = Some(Arc::new(IORecord { input, output: output.clone() }));
+			output
+		})
+	}
+
+	fn serialize(&self) -> Option<Arc<dyn std::any::Any + Send + Sync>> {
+		let io = self.io.lock().unwrap();
+		(io).as_ref().map(|output| output.clone() as Arc<dyn std::any::Any + Send + Sync>)
+	}
+}
+
+impl<I, T, N> MonitorNode<I, T, N> {
+	pub fn new(node: N) -> MonitorNode<I, T, N> {
+		MonitorNode { io: Arc::new(Mutex::new(None)), node }
+	}
+}
+
+pub mod monitor {
+	use core_types::ProtoNodeIdentifier;
+
+	pub const IDENTIFIER: ProtoNodeIdentifier = ProtoNodeIdentifier::new("graphene_core::memo::MonitorNode");
+}

node-graph/nodes/gcore/src/ops.rs

@@ -0,0 +1,33 @@
+use core_types::{Ctx, ExtractFootprint, ops::Convert, transform::Footprint};
+use std::marker::PhantomData;
+
+// Re-export TypeNode from core-types for convenience
+pub use core_types::ops::TypeNode;
+
+// TODO: Rename to "Passthrough"
+/// Passes-through the input value without changing it.
+/// This is useful for rerouting wires for organization purposes.
+#[node_macro::node(skip_impl)]
+fn identity<'i, T: 'i + Send>(value: T) -> T {
+	value
+}
+
+#[node_macro::node(skip_impl)]
+fn into<'i, T: 'i + Send + Into<O>, O: 'i + Send>(_: impl Ctx, value: T, _out_ty: PhantomData<O>) -> O {
+	value.into()
+}
+
+#[node_macro::node(skip_impl)]
+async fn convert<'i, T: 'i + Send + Convert<O, C>, O: 'i + Send, C: 'i + Send>(ctx: impl Ctx + ExtractFootprint, value: T, converter: C, _out_ty: PhantomData<O>) -> O {
+	value.convert(*ctx.try_footprint().unwrap_or(&Footprint::DEFAULT), converter).await
+}
+
+#[cfg(test)]
+mod test {
+	use super::*;
+
+	#[test]
+	pub fn identity_node() {
+		assert_eq!(identity(&4), &4);
+	}
+}