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/Cargo.toml

@@ -0,0 +1,66 @@
+[package]
+name = "raster-nodes"
+version = "0.1.0"
+edition = "2024"
+description = "Raster operation nodes for Graphene"
+authors = ["Graphite Authors <contact@graphite.rs>"]
+license = "MIT OR Apache-2.0"
+
+[lints]
+workspace = true
+
+[features]
+default = ["std"]
+shader-nodes = [
+	"std",
+	"dep:raster-nodes-shaders",
+	"dep:wgpu-executor",
+]
+std = [
+	"dep:core-types",
+	"dep:dyn-any",
+	"dep:raster-types",
+	"dep:vector-types",
+	"dep:image",
+	"dep:ndarray",
+	"dep:rand",
+	"dep:rand_chacha",
+	"dep:fastnoise-lite",
+	"dep:serde",
+	"dep:specta",
+	"dep:kurbo",
+]
+
+[dependencies]
+# Local dependencies
+no-std-types = { workspace = true }
+node-macro = { workspace = true }
+
+# Local std dependencies
+dyn-any = { workspace = true, optional = true }
+core-types = { workspace = true, optional = true }
+raster-types = { workspace = true, optional = true }
+vector-types = { workspace = true, optional = true }
+wgpu-executor = { workspace = true, optional = true }
+raster-nodes-shaders = { path = "./shaders", optional = true }
+
+# Workspace dependencies
+bytemuck = { workspace = true }
+glam = { workspace = true }
+spirv-std = { workspace = true }
+num-traits = { workspace = true }
+num_enum = { workspace = true }
+
+# Workspace std dependencies
+specta = { workspace = true, optional = true }
+image = { workspace = true, optional = true }
+ndarray = { workspace = true, optional = true }
+rand = { workspace = true, optional = true }
+rand_chacha = { workspace = true, optional = true }
+fastnoise-lite = { workspace = true, optional = true }
+serde = { workspace = true, optional = true }
+kurbo = { workspace = true, optional = true }
+
+[dev-dependencies]
+tokio = { workspace = true }
+futures = { workspace = true }

node-graph/nodes/raster/shaders/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "raster-nodes-shaders"
+version = "0.1.0"
+edition = "2024"
+description = "graphene raster data format"
+authors = ["Graphite Authors <contact@graphite.rs>"]
+license = "MIT OR Apache-2.0"
+
+[lib]
+crate-type = ["rlib", "dylib"]
+
+[dependencies]
+
+[build-dependencies]
+cargo-gpu = { workspace = true }
+env_logger = { workspace = true }
+log = { workspace = true }

node-graph/nodes/raster/shaders/build.rs

@@ -0,0 +1,54 @@
+use cargo_gpu::InstalledBackend;
+use cargo_gpu::spirv_builder::{MetadataPrintout, SpirvMetadata};
+use std::path::PathBuf;
+
+pub fn main() -> Result<(), Box<dyn std::error::Error>> {
+	env_logger::builder().filter_level(log::LevelFilter::Debug).init();
+
+	// Skip building the shader if they are provided externally
+	println!("cargo:rerun-if-env-changed=GRAPHENE_RASTER_NODES_SHADER_PATH");
+	if !std::env::var("GRAPHENE_RASTER_NODES_SHADER_PATH").unwrap_or_default().is_empty() {
+		return Ok(());
+	}
+
+	// Allows overriding the PATH to inject the rust-gpu rust toolchain when building the rest of the project with stable rustc.
+	// Used in nix shell. Do not remove without checking with developers using nix.
+	println!("cargo:rerun-if-env-changed=RUST_GPU_PATH_OVERRIDE");
+	if let Ok(path_override) = std::env::var("RUST_GPU_PATH_OVERRIDE") {
+		let current_path = std::env::var("PATH").unwrap_or_default();
+		let new_path = format!("{path_override}:{current_path}");
+		// SAFETY: Build script is single-threaded therefore this cannot lead to undefined behavior.
+		unsafe {
+			std::env::set_var("PATH", &new_path);
+		}
+	}
+
+	let shader_crate = PathBuf::from(concat!(env!("CARGO_MANIFEST_DIR"), "/entrypoint"));
+
+	println!("cargo:rerun-if-env-changed=RUSTC_CODEGEN_SPIRV_PATH");
+	let rustc_codegen_spirv_path = std::env::var("RUSTC_CODEGEN_SPIRV_PATH").unwrap_or_default();
+	let backend = if rustc_codegen_spirv_path.is_empty() {
+		// install the toolchain and build the `rustc_codegen_spirv` codegen backend with it
+		cargo_gpu::Install::from_shader_crate(shader_crate.clone()).run()?
+	} else {
+		// use the `RUSTC_CODEGEN_SPIRV` environment variable to find the codegen backend
+		let mut backend = InstalledBackend::default();
+		backend.rustc_codegen_spirv_location = PathBuf::from(rustc_codegen_spirv_path);
+		backend.toolchain_channel = "nightly".to_string();
+		backend.target_spec_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+		backend
+	};
+
+	// build the shader crate
+	let mut builder = backend.to_spirv_builder(shader_crate, "spirv-unknown-naga-wgsl");
+	builder.print_metadata = MetadataPrintout::DependencyOnly;
+	builder.spirv_metadata = SpirvMetadata::Full;
+	let wgsl_result = builder.build()?;
+	let path_to_spv = wgsl_result.module.unwrap_single();
+
+	// needs to be fixed upstream
+	let path_to_wgsl = path_to_spv.with_extension("wgsl");
+
+	println!("cargo::rustc-env=GRAPHENE_RASTER_NODES_SHADER_PATH={}", path_to_wgsl.display());
+	Ok(())
+}

node-graph/nodes/raster/shaders/entrypoint/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "raster-nodes-shaders-entrypoint"
+version = "0.1.0"
+edition = "2024"
+description = "graphene raster nodes shaders entrypoint"
+authors = ["Graphite Authors <contact@graphite.rs>"]
+license = "MIT OR Apache-2.0"
+
+[lib]
+crate-type = ["rlib", "dylib"]
+
+[dependencies]
+raster-nodes = { path = "../..", default-features = false }

node-graph/nodes/raster/shaders/entrypoint/src/lib.rs

@@ -0,0 +1,2 @@
+#![no_std]
+pub use raster_nodes::*;

node-graph/nodes/raster/shaders/spirv-unknown-naga-wgsl.json

@@ -0,0 +1,26 @@
+{
+	"allows-weak-linkage": false,
+	"arch": "spirv",
+	"crt-objects-fallback": "false",
+	"crt-static-allows-dylibs": true,
+	"crt-static-respected": true,
+	"data-layout": "e-m:e-p:32:32:32-i64:64-n8:16:32:64",
+	"dll-prefix": "",
+	"dll-suffix": ".spv.json",
+	"dynamic-linking": true,
+	"emit-debug-gdb-scripts": false,
+	"env": "naga-wgsl",
+	"linker-flavor": "unix",
+	"linker-is-gnu": false,
+	"llvm-target": "spirv-unknown-naga-wgsl",
+	"main-needs-argc-argv": false,
+	"metadata": {
+		"description": null,
+		"host_tools": null,
+		"std": null,
+		"tier": null
+	},
+	"panic-strategy": "abort",
+	"simd-types-indirect": false,
+	"target-pointer-width": "32"
+}

node-graph/nodes/raster/shaders/src/lib.rs

@@ -0,0 +1 @@
+pub const WGSL_SHADER: &str = include_str!(env!("GRAPHENE_RASTER_NODES_SHADER_PATH"));

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

@@ -0,0 +1,49 @@
+use no_std_types::color::Color;
+
+pub trait Adjust<P> {
+	fn adjust(&mut self, map_fn: impl Fn(&P) -> P);
+}
+impl Adjust<Color> for Color {
+	fn adjust(&mut self, map_fn: impl Fn(&Color) -> Color) {
+		*self = map_fn(self);
+	}
+}
+
+#[cfg(feature = "std")]
+mod adjust_std {
+	use super::*;
+	use core_types::table::Table;
+	use raster_types::{CPU, Raster};
+	use vector_types::GradientStops;
+
+	impl Adjust<Color> for Table<Raster<CPU>> {
+		fn adjust(&mut self, map_fn: impl Fn(&Color) -> Color) {
+			for row in self.iter_mut() {
+				for color in row.element.data_mut().data.iter_mut() {
+					*color = map_fn(color);
+				}
+			}
+		}
+	}
+	impl Adjust<Color> for Table<Color> {
+		fn adjust(&mut self, map_fn: impl Fn(&Color) -> Color) {
+			for row in self.iter_mut() {
+				*row.element = map_fn(row.element);
+			}
+		}
+	}
+	impl Adjust<Color> for Table<GradientStops> {
+		fn adjust(&mut self, map_fn: impl Fn(&Color) -> Color) {
+			for row in self.iter_mut() {
+				row.element.adjust(&map_fn);
+			}
+		}
+	}
+	impl Adjust<Color> for GradientStops {
+		fn adjust(&mut self, map_fn: impl Fn(&Color) -> Color) {
+			for (_, color) in self.iter_mut() {
+				*color = map_fn(color);
+			}
+		}
+	}
+}

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

