Merge branch 'master' into masking

node-graph/gcore/src/context.rs

@@ -356,7 +356,7 @@ pub struct ContextImpl<'a> {
 }
 
 impl<'a> ContextImpl<'a> {
-	pub fn with_footprint<'f>(&self, new_footprint: &'f Footprint, varargs: Option<&'f impl (Borrow<[DynRef<'f>]>)>) -> ContextImpl<'f>
+	pub fn with_footprint<'f>(&self, new_footprint: &'f Footprint, varargs: Option<&'f impl Borrow<[DynRef<'f>]>>) -> ContextImpl<'f>
 	where
 		'a: 'f,
 	{

node-graph/gcore/src/lib.rs

@@ -12,7 +12,7 @@ pub mod debug;
 pub mod extract_xy;
 pub mod generic;
 pub mod gradient;
-mod graphic_element;
+pub mod graphic_element;
 pub mod instances;
 pub mod logic;
 pub mod math;
@@ -35,7 +35,7 @@ pub use blending::*;
 pub use context::*;
 pub use ctor;
 pub use dyn_any::{StaticTypeSized, WasmNotSend, WasmNotSync};
-pub use graphic_element::*;
+pub use graphic_element::{Artboard, ArtboardGroupTable, GraphicElement, GraphicGroupTable};
 pub use memo::MemoHash;
 pub use num_traits;
 pub use raster::Color;
@@ -161,7 +161,7 @@ where
 
 pub trait NodeInputDecleration {
 	const INDEX: usize;
-	fn identifier() -> &'static str;
+	fn identifier() -> ProtoNodeIdentifier;
 	type Result;
 }
 

node-graph/gcore/src/memo.rs

@@ -2,6 +2,7 @@ use crate::{Node, WasmNotSend};
 use dyn_any::DynFuture;
 use std::future::Future;
 use std::hash::DefaultHasher;
+use std::hash::{Hash, Hasher};
 use std::ops::Deref;
 use std::sync::Arc;
 use std::sync::Mutex;
@@ -49,6 +50,10 @@ impl<T, CachedNode> MemoNode<T, CachedNode> {
 	}
 }
 
+pub mod memo {
+	pub const IDENTIFIER: crate::ProtoNodeIdentifier = crate::ProtoNodeIdentifier::new("graphene_core::memo::MemoNode");
+}
+
 /// Caches the output of a given Node and acts as a proxy.
 /// In contrast to the regular `MemoNode`. This node ignores all input.
 /// Using this node might result in the document not updating properly,
@@ -98,6 +103,10 @@ impl<T, I, CachedNode> ImpureMemoNode<I, T, CachedNode> {
 	}
 }
 
+pub mod impure_memo {
+	pub const IDENTIFIER: crate::ProtoNodeIdentifier = crate::ProtoNodeIdentifier::new("graphene_core::memo::ImpureMemoNode");
+}
+
 /// Stores both what a node was called with and what it returned.
 #[derive(Clone, Debug)]
 pub struct IORecord<I, O> {
@@ -142,7 +151,10 @@ impl<I, T, N> MonitorNode<I, T, N> {
 	}
 }
 
