Implement new node_fn macro

Author: TrueDoctor

Cargo.lock

@@ -154,7 +154,7 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 			category: "Value",
 			node_template: NodeTemplate {
 				document_node: DocumentNode {
-					implementation: DocumentNodeImplementation::proto("graphene_core::ops::ConstructVector2<_, _>"),
+					implementation: DocumentNodeImplementation::proto("graphene_core::ops::construct_vector2::ConstructVector2"),
 					inputs: vec![
 						NodeInput::value(TaggedValue::None, false),
 						NodeInput::value(TaggedValue::F64(0.), false),

editor/src/messages/portfolio/document/node_graph/document_node_definitions.rs

@@ -19,7 +19,15 @@ export async function initWasm() {
 
 	// Import the WASM module JS bindings and wrap them in the panic proxy
 	// eslint-disable-next-line import/no-cycle
-	await init();
+	let wasm = await init();
+	// console.log(wasm);
+	for (const [name, f] of Object.entries(wasm)) {
+		if (name.startsWith("__node_registry")) {
+				console.log(f);
+				f();
+		}
+	}
+	
 	wasmImport = await wasmMemory();
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	(window as any).imageCanvases = {};

frontend/src/wasm-communication/editor.ts

@@ -8,6 +8,7 @@ pub mod editor_api;
 pub mod helpers;
 
 use editor::messages::prelude::*;
+use js_sys::{Array, Function, Object, Reflect};
 
 use std::panic;
 use std::sync::atomic::{AtomicBool, Ordering};

frontend/wasm/src/lib.rs

@@ -30,7 +30,7 @@ std = [
 ]
 reflections = [
 	"alloc",
-	"ctor"
+	"ctor",
 ]
 serde = [
 	"dep:serde",

node-graph/gcore/Cargo.toml

@@ -40,7 +40,7 @@ pub mod vector;
 #[cfg(feature = "alloc")]
 pub mod application_io;
 
-#[cfg(feature = "alloc")]
+#[cfg(feature = "reflections")]
 pub mod registry;
 
 pub mod quantization;

node-graph/gcore/src/lib.rs

@@ -192,12 +192,8 @@ where
 	first % second
 }
 
-pub struct ConstructVector2<X, Y> {
-	x: X,
-	y: Y,
-}
-#[node_macro::node_fn(ConstructVector2)]
-fn construct_vector2(_primary: (), x: f64, y: f64) -> glam::DVec2 {
+#[node_macro::new_node_fn]
+fn construct_vector2(_: (), x: f64, y: f64) -> glam::DVec2 {
 	glam::DVec2::new(x, y)
 }
 

node-graph/gcore/src/ops.rs

@@ -233,116 +233,3 @@ where
 		}
 	}
 }
-
-async fn construct_vector2<'n, IY: Into<f64> + Send + 'n, IC: Into<u64> + Send + 'n>(_: (), x: f64, y: IY, c: impl Node<'n, (), Output: core::future::Future<Output = IC>>) -> glam::DVec2 {
-	glam::DVec2::new(x, y.into())
-}
-mod construct_vector2 {
-	use super::*;
-	use crate as gcore;
-	use ctor::ctor;
-	use gcore::ops::TypeNode;
-	use gcore::registry::{DowncastBothNode, DynAnyNode, DynFuture, FieldMetadata, NodeMetadata, TypeErasedBox, NODE_METADATA, NODE_REGISTRY};
-	use gcore::value::ClonedNode;
-	use gcore::{concrete, fn_type, Node, NodeIOTypes, ProtoNodeIdentifier, WasmNotSync};
-	pub struct ConstructVector2<Node0, Node1, Node2> {
-		x: Node0,
-		y: Node1,
-		c: Node2,
-	}
-	#[automatically_derived]
-	impl<'n, IY: Into<f64> + Send + 'n, IC: Into<u64> + Send + 'n, Node0, Node1, Node2> Node<'n, ()> for ConstructVector2<Node0, Node1, Node2>
-	where
-		Node0: Node<'n, (), Output = f64>,
-		Node1: Node<'n, (), Output = IY>,
-		Node2: Node<'n, (), Output: core::future::Future<Output = IC>> + WasmNotSync + 'n,
-	{
-		type Output = DynFuture<'n, glam::DVec2>;
-		fn eval(&'n self, input: ()) -> Self::Output {
-			let x = self.x.eval(());
-			let y = self.y.eval(());
-			let c = &self.c;
-			Box::pin(construct_vector2(input, x, y, c))
-		}
-	}
-	#[automatically_derived]
-	impl<'n, Node0, Node1, Node2> ConstructVector2<Node0, Node1, Node2> {
-		pub fn new(x: Node0, y: Node1, c: Node2) -> Self {
-			Self { x, y, c }
-		}
-	}
-	#[ctor]
-	fn register_node() {
-		let mut registry = NODE_REGISTRY.lock().unwrap();
-		registry.insert(
-			ProtoNodeIdentifier::new(concat![std::module_path!(), "::", stringify!(ConstructVector2)]),
-			vec![
-				(
-					|args| {
-						Box::pin(async move {
-							let x: DowncastBothNode<(), f64> = DowncastBothNode::new(args[0usize].clone());
-							let value = x.eval(()).await;
-							let x = ClonedNode::new(value);
-							let x: TypeNode<_, (), f64> = TypeNode::new(x);
-							let y: DowncastBothNode<(), f32> = DowncastBothNode::new(args[1usize].clone());
-							let value = y.eval(()).await;
-							let y = ClonedNode::new(value);
-							let y: TypeNode<_, (), f32> = TypeNode::new(y);
-							let c: DowncastBothNode<(), u32> = DowncastBothNode::new(args[2usize].clone());
-							let node = ConstructVector2::new(x, y, c);
-							let any: DynAnyNode<(), _, _> = DynAnyNode::new(node);
-							Box::new(any) as TypeErasedBox<'_>
-						})
-					},
-					NodeIOTypes::new(concrete!(()), concrete!(glam::DVec2), vec![fn_type!((), f64), fn_type!((), f32), fn_type!((), u32)]),
-				),
-				(
-					|args| {
-						Box::pin(async move {
-							let x: DowncastBothNode<(), f64> = DowncastBothNode::new(args[0usize].clone());
-							let value = x.eval(()).await;
-							let x = ClonedNode::new(value);
-							let x: TypeNode<_, (), f64> = TypeNode::new(x);
-							let y: DowncastBothNode<(), f64> = DowncastBothNode::new(args[1usize].clone());
-							let value = y.eval(()).await;
-							let y = ClonedNode::new(value);
-							let y: TypeNode<_, (), f64> = TypeNode::new(y);
-							let c: DowncastBothNode<(), u64> = DowncastBothNode::new(args[2usize].clone());
-							let node = ConstructVector2::new(x, y, c);
-							let any: DynAnyNode<(), _, _> = DynAnyNode::new(node);
-							Box::new(any) as TypeErasedBox<'_>
-						})
-					},
-					NodeIOTypes::new(concrete!(()), concrete!(glam::DVec2), vec![fn_type!((), f64), fn_type!((), f64), fn_type!((), u64)]),
-				),
-			],
-		);
-	}
-	#[ctor]
-	fn register_metadata() {
-		let metadata = NodeMetadata {
-			identifier: ProtoNodeIdentifier::new(concat![std::module_path!(), "::", stringify!(ConstructVector2)]),
-			category: Some("Value"),
-			input_type: concrete!(()),
-			output_type: concrete!(glam::DVec2),
-			fields: vec![
-				FieldMetadata {
-					name: stringify!(x).to_string(),
-					default_value: Some(stringify!(1.3)),
-				},
-				FieldMetadata {
-					name: stringify!(y).to_string(),
-					default_value: None,
-				},
-				FieldMetadata {
-					name: stringify!(c).to_string(),
-					default_value: None,
-				},
-			],
-		};
-		NODE_METADATA
-			.lock()
-			.unwrap()
-			.insert(ProtoNodeIdentifier::new(concat![std::module_path!(), "::", stringify!(ConstructVector2)]), metadata);
-	}
-}

node-graph/gcore/src/registry.rs

@@ -286,7 +286,6 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 		register_node!(graphene_core::ops::ModuloNode<_>, input: &f64, params: [f64]),
 		register_node!(graphene_core::ops::ModuloNode<_>, input: f64, params: [&f64]),
 		register_node!(graphene_core::ops::ModuloNode<_>, input: &f64, params: [&f64]),
-		register_node!(graphene_core::ops::ConstructVector2<_, _>, input: (), params: [f64, f64]),
 		register_node!(graphene_core::ops::SomeNode, input: &WasmEditorApi, params: []),
 		register_node!(graphene_core::ops::UnwrapNode, input: Option<Color>, params: []),
 		register_node!(graphene_core::logic::LogToConsoleNode, input: bool, params: []),
@@ -806,6 +805,12 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 		async_node!(graphene_core::AddArtboardNode<_, _>, input: Footprint, output: ArtboardGroup, fn_params: [Footprint => ArtboardGroup, Footprint => Artboard]),
 	];
 	let mut map: HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeConstructor>> = HashMap::new();
+	for (id, entry) in graphene_core::registry::NODE_REGISTRY.lock().unwrap().drain() {
+		log::debug!("id: {id:?}");
+		for (constructor, types) in entry.into_iter() {
+			map.entry(id.clone()).or_default().insert(types, constructor);
+		}
+	}
 	for (id, c, types) in node_types.into_iter().flatten() {
 		// TODO: this is a hack to remove the newline from the node new_name
 		// This occurs for the ChannelMixerNode presumably because of the long name.

node-graph/interpreted-executor/src/node_registry.rs

@@ -15,6 +15,11 @@ proc-macro = true
 
 [dependencies]
 # Workspace dependencies
-syn = { workspace = true }
+syn = { workspace = true, features = ["extra-traits", "full"] }
 proc-macro2 = { workspace = true }
 quote = { workspace = true }
+
+convert_case = "0.6.0"
+indoc = "2.0.5"
+proc-macro-crate = "3.1.0"
+