Add migrations

Author: timon-schelling

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

@@ -109,9 +109,9 @@ pub struct DocumentMessageHandler {
 	pub graph_view_overlay_open: bool,
 	/// The current opacity of the faded node graph background that covers up the artwork.
 	pub graph_fade_artwork_percentage: f64,
-	/// Resources embedded in the document. Must be None for autosaved documents.
-	#[serde(rename = "resources", skip_serializing_if = "Option::is_none")]
-	pub embedded_resources: Option<EmbeddedResources>,
+	/// Resources embedded in the document. Only propagated if saving to an external file and never for autosaved documents.
+	#[serde(rename = "resources", default, skip_serializing_if = "EmbeddedResources::is_empty")]
+	pub embedded_resources: EmbeddedResources,
 
 	// =============================================
 	// Fields omitted from the saved document format
@@ -174,7 +174,7 @@ impl Default for DocumentMessageHandler {
 			graph_view_overlay_open: false,
 			snapping_state: SnappingState::default(),
 			graph_fade_artwork_percentage: 80.,
-			embedded_resources: None,
+			embedded_resources: EmbeddedResources::default(),
 			// =============================================
 			// Fields omitted from the saved document format
 			// =============================================
@@ -926,12 +926,11 @@ impl MessageHandler<DocumentMessage, DocumentMessageContext<'_>> for DocumentMes
 				let folder = self.path.as_ref().and_then(|path| path.parent()).map(|parent| parent.to_path_buf());
 
 				let exported = resources.export(&Vec::from_iter(self.used_resources()));
-				let embedded = EmbeddedResources::from_iter(exported);
-				if !embedded.is_empty() {
-					self.embedded_resources = Some(embedded);
-				}
+				self.embedded_resources = EmbeddedResources::from_iter(exported);
 				let content = self.serialize_document();
-				self.embedded_resources = None;
+
+				// Clear embedded resources after serialization to free memory.
+				let _ = std::mem::take(&mut self.embedded_resources);
 
 				responses.add(FrontendMessage::TriggerSaveDocument {
 					document_id,

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

@@ -303,13 +303,13 @@ impl<'a> ModifyInputsContext<'a> {
 		let hash = graphene_std::application_io::ResourceHash::from(png_bytes.as_ref());
 		self.responses.add(ResourceMessage::Write { data: png_bytes });
 
-		let resource_image = resolve_proto_node_type(graphene_std::platform_application_io::resource_image::IDENTIFIER)
-			.expect("Resource Image node does not exist")
+		let image_node = resolve_proto_node_type(graphene_std::platform_application_io::image::IDENTIFIER)
+			.expect("Image node does not exist")
 			.node_template_input_override([Some(NodeInput::value(TaggedValue::Resource(hash), false))]);
 
-		let resource_image_id = NodeId::new();
-		self.network_interface.insert_node(resource_image_id, resource_image, &[]);
-		self.network_interface.move_node_to_chain_start(&resource_image_id, layer, &[], self.import);
+		let image_node_id = NodeId::new();
+		self.network_interface.insert_node(image_node_id, image_node, &[]);
+		self.network_interface.move_node_to_chain_start(&image_node_id, layer, &[], self.import);
 
 		let transform_id = NodeId::new();
 		self.network_interface.insert_node(transform_id, transform, &[]);

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

@@ -13,6 +13,12 @@ impl EmbeddedResources {
 	pub fn is_empty(&self) -> bool {
 		self.resources.is_empty()
 	}
+
+	pub fn store(&mut self, resource: Resource) -> ResourceHash {
+		let hash = ResourceHash::from(resource.as_ref());
+		self.resources.insert(hash, resource);
+		hash
+	}
 }
 
 impl FromIterator<(ResourceHash, Resource)> for EmbeddedResources {

editor/src/messages/portfolio/document_migration.rs

@@ -549,12 +549,13 @@ const NODE_REPLACEMENTS: &[NodeReplacement<'static>] = &[
 		],
 	},
 	NodeReplacement {
-		node: graphene_std::raster_nodes::std_nodes::image::IDENTIFIER,
+		node: graphene_std::platform_application_io::image::IDENTIFIER,
 		aliases: &[
 			"raster_nodes::std_nodes::ImageValueNode",
 			"graphene_raster_nodes::std_nodes::ImageValueNode",
 			"graphene_std::raster::ImageValueNode",
 			"graphene_std::raster::ImageNode",
+			"graphene_std::raster_nodes::std_nodes::ImageNode",
 		],
 	},
 	NodeReplacement {
@@ -1588,12 +1589,24 @@ fn migrate_node(node_id: &NodeId, node: &DocumentNode, network_path: &[NodeId],
 		document.network_interface.set_input(&InputConnector::node(*node_id, 4), old_inputs[3].clone(), network_path);
 	}
 
-	if reference == DefinitionIdentifier::ProtoNode(graphene_std::raster_nodes::std_nodes::image::IDENTIFIER) && inputs_count == 1 {
-		let mut node_template = resolve_document_node_type(&reference)?.default_node_template();
-		document.network_interface.replace_implementation(node_id, network_path, &mut node_template);
+	// Upgrade `image` nodes that stored image data as `Image<Color>`` to `image` nodes that store a reference to the image data as a resource.
+	// Encodes the image data as PNG and stores it in the document's embedded resources and rewires the node to reference that resource.
+	if reference == DefinitionIdentifier::ProtoNode(graphene_std::platform_application_io::image::IDENTIFIER) && inputs_count == 2 {
+		let image = node.inputs.iter().find_map(|input| match input.as_value()? {
+			TaggedValue::ImageData(image) => Some(image.clone()),
+			_ => None,
+		});
+
+		if let Some(image) = image {
+			let hash = document.embedded_resources.store(graphene_std::application_io::Resource::new(image.to_png()));
 
-		// Insert a new empty input for the image
-		document.network_interface.add_import(TaggedValue::None, false, 0, "Empty", "", &[*node_id]);
+			let mut node_template = resolve_document_node_type(&reference)?.default_node_template();
+			document.network_interface.replace_implementation(node_id, network_path, &mut node_template);
+			let _ = document.network_interface.replace_inputs(node_id, network_path, &mut node_template);
+			document
+				.network_interface
+				.set_input(&InputConnector::node(*node_id, 0), NodeInput::value(TaggedValue::Resource(hash), false), network_path);
+		}
 	}
 
 	if reference == DefinitionIdentifier::ProtoNode(graphene_std::raster_nodes::std_nodes::noise_pattern::IDENTIFIER) && inputs_count == 15 {

editor/src/messages/portfolio/portfolio_message_handler.rs

@@ -778,20 +778,19 @@ impl MessageHandler<PortfolioMessage, PortfolioMessageContext<'_>> for Portfolio
 					}
 				};
 
-				if let Some(resources) = document.embedded_resources.take() {
-					resources.into_iter().for_each(|(hash, resource)| {
-						let data: Arc<[u8]> = Arc::from(resource.as_ref());
-						if ResourceHash::from(data.as_ref()) != hash {
-							log::error!("Resource hash mismatch for resource with hash {hash}");
-							return;
-						}
-						responses.add(ResourceMessage::Write { data });
-					});
-				}
-
 				// Upgrade the document's nodes to be compatible with the latest version
 				document_migration_upgrades(&mut document, reset_node_definitions_on_open);
 
+				// Load the document's embedded resources into the resource storage
+				std::mem::take(&mut document.embedded_resources).into_iter().for_each(|(hash, resource)| {
+					let data: Arc<[u8]> = Arc::from(resource.as_ref());
+					if ResourceHash::from(data.as_ref()) != hash {
+						log::error!("Resource hash mismatch for resource with hash {hash}");
+						return;
+					}
+					responses.add(ResourceMessage::Write { data });
+				});
+
 				// Ensure each node has the metadata for its inputs
 				for (node_id, node, path) in document.network_interface.document_network().clone().recursive_nodes() {
 					document.network_interface.validate_input_metadata(node_id, node, &path);

node-graph/graph-craft/src/application_io/resource/indexed_db.rs

@@ -76,7 +76,7 @@ impl IndexedDbResourceStorage {
 				}
 			};
 
-			let key = JsValue::from_str(&hash.to_hex());
+			let key = JsValue::from_str(&String::from(&hash));
 
 			let request = match store.delete(&key) {
 				Ok(request) => request,
@@ -113,7 +113,7 @@ impl IndexedDbResourceStorage {
 				}
 			};
 
-			let key = JsValue::from_str(&hash.to_hex());
+			let key = JsValue::from_str(&String::from(&hash));
 			let value = js_sys::Uint8Array::from(data.as_slice());
 
 			let request = match store.put_with_key(&value, &key) {
@@ -234,7 +234,7 @@ async fn fetch_known_keys(db: &IdbDatabase, store_name: &str) -> Result<HashSet<
 async fn fetch_one(db: &IdbDatabase, store_name: &str, hash: ResourceHash) -> Result<Option<Vec<u8>>, JsValue> {
 	let transaction = db.transaction_with_str(store_name)?;
 	let store = transaction.object_store(store_name)?;
-	let key = JsValue::from_str(&hash.to_hex());
+	let key = JsValue::from_str(&String::from(&hash));
 	let request = store.get(&key)?;
 	let result = await_request(&request).await?;
 	if result.is_undefined() || result.is_null() {

node-graph/nodes/gstd/src/platform_application_io.rs

@@ -161,7 +161,7 @@ async fn load_resource<'a: 'n>(_: impl Ctx, _primary: (), #[scope("editor-api")]
 /// Works with standard image format (PNG, JPEG, WebP, etc.). Automatically converts the color space to linear sRGB for accurate compositing.
 #[node_macro::node(category("Web Request"))]
 fn decode_image(_: impl Ctx, data: Arc<[u8]>) -> List<Raster<CPU>> {
-	let Some(image) = image::load_from_memory(data.as_ref()).ok() else {
+	let Some(image) = ::image::load_from_memory(data.as_ref()).ok() else {
 		return List::new();
 	};
 	let image = image.to_rgba32f();
@@ -269,10 +269,10 @@ pub async fn resource<'a: 'n>(_: impl Ctx, _primary: (), #[scope("editor-api")]
 }
 
 #[node_macro::node(category(""))]
-pub fn resource_image<'a: 'n>(_: impl Ctx, resource: Resource) -> List<Raster<CPU>> {
+pub fn image<'a: 'n>(_: impl Ctx, resource: Resource) -> List<Raster<CPU>> {
 	let image_data = resource.as_ref();
 
-	let Some(image) = image::load_from_memory(image_data).ok() else {
+	let Some(image) = ::image::load_from_memory(image_data).ok() else {
 		return List::new();
 	};
 	let image = image.to_rgba32f();

node-graph/nodes/raster/src/std_nodes.rs

@@ -288,11 +288,6 @@ pub fn empty_image(_: impl Ctx, transform: DAffine2, color: List<Color>) -> List
 	result_list
 }
 
-#[node_macro::node(category(""))]
-pub fn image(_: impl Ctx, _primary: (), image: Image<Color>) -> List<Raster<CPU>> {
-	List::new_from_element(Raster::new_cpu(image))
-}
-
 /// Generates customizable procedural noise patterns.
 #[node_macro::node(category("Raster: Pattern"))]
 #[allow(clippy::too_many_arguments)]