Restructure GPU execution to model GPU pipelines in the node graph (#1088)

* Start implementing GpuExecutor for wgpu

* Implement read_output_buffer function

* Implement extraction node in the compiler

* Generate type annotations during shader compilation

* Start adding node wrapprs for graph execution api

* Wrap more of the api in nodes

* Restructure Pipeline to accept arbitrary shader inputs

* Adapt nodes to new trait definitions

* Start implementing gpu-compiler trait

* Adapt shader generation

* Hardstuck on pointer casts

* Pass nodes as references in gpu code to avoid zsts

* Update gcore to compile on the gpu

* Fix color doc tests

* Impl Node for node refs

node-graph/gcore/src/structural.rs

@@ -2,60 +2,47 @@ use core::marker::PhantomData;
 
 use crate::Node;
 
-pub struct ComposeNode<First: for<'i> Node<'i, I>, Second: for<'i> Node<'i, <First as Node<'i, I>>::Output>, I> {
+#[derive(Clone)]
+pub struct ComposeNode<First, Second, I> {
 	first: First,
 	second: Second,
 	phantom: PhantomData<I>,
 }
 
-impl<'i, Input: 'i, First, Second> Node<'i, Input> for ComposeNode<First, Second, Input>
+impl<'i, 'f: 'i, 's: 'i, Input: 'i, First, Second> Node<'i, Input> for ComposeNode<First, Second, Input>
 where
-	First: for<'a> Node<'a, Input> + 'i,
-	Second: for<'a> Node<'a, <First as Node<'a, Input>>::Output> + 'i,
+	First: Node<'i, Input>,
+	Second: Node<'i, <First as Node<'i, Input>>::Output> + 'i,
 {
 	type Output = <Second as Node<'i, <First as Node<'i, Input>>::Output>>::Output;
 	fn eval(&'i self, input: Input) -> Self::Output {
 		let arg = self.first.eval(input);
-		self.second.eval(arg)
+		let second = &self.second;
+		second.eval(arg)
 	}
 }
 
-impl<First, Second, Input> ComposeNode<First, Second, Input>
+impl<'i, First, Second, Input: 'i> ComposeNode<First, Second, Input>
 where
-	First: for<'a> Node<'a, Input>,
-	Second: for<'a> Node<'a, <First as Node<'a, Input>>::Output>,
+	First: Node<'i, Input>,
+	Second: Node<'i, <First as Node<'i, Input>>::Output>,
 {
 	pub const fn new(first: First, second: Second) -> Self {
 		ComposeNode::<First, Second, Input> { first, second, phantom: PhantomData }
 	}
 }
 
-// impl Clone for ComposeNode<First, Second, Input>
-impl<First, Second, Input> Clone for ComposeNode<First, Second, Input>
-where
-	First: for<'a> Node<'a, Input> + Clone,
-	Second: for<'a> Node<'a, <First as Node<'a, Input>>::Output> + Clone,
-{
-	fn clone(&self) -> Self {
-		ComposeNode::<First, Second, Input> {
-			first: self.first.clone(),
-			second: self.second.clone(),
-			phantom: PhantomData,
-		}
-	}
-}
-
 pub trait Then<'i, Input: 'i>: Sized {
 	fn then<Second>(self, second: Second) -> ComposeNode<Self, Second, Input>
 	where
-		Self: for<'a> Node<'a, Input>,
-		Second: for<'a> Node<'a, <Self as Node<'a, Input>>::Output>,
+		Self: Node<'i, Input>,
+		Second: Node<'i, <Self as Node<'i, Input>>::Output>,
 	{
 		ComposeNode::new(self, second)
 	}
 }
 
-impl<'i, First: for<'a> Node<'a, Input>, Input: 'i> Then<'i, Input> for First {}
+impl<'i, First: Node<'i, Input>, Input: 'i> Then<'i, Input> for First {}
 
 pub struct ConsNode<I: From<()>, Root>(pub Root, PhantomData<I>);
 
@@ -89,4 +76,16 @@ mod test {
 		let type_erased = &compose as &dyn for<'i> Node<'i, (), Output = &'i u32>;
 		assert_eq!(type_erased.eval(()), &4u32);
 	}
+
+	#[test]
+	fn test_ref_eval() {
+		let value = ValueNode::new(5);
+
+		assert_eq!((&value).eval(()), &5);
+		let id = IdNode::new();
+
+		let compose = ComposeNode::new(&value, &id);
+
+		assert_eq!(compose.eval(()), &5);
+	}
 }