merge

node-graph/graster-nodes/Cargo.toml

@@ -7,28 +7,45 @@ authors = ["Graphite Authors <contact@graphite.rs>"]
 license = "MIT OR Apache-2.0"
 
 [features]
-default = ["serde"]
-serde = ["dep:serde"]
+default = ["std"]
+std = [
+	"dep:graphene-core",
+	"dep:dyn-any",
+	"dep:image",
+	"dep:ndarray",
+	"dep:rand",
+	"dep:rand_chacha",
+	"dep:fastnoise-lite",
+	"dep:serde",
+	"dep:specta",
+	"dep:kurbo",
+	"glam/debug-glam-assert",
+	"glam/serde",
+]
 
 [dependencies]
 # Local dependencies
-dyn-any = { workspace = true }
-graphene-core = { workspace = true }
+graphene-core-shaders = { workspace = true }
 node-macro = { workspace = true }
 
-# Workspace dependencies
-glam = { workspace = true }
-specta = { workspace = true }
-image = { workspace = true }
-bytemuck = { workspace = true }
-ndarray = { workspace = true }
-bezier-rs = { workspace = true }
-rand = { workspace = true }
-rand_chacha = { workspace = true }
-fastnoise-lite = { workspace = true }
+# Local std dependencies
+dyn-any = { workspace = true, optional = true }
+graphene-core = { workspace = true, optional = true }
 
-# Optional workspace dependencies
-serde = { workspace = true, optional = true, features = ["derive"] }
+# Workspace dependencies
+bytemuck = { workspace = true }
+glam = { workspace = true }
+num-traits = { 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 }

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

@@ -0,0 +1,49 @@
+use graphene_core_shaders::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 graphene_core::gradient::GradientStops;
+	use graphene_core::raster_types::{CPU, Raster};
+	use graphene_core::table::Table;
+
+	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/graster-nodes/src/blending_nodes.rs

@@ -0,0 +1,212 @@
+use crate::adjust::Adjust;
+#[cfg(feature = "std")]
+use graphene_core::gradient::GradientStops;
+#[cfg(feature = "std")]
+use graphene_core::raster_types::{CPU, Raster};
+#[cfg(feature = "std")]
+use graphene_core::table::Table;
+use graphene_core_shaders::Ctx;
+use graphene_core_shaders::blending::BlendMode;
+use graphene_core_shaders::color::{Color, Pixel};
+use graphene_core_shaders::registry::types::PercentageF32;
+
+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 graphene_core::raster::Image;
+	use graphene_core::raster_types::Raster;
+	use graphene_core::table::Table;
+
+	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 as f32))
+}
+
+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"), shader_node(PerPixelAdjust))]
+fn blend<T: Blend<Color> + Send>(
+	_: impl Ctx,
+	#[implementations(
+		Table<Raster<CPU>>,
+		Table<Color>,
+		Table<GradientStops>,
+		GradientStops,
+	)]
+	over: T,
+	#[expose]
+	#[implementations(
+		Table<Raster<CPU>>,
+		Table<Color>,
+		Table<GradientStops>,
+		GradientStops,
+	)]
+	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,
+	)]
+	mut image: T,
+	#[default(Color::BLACK)] color: Color,
+	blend_mode: BlendMode,
+	#[default(100.)] opacity: PercentageF32,
+) -> T {
+	let opacity = (opacity as f32 / 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 graphene_core::blending::BlendMode;
+	use graphene_core::color::Color;
+	use graphene_core::raster::image::Image;
+	use graphene_core::raster_types::Raster;
+	use graphene_core::table::Table;
+
+	#[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/graster-nodes/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/graster-nodes/src/curve.rs

@@ -45,125 +45,6 @@ impl Hash for CurveManipulatorGroup {
 	}
 }
 
-#[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(std::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.)
-	}
-}
-
 pub struct ValueMapperNode<C> {
 	lut: Vec<C>,
 }

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

@@ -1,17 +1,18 @@
 use graphene_core::context::Ctx;
 use graphene_core::raster::image::Image;
-use graphene_core::raster_types::{CPU, Raster, RasterDataTable};
+use graphene_core::raster_types::{CPU, Raster};
 use graphene_core::registry::types::Percentage;
