76 lines
2.3 KiB
Plaintext
76 lines
2.3 KiB
Plaintext
pub mod value;
|
|
pub use graphene_core::{generic, ops /*, structural*/};
|
|
|
|
#[cfg(feature = "caching")]
|
|
pub mod caching;
|
|
#[cfg(feature = "memoization")]
|
|
pub mod memo;
|
|
|
|
pub use graphene_core::*;
|
|
|
|
use dyn_any::{downcast_ref, DynAny, StaticType};
|
|
pub type DynNode<'n, T> = &'n (dyn Node<'n, Output = T> + 'n);
|
|
pub type DynAnyNode<'n> = &'n (dyn Node<'n, Output = &'n dyn DynAny<'n>> + 'n);
|
|
|
|
pub trait DynamicInput<'n> {
|
|
fn set_kwarg_by_name(&mut self, name: &str, value: DynAnyNode<'n>);
|
|
fn set_arg_by_index(&mut self, index: usize, value: DynAnyNode<'n>);
|
|
}
|
|
|
|
use quote::quote;
|
|
use syn::{Expr, ExprPath, Type};
|
|
|
|
/// Given a Node call tree, construct a function
|
|
/// that takes an input tuple and evaluates the call graph
|
|
/// on the gpu an fn node is constructed that takes a value
|
|
/// node as input
|
|
struct NodeGraph {
|
|
/// Collection of nodes with their corresponding inputs.
|
|
/// The first node always always has to be an Input Node.
|
|
nodes: Vec<NodeKind>,
|
|
}
|
|
enum NodeKind {
|
|
Value(Expr),
|
|
Input(Type),
|
|
Node(ExprPath, Vec<u64>),
|
|
}
|
|
|
|
impl NodeGraph {
|
|
pub fn serialize(&self) -> String {
|
|
let mut output = String::new();
|
|
let output_type = if let Some(NodeKind::Node(expr, _)) = self.nodes.last() {
|
|
expr
|
|
} else {
|
|
panic!("last node wasn't a valid node")
|
|
};
|
|
let output_type = quote! {#output_type::Output};
|
|
let input_type = if let Some(NodeKind::Input(type_)) = self.nodes.first() {
|
|
type_
|
|
} else {
|
|
panic!("first node wasn't an input node")
|
|
};
|
|
|
|
let mut nodes = Vec::new();
|
|
for (id, node) in self.nodes.iter().enumerate() {
|
|
let nid = |id| format!("n{id}");
|
|
let id = nid(&id as u64);
|
|
let line = match node {
|
|
NodeKind::Value(val) => {
|
|
quote! {let #id = graphene_core::value::ValueNode::new(#val);}
|
|
}
|
|
NodeKind::Node(node, ids) => {
|
|
let ids = ids.iter().map(nid).collect::<Vec<_>>();
|
|
quote! {let #id = #node::new(((#(#ids),)*));}
|
|
}
|
|
};
|
|
nodes.push(line)
|
|
}
|
|
let function = quote! {
|
|
fn node_graph(input: #input_type) -> #output_type {
|
|
#(#nodes)*
|
|
}
|
|
};
|
|
function.to_string()
|
|
}
|
|
}
|