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/compilation-client/src/lib.rs

@@ -1,15 +1,30 @@
 use gpu_compiler_bin_wrapper::CompileRequest;
-use graph_craft::document::*;
+use gpu_executor::ShaderIO;
+use graph_craft::{proto::ProtoNetwork, Type};
 
-pub async fn compile<I, O>(network: NodeNetwork) -> Result<Vec<u8>, reqwest::Error> {
+pub async fn compile(network: ProtoNetwork, inputs: Vec<Type>, output: Type, io: ShaderIO) -> Result<Shader, reqwest::Error> {
 	let client = reqwest::Client::new();
 
-	let compile_request = CompileRequest::new(network, std::any::type_name::<I>().to_owned(), std::any::type_name::<O>().to_owned());
+	let compile_request = CompileRequest::new(network, inputs.clone(), output.clone(), io.clone());
 	let response = client.post("http://localhost:3000/compile/spirv").json(&compile_request).send();
 	let response = response.await?;
-	response.bytes().await.map(|b| b.to_vec())
+	response.bytes().await.map(|b| Shader {
+		spirv_binary: b.windows(4).map(|x| u32::from_le_bytes(x.try_into().unwrap())).collect(),
+		input_types: inputs,
+		output_type: output,
+		io,
+	})
 }
 
-pub fn compile_sync<I: 'static, O: 'static>(network: NodeNetwork) -> Result<Vec<u8>, reqwest::Error> {
-	future_executor::block_on(compile::<I, O>(network))
+pub fn compile_sync(network: ProtoNetwork, inputs: Vec<Type>, output: Type, io: ShaderIO) -> Result<Shader, reqwest::Error> {
+	future_executor::block_on(compile(network, inputs, output, io))
+}
+
+// TODO: should we add the entry point as a field?
+/// A compiled shader with type annotations.
+pub struct Shader {
+	pub spirv_binary: Vec<u32>,
+	pub input_types: Vec<Type>,
+	pub output_type: Type,
+	pub io: ShaderIO,
 }