Implement dynamic table attributes to generalize the graphic-specific Table type (#4050)

* Feature-gate serde derives behind cfg_attr in all runtime node graph type crates * Refactor Table to move its hard-coded fields into an attributes field * Encapsulate TableRow/TableRowRef/TableRowMut attribute fields behind accessor methods * Remove TaggedValue::GraphicUnused * Refactor Table<T> to use dynamic attributes instead fixed names * Fix code review soundness concerns * Add todo work * Replace row-oriented Table<T> API with column-oriented access * Fix attribute propagation bugs ---------
2026-09-15 22:28:10 +08:00 · 2026-04-28 02:10:24 -07:00
parent 324b9e664c
commit 76938eb69a
75 changed files with 2330 additions and 1349 deletions
--- a/node-graph/nodes/raster/Cargo.toml
+++ b/node-graph/nodes/raster/Cargo.toml
@@ -11,8 +11,10 @@ workspace = true

 [features]
 default = ["std"]
+serde = ["dep:serde", "core-types?/serde", "raster-types?/serde", "vector-types?/serde"]
 shader-nodes = ["std", "dep:raster-nodes-shaders", "dep:wgpu-executor"]
 std = [
+	"serde",
 	"dep:core-types",
 	"dep:dyn-any",
 	"dep:graphene-hash",
@@ -23,7 +25,6 @@ std = [
 	"dep:rand",
 	"dep:rand_chacha",
 	"dep:fastnoise-lite",
-	"dep:serde",
 	"dep:kurbo",
 ]
 wasm = [
--- a/node-graph/nodes/raster/src/adjust.rs
+++ b/node-graph/nodes/raster/src/adjust.rs
@@ -18,8 +18,8 @@ mod adjust_std {

 	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() {
+			for element in self.iter_element_values_mut() {
+				for color in element.data_mut().data.iter_mut() {
 					*color = map_fn(color);
 				}
 			}
@@ -27,15 +27,15 @@ mod adjust_std {
 	}
 	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);
+			for element in self.iter_element_values_mut() {
+				*element = map_fn(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);
+			for element in self.iter_element_values_mut() {
+				element.adjust(&map_fn);
 			}
 		}
 	}
--- a/node-graph/nodes/raster/src/adjustments.rs
+++ b/node-graph/nodes/raster/src/adjustments.rs
@@ -34,7 +34,8 @@ use vector_types::GradientStops;
 // https://www.adobe.com/devnet-apps/photoshop/fileformatashtml/#:~:text=Color%20Lookup%20(Photoshop%20CS6

 #[cfg_attr(feature = "wasm", derive(tsify::Tsify))]
-#[cfg_attr(feature = "std", derive(dyn_any::DynAny, serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "std", derive(dyn_any::DynAny))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[derive(Debug, Default, Clone, Copy, Eq, PartialEq, Hash, node_macro::ChoiceType, bytemuck::NoUninit, BufferStruct, FromPrimitive, IntoPrimitive)]
 #[widget(Dropdown)]
 #[repr(u32)]
@@ -565,7 +566,8 @@ fn vibrance<T: Adjust<Color>>(

 #[repr(u32)]
 #[cfg_attr(feature = "wasm", derive(tsify::Tsify))]
-#[cfg_attr(feature = "std", derive(dyn_any::DynAny, serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "std", derive(dyn_any::DynAny))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, node_macro::ChoiceType, BufferStruct, FromPrimitive, IntoPrimitive)]
 #[widget(Radio)]
 pub enum RedGreenBlue {
@@ -576,7 +578,8 @@ pub enum RedGreenBlue {
 }

 #[cfg_attr(feature = "wasm", derive(tsify::Tsify))]
-#[cfg_attr(feature = "std", derive(dyn_any::DynAny, serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "std", derive(dyn_any::DynAny))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, node_macro::ChoiceType, bytemuck::NoUninit, BufferStruct, FromPrimitive, IntoPrimitive)]
 #[widget(Radio)]
 #[repr(u32)]
@@ -590,7 +593,8 @@ pub enum RedGreenBlueAlpha {

 /// Style of noise pattern.
 #[cfg_attr(feature = "wasm", derive(tsify::Tsify))]
-#[cfg_attr(feature = "std", derive(dyn_any::DynAny, serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "std", derive(dyn_any::DynAny))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, node_macro::ChoiceType)]
 #[widget(Dropdown)]
 pub enum NoiseType {
@@ -608,7 +612,8 @@ pub enum NoiseType {

 /// Style of layered levels of the noise pattern.
 #[cfg_attr(feature = "wasm", derive(tsify::Tsify))]
-#[cfg_attr(feature = "std", derive(dyn_any::DynAny, serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "std", derive(dyn_any::DynAny))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, node_macro::ChoiceType)]
 pub enum FractalType {
 	#[default]
@@ -625,7 +630,8 @@ pub enum FractalType {

 /// Distance function used by the cellular noise.
 #[cfg_attr(feature = "wasm", derive(tsify::Tsify))]
-#[cfg_attr(feature = "std", derive(dyn_any::DynAny, serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "std", derive(dyn_any::DynAny))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, node_macro::ChoiceType)]
 pub enum CellularDistanceFunction {
 	#[default]
@@ -637,7 +643,8 @@ pub enum CellularDistanceFunction {
 }

 #[cfg_attr(feature = "wasm", derive(tsify::Tsify))]
-#[cfg_attr(feature = "std", derive(dyn_any::DynAny, serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "std", derive(dyn_any::DynAny))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, node_macro::ChoiceType)]
 pub enum CellularReturnType {
 	CellValue,
@@ -657,7 +664,8 @@ pub enum CellularReturnType {
 }

 #[cfg_attr(feature = "wasm", derive(tsify::Tsify))]
-#[cfg_attr(feature = "std", derive(dyn_any::DynAny, serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "std", derive(dyn_any::DynAny))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, node_macro::ChoiceType)]
 #[widget(Dropdown)]
 pub enum DomainWarpType {
@@ -771,7 +779,8 @@ fn channel_mixer<T: Adjust<Color>>(

 #[repr(u32)]
 #[cfg_attr(feature = "wasm", derive(tsify::Tsify))]
-#[cfg_attr(feature = "std", derive(dyn_any::DynAny, serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "std", derive(dyn_any::DynAny))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, node_macro::ChoiceType, BufferStruct, FromPrimitive, IntoPrimitive)]
 #[widget(Radio)]
 pub enum RelativeAbsolute {
@@ -782,7 +791,8 @@ pub enum RelativeAbsolute {

 #[repr(u32)]
 #[cfg_attr(feature = "wasm", derive(tsify::Tsify))]
-#[cfg_attr(feature = "std", derive(dyn_any::DynAny, serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "std", derive(dyn_any::DynAny))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, node_macro::ChoiceType, BufferStruct, FromPrimitive, IntoPrimitive)]
 pub enum SelectiveColorChoice {
 	#[default]
--- a/node-graph/nodes/raster/src/blending_nodes.rs
+++ b/node-graph/nodes/raster/src/blending_nodes.rs
@@ -30,13 +30,17 @@ mod blend_std {
 	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();
+			let pair_count = result_table.len().min(under.len());
+			for index in 0..pair_count {
+				let Some(over) = result_table.element(index) else { break };
+				let Some(under_element) = under.element(index) else { break };
+				let data = over.data.iter().zip(under_element.data.iter()).map(|(a, b)| blend_fn(*a, *b)).collect();
+				let (width, height) = (over.width, over.height);

-				*over.element = Raster::new_cpu(Image {
+				*result_table.element_mut(index).unwrap() = Raster::new_cpu(Image {
 					data,
-					width: over.element.width,
-					height: over.element.height,
+					width,
+					height,
 					base64_string: None,
 				});
 			}
@@ -46,8 +50,12 @@ mod blend_std {
 	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);
+			let pair_count = result_table.len().min(under.len());
+			for index in 0..pair_count {
+				let Some(over) = result_table.element(index) else { break };
+				let Some(under_element) = under.element(index) else { break };
+				let new_val = blend_fn(*over, *under_element);
+				*result_table.element_mut(index).unwrap() = new_val;
 			}
 			result_table
 		}
@@ -55,8 +63,12 @@ mod blend_std {
 	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);
+			let pair_count = result_table.len().min(under.len());
+			for index in 0..pair_count {
+				let Some(over) = result_table.element(index) else { break };
+				let Some(under_element) = under.element(index) else { break };
+				let new_val = over.blend(under_element, &blend_fn);
+				*result_table.element_mut(index).unwrap() = new_val;
 			}
 			result_table
 		}
@@ -201,7 +213,7 @@ mod test {
 		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;
+		let result = result.element(0).unwrap().clone();

 		// 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()));
--- a/node-graph/nodes/raster/src/curve.rs
+++ b/node-graph/nodes/raster/src/curve.rs
@@ -4,13 +4,14 @@ use dyn_any::{DynAny, StaticType, StaticTypeSized};
 use std::ops::{Add, Mul, Sub};

 #[cfg_attr(feature = "wasm", derive(tsify::Tsify))]
-#[derive(Debug, Clone, PartialEq, core_types::CacheHash, DynAny, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone, PartialEq, core_types::CacheHash, DynAny)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Curve {
-	#[serde(rename = "manipulatorGroups")]
+	#[cfg_attr(feature = "serde", serde(rename = "manipulatorGroups"))]
 	pub manipulator_groups: Vec<CurveManipulatorGroup>,
-	#[serde(rename = "firstHandle")]
+	#[cfg_attr(feature = "serde", serde(rename = "firstHandle"))]
 	pub first_handle: [f32; 2],
-	#[serde(rename = "lastHandle")]
+	#[cfg_attr(feature = "serde", serde(rename = "lastHandle"))]
 	pub last_handle: [f32; 2],
 }

@@ -25,7 +26,8 @@ impl Default for Curve {
 }

 #[cfg_attr(feature = "wasm", derive(tsify::Tsify))]
-#[derive(Debug, Clone, Copy, PartialEq, core_types::CacheHash, DynAny, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone, Copy, PartialEq, core_types::CacheHash, DynAny)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct CurveManipulatorGroup {
 	pub anchor: [f32; 2],
 	pub handles: [[f32; 2]; 2],
--- a/node-graph/nodes/raster/src/dehaze.rs
+++ b/node-graph/nodes/raster/src/dehaze.rs
@@ -12,7 +12,7 @@ async fn dehaze(_: impl Ctx, image_frame: Table<Raster<CPU>>, strength: Percenta
 	image_frame
 		.into_iter()
 		.map(|mut row| {
-			let image = row.element;
+			let image = std::mem::replace(row.element_mut(), Raster::new_cpu(Image::default()));
 			// 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.");
@@ -31,7 +31,7 @@ async fn dehaze(_: impl Ctx, image_frame: Table<Raster<CPU>>, strength: Percenta
 				base64_string: None,
 			};

-			row.element = Raster::new_cpu(dehazed_image);
+			*row.element_mut() = Raster::new_cpu(dehazed_image);
 			row
 		})
 		.collect()
--- a/node-graph/nodes/raster/src/filter.rs
+++ b/node-graph/nodes/raster/src/filter.rs
@@ -24,7 +24,7 @@ async fn blur(
 	image_frame
 		.into_iter()
 		.map(|mut row| {
-			let image = row.element.clone();
+			let image = row.element().clone();

 			// Run blur algorithm
 			let blurred_image = if radius < 0.1 {
@@ -36,7 +36,7 @@ async fn blur(
 				Raster::new_cpu(gaussian_blur_algorithm(image.into_data(), radius, gamma))
 			};

-			row.element = blurred_image;
+			*row.element_mut() = blurred_image;
 			row
 		})
 		.collect()
@@ -56,7 +56,7 @@ async fn median_filter(
 	image_frame
 		.into_iter()
 		.map(|mut row| {
-			let image = row.element.clone();
+			let image = row.element().clone();

 			// Apply median filter
 			let filtered_image = if radius < 0.5 {
@@ -66,7 +66,7 @@ async fn median_filter(
 				Raster::new_cpu(median_filter_algorithm(image.into_data(), radius as u32))
 			};

-			row.element = filtered_image;
+			*row.element_mut() = filtered_image;
 			row
 		})
 		.collect()
--- a/node-graph/nodes/raster/src/gradient_map.rs
+++ b/node-graph/nodes/raster/src/gradient_map.rs
@@ -21,12 +21,12 @@ async fn gradient_map<T: Adjust<Color>>(
 	gradient: Table<GradientStops>,
 	reverse: bool,
 ) -> T {
-	let Some(row) = gradient.get(0) else { return image };
+	let Some(gradient) = gradient.element(0) else { return image };

 	image.adjust(|color| {
 		let intensity = color.luminance_srgb();
 		let intensity = if reverse { 1. - intensity } else { intensity };
-		row.element.evaluate(intensity as f64).to_linear_srgb()
+		gradient.evaluate(intensity as f64).to_linear_srgb()
 	});

 	image
--- a/node-graph/nodes/raster/src/image_color_palette.rs
+++ b/node-graph/nodes/raster/src/image_color_palette.rs
@@ -18,8 +18,8 @@ async fn image_color_palette(
 	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() {
+	for element in image.iter_element_values() {
+		for pixel in element.data.iter() {
 			let r = pixel.r() * GRID;
 			let g = pixel.g() * GRID;
 			let b = pixel.b() * GRID;
--- a/node-graph/nodes/raster/src/std_nodes.rs
+++ b/node-graph/nodes/raster/src/std_nodes.rs
@@ -33,9 +33,9 @@ impl From<std::io::Error> for Error {
 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;
+		.filter_map(|row| {
+			let image_frame_transform: DAffine2 = row.attribute_cloned_or_default("transform");
+			let (image, mut attributes) = row.into_parts();

 			// Resize the image using the image crate
 			let data = bytemuck::cast_vec(image.data.clone());
@@ -86,10 +86,9 @@ pub fn sample_image(ctx: impl ExtractFootprint + Clone + Send, image_frame: Tabl
 			// 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);
+			attributes.insert("transform", new_transform);

-			row.transform = new_transform;
-			row.element = Raster::new_cpu(image);
-			Some(row)
+			Some(TableRow::from_parts(Raster::new_cpu(image), attributes))
 		})
 		.collect()
 }
@@ -114,23 +113,20 @@ pub fn combine_channels(
 		.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);
+			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))?;
+			let attributes = [&red, &green, &blue, &alpha].iter().find_map(|i| i.as_ref()).map(|i| i.attributes().clone())?;

 			// 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)),
+				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
@@ -150,22 +146,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.element.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.element.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.element.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.element.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.));
@@ -173,12 +169,7 @@ pub fn combine_channels(
 				}
 			}

-			Some(TableRow {
-				element: Raster::new_cpu(image),
-				transform,
-				alpha_blending,
-				source_node_id,
-			})
+			Some(TableRow::from_parts(Raster::new_cpu(image), attributes))
 		})
 		.collect()
 }
@@ -197,32 +188,34 @@ pub fn mask(
 		// 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);
+	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.scale_magnitudes();
+			let image_size = DVec2::new(row.element().width as f64, row.element().height as f64);
+			let stencil_transform: DAffine2 = stencil.attribute_cloned_or_default("transform");
+			let mask_size = stencil_transform.scale_magnitudes();

 			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();
+			let transform_attribute: DAffine2 = row.attribute_cloned_or_default("transform");
+			let bg_to_fg = transform_attribute * 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 {
+			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 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);
+					let image_pixel = row.element_mut().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());
 				}
 			}
@@ -237,20 +230,21 @@ pub fn extend_image_to_bounds(_: impl Ctx, image: Table<Raster<CPU>>, bounds: DA
 	image
 		.into_iter()
 		.map(|mut row| {
-			let image_aabb = Bbox::unit().affine_transform(row.transform).to_axis_aligned_bbox();
+			let row_transform: DAffine2 = row.attribute_cloned_or_default("transform");
+			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);
+			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 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);
@@ -270,10 +264,10 @@ pub fn extend_image_to_bounds(_: impl Ctx, image: Table<Raster<CPU>>, bounds: DA

 			// 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);
+			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.element_mut() = Raster::new_cpu(new_image);
+			row.set_attribute("transform", new_texture_to_layer_space);
 			row
 		})
 		.collect()
@@ -284,13 +278,12 @@ pub fn empty_image(_: impl Ctx, transform: DAffine2, color: Table<Color>) -> Tab
 	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 color = color.element(0).copied().unwrap_or(Color::WHITE);
+	let image = Image::new(width, height, color);

 	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();
+	result_table.set_attribute("transform", 0, transform);
+	result_table.set_attribute("alpha_blending", 0, AlphaBlending::default());

 	// Callers of empty_image can safely unwrap on returned table
 	result_table
@@ -383,11 +376,12 @@ pub fn noise_pattern(
 				}
 			}

-			return Table::new_from_row(TableRow {
-				element: Raster::new_cpu(image),
-				transform: DAffine2::from_translation(offset) * DAffine2::from_scale(size),
-				..Default::default()
-			});
+			return Table::new_from_row(
+				TableRow::new_from_element(Raster::new_cpu(image))
+					.with_attribute("transform", DAffine2::from_translation(offset) * DAffine2::from_scale(size))
+					.with_attribute("alpha_blending", AlphaBlending::default())
+					.with_attribute("source_node_id", None::<core_types::uuid::NodeId>),
+			);
 		}
 	};
 	noise.set_noise_type(Some(noise_type));
@@ -445,11 +439,12 @@ pub fn noise_pattern(
 		}
 	}

-	Table::new_from_row(TableRow {
-		element: Raster::new_cpu(image),
-		transform: DAffine2::from_translation(offset) * DAffine2::from_scale(size),
-		..Default::default()
-	})
+	Table::new_from_row(
+		TableRow::new_from_element(Raster::new_cpu(image))
+			.with_attribute("transform", DAffine2::from_translation(offset) * DAffine2::from_scale(size))
+			.with_attribute("alpha_blending", AlphaBlending::default())
+			.with_attribute("source_node_id", None::<core_types::uuid::NodeId>),
+	)
 }

 #[node_macro::node(category("Raster: Pattern"))]
@@ -487,16 +482,17 @@ pub fn mandelbrot(ctx: impl ExtractFootprint + Send) -> Table<Raster<CPU>> {
 		}
 	}

-	Table::new_from_row(TableRow {
-		element: Raster::new_cpu(Image {
+	Table::new_from_row(
+		TableRow::new_from_element(Raster::new_cpu(Image {
 			width,
 			height,
 			data,
 			..Default::default()
-		}),
-		transform: DAffine2::from_translation(offset) * DAffine2::from_scale(size),
-		..Default::default()
-	})
+		}))
+		.with_attribute("transform", DAffine2::from_translation(offset) * DAffine2::from_scale(size))
+		.with_attribute("alpha_blending", AlphaBlending::default())
+		.with_attribute("source_node_id", None::<core_types::uuid::NodeId>),
+	)
 }

 #[inline(always)]