Instance tables refactor part 7: Rename "ImageFrame" -> "RasterData", "ImageFrameTable" -> "RasterDataType", and "RasterFrame" -> "RasterDataType"

2026-09-16 06:38:03 +08:00 · 2025-06-15 16:54:40 -07:00
parent 2696abc6b3
commit 5cacab2e39
34 changed files with 285 additions and 281 deletions
--- a/node-graph/gstd/src/brush.rs
+++ b/node-graph/gstd/src/brush.rs
@@ -6,7 +6,7 @@ use graphene_core::instances::Instance;
 use graphene_core::raster::adjustments::blend_colors;
 use graphene_core::raster::bbox::{AxisAlignedBbox, Bbox};
 use graphene_core::raster::brush_cache::BrushCache;
-use graphene_core::raster::image::{Image, ImageFrameTable};
+use graphene_core::raster::image::{Image, RasterDataTable};
 use graphene_core::raster::{Alpha, BitmapMut, BlendMode, Color, Pixel, Sample};
 use graphene_core::renderer::GraphicElementRendered;
 use graphene_core::transform::Transform;
@@ -80,7 +80,7 @@ fn brush_stamp_generator(diameter: f64, color: Color, hardness: f64, flow: f64)
 }

 #[node_macro::node(skip_impl)]
-fn blit<P, BlendFn>(mut target: ImageFrameTable<P>, texture: Image<P>, positions: Vec<DVec2>, blend_mode: BlendFn) -> ImageFrameTable<P>
+fn blit<P, BlendFn>(mut target: RasterDataTable<P>, texture: Image<P>, positions: Vec<DVec2>, blend_mode: BlendFn) -> RasterDataTable<P>
 where
 	P: Pixel + Alpha + std::fmt::Debug,
 	BlendFn: for<'any_input> Node<'any_input, (P, P), Output = P>,
@@ -184,10 +184,10 @@ pub fn blend_with_mode(background: Instance<Image<Color>>, foreground: Instance<
 }

 #[node_macro::node(category("Raster"))]