+use graphene_core::table::Table;
 use image::{DynamicImage, GenericImage, GenericImageView, GrayImage, ImageBuffer, Luma, Rgba, RgbaImage};
 use ndarray::{Array2, ArrayBase, Dim, OwnedRepr};
 use std::cmp::{max, min};
 
 #[node_macro::node(category("Raster: Filter"))]
-async fn dehaze(_: impl Ctx, image_frame: RasterDataTable<CPU>, strength: Percentage) -> RasterDataTable<CPU> {
+async fn dehaze(_: impl Ctx, image_frame: Table<Raster<CPU>>, strength: Percentage) -> Table<Raster<CPU>> {
 	image_frame
-		.instance_iter()
-		.map(|mut image_frame_instance| {
-			let image = image_frame_instance.instance;
+		.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.");
@@ -30,9 +31,8 @@ async fn dehaze(_: impl Ctx, image_frame: RasterDataTable<CPU>, strength: Percen
 				base64_string: None,
 			};
 
-			image_frame_instance.instance = Raster::new_cpu(dehazed_image);
-			image_frame_instance.source_node_id = None;
-			image_frame_instance
+			row.element = Raster::new_cpu(dehazed_image);
+			row
 		})
 		.collect()
 }

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

@@ -2,15 +2,16 @@ use graphene_core::color::Color;
 use graphene_core::context::Ctx;
 use graphene_core::raster::image::Image;
 use graphene_core::raster::{Bitmap, BitmapMut};
-use graphene_core::raster_types::{CPU, Raster, RasterDataTable};
+use graphene_core::raster_types::{CPU, Raster};
 use graphene_core::registry::types::PixelLength;
+use graphene_core::table::Table;
 
 /// 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: RasterDataTable<CPU>,
+	image_frame: Table<Raster<CPU>>,
 	/// The radius of the blur kernel.
 	#[range((0., 100.))]
 	#[hard_min(0.)]
@@ -19,11 +20,11 @@ async fn blur(
 	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,
-) -> RasterDataTable<CPU> {
+) -> Table<Raster<CPU>> {
 	image_frame
-		.instance_iter()
-		.map(|mut image_instance| {
-			let image = image_instance.instance.clone();
+		.into_iter()
+		.map(|mut row| {
+			let image = row.element.clone();
 
 			// Run blur algorithm
 			let blurred_image = if radius < 0.1 {
@@ -35,9 +36,8 @@ async fn blur(
 				Raster::new_cpu(gaussian_blur_algorithm(image.into_data(), radius, gamma))
 			};
 
-			image_instance.instance = blurred_image;
-			image_instance.source_node_id = None;
-			image_instance
+			row.element = blurred_image;
+			row
 		})
 		.collect()
 }

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

@@ -1,9 +1,8 @@
-//! requires bezier-rs
-
 use crate::curve::{Curve, CurveManipulatorGroup, ValueMapperNode};
-use bezier_rs::{Bezier, TValue};
 use graphene_core::color::{Channel, Linear};
 use graphene_core::context::Ctx;
+use graphene_core::vector::algorithms::bezpath_algorithms::pathseg_find_tvalues_for_x;
+use kurbo::{CubicBez, ParamCurve, PathSeg, Point};
 
 const WINDOW_SIZE: usize = 1024;
 
@@ -18,7 +17,7 @@ fn generate_curves<C: Channel + Linear>(_: impl Ctx, curve: Curve, #[implementat
 	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 bezier = Bezier::from_cubic_coordinates(x0, y0, x1, y1, x2, y2, x3, y3);
+		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 _;
@@ -30,10 +29,10 @@ fn generate_curves<C: Channel + Linear>(_: impl Ctx, curve: Curve, #[implementat
 			} else if x >= x3 {
 				y3
 			} else {
-				bezier.find_tvalues_for_x(x)
+				pathseg_find_tvalues_for_x(segment, x)
 					.next()
-					.map(|t| bezier.evaluate(TValue::Parametric(t.clamp(0., 1.))).y)
-					// Fall back to a very bad approximation if Bezier-rs fails
+					.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);

node-graph/graster-nodes/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 graphene_core::gradient::GradientStops;
+use graphene_core::raster_types::{CPU, Raster};
+use graphene_core::table::Table;
+use graphene_core::{Color, Ctx};
+
+// 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/graster-nodes/src/image_color_palette.rs

@@ -1,24 +1,25 @@
 use graphene_core::color::Color;
 use graphene_core::context::Ctx;
-use graphene_core::raster_types::{CPU, RasterDataTable};
+use graphene_core::raster_types::{CPU, Raster};
+use graphene_core::table::{Table, TableRow};
 
 #[node_macro::node(category("Color"))]
 async fn image_color_palette(
 	_: impl Ctx,
-	image: RasterDataTable<CPU>,
+	image: Table<Raster<CPU>>,
 	#[hard_min(1.)]
 	#[soft_max(28.)]
 	max_size: u32,
-) -> Vec<Color> {
+) -> Table<Color> {
 	const GRID: f32 = 3.;
 
 	let bins = GRID * GRID * GRID;
 
-	let mut histogram: Vec<usize> = vec![0; (bins + 1.) as usize];
-	let mut colors: Vec<Vec<Color>> = vec![vec![]; (bins + 1.) as usize];
+	let mut histogram = vec![0; (bins + 1.) as usize];
+	let mut color_bins = vec![Vec::new(); (bins + 1.) as usize];
 
-	for image_instance in image.instance_ref_iter() {
-		for pixel in image_instance.instance.data.iter() {
+	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;
@@ -26,53 +27,51 @@ async fn image_color_palette(
 			let bin = (r * GRID + g * GRID + b * GRID) as usize;
 
 			histogram[bin] += 1;
-			colors[bin].push(pixel.to_gamma_srgb());
+			color_bins[bin].push(pixel.to_gamma_srgb());
 		}
 	}
 
 	let shorted = histogram.iter().enumerate().filter(|&(_, &count)| count > 0).map(|(i, _)| i).collect::<Vec<usize>>();
 
-	let mut palette = vec![];
+	shorted
+		.iter()
+		.take(max_size as usize)
+		.flat_map(|&i| {
+			let list = &color_bins[i];
 
-	for i in shorted.iter().take(max_size as usize) {
-		let list = colors[*i].clone();
+			let mut r = 0.;
+			let mut g = 0.;
+			let mut b = 0.;
+			let mut a = 0.;
 
-		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();
+			}
 
-		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;
 
-		r /= list.len() as f32;
-		g /= list.len() as f32;
-		b /= list.len() as f32;
-		a /= list.len() as f32;
-
-		let color = Color::from_rgbaf32(r, g, b, a).unwrap();
-
-		palette.push(color);
-	}
-
-	palette
+			Color::from_rgbaf32(r, g, b, a).map(TableRow::new_from_element).into_iter()
+		})
+		.collect()
 }
 
 #[cfg(test)]
 mod test {
 	use super::*;
 	use graphene_core::raster::image::Image;
-	use graphene_core::raster_types::{Raster, RasterDataTable};
+	use graphene_core::raster_types::Raster;
 
 	#[test]
 	fn test_image_color_palette() {
 		let result = image_color_palette(
 			(),
-			RasterDataTable::new(Raster::new_cpu(Image {
+			Table::new_from_element(Raster::new_cpu(Image {
 				width: 100,
 				height: 100,
 				data: vec![Color::from_rgbaf32(0., 0., 0., 1.).unwrap(); 10000],
@@ -80,6 +79,6 @@ mod test {
 			})),
 			1,
 		);
-		assert_eq!(futures::executor::block_on(result), [Color::from_rgbaf32(0., 0., 0., 1.).unwrap()]);
+		assert_eq!(futures::executor::block_on(result), Table::new_from_element(Color::from_rgbaf32(0., 0., 0., 1.).unwrap()));
 	}
 }

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

@@ -1,7 +1,21 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+pub mod adjust;
 pub mod adjustments;
+pub mod blending_nodes;
+pub mod cubic_spline;
+
+#[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/graster-nodes/src/std_nodes.rs

@@ -4,17 +4,16 @@ use fastnoise_lite;
 use glam::{DAffine2, DVec2, Vec2};
 use graphene_core::blending::AlphaBlending;
 use graphene_core::color::Color;
-use graphene_core::color::{Alpha, AlphaMut, Channel, LinearChannel, Luminance, RGBMut};
+use graphene_core::color::{AlphaMut, Channel, LinearChannel, Luminance, RGBMut};
 use graphene_core::context::{Ctx, ExtractFootprint};
-use graphene_core::instances::Instance;
-use graphene_core::instances::Instances;
 use graphene_core::math::bbox::Bbox;
 use graphene_core::raster::image::Image;
 use graphene_core::raster::{Bitmap, BitmapMut};
-use graphene_core::raster_types::{CPU, Raster, RasterDataTable};
+use graphene_core::raster_types::{CPU, Raster};
+use graphene_core::table::{Table, TableRow};
 use graphene_core::transform::Transform;
-use graphene_core::vector::VectorDataTable;
-use graphene_core::{GraphicElement, GraphicGroupTable};
+use graphene_core::vector::Vector;
+use graphene_core::Graphic;
 use rand::prelude::*;
 use rand_chacha::ChaCha8Rng;
 use std::fmt::Debug;
@@ -33,12 +32,12 @@ impl From<std::io::Error> for Error {
 }
 
 #[node_macro::node(category("Debug: Raster"))]
-pub fn sample_image(ctx: impl ExtractFootprint + Clone + Send, image_frame: RasterDataTable<CPU>) -> RasterDataTable<CPU> {
+pub fn sample_image(ctx: impl ExtractFootprint + Clone + Send, image_frame: Table<Raster<CPU>>) -> Table<Raster<CPU>> {
 	image_frame
-		.instance_iter()
-		.filter_map(|mut image_frame_instance| {
-			let image_frame_transform = image_frame_instance.transform;
-			let image = image_frame_instance.instance;
+		.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());
@@ -90,10 +89,9 @@ pub fn sample_image(ctx: impl ExtractFootprint + Clone + Send, image_frame: Rast
 
 			let new_transform = image_frame_transform * DAffine2::from_translation(offset) * DAffine2::from_scale(size);
 
-			image_frame_instance.transform = new_transform;
-			image_frame_instance.source_node_id = None;
-			image_frame_instance.instance = Raster::new_cpu(image);
-			Some(image_frame_instance)
+			row.transform = new_transform;
+			row.element = Raster::new_cpu(image);
+			Some(row)
 		})
 		.collect()
 }
@@ -102,38 +100,39 @@ pub fn sample_image(ctx: impl ExtractFootprint + Clone + Send, image_frame: Rast
 pub fn combine_channels(
 	_: impl Ctx,
 	_primary: (),
-	#[expose] red: RasterDataTable<CPU>,
-	#[expose] green: RasterDataTable<CPU>,
-	#[expose] blue: RasterDataTable<CPU>,
-	#[expose] alpha: RasterDataTable<CPU>,
-) -> RasterDataTable<CPU> {
+	#[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.instance_iter().map(Some).chain(std::iter::repeat(None)).take(max_len);
-	let green = green.instance_iter().map(Some).chain(std::iter::repeat(None)).take(max_len);
-	let blue = blue.instance_iter().map(Some).chain(std::iter::repeat(None)).take(max_len);
-	let alpha = alpha.instance_iter().map(Some).chain(std::iter::repeat(None)).take(max_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 instances into None
-			let red = red.filter(|i| i.instance.width > 0 && i.instance.height > 0);
-			let green = green.filter(|i| i.instance.width > 0 && i.instance.height > 0);
-			let blue = blue.filter(|i| i.instance.width > 0 && i.instance.height > 0);
-			let alpha = alpha.filter(|i| i.instance.width > 0 && i.instance.height > 0);
+			// 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 instance's transform and alpha blending mode from the first non-empty channel
-			let Some((transform, alpha_blending)) = [&red, &green, &blue, &alpha].iter().find_map(|i| i.as_ref()).map(|i| (i.transform, i.alpha_blending)) else {
-				return None;
-			};
+			// 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.instance.width, r.instance.height)),
-				green.as_ref().map(|g| (g.instance.width, g.instance.height)),
-				blue.as_ref().map(|b| (b.instance.width, b.instance.height)),
-				alpha.as_ref().map(|a| (a.instance.width, a.instance.height)),
+				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
@@ -143,11 +142,9 @@ pub fn combine_channels(
 			{
 				return None;
 			}
-			let Some(&(width, height)) = channel_dimensions.iter().flatten().next() else {
-				return None;
-			};
+			let &(width, height) = channel_dimensions.iter().flatten().next()?;
 
-			// Create a new image for this instance output
+			// 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
@@ -155,22 +152,22 @@ pub fn combine_channels(
 				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.instance.get_pixel(x, y)) {
+					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.instance.get_pixel(x, y)) {
+					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.instance.get_pixel(x, y)) {
+					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.instance.get_pixel(x, y)) {
+					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.));
@@ -178,12 +175,12 @@ pub fn combine_channels(
 				}
 			}
 
-			Some(Instance {
-				instance: Raster::new_cpu(image),
+			Some(TableRow {
+				element: Raster::new_cpu(image),
 				mask: None,
 				transform,
 				alpha_blending,
-				source_node_id: None,
+				source_node_id,
 			})
 		})
 		.collect()
@@ -194,102 +191,62 @@ pub fn mask<T, E>(
 	_: impl Ctx,
 	/// The image to be masked.
 	#[implementations(
-		VectorDataTable,
-		VectorDataTable,
-		VectorDataTable,
-		RasterDataTable<CPU>,
-		RasterDataTable<CPU>,
-		RasterDataTable<CPU>,
-		GraphicGroupTable,
-		GraphicGroupTable,
-		GraphicGroupTable
+        Table<Vector>,
+        Table<Graphic>,
+        Table<Raster<CPU>>,
+        Table<Vector>,
+        Table<Graphic>,
+        Table<Raster<CPU>>,
+        Table<Vector>,
+        Table<Graphic>,
+        Table<Raster<CPU>>,
 	)]
-	mut image: Instances<T>,
-	/// The stencil to be used for masking.
+	mut image: Table<T>,
+
 	#[expose]
 	#[implementations(
-		VectorDataTable,
-		RasterDataTable<CPU>,
-		GraphicGroupTable,
-		VectorDataTable,
-		RasterDataTable<CPU>,
-		GraphicGroupTable,
-		VectorDataTable,
-		RasterDataTable<CPU>,
-		GraphicGroupTable
+        Table<Vector>,
+        Table<Vector>,
+        Table<Vector>,
+        Table<Graphic>,
+        Table<Graphic>,
+        Table<Graphic>,
+        Table<Raster<CPU>>,
+        Table<Raster<CPU>>,
+        Table<Raster<CPU>>,
 	)]
-	stencil: Instances<E>,
-) -> Instances<T>
+	stencil: Table<E>,
+) -> Table<T>
 where
-	Instances<E>: Into<GraphicElement> + Clone,
+	Table<E>: Into<Graphic> + Clone,
 {
-	for instance in image.instance_mut_iter() {
+	for instance in image.iter_mut() {
 		*instance.mask = Some(stencil.clone().into());
 	}
 	image
 }
 
 // TODO: Use as in-place raster modifier
-fn _mask_lambda(image: RasterDataTable<CPU>, stencil: RasterDataTable<CPU>) -> RasterDataTable<CPU> {
-	// TODO: Support multiple stencil instances
-	let Some(stencil_instance) = stencil.instance_iter().next() else {
-		// No stencil provided so we return the original image
-		return image;
-	};
-	let stencil_size = DVec2::new(stencil_instance.instance.width as f64, stencil_instance.instance.height as f64);
-
-	image
-		.instance_iter()
-		.filter_map(|mut image_instance| {
-			let image_size = DVec2::new(image_instance.instance.width as f64, image_instance.instance.height as f64);
-			let mask_size = stencil_instance.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 = image_instance.transform * DAffine2::from_scale(1. / image_size);
-			let stencil_transform_inverse = stencil_instance.transform.inverse();
-
-			for y in 0..image_instance.instance.height {
-				for x in 0..image_instance.instance.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_instance.transform.transform_point2(local_mask_point.clamp(DVec2::ZERO, DVec2::ONE));
-					let mask_point = (DAffine2::from_scale(stencil_size) * stencil_instance.transform.inverse()).transform_point2(mask_point);
-
-					let image_pixel = image_instance.instance.data_mut().get_pixel_mut(x, y).unwrap();
-					let mask_pixel = stencil_instance.instance.sample(mask_point);
-					*image_pixel = image_pixel.multiplied_alpha(mask_pixel.l().cast_linear_channel());
-				}
-			}
-
-			Some(image_instance)
-		})
-		.collect()
-}
 
 #[node_macro::node(category(""))]
-pub fn extend_image_to_bounds(_: impl Ctx, image: RasterDataTable<CPU>, bounds: DAffine2) -> RasterDataTable<CPU> {
+pub fn extend_image_to_bounds(_: impl Ctx, image: Table<Raster<CPU>>, bounds: DAffine2) -> Table<Raster<CPU>> {
 	image
-		.instance_iter()
-		.map(|mut image_instance| {
-			let image_aabb = Bbox::unit().affine_transform(image_instance.transform).to_axis_aligned_bbox();
+		.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 image_instance;
+				return row;
 			}
 
-			let image_data = &image_instance.instance.data;
-			let (image_width, image_height) = (image_instance.instance.width, image_instance.instance.height);
+			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, Color::TRANSPARENT).instance_iter().next().unwrap();
+				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) * image_instance.transform.inverse();
+			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);
@@ -309,27 +266,27 @@ pub fn extend_image_to_bounds(_: impl Ctx, image: RasterDataTable<CPU>, bounds:
 
 			// 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 = image_instance.transform * DAffine2::from_scale(1. / orig_image_scale) * DAffine2::from_translation(new_start) * DAffine2::from_scale(new_scale);
+			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);
 
-			image_instance.instance = Raster::new_cpu(new_image);
-			image_instance.transform = new_texture_to_layer_space;
-			image_instance.source_node_id = None;
-			image_instance
+			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: Color) -> RasterDataTable<CPU> {
+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 image = Image::new(width, height, color);
+	let color: Option<Color> = color.into();
+	let image = Image::new(width, height, color.unwrap_or(Color::WHITE));
 
-	let mut result_table = RasterDataTable::new(Raster::new_cpu(image));
-	let image_instance = result_table.get_mut(0).unwrap();
-	*image_instance.transform = transform;
-	*image_instance.alpha_blending = AlphaBlending::default();
+	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
@@ -337,7 +294,7 @@ pub fn empty_image(_: impl Ctx, transform: DAffine2, color: Color) -> RasterData
 
 /// Constructs a raster image.
 #[node_macro::node(category(""))]
-pub fn image_value(_: impl Ctx, _primary: (), image: RasterDataTable<CPU>) -> RasterDataTable<CPU> {
+pub fn image_value(_: impl Ctx, _primary: (), image: Table<Raster<CPU>>) -> Table<Raster<CPU>> {
 	image
 }
 
@@ -361,7 +318,7 @@ pub fn noise_pattern(
 	cellular_distance_function: CellularDistanceFunction,
 	cellular_return_type: CellularReturnType,
 	cellular_jitter: f64,
-) -> RasterDataTable<CPU> {
+) -> Table<Raster<CPU>> {
 	let footprint = ctx.footprint();
 	let viewport_bounds = footprint.viewport_bounds_in_local_space();
 
@@ -379,7 +336,7 @@ pub fn noise_pattern(
 
 	// If the image would not be visible, return an empty image
 	if size.x <= 0. || size.y <= 0. {
-		return RasterDataTable::default();
+		return Table::new();
 	}
 
 	let footprint_scale = footprint.scale();
@@ -423,8 +380,8 @@ pub fn noise_pattern(
 				}
 			}
 
-			return RasterDataTable::new_instance(Instance {
-				instance: Raster::new_cpu(image),
+			return Table::new_from_row(TableRow {
+				element: Raster::new_cpu(image),
 				transform: DAffine2::from_translation(offset) * DAffine2::from_scale(size),
 				..Default::default()
 			});
@@ -485,15 +442,15 @@ pub fn noise_pattern(
 		}
 	}
 
-	RasterDataTable::new_instance(Instance {
-		instance: Raster::new_cpu(image),
+	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) -> RasterDataTable<CPU> {
+pub fn mandelbrot(ctx: impl ExtractFootprint + Send) -> Table<Raster<CPU>> {
 	let footprint = ctx.footprint();
 	let viewport_bounds = footprint.viewport_bounds_in_local_space();
 
@@ -505,7 +462,7 @@ pub fn mandelbrot(ctx: impl ExtractFootprint + Send) -> RasterDataTable<CPU> {
 
 	// If the image would not be visible, return an empty image
 	if size.x <= 0. || size.y <= 0. {
-		return RasterDataTable::default();
+		return Table::new();
 	}
 
 	let scale = footprint.scale();
@@ -527,8 +484,8 @@ pub fn mandelbrot(ctx: impl ExtractFootprint + Send) -> RasterDataTable<CPU> {
 		}
 	}
 
-	RasterDataTable::new_instance(Instance {
-		instance: Raster::new_cpu(Image {
+	Table::new_from_row(TableRow {
+		element: Raster::new_cpu(Image {
 			width,
 			height,
 			data,