Instance tables refactor part 7: Remove RasterDataType and add Raster<CPU>/Raster<GPU>

2026-09-19 02:48:12 +08:00 · 2025-06-17 19:39:38 -07:00
parent 5cacab2e39
commit 6111440afd
34 changed files with 560 additions and 826 deletions
--- a/node-graph/gcore/src/raster/image.rs
+++ b/node-graph/gcore/src/raster/image.rs
@@ -1,11 +1,14 @@
+use crate::{
+	AlphaBlending,
+	instances::{Instance, Instances},
+	raster_types::Raster,
+};
+
 use super::Color;
 use super::discrete_srgb::float_to_srgb_u8;
-use crate::AlphaBlending;
-use crate::GraphicElement;
-use crate::instances::{Instance, Instances};
 use alloc::vec::Vec;
 use core::hash::{Hash, Hasher};
-use dyn_any::StaticType;
+use dyn_any::{DynAny, StaticType};
 use glam::{DAffine2, DVec2};

 #[cfg(feature = "serde")]
@@ -208,9 +211,39 @@ 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<RasterDataTable<Color>, D::Error> {
+pub fn migrate_image_frame<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Result<RasterDataTable<CPU>, D::Error> {
 	use serde::Deserialize;

+	type ImageFrameTable<P> = Instances<Image<P>>;
+
+	#[derive(Clone, Debug, Hash, PartialEq, DynAny)]
+	enum RasterFrame {
+		/// 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
+		ImageFrame(ImageFrameTable<Color>),
+	}
+	impl<'de> serde::Deserialize<'de> for RasterFrame {
+		fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+			Ok(RasterFrame::ImageFrame(ImageFrameTable::new(Image::deserialize(deserializer)?)))
+		}
+	}
+	impl serde::Serialize for RasterFrame {
+		fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+			match self {
+				RasterFrame::ImageFrame(image_instances) => image_instances.serialize(serializer),
+			}
+		}
+	}
+
+	#[derive(Clone, Debug, Hash, PartialEq, DynAny)]
+	#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+	pub enum GraphicElement {
+		/// Equivalent to the SVG <g> tag: https://developer.mozilla.org/en-US/docs/Web/SVG/Element/g
+		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),
+	}
+
 	#[derive(Clone, Default, Debug, PartialEq, specta::Type)]
 	#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 	pub struct ImageFrame<P: Pixel> {
