Move Vec<BrushStroke> to Table<BrushStroke>

Author: Keavon

editor/src/messages/portfolio/document/data_panel/data_panel_message_handler.rs

@@ -217,46 +217,6 @@ trait TableRowLayout {
 	}
 }
 
-impl<T: TableRowLayout> TableRowLayout for Vec<T> {
-	fn type_name() -> &'static str {
-		"Vec"
-	}
-	fn identifier(&self) -> String {
-		format!("Vec<{}> ({} element{})", T::type_name(), self.len(), if self.len() == 1 { "" } else { "s" })
-	}
-	fn element_page(&self, data: &mut LayoutData) -> Vec<LayoutGroup> {
-		if let Some(step) = data.desired_path.get(data.current_depth).cloned() {
-			match step {
-				PathStep::Element(index) => {
-					if let Some(row) = self.get(index) {
-						data.current_depth += 1;
-						let result = row.layout_with_breadcrumb(data);
-						data.current_depth -= 1;
-						return result;
-					} else {
-						warn!("Desired path truncated");
-						data.desired_path.truncate(data.current_depth);
-					}
-				}
-				PathStep::Attribute { .. } => {
-					warn!("Attribute path step inside a Vec is unsupported");
-					data.desired_path.truncate(data.current_depth);
-				}
-			}
-		}
-
-		let mut rows = self
-			.iter()
-			.enumerate()
-			.map(|(index, row)| vec![TextLabel::new(format!("{index}")).narrow(true).widget_instance(), row.cell_widget(PathStep::Element(index))])
-			.collect::<Vec<_>>();
-
-		rows.insert(0, column_headings(&["", "element"]));
-
-		vec![LayoutGroup::table(rows, false)]
-	}
-}
-
 impl<T: TableRowLayout> TableRowLayout for Table<T> {
 	fn type_name() -> &'static str {
 		"Table"

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

@@ -580,7 +580,8 @@ impl<'a> ModifyInputsContext<'a> {
 		let Some(brush_node_id) = self.existing_network_node_id("Brush", true) else {
 			return;
 		};
-		self.set_input_with_refresh(InputConnector::node(brush_node_id, 1), NodeInput::value(TaggedValue::BrushStrokes(strokes), false), false);
+		let strokes_table = strokes.into_iter().map(graphene_std::table::TableRow::new_from_element).collect();
+		self.set_input_with_refresh(InputConnector::node(brush_node_id, 1), NodeInput::value(TaggedValue::BrushStrokeTable(strokes_table), false), false);
 	}
 
 	pub fn resize_artboard(&mut self, location: IVec2, dimensions: IVec2) {

editor/src/messages/portfolio/document/node_graph/document_node_definitions.rs

@@ -1391,7 +1391,7 @@ fn document_node_definitions() -> HashMap<DefinitionIdentifier, DocumentNodeDefi
 					}),
 					inputs: vec![
 						NodeInput::value(TaggedValue::Raster(Default::default()), true),
-						NodeInput::value(TaggedValue::BrushStrokes(Vec::new()), false),
+						NodeInput::value(TaggedValue::BrushStrokeTable(Default::default()), false),
 						NodeInput::value(TaggedValue::BrushCache(BrushCache::default()), false),
 					],
 					..Default::default()

editor/src/messages/tool/tool_messages/brush_tool.rs

@@ -321,8 +321,8 @@ impl BrushToolData {
 
 			if reference == DefinitionIdentifier::Network("Brush".into()) && node_id != layer.to_node() {
 				let points_input = node.inputs.get(1)?;
-				let Some(TaggedValue::BrushStrokes(strokes)) = points_input.as_value() else { continue };
-				self.strokes.clone_from(strokes);
+				let Some(TaggedValue::BrushStrokeTable(strokes)) = points_input.as_value() else { continue };
+				self.strokes = strokes.iter_element_values().cloned().collect();
 
 				return Some(layer);
 			}

node-graph/graph-craft/src/document/value.rs

@@ -191,6 +191,9 @@ tagged_value! {
 	#[serde(deserialize_with = "graphic_types::vector_types::gradient::migrate_gradient_stops")] // TODO: Eventually remove this migration document upgrade code
 	#[serde(alias = "GradientPositions", alias = "GradientStops")]
 	GradientTable(Table<GradientStops>),
+	#[serde(deserialize_with = "brush_nodes::migrations::migrate_brush_strokes_to_table")] // TODO: Eventually remove this migration document upgrade code
+	#[serde(alias = "BrushStrokes")]
+	BrushStrokeTable(Table<BrushStroke>),
 	// ============
 	// SCALAR TYPES
 	// ============
@@ -208,7 +211,6 @@ tagged_value! {
 	Stroke(Stroke),
 	Gradient(Gradient),
 	Font(Font),
-	BrushStrokes(Vec<BrushStroke>),
 	BrushCache(BrushCache),
 	DocumentNode(DocumentNode),
 	ContextFeatures(ContextFeatures),

node-graph/interpreted-executor/src/node_registry.rs

@@ -102,7 +102,7 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => Table<u8>]),
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => Graphic]),
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => graphene_std::text::Font]),
-		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => Vec<BrushStroke>]),
+		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => Table<BrushStroke>]),
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => BrushCache]),
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => DocumentNode]),
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => graphene_std::raster::curve::Curve]),
@@ -180,7 +180,7 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 		async_node!(graphene_core::memo::MemoNode<_, _>, input: Context, fn_params: [Context => graphene_std::vector::style::Stroke]),
 		async_node!(graphene_core::memo::MemoNode<_, _>, input: Context, fn_params: [Context => graphene_std::vector::style::Gradient]),
 		async_node!(graphene_core::memo::MemoNode<_, _>, input: Context, fn_params: [Context => graphene_std::text::Font]),