-async fn brush(_: impl Ctx, mut image_frame_table: ImageFrameTable<Color>, strokes: Vec<BrushStroke>, cache: BrushCache) -> ImageFrameTable<Color> {
+async fn brush(_: impl Ctx, mut image_frame_table: RasterDataTable<Color>, strokes: Vec<BrushStroke>, cache: BrushCache) -> RasterDataTable<Color> {
 	// TODO: Find a way to handle more than one instance
 	let Some(image_frame_instance) = image_frame_table.instance_ref_iter().next() else {
-		return ImageFrameTable::default();
+		return RasterDataTable::default();
 	};
 	let image_frame_instance = image_frame_instance.to_instance_cloned();

@@ -204,7 +204,7 @@ async fn brush(_: impl Ctx, mut image_frame_table: ImageFrameTable<Color>, strok

 	// TODO: Find a way to handle more than one instance
 	let Some(mut actual_image) = extend_image_to_bounds((), brush_plan.background.to_table(), background_bounds).instance_iter().next() else {
-		return ImageFrameTable::default();
+		return RasterDataTable::default();
 	};

 	let final_stroke_idx = brush_plan.strokes.len().saturating_sub(1);
@@ -397,7 +397,7 @@ mod test {
 	async fn test_brush_output_size() {
 		let image = brush(
 			(),
-			ImageFrameTable::<Color>::new(Image::<Color>::default()),
+			RasterDataTable::<Color>::new(Image::<Color>::default()),
 			vec![BrushStroke {
 				trace: vec![crate::vector::brush_stroke::BrushInputSample { position: DVec2::ZERO }],
 				style: BrushStyle {
--- a/node-graph/gstd/src/dehaze.rs
+++ b/node-graph/gstd/src/dehaze.rs
@@ -1,13 +1,13 @@
 use graph_craft::proto::types::Percentage;
-use graphene_core::raster::image::{Image, ImageFrameTable};
+use graphene_core::raster::image::{Image, RasterDataTable};
 use graphene_core::{Color, Ctx};
 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"))]
-async fn dehaze(_: impl Ctx, image_frame: ImageFrameTable<Color>, strength: Percentage) -> ImageFrameTable<Color> {
-	let mut result_table = ImageFrameTable::default();
+async fn dehaze(_: impl Ctx, image_frame: RasterDataTable<Color>, strength: Percentage) -> RasterDataTable<Color> {
+	let mut result_table = RasterDataTable::default();

 	for mut image_frame_instance in image_frame.instance_iter() {
 		let image = image_frame_instance.instance;
--- a/node-graph/gstd/src/filter.rs
+++ b/node-graph/gstd/src/filter.rs
@@ -1,5 +1,5 @@
 use graph_craft::proto::types::PixelLength;
-use graphene_core::raster::image::{Image, ImageFrameTable};
+use graphene_core::raster::image::{Image, RasterDataTable};
 use graphene_core::raster::{Bitmap, BitmapMut};
 use graphene_core::{Color, Ctx};

@@ -8,7 +8,7 @@ use graphene_core::{Color, Ctx};
 async fn blur(
 	_: impl Ctx,
 	/// The image to be blurred.
-	image_frame: ImageFrameTable<Color>,
+	image_frame: RasterDataTable<Color>,
 	/// The radius of the blur kernel.
 	#[range((0., 100.))]
 	#[hard_min(0.)]
@@ -17,8 +17,8 @@ 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,
-) -> ImageFrameTable<Color> {
-	let mut result_table = ImageFrameTable::default();
+) -> RasterDataTable<Color> {
+	let mut result_table = RasterDataTable::default();

 	for mut image_instance in image_frame.instance_iter() {
 		let image = image_instance.instance.clone();
--- a/node-graph/gstd/src/gpu_nodes.rs
+++ b/node-graph/gstd/src/gpu_nodes.rs
@@ -4,7 +4,7 @@ use graph_craft::document::value::TaggedValue;
 use graph_craft::document::*;
 use graph_craft::proto::*;
 use graphene_core::raster::BlendMode;
-use graphene_core::raster::image::{Image, ImageFrameTable};
+use graphene_core::raster::image::{Image, RasterDataTable};
 use graphene_core::*;
 use std::sync::Arc;
 use wgpu_executor::{Bindgroup, PipelineLayout, Shader, ShaderIO, ShaderInput, WgpuExecutor};
@@ -34,8 +34,8 @@ async fn compile_gpu<'a: 'n>(_: impl Ctx, node: &'a DocumentNode, typing_context
 }

 #[node_macro::node(category("Debug: GPU"))]
-async fn blend_gpu_image(_: impl Ctx, foreground: ImageFrameTable<Color>, background: ImageFrameTable<Color>, blend_mode: BlendMode, opacity: f64) -> ImageFrameTable<Color> {
-	let mut result_table = ImageFrameTable::default();
+async fn blend_gpu_image(_: impl Ctx, foreground: RasterDataTable<Color>, background: RasterDataTable<Color>, blend_mode: BlendMode, opacity: f64) -> RasterDataTable<Color> {
+	let mut result_table = RasterDataTable::default();

 	for (foreground_instance, mut background_instance) in foreground.instance_iter().zip(background.instance_iter()) {
 		let foreground_transform = foreground_instance.transform;
@@ -95,7 +95,7 @@ async fn blend_gpu_image(_: impl Ctx, foreground: ImageFrameTable<Color>, backgr
 		let proto_networks: Result<Vec<_>, _> = compiler.compile(network.clone()).collect();
 		let Ok(proto_networks_result) = proto_networks else {
 			log::error!("Error compiling network in 'blend_gpu_image()");
-			return ImageFrameTable::default();
+			return RasterDataTable::default();
 		};
 		let proto_networks = proto_networks_result;
 		log::debug!("compiling shader");
@@ -241,7 +241,7 @@ async fn blend_gpu_image(_: impl Ctx, foreground: ImageFrameTable<Color>, backgr
 // }

 // #[node_macro::old_node_impl(MapGpuNode)]
-// async fn map_gpu<'a: 'input>(image: ImageFrameTable<Color>, node: DocumentNode, editor_api: &'a graphene_core::application_io::EditorApi<WasmApplicationIo>) -> ImageFrameTable<Color> {
+// async fn map_gpu<'a: 'input>(image: RasterDataTable<Color>, node: DocumentNode, editor_api: &'a graphene_core::application_io::EditorApi<WasmApplicationIo>) -> RasterDataTable<Color> {
 // 	let image_frame_table = &image;
 // 	let image = image.instance_ref_iter().next().unwrap().instance;

@@ -258,7 +258,7 @@ async fn blend_gpu_image(_: impl Ctx, foreground: ImageFrameTable<Color>, backgr
 // 		let name = "placeholder".to_string();
 // 		let Ok(compute_pass_descriptor) = create_compute_pass_descriptor(node, image_frame_table, executor).await else {
 // 			log::error!("Error creating compute pass descriptor in 'map_gpu()");
-// 			return ImageFrameTable::default();
+// 			return RasterDataTable::default();
 // 		};
 // 		self.cache.lock().as_mut().unwrap().insert(name, compute_pass_descriptor.clone());
 // 		log::error!("created compute pass");
@@ -292,7 +292,7 @@ async fn blend_gpu_image(_: impl Ctx, foreground: ImageFrameTable<Color>, backgr
 // 		height: image.height,
 // 		..Default::default()
 // 	};
-// 	let mut result = ImageFrameTable::new(new_image);
+// 	let mut result = RasterDataTable::new(new_image);
 // 	*result.transform_mut() = image_frame_table.transform();
 // 	*result.instance_mut_iter().next().unwrap().alpha_blending = *image_frame_table.instance_ref_iter().next().unwrap().alpha_blending;

@@ -309,7 +309,7 @@ async fn blend_gpu_image(_: impl Ctx, foreground: ImageFrameTable<Color>, backgr
 // 	}
 // }

-// async fn create_compute_pass_descriptor<T: Clone + Pixel + StaticTypeSized>(node: DocumentNode, image: &ImageFrameTable<T>, executor: &&WgpuExecutor) -> Result<ComputePass, String>
+// async fn create_compute_pass_descriptor<T: Clone + Pixel + StaticTypeSized>(node: DocumentNode, image: &RasterDataTable<T>, executor: &&WgpuExecutor) -> Result<ComputePass, String>
 // where
 // 	GraphicElement: From<Image<T>>,
 // 	T::Static: Pixel,
--- a/node-graph/gstd/src/image_color_palette.rs
+++ b/node-graph/gstd/src/image_color_palette.rs
@@ -1,10 +1,10 @@
-use graphene_core::raster::image::ImageFrameTable;
+use graphene_core::raster::image::RasterDataTable;
 use graphene_core::{Color, Ctx};

 #[node_macro::node(category("Raster"))]
 async fn image_color_palette(
 	_: impl Ctx,
-	image: ImageFrameTable<Color>,
+	image: RasterDataTable<Color>,
 	#[hard_min(1.)]
 	#[soft_max(28.)]
 	max_size: u32,
@@ -64,13 +64,13 @@ async fn image_color_palette(
 #[cfg(test)]
 mod test {
 	use super::*;
-	use graphene_core::raster::image::{Image, ImageFrameTable};
+	use graphene_core::raster::image::{Image, RasterDataTable};

 	#[test]
 	fn test_image_color_palette() {
 		let result = image_color_palette(
 			(),
-			ImageFrameTable::new(Image {
+			RasterDataTable::new(Image {
 				width: 100,
 				height: 100,
 				data: vec![Color::from_rgbaf32(0., 0., 0., 1.).unwrap(); 10000],
--- a/node-graph/gstd/src/raster.rs
+++ b/node-graph/gstd/src/raster.rs
@@ -3,7 +3,7 @@ use fastnoise_lite;
 use glam::{DAffine2, DVec2, Vec2};
 use graphene_core::instances::Instance;
 use graphene_core::raster::bbox::Bbox;
-use graphene_core::raster::image::{Image, ImageFrameTable};
+use graphene_core::raster::image::{Image, RasterDataTable};
 use graphene_core::raster::{Alpha, AlphaMut, Bitmap, BitmapMut, CellularDistanceFunction, CellularReturnType, Channel, DomainWarpType, FractalType, LinearChannel, Luminance, NoiseType, RGBMut};
 use graphene_core::transform::Transform;
 use graphene_core::{AlphaBlending, Color, Ctx, ExtractFootprint};
@@ -25,8 +25,8 @@ impl From<std::io::Error> for Error {
 }

 #[node_macro::node(category("Debug: Raster"))]
-fn sample_image(ctx: impl ExtractFootprint + Clone + Send, image_frame: ImageFrameTable<Color>) -> ImageFrameTable<Color> {
-	let mut result_table = ImageFrameTable::default();
+fn sample_image(ctx: impl ExtractFootprint + Clone + Send, image_frame: RasterDataTable<Color>) -> RasterDataTable<Color> {
+	let mut result_table = RasterDataTable::default();

 	for mut image_frame_instance in image_frame.instance_iter() {
 		let image_frame_transform = image_frame_instance.transform;
@@ -95,12 +95,12 @@ fn sample_image(ctx: impl ExtractFootprint + Clone + Send, image_frame: ImageFra
 fn combine_channels(
 	_: impl Ctx,
 	_primary: (),
-	#[expose] red: ImageFrameTable<Color>,
-	#[expose] green: ImageFrameTable<Color>,
-	#[expose] blue: ImageFrameTable<Color>,
-	#[expose] alpha: ImageFrameTable<Color>,
-) -> ImageFrameTable<Color> {
-	let mut result_table = ImageFrameTable::default();
+	#[expose] red: RasterDataTable<Color>,
+	#[expose] green: RasterDataTable<Color>,
+	#[expose] blue: RasterDataTable<Color>,
+	#[expose] alpha: RasterDataTable<Color>,
+) -> RasterDataTable<Color> {
+	let mut result_table = RasterDataTable::default();

 	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);
@@ -184,11 +184,11 @@ fn combine_channels(
 fn mask(
 	_: impl Ctx,
 	/// The image to be masked.
-	image: ImageFrameTable<Color>,
+	image: RasterDataTable<Color>,
 	/// The stencil to be used for masking.
 	#[expose]
-	stencil: ImageFrameTable<Color>,
-) -> ImageFrameTable<Color> {
+	stencil: RasterDataTable<Color>,
+) -> RasterDataTable<Color> {
 	// TODO: Support multiple stencil instances
 	let Some(stencil_instance) = stencil.instance_iter().next() else {
 		// No stencil provided so we return the original image
@@ -196,7 +196,7 @@ fn mask(
 	};
 	let stencil_size = DVec2::new(stencil_instance.instance.width as f64, stencil_instance.instance.height as f64);

-	let mut result_table = ImageFrameTable::default();
+	let mut result_table = RasterDataTable::default();

 	for mut image_instance in image.instance_iter() {
 		let image_size = DVec2::new(image_instance.instance.width as f64, image_instance.instance.height as f64);
@@ -231,8 +231,8 @@ fn mask(
 }

 #[node_macro::node(category(""))]
-fn extend_image_to_bounds(_: impl Ctx, image: ImageFrameTable<Color>, bounds: DAffine2) -> ImageFrameTable<Color> {
-	let mut result_table = ImageFrameTable::default();
+fn extend_image_to_bounds(_: impl Ctx, image: RasterDataTable<Color>, bounds: DAffine2) -> RasterDataTable<Color> {
+	let mut result_table = RasterDataTable::default();

 	for mut image_instance in image.instance_iter() {
 		let image_aabb = Bbox::unit().affine_transform(image_instance.transform).to_axis_aligned_bbox();
@@ -284,13 +284,13 @@ fn extend_image_to_bounds(_: impl Ctx, image: ImageFrameTable<Color>, bounds: DA
 }

 #[node_macro::node(category("Debug: Raster"))]
-fn empty_image(_: impl Ctx, transform: DAffine2, color: Color) -> ImageFrameTable<Color> {
+fn empty_image(_: impl Ctx, transform: DAffine2, color: Color) -> RasterDataTable<Color> {
 	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 mut result_table = ImageFrameTable::new(image);
+	let mut result_table = RasterDataTable::new(image);
 	let image_instance = result_table.get_mut(0).unwrap();
 	*image_instance.transform = transform;
 	*image_instance.alpha_blending = AlphaBlending::default();
@@ -301,7 +301,7 @@ fn empty_image(_: impl Ctx, transform: DAffine2, color: Color) -> ImageFrameTabl

 /// Constructs a raster image.
 #[node_macro::node(category(""))]
-fn image(_: impl Ctx, _primary: (), image: ImageFrameTable<Color>) -> ImageFrameTable<Color> {
+fn image(_: impl Ctx, _primary: (), image: RasterDataTable<Color>) -> RasterDataTable<Color> {
 	image
 }

@@ -329,15 +329,15 @@ fn image(_: impl Ctx, _primary: (), image: ImageFrameTable<Color>) -> ImageFrame
 // 			}
 // 		}

-// 		impl<'i, 'e: 'i, P: Pixel + 'i + Hash + Default + Send, E: 'i, C: 'i, G: 'i, $($t: 'i,)*> Node<'i, ImageFrame<P>> for ImaginateNode<P, E, C, G, $($t,)*>
+// 		impl<'i, 'e: 'i, P: Pixel + 'i + Hash + Default + Send, E: 'i, C: 'i, G: 'i, $($t: 'i,)*> Node<'i, RasterData<P>> for ImaginateNode<P, E, C, G, $($t,)*>
 // 		where $($t: for<'any_input> Node<'any_input, (), Output = DynFuture<'any_input, $o>>,)*
 // 			E: for<'any_input> Node<'any_input, (), Output = DynFuture<'any_input, &'e WasmEditorApi>>,
 // 			C: for<'any_input> Node<'any_input, (), Output = DynFuture<'any_input, ImaginateController>>,
 // 			G: for<'any_input> Node<'any_input, (), Output = DynFuture<'any_input, u64>>,
 // 		{
-// 			type Output = DynFuture<'i, ImageFrame<P>>;
+// 			type Output = DynFuture<'i, RasterData<P>>;

-// 			fn eval(&'i self, frame: ImageFrame<P>) -> Self::Output {
+// 			fn eval(&'i self, frame: RasterData<P>) -> Self::Output {
 // 				let controller = self.controller.eval(());
 // 				$(let $val = self.$val.eval(());)*

@@ -369,16 +369,16 @@ fn image(_: impl Ctx, _primary: (), image: ImageFrameTable<Color>) -> ImageFrame
 // 	}
 // }

-// fn wrap_image_frame<P: Pixel>(image: Image<P>, transform: DAffine2) -> ImageFrame<P> {
+// fn wrap_image_frame<P: Pixel>(image: Image<P>, transform: DAffine2) -> RasterData<P> {
 // 	if !transform.decompose_scale().abs_diff_eq(DVec2::ZERO, 0.00001) {
-// 		ImageFrame {
+// 		RasterData {
 // 			image,
 // 			transform,
 // 			alpha_blending: AlphaBlending::default(),
 // 		}
 // 	} else {
 // 		let resolution = DVec2::new(image.height as f64, image.width as f64);
-// 		ImageFrame {
+// 		RasterData {
 // 			image,
 // 			transform: DAffine2::from_scale_angle_translation(resolution, 0., transform.translation),
 // 			alpha_blending: AlphaBlending::default(),
@@ -424,7 +424,7 @@ fn noise_pattern(
 	cellular_distance_function: CellularDistanceFunction,
 	cellular_return_type: CellularReturnType,
 	cellular_jitter: f64,
-) -> ImageFrameTable<Color> {
+) -> RasterDataTable<Color> {
 	let footprint = ctx.footprint();
 	let viewport_bounds = footprint.viewport_bounds_in_local_space();

@@ -442,7 +442,7 @@ fn noise_pattern(

 	// If the image would not be visible, return an empty image
 	if size.x <= 0. || size.y <= 0. {
-		return ImageFrameTable::default();
+		return RasterDataTable::default();
 	}

 	let footprint_scale = footprint.scale();
@@ -486,7 +486,7 @@ fn noise_pattern(
 				}
 			}

-			let mut result = ImageFrameTable::default();
+			let mut result = RasterDataTable::default();
 			result.push(Instance {
 				instance: image,
 				transform: DAffine2::from_translation(offset) * DAffine2::from_scale(size),
@@ -551,7 +551,7 @@ fn noise_pattern(
 		}
 	}

-	let mut result = ImageFrameTable::default();
+	let mut result = RasterDataTable::default();
 	result.push(Instance {
 		instance: image,
 		transform: DAffine2::from_translation(offset) * DAffine2::from_scale(size),
@@ -562,7 +562,7 @@ fn noise_pattern(
 }

 #[node_macro::node(category("Raster"))]
-fn mandelbrot(ctx: impl ExtractFootprint + Send) -> ImageFrameTable<Color> {
+fn mandelbrot(ctx: impl ExtractFootprint + Send) -> RasterDataTable<Color> {
 	let footprint = ctx.footprint();
 	let viewport_bounds = footprint.viewport_bounds_in_local_space();

@@ -574,7 +574,7 @@ fn mandelbrot(ctx: impl ExtractFootprint + Send) -> ImageFrameTable<Color> {

 	// If the image would not be visible, return an empty image
 	if size.x <= 0. || size.y <= 0. {
-		return ImageFrameTable::default();
+		return RasterDataTable::default();
 	}

 	let scale = footprint.scale();
@@ -602,7 +602,7 @@ fn mandelbrot(ctx: impl ExtractFootprint + Send) -> ImageFrameTable<Color> {
 		data,
 		..Default::default()
 	};
-	let mut result = ImageFrameTable::default();
+	let mut result = RasterDataTable::default();
 	result.push(Instance {
 		instance: image,
 		transform: DAffine2::from_translation(offset) * DAffine2::from_scale(size),
--- a/node-graph/gstd/src/vector.rs
+++ b/node-graph/gstd/src/vector.rs
@@ -1,6 +1,6 @@
 use bezier_rs::{ManipulatorGroup, Subpath};
 use glam::{DAffine2, DVec2};
-use graphene_core::RasterFrame;
+use graphene_core::RasterDataType;
 use graphene_core::instances::{Instance, InstanceRef};
 use graphene_core::vector::misc::BooleanOperation;
 use graphene_core::vector::style::Fill;
@@ -203,7 +203,7 @@ fn flatten_vector_data(graphic_group_table: &GraphicGroupTable) -> VectorDataTab
 					result_table.push(sub_vector_data);
 				}
 			}
-			GraphicElement::RasterFrame(image) => {
+			GraphicElement::RasterDataType(image) => {
 				let make_instance = |transform| {
 					// Convert the image frame into a rectangular subpath with the image's transform
 					let mut subpath = Subpath::new_rect(DVec2::ZERO, DVec2::ONE);
@@ -218,12 +218,12 @@ fn flatten_vector_data(graphic_group_table: &GraphicGroupTable) -> VectorDataTab

 				// Apply the parent group's transform to each element of raster data
 				match image {
-					RasterFrame::ImageFrame(image) => {
+					RasterDataType::RasterData(image) => {
 						for instance in image.instance_ref_iter() {
 							result_table.push(make_instance(*element.transform * *instance.transform));
 						}
 					}
-					RasterFrame::TextureFrame(image) => {
+					RasterDataType::TextureData(image) => {
 						for instance in image.instance_ref_iter() {
 							result_table.push(make_instance(*element.transform * *instance.transform));
 						}
--- a/node-graph/gstd/src/wasm_application_io.rs
+++ b/node-graph/gstd/src/wasm_application_io.rs
@@ -8,7 +8,7 @@ use graphene_core::application_io::{ApplicationIo, ExportFormat, RenderConfig};
 use graphene_core::instances::Instances;
 #[cfg(target_arch = "wasm32")]
 use graphene_core::raster::bbox::Bbox;
-use graphene_core::raster::image::{Image, ImageFrameTable};
+use graphene_core::raster::image::{Image, RasterDataTable};
 use graphene_core::renderer::RenderMetadata;
 use graphene_core::renderer::{GraphicElementRendered, RenderParams, RenderSvgSegmentList, SvgRender, format_transform_matrix};
 use graphene_core::transform::Footprint;
@@ -39,7 +39,7 @@ async fn create_surface<'a: 'n>(_: impl Ctx, editor: &'a WasmEditorApi) -> Arc<W
 // #[cfg(target_arch = "wasm32")]
 // async fn draw_image_frame(
 // 	_: impl Ctx,
-// 	image: ImageFrameTable<graphene_core::raster::SRGBA8>,
+// 	image: RasterDataTable<graphene_core::raster::SRGBA8>,
 // 	surface_handle: Arc<WasmSurfaceHandle>,
 // ) -> graphene_core::application_io::SurfaceHandleFrame<HtmlCanvasElement> {
 // 	let image = image.instance_ref_iter().next().unwrap().instance;
@@ -49,9 +49,9 @@ async fn create_surface<'a: 'n>(_: impl Ctx, editor: &'a WasmEditorApi) -> Arc<W
 // 		let canvas = &surface_handle.surface;
 // 		canvas.set_width(image.image.width);
 // 		canvas.set_height(image.image.height);
-// 		// TODO: replace "2d" with "bitmaprenderer" once we switch to ImageBitmap (lives on gpu) from ImageData (lives on cpu)
+// 		// TODO: replace "2d" with "bitmaprenderer" once we switch to ImageBitmap (lives on gpu) from RasterData (lives on cpu)
 // 		let context = canvas.get_context("2d").unwrap().unwrap().dyn_into::<CanvasRenderingContext2d>().unwrap();
-// 		let image_data = web_sys::ImageData::new_with_u8_clamped_array_and_sh(array, image.image.width, image.image.height).expect("Failed to construct ImageData");
+// 		let image_data = web_sys::ImageData::new_with_u8_clamped_array_and_sh(array, image.image.width, image.image.height).expect("Failed to construct RasterData");
 // 		context.put_image_data(&image_data, 0., 0.).unwrap();
 // 	}
 // 	graphene_core::application_io::SurfaceHandleFrame {
@@ -76,9 +76,9 @@ async fn load_resource<'a: 'n>(_: impl Ctx, _primary: (), #[scope("editor-api")]
 }

 #[node_macro::node(category("Network"))]
-fn decode_image(_: impl Ctx, data: Arc<[u8]>) -> ImageFrameTable<Color> {
+fn decode_image(_: impl Ctx, data: Arc<[u8]>) -> RasterDataTable<Color> {
 	let Some(image) = image::load_from_memory(data.as_ref()).ok() else {
-		return ImageFrameTable::default();
+		return RasterDataTable::default();
 	};
 	let image = image.to_rgba32f();
 	let image = Image {
@@ -91,7 +91,7 @@ fn decode_image(_: impl Ctx, data: Arc<[u8]>) -> ImageFrameTable<Color> {
 		..Default::default()
 	};

-	ImageFrameTable::new(image)
+	RasterDataTable::new(image)
 }

 fn render_svg(data: impl GraphicElementRendered, mut render: SvgRender, render_params: RenderParams, footprint: Footprint) -> RenderOutputType {
@@ -165,13 +165,13 @@ async fn rasterize<T: WasmNotSend + 'n>(
 	_: impl Ctx,
 	#[implementations(
 		VectorDataTable,
-		ImageFrameTable<Color>,
+		RasterDataTable<Color>,
 		GraphicGroupTable,
 	)]
 	mut data: Instances<T>,
 	footprint: Footprint,
 	surface_handle: Arc<SurfaceHandle<HtmlCanvasElement>>,
-) -> ImageFrameTable<Color>
+) -> RasterDataTable<Color>
 where
 	Instances<T>: GraphicElementRendered,
 {
@@ -179,7 +179,7 @@ where

 	if footprint.transform.matrix2.determinant() == 0. {
 		log::trace!("Invalid footprint received for rasterization");
-		return ImageFrameTable::default();
+		return RasterDataTable::default();
 	}

 	let mut render = SvgRender::new();
@@ -218,7 +218,7 @@ where

 	let rasterized = context.get_image_data(0., 0., resolution.x as f64, resolution.y as f64).unwrap();

-	let mut result = ImageFrameTable::default();
+	let mut result = RasterDataTable::default();
 	result.push(Instance {
 		instance: Image::from_image_data(&rasterized.data().0, resolution.x as u32, resolution.y as u32),
 		transform: footprint.transform,
@@ -234,7 +234,7 @@ async fn render<'a: 'n, T: 'n + GraphicElementRendered + WasmNotSend>(
 	editor_api: impl Node<Context<'static>, Output = &'a WasmEditorApi>,
 	#[implementations(
 		Context -> VectorDataTable,
-		Context -> ImageFrameTable<Color>,
+		Context -> RasterDataTable<Color>,
 		Context -> GraphicGroupTable,
 		Context -> graphene_core::Artboard,
 		Context -> graphene_core::ArtboardGroupTable,