fork/Graphite
1
0
Fork 0
mirror of https://github.com/GraphiteEditor/Graphite.git synced 2026-09-16 06:38:03 +08:00
Code Issues Packages Projects Releases Wiki Activity

Don't force nodes to store references to other nodes

Browse Source
This commit is contained in:
Dennis
2022-06-05 15:25:07 +02:00
committed by Keavon Chambers
parent fa5345d33f
commit a2703c0fb1
12 changed files with 252 additions and 242 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
node-graph/gstd/src/lib.rs
View File

@@ -1,5 +1,5 @@
pub mod value;
pub use graphene_core::{generic, ops, structural};
pub use graphene_core::{generic, ops /*, structural*/};
#[cfg(feature = "caching")]
pub mod caching;
@@ -9,25 +9,10 @@ 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 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>);
}
pub trait AnyRef<'n, I: 'n + StaticType>: Node<'n, &'n I> {
fn any(&'n self, input: &'n dyn DynAny<'n>) -> Self::Output;
}
impl<'n, N: Node<'n, &'n I>, I: StaticType + 'n> AnyRef<'n, I> for N {
fn any(&'n self, input: &'n dyn DynAny<'n>) -> Self::Output {
self.eval(downcast_ref::<I>(input).unwrap_or_else(|| {
panic!(
"Node was evaluated with wrong input. The input has to be of type: {}",
std::any::type_name::<I>(),
)
}))
}
}

28
node-graph/gstd/src/main.rs
View File

@@ -25,13 +25,13 @@ mod mul {
pub a: Option<DynNode<'n, &'n f32>>,
pub b: Option<DynNode<'n, &'n f32>>,
}
impl<'n> Node<'n, ()> for MulNodeAnyProxy<'n> {
impl<'n> Node<'n> for MulNodeAnyProxy<'n> {
type Output = MulNodeInput<'n>;
fn eval(&'n self, _input: ()) -> <Self as graphene_std::Node<'n, ()>>::Output {
let a = self.a.unwrap().eval(());
fn eval(&'n self) -> <Self as graphene_std::Node<'n>>::Output {
let a = self.a.unwrap().eval();
let a: &f32 = self
.a
.map(|v| downcast_ref(v.eval(())).unwrap())
.map(|v| downcast_ref(v.eval()).unwrap())
.unwrap_or(&1.);
/*let b: &f32 = self
.b
@@ -41,11 +41,11 @@ mod mul {
MulNodeInput { a, b: a }
}
}
impl<'n> Node<'n, ()> for MulNodeTypedProxy<'n> {
impl<'n> Node<'n> for MulNodeTypedProxy<'n> {
type Output = MulNodeInput<'n>;
fn eval(&'n self, _input: ()) -> <Self as graphene_std::Node<'n, ()>>::Output {
let a = self.a.unwrap().eval(());
let b = self.b.unwrap().eval(());
fn eval(&'n self) -> <Self as graphene_std::Node<'n>>::Output {
let a = self.a.unwrap().eval();
let b = self.b.unwrap().eval();
MulNodeInput { a, b }
}
}
@@ -71,7 +71,7 @@ mod mul {
}
}
}
type SNode<'n> = dyn Node<'n, (), Output = &'n dyn DynAny<'n>>;
type SNode<'n> = dyn Node<'n, Output = &'n dyn DynAny<'n>>;
struct NodeStore<'n>(borrow_stack::FixedSizeStack<'n, Box<SNode<'n>>>);
@@ -91,14 +91,16 @@ impl<'n> NodeStore<'n> {
}
fn main() {
use dyn_any::{downcast_ref, DynAny, StaticType};
//let mut mul = mul::MulNode::new();
let mut stack: borrow_stack::FixedSizeStack<Box<dyn Node<'_, (), Output = &dyn DynAny>>> =
let mut stack: borrow_stack::FixedSizeStack<Box<dyn Node<'_, Output = &dyn DynAny>>> =
borrow_stack::FixedSizeStack::new(42);
unsafe { stack.push(Box::new(AnyValueNode::new(1f32))) };
//let node = unsafe { stack.get(0) };
//let boxed = Box::new(StorageNode::new(node));
//unsafe { stack.push(boxed) };
let result = unsafe { &stack.get()[0] }.eval(());
let result = unsafe { &stack.get()[0] }.eval();
dbg!(downcast_ref::<f32>(result));
/*unsafe {
stack
.push(Box::new(AnyRefNode::new(stack.get(0).as_ref()))
@@ -117,8 +119,8 @@ fn main() {
//let foo = value::AnyRefNode::new(&cached);
mul2.set_arg_by_index(0, &any_a);*/
let int = value::IntNode::<32>;
int.exec();
println!("{}", int.exec());
Node::eval(&int);
println!("{}", Node::eval(&int));
//let _add: u32 = ops::AddNode::<u32>::default().eval((int.exec(), int.exec()));
//let fnode = generic::FnNode::new(|(a, b): &(i32, i32)| a - b);
//let sub = fnode.any(&("a", 2));

19
node-graph/gstd/src/memo.rs
View File

@@ -1,30 +1,33 @@
use graphene_core::{Cache, Node};
use once_cell::sync::OnceCell;
use std::marker::PhantomData;
/// Caches the output of a given Node and acts as a proxy
pub struct CacheNode<'n, CachedNode: Node<'n, Input>, Input> {
node: &'n CachedNode,
pub struct CacheNode<'n, CachedNode: Node<'n>> {
node: CachedNode,
cache: OnceCell<CachedNode::Output>,
_phantom: PhantomData<&'n ()>,
}
impl<'n, CashedNode: Node<'n, Input>, Input> Node<'n, Input> for CacheNode<'n, CashedNode, Input> {
impl<'n, CashedNode: Node<'n>> Node<'n> for CacheNode<'n, CashedNode> {
type Output = &'n CashedNode::Output;
fn eval(&'n self, input: Input) -> Self::Output {
self.cache.get_or_init(|| self.node.eval(input))
fn eval(&'n self) -> Self::Output {
self.cache.get_or_init(|| self.node.eval())
}
}
impl<'n, CachedNode: Node<'n, Input>, Input> CacheNode<'n, CachedNode, Input> {
impl<'n, CachedNode: Node<'n>> CacheNode<'n, CachedNode> {
pub fn clear(&'n mut self) {
self.cache = OnceCell::new();
}
pub fn new(node: &'n CachedNode) -> CacheNode<'n, CachedNode, Input> {
pub fn new(node: CachedNode) -> CacheNode<'n, CachedNode> {
CacheNode {
node,
cache: OnceCell::new(),
_phantom: PhantomData,
}
}
}
impl<'n, CachedNode: Node<'n, Input>, Input> Cache for CacheNode<'n, CachedNode, Input> {
impl<'n, CachedNode: Node<'n>> Cache for CacheNode<'n, CachedNode> {
fn clear(&mut self) {
self.cache = OnceCell::new();
}

34
node-graph/gstd/src/value.rs
View File

@@ -4,47 +4,41 @@ use graphene_core::Node;
use dyn_any::{DynAny, StaticType, StaticTypeSized};
pub struct AnyRefNode<'n, N: Node<'n, I, Output = O>, I, O>(
&'n N,
PhantomData<&'n I>,
PhantomData<&'n O>,
);
pub struct AnyRefNode<'n, N: Node<'n>>(N, PhantomData<&'n ()>);
impl<'n, N: Node<'n, I, Output = &'n O>, I, O: DynAny<'n>> Node<'n, I>
for AnyRefNode<'n, N, I, &'n O>
{
impl<'n, N: Node<'n, Output = &'n O>, O: DynAny<'n> + 'n> Node<'n> for AnyRefNode<'n, N> {
type Output = &'n (dyn DynAny<'n>);
fn eval(&'n self, input: I) -> Self::Output {
let value: &O = self.0.eval(input);
fn eval(&'n self) -> Self::Output {
let value: &O = self.0.eval();
value
}
}
impl<'n, N: Node<'n, I, Output = &'n O>, I, O: 'n + ?Sized> AnyRefNode<'n, N, I, &'n O> {
pub fn new(n: &'n N) -> AnyRefNode<'n, N, I, &'n O> {
AnyRefNode(n, PhantomData, PhantomData)
impl<'n, N: Node<'n, Output = &'n O>, O: 'n + ?Sized> AnyRefNode<'n, N> {
pub fn new(n: N) -> AnyRefNode<'n, N> {
AnyRefNode(n, PhantomData)
}
}
pub struct StorageNode<'n>(&'n dyn Node<'n, (), Output = &'n dyn DynAny<'n>>);
pub struct StorageNode<'n>(&'n dyn Node<'n, Output = &'n dyn DynAny<'n>>);
impl<'n> Node<'n, ()> for StorageNode<'n> {
impl<'n> Node<'n> for StorageNode<'n> {
type Output = &'n (dyn DynAny<'n>);
fn eval(&'n self, input: ()) -> Self::Output {
let value = self.0.eval(input);
fn eval(&'n self) -> Self::Output {
let value = self.0.eval();
value
}
}
impl<'n> StorageNode<'n> {
pub fn new<N: Node<'n, (), Output = &'n dyn DynAny<'n>>>(n: &'n N) -> StorageNode<'n> {
pub fn new<N: Node<'n, Output = &'n dyn DynAny<'n>>>(n: &'n N) -> StorageNode<'n> {
StorageNode(n)
}
}
#[derive(Default)]
pub struct AnyValueNode<'n, T>(T, PhantomData<&'n ()>);
impl<'n, T: 'n + DynAny<'n>> Node<'n, ()> for AnyValueNode<'n, T> {
impl<'n, T: 'n + DynAny<'n>> Node<'n> for AnyValueNode<'n, T> {
type Output = &'n dyn DynAny<'n>;
fn eval(&'n self, _input: ()) -> &'n dyn DynAny<'n> {
fn eval(&'n self) -> &'n dyn DynAny<'n> {
&self.0
}
}