-		async_node!(graphene_core::memo::MemoNode<_, _>, input: Context, fn_params: [Context => Vec<BrushStroke>]),
+		async_node!(graphene_core::memo::MemoNode<_, _>, input: Context, fn_params: [Context => Table<BrushStroke>]),
 		async_node!(graphene_core::memo::MemoNode<_, _>, input: Context, fn_params: [Context => BrushCache]),
 		async_node!(graphene_core::memo::MemoNode<_, _>, input: Context, fn_params: [Context => DocumentNode]),
 		async_node!(graphene_core::memo::MemoNode<_, _>, input: Context, fn_params: [Context => graphene_std::ContextFeatures]),

node-graph/nodes/brush/src/brush.rs

@@ -192,7 +192,7 @@ async fn brush(
 	/// Optional raster content that may be drawn onto.
 	mut image: Table<Raster<CPU>>,
 	/// The list of brush stroke paths drawn by the Brush tool, with each including both its coordinates and styles.
-	strokes: Vec<BrushStroke>,
+	strokes: Table<BrushStroke>,
 	/// Internal cache data used to accelerate rendering of the brush content.
 	cache: BrushCache,
 ) -> Table<Raster<CPU>> {
@@ -205,11 +205,15 @@ async fn brush(
 	let bounds = Table::new_from_row(table_row.clone()).bounding_box(DAffine2::IDENTITY, false);
 	let [start, end] = if let RenderBoundingBox::Rectangle(rect) = bounds { rect } else { [DVec2::ZERO, DVec2::ZERO] };
 	let image_bbox = AxisAlignedBbox { start, end };
-	let stroke_bbox = strokes.iter().map(|s| s.bounding_box()).reduce(|a, b| a.union(&b)).unwrap_or(AxisAlignedBbox::ZERO);
+	let stroke_bbox = strokes.iter_element_values().map(|s| s.bounding_box()).reduce(|a, b| a.union(&b)).unwrap_or(AxisAlignedBbox::ZERO);
 	let bbox = if image_bbox.size().length() < 0.1 { stroke_bbox } else { stroke_bbox.union(&image_bbox) };
 	let background_bounds = bbox.to_transform();
 
-	let mut draw_strokes: Vec<_> = strokes.iter().filter(|&s| !matches!(s.style.blend_mode, BlendMode::Erase | BlendMode::Restore)).cloned().collect();
+	let mut draw_strokes: Vec<_> = strokes
+		.iter_element_values()
+		.filter(|&s| !matches!(s.style.blend_mode, BlendMode::Erase | BlendMode::Restore))
+		.cloned()
+		.collect();
 
 	let mut brush_plan = cache.compute_brush_plan(table_row, &draw_strokes);
 
@@ -273,12 +277,12 @@ async fn brush(
 		actual_image = blend_with_mode(actual_image, stroke_texture, stroke.style.blend_mode, (stroke.style.color.a() * 100.) as f64);
 	}
 
-	let has_erase_or_restore_strokes = strokes.iter().any(|s| matches!(s.style.blend_mode, BlendMode::Erase | BlendMode::Restore));
+	let has_erase_or_restore_strokes = strokes.iter_element_values().any(|s| matches!(s.style.blend_mode, BlendMode::Erase | BlendMode::Restore));
 	if has_erase_or_restore_strokes {
 		let opaque_image = Image::new(bbox.size().x as u32, bbox.size().y as u32, Color::WHITE);
 		let mut erase_restore_mask = TableRow::new_from_element(Raster::new_cpu(opaque_image)).with_attribute("transform", background_bounds);
 
-		for stroke in strokes {
+		for stroke in strokes.into_iter().map(|row| row.into_element()) {
 			let mut brush_texture = cache.get_cached_brush(&stroke.style);
 			if brush_texture.is_none() {
 				let tex = create_brush_texture(&stroke.style).await;

node-graph/nodes/brush/src/lib.rs

@@ -1,3 +1,25 @@
 pub mod brush;
 pub mod brush_cache;
 pub mod brush_stroke;
+
+pub mod migrations {
+	use crate::brush_stroke::BrushStroke;
+	use core_types::table::{Table, TableRow};
+
+	// TODO: Eventually remove this migration document upgrade code
+	pub fn migrate_brush_strokes_to_table<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Result<Table<BrushStroke>, D::Error> {
+		use serde::Deserialize;
+
+		#[derive(serde::Serialize, serde::Deserialize)]
+		#[serde(untagged)]
+		enum BrushStrokeTableFormat {
+			BrushStrokes(Vec<BrushStroke>),
+			BrushStrokeTable(Table<BrushStroke>),
+		}
+
+		Ok(match BrushStrokeTableFormat::deserialize(deserializer)? {
+			BrushStrokeTableFormat::BrushStrokes(strokes) => strokes.into_iter().map(TableRow::new_from_element).collect(),
+			BrushStrokeTableFormat::BrushStrokeTable(table) => table,
+		})
+	}
+}