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

node-graph/gcore/src/application_io.rs

@@ -53,8 +53,7 @@ impl Size for web_sys::HtmlCanvasElement {
 	}
 }
 
-// TODO: Rename to ImageTextureTable
-pub type TextureFrameTable = Instances<ImageTexture>;
+pub type TextureDataTable = Instances<ImageTexture>;
 
 #[derive(Debug, Clone)]
 pub struct ImageTexture {

node-graph/gcore/src/graphic_element.rs

@@ -1,7 +1,7 @@
-use crate::application_io::{ImageTexture, TextureFrameTable};
+use crate::application_io::{ImageTexture, TextureDataTable};
 use crate::instances::{Instance, Instances};
 use crate::raster::BlendMode;
-use crate::raster::image::{Image, ImageFrameTable};
+use crate::raster::image::{Image, RasterDataTable};
 use crate::transform::TransformMut;
 use crate::uuid::NodeId;
 use crate::vector::{VectorData, VectorDataTable};
@@ -124,22 +124,22 @@ impl From<VectorDataTable> for GraphicGroupTable {
 }
 impl From<Image<Color>> for GraphicGroupTable {
 	fn from(image: Image<Color>) -> Self {
-		Self::new(GraphicElement::RasterFrame(RasterFrame::ImageFrame(ImageFrameTable::new(image))))
+		Self::new(GraphicElement::RasterDataType(RasterDataType::RasterData(RasterDataTable::new(image))))
 	}
 }
-impl From<ImageFrameTable<Color>> for GraphicGroupTable {
-	fn from(image_frame: ImageFrameTable<Color>) -> Self {
-		Self::new(GraphicElement::RasterFrame(RasterFrame::ImageFrame(image_frame)))
+impl From<RasterDataTable<Color>> for GraphicGroupTable {
+	fn from(image_frame: RasterDataTable<Color>) -> Self {
+		Self::new(GraphicElement::RasterDataType(RasterDataType::RasterData(image_frame)))
 	}
 }
 impl From<ImageTexture> for GraphicGroupTable {
 	fn from(image_texture: ImageTexture) -> Self {
-		Self::new(GraphicElement::RasterFrame(RasterFrame::TextureFrame(TextureFrameTable::new(image_texture))))
+		Self::new(GraphicElement::RasterDataType(RasterDataType::TextureData(TextureDataTable::new(image_texture))))
 	}
 }
-impl From<TextureFrameTable> for GraphicGroupTable {
-	fn from(texture_frame: TextureFrameTable) -> Self {
-		Self::new(GraphicElement::RasterFrame(RasterFrame::TextureFrame(texture_frame)))
+impl From<TextureDataTable> for GraphicGroupTable {
+	fn from(texture_frame: TextureDataTable) -> Self {
+		Self::new(GraphicElement::RasterDataType(RasterDataType::TextureData(texture_frame)))
 	}
 }
 
@@ -151,7 +151,7 @@ pub enum GraphicElement {
 	GraphicGroup(GraphicGroupTable),
 	/// A vector shape, equivalent to the SVG <path> tag: https://developer.mozilla.org/en-US/docs/Web/SVG/Element/path
 	VectorData(VectorDataTable),
-	RasterFrame(RasterFrame),
+	RasterDataType(RasterDataType),
 }
 
 impl Default for GraphicElement {
@@ -189,16 +189,16 @@ impl GraphicElement {
 		}
 	}
 
-	pub fn as_raster(&self) -> Option<&RasterFrame> {
+	pub fn as_raster(&self) -> Option<&RasterDataType> {
 		match self {
-			GraphicElement::RasterFrame(raster) => Some(raster),
+			GraphicElement::RasterDataType(raster) => Some(raster),
 			_ => None,
 		}
 	}
 
-	pub fn as_raster_mut(&mut self) -> Option<&mut RasterFrame> {
+	pub fn as_raster_mut(&mut self) -> Option<&mut RasterDataType> {
 		match self {
-			GraphicElement::RasterFrame(raster) => Some(raster),
+			GraphicElement::RasterDataType(raster) => Some(raster),
 			_ => None,
 		}
 	}
@@ -206,32 +206,32 @@ impl GraphicElement {
 
 // TODO: Rename to Raster
 #[derive(Clone, Debug, Hash, PartialEq, DynAny)]
-pub enum RasterFrame {
+pub enum RasterDataType {
 	/// A CPU-based bitmap image with a finite position and extent, equivalent to the SVG <image> tag: https://developer.mozilla.org/en-US/docs/Web/SVG/Element/image
 	// TODO: Rename to ImageTable
-	ImageFrame(ImageFrameTable<Color>),
+	RasterData(RasterDataTable<Color>),
 	/// A GPU texture with a finite position and extent
 	// TODO: Rename to ImageTextureTable
-	TextureFrame(TextureFrameTable),
+	TextureData(TextureDataTable),
 }
 
-impl<'de> serde::Deserialize<'de> for RasterFrame {
+impl<'de> serde::Deserialize<'de> for RasterDataType {
 	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
 	where
 		D: serde::Deserializer<'de>,
 	{
-		Ok(RasterFrame::ImageFrame(ImageFrameTable::new(Image::deserialize(deserializer)?)))
+		Ok(RasterDataType::RasterData(RasterDataTable::new(Image::deserialize(deserializer)?)))
 	}
 }
 
-impl serde::Serialize for RasterFrame {
+impl serde::Serialize for RasterDataType {
 	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 	where
 		S: serde::Serializer,
 	{
 		match self {
-			RasterFrame::ImageFrame(_) => self.serialize(serializer),
-			RasterFrame::TextureFrame(_) => todo!(),
+			RasterDataType::RasterData(_) => self.serialize(serializer),
+			RasterDataType::TextureData(_) => todo!(),
 		}
 	}
 }
@@ -324,8 +324,8 @@ async fn to_element<Data: Into<GraphicElement> + 'n>(
 	#[implementations(
 		GraphicGroupTable,
 	 	VectorDataTable,
-		ImageFrameTable<Color>,
-	 	TextureFrameTable,
+		RasterDataTable<Color>,
+	 	TextureDataTable,
 	)]
 	data: Data,
 ) -> GraphicElement {
@@ -338,8 +338,8 @@ async fn to_group<Data: Into<GraphicGroupTable> + 'n>(
 	#[implementations(
 		GraphicGroupTable,
 		VectorDataTable,
-		ImageFrameTable<Color>,
-		TextureFrameTable,
+		RasterDataTable<Color>,
+		TextureDataTable,
 	)]
 	element: Data,
 ) -> GraphicGroupTable {
@@ -391,8 +391,8 @@ async fn to_artboard<Data: Into<GraphicGroupTable> + 'n>(
 	#[implementations(
 		Context -> GraphicGroupTable,
 		Context -> VectorDataTable,
-		Context -> ImageFrameTable<Color>,
-		Context -> TextureFrameTable,
+		Context -> RasterDataTable<Color>,
+		Context -> TextureDataTable,
 	)]
 	contents: impl Node<Context<'static>, Output = Data>,
 	label: String,
@@ -438,23 +438,23 @@ async fn append_artboard(_ctx: impl Ctx, mut artboards: ArtboardGroupTable, artb
 // TODO: Remove this one
 impl From<Image<Color>> for GraphicElement {
 	fn from(image_frame: Image<Color>) -> Self {
-		GraphicElement::RasterFrame(RasterFrame::ImageFrame(ImageFrameTable::new(image_frame)))
+		GraphicElement::RasterDataType(RasterDataType::RasterData(RasterDataTable::new(image_frame)))
 	}
 }
-impl From<ImageFrameTable<Color>> for GraphicElement {
-	fn from(image_frame: ImageFrameTable<Color>) -> Self {
-		GraphicElement::RasterFrame(RasterFrame::ImageFrame(image_frame))
+impl From<RasterDataTable<Color>> for GraphicElement {
+	fn from(image_frame: RasterDataTable<Color>) -> Self {
+		GraphicElement::RasterDataType(RasterDataType::RasterData(image_frame))
 	}
 }
 // TODO: Remove this one
 impl From<ImageTexture> for GraphicElement {
-	fn from(texture: ImageTexture) -> Self {
-		GraphicElement::RasterFrame(RasterFrame::TextureFrame(TextureFrameTable::new(texture)))
+	fn from(image_texture: ImageTexture) -> Self {
+		GraphicElement::RasterDataType(RasterDataType::TextureData(TextureDataTable::new(image_texture)))
 	}
 }
-impl From<TextureFrameTable> for GraphicElement {
-	fn from(texture: TextureFrameTable) -> Self {
-		GraphicElement::RasterFrame(RasterFrame::TextureFrame(texture))
+impl From<TextureDataTable> for GraphicElement {
+	fn from(texture_data: TextureDataTable) -> Self {
+		GraphicElement::RasterDataType(RasterDataType::TextureData(texture_data))
 	}
 }
 // TODO: Remove this one

node-graph/gcore/src/graphic_element/renderer.rs

@@ -1,13 +1,13 @@
 mod quad;
 mod rect;
 
-use crate::raster::image::ImageFrameTable;
+use crate::raster::image::RasterDataTable;
 use crate::raster::{BlendMode, Image};
 use crate::transform::{Footprint, Transform};
 use crate::uuid::{NodeId, generate_uuid};
 use crate::vector::style::{Fill, Stroke, ViewMode};
 use crate::vector::{PointId, VectorDataTable};
-use crate::{Artboard, ArtboardGroupTable, Color, GraphicElement, GraphicGroupTable, RasterFrame};
+use crate::{Artboard, ArtboardGroupTable, Color, GraphicElement, GraphicGroupTable, RasterDataType};
 use base64::Engine;
 use bezier_rs::Subpath;
 use dyn_any::DynAny;
@@ -843,7 +843,7 @@ impl GraphicElementRendered for ArtboardGroupTable {
 	}
 }
 
-impl GraphicElementRendered for ImageFrameTable<Color> {
+impl GraphicElementRendered for RasterDataTable<Color> {
 	fn render_svg(&self, render: &mut SvgRender, _render_params: &RenderParams) {
 		for instance in self.instance_ref_iter() {
 			let transform = *instance.transform * render.transform;
@@ -923,11 +923,11 @@ impl GraphicElementRendered for ImageFrameTable<Color> {
 	}
 }
 
-impl GraphicElementRendered for RasterFrame {
+impl GraphicElementRendered for RasterDataType {
 	fn render_svg(&self, render: &mut SvgRender, render_params: &RenderParams) {
 		match self {
-			RasterFrame::ImageFrame(image) => image.render_svg(render, render_params),
-			RasterFrame::TextureFrame(_) => log::warn!("tried to render texture as an svg"),
+			RasterDataType::RasterData(image) => image.render_svg(render, render_params),
+			RasterDataType::TextureData(_) => log::warn!("tried to render texture as an svg"),
 		}
 	}
 
@@ -953,7 +953,7 @@ impl GraphicElementRendered for RasterFrame {
 		};
 
 		match self {
-			RasterFrame::ImageFrame(image) => {
+			RasterDataType::RasterData(image) => {
 				for instance in image.instance_ref_iter() {
 					let image = &instance.instance;
 					if image.data.is_empty() {
@@ -965,7 +965,7 @@ impl GraphicElementRendered for RasterFrame {
 					render_stuff(image, *instance.transform, *instance.alpha_blending);
 				}
 			}
-			RasterFrame::TextureFrame(image_texture) => {
+			RasterDataType::TextureData(image_texture) => {
 				for instance in image_texture.instance_ref_iter() {
 					let image =
 						vello::peniko::Image::new(vec![].into(), peniko::Format::Rgba8, instance.instance.texture.width(), instance.instance.texture.height()).with_extend(peniko::Extend::Repeat);
@@ -986,8 +986,8 @@ impl GraphicElementRendered for RasterFrame {
 		};
 
 		match self {
-			RasterFrame::ImageFrame(instances) => instances.instance_ref_iter().flat_map(|instance| calculate_transform(*instance.transform)).reduce(Quad::combine_bounds),
-			RasterFrame::TextureFrame(instances) => instances.instance_ref_iter().flat_map(|instance| calculate_transform(*instance.transform)).reduce(Quad::combine_bounds),
+			RasterDataType::RasterData(instances) => instances.instance_ref_iter().flat_map(|instance| calculate_transform(*instance.transform)).reduce(Quad::combine_bounds),
+			RasterDataType::TextureData(instances) => instances.instance_ref_iter().flat_map(|instance| calculate_transform(*instance.transform)).reduce(Quad::combine_bounds),
 		}
 	}
 
@@ -999,13 +999,13 @@ impl GraphicElementRendered for RasterFrame {
 		metadata.upstream_footprints.insert(element_id, footprint);
 
 		match self {
-			RasterFrame::ImageFrame(instances) => {
+			RasterDataType::RasterData(instances) => {
 				// TODO: Find a way to handle more than one row of the graphical data table
 				if let Some(image) = instances.instance_ref_iter().next() {
 					metadata.local_transforms.insert(element_id, *image.transform);
 				}
 			}
-			RasterFrame::TextureFrame(instances) => {
+			RasterDataType::TextureData(instances) => {
 				// TODO: Find a way to handle more than one row of the graphical data table
 				if let Some(image_texture) = instances.instance_ref_iter().next() {
 					metadata.local_transforms.insert(element_id, *image_texture.transform);
@@ -1024,7 +1024,7 @@ impl GraphicElementRendered for GraphicElement {
 	fn render_svg(&self, render: &mut SvgRender, render_params: &RenderParams) {
 		match self {
 			GraphicElement::VectorData(vector_data) => vector_data.render_svg(render, render_params),
-			GraphicElement::RasterFrame(raster) => raster.render_svg(render, render_params),
+			GraphicElement::RasterDataType(raster) => raster.render_svg(render, render_params),
 			GraphicElement::GraphicGroup(graphic_group) => graphic_group.render_svg(render, render_params),
 		}
 	}
@@ -1034,14 +1034,14 @@ impl GraphicElementRendered for GraphicElement {
 		match self {
 			GraphicElement::VectorData(vector_data) => vector_data.render_to_vello(scene, transform, context, render_params),
 			GraphicElement::GraphicGroup(graphic_group) => graphic_group.render_to_vello(scene, transform, context, render_params),
-			GraphicElement::RasterFrame(raster) => raster.render_to_vello(scene, transform, context, render_params),
+			GraphicElement::RasterDataType(raster) => raster.render_to_vello(scene, transform, context, render_params),
 		}
 	}
 
 	fn bounding_box(&self, transform: DAffine2, include_stroke: bool) -> Option<[DVec2; 2]> {
 		match self {
 			GraphicElement::VectorData(vector_data) => vector_data.bounding_box(transform, include_stroke),
-			GraphicElement::RasterFrame(raster) => raster.bounding_box(transform, include_stroke),
+			GraphicElement::RasterDataType(raster) => raster.bounding_box(transform, include_stroke),
 			GraphicElement::GraphicGroup(graphic_group) => graphic_group.bounding_box(transform, include_stroke),
 		}
 	}
@@ -1059,16 +1059,16 @@ impl GraphicElementRendered for GraphicElement {
 						metadata.local_transforms.insert(element_id, *vector_data.transform);
 					}
 				}
-				GraphicElement::RasterFrame(raster_frame) => {
+				GraphicElement::RasterDataType(raster_frame) => {
 					metadata.upstream_footprints.insert(element_id, footprint);
 					match raster_frame {
-						RasterFrame::ImageFrame(instances) => {
+						RasterDataType::RasterData(instances) => {
 							// TODO: Find a way to handle more than one row of images
 							if let Some(image) = instances.instance_ref_iter().next() {
 								metadata.local_transforms.insert(element_id, *image.transform);
 							}
 						}
-						RasterFrame::TextureFrame(instances) => {
+						RasterDataType::TextureData(instances) => {
 							// TODO: Find a way to handle more than one row of image textures
 							if let Some(image_texture) = instances.instance_ref_iter().next() {
 								metadata.local_transforms.insert(element_id, *image_texture.transform);
@@ -1081,7 +1081,7 @@ impl GraphicElementRendered for GraphicElement {
 
 		match self {
 			GraphicElement::VectorData(vector_data) => vector_data.collect_metadata(metadata, footprint, element_id),
-			GraphicElement::RasterFrame(raster) => raster.collect_metadata(metadata, footprint, element_id),
+			GraphicElement::RasterDataType(raster) => raster.collect_metadata(metadata, footprint, element_id),
 			GraphicElement::GraphicGroup(graphic_group) => graphic_group.collect_metadata(metadata, footprint, element_id),
 		}
 	}
@@ -1089,7 +1089,7 @@ impl GraphicElementRendered for GraphicElement {
 	fn add_upstream_click_targets(&self, click_targets: &mut Vec<ClickTarget>) {
 		match self {
 			GraphicElement::VectorData(vector_data) => vector_data.add_upstream_click_targets(click_targets),
-			GraphicElement::RasterFrame(raster) => raster.add_upstream_click_targets(click_targets),
+			GraphicElement::RasterDataType(raster) => raster.add_upstream_click_targets(click_targets),
 			GraphicElement::GraphicGroup(graphic_group) => graphic_group.add_upstream_click_targets(click_targets),
 		}
 	}
@@ -1098,7 +1098,7 @@ impl GraphicElementRendered for GraphicElement {
 		match self {
 			GraphicElement::VectorData(vector_data) => vector_data.contains_artboard(),
 			GraphicElement::GraphicGroup(graphic_group) => graphic_group.contains_artboard(),
-			GraphicElement::RasterFrame(raster) => raster.contains_artboard(),
+			GraphicElement::RasterDataType(raster) => raster.contains_artboard(),
 		}
 	}
 
@@ -1106,7 +1106,7 @@ impl GraphicElementRendered for GraphicElement {
 		match self {
 			GraphicElement::VectorData(vector_data) => vector_data.new_ids_from_hash(reference),
 			GraphicElement::GraphicGroup(graphic_group) => graphic_group.new_ids_from_hash(reference),
-			GraphicElement::RasterFrame(_) => (),
+			GraphicElement::RasterDataType(_) => (),
 		}
 	}
 }

node-graph/gcore/src/ops.rs

@@ -1,6 +1,6 @@
 use crate::Ctx;
 use crate::raster::BlendMode;
-use crate::raster::image::ImageFrameTable;
+use crate::raster::image::RasterDataTable;
 use crate::registry::types::{Fraction, Percentage};
 use crate::vector::style::GradientStops;
 use crate::{Color, Node};
@@ -453,7 +453,7 @@ fn color_value(_: impl Ctx, _primary: (), #[default(Color::BLACK)] color: Option
 // 	_: impl Ctx,
 // 	#[implementations(
 // 		Color,
-// 		ImageFrameTable<Color>,
+// 		RasterDataTable<Color>,
 // 		GradientStops,
 // 	)]
 // 	mut image: T,
@@ -515,7 +515,7 @@ fn unwrap<T: Default>(_: impl Ctx, #[implementations(Option<f64>, Option<f32>, O
 
 /// Meant for debugging purposes, not general use. Clones the input value.
 #[node_macro::node(category("Debug"))]
-fn clone<'i, T: Clone + 'i>(_: impl Ctx, #[implementations(&ImageFrameTable<Color>)] value: &'i T) -> T {
+fn clone<'i, T: Clone + 'i>(_: impl Ctx, #[implementations(&RasterDataTable<Color>)] value: &'i T) -> T {
 	value.clone()
 }
 

node-graph/gcore/src/raster.rs

@@ -1,7 +1,7 @@
 pub use self::color::{Color, Luma, SRGBA8};
 use crate::Ctx;
 use crate::GraphicGroupTable;
-use crate::raster::image::ImageFrameTable;
+use crate::raster::image::RasterDataTable;
 use crate::registry::types::Percentage;
 use crate::vector::VectorDataTable;
 use bytemuck::{Pod, Zeroable};
@@ -310,7 +310,7 @@ impl SetBlendMode for GraphicGroupTable {
 		}
 	}
 }
-impl SetBlendMode for ImageFrameTable<Color> {
+impl SetBlendMode for RasterDataTable<Color> {
 	fn set_blend_mode(&mut self, blend_mode: BlendMode) {
 		for instance in self.instance_mut_iter() {
 			instance.alpha_blending.blend_mode = blend_mode;
@@ -324,7 +324,7 @@ fn blend_mode<T: SetBlendMode>(
 	#[implementations(
 		GraphicGroupTable,
 		VectorDataTable,
-		ImageFrameTable<Color>,
+		RasterDataTable<Color>,
 	)]
 	mut value: T,
 	blend_mode: BlendMode,
@@ -340,7 +340,7 @@ fn opacity<T: MultiplyAlpha>(
 	#[implementations(
 		GraphicGroupTable,
 		VectorDataTable,
-		ImageFrameTable<Color>,
+		RasterDataTable<Color>,
 	)]
 	mut value: T,
 	#[default(100.)] factor: Percentage,

node-graph/gcore/src/raster/adjustments.rs

@@ -4,7 +4,7 @@ use crate::raster::curve::{CubicSplines, CurveManipulatorGroup};
 #[cfg(feature = "alloc")]
 use crate::raster::curve::{Curve, ValueMapperNode};
 #[cfg(feature = "alloc")]
-use crate::raster::image::{Image, ImageFrameTable};
+use crate::raster::image::{Image, RasterDataTable};
 use crate::raster::{Channel, Color, Pixel};
 use crate::registry::types::{Angle, Percentage, SignedPercentage};
 use crate::vector::VectorDataTable;
@@ -265,7 +265,7 @@ fn luminance<T: Adjust<Color>>(
 	_: impl Ctx,
 	#[implementations(
 		Color,
-		ImageFrameTable<Color>,
+		RasterDataTable<Color>,
 		GradientStops,
 	)]
 	mut input: T,
@@ -289,7 +289,7 @@ fn extract_channel<T: Adjust<Color>>(
 	_: impl Ctx,
 	#[implementations(
 		Color,
-		ImageFrameTable<Color>,
+		RasterDataTable<Color>,
 		GradientStops,
 	)]
 	mut input: T,
@@ -312,7 +312,7 @@ fn make_opaque<T: Adjust<Color>>(
 	_: impl Ctx,
 	#[implementations(
 		Color,
-		ImageFrameTable<Color>,
+		RasterDataTable<Color>,
 		GradientStops,
 	)]
 	mut input: T,
@@ -337,7 +337,7 @@ fn brightness_contrast<T: Adjust<Color>>(
 	_: impl Ctx,
 	#[implementations(
 	Color,
-	ImageFrameTable<Color>,
+	RasterDataTable<Color>,
 	GradientStops,
 )]
 	mut input: T,
@@ -426,7 +426,7 @@ fn levels<T: Adjust<Color>>(
 	_: impl Ctx,
 	#[implementations(
 		Color,
-		ImageFrameTable<Color>,
+		RasterDataTable<Color>,
 		GradientStops,
 	)]
 	mut image: T,
@@ -493,7 +493,7 @@ async fn black_and_white<T: Adjust<Color>>(
 	_: impl Ctx,
 	#[implementations(
 		Color,
-		ImageFrameTable<Color>,
+		RasterDataTable<Color>,
 		GradientStops,
 	)]
 	mut image: T,
@@ -565,7 +565,7 @@ async fn hue_saturation<T: Adjust<Color>>(
 	_: impl Ctx,
 	#[implementations(
 		Color,
-		ImageFrameTable<Color>,
+		RasterDataTable<Color>,
 		GradientStops,
 	)]
 	mut input: T,
@@ -599,7 +599,7 @@ async fn invert<T: Adjust<Color>>(
 	_: impl Ctx,
 	#[implementations(
 		Color,
-		ImageFrameTable<Color>,
+		RasterDataTable<Color>,
 		GradientStops,
 	)]
 	mut input: T,
@@ -621,7 +621,7 @@ async fn threshold<T: Adjust<Color>>(
 	_: impl Ctx,
 	#[implementations(
 		Color,
-		ImageFrameTable<Color>,
+		RasterDataTable<Color>,
 		GradientStops,
 	)]
 	mut image: T,
@@ -663,7 +663,7 @@ impl Blend<Color> for Option<Color> {
 		}
 	}
 }
-impl Blend<Color> for ImageFrameTable<Color> {
+impl Blend<Color> for RasterDataTable<Color> {
 	fn blend(&self, under: &Self, blend_fn: impl Fn(Color, Color) -> Color) -> Self {
 		let mut result_table = self.clone();
 
@@ -706,14 +706,14 @@ async fn blend<T: Blend<Color> + Send>(
 	_: impl Ctx,
 	#[implementations(
 		Color,
-		ImageFrameTable<Color>,
+		RasterDataTable<Color>,
 		GradientStops,
 	)]
 	over: T,
 	#[expose]
 	#[implementations(
 		Color,
-		ImageFrameTable<Color>,
+		RasterDataTable<Color>,
 		GradientStops,
 	)]
 	under: T,
@@ -795,7 +795,7 @@ impl Adjust<Color> for GradientStops {
 		}
 	}
 }
-impl<P: Pixel> Adjust<P> for ImageFrameTable<P>
+impl<P: Pixel> Adjust<P> for RasterDataTable<P>
 where
 	GraphicElement: From<Image<P>>,
 {
@@ -829,7 +829,7 @@ async fn gradient_map<T: Adjust<Color>>(
 	_: impl Ctx,
 	#[implementations(
 		Color,
-		ImageFrameTable<Color>,
+		RasterDataTable<Color>,
 		GradientStops,
 	)]
 	mut image: T,
@@ -865,7 +865,7 @@ async fn vibrance<T: Adjust<Color>>(
 	_: impl Ctx,
 	#[implementations(
 		Color,
-		ImageFrameTable<Color>,
+		RasterDataTable<Color>,
 		GradientStops,
 	)]
 	mut image: T,
@@ -1037,7 +1037,7 @@ async fn channel_mixer<T: Adjust<Color>>(
 	_: impl Ctx,
 	#[implementations(
 		Color,
-		ImageFrameTable<Color>,
+		RasterDataTable<Color>,
 		GradientStops,
 	)]
 	mut image: T,
@@ -1166,7 +1166,7 @@ async fn selective_color<T: Adjust<Color>>(
 	_: impl Ctx,
 	#[implementations(
 		Color,
-		ImageFrameTable<Color>,
+		RasterDataTable<Color>,
 		GradientStops,
 	)]
 	mut image: T,
@@ -1309,7 +1309,7 @@ impl MultiplyAlpha for GraphicGroupTable {
 		}
 	}
 }
-impl<P: Pixel> MultiplyAlpha for ImageFrameTable<P>
+impl<P: Pixel> MultiplyAlpha for RasterDataTable<P>
 where
 	GraphicElement: From<Image<P>>,
 {
@@ -1331,7 +1331,7 @@ async fn posterize<T: Adjust<Color>>(
 	_: impl Ctx,
 	#[implementations(
 		Color,
-		ImageFrameTable<Color>,
+		RasterDataTable<Color>,
 		GradientStops,
 	)]
 	mut input: T,
@@ -1364,7 +1364,7 @@ async fn exposure<T: Adjust<Color>>(
 	_: impl Ctx,
 	#[implementations(
 		Color,
-		ImageFrameTable<Color>,
+		RasterDataTable<Color>,
 		GradientStops,
 	)]
 	mut input: T,
@@ -1438,7 +1438,7 @@ fn color_overlay<T: Adjust<Color>>(
 	_: impl Ctx,
 	#[implementations(
 		Color,
-		ImageFrameTable<Color>,
+		RasterDataTable<Color>,
 		GradientStops,
 	)]
 	mut image: T,
@@ -1488,7 +1488,7 @@ fn color_overlay<T: Adjust<Color>>(
 #[cfg(test)]
 mod test {
 	use crate::raster::adjustments::BlendMode;
-	use crate::raster::image::{Image, ImageFrameTable};
+	use crate::raster::image::{Image, RasterDataTable};
 	use crate::{Color, Node};
 	use std::pin::Pin;
 
@@ -1514,7 +1514,7 @@ mod test {
 		// 100% of the output should come from the multiplied value
 		let opacity = 100_f64;
 
-		let result = super::color_overlay((), ImageFrameTable::new(image.clone()), overlay_color, BlendMode::Multiply, opacity);
+		let result = super::color_overlay((), RasterDataTable::new(image.clone()), overlay_color, BlendMode::Multiply, opacity);
 		let result = result.instance_ref_iter().next().unwrap().instance;
 
 		// The output should just be the original green and alpha channels (as we multiply them by 1 and other channels by 0)

node-graph/gcore/src/raster/image.rs

@@ -16,19 +16,13 @@ mod base64_serde {
 	use base64::Engine;
 	use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
-	pub fn as_base64<S, P: Pixel>(key: &[P], serializer: S) -> Result<S::Ok, S::Error>
-	where
-		S: Serializer,
-	{
+	pub fn as_base64<S: Serializer, P: Pixel>(key: &[P], serializer: S) -> Result<S::Ok, S::Error> {
 		let u8_data = bytemuck::cast_slice(key);
 		let string = base64::engine::general_purpose::STANDARD.encode(u8_data);
 		(key.len() as u64, string).serialize(serializer)
 	}
 
-	pub fn from_base64<'a, D, P: Pixel>(deserializer: D) -> Result<Vec<P>, D::Error>
-	where
-		D: Deserializer<'a>,
-	{
+	pub fn from_base64<'a, D: Deserializer<'a>, P: Pixel>(deserializer: D) -> Result<Vec<P>, D::Error> {
 		use serde::de::Error;
 		<(u64, &[u8])>::deserialize(deserializer)
 			.and_then(|(len, str)| {
@@ -214,7 +208,7 @@ impl<P: Pixel> IntoIterator for Image<P> {
 }
 
 // TODO: Eventually remove this migration document upgrade code
-pub fn migrate_image_frame<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Result<ImageFrameTable<Color>, D::Error> {
+pub fn migrate_image_frame<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Result<RasterDataTable<Color>, D::Error> {
 	use serde::Deserialize;
 
 	#[derive(Clone, Default, Debug, PartialEq, specta::Type)]
@@ -224,13 +218,13 @@ pub fn migrate_image_frame<'de, D: serde::Deserializer<'de>>(deserializer: D) ->
 	}
 	impl From<ImageFrame<Color>> for GraphicElement {
 		fn from(image_frame: ImageFrame<Color>) -> Self {
-			GraphicElement::RasterFrame(crate::RasterFrame::ImageFrame(ImageFrameTable::new(image_frame.image)))
+			GraphicElement::RasterDataType(crate::RasterDataType::RasterData(RasterDataTable::new(image_frame.image)))
 		}
 	}
 	impl From<GraphicElement> for ImageFrame<Color> {
 		fn from(element: GraphicElement) -> Self {
 			match element {
-				GraphicElement::RasterFrame(crate::RasterFrame::ImageFrame(image)) => Self {
+				GraphicElement::RasterDataType(crate::RasterDataType::RasterData(image)) => Self {
 					image: image.instance_ref_iter().next().unwrap().instance.clone(),
 				},
 				_ => panic!("Expected Image, found {:?}", element),
@@ -261,20 +255,20 @@ pub fn migrate_image_frame<'de, D: serde::Deserializer<'de>>(deserializer: D) ->
 		Image(Image<Color>),
 		OldImageFrame(OldImageFrame<Color>),
 		ImageFrame(Instances<ImageFrame<Color>>),
-		ImageFrameTable(ImageFrameTable<Color>),
+		RasterDataTable(RasterDataTable<Color>),
 	}
 
 	Ok(match FormatVersions::deserialize(deserializer)? {
-		FormatVersions::Image(image) => ImageFrameTable::new(image),
+		FormatVersions::Image(image) => RasterDataTable::new(image),
 		FormatVersions::OldImageFrame(image_frame_with_transform_and_blending) => {
 			let OldImageFrame { image, transform, alpha_blending } = image_frame_with_transform_and_blending;
-			let mut image_frame_table = ImageFrameTable::new(image);
+			let mut image_frame_table = RasterDataTable::new(image);
 			*image_frame_table.instance_mut_iter().next().unwrap().transform = transform;
 			*image_frame_table.instance_mut_iter().next().unwrap().alpha_blending = alpha_blending;
 			image_frame_table
 		}
-		FormatVersions::ImageFrame(image_frame) => ImageFrameTable::new(image_frame.instance_ref_iter().next().unwrap().instance.image.clone()),
-		FormatVersions::ImageFrameTable(image_frame_table) => image_frame_table,
+		FormatVersions::ImageFrame(image_frame) => RasterDataTable::new(image_frame.instance_ref_iter().next().unwrap().instance.image.clone()),
+		FormatVersions::RasterDataTable(image_frame_table) => image_frame_table,
 	})
 }
 
@@ -289,13 +283,13 @@ pub fn migrate_image_frame_instance<'de, D: serde::Deserializer<'de>>(deserializ
 	}
 	impl From<ImageFrame<Color>> for GraphicElement {
 		fn from(image_frame: ImageFrame<Color>) -> Self {
-			GraphicElement::RasterFrame(crate::RasterFrame::ImageFrame(ImageFrameTable::new(image_frame.image)))
+			GraphicElement::RasterDataType(crate::RasterDataType::RasterData(RasterDataTable::new(image_frame.image)))
 		}
 	}
 	impl From<GraphicElement> for ImageFrame<Color> {
 		fn from(element: GraphicElement) -> Self {
 			match element {
-				GraphicElement::RasterFrame(crate::RasterFrame::ImageFrame(image)) => Self {
+				GraphicElement::RasterDataType(crate::RasterDataType::RasterData(image)) => Self {
 					image: image.instance_ref_iter().next().unwrap().instance.clone(),
 				},
 				_ => panic!("Expected Image, found {:?}", element),
@@ -326,7 +320,7 @@ pub fn migrate_image_frame_instance<'de, D: serde::Deserializer<'de>>(deserializ
 		Image(Image<Color>),
 		OldImageFrame(OldImageFrame<Color>),
 		ImageFrame(Instances<ImageFrame<Color>>),
-		ImageFrameTable(ImageFrameTable<Color>),
+		RasterDataTable(RasterDataTable<Color>),
 		ImageInstance(Instance<Image<Color>>),
 	}
 
@@ -345,13 +339,13 @@ pub fn migrate_image_frame_instance<'de, D: serde::Deserializer<'de>>(deserializ
 			instance: image_frame.instance_ref_iter().next().unwrap().instance.image.clone(),
 			..Default::default()
 		},
-		FormatVersions::ImageFrameTable(image_frame_table) => image_frame_table.instance_iter().next().unwrap_or_default(),
+		FormatVersions::RasterDataTable(image_frame_table) => image_frame_table.instance_iter().next().unwrap_or_default(),
 		FormatVersions::ImageInstance(image_instance) => image_instance,
 	})
 }
 
 // TODO: Rename to ImageTable
-pub type ImageFrameTable<P> = Instances<Image<P>>;
+pub type RasterDataTable<P> = Instances<Image<P>>;
 
 impl<P: Debug + Copy + Pixel> Sample for Image<P> {
 	type Pixel = P;
@@ -399,9 +393,9 @@ impl From<Image<Color>> for Image<SRGBA8> {
 	}
 }
 
-impl From<ImageFrameTable<Color>> for ImageFrameTable<SRGBA8> {
-	fn from(image_frame_table: ImageFrameTable<Color>) -> Self {
-		let mut result_table = ImageFrameTable::<SRGBA8>::default();
+impl From<RasterDataTable<Color>> for RasterDataTable<SRGBA8> {
+	fn from(image_frame_table: RasterDataTable<Color>) -> Self {
+		let mut result_table = RasterDataTable::<SRGBA8>::default();
 
 		for image_frame_instance in image_frame_table.instance_iter() {
 			result_table.push(Instance {

node-graph/gcore/src/transform.rs

@@ -1,7 +1,7 @@
-use crate::application_io::TextureFrameTable;
+use crate::application_io::TextureDataTable;
 use crate::instances::Instances;
 use crate::raster::bbox::AxisAlignedBbox;
-use crate::raster::image::ImageFrameTable;
+use crate::raster::image::RasterDataTable;
 use crate::vector::VectorDataTable;
 use crate::{Artboard, CloneVarArgs, Color, Context, Ctx, ExtractAll, GraphicGroupTable, OwnedContextImpl};
 use core::f64;
@@ -162,8 +162,8 @@ async fn transform<T: 'n + 'static>(
 	#[implementations(
 		Context -> VectorDataTable,
 		Context -> GraphicGroupTable,
-		Context -> ImageFrameTable<Color>,
-		Context -> TextureFrameTable,
+		Context -> RasterDataTable<Color>,
+		Context -> TextureDataTable,
 	)]
 	transform_target: impl Node<Context<'static>, Output = Instances<T>>,
 	translate: DVec2,
@@ -194,7 +194,7 @@ async fn transform<T: 'n + 'static>(
 #[node_macro::node(category(""))]
 fn replace_transform<Data, TransformInput: Transform>(
 	_: impl Ctx,
-	#[implementations(VectorDataTable, ImageFrameTable<Color>, GraphicGroupTable)] mut data: Instances<Data>,
+	#[implementations(VectorDataTable, RasterDataTable<Color>, GraphicGroupTable)] mut data: Instances<Data>,
 	#[implementations(DAffine2)] transform: TransformInput,
 ) -> Instances<Data> {
 	for data_transform in data.instance_mut_iter() {
@@ -209,8 +209,8 @@ async fn boundless_footprint<T: 'n + 'static>(
 	#[implementations(
 		Context -> VectorDataTable,
 		Context -> GraphicGroupTable,
-		Context -> ImageFrameTable<Color>,
-		Context -> TextureFrameTable,
+		Context -> RasterDataTable<Color>,
+		Context -> TextureDataTable,
 		Context -> String,
 		Context -> f64,
 	)]
@@ -226,8 +226,8 @@ async fn freeze_real_time<T: 'n + 'static>(
 	#[implementations(
 		Context -> VectorDataTable,
 		Context -> GraphicGroupTable,
-		Context -> ImageFrameTable<Color>,
-		Context -> TextureFrameTable,
+		Context -> RasterDataTable<Color>,
+		Context -> TextureDataTable,
 		Context -> String,
 		Context -> f64,
 	)]

node-graph/gcore/src/vector/algorithms/instance.rs

@@ -1,6 +1,6 @@
 use crate::instances::{InstanceRef, Instances};
 use crate::raster::Color;
-use crate::raster::image::ImageFrameTable;
+use crate::raster::image::RasterDataTable;
 use crate::transform::TransformMut;
 use crate::vector::VectorDataTable;
 use crate::{CloneVarArgs, Context, Ctx, ExtractAll, ExtractIndex, ExtractVarArgs, GraphicElement, GraphicGroupTable, OwnedContextImpl};
@@ -10,7 +10,7 @@ use glam::DVec2;
 async fn instance_on_points<T: Into<GraphicElement> + Default + Clone + 'static>(
 	ctx: impl ExtractAll + CloneVarArgs + Sync + Ctx,
 	points: VectorDataTable,
-	#[implementations(Context -> GraphicGroupTable, Context -> VectorDataTable, Context -> ImageFrameTable<Color>)] instance: impl Node<'n, Context<'static>, Output = Instances<T>>,
+	#[implementations(Context -> GraphicGroupTable, Context -> VectorDataTable, Context -> RasterDataTable<Color>)] instance: impl Node<'n, Context<'static>, Output = Instances<T>>,
 	reverse: bool,
 ) -> GraphicGroupTable {
 	let mut result_table = GraphicGroupTable::default();
@@ -46,7 +46,7 @@ async fn instance_on_points<T: Into<GraphicElement> + Default + Clone + 'static>
 #[node_macro::node(category("Instancing"), path(graphene_core::vector))]
 async fn instance_repeat<T: Into<GraphicElement> + Default + Clone + 'static>(
 	ctx: impl ExtractAll + CloneVarArgs + Ctx,
-	#[implementations(Context -> GraphicGroupTable, Context -> VectorDataTable, Context -> ImageFrameTable<Color>)] instance: impl Node<'n, Context<'static>, Output = Instances<T>>,
+	#[implementations(Context -> GraphicGroupTable, Context -> VectorDataTable, Context -> RasterDataTable<Color>)] instance: impl Node<'n, Context<'static>, Output = Instances<T>>,
 	#[default(1)] count: u64,
 	reverse: bool,
 ) -> GraphicGroupTable {

node-graph/gcore/src/vector/vector_nodes.rs

@@ -4,7 +4,7 @@ use super::misc::{CentroidType, point_to_dvec2};
 use super::style::{Fill, Gradient, GradientStops, Stroke};
 use super::{PointId, SegmentDomain, SegmentId, StrokeId, VectorData, VectorDataTable};
 use crate::instances::{Instance, InstanceMut, Instances};
-use crate::raster::image::ImageFrameTable;
+use crate::raster::image::RasterDataTable;
 use crate::registry::types::{Angle, Fraction, IntegerCount, Length, Multiplier, Percentage, PixelLength, PixelSize, SeedValue};
 use crate::renderer::GraphicElementRendered;
 use crate::transform::{Footprint, ReferencePoint, Transform};
@@ -204,7 +204,7 @@ where
 async fn repeat<I: 'n + Send>(
 	_: impl Ctx,
 	// TODO: Implement other GraphicElementRendered types.
-	#[implementations(GraphicGroupTable, VectorDataTable, ImageFrameTable<Color>)] instance: Instances<I>,
+	#[implementations(GraphicGroupTable, VectorDataTable, RasterDataTable<Color>)] instance: Instances<I>,
 	#[default(100., 100.)]
 	// TODO: When using a custom Properties panel layout in document_node_definitions.rs and this default is set, the widget weirdly doesn't show up in the Properties panel. Investigation is needed.
 	direction: PixelSize,
@@ -246,7 +246,7 @@ where
 async fn circular_repeat<I: 'n + Send>(
 	_: impl Ctx,
 	// TODO: Implement other GraphicElementRendered types.
-	#[implementations(GraphicGroupTable, VectorDataTable, ImageFrameTable<Color>)] instance: Instances<I>,
+	#[implementations(GraphicGroupTable, VectorDataTable, RasterDataTable<Color>)] instance: Instances<I>,
 	angle_offset: Angle,
 	#[default(5)] radius: f64,
 	#[default(5)] instances: IntegerCount,
@@ -286,7 +286,7 @@ async fn copy_to_points<I: 'n + Send>(
 	points: VectorDataTable,
 	#[expose]
 	/// Artwork to be copied and placed at each point.
-	#[implementations(GraphicGroupTable, VectorDataTable, ImageFrameTable<Color>)]
+	#[implementations(GraphicGroupTable, VectorDataTable, RasterDataTable<Color>)]
 	instance: Instances<I>,
 	/// Minimum range of randomized sizes given to each instance.
 	#[default(1)]
@@ -370,7 +370,7 @@ where
 #[node_macro::node(category("Vector"), path(graphene_core::vector))]
 async fn mirror<I: 'n + Send>(
 	_: impl Ctx,
-	#[implementations(GraphicGroupTable, VectorDataTable, ImageFrameTable<Color>)] instance: Instances<I>,
+	#[implementations(GraphicGroupTable, VectorDataTable, RasterDataTable<Color>)] instance: Instances<I>,
 	#[default(ReferencePoint::Center)] reference_point: ReferencePoint,
 	offset: f64,
 	#[range((-90., 90.))] angle: Angle,