@@ -0,0 +1,215 @@
+use crate::adjust::Adjust;
+#[cfg(feature = "std")]
+use core_types::table::Table;
+use no_std_types::Ctx;
+use no_std_types::blending::BlendMode;
+use no_std_types::color::{Color, Pixel};
+use no_std_types::registry::types::PercentageF32;
+#[cfg(feature = "std")]
+use raster_types::{CPU, Raster};
+#[cfg(feature = "std")]
+use vector_types::GradientStops;
+
+pub trait Blend<P: Pixel> {
+	fn blend(&self, under: &Self, blend_fn: impl Fn(P, P) -> P) -> Self;
+}
+impl Blend<Color> for Color {
+	fn blend(&self, under: &Self, blend_fn: impl Fn(Color, Color) -> Color) -> Self {
+		blend_fn(*self, *under)
+	}
+}
+
+#[cfg(feature = "std")]
+mod blend_std {
+	use super::*;
+	use core::cmp::Ordering;
+	use core_types::table::Table;
+	use raster_types::Image;
+	use raster_types::Raster;
+
+	impl Blend<Color> for Table<Raster<CPU>> {
+		fn blend(&self, under: &Self, blend_fn: impl Fn(Color, Color) -> Color) -> Self {
+			let mut result_table = self.clone();
+			for (over, under) in result_table.iter_mut().zip(under.iter()) {
+				let data = over.element.data.iter().zip(under.element.data.iter()).map(|(a, b)| blend_fn(*a, *b)).collect();
+
+				*over.element = Raster::new_cpu(Image {
+					data,
+					width: over.element.width,
+					height: over.element.height,
+					base64_string: None,
+				});
+			}
+			result_table
+		}
+	}
+	impl Blend<Color> for Table<Color> {
+		fn blend(&self, under: &Self, blend_fn: impl Fn(Color, Color) -> Color) -> Self {
+			let mut result_table = self.clone();
+			for (over, under) in result_table.iter_mut().zip(under.iter()) {
+				*over.element = blend_fn(*over.element, *under.element);
+			}
+			result_table
+		}
+	}
+	impl Blend<Color> for Table<GradientStops> {
+		fn blend(&self, under: &Self, blend_fn: impl Fn(Color, Color) -> Color) -> Self {
+			let mut result_table = self.clone();
+			for (over, under) in result_table.iter_mut().zip(under.iter()) {
+				*over.element = over.element.blend(under.element, &blend_fn);
+			}
+			result_table
+		}
+	}
+	impl Blend<Color> for GradientStops {
+		fn blend(&self, under: &Self, blend_fn: impl Fn(Color, Color) -> Color) -> Self {
+			let mut combined_stops = self.iter().map(|(position, _)| position).chain(under.iter().map(|(position, _)| position)).collect::<Vec<_>>();
+			combined_stops.dedup_by(|&mut a, &mut b| (a - b).abs() < 1e-6);
+			combined_stops.sort_by(|a, b| a.partial_cmp(b).unwrap_or(Ordering::Equal));
+			let stops = combined_stops
+				.into_iter()
+				.map(|&position| {
+					let over_color = self.evaluate(position);
+					let under_color = under.evaluate(position);
+					let color = blend_fn(over_color, under_color);
+					(position, color)
+				})
+				.collect::<Vec<_>>();
+			GradientStops::new(stops)
+		}
+	}
+}
+
+#[inline(always)]
+pub fn blend_colors(foreground: Color, background: Color, blend_mode: BlendMode, opacity: f32) -> Color {
+	let target_color = match blend_mode {
+		// Other utility blend modes (hidden from the normal list) - do not have alpha blend
+		BlendMode::Erase => return background.alpha_subtract(foreground),
+		BlendMode::Restore => return background.alpha_add(foreground),
+		BlendMode::MultiplyAlpha => return background.alpha_multiply(foreground),
+		blend_mode => apply_blend_mode(foreground, background, blend_mode),
+	};
+
+	background.alpha_blend(target_color.to_associated_alpha(opacity))
+}
+
+pub fn apply_blend_mode(foreground: Color, background: Color, blend_mode: BlendMode) -> Color {
+	match blend_mode {
+		// Normal group
+		BlendMode::Normal => background.blend_rgb(foreground, Color::blend_normal),
+		// Darken group
+		BlendMode::Darken => background.blend_rgb(foreground, Color::blend_darken),
+		BlendMode::Multiply => background.blend_rgb(foreground, Color::blend_multiply),
+		BlendMode::ColorBurn => background.blend_rgb(foreground, Color::blend_color_burn),
+		BlendMode::LinearBurn => background.blend_rgb(foreground, Color::blend_linear_burn),
+		BlendMode::DarkerColor => background.blend_darker_color(foreground),
+		// Lighten group
+		BlendMode::Lighten => background.blend_rgb(foreground, Color::blend_lighten),
+		BlendMode::Screen => background.blend_rgb(foreground, Color::blend_screen),
+		BlendMode::ColorDodge => background.blend_rgb(foreground, Color::blend_color_dodge),
+		BlendMode::LinearDodge => background.blend_rgb(foreground, Color::blend_linear_dodge),
+		BlendMode::LighterColor => background.blend_lighter_color(foreground),
+		// Contrast group
+		BlendMode::Overlay => foreground.blend_rgb(background, Color::blend_hardlight),
+		BlendMode::SoftLight => background.blend_rgb(foreground, Color::blend_softlight),
+		BlendMode::HardLight => background.blend_rgb(foreground, Color::blend_hardlight),
+		BlendMode::VividLight => background.blend_rgb(foreground, Color::blend_vivid_light),
+		BlendMode::LinearLight => background.blend_rgb(foreground, Color::blend_linear_light),
+		BlendMode::PinLight => background.blend_rgb(foreground, Color::blend_pin_light),
+		BlendMode::HardMix => background.blend_rgb(foreground, Color::blend_hard_mix),
+		// Inversion group
+		BlendMode::Difference => background.blend_rgb(foreground, Color::blend_difference),
+		BlendMode::Exclusion => background.blend_rgb(foreground, Color::blend_exclusion),
+		BlendMode::Subtract => background.blend_rgb(foreground, Color::blend_subtract),
+		BlendMode::Divide => background.blend_rgb(foreground, Color::blend_divide),
+		// Component group
+		BlendMode::Hue => background.blend_hue(foreground),
+		BlendMode::Saturation => background.blend_saturation(foreground),
+		BlendMode::Color => background.blend_color(foreground),
+		BlendMode::Luminosity => background.blend_luminosity(foreground),
+		// Other utility blend modes (hidden from the normal list) - do not have alpha blend
+		_ => panic!("Used blend mode without alpha blend"),
+	}
+}
+
+#[node_macro::node(category("Raster"), cfg(feature = "std"))]
+fn blend<T: Blend<Color> + Send>(
+	_: impl Ctx,
+	#[implementations(
+		Table<Raster<CPU>>,
+		Table<Color>,
+		Table<GradientStops>,
+		GradientStops,
+	)]
+	#[gpu_image]
+	over: T,
+	#[expose]
+	#[implementations(
+		Table<Raster<CPU>>,
+		Table<Color>,
+		Table<GradientStops>,
+		GradientStops,
+	)]
+	#[gpu_image]
+	under: T,
+	blend_mode: BlendMode,
+	#[default(100.)] opacity: PercentageF32,
+) -> T {
+	over.blend(&under, |a, b| blend_colors(a, b, blend_mode, opacity / 100.))
+}
+
+#[node_macro::node(category("Raster: Adjustment"), shader_node(PerPixelAdjust))]
+fn color_overlay<T: Adjust<Color>>(
+	_: impl Ctx,
+	#[implementations(
+		Table<Raster<CPU>>,
+		Table<Color>,
+		Table<GradientStops>,
+		GradientStops,
+	)]
+	#[gpu_image]
+	mut image: T,
+	#[default(Color::BLACK)] color: Color,
+	blend_mode: BlendMode,
+	#[default(100.)] opacity: PercentageF32,
+) -> T {
+	let opacity = (opacity / 100.).clamp(0., 1.);
+
+	image.adjust(|pixel| {
+		let image = pixel.map_rgb(|channel| channel * (1. - opacity));
+
+		// The apply blend mode function divides rgb by the alpha channel for the background. This undoes that.
+		let associated_pixel = Color::from_rgbaf32_unchecked(pixel.r() * pixel.a(), pixel.g() * pixel.a(), pixel.b() * pixel.a(), pixel.a());
+		let overlay = apply_blend_mode(color, associated_pixel, blend_mode).map_rgb(|channel| channel * opacity);
+
+		Color::from_rgbaf32_unchecked(image.r() + overlay.r(), image.g() + overlay.g(), image.b() + overlay.b(), pixel.a())
+	});
+	image
+}
+
+#[cfg(all(feature = "std", test))]
+mod test {
+	use core_types::blending::BlendMode;
+	use core_types::color::Color;
+	use core_types::table::Table;
+	use raster_types::Image;
+	use raster_types::Raster;
+
+	#[tokio::test]
+	async fn color_overlay_multiply() {
+		let image_color = Color::from_rgbaf32_unchecked(0.7, 0.6, 0.5, 0.4);
+		let image = Image::new(1, 1, image_color);
+
+		// Color { red: 0., green: 1., blue: 0., alpha: 1. }
+		let overlay_color = Color::GREEN;
+
+		// 100% of the output should come from the multiplied value
+		let opacity = 100.;
+
+		let result = super::color_overlay((), Table::new_from_element(Raster::new_cpu(image.clone())), overlay_color, BlendMode::Multiply, opacity);
+		let result = result.iter().next().unwrap().element;
+
+		// The output should just be the original green and alpha channels (as we multiply them by 1 and other channels by 0)
+		assert_eq!(result.data[0], Color::from_rgbaf32_unchecked(0., image_color.g(), 0., image_color.a()));
+	}
+}

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