-use std::hash::{Hash, Hasher};
+pub mod monitor {
+	pub const IDENTIFIER: crate::ProtoNodeIdentifier = crate::ProtoNodeIdentifier::new("graphene_core::memo::MonitorNode");
+}
+
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug)]
 pub struct MemoHash<T: Hash> {
 	hash: u64,

node-graph/gcore/src/registry.rs

@@ -1,4 +1,4 @@
-use crate::{Node, NodeIO, NodeIOTypes, Type, WasmNotSend};
+use crate::{Node, NodeIO, NodeIOTypes, ProtoNodeIdentifier, Type, WasmNotSend};
 use dyn_any::{DynAny, StaticType};
 use std::borrow::Cow;
 use std::collections::HashMap;
@@ -103,11 +103,11 @@ pub enum RegistryValueSource {
 	Scope(&'static str),
 }
 
-type NodeRegistry = LazyLock<Mutex<HashMap<String, Vec<(NodeConstructor, NodeIOTypes)>>>>;
+type NodeRegistry = LazyLock<Mutex<HashMap<ProtoNodeIdentifier, Vec<(NodeConstructor, NodeIOTypes)>>>>;
 
 pub static NODE_REGISTRY: NodeRegistry = LazyLock::new(|| Mutex::new(HashMap::new()));
 
-pub static NODE_METADATA: LazyLock<Mutex<HashMap<String, NodeMetadata>>> = LazyLock::new(|| Mutex::new(HashMap::new()));
+pub static NODE_METADATA: LazyLock<Mutex<HashMap<ProtoNodeIdentifier, NodeMetadata>>> = LazyLock::new(|| Mutex::new(HashMap::new()));
 
 #[cfg(not(target_arch = "wasm32"))]
 pub type DynFuture<'n, T> = Pin<Box<dyn Future<Output = T> + 'n + Send>>;

node-graph/gcore/src/transform_nodes.rs

@@ -20,7 +20,6 @@ async fn transform<T: 'n + 'static>(
 	rotate: f64,
 	scale: DVec2,
 	skew: DVec2,
-	_pivot: DVec2,
 ) -> Instances<T> {
 	let matrix = DAffine2::from_scale_angle_translation(scale, rotate, translate) * DAffine2::from_cols_array(&[1., skew.y, skew.x, 1., 0., 0.]);
 

node-graph/gcore/src/types.rs

@@ -1,6 +1,7 @@
 use std::any::TypeId;
 
 pub use std::borrow::Cow;
+use std::ops::Deref;
 
 #[macro_export]
 macro_rules! concrete {
@@ -128,12 +129,37 @@ impl std::fmt::Debug for NodeIOTypes {
 pub struct ProtoNodeIdentifier {
 	pub name: Cow<'static, str>,
 }
+
 impl From<String> for ProtoNodeIdentifier {
 	fn from(value: String) -> Self {
 		Self { name: Cow::Owned(value) }
 	}
 }
 
+impl From<&'static str> for ProtoNodeIdentifier {
+	fn from(s: &'static str) -> Self {
+		ProtoNodeIdentifier { name: Cow::Borrowed(s) }
+	}
+}
+
+impl ProtoNodeIdentifier {
+	pub const fn new(name: &'static str) -> Self {
+		ProtoNodeIdentifier { name: Cow::Borrowed(name) }
+	}
+
+	pub const fn with_owned_string(name: String) -> Self {
+		ProtoNodeIdentifier { name: Cow::Owned(name) }
+	}
+}
+
+impl Deref for ProtoNodeIdentifier {
+	type Target = str;
+
+	fn deref(&self) -> &Self::Target {
+		self.name.as_ref()
+	}
+}
+
 fn migrate_type_descriptor_names<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Result<Cow<'static, str>, D::Error> {
 	use serde::Deserialize;
 
@@ -306,6 +332,13 @@ impl Type {
 			Self::Future(output) => output.replace_nested(f),
 		}
 	}
+
+	pub fn to_cow_string(&self) -> Cow<'static, str> {
+		match self {
+			Type::Generic(name) => name.clone(),
+			_ => Cow::Owned(self.to_string()),
+		}
+	}
 }
 
 fn format_type(ty: &str) -> String {
@@ -343,19 +376,3 @@ impl std::fmt::Display for Type {
 		write!(f, "{}", result)
 	}
 }
-
-impl From<&'static str> for ProtoNodeIdentifier {
-	fn from(s: &'static str) -> Self {
-		ProtoNodeIdentifier { name: Cow::Borrowed(s) }
-	}
-}
-
-impl ProtoNodeIdentifier {
-	pub const fn new(name: &'static str) -> Self {
-		ProtoNodeIdentifier { name: Cow::Borrowed(name) }
-	}
-
-	pub const fn with_owned_string(name: String) -> Self {
-		ProtoNodeIdentifier { name: Cow::Owned(name) }
-	}
-}

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

@@ -1,7 +1,7 @@
 use super::*;
 use crate::Ctx;
 use crate::instances::Instance;
-use crate::uuid::generate_uuid;
+use crate::uuid::{NodeId, generate_uuid};
 use bezier_rs::BezierHandles;
 use dyn_any::DynAny;
 use kurbo::{BezPath, PathEl, Point};
@@ -420,12 +420,17 @@ impl Hash for VectorModification {
 
 /// 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 {
+async fn path_modify(_ctx: impl Ctx, mut vector_data: VectorDataTable, modification: Box<VectorModification>, node_path: Vec<NodeId>) -> 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);
+
+	// Update the source node id
+	let this_node_path = node_path.iter().rev().nth(1).copied();
+	*vector_data_instance.source_node_id = vector_data_instance.source_node_id.or(this_node_path);
+
 	if vector_data.len() > 1 {
 		warn!("The path modify ran on {} instances of vector data. Only the first can be modified.", vector_data.len());
 	}

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

@@ -352,8 +352,7 @@ async fn copy_to_points<I: 'n + Send + Clone>(
 			let transform = DAffine2::from_scale_angle_translation(DVec2::splat(scale), rotation, translation);
 
 			for mut instance in instance.instance_ref_iter().map(|instance| instance.to_instance_cloned()) {
-				let local_matrix = DAffine2::from_mat2(instance.transform.matrix2);
-				instance.transform = transform * local_matrix;
+				instance.transform = transform * instance.transform;
 
 				result_table.push(instance);
 			}