Remove ImageFrame<T> by flattening it into Image<T>

Author: Keavon

editor/src/messages/portfolio/document/document_message_handler.rs

@@ -28,7 +28,7 @@ use crate::node_graph_executor::NodeGraphExecutor;
 use bezier_rs::Subpath;
 use graph_craft::document::value::TaggedValue;
 use graph_craft::document::{NodeId, NodeNetwork, OldNodeNetwork};
-use graphene_core::raster::image::{ImageFrame, ImageFrameTable};
+use graphene_core::raster::image::ImageFrameTable;
 use graphene_core::raster::BlendMode;
 use graphene_core::vector::style::ViewMode;
 use graphene_std::renderer::{ClickTarget, Quad};
@@ -762,7 +762,7 @@ impl MessageHandler<DocumentMessage, DocumentMessageData<'_>> for DocumentMessag
 
 				responses.add(DocumentMessage::AddTransaction);
 
-				let layer = graph_modification_utils::new_image_layer(ImageFrameTable::new(ImageFrame { image }), layer_node_id, self.new_layer_parent(true), responses);
+				let layer = graph_modification_utils::new_image_layer(ImageFrameTable::new(image), layer_node_id, self.new_layer_parent(true), responses);
 
 				if let Some(name) = name {
 					responses.add(NodeGraphMessage::SetDisplayName {

editor/src/messages/portfolio/document/utility_types/network_interface.rs

@@ -6222,10 +6222,11 @@ impl PropertiesRow {
 fn migrate_output_names<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Result<Vec<String>, D::Error> {
 	use serde::Deserialize;
 
-	const REPLACEMENTS: [(&str, &str); 3] = [
+	const REPLACEMENTS: [(&str, &str); 4] = [
 		("VectorData", "Instances<VectorData>"),
 		("GraphicGroup", "Instances<GraphicGroup>"),
-		("ImageFrame", "Instances<ImageFrame>"),
+		("ImageFrame", "Instances<Image>"),
+		("Instances<ImageFrame>", "Instances<Image>"),
 	];
 
 	let mut names = Vec::<String>::deserialize(deserializer)?;

node-graph/gcore/src/graphic_element.rs

@@ -1,6 +1,6 @@
 use crate::application_io::{TextureFrame, TextureFrameTable};
 use crate::instances::Instances;
-use crate::raster::image::{ImageFrame, ImageFrameTable};
+use crate::raster::image::{Image, ImageFrameTable};
 use crate::raster::BlendMode;
 use crate::transform::{Transform, TransformMut};
 use crate::uuid::NodeId;
@@ -96,9 +96,9 @@ impl From<VectorDataTable> for GraphicGroupTable {
 		Self::new(GraphicGroup::new(vec![GraphicElement::VectorData(vector_data)]))
 	}
 }
-impl From<ImageFrame<Color>> for GraphicGroupTable {
-	fn from(image_frame: ImageFrame<Color>) -> Self {
-		Self::new(GraphicGroup::new(vec![GraphicElement::RasterFrame(RasterFrame::ImageFrame(ImageFrameTable::new(image_frame)))]))
+impl From<Image<Color>> for GraphicGroupTable {
+	fn from(image: Image<Color>) -> Self {
+		Self::new(GraphicGroup::new(vec![GraphicElement::RasterFrame(RasterFrame::ImageFrame(ImageFrameTable::new(image)))]))
 	}
 }
 impl From<ImageFrameTable<Color>> for GraphicGroupTable {
@@ -192,7 +192,7 @@ impl<'de> serde::Deserialize<'de> for RasterFrame {
 	where
 		D: serde::Deserializer<'de>,
 	{
-		Ok(RasterFrame::ImageFrame(ImageFrameTable::new(ImageFrame::deserialize(deserializer)?)))
+		Ok(RasterFrame::ImageFrame(ImageFrameTable::new(Image::deserialize(deserializer)?)))
 	}
 }
 
@@ -383,8 +383,8 @@ async fn append_artboard<C: Ctx + Clone + 'n>(
 }
 
 // TODO: Remove this one
-impl From<ImageFrame<Color>> for GraphicElement {
-	fn from(image_frame: ImageFrame<Color>) -> Self {
+impl From<Image<Color>> for GraphicElement {
+	fn from(image_frame: Image<Color>) -> Self {
 		GraphicElement::RasterFrame(RasterFrame::ImageFrame(ImageFrameTable::new(image_frame)))
 	}
 }

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

@@ -831,7 +831,7 @@ impl GraphicElementRendered for ImageFrameTable<Color> {
 
 			match render_params.image_render_mode {
 				ImageRenderMode::Base64 => {
-					let image = &instance.instance.image;
+					let image = &instance.instance;
 					if image.data.is_empty() {
 						return;
 					}
@@ -894,7 +894,7 @@ impl GraphicElementRendered for ImageFrameTable<Color> {
 		use vello::peniko;
 
 		for instance in self.instances() {
-			let image = &instance.instance.image;
+			let image = &instance.instance;
 			if image.data.is_empty() {
 				return;
 			}
@@ -918,7 +918,7 @@ impl GraphicElementRendered for RasterFrame {
 				};
 
 				for instance in image.instances() {
-					let (image, blending) = (&instance.instance.image, instance.alpha_blending);
+					let (image, blending) = (&instance.instance, instance.alpha_blending);
 					if image.data.is_empty() {
 						return;
 					}
@@ -994,7 +994,7 @@ impl GraphicElementRendered for RasterFrame {
 		match self {
 			RasterFrame::ImageFrame(image_frame) => {
 				for instance in image_frame.instances() {
-					let image = &instance.instance.image;
+					let image = &instance.instance;
 					if image.data.is_empty() {
 						return;
 					}

node-graph/gcore/src/instances.rs

@@ -1,5 +1,5 @@
 use crate::application_io::{TextureFrame, TextureFrameTable};
-use crate::raster::image::{ImageFrame, ImageFrameTable};
+use crate::raster::image::{Image, ImageFrameTable};
 use crate::raster::Pixel;
 use crate::transform::{Transform, TransformMut};
 use crate::vector::{InstanceId, VectorData, VectorDataTable};
@@ -200,24 +200,24 @@ impl TransformMut for TextureFrameTable {
 	}
 }
 
-// IMAGE FRAME
-impl<P: Pixel> Transform for Instance<'_, ImageFrame<P>> {
+// IMAGE
+impl<P: Pixel> Transform for Instance<'_, Image<P>> {
 	fn transform(&self) -> DAffine2 {
 		*self.transform
 	}
 	fn local_pivot(&self, pivot: DVec2) -> DVec2 {
 		self.transform.transform_point2(pivot)
 	}
 }
-impl<P: Pixel> Transform for InstanceMut<'_, ImageFrame<P>> {
+impl<P: Pixel> Transform for InstanceMut<'_, Image<P>> {
 	fn transform(&self) -> DAffine2 {
 		*self.transform
 	}
 	fn local_pivot(&self, pivot: DVec2) -> DVec2 {
 		self.transform.transform_point2(pivot)
 	}
 }
-impl<P: Pixel> TransformMut for InstanceMut<'_, ImageFrame<P>> {
+impl<P: Pixel> TransformMut for InstanceMut<'_, Image<P>> {
 	fn transform_mut(&mut self) -> &mut DAffine2 {
 		self.transform
 	}
@@ -228,7 +228,7 @@ impl<P: Pixel> Transform for ImageFrameTable<P>
 where
 	P: dyn_any::StaticType,
 	P::Static: Pixel,
-	GraphicElement: From<ImageFrame<P>>,
+	GraphicElement: From<Image<P>>,
 {
 	fn transform(&self) -> DAffine2 {
 		self.one_instance().transform()
@@ -238,7 +238,7 @@ impl<P: Pixel> TransformMut for ImageFrameTable<P>
 where
 	P: dyn_any::StaticType,
 	P::Static: Pixel,
-	GraphicElement: From<ImageFrame<P>>,
+	GraphicElement: From<Image<P>>,
 {
 	fn transform_mut(&mut self) -> &mut DAffine2 {
 		self.transform.first_mut().unwrap_or_else(|| panic!("ONE INSTANCE EXPECTED"))

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

@@ -3,7 +3,7 @@
 #[cfg(feature = "alloc")]
 use crate::raster::curve::{Curve, CurveManipulatorGroup, ValueMapperNode};
 #[cfg(feature = "alloc")]
-use crate::raster::image::{ImageFrame, ImageFrameTable};
+use crate::raster::image::{Image, ImageFrameTable};
 use crate::raster::{Channel, Color, Pixel};
 use crate::registry::types::{Angle, Percentage, SignedPercentage};
 use crate::vector::style::GradientStops;
@@ -605,15 +605,13 @@ impl Blend<Color> for ImageFrameTable<Color> {
 		let mut result = self.clone();
 
 		for (over, under) in result.instances_mut().zip(under.instances()) {
-			let data = over.instance.image.data.iter().zip(under.instance.image.data.iter()).map(|(a, b)| blend_fn(*a, *b)).collect();
-
-			*over.instance = ImageFrame {
-				image: super::Image {
-					data,
-					width: over.instance.image.width,
-					height: over.instance.image.height,
-					base64_string: None,
-				},
+			let data = over.instance.data.iter().zip(under.instance.data.iter()).map(|(a, b)| blend_fn(*a, *b)).collect();
+
+			*over.instance = Image {
+				data,
+				width: over.instance.width,
+				height: over.instance.height,
+				base64_string: None,
 			};
 		}
 
@@ -738,11 +736,11 @@ impl<P: Pixel> Adjust<P> for ImageFrameTable<P>
 where
 	P: dyn_any::StaticType,
 	P::Static: Pixel,
-	GraphicElement: From<ImageFrame<P>>,
+	GraphicElement: From<Image<P>>,
 {
 	fn adjust(&mut self, map_fn: impl Fn(&P) -> P) {
 		for instance in self.instances_mut() {
-			for c in instance.instance.image.data.iter_mut() {
+			for c in instance.instance.data.iter_mut() {
 				*c = map_fn(c);
 			}
 		}
@@ -1386,7 +1384,7 @@ impl<P: Pixel> MultiplyAlpha for ImageFrameTable<P>
 where
 	P: dyn_any::StaticType,
 	P::Static: Pixel,
-	GraphicElement: From<ImageFrame<P>>,
+	GraphicElement: From<Image<P>>,
 {
 	fn multiply_alpha(&mut self, factor: f64) {
 		for instance in self.instances_mut() {
@@ -1539,13 +1537,13 @@ fn color_overlay<T: Adjust<Color>>(
 
 // #[cfg(feature = "alloc")]
 // mod index_node {
-// 	use crate::raster::{Color, ImageFrame};
+// 	use crate::raster::{Color, Image};
 // 	use crate::Ctx;
 
 // 	#[node_macro::node(category(""))]
 // 	pub fn index<T: Default + Clone>(
 // 		_: impl Ctx,
-// 		#[implementations(Vec<ImageFrame<Color>>, Vec<Color>)]
+// 		#[implementations(Vec<Image<Color>>, Vec<Color>)]
 // 		#[widget(ParsedWidgetOverride::Hidden)]
 // 		input: Vec<T>,
 // 		index: u32,
@@ -1561,7 +1559,7 @@ fn color_overlay<T: Adjust<Color>>(
 
 #[cfg(test)]
 mod test {
-	use crate::raster::image::{ImageFrame, ImageFrameTable};
+	use crate::raster::image::{Image, ImageFrameTable};
 	use crate::raster::{BlendMode, Image};
 	use crate::{Color, Node};
 	use std::pin::Pin;
@@ -1580,7 +1578,7 @@ mod test {
 	#[tokio::test]
 	async fn color_overlay_multiply() {
 		let image_color = Color::from_rgbaf32_unchecked(0.7, 0.6, 0.5, 0.4);
-		let image = ImageFrame { image: Image::new(1, 1, image_color) };
+		let image = Image::new(1, 1, image_color);
 
 		// Color { red: 0., green: 1., blue: 0., alpha: 1. }
 		let overlay_color = Color::GREEN;
@@ -1592,6 +1590,6 @@ mod test {
 		let result = result.one_instance().instance;
 
 		// 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.image.data[0], Color::from_rgbaf32_unchecked(0., image_color.g(), 0., image_color.a()));
+		assert_eq!(result.data[0], Color::from_rgbaf32_unchecked(0., image_color.g(), 0., image_color.a()));
 	}
 }

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

@@ -29,7 +29,7 @@ struct BrushCacheImpl {
 impl BrushCacheImpl {
 	fn compute_brush_plan(&mut self, mut background: ImageFrameTable<Color>, input: &[BrushStroke]) -> BrushPlan {
 		// Do background invalidation.
-		if background.one_instance().instance.image != self.background.one_instance().instance.image {
+		if background.one_instance().instance != self.background.one_instance().instance {
 			self.background = background.clone();
 			return BrushPlan {
 				strokes: input.to_vec(),