@@ -0,0 +1,123 @@
+#[derive(Debug)]
+pub struct CubicSplines {
+	pub x: [f32; 4],
+	pub y: [f32; 4],
+}
+
+impl CubicSplines {
+	pub fn solve(&self) -> [f32; 4] {
+		let (x, y) = (&self.x, &self.y);
+
+		// Build an augmented matrix to solve the system of equations using Gaussian elimination
+		let mut augmented_matrix = [
+			[
+				2. / (x[1] - x[0]),
+				1. / (x[1] - x[0]),
+				0.,
+				0.,
+				// |
+				3. * (y[1] - y[0]) / ((x[1] - x[0]) * (x[1] - x[0])),
+			],
+			[
+				1. / (x[1] - x[0]),
+				2. * (1. / (x[1] - x[0]) + 1. / (x[2] - x[1])),
+				1. / (x[2] - x[1]),
+				0.,
+				// |
+				3. * ((y[1] - y[0]) / ((x[1] - x[0]) * (x[1] - x[0])) + (y[2] - y[1]) / ((x[2] - x[1]) * (x[2] - x[1]))),
+			],
+			[
+				0.,
+				1. / (x[2] - x[1]),
+				2. * (1. / (x[2] - x[1]) + 1. / (x[3] - x[2])),
+				1. / (x[3] - x[2]),
+				// |
+				3. * ((y[2] - y[1]) / ((x[2] - x[1]) * (x[2] - x[1])) + (y[3] - y[2]) / ((x[3] - x[2]) * (x[3] - x[2]))),
+			],
+			[
+				0.,
+				0.,
+				1. / (x[3] - x[2]),
+				2. / (x[3] - x[2]),
+				// |
+				3. * (y[3] - y[2]) / ((x[3] - x[2]) * (x[3] - x[2])),
+			],
+		];
+
+		// Gaussian elimination: forward elimination
+		for row in 0..4 {
+			let pivot_row_index = (row..4)
+				.max_by(|&a_row, &b_row| {
+					augmented_matrix[a_row][row]
+						.abs()
+						.partial_cmp(&augmented_matrix[b_row][row].abs())
+						.unwrap_or(core::cmp::Ordering::Equal)
+				})
+				.unwrap();
+
+			// Swap the current row with the row that has the largest pivot element
+			augmented_matrix.swap(row, pivot_row_index);
+
+			// Eliminate the current column in all rows below the current one
+			for row_below_current in row + 1..4 {
+				assert!(augmented_matrix[row][row].abs() > f32::EPSILON);
+
+				let scale_factor = augmented_matrix[row_below_current][row] / augmented_matrix[row][row];
+				for col in row..5 {
+					augmented_matrix[row_below_current][col] -= augmented_matrix[row][col] * scale_factor
+				}
+			}
+		}
+
+		// Gaussian elimination: back substitution
+		let mut solutions = [0.; 4];
+		for col in (0..4).rev() {
+			assert!(augmented_matrix[col][col].abs() > f32::EPSILON);
+
+			solutions[col] = augmented_matrix[col][4] / augmented_matrix[col][col];
+
+			for row in (0..col).rev() {
+				augmented_matrix[row][4] -= augmented_matrix[row][col] * solutions[col];
+				augmented_matrix[row][col] = 0.;
+			}
+		}
+
+		solutions
+	}
+
+	pub fn interpolate(&self, input: f32, solutions: &[f32]) -> f32 {
+		if input <= self.x[0] {
+			return self.y[0];
+		}
+		if input >= self.x[self.x.len() - 1] {
+			return self.y[self.x.len() - 1];
+		}
+
+		// Find the segment that the input falls between
+		let mut segment = 1;
+		while self.x[segment] < input {
+			segment += 1;
+		}
+		let segment_start = segment - 1;
+		let segment_end = segment;
+
+		// Calculate the output value using quadratic interpolation
+		let input_value = self.x[segment_start];
+		let input_value_prev = self.x[segment_end];
+		let output_value = self.y[segment_start];
+		let output_value_prev = self.y[segment_end];
+		let solutions_value = solutions[segment_start];
+		let solutions_value_prev = solutions[segment_end];
+
+		let output_delta = solutions_value_prev * (input_value - input_value_prev) - (output_value - output_value_prev);
+		let solution_delta = (output_value - output_value_prev) - solutions_value * (input_value - input_value_prev);
+
+		let input_ratio = (input - input_value_prev) / (input_value - input_value_prev);
+		let prev_output_ratio = (1. - input_ratio) * output_value_prev;
+		let output_ratio = input_ratio * output_value;
+		let quadratic_ratio = input_ratio * (1. - input_ratio) * (output_delta * (1. - input_ratio) + solution_delta * input_ratio);
+
+		let result = prev_output_ratio + output_ratio + quadratic_ratio;
+		result.clamp(0., 1.)
+	}
+}

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
+	}
+}

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