@@ -218,13 +251,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::RasterDataType(crate::RasterDataType::RasterData(RasterDataTable::new(image_frame.image)))
+			GraphicElement::RasterFrame(RasterFrame::ImageFrame(ImageFrameTable::new(image_frame.image)))
 		}
 	}
 	impl From<GraphicElement> for ImageFrame<Color> {
 		fn from(element: GraphicElement) -> Self {
 			match element {
-				GraphicElement::RasterDataType(crate::RasterDataType::RasterData(image)) => Self {
+				GraphicElement::RasterFrame(RasterFrame::ImageFrame(image)) => Self {
 					image: image.instance_ref_iter().next().unwrap().instance.clone(),
 				},
 				_ => panic!("Expected Image, found {:?}", element),
@@ -255,27 +288,59 @@ pub fn migrate_image_frame<'de, D: serde::Deserializer<'de>>(deserializer: D) ->
 		Image(Image<Color>),
 		OldImageFrame(OldImageFrame<Color>),
 		ImageFrame(Instances<ImageFrame<Color>>),
-		RasterDataTable(RasterDataTable<Color>),
+		ImageFrameTable(ImageFrameTable<Color>),
+		RasterDataTable(RasterDataTable<CPU>),
 	}

 	Ok(match FormatVersions::deserialize(deserializer)? {
-		FormatVersions::Image(image) => RasterDataTable::new(image),
+		FormatVersions::Image(image) => RasterDataTable::new(Raster::new_cpu(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 = RasterDataTable::new(image);
+			let mut image_frame_table = RasterDataTable::new(Raster::new_cpu(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) => RasterDataTable::new(image_frame.instance_ref_iter().next().unwrap().instance.image.clone()),
-		FormatVersions::RasterDataTable(image_frame_table) => image_frame_table,
+		FormatVersions::ImageFrame(image_frame) => RasterDataTable::new(Raster::new_cpu(image_frame.instance_ref_iter().next().unwrap().instance.image.clone())),
+		FormatVersions::ImageFrameTable(image_frame_table) => RasterDataTable::new(Raster::new_cpu(image_frame_table.instance_ref_iter().next().unwrap().instance.clone())),
+		FormatVersions::RasterDataTable(raster_data_table) => raster_data_table,
 	})
 }

 // TODO: Eventually remove this migration document upgrade code
-pub fn migrate_image_frame_instance<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Result<Instance<Image<Color>>, D::Error> {
+pub fn migrate_image_frame_instance<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Result<Instance<Raster<CPU>>, D::Error> {
 	use serde::Deserialize;

+	type ImageFrameTable<P> = Instances<Image<P>>;
+
+	#[derive(Clone, Debug, Hash, PartialEq, DynAny)]
+	enum RasterFrame {
+		/// 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
+		ImageFrame(ImageFrameTable<Color>),
+	}
+	impl<'de> serde::Deserialize<'de> for RasterFrame {
+		fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+			Ok(RasterFrame::ImageFrame(ImageFrameTable::new(Image::deserialize(deserializer)?)))
+		}
+	}
+	impl serde::Serialize for RasterFrame {
+		fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+			match self {
+				RasterFrame::ImageFrame(image_instances) => image_instances.serialize(serializer),
+			}
+		}
+	}
+
+	#[derive(Clone, Debug, Hash, PartialEq, DynAny)]
+	#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+	pub enum GraphicElement {
+		/// Equivalent to the SVG <g> tag: https://developer.mozilla.org/en-US/docs/Web/SVG/Element/g
+		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),
+	}
+
 	#[derive(Clone, Default, Debug, PartialEq, specta::Type)]
 	#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 	pub struct ImageFrame<P: Pixel> {
@@ -283,13 +348,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::RasterDataType(crate::RasterDataType::RasterData(RasterDataTable::new(image_frame.image)))
+			GraphicElement::RasterFrame(RasterFrame::ImageFrame(ImageFrameTable::new(image_frame.image)))
 		}
 	}
 	impl From<GraphicElement> for ImageFrame<Color> {
 		fn from(element: GraphicElement) -> Self {
 			match element {
-				GraphicElement::RasterDataType(crate::RasterDataType::RasterData(image)) => Self {
+				GraphicElement::RasterFrame(RasterFrame::ImageFrame(image)) => Self {
 					image: image.instance_ref_iter().next().unwrap().instance.clone(),
 				},
 				_ => panic!("Expected Image, found {:?}", element),
@@ -320,23 +385,23 @@ pub fn migrate_image_frame_instance<'de, D: serde::Deserializer<'de>>(deserializ
 		Image(Image<Color>),
 		OldImageFrame(OldImageFrame<Color>),
 		ImageFrame(Instances<ImageFrame<Color>>),
-		RasterDataTable(RasterDataTable<Color>),
-		ImageInstance(Instance<Image<Color>>),
+		RasterDataTable(RasterDataTable<CPU>),
+		ImageInstance(Instance<Raster<CPU>>),
 	}

 	Ok(match FormatVersions::deserialize(deserializer)? {
 		FormatVersions::Image(image) => Instance {
-			instance: image,
+			instance: Raster::new_cpu(image),
 			..Default::default()
 		},
 		FormatVersions::OldImageFrame(image_frame_with_transform_and_blending) => Instance {
-			instance: image_frame_with_transform_and_blending.image,
+			instance: Raster::new_cpu(image_frame_with_transform_and_blending.image),
 			transform: image_frame_with_transform_and_blending.transform,
 			alpha_blending: image_frame_with_transform_and_blending.alpha_blending,
 			source_node_id: None,
 		},
 		FormatVersions::ImageFrame(image_frame) => Instance {
-			instance: image_frame.instance_ref_iter().next().unwrap().instance.image.clone(),
+			instance: Raster::new_cpu(image_frame.instance_ref_iter().next().unwrap().instance.image.clone()),
 			..Default::default()
 		},
 		FormatVersions::RasterDataTable(image_frame_table) => image_frame_table.instance_iter().next().unwrap_or_default(),
@@ -344,8 +409,7 @@ pub fn migrate_image_frame_instance<'de, D: serde::Deserializer<'de>>(deserializ
 	})
 }

-// TODO: Rename to ImageTable
-pub type RasterDataTable<P> = Instances<Image<P>>;
+// pub type RasterDataTable<P> = Instances<Image<P>>;

 impl<P: Debug + Copy + Pixel> Sample for Image<P> {
 	type Pixel = P;
@@ -393,22 +457,22 @@ impl From<Image<Color>> for Image<SRGBA8> {
 	}
 }

-impl From<RasterDataTable<Color>> for RasterDataTable<SRGBA8> {
-	fn from(image_frame_table: RasterDataTable<Color>) -> Self {
-		let mut result_table = RasterDataTable::<SRGBA8>::default();
+// impl From<RasterDataTable<CPU>> for RasterDataTable<SRGBA8> {
+// 	fn from(image_frame_table: RasterDataTable<CPU>) -> Self {
+// 		let mut result_table = RasterDataTable::<SRGBA8>::default();

-		for image_frame_instance in image_frame_table.instance_iter() {
-			result_table.push(Instance {
-				instance: image_frame_instance.instance.into(),
-				transform: image_frame_instance.transform,
-				alpha_blending: image_frame_instance.alpha_blending,
-				source_node_id: image_frame_instance.source_node_id,
-			});
-		}
+// 		for image_frame_instance in image_frame_table.instance_iter() {
+// 			result_table.push(Instance {
+// 				instance: image_frame_instance.instance,
+// 				transform: image_frame_instance.transform,
+// 				alpha_blending: image_frame_instance.alpha_blending,
+// 				source_node_id: image_frame_instance.source_node_id,
+// 			});
+// 		}

-		result_table
-	}
-}
+// 		result_table
+// 	}
+// }

 impl From<Image<SRGBA8>> for Image<Color> {
 	fn from(image: Image<SRGBA8>) -> Self {