Restructure node crates (#3384)

* Restructure node-graph folder

* Fix wasm compilation

* Move node definitions out of *-types crates

* Cleanup

* Fix warnings

* Fix warnings

* Start adding migrations

* Add migrations and move memo nodes to gcore

* Move nodes/gsvg-render -> rendering

* Replace some hard coded identifiers and fix automatic conversion

* Fix Vec2Value node migration

* Fix formatting

* Add more migrations

* Cleanup features

* Fix core_types::raster import

* Update demo artwork (to make profile ci work)

* Move *-types to node-graph/libraries folder

* Add missing node migrations

* Migrate more nodes

* Remove impure memo node

* More fixes and remove warning

* Migrate context and add a few missing migrations

---------

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

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

@@ -0,0 +1,81 @@
+use core_types::Node;
+use core_types::color::{Channel, Linear, LuminanceMut};
+use dyn_any::{DynAny, StaticType, StaticTypeSized};
+use std::hash::{Hash, Hasher};
+use std::ops::{Add, Mul, Sub};
+
+#[derive(Debug, Clone, PartialEq, DynAny, specta::Type, serde::Serialize, serde::Deserialize)]
+pub struct Curve {
+	#[serde(rename = "manipulatorGroups")]
+	pub manipulator_groups: Vec<CurveManipulatorGroup>,
+	#[serde(rename = "firstHandle")]
+	pub first_handle: [f32; 2],
+	#[serde(rename = "lastHandle")]
+	pub last_handle: [f32; 2],
+}
+
+impl Default for Curve {
+	fn default() -> Self {
+		Self {
+			manipulator_groups: vec![],
+			first_handle: [0.2; 2],
+			last_handle: [0.8; 2],
+		}
+	}
+}
+
+impl Hash for Curve {
+	fn hash<H: Hasher>(&self, state: &mut H) {
+		self.manipulator_groups.hash(state);
+		[self.first_handle, self.last_handle].iter().flatten().for_each(|f| f.to_bits().hash(state));
+	}
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, DynAny, specta::Type, serde::Serialize, serde::Deserialize)]
+pub struct CurveManipulatorGroup {
+	pub anchor: [f32; 2],
+	pub handles: [[f32; 2]; 2],
+}
+
+impl Hash for CurveManipulatorGroup {
+	fn hash<H: Hasher>(&self, state: &mut H) {
+		for c in self.handles.iter().chain([&self.anchor]).flatten() {
+			c.to_bits().hash(state);
+		}
+	}
+}
+
+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 }
+	}
+}
+
+impl<'i, L: LuminanceMut + 'i> Node<'i, L> for ValueMapperNode<L::LuminanceChannel>
+where
+	L::LuminanceChannel: Linear + Copy,
+	L::LuminanceChannel: Add<Output = L::LuminanceChannel>,
+	L::LuminanceChannel: Sub<Output = L::LuminanceChannel>,
+	L::LuminanceChannel: Mul<Output = L::LuminanceChannel>,
+{
+	type Output = L;
+
+	fn eval(&'i self, mut val: L) -> L {
+		let luminance: f32 = val.luminance().to_linear();
+		let floating_sample_index = luminance * (self.lut.len() - 1) as f32;
+		let index_in_lut = floating_sample_index.floor() as usize;
+		let a = self.lut[index_in_lut];
+		let b = self.lut[(index_in_lut + 1).clamp(0, self.lut.len() - 1)];
+		let result = a.lerp(b, L::LuminanceChannel::from_linear(floating_sample_index.fract()));
+		val.set_luminance(result);
+		val
+	}
+}