@@ -0,0 +1,265 @@
+use core_types::context::Ctx;
+use core_types::registry::types::Percentage;
+use core_types::table::Table;
+use image::{DynamicImage, GenericImage, GenericImageView, GrayImage, ImageBuffer, Luma, Rgba, RgbaImage};
+use ndarray::{Array2, ArrayBase, Dim, OwnedRepr};
+use raster_types::Image;
+use raster_types::{CPU, Raster};
+use std::cmp::{max, min};
+
+#[node_macro::node(category("Raster: Filter"))]
+async fn dehaze(_: impl Ctx, image_frame: Table<Raster<CPU>>, strength: Percentage) -> Table<Raster<CPU>> {
+	image_frame
+		.into_iter()
+		.map(|mut row| {
+			let image = row.element;
+			// Prepare the image data for processing
+			let image_data = bytemuck::cast_vec(image.data.clone());
+			let image_buffer = image::Rgba32FImage::from_raw(image.width, image.height, image_data).expect("Failed to convert internal image format into image-rs data type.");
+			let dynamic_image: DynamicImage = image_buffer.into();
+
+			// Run the dehaze algorithm
+			let dehazed_dynamic_image = dehaze_image(dynamic_image, strength / 100.);
+
+			// Prepare the image data for returning
+			let buffer = dehazed_dynamic_image.to_rgba32f().into_raw();
+			let color_vec = bytemuck::cast_vec(buffer);
+			let dehazed_image = Image {
+				width: image.width,
+				height: image.height,
+				data: color_vec,
+				base64_string: None,
+			};
+
+			row.element = Raster::new_cpu(dehazed_image);
+			row
+		})
+		.collect()
+}
+
+// There is no real point in modifying these values because they do not change the final result all that much.
+// The authors of the paper recommended using these values to get a reasonable balance of performance and quality.
+const PATCH_SIZE: u32 = 15;
+const TOP_PERCENT: f64 = 0.001;
+const RADIUS: u32 = 60;
+const EPSILON: f64 = 0.0001;
+const TX: f32 = 0.1;
+
+// Dehazing algorithm based on "Single Image Haze Removal Using Dark Channel Prior"
+// Paper: <https://www.researchgate.net/publication/220182411_Single_Image_Haze_Removal_Using_Dark_Channel_Prior>
+// TODO: Make this algorithm work with negative strength values
+fn dehaze_image(image: DynamicImage, strength: f64) -> DynamicImage {
+	// TODO: Break out this pair of steps into its own node, with a memoize node which caches the pair of outputs, so the strength can be adjusted without recomputing these two steps.
+	let dark_channel = compute_dark_channel(&image);
+	let atmospheric_light = estimate_atmospheric_light(&image, &dark_channel);
+
+	let transmission_map = estimate_transmission_map(&image, &dark_channel, strength);
+	let refined_transmission_map = refine_transmission_map(&image, &transmission_map);
+
+	recover(&image, &refined_transmission_map, atmospheric_light)
+}
+
+fn compute_dark_channel(image: &DynamicImage) -> DynamicImage {
+	let (width, height) = image.dimensions();
+	let mut dark_channel = GrayImage::new(width, height);
+	let half_patch = PATCH_SIZE / 2;
+
+	for y in 0..height {
+		for x in 0..width {
+			let pixel = image.get_pixel(x, y);
+			let min_intensity = min(min(pixel[0], pixel[1]), pixel[2]);
+			dark_channel.put_pixel(x, y, Luma([min_intensity]));
+		}
+	}
+
+	let mut eroded_channel = RgbaImage::new(width, height);
+
+	for y in 0..height {
+		for x in 0..width {
+			let mut local_min = u8::MAX;
+
+			for dy in 0..PATCH_SIZE {
+				for dx in 0..PATCH_SIZE {
+					let nx = x as i32 + dx as i32 - half_patch as i32;
+					let ny = y as i32 + dy as i32 - half_patch as i32;
+
+					if nx >= 0 && nx < width as i32 && ny >= 0 && ny < height as i32 {
+						let intensity = dark_channel.get_pixel(nx as u32, ny as u32)[0];
+						if intensity < local_min {
+							local_min = intensity;
+						}
+					}
+				}
+			}
+			let alpha = image.get_pixel(x, y)[3];
+			eroded_channel.put_pixel(x, y, Rgba([local_min, local_min, local_min, alpha]));
+		}
+	}
+
+	DynamicImage::ImageRgba8(eroded_channel)
+}
+
+fn estimate_atmospheric_light(hazy: &DynamicImage, dark_channel: &DynamicImage) -> Rgba<u8> {
+	let (width, height) = hazy.dimensions();
+	let dark = dark_channel.to_luma_alpha8();
+	let total_pixels = (width * height) as usize;
+	let num_pixels = ((TOP_PERCENT / 100.) * total_pixels as f64).ceil() as usize;
+
+	let mut intensities: Vec<(u32, u32, f64)> = Vec::with_capacity(total_pixels);
+
+	for y in 0..height {
+		for x in 0..width {
+			let pixel = dark.get_pixel(x, y);
+			let intensity = pixel.0[0] as f64;
+			intensities.push((x, y, intensity))
+		}
+	}
+
+	intensities.sort_by(|a, b| b.2.partial_cmp(&a.2).unwrap());
+
+	let top_intensities = &intensities[..num_pixels];
+
+	let mut atm_sum = [0., 0., 0.];
+	for (x, y, _) in top_intensities {
+		let pixel = hazy.get_pixel(*x, *y);
+		atm_sum[0] += pixel[0] as f64;
+		atm_sum[1] += pixel[1] as f64;
+		atm_sum[2] += pixel[2] as f64;
+	}
+
+	let num_pixels = num_pixels as f64;
+
+	Rgba([(atm_sum[0] / num_pixels) as u8, (atm_sum[1] / num_pixels) as u8, (atm_sum[2] / num_pixels) as u8, 255])
+}
+
+fn estimate_transmission_map(image: &DynamicImage, dark_channel: &DynamicImage, omega: f64) -> DynamicImage {
+	let (width, height) = image.dimensions();
+	let mut transmission_map = RgbaImage::new(width, height);
+
+	for y in 0..height {
+		for x in 0..width {
+			let min_intensity = dark_channel.get_pixel(x, y).0[0] as f32 / 255.;
+			let transmission_value = 1. - omega * min_intensity as f64;
+			let alpha = image.get_pixel(x, y)[3];
+			transmission_map.put_pixel(
+				x,
+				y,
+				Rgba([(transmission_value * 255.) as u8, (transmission_value * 255.) as u8, (transmission_value * 255.) as u8, alpha]),
+			);
+		}
+	}
+
+	DynamicImage::ImageRgba8(transmission_map)
+}
+
+fn refine_transmission_map(img: &DynamicImage, transmission_map: &DynamicImage) -> DynamicImage {
+	let gray_image = img.to_luma8();
+
+	let normalized_gray_image: GrayImage = ImageBuffer::from_fn(gray_image.width(), gray_image.height(), |x, y| {
+		let pixel = gray_image.get_pixel(x, y);
+		let normalized_value = (pixel[0] as f64 / 255.) * 255.;
+		Luma([normalized_value as u8])
+	});
+
+	let normalized_gray_image = DynamicImage::ImageLuma8(normalized_gray_image);
+
+	guided_filter(&normalized_gray_image, transmission_map, RADIUS, EPSILON)
+}
+
+fn recover(im: &DynamicImage, t: &DynamicImage, a: Rgba<u8>) -> DynamicImage {
+	let (width, height) = im.dimensions();
+	let mut res = DynamicImage::new_rgba8(width, height);
+
+	let a = [a[0] as f32 / 255., a[1] as f32 / 255., a[2] as f32 / 255.];
+
+	for y in 0..height {
+		for x in 0..width {
+			let im_pixel = im.get_pixel(x, y).0;
+			let t_pixel = t.get_pixel(x, y).0;
+			let t_val = f32::max(t_pixel[0] as f32 / 255., TX);
+
+			let mut res_pixel = [0; 4];
+			for ind in 0..3 {
+				res_pixel[ind] = ((((im_pixel[ind] as f32 / 255. - a[ind]) / t_val) + a[ind]).clamp(0., 1.) * 255.) as u8;
+			}
+			res_pixel[3] = im_pixel[3];
+
+			res.put_pixel(x, y, Rgba(res_pixel));
+		}
+	}
+
+	res
+}
+
+fn guided_filter(guidance_img: &DynamicImage, input_img: &DynamicImage, r: u32, epsilon: f64) -> DynamicImage {
+	let (width, height) = guidance_img.dimensions();
+	let radius = r as i32;
+
+	let guidance_nd = image_to_ndarray(guidance_img);
+	let input_nd = image_to_ndarray(input_img);
+
+	let mean_guidance = box_filter(&guidance_nd, radius);
+	let mean_input = box_filter(&input_nd, radius);
+	let corr_guidance = box_filter(&(guidance_nd.clone() * guidance_nd.clone()), radius);
+	let corr_guidance_input = box_filter(&(guidance_nd.clone() * input_nd.clone()), radius);
+
+	let var_guidance = &corr_guidance - &(mean_guidance.clone() * mean_guidance.clone());
+	let cov_guidance_input = &corr_guidance_input - &(mean_guidance.clone() * mean_input.clone());
+
+	let a = &cov_guidance_input / &(var_guidance.clone() + epsilon);
+	let b = mean_input - &(a.clone() * mean_guidance);
+
+	let mean_a = box_filter(&a, radius);
+	let mean_b = box_filter(&b, radius);
+
+	let q = &mean_a * &guidance_nd + mean_b;
+
+	ndarray_to_image(&q, width, height)
+}
+
+fn box_filter(img: &Array2<f64>, radius: i32) -> Array2<f64> {
+	let (height, width) = img.dim();
+	let mut result = Array2::zeros((height, width));
+	let mut integral_image: ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>> = Array2::zeros((height + 1, width + 1));
+
+	// Compute integral image
+	for y in 0..height {
+		for x in 0..width {
+			integral_image[(y + 1, x + 1)] = img[(y, x)] + integral_image[(y, x + 1)] + integral_image[(y + 1, x)] - integral_image[(y, x)];
+		}
+	}
+
+	for y in 0..height {
+		for x in 0..width {
+			let y1 = max(0, y as i32 - radius) as usize;
+			let y2 = min(height as i32 - 1, y as i32 + radius) as usize;
+			let x1 = max(0, x as i32 - radius) as usize;
+			let x2 = min(width as i32 - 1, x as i32 + radius) as usize;
+
+			let area = (y2 - y1 + 1) as f64 * (x2 - x1 + 1) as f64;
+
+			result[(y, x)] = (integral_image[(y2 + 1, x2 + 1)] - integral_image[(y1, x2 + 1)] - integral_image[(y2 + 1, x1)] + integral_image[(y1, x1)]) / area;
+		}
+	}
+
+	result
+}
+
+fn image_to_ndarray(img: &DynamicImage) -> Array2<f64> {
+	let (width, height) = img.dimensions();
+	let mut array = Array2::zeros((height as usize, width as usize));
+	for (x, y, pixel) in img.pixels() {
+		let luminance = pixel.0[0] as f64 / 255.;
+		array[(y as usize, x as usize)] = luminance;
+	}
+	array
+}
+
+fn ndarray_to_image(array: &Array2<f64>, width: u32, height: u32) -> DynamicImage {
+	let mut img = DynamicImage::new_rgba8(width, height);
+	for ((y, x), &value) in array.indexed_iter() {
+		let clamped_value = (value * 255.).clamp(0., 255.) as u8;
+		img.put_pixel(x as u32, y as u32, Rgba([clamped_value, clamped_value, clamped_value, 255]));
+	}
+	img
+}

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

