Refactor the node macro and simply most of the node implementations (#1942)

* Add support structure for new node macro to gcore

* Fix compile issues and code generation

* Implement new node_fn macro

* Implement property translation

* Fix NodeIO type generation

* Start translating math nodes

* Move node implementation to outer scope to allow usage of local imports

* Add expose attribute to allow controlling the parameter exposure

* Add rust analyzer support for #[implementations] attribute

* Migrate logic nodes

* Handle where clause properly

* Implement argument ident pattern preservation

* Implement adjustment layer mapping

* Fix node registry types

* Fix module paths

* Improve demo artwork comptibility

* Improve macro error reporting

* Fix handling of impl node implementations

* Fix nodeio type computation

* Fix opacity node and graph type resolution

* Fix loading of demo artworks

* Fix eslint

* Fix typo in macro test

* Remove node definitions for Adjustment Nodes

* Fix type alias property generation and make adjustments footprint aware

* Convert vector nodes

* Implement path overrides

* Fix stroke node

* Fix painted dreams

* Implement experimental type level specialization

* Fix poisson disk sampling -> all demo artworks should work again

* Port text node + make node macro more robust by implementing lifetime substitution

* Fix vector node tests

* Fix red dress demo + ci

* Fix clippy warnings

* Code review

* Fix primary input issues

* Improve math nodes and audit others

* Set no_properties when no automatic properties are derived

* Port vector generator nodes (could not derive all definitions yet)

* Various QA changes and add min/max/mode_range to number parameters

* Add min and max for f64 and u32

* Convert gpu nodes and clean up unused nodes

* Partially port transform node

* Allow implementations on call arg

* Port path modify node

* Start porting graphic element nodes

* Transform nodes in graphic_element.rs

* Port brush node

* Port nodes in wasm_executior

* Rename node macro

* Fix formatting

* Fix Mandelbrot node

* Formatting

* Fix Load Image and Load Resource nodes, add scope input to node macro

* Remove unnecessary underscores

* Begin attemping to make nodes resolution-aware

* Infer a generic manual compositon type on generic call arg

* Various fixes and work towards merging

* Final changes for merge!

* Fix tests, probably

* More free line removals!

---------

Co-authored-by: Keavon Chambers <keavon@keavon.com>

node-graph/gcore/src/raster/bbox.rs

@@ -1,4 +1,4 @@
-use dyn_any::{DynAny, StaticType};
+use dyn_any::DynAny;
 use glam::{DAffine2, DVec2};
 
 #[cfg_attr(not(target_arch = "spirv"), derive(Debug))]

node-graph/gcore/src/raster/brightness_contrast.rs

@@ -26,8 +26,8 @@ pub struct GenerateBrightnessContrastLegacyMapperNode<Brightness, Contrast> {
 	contrast: Contrast,
 }
 
-#[node_macro::node_fn(GenerateBrightnessContrastLegacyMapperNode)]
-fn brightness_contrast_legacy_node(_primary: (), brightness: f64, contrast: f64) -> BrightnessContrastLegacyMapperNode {
+#[node_macro::old_node_fn(GenerateBrightnessContrastLegacyMapperNode)]
+fn brightness_contrast_legacy(_primary: (), brightness: f64, contrast: f64) -> BrightnessContrastLegacyMapperNode {
 	let brightness = brightness as f32 / 255.;
 
 	let contrast = contrast as f32 / 100.;
@@ -67,8 +67,8 @@ pub struct GenerateBrightnessContrastMapperNode<Brightness, Contrast> {
 
 // TODO: Replace this node implementation with one that reuses the more generalized Curves adjustment node.
 // TODO: It will be necessary to ensure the tests below are faithfully translated in a way that ensures identical results.
-#[node_macro::node_fn(GenerateBrightnessContrastMapperNode)]
-fn brightness_contrast_node(_primary: (), brightness: f64, contrast: f64) -> BrightnessContrastMapperNode {
+#[node_macro::old_node_fn(GenerateBrightnessContrastMapperNode)]
+fn brightness_contrast(_primary: (), brightness: f64, contrast: f64) -> BrightnessContrastMapperNode {
 	// Brightness LUT
 	let brightness_is_negative = brightness < 0.;
 	let brightness = brightness.abs() as f32 / 100.;

node-graph/gcore/src/raster/brush_cache.rs

@@ -3,7 +3,7 @@ use std::collections::HashMap;
 use std::sync::Arc;
 use std::sync::Mutex;
 
-use dyn_any::{DynAny, StaticType};
+use dyn_any::DynAny;
 
 use crate::raster::Image;
 use crate::raster::ImageFrame;
@@ -100,12 +100,18 @@ pub struct BrushPlan {
 }
 
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-#[derive(Debug, DynAny, Default)]
+#[derive(Debug, DynAny)]
 pub struct BrushCache {
 	inner: Arc<Mutex<BrushCacheImpl>>,
 	proto: bool,
 }
 
+impl Default for BrushCache {
+	fn default() -> Self {
+		Self::new_proto()
+	}
+}
+
 // A bit of a cursed implementation to work around the current node system.
 // The original object is a 'prototype' that when cloned gives you a independent
 // new object. Any further clones however are all the same underlying cache object.

node-graph/gcore/src/raster/color.rs

@@ -1,7 +1,7 @@
 use super::discrete_srgb::{float_to_srgb_u8, srgb_u8_to_float};
 use super::{Alpha, AssociatedAlpha, Luminance, LuminanceMut, Pixel, RGBMut, Rec709Primaries, RGB, SRGB};
 
-use dyn_any::{DynAny, StaticType};
+use dyn_any::DynAny;
 #[cfg(feature = "serde")]
 #[cfg(target_arch = "spirv")]
 use spirv_std::num_traits::float::Float;

node-graph/gcore/src/raster/curve.rs

@@ -1,7 +1,7 @@
 use super::{Channel, Linear, LuminanceMut};
 use crate::Node;
 
-use dyn_any::{DynAny, StaticType};
+use dyn_any::{DynAny, StaticType, StaticTypeSized};
 
 use core::ops::{Add, Mul, Sub};
 
@@ -176,6 +176,10 @@ pub struct ValueMapperNode<C> {
 	lut: Vec<C>,
 }
 
+unsafe impl<C: StaticTypeSized> StaticType for ValueMapperNode<C> {
+	type Static = ValueMapperNode<C::Static>;
+}
+
 impl<C> ValueMapperNode<C> {
 	pub const fn new(lut: Vec<C>) -> Self {
 		Self { lut }

node-graph/gcore/src/raster/image.rs

@@ -1,6 +1,6 @@
 use super::discrete_srgb::float_to_srgb_u8;
-use super::{Color, ImageSlice};
-use crate::{AlphaBlending, Node};
+use super::Color;
+use crate::AlphaBlending;
 use alloc::vec::Vec;
 use core::hash::{Hash, Hasher};
 use dyn_any::StaticType;
@@ -65,7 +65,7 @@ impl<P: Pixel + Debug> Debug for Image<P> {
 	}
 }
 
-unsafe impl<P: StaticTypeSized + Pixel> StaticType for Image<P>
+unsafe impl<P: dyn_any::StaticTypeSized + Pixel> StaticType for Image<P>
 where
 	P::Static: Pixel,
 {
@@ -126,14 +126,6 @@ impl<P: Pixel> Image<P> {
 			base64_string: None,
 		}
 	}
-
-	pub fn as_slice(&self) -> ImageSlice<P> {
-		ImageSlice {
-			width: self.width,
-			height: self.height,
-			data: self.data.as_slice(),
-		}
-	}
 }
 
 impl Image<Color> {
@@ -224,42 +216,6 @@ impl<P: Pixel> IntoIterator for Image<P> {
 	}
 }
 
-#[derive(Debug, Clone, Copy, Default)]
-pub struct ImageRefNode<P> {
-	_p: PhantomData<P>,
-}
-
-#[node_macro::node_fn(ImageRefNode<_P>)]
-fn image_ref_node<_P: Pixel>(image: &'input Image<_P>) -> ImageSlice<'input, _P> {
-	image.as_slice()
-}
-
-#[derive(Debug, Clone)]
-pub struct CollectNode {}
-
-#[node_macro::node_fn(CollectNode)]
-fn collect_node<_Iter>(input: _Iter) -> Vec<_Iter::Item>
-where
-	_Iter: Iterator,
-{
-	input.collect()
-}
-
-#[derive(Debug)]
-pub struct MapImageSliceNode<Data> {
-	data: Data,
-}
-
-#[node_macro::node_fn(MapImageSliceNode)]
-fn map_node<P: Pixel>(input: (u32, u32), data: Vec<P>) -> Image<P> {
-	Image {
-		width: input.0,
-		height: input.1,
-		data,
-		base64_string: None,
-	}
-}
-
 #[derive(Clone, Debug, PartialEq, Default, specta::Type)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct ImageFrame<P: Pixel> {
@@ -314,7 +270,7 @@ impl<P: Copy + Pixel> BitmapMut for ImageFrame<P> {
 	}
 }
 
-unsafe impl<P: StaticTypeSized + Pixel> StaticType for ImageFrame<P>
+unsafe impl<P: dyn_any::StaticTypeSized + Pixel> StaticType for ImageFrame<P>
 where
 	P::Static: Pixel,
 {