Bump dyn-any version + format code

Cargo.lock

@@ -283,14 +283,14 @@ checksum = "9bda8e21c04aca2ae33ffc2fd8c23134f3cac46db123ba97bd9d3f3b8a4a85e1"
 
 [[package]]
 name = "dyn-any"
-version = "0.2.0"
+version = "0.2.1"
 dependencies = [
  "dyn-any-derive",
 ]
 
 [[package]]
 name = "dyn-any-derive"
-version = "0.2.0"
+version = "0.2.1"
 dependencies = [
  "dyn-any",
  "proc-macro2",

libraries/dyn-any/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "dyn-any"
-version = "0.2.0"
+version = "0.2.1"
 edition = "2021"
 authors = ["Dennis Kobert <dennis@kobert.dev>"]
 

libraries/dyn-any/derive/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "dyn-any-derive"
-version = "0.2.0"
+version = "0.2.1"
 edition = "2021"
 authors = ["Dennis Kobert"]
 

libraries/dyn-any/src/lib.rs

@@ -61,9 +61,7 @@ macro_rules! impl_type {
         )*
     };
 }
-impl<'a, T: Clone + StaticTypeClone> StaticTypeClone
+impl<'a, T: Clone + StaticTypeClone> StaticTypeClone for std::borrow::Cow<'a, T> {
-    for std::borrow::Cow<'a, T>
-{
 	type Static = std::borrow::Cow<'static, <T as StaticTypeSized>::Static>;
 }
 impl<'a, T: StaticTypeSized> StaticTypeSized for *const [T] {

node-graph/borrow_stack/src/lib.rs

@@ -24,12 +24,7 @@ impl<'n, T: Unpin> FixedSizeStack<'n, T> {
 	pub fn new(capacity: usize) -> Self {
 		let layout = std::alloc::Layout::array::<MaybeUninit<T>>(capacity).unwrap();
 		let array = unsafe { std::alloc::alloc(layout) };
-        let array = Pin::new(unsafe {
+		let array = Pin::new(unsafe { Box::from_raw(std::slice::from_raw_parts_mut(array as *mut MaybeUninit<T>, capacity) as *mut [MaybeUninit<T>]) });
-            Box::from_raw(
-                std::slice::from_raw_parts_mut(array as *mut MaybeUninit<T>, capacity)
-                    as *mut [MaybeUninit<T>],
-            )
-        });
 
 		Self {
 			data: array,
@@ -62,10 +57,7 @@ impl<'n, T> BorrowStack<'n> for FixedSizeStack<'n, T> {
 	}
 
 	unsafe fn get(&'n self) -> &'n [Self::Item] {
-        std::slice::from_raw_parts(
+		std::slice::from_raw_parts(self.data.as_ptr() as *const T, self.len.load(Ordering::SeqCst))
-            self.data.as_ptr() as *const T,
-            self.len.load(Ordering::SeqCst),
-        )
 	}
 }
 

node-graph/gcore/src/generic.rs

@@ -1,11 +1,7 @@
 use core::marker::PhantomData;
 
 use crate::Node;
-pub struct FnNode<'n, T: Fn(<N as Node<'n>>::Output) -> O, N: Node<'n>, O>(
+pub struct FnNode<'n, T: Fn(<N as Node<'n>>::Output) -> O, N: Node<'n>, O>(T, N, PhantomData<&'n O>);
-    T,
-    N,
-    PhantomData<&'n O>,
-);
 impl<'n, T: Fn(<N as Node<'n>>::Output) -> O, N: Node<'n>, O> Node<'n> for FnNode<'n, T, N, O> {
 	type Output = O;
 
@@ -20,16 +16,8 @@ impl<'n, T: Fn(<N as Node<'n>>::Output) -> O, N: Node<'n>, O> FnNode<'n, T, N, O
 	}
 }
 
-pub struct FnNodeWithState<
+pub struct FnNodeWithState<'n, T: Fn(<N as Node<'n>>::Output, &'n State) -> O, N: Node<'n>, O, State: 'n>(T, N, State, PhantomData<&'n O>);
-    'n,
+impl<'n, T: Fn(<N as Node<'n>>::Output, &'n State) -> O, N: Node<'n>, O: 'n, State: 'n> Node<'n> for FnNodeWithState<'n, T, N, O, State> {
-    T: Fn(<N as Node<'n>>::Output, &'n State) -> O,
-    N: Node<'n>,
-    O,
-    State: 'n,
->(T, N, State, PhantomData<&'n O>);
-impl<'n, T: Fn(<N as Node<'n>>::Output, &'n State) -> O, N: Node<'n>, O: 'n, State: 'n> Node<'n>
-    for FnNodeWithState<'n, T, N, O, State>
-{
 	type Output = O;
 
 	fn eval(&'n self) -> Self::Output {
@@ -37,9 +25,7 @@ impl<'n, T: Fn(<N as Node<'n>>::Output, &'n State) -> O, N: Node<'n>, O: 'n, Sta
 	}
 }
 
-impl<'n, T: Fn(<N as Node<'n>>::Output, &'n State) -> O, N: Node<'n>, O: 'n, State: 'n>
+impl<'n, T: Fn(<N as Node<'n>>::Output, &'n State) -> O, N: Node<'n>, O: 'n, State: 'n> FnNodeWithState<'n, T, N, O, State> {
-    FnNodeWithState<'n, T, N, O, State>
-{
 	pub fn new(f: T, input: N, state: State) -> Self {
 		FnNodeWithState(f, input, state, PhantomData)
 	}

node-graph/gcore/src/ops.rs

@@ -3,22 +3,14 @@ use core::{marker::PhantomData, ops::Add};
 use crate::{Node, NodeInput};
 
 #[repr(C)]
-pub struct AddNode<'n, L: Add<R>, R, I1: Node<'n, Output = L>, I2: Node<'n, Output = R>>(
+pub struct AddNode<'n, L: Add<R>, R, I1: Node<'n, Output = L>, I2: Node<'n, Output = R>>(pub I1, pub I2, PhantomData<&'n (L, R)>);
-    pub I1,
+impl<'n, L: Add<R>, R, I1: Node<'n, Output = L>, I2: Node<'n, Output = R>> Node<'n> for AddNode<'n, L, R, I1, I2> {
-    pub I2,
-    PhantomData<&'n (L, R)>,
-);
-impl<'n, L: Add<R>, R, I1: Node<'n, Output = L>, I2: Node<'n, Output = R>> Node<'n>
-    for AddNode<'n, L, R, I1, I2>
-{
 	type Output = <L as Add<R>>::Output;
 	fn eval(&'n self) -> Self::Output {
 		self.0.eval() + self.1.eval()
 	}
 }
-impl<'n, L: Add<R>, R, I1: Node<'n, Output = L>, I2: Node<'n, Output = R>>
+impl<'n, L: Add<R>, R, I1: Node<'n, Output = L>, I2: Node<'n, Output = R>> AddNode<'n, L, R, I1, I2> {
-    AddNode<'n, L, R, I1, I2>
-{
 	pub fn new(input: (I1, I2)) -> AddNode<'n, L, R, I1, I2> {
 		AddNode(input.0, input.1, PhantomData)
 	}
@@ -127,8 +119,7 @@ pub mod gpu {
 	//use crate::Node;
 	use spirv_std::glam::UVec3;
 	const ADD: AddNode<u32> = AddNode(PhantomData);
-    const OPERATION: ComposeNodeOwned<'_, (u32, u32), u32, FstNode<u32, u32>, DupNode<u32>> =
+	const OPERATION: ComposeNodeOwned<'_, (u32, u32), u32, FstNode<u32, u32>, DupNode<u32>> = ComposeNodeOwned::new(FstNode(PhantomData, PhantomData), DupNode(PhantomData));
-        ComposeNodeOwned::new(FstNode(PhantomData, PhantomData), DupNode(PhantomData));
 
 	#[allow(unused)]
 	#[spirv(compute(threads(64)))]

node-graph/gstd/src/lib.rs

@@ -2,7 +2,7 @@ pub mod value;
 pub use graphene_core::{generic, ops /*, structural*/};
 
 #[cfg(feature = "caching")]
-pub mod caching;
+pub mod cache;
 #[cfg(feature = "memoization")]
 pub mod memo;
 

node-graph/gstd/src/main.rs

@@ -29,10 +29,7 @@ mod mul {
 		type Output = MulNodeInput<'n>;
 		fn eval(&'n self) -> <Self as graphene_std::Node<'n>>::Output {
 			let a = self.a.unwrap().eval();
-            let a: &f32 = self
+			let a: &f32 = self.a.map(|v| downcast_ref(v.eval()).unwrap()).unwrap_or(&1.);
-                .a
-                .map(|v| downcast_ref(v.eval()).unwrap())
-                .unwrap_or(&1.);
 			/*let b: &f32 = self
 				.b
 				.map(|v| v.eval(&()).downcast_ref::<&'n f32, &'n f32>().unwrap())

node-graph/proc-macro/src/lib.rs

@@ -47,14 +47,8 @@ fn generate_to_string(parsed: ItemFn, string: String) -> TokenStream {
 	let fn_name = sig.ident; // function name/identifier
 	let idents = extract_arg_idents(fn_args.clone());
 	let types = extract_arg_types(fn_args);
-    let types = types
+	let types = types.iter().map(|t| t.to_token_stream()).collect::<Vec<_>>();
-        .iter()
+	let idents = idents.iter().map(|t| t.to_token_stream()).collect::<Vec<_>>();
-        .map(|t| t.to_token_stream())
-        .collect::<Vec<_>>();
-    let idents = idents
-        .iter()
-        .map(|t| t.to_token_stream())
-        .collect::<Vec<_>>();
 	let const_idents = idents
 		.iter()
 		.map(|t| {
@@ -65,15 +59,8 @@ fn generate_to_string(parsed: ItemFn, string: String) -> TokenStream {
 
 	let node_fn_name = fn_name.append("_node");
 	let struct_name = fn_name.append("_input");
-    let return_type_string = fn_return_type
+	let return_type_string = fn_return_type.to_token_stream().to_string().replace("->", "");
-        .to_token_stream()
+	let arg_type_string = types.iter().map(|t| t.to_string()).collect::<Vec<_>>().join(", ");
-        .to_string()
-        .replace("->", "");
-    let arg_type_string = types
-        .iter()
-        .map(|t| t.to_string())
-        .collect::<Vec<_>>()
-        .join(", ");
 	let error = format!("called {} with the wrong type", fn_name);
 
 	let x = quote! {