@@ -0,0 +1,181 @@
+use core_types::color::Color;
+use core_types::context::Ctx;
+use core_types::registry::types::PixelLength;
+use core_types::table::Table;
+use raster_types::Image;
+use raster_types::{Bitmap, BitmapMut};
+use raster_types::{CPU, Raster};
+
+/// Blurs the image with a Gaussian or blur kernel filter.
+#[node_macro::node(category("Raster: Filter"))]
+async fn blur(
+	_: impl Ctx,
+	/// The image to be blurred.
+	image_frame: Table<Raster<CPU>>,
+	/// The radius of the blur kernel.
+	#[range((0., 100.))]
+	#[hard_min(0.)]
+	radius: PixelLength,
+	/// Use a lower-quality box kernel instead of a circular Gaussian kernel. This is faster but produces boxy artifacts.
+	box_blur: bool,
+	/// Opt to incorrectly apply the filter with color calculations in gamma space for compatibility with the results from other software.
+	gamma: bool,
+) -> Table<Raster<CPU>> {
+	image_frame
+		.into_iter()
+		.map(|mut row| {
+			let image = row.element.clone();
+
+			// Run blur algorithm
+			let blurred_image = if radius < 0.1 {
+				// Minimum blur radius
+				image.clone()
+			} else if box_blur {
+				Raster::new_cpu(box_blur_algorithm(image.into_data(), radius, gamma))
+			} else {
+				Raster::new_cpu(gaussian_blur_algorithm(image.into_data(), radius, gamma))
+			};
+
+			row.element = blurred_image;
+			row
+		})
+		.collect()
+}
+
+// 1D gaussian kernel
+fn gaussian_kernel(radius: f64) -> Vec<f64> {
+	// Given radius, compute the size of the kernel that's approximately three times the radius
+	let kernel_radius = (3. * radius).ceil() as usize;
+	let kernel_size = 2 * kernel_radius + 1;
+	let mut gaussian_kernel: Vec<f64> = vec![0.; kernel_size];
+
+	// Kernel values
+	let two_radius_squared = 2. * radius * radius;
+	let sum = gaussian_kernel
+		.iter_mut()
+		.enumerate()
+		.map(|(i, value_at_index)| {
+			let x = i as f64 - kernel_radius as f64;
+			let exponent = -(x * x) / two_radius_squared;
+			*value_at_index = exponent.exp();
+			*value_at_index
+		})
+		.sum::<f64>();
+
+	// Normalize
+	gaussian_kernel.iter_mut().for_each(|value_at_index| *value_at_index /= sum);
+
+	gaussian_kernel
+}
+
+fn gaussian_blur_algorithm(mut original_buffer: Image<Color>, radius: f64, gamma: bool) -> Image<Color> {
+	if gamma {
+		original_buffer.map_pixels(|px| px.to_gamma_srgb().to_associated_alpha(px.a()));
+	} else {
+		original_buffer.map_pixels(|px| px.to_associated_alpha(px.a()));
+	}
+
+	let (width, height) = original_buffer.dimensions();
+
+	// Create 1D gaussian kernel
+	let kernel = gaussian_kernel(radius);
+	let half_kernel = kernel.len() / 2;
+
+	// Intermediate buffer for horizontal and vertical passes
+	let mut x_axis = Image::new(width, height, Color::TRANSPARENT);
+	let mut y_axis = Image::new(width, height, Color::TRANSPARENT);
+
+	for pass in [false, true] {
+		let (max, old_buffer, current_buffer) = match pass {
+			false => (width, &original_buffer, &mut x_axis),
+			true => (height, &x_axis, &mut y_axis),
+		};
+		let pass = pass as usize;
+
+		for y in 0..height {
+			for x in 0..width {
+				let (mut r_sum, mut g_sum, mut b_sum, mut a_sum, mut weight_sum) = (0., 0., 0., 0., 0.);
+
+				for (i, &weight) in kernel.iter().enumerate() {
+					let p = [x, y][pass] as i32 + (i as i32 - half_kernel as i32);
+
+					if p >= 0
+						&& p < max as i32 && let Some(px) = old_buffer.get_pixel([p as u32, x][pass], [y, p as u32][pass])
+					{
+						r_sum += px.r() as f64 * weight;
+						g_sum += px.g() as f64 * weight;
+						b_sum += px.b() as f64 * weight;
+						a_sum += px.a() as f64 * weight;
+						weight_sum += weight;
+					}
+				}
+
+				// Normalize
+				let (r, g, b, a) = if weight_sum > 0. {
+					((r_sum / weight_sum) as f32, (g_sum / weight_sum) as f32, (b_sum / weight_sum) as f32, (a_sum / weight_sum) as f32)
+				} else {
+					let px = old_buffer.get_pixel(x, y).unwrap();
+					(px.r(), px.g(), px.b(), px.a())
+				};
+				current_buffer.set_pixel(x, y, Color::from_rgbaf32_unchecked(r, g, b, a));
+			}
+		}
+	}
+
+	if gamma {
+		y_axis.map_pixels(|px| px.to_linear_srgb().to_unassociated_alpha());
+	} else {
+		y_axis.map_pixels(|px| px.to_unassociated_alpha());
+	}
+
+	y_axis
+}
+
+fn box_blur_algorithm(mut original_buffer: Image<Color>, radius: f64, gamma: bool) -> Image<Color> {
+	if gamma {
+		original_buffer.map_pixels(|px| px.to_gamma_srgb().to_associated_alpha(px.a()));
+	} else {
+		original_buffer.map_pixels(|px| px.to_associated_alpha(px.a()));
+	}
+
+	let (width, height) = original_buffer.dimensions();
+	let mut x_axis = Image::new(width, height, Color::TRANSPARENT);
+	let mut y_axis = Image::new(width, height, Color::TRANSPARENT);
+
+	for pass in [false, true] {
+		let (max, old_buffer, current_buffer) = match pass {
+			false => (width, &original_buffer, &mut x_axis),
+			true => (height, &x_axis, &mut y_axis),
+		};
+		let pass = pass as usize;
+
+		for y in 0..height {
+			for x in 0..width {
+				let (mut r_sum, mut g_sum, mut b_sum, mut a_sum, mut weight_sum) = (0., 0., 0., 0., 0.);
+
+				let i = [x, y][pass];
+				for d in (i as i32 - radius as i32).max(0)..=(i as i32 + radius as i32).min(max as i32 - 1) {
+					if let Some(px) = old_buffer.get_pixel([d as u32, x][pass], [y, d as u32][pass]) {
+						let weight = 1.;
+						r_sum += px.r() as f64 * weight;
+						g_sum += px.g() as f64 * weight;
+						b_sum += px.b() as f64 * weight;
+						a_sum += px.a() as f64 * weight;
+						weight_sum += weight;
+					}
+				}
+
+				let (r, g, b, a) = ((r_sum / weight_sum) as f32, (g_sum / weight_sum) as f32, (b_sum / weight_sum) as f32, (a_sum / weight_sum) as f32);
+				current_buffer.set_pixel(x, y, Color::from_rgbaf32_unchecked(r, g, b, a));
+			}
+		}
+	}
+
+	if gamma {
+		y_axis.map_pixels(|px| px.to_linear_srgb().to_unassociated_alpha());
+	} else {
+		y_axis.map_pixels(|px| px.to_unassociated_alpha());
+	}
+
+	y_axis
+}

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

@@ -0,0 +1,29 @@
+use glam::{Vec2, Vec4};
+use spirv_std::spirv;
+
+/// webgpu NDC is like OpenGL: (-1.0 .. 1.0, -1.0 .. 1.0, 0.0 .. 1.0)
+/// https://www.w3.org/TR/webgpu/#coordinate-systems
+///
+/// So to make a fullscreen triangle around a box at (-1..1):
+///
+/// ```text
+///  3 +
+///    |\
+///  2 |  \
+///    |    \
+///  1 +-----+
+///    |     |\
+///  0 |  0  |  \
+///    |     |    \
+/// -1 +-----+-----+
+///   -1  0  1  2  3
+/// ```
+const FULLSCREEN_VERTICES: [Vec2; 3] = [Vec2::new(-1., -1.), Vec2::new(-1., 3.), Vec2::new(3., -1.)];
+
+#[spirv(vertex)]
+pub fn fullscreen_vertex(#[spirv(vertex_index)] vertex_index: u32, #[spirv(position)] gl_position: &mut Vec4) {
+	// broken on edition 2024 branch
+	// let vertex = unsafe { *FULLSCREEN_VERTICES.index_unchecked(vertex_index as usize) };
+	let vertex = FULLSCREEN_VERTICES[vertex_index as usize];
+	*gl_position = Vec4::from((vertex, 0., 1.));
+}

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

@@ -0,0 +1,45 @@
+use crate::curve::{Curve, CurveManipulatorGroup, ValueMapperNode};
+use core_types::color::{Channel, Linear};
+use core_types::context::Ctx;
+use kurbo::{CubicBez, ParamCurve, PathSeg, Point};
+use vector_types::vector::algorithms::bezpath_algorithms::pathseg_find_tvalues_for_x;
+
+const WINDOW_SIZE: usize = 1024;
+
+#[node_macro::node(category(""))]
+fn generate_curves<C: Channel + Linear>(_: impl Ctx, curve: Curve, #[implementations(f32, f64)] _target_format: C) -> ValueMapperNode<C> {
+	let [mut pos, mut param]: [[f32; 2]; 2] = [[0.; 2], curve.first_handle];
+	let mut lut = vec![C::from_f64(0.); WINDOW_SIZE];
+	let end = CurveManipulatorGroup {
+		anchor: [1.; 2],
+		handles: [curve.last_handle, [0.; 2]],
+	};
+	for sample in curve.manipulator_groups.iter().chain(std::iter::once(&end)) {
+		let [x0, y0, x1, y1, x2, y2, x3, y3] = [pos[0], pos[1], param[0], param[1], sample.handles[0][0], sample.handles[0][1], sample.anchor[0], sample.anchor[1]].map(f64::from);
+
+		let segment = PathSeg::Cubic(CubicBez::new(Point::new(x0, y0), Point::new(x1, y1), Point::new(x2, y2), Point::new(x3, y3)));
+
+		let [left, right] = [pos[0], sample.anchor[0]].map(|c| c.clamp(0., 1.));
+		let lut_index_left: usize = (left * (lut.len() - 1) as f32).floor() as _;
+		let lut_index_right: usize = (right * (lut.len() - 1) as f32).ceil() as _;
+		for index in lut_index_left..=lut_index_right {
+			let x = index as f64 / (lut.len() - 1) as f64;
+			let y = if x <= x0 {
+				y0
+			} else if x >= x3 {
+				y3
+			} else {
+				pathseg_find_tvalues_for_x(segment, x)
+					.next()
+					.map(|t| segment.eval(t.clamp(0., 1.)).y)
+					// Fall back to a very bad approximation if the above fails
+					.unwrap_or_else(|| (x - x0) / (x3 - x0) * (y3 - y0) + y0)
+			};
+			lut[index] = C::from_f64(y);
+		}
+
+		pos = sample.anchor;
+		param = sample.handles[1];
+	}
+	ValueMapperNode::new(lut)
+}

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

@@ -0,0 +1,32 @@
+//! Not immediately shader compatible due to needing [`GradientStops`] as a param, which needs [`Vec`]
+
+use crate::adjust::Adjust;
+use core_types::table::Table;
+use core_types::{Color, Ctx};
+use raster_types::{CPU, Raster};
+use vector_types::GradientStops;
+
+// Aims for interoperable compatibility with:
+// https://www.adobe.com/devnet-apps/photoshop/fileformatashtml/#:~:text=%27grdm%27%20%3D%20Gradient%20Map
+// https://www.adobe.com/devnet-apps/photoshop/fileformatashtml/#:~:text=Gradient%20settings%20(Photoshop%206.0)
+#[node_macro::node(category("Raster: Adjustment"))]
+async fn gradient_map<T: Adjust<Color>>(
+	_: impl Ctx,
+	#[implementations(
+		Table<Raster<CPU>>,
+		Table<Color>,
+		Table<GradientStops>,
+		GradientStops,
+	)]
+	mut image: T,
+	gradient: GradientStops,
+	reverse: bool,
+) -> T {
+	image.adjust(|color| {
+		let intensity = color.luminance_srgb();
+		let intensity = if reverse { 1. - intensity } else { intensity };
+		gradient.evaluate(intensity as f64).to_linear_srgb()
+	});
+
+	image
+}

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

@@ -0,0 +1,84 @@
+use core_types::color::Color;
+use core_types::context::Ctx;
+use core_types::table::{Table, TableRow};
+use raster_types::{CPU, Raster};
+
+#[node_macro::node(category("Color"))]
+async fn image_color_palette(
+	_: impl Ctx,
+	image: Table<Raster<CPU>>,
+	#[hard_min(1.)]
+	#[soft_max(28.)]
+	max_size: u32,
+) -> Table<Color> {
+	const GRID: f32 = 3.;
+
+	let bins = GRID * GRID * GRID;
+
+	let mut histogram = vec![0; (bins + 1.) as usize];
+	let mut color_bins = vec![Vec::new(); (bins + 1.) as usize];
+
+	for row in image.iter() {
+		for pixel in row.element.data.iter() {
+			let r = pixel.r() * GRID;
+			let g = pixel.g() * GRID;
+			let b = pixel.b() * GRID;
+
+			let bin = (r * GRID + g * GRID + b * GRID) as usize;
+
+			histogram[bin] += 1;
+			color_bins[bin].push(pixel.to_gamma_srgb());
+		}
+	}
+
+	let shorted = histogram.iter().enumerate().filter(|&(_, &count)| count > 0).map(|(i, _)| i).collect::<Vec<usize>>();
+
+	shorted
+		.iter()
+		.take(max_size as usize)
+		.flat_map(|&i| {
+			let list = &color_bins[i];
+
+			let mut r = 0.;
+			let mut g = 0.;
+			let mut b = 0.;
+			let mut a = 0.;
+
+			for color in list.iter() {
+				r += color.r();
+				g += color.g();
+				b += color.b();
+				a += color.a();
+			}
+
+			r /= list.len() as f32;
+			g /= list.len() as f32;
+			b /= list.len() as f32;
+			a /= list.len() as f32;
+
+			Color::from_rgbaf32(r, g, b, a).map(TableRow::new_from_element).into_iter()
+		})
+		.collect()
+}
+
+#[cfg(test)]
+mod test {
+	use super::*;
+	use raster_types::Image;
+	use raster_types::Raster;
+
+	#[test]
+	fn test_image_color_palette() {
+		let result = image_color_palette(
+			(),
+			Table::new_from_element(Raster::new_cpu(Image {
+				width: 100,
+				height: 100,
+				data: vec![Color::from_rgbaf32(0., 0., 0., 1.).unwrap(); 10000],
+				base64_string: None,
+			})),
+			1,
+		);
+		assert_eq!(futures::executor::block_on(result), Table::new_from_element(Color::from_rgbaf32(0., 0., 0., 1.).unwrap()));
+	}
+}

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

@@ -0,0 +1,26 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+pub mod adjust;
+pub mod adjustments;
+pub mod blending_nodes;
+pub mod cubic_spline;
+pub mod fullscreen_vertex;
+
+/// required by shader macro
+#[cfg(feature = "shader-nodes")]
+pub use raster_nodes_shaders::WGSL_SHADER;
+
+#[cfg(feature = "std")]
+pub mod curve;
+#[cfg(feature = "std")]
+pub mod dehaze;
+#[cfg(feature = "std")]
+pub mod filter;
+#[cfg(feature = "std")]
+pub mod generate_curves;
+#[cfg(feature = "std")]
+pub mod gradient_map;
+#[cfg(feature = "std")]
+pub mod image_color_palette;
+#[cfg(feature = "std")]
+pub mod std_nodes;

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

@@ -0,0 +1,518 @@
+use crate::adjustments::{CellularDistanceFunction, CellularReturnType, DomainWarpType, FractalType, NoiseType};
+use core_types::blending::AlphaBlending;
+use core_types::color::Color;
+use core_types::color::{Alpha, AlphaMut, Channel, LinearChannel, Luminance, RGBMut};
+use core_types::context::{Ctx, ExtractFootprint};
+use core_types::math::bbox::Bbox;
+use core_types::table::{Table, TableRow};
+use core_types::transform::Transform;
+use dyn_any::DynAny;
+use fastnoise_lite;
+use glam::{DAffine2, DVec2, Vec2};
+use rand::prelude::*;
+use rand_chacha::ChaCha8Rng;
+use raster_types::Image;
+use raster_types::{Bitmap, BitmapMut};
+use raster_types::{CPU, Raster};
+use std::fmt::Debug;
+use std::hash::Hash;
+
+#[derive(Debug, DynAny)]
+pub enum Error {
+	IO(std::io::Error),
+	Image(::image::ImageError),
+}
+
+impl From<std::io::Error> for Error {
+	fn from(e: std::io::Error) -> Self {
+		Error::IO(e)
+	}
+}
+
+#[node_macro::node(category("Debug: Raster"))]
+pub fn sample_image(ctx: impl ExtractFootprint + Clone + Send, image_frame: Table<Raster<CPU>>) -> Table<Raster<CPU>> {
+	image_frame
+		.into_iter()
+		.filter_map(|mut row| {
+			let image_frame_transform = row.transform;
+			let image = row.element;
+
+			// Resize the image using the image crate
+			let data = bytemuck::cast_vec(image.data.clone());
+
+			let footprint = ctx.footprint();
+			let viewport_bounds = footprint.viewport_bounds_in_local_space();
+			let image_bounds = Bbox::from_transform(image_frame_transform).to_axis_aligned_bbox();
+			let intersection = viewport_bounds.intersect(&image_bounds);
+			let image_size = DAffine2::from_scale(DVec2::new(image.width as f64, image.height as f64));
+			let size = intersection.size();
+			let size_px = image_size.transform_vector2(size).as_uvec2();
+
+			// If the image would not be visible, add nothing.
+			if size.x <= 0. || size.y <= 0. {
+				return None;
+			}
+
+			let image_buffer = ::image::Rgba32FImage::from_raw(image.width, image.height, data).expect("Failed to convert internal image format into image-rs data type.");
+
+			let dynamic_image: ::image::DynamicImage = image_buffer.into();
+			let offset = (intersection.start - image_bounds.start).max(DVec2::ZERO);
+			let offset_px = image_size.transform_vector2(offset).as_uvec2();
+			let cropped = dynamic_image.crop_imm(offset_px.x, offset_px.y, size_px.x, size_px.y);
+
+			let viewport_resolution_x = footprint.transform.transform_vector2(DVec2::X * size.x).length();
+			let viewport_resolution_y = footprint.transform.transform_vector2(DVec2::Y * size.y).length();
+			let mut new_width = size_px.x;
+			let mut new_height = size_px.y;
+
+			// Only downscale the image for now
+			let resized = if new_width < image.width || new_height < image.height {
+				new_width = viewport_resolution_x as u32;
+				new_height = viewport_resolution_y as u32;
+				// TODO: choose filter based on quality requirements
+				cropped.resize_exact(new_width, new_height, ::image::imageops::Triangle)
+			} else {
+				cropped
+			};
+			let buffer = resized.to_rgba32f();
+			let buffer = buffer.into_raw();
+			let vec = bytemuck::cast_vec(buffer);
+			let image = Image {
+				width: new_width,
+				height: new_height,
+				data: vec,
+				base64_string: None,
+			};
+			// we need to adjust the offset if we truncate the offset calculation
+
+			let new_transform = image_frame_transform * DAffine2::from_translation(offset) * DAffine2::from_scale(size);
+
+			row.transform = new_transform;
+			row.element = Raster::new_cpu(image);
+			Some(row)
+		})
+		.collect()
+}
+
+#[node_macro::node(category("Raster: Channels"))]
+pub fn combine_channels(
+	_: impl Ctx,
+	_primary: (),
+	#[expose] red: Table<Raster<CPU>>,
+	#[expose] green: Table<Raster<CPU>>,
+	#[expose] blue: Table<Raster<CPU>>,
+	#[expose] alpha: Table<Raster<CPU>>,
+) -> Table<Raster<CPU>> {
+	let max_len = red.len().max(green.len()).max(blue.len()).max(alpha.len());
+	let red = red.into_iter().map(Some).chain(std::iter::repeat(None)).take(max_len);
+	let green = green.into_iter().map(Some).chain(std::iter::repeat(None)).take(max_len);
+	let blue = blue.into_iter().map(Some).chain(std::iter::repeat(None)).take(max_len);
+	let alpha = alpha.into_iter().map(Some).chain(std::iter::repeat(None)).take(max_len);
+
+	red.zip(green)
+		.zip(blue)
+		.zip(alpha)
+		.filter_map(|(((red, green), blue), alpha)| {
+			// Turn any default zero-sized image rows into None
+			let red = red.filter(|i| i.element.width > 0 && i.element.height > 0);
+			let green = green.filter(|i| i.element.width > 0 && i.element.height > 0);
+			let blue = blue.filter(|i| i.element.width > 0 && i.element.height > 0);
+			let alpha = alpha.filter(|i| i.element.width > 0 && i.element.height > 0);
+
+			// Get this row's transform and alpha blending mode from the first non-empty channel
+			let (transform, alpha_blending, source_node_id) = [&red, &green, &blue, &alpha]
+				.iter()
+				.find_map(|i| i.as_ref())
+				.map(|i| (i.transform, i.alpha_blending, i.source_node_id))?;
+
+			// Get the common width and height of the channels, which must have equal dimensions
+			let channel_dimensions = [
+				red.as_ref().map(|r| (r.element.width, r.element.height)),
+				green.as_ref().map(|g| (g.element.width, g.element.height)),
+				blue.as_ref().map(|b| (b.element.width, b.element.height)),
+				alpha.as_ref().map(|a| (a.element.width, a.element.height)),
+			];
+			if channel_dimensions.iter().all(Option::is_none)
+				|| channel_dimensions
+					.iter()
+					.flatten()
+					.any(|&(x, y)| channel_dimensions.iter().flatten().any(|&(other_x, other_y)| x != other_x || y != other_y))
+			{
+				return None;
+			}
+			let &(width, height) = channel_dimensions.iter().flatten().next()?;
+
+			// Create a new image for the output element
+			let mut image = Image::new(width, height, Color::TRANSPARENT);
+
+			// Iterate over all pixels in the image and set the color channels
+			for y in 0..image.height() {
+				for x in 0..image.width() {
+					let image_pixel = image.get_pixel_mut(x, y).unwrap();
+
+					if let Some(r) = red.as_ref().and_then(|r| r.element.get_pixel(x, y)) {
+						image_pixel.set_red(r.l().cast_linear_channel());
+					} else {
+						image_pixel.set_red(Channel::from_linear(0.));
+					}
+					if let Some(g) = green.as_ref().and_then(|g| g.element.get_pixel(x, y)) {
+						image_pixel.set_green(g.l().cast_linear_channel());
+					} else {
+						image_pixel.set_green(Channel::from_linear(0.));
+					}
+					if let Some(b) = blue.as_ref().and_then(|b| b.element.get_pixel(x, y)) {
+						image_pixel.set_blue(b.l().cast_linear_channel());
+					} else {
+						image_pixel.set_blue(Channel::from_linear(0.));
+					}
+					if let Some(a) = alpha.as_ref().and_then(|a| a.element.get_pixel(x, y)) {
+						image_pixel.set_alpha(a.l().cast_linear_channel());
+					} else {
+						image_pixel.set_alpha(Channel::from_linear(1.));
+					}
+				}
+			}
+
+			Some(TableRow {
+				element: Raster::new_cpu(image),
+				transform,
+				alpha_blending,
+				source_node_id,
+			})
+		})
+		.collect()
+}
+
+#[node_macro::node(category("Raster"))]
+pub fn mask(
+	_: impl Ctx,
+	/// The image to be masked.
+	image: Table<Raster<CPU>>,
+	/// The stencil to be used for masking.
+	#[expose]
+	stencil: Table<Raster<CPU>>,
+) -> Table<Raster<CPU>> {
+	// TODO: Figure out what it means to support multiple stencil rows?
+	let Some(stencil) = stencil.into_iter().next() else {
+		// No stencil provided so we return the original image
+		return image;
+	};
+	let stencil_size = DVec2::new(stencil.element.width as f64, stencil.element.height as f64);
+
+	image
+		.into_iter()
+		.filter_map(|mut row| {
+			let image_size = DVec2::new(row.element.width as f64, row.element.height as f64);
+			let mask_size = stencil.transform.decompose_scale();
+
+			if mask_size == DVec2::ZERO {
+				return None;
+			}
+
+			// Transforms a point from the background image to the foreground image
+			let bg_to_fg = row.transform * DAffine2::from_scale(1. / image_size);
+			let stencil_transform_inverse = stencil.transform.inverse();
+
+			for y in 0..row.element.height {
+				for x in 0..row.element.width {
+					let image_point = DVec2::new(x as f64, y as f64);
+					let mask_point = bg_to_fg.transform_point2(image_point);
+					let local_mask_point = stencil_transform_inverse.transform_point2(mask_point);
+					let mask_point = stencil.transform.transform_point2(local_mask_point.clamp(DVec2::ZERO, DVec2::ONE));
+					let mask_point = (DAffine2::from_scale(stencil_size) * stencil.transform.inverse()).transform_point2(mask_point);
+
+					let image_pixel = row.element.data_mut().get_pixel_mut(x, y).unwrap();
+					let mask_pixel = stencil.element.sample(mask_point);
+					*image_pixel = image_pixel.multiplied_alpha(mask_pixel.l().cast_linear_channel());
+				}
+			}
+
+			Some(row)
+		})
+		.collect()
+}
+
+#[node_macro::node(category(""))]
+pub fn extend_image_to_bounds(_: impl Ctx, image: Table<Raster<CPU>>, bounds: DAffine2) -> Table<Raster<CPU>> {
+	image
+		.into_iter()
+		.map(|mut row| {
+			let image_aabb = Bbox::unit().affine_transform(row.transform).to_axis_aligned_bbox();
+			let bounds_aabb = Bbox::unit().affine_transform(bounds.transform()).to_axis_aligned_bbox();
+			if image_aabb.contains(bounds_aabb.start) && image_aabb.contains(bounds_aabb.end) {
+				return row;
+			}
+
+			let image_data = &row.element.data;
+			let (image_width, image_height) = (row.element.width, row.element.height);
+			if image_width == 0 || image_height == 0 {
+				return empty_image((), bounds, Table::new_from_element(Color::TRANSPARENT)).into_iter().next().unwrap();
+			}
+
+			let orig_image_scale = DVec2::new(image_width as f64, image_height as f64);
+			let layer_to_image_space = DAffine2::from_scale(orig_image_scale) * row.transform.inverse();
+			let bounds_in_image_space = Bbox::unit().affine_transform(layer_to_image_space * bounds).to_axis_aligned_bbox();
+
+			let new_start = bounds_in_image_space.start.floor().min(DVec2::ZERO);
+			let new_end = bounds_in_image_space.end.ceil().max(orig_image_scale);
+			let new_scale = new_end - new_start;
+
+			// Copy over original image into enlarged image.
+			let mut new_image = Image::new(new_scale.x as u32, new_scale.y as u32, Color::TRANSPARENT);
+			let offset_in_new_image = (-new_start).as_uvec2();
+			for y in 0..image_height {
+				let old_start = y * image_width;
+				let new_start = (y + offset_in_new_image.y) * new_image.width + offset_in_new_image.x;
+				let old_row = &image_data[old_start as usize..(old_start + image_width) as usize];
+				let new_row = &mut new_image.data[new_start as usize..(new_start + image_width) as usize];
+				new_row.copy_from_slice(old_row);
+			}
+
+			// Compute new transform.
+			// let layer_to_new_texture_space = (DAffine2::from_scale(1. / new_scale) * DAffine2::from_translation(new_start) * layer_to_image_space).inverse();
+			let new_texture_to_layer_space = row.transform * DAffine2::from_scale(1. / orig_image_scale) * DAffine2::from_translation(new_start) * DAffine2::from_scale(new_scale);
+
+			row.element = Raster::new_cpu(new_image);
+			row.transform = new_texture_to_layer_space;
+			row
+		})
+		.collect()
+}
+
+#[node_macro::node(category("Debug: Raster"))]
+pub fn empty_image(_: impl Ctx, transform: DAffine2, color: Table<Color>) -> Table<Raster<CPU>> {
+	let width = transform.transform_vector2(DVec2::new(1., 0.)).length() as u32;
+	let height = transform.transform_vector2(DVec2::new(0., 1.)).length() as u32;
+
+	let color: Option<Color> = color.into();
+	let image = Image::new(width, height, color.unwrap_or(Color::WHITE));
+
+	let mut result_table = Table::new_from_element(Raster::new_cpu(image));
+	let row = result_table.get_mut(0).unwrap();
+	*row.transform = transform;
+	*row.alpha_blending = AlphaBlending::default();
+
+	// Callers of empty_image can safely unwrap on returned table
+	result_table
+}
+
+/// Constructs a raster image.
+#[node_macro::node(category(""))]
+pub fn image_value(_: impl Ctx, _primary: (), image: Table<Raster<CPU>>) -> Table<Raster<CPU>> {
+	image
+}
+
+#[node_macro::node(category("Raster: Pattern"))]
+#[allow(clippy::too_many_arguments)]
+pub fn noise_pattern(
+	ctx: impl ExtractFootprint + Ctx,
+	_primary: (),
+	clip: bool,
+	seed: u32,
+	scale: f64,
+	noise_type: NoiseType,
+	domain_warp_type: DomainWarpType,
+	domain_warp_amplitude: f64,
+	fractal_type: FractalType,
+	fractal_octaves: u32,
+	fractal_lacunarity: f64,
+	fractal_gain: f64,
+	fractal_weighted_strength: f64,
+	fractal_ping_pong_strength: f64,
+	cellular_distance_function: CellularDistanceFunction,
+	cellular_return_type: CellularReturnType,
+	cellular_jitter: f64,
+) -> Table<Raster<CPU>> {
+	let footprint = ctx.footprint();
+	let viewport_bounds = footprint.viewport_bounds_in_local_space();
+
+	let mut size = viewport_bounds.size();
+	let mut offset = viewport_bounds.start;
+	if clip {
+		// TODO: Remove "clip" entirely (and its arbitrary 100x100 clipping square) once we have proper resolution-aware layer clipping
+		const CLIPPING_SQUARE_SIZE: f64 = 100.;
+		let image_bounds = Bbox::from_transform(DAffine2::from_scale(DVec2::splat(CLIPPING_SQUARE_SIZE))).to_axis_aligned_bbox();
+		let intersection = viewport_bounds.intersect(&image_bounds);
+
+		offset = (intersection.start - image_bounds.start).max(DVec2::ZERO);
+		size = intersection.size();
+	}
+
+	// If the image would not be visible, return an empty image
+	if size.x <= 0. || size.y <= 0. {
+		return Table::new();
+	}
+
+	let footprint_scale = footprint.scale();
+	let width = (size.x * footprint_scale.x) as u32;
+	let height = (size.y * footprint_scale.y) as u32;
+
+	// All
+	let mut image = Image::new(width, height, Color::from_luminance(0.5));
+	let mut noise = fastnoise_lite::FastNoiseLite::with_seed(seed as i32);
+	noise.set_frequency(Some(1. / (scale as f32).max(f32::EPSILON)));
+
+	// Domain Warp
+	let domain_warp_type = match domain_warp_type {
+		DomainWarpType::None => None,
+		DomainWarpType::OpenSimplex2 => Some(fastnoise_lite::DomainWarpType::OpenSimplex2),
+		DomainWarpType::OpenSimplex2Reduced => Some(fastnoise_lite::DomainWarpType::OpenSimplex2Reduced),
+		DomainWarpType::BasicGrid => Some(fastnoise_lite::DomainWarpType::BasicGrid),
+	};
+	let domain_warp_active = domain_warp_type.is_some();
+	noise.set_domain_warp_type(domain_warp_type);
+	noise.set_domain_warp_amp(Some(domain_warp_amplitude as f32));
+
+	// Fractal
+	let noise_type = match noise_type {
+		NoiseType::Perlin => fastnoise_lite::NoiseType::Perlin,
+		NoiseType::OpenSimplex2 => fastnoise_lite::NoiseType::OpenSimplex2,
+		NoiseType::OpenSimplex2S => fastnoise_lite::NoiseType::OpenSimplex2S,
+		NoiseType::Cellular => fastnoise_lite::NoiseType::Cellular,
+		NoiseType::ValueCubic => fastnoise_lite::NoiseType::ValueCubic,
+		NoiseType::Value => fastnoise_lite::NoiseType::Value,
+		NoiseType::WhiteNoise => {
+			// TODO: Generate in layer space, not viewport space
+
+			let mut rng = ChaCha8Rng::seed_from_u64(seed as u64);
+
+			for y in 0..height {
+				for x in 0..width {
+					let pixel = image.get_pixel_mut(x, y).unwrap();
+					let luminance = rng.random_range(0.0..1.) as f32;
+					*pixel = Color::from_luminance(luminance);
+				}
+			}
+
+			return Table::new_from_row(TableRow {
+				element: Raster::new_cpu(image),
+				transform: DAffine2::from_translation(offset) * DAffine2::from_scale(size),
+				..Default::default()
+			});
+		}
+	};
+	noise.set_noise_type(Some(noise_type));
+	let fractal_type = match fractal_type {
+		FractalType::None => fastnoise_lite::FractalType::None,
+		FractalType::FBm => fastnoise_lite::FractalType::FBm,
+		FractalType::Ridged => fastnoise_lite::FractalType::Ridged,
+		FractalType::PingPong => fastnoise_lite::FractalType::PingPong,
+		FractalType::DomainWarpProgressive => fastnoise_lite::FractalType::DomainWarpProgressive,
+		FractalType::DomainWarpIndependent => fastnoise_lite::FractalType::DomainWarpIndependent,
+	};
+	noise.set_fractal_type(Some(fractal_type));
+	noise.set_fractal_octaves(Some(fractal_octaves as i32));
+	noise.set_fractal_lacunarity(Some(fractal_lacunarity as f32));
+	noise.set_fractal_gain(Some(fractal_gain as f32));
+	noise.set_fractal_weighted_strength(Some(fractal_weighted_strength as f32));
+	noise.set_fractal_ping_pong_strength(Some(fractal_ping_pong_strength as f32));
+
+	// Cellular
+	let cellular_distance_function = match cellular_distance_function {
+		CellularDistanceFunction::Euclidean => fastnoise_lite::CellularDistanceFunction::Euclidean,
+		CellularDistanceFunction::EuclideanSq => fastnoise_lite::CellularDistanceFunction::EuclideanSq,
+		CellularDistanceFunction::Manhattan => fastnoise_lite::CellularDistanceFunction::Manhattan,
+		CellularDistanceFunction::Hybrid => fastnoise_lite::CellularDistanceFunction::Hybrid,
+	};
+	let cellular_return_type = match cellular_return_type {
+		CellularReturnType::CellValue => fastnoise_lite::CellularReturnType::CellValue,
+		CellularReturnType::Nearest => fastnoise_lite::CellularReturnType::Distance,
+		CellularReturnType::NextNearest => fastnoise_lite::CellularReturnType::Distance2,
+		CellularReturnType::Average => fastnoise_lite::CellularReturnType::Distance2Add,
+		CellularReturnType::Difference => fastnoise_lite::CellularReturnType::Distance2Sub,
+		CellularReturnType::Product => fastnoise_lite::CellularReturnType::Distance2Mul,
+		CellularReturnType::Division => fastnoise_lite::CellularReturnType::Distance2Div,
+	};
+	noise.set_cellular_distance_function(Some(cellular_distance_function));
+	noise.set_cellular_return_type(Some(cellular_return_type));
+	noise.set_cellular_jitter(Some(cellular_jitter as f32));
+
+	let coordinate_offset = offset.as_vec2();
+	let scale = size.as_vec2() / Vec2::new(width as f32, height as f32);
+	// Calculate the noise for every pixel
+	for y in 0..height {
+		for x in 0..width {
+			let pixel = image.get_pixel_mut(x, y).unwrap();
+			let pos = Vec2::new(x as f32, y as f32);
+			let vec = pos * scale + coordinate_offset;
+
+			let (mut x, mut y) = (vec.x, vec.y);
+			if domain_warp_active && domain_warp_amplitude > 0. {
+				(x, y) = noise.domain_warp_2d(x, y);
+			}
+
+			let luminance = (noise.get_noise_2d(x, y) + 1.) * 0.5;
+			*pixel = Color::from_luminance(luminance);
+		}
+	}
+
+	Table::new_from_row(TableRow {
+		element: Raster::new_cpu(image),
+		transform: DAffine2::from_translation(offset) * DAffine2::from_scale(size),
+		..Default::default()
+	})
+}
+
+#[node_macro::node(category("Raster: Pattern"))]
+pub fn mandelbrot(ctx: impl ExtractFootprint + Send) -> Table<Raster<CPU>> {
+	let footprint = ctx.footprint();
+	let viewport_bounds = footprint.viewport_bounds_in_local_space();
+
+	let image_bounds = Bbox::from_transform(DAffine2::IDENTITY).to_axis_aligned_bbox();
+	let intersection = viewport_bounds.intersect(&image_bounds);
+	let size = intersection.size();
+
+	let offset = (intersection.start - image_bounds.start).max(DVec2::ZERO);
+
+	// If the image would not be visible, return an empty image
+	if size.x <= 0. || size.y <= 0. {
+		return Table::new();
+	}
+
+	let scale = footprint.scale();
+	let width = (size.x * scale.x) as u32;
+	let height = (size.y * scale.y) as u32;
+
+	let mut data = Vec::with_capacity(width as usize * height as usize);
+	let max_iter = 255;
+
+	let scale = 3. * size.as_vec2() / Vec2::new(width as f32, height as f32);
+	let coordinate_offset = offset.as_vec2() * 3. - Vec2::new(2., 1.5);
+	for y in 0..height {
+		for x in 0..width {
+			let pos = Vec2::new(x as f32, y as f32);
+			let c = pos * scale + coordinate_offset;
+
+			let iter = mandelbrot_impl(c, max_iter);
+			data.push(map_color(iter, max_iter));
+		}
+	}
+
+	Table::new_from_row(TableRow {
+		element: Raster::new_cpu(Image {
+			width,
+			height,
+			data,
+			..Default::default()
+		}),
+		transform: DAffine2::from_translation(offset) * DAffine2::from_scale(size),
+		..Default::default()
+	})
+}
+
+#[inline(always)]
+fn mandelbrot_impl(c: Vec2, max_iter: usize) -> usize {
+	let mut z = Vec2::new(0., 0.);
+	for i in 0..max_iter {
+		z = Vec2::new(z.x * z.x - z.y * z.y, 2. * z.x * z.y) + c;
+		if z.length_squared() > 4. {
+			return i;
+		}
+	}
+	max_iter
+}
+
+fn map_color(iter: usize, max_iter: usize) -> Color {
+	let v = iter as f32 / max_iter as f32;
+	Color::from_rgbaf32_unchecked(v, v, v, 1.)
+}