Implement Convert trait / node for places we can't use Into

Author: TrueDoctor

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

@@ -101,13 +101,19 @@ pub(super) fn post_process_nodes(mut custom: Vec<DocumentNodeDefinition>) -> Vec
 							let into_node_identifier = ProtoNodeIdentifier {
 								name: format!("graphene_core::ops::IntoNode<{}>", input_ty.clone()).into(),
 							};
+							let convert_node_identifier = ProtoNodeIdentifier {
+								name: format!("graphene_core::ops::ConvertNode<{}>", input_ty.clone()).into(),
+							};
 							let proto_node = if into_node_registry.iter().any(|(ident, _)| {
 								let ident = ident.name.as_ref();
-								// log::debug!("checking: {} against {}", ident, into_node_identifier.name.as_ref());
 								ident == into_node_identifier.name.as_ref()
 							}) {
-								// log::debug!("placing {}", into_node_identifier.name.as_ref());
 								into_node_identifier
+							} else if into_node_registry.iter().any(|(ident, _)| {
+								let ident = ident.name.as_ref();
+								ident == convert_node_identifier.name.as_ref()
+							}) {
+								convert_node_identifier
 							} else {
 								identity_node.clone()
 							};
@@ -122,7 +128,7 @@ pub(super) fn post_process_nodes(mut custom: Vec<DocumentNodeDefinition>) -> Vec
 						_ => DocumentNode {
 							inputs: vec![NodeInput::network(generic!(X), i)],
 							implementation: DocumentNodeImplementation::ProtoNode(identity_node.clone()),
-							visible: true,
+							visible: false,
 							..Default::default()
 						},
 					},

node-graph/gcore/src/ops.rs

@@ -608,6 +608,68 @@ where
 		Box::pin(async move { input.into() })
 	}
 }
+pub trait Convert<T>: Sized {
+	/// Converts this type into the (usually inferred) input type.
+	#[must_use]
+	fn convert(self) -> T;
+}
+
+macro_rules! impl_convert {
+	($from:ty,$to:ty) => {
+		impl Convert<$to> for $from {
+			fn convert(self) -> $to {
+				self as $to
+			}
+		}
+	};
+	($to:ty) => {
+		impl_convert!(i8, $to);
+		impl_convert!(u8, $to);
+		impl_convert!(u16, $to);
+		impl_convert!(i16, $to);
+		impl_convert!(i32, $to);
+		impl_convert!(u32, $to);
+		impl_convert!(i64, $to);
+		impl_convert!(u64, $to);
+		impl_convert!(f32, $to);
+		impl_convert!(f64, $to);
+	};
+}
+impl_convert!(i8);
+impl_convert!(u8);
+impl_convert!(u16);
+impl_convert!(i16);
+impl_convert!(i32);
+impl_convert!(u32);
+impl_convert!(i64);
+impl_convert!(u64);
+impl_convert!(f32);
+impl_convert!(f64);
+
+// Convert
+pub struct ConvertNode<O>(PhantomData<O>);
+impl<_O> ConvertNode<_O> {
+	#[cfg(feature = "alloc")]
+	pub const fn new() -> Self {
+		Self(core::marker::PhantomData)
+	}
+}
+impl<_O> Default for ConvertNode<_O> {
+	fn default() -> Self {
+		Self::new()
+	}
+}
+impl<'input, I: 'input, _O: 'input> Node<'input, I> for ConvertNode<_O>
+where
+	I: Convert<_O> + Sync + Send,
+{
+	type Output = ::dyn_any::DynFuture<'input, _O>;
+
+	#[inline]
+	fn eval(&'input self, input: I) -> Self::Output {
+		Box::pin(async move { input.convert() })
+	}
+}
 
 #[cfg(test)]
 mod test {

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

@@ -15,7 +15,7 @@ use graphene_std::GraphicElement;
 use graphene_std::any::{ComposeTypeErased, DowncastBothNode, DynAnyNode, IntoTypeErasedNode};
 use graphene_std::application_io::{ImageTexture, TextureFrameTable};
 use graphene_std::wasm_application_io::*;
-use node_registry_macros::{async_node, into_node};
+use node_registry_macros::{async_node, convert_node, into_node};
 use once_cell::sync::Lazy;
 use std::collections::HashMap;
 use std::sync::Arc;
@@ -25,10 +25,7 @@ use wgpu_executor::{WgpuExecutor, WgpuSurface, WindowHandle};
 
 // TODO: turn into hashmap
 fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeConstructor>> {
-	let node_types: Vec<(ProtoNodeIdentifier, NodeConstructor, NodeIOTypes)> = vec![
-		into_node!(from: f64, to: f64),
-		into_node!(from: u32, to: f64),
-		into_node!(from: u8, to: u32),
+	let mut node_types: Vec<(ProtoNodeIdentifier, NodeConstructor, NodeIOTypes)> = vec![
 		into_node!(from: VectorDataTable, to: VectorDataTable),
 		into_node!(from: VectorDataTable, to: GraphicElement),
 		into_node!(from: VectorDataTable, to: GraphicGroupTable),
@@ -137,6 +134,22 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 			},
 		),
 	];
+	node_types.extend(
+		[
+			convert_node!(from: i8, to: numbers),
+			convert_node!(from: u8, to: numbers),
+			convert_node!(from: u16, to: numbers),
+			convert_node!(from: i16, to: numbers),
+			convert_node!(from: i32, to: numbers),
+			convert_node!(from: u32, to: numbers),
+			convert_node!(from: i64, to: numbers),
+			convert_node!(from: u64, to: numbers),
+			convert_node!(from: f32, to: numbers),
+			convert_node!(from: f64, to: numbers),
+		]
+		.into_iter()
+		.flatten(),
+	);
 
 	let mut map: HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeConstructor>> = HashMap::new();
 
@@ -152,7 +165,7 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 		// This might be caused by the stringify! macro
 		let mut new_name = id.name.replace('\n', " ");
 		// Remove struct generics for all nodes except for the IntoNode
-		if !new_name.contains("IntoNode") {
+		if !(new_name.contains("IntoNode") || new_name.contains("ConvertNode")) {
 			if let Some((path, _generics)) = new_name.split_once("<") {
 				new_name = path.to_string();
 			}
@@ -203,9 +216,8 @@ mod node_registry_macros {
 		(from: $from:ty, to: $to:ty) => {
 			(
 				ProtoNodeIdentifier::new(concat!["graphene_core::ops::IntoNode<", stringify!($to), ">"]),
-				|mut args| {
+				|_| {
 					Box::pin(async move {
-						args.reverse();
 						let node = graphene_core::ops::IntoNode::<$to>::new();
 						let any: DynAnyNode<$from, _, _> = graphene_std::any::DynAnyNode::new(node);
 						Box::new(any) as TypeErasedBox
@@ -220,7 +232,43 @@ mod node_registry_macros {
 			)
 		};
 	}
+	macro_rules! convert_node {
+		(from: $from:ty, to: numbers) => {{
+			let x: Vec<(ProtoNodeIdentifier, NodeConstructor, NodeIOTypes)> = vec![
+				convert_node!(from: $from, to: i8),
+				convert_node!(from: $from, to: u8),
+				convert_node!(from: $from, to: u16),
+				convert_node!(from: $from, to: i16),
+				convert_node!(from: $from, to: i32),
+				convert_node!(from: $from, to: u32),
+				convert_node!(from: $from, to: i64),
+				convert_node!(from: $from, to: u64),
+				convert_node!(from: $from, to: f32),
+				convert_node!(from: $from, to: f64),
+			];
+			x
+		}};
+		(from: $from:ty, to: $to:ty) => {
+			(
+				ProtoNodeIdentifier::new(concat!["graphene_core::ops::ConvertNode<", stringify!($to), ">"]),
+				|_| {
+					Box::pin(async move {
+						let node = graphene_core::ops::ConvertNode::<$to>::new();
+						let any: DynAnyNode<$from, _, _> = graphene_std::any::DynAnyNode::new(node);
+						Box::new(any) as TypeErasedBox
+					})
+				},
+				{
+					let node = graphene_core::ops::ConvertNode::<$to>::new();
+					let mut node_io = NodeIO::<'_, $from>::to_async_node_io(&node, vec![]);
+					node_io.call_argument = future!(<$from as StaticType>::Static);
+					node_io
+				},
+			)
+		};
+	}
 
 	pub(crate) use async_node;
+	pub(crate) use convert_node;
 	pub(crate) use into_node;
 }