Refactor the 'Fill' and 'Stroke' nodes to set "fill" and "stroke" attributes for paints (#4257)

* Allow using any graphics type for fill

* Adapt gradient/fill property panels and tools to handle List<T>

* Make the initial gradient transform covers the target's bounding box

* Introduce AnyGraphicListDyn to avoid combinatorial explosion

* Allow using any graphics type for stroke paint

* Add FIll node migration

* Add `for_each_vector_list_mut` instead of `set_paint_attribute`

* Adapt paint flow to read and write attributes instead of legacy Fill/Stroke.color

* Fix responsibilities of paint related node input setters

* Fix Morph by storing List<Graphic> for attributes rather than the concrete types

Store fill/stroke paints as List<Graphic> so Color/Gradient transitions
do not hit set_attribute_value_dyn's type-mismatch fallback to default paint.

* Preserve paint attributes in vector editing ops

* Enhance the clarity between direct and chained fill gradients

* Update demo arts

* Consolidate Fill node gradient appearance inputs

* Fix after the cubic review

* Revert "Consolidate Fill node gradient appearance inputs"

This reverts commit 9622feb20196e2c4da99e98ca95dcc2e34c2c98e.

* Replace AnyGraphicListDyn with generic paint connectors on the Fill and Stroke nodes

* Canonicalize paint attribute storage to List<Graphic> with a single write helper

* Fix Solidify Stroke missing fills stored in the legacy style

* Fix Solidify Stroke producing invisible strokes for legacy-only stroke colors

* Fix the initial gradient transform ignoring the bounding box's vertical extent

* Step paint at the morph midpoint instead of dropping it for unmixable pairings

* Remove migration-stage comments

* Clarify the initial gradient transform helper's doc and name

* Correct the bake_paint_transforms doc and prune dead tolerance arms

* Delete the unused Gradient::lerp

* Fix a comment typo

* Thread network paths through the legacy gradient bake so nested fills migrate

* Restore the legacy fill fallback in Expand Fill and Stroke

* Read gradient stops from the node's own input in the Fill properties panel

* Use the transform input constant instead of a hardcoded index

* Remove the unreachable wired color fallback in the Fill properties solid branch

* Narrow the fill overlay redraw check to actual fill inputs

* Coalesce the fill setter's graph runs into a single dispatch

* Position the Gradient Value node inserted for gradient stops

* Bake backup gradient placement during migration

* Persist pending gradient bakes so unfinished migrations retry on reopen

* Migrate the backup gradient's type and spread method

* Harden the gradient-migration pass against document switches and stale bakes

* Keep the Fill properties UI for layerless and nested Fill nodes

* Leave a wired gradient transform input connected instead of overwriting it

* Refuse to start a gradient chain ahead of existing layer content

* Decode a Fill node's gradient through one shared reader

* Nudge a degenerate bounding box so the Fill gradient transform stays invertible

* Broadcast Fill and Stroke paint with a single attribute-column pass

* Fix Morph stepping the target's stroke in near the source instead of the target

* Tidy conventions: clippy get_first, comment periods, sentence-case test messages

* Reattach the gradient orientation doc to its function

* Re-save demo artwork

---------

Co-authored-by: Keavon Chambers <keavon@keavon.com>

node-graph/libraries/core-types/src/list.rs

@@ -673,6 +673,21 @@ impl ItemAttributeValues {
 		}
 		self.0.push((to_key, value));
 	}
+
+	/// Clones the attribute with `key` from `source`, replacing any existing attribute with the same key.
+	pub fn insert_cloned_from(&mut self, source: &Self, key: &str) {
+		let Some((_, value)) = source.0.iter().find(|(existing_key, _)| existing_key == key) else {
+			return;
+		};
+
+		let value = value.clone();
+
+		if let Some((_, existing_value)) = self.0.iter_mut().find(|(existing_key, _)| existing_key == key) {
+			*existing_value = value;
+		} else {
+			self.0.push((key.to_string(), value));
+		}
+	}
 }
 
 // ==========

node-graph/libraries/graphic-types/src/graphic.rs

@@ -1,6 +1,6 @@
 use core_types::bounds::{BoundingBox, RenderBoundingBox};
 use core_types::graphene_hash::CacheHash;
-use core_types::list::{ATTR_FILL, ATTR_STROKE, Item, List};
+use core_types::list::{ATTR_FILL, ATTR_STROKE, Item, ItemAttributeValues, List};
 use core_types::ops::{FromAnchorPosition, ListConvert};
 use core_types::render_complexity::RenderComplexity;
 use core_types::uuid::NodeId;
@@ -215,29 +215,34 @@ pub fn color_to_graphic_list(color: Option<Color>) -> Option<List<Graphic>> {
 	color.as_ref().map(|color| List::new_from_element((*color).into()))
 }
 
-/// Look up the paint graphics stored under attribute for a vector item, normalizing any graphic list type to `List<Graphic>`.
+/// Whether a normalized paint graphic list actually carries renderable paint.
+/// A 0-item list, or a list whose first graphic is empty, is treated as no paint.
+pub fn is_paint_present(graphic_list: &List<Graphic>) -> bool {
+	graphic_list.element(0).is_some_and(|graphic| !graphic.is_empty())
+}
+
+/// Look up the paint graphics stored under attribute for a vector item, in the canonical `List<Graphic>` form.
 pub fn graphic_list_at<'a>(list: &'a List<Vector>, index: usize, attribute: &str) -> Option<Cow<'a, List<Graphic>>> {
 	list.attribute::<List<Graphic>>(attribute, index)
 		.map(Cow::Borrowed)
-		.or_else(|| list.attribute::<List<Color>>(attribute, index).map(|c| Cow::Owned(c.clone().into_graphic_list())))
-		.or_else(|| list.attribute::<List<GradientStops>>(attribute, index).map(|g| Cow::Owned(g.clone().into_graphic_list())))
-		.or_else(|| list.attribute::<List<Vector>>(attribute, index).map(|v| Cow::Owned(v.clone().into_graphic_list())))
-		.or_else(|| list.attribute::<List<Raster<CPU>>>(attribute, index).map(|r| Cow::Owned(r.clone().into_graphic_list())))
-		.or_else(|| list.attribute::<List<Raster<GPU>>>(attribute, index).map(|r| Cow::Owned(r.clone().into_graphic_list())))
 		// Treat a blank attribute as absent so consumers fall back to the legacy `style` instead of masking it.
-		.filter(|graphic_list| graphic_list.element(0).is_some_and(|graphic| !graphic.is_empty()))
+		.filter(|graphic_list| is_paint_present(graphic_list))
 }
 
-/// Whether the item carries a non-blank paint attribute in any representation (`Graphic`, `Color`,
-/// `GradientStops`, `Vector`, or raster), checked by borrowing without cloning the renderable list.
+/// Whether the item carries a non-blank canonical `List<Graphic>` paint attribute,
+/// checked by borrowing without cloning the renderable list.
 pub fn has_paint_at(list: &List<Vector>, index: usize, attribute: &str) -> bool {
-	list.attribute::<List<Graphic>>(attribute, index)
-		.is_some_and(|graphics| graphics.element(0).is_some_and(|graphic| !graphic.is_empty()))
-		|| list.attribute::<List<Color>>(attribute, index).is_some_and(|paint_list| !paint_list.is_empty())
-		|| list.attribute::<List<GradientStops>>(attribute, index).is_some_and(|paint_list| !paint_list.is_empty())
-		|| list.attribute::<List<Vector>>(attribute, index).is_some_and(|paint_list| !paint_list.is_empty())
-		|| list.attribute::<List<Raster<CPU>>>(attribute, index).is_some_and(|paint_list| !paint_list.is_empty())
-		|| list.attribute::<List<Raster<GPU>>>(attribute, index).is_some_and(|paint_list| !paint_list.is_empty())
+	list.attribute::<List<Graphic>>(attribute, index).is_some_and(is_paint_present)
+}
+
+/// Stores a paint attribute in its canonical `List<Graphic>` form, the only representation paint readers accept.
+pub fn set_paint_attribute(attributes: &mut ItemAttributeValues, key: &str, paint: impl IntoGraphicList) {
+	attributes.insert(key, paint.into_graphic_list());
+}
+
+/// Stores a paint attribute at a list index in its canonical `List<Graphic>` form, the only representation paint readers accept.
+pub fn set_paint_attribute_at<T>(list: &mut List<T>, index: usize, key: &str, paint: impl IntoGraphicList) {
+	list.set_attribute(key, index, paint.into_graphic_list());
 }
 
 /// Look up the fill paint graphics for a vector item, falling back to the legacy
@@ -320,6 +325,36 @@ pub fn is_stroke_fully_transparent_at(list: &List<Vector>, index: usize) -> bool
 	color.a() == 0.
 }
 
+/// Bake the provided transform into the per-item transforms of the paint graphics stored under the
+/// canonical `List<Graphic>` fill and stroke attributes.
+pub fn bake_paint_transforms(attributes: &mut ItemAttributeValues, transform: DAffine2) {
+	fn bake_list_transform<T>(list: &mut List<T>, transform: DAffine2) {
+		for item_transform in list.iter_attribute_values_mut_or_default::<DAffine2>(ATTR_TRANSFORM) {
+			*item_transform = transform * *item_transform;
+		}
+	}
+
+	fn bake_graphic_paint_transform(graphics: &mut List<Graphic>, transform: DAffine2) {
+		for graphic in graphics.iter_element_values_mut() {
+			match graphic {
+				Graphic::Graphic(list) => bake_list_transform(list, transform),
+				Graphic::Vector(list) => bake_list_transform(list, transform),
+				Graphic::RasterCPU(list) => bake_list_transform(list, transform),
+				Graphic::RasterGPU(list) => bake_list_transform(list, transform),
+				Graphic::Gradient(list) => bake_list_transform(list, transform),
+				Graphic::Text(list) => bake_list_transform(list, transform),
+				Graphic::Color(_) => {}
+			}
+		}
+	}
+
+	for paint_key in [ATTR_FILL, ATTR_STROKE] {
+		if let Some(graphics) = attributes.get_mut::<List<Graphic>>(paint_key) {
+			bake_graphic_paint_transform(graphics, transform);
+		}
+	}
+}
+
 /// Maps from a concrete element type to its corresponding `Graphic` enum variant,
 /// enabling type-directed casting of typed `List`s from a `Graphic` value.
 pub trait TryFromGraphic: Clone + Sized {
@@ -357,7 +392,7 @@ impl TryFromGraphic for String {
 }
 
 // Local trait to convert types to List<Graphic> (avoids orphan rule issues)
-pub trait IntoGraphicList {
+pub trait IntoGraphicList: Clone + Send + Sync + Default + std::fmt::Debug + PartialEq + CacheHash + 'static {
 	fn into_graphic_list(self) -> List<Graphic>;
 
 	/// Deeply flattens any content of type `T` within a `List<Graphic>`, discarding all other content, and returning a flat `List<T>`.

node-graph/libraries/rendering/src/renderer.rs

@@ -21,7 +21,7 @@ use dyn_any::DynAny;
 use glam::{DAffine2, DMat2, DVec2};
 use graphene_hash::CacheHashWrapper;
 use graphene_resource::Resource;
-use graphic_types::graphic::{fill_graphic_list_at, graphic_list_at, has_paint_at, stroke_graphic_list_at};
+use graphic_types::graphic::{fill_graphic_list_at, graphic_list_at, has_paint_at, is_paint_present, set_paint_attribute, stroke_graphic_list_at};
 use graphic_types::raster_types::{BitmapMut, CPU, GPU, Image, Raster};
 use graphic_types::vector_types::gradient::{GradientStops, GradientType};
 use graphic_types::vector_types::subpath::Subpath;
@@ -1128,11 +1128,12 @@ impl Render for List<Vector> {
 
 				let mut cloned_vector = vector.clone();
 				cloned_vector.style.clear_stroke();
-				cloned_vector.style.set_fill(Fill::solid(Color::BLACK));
 
 				// The mask must draw at full alpha so the SVG `<mask>`/`<clipPath>` fully zeroes the path interior.
 				// The wrapping SVG group (above) handles the user-set opacity.
-				let vector_item = List::new_from_item(Item::new_from_element(cloned_vector).with_attribute(ATTR_TRANSFORM, item_transform));
+				let mut mask_item = Item::new_from_element(cloned_vector).with_attribute(ATTR_TRANSFORM, item_transform);
+				set_paint_attribute(mask_item.attributes_mut(), ATTR_FILL, List::new_from_element(Color::BLACK));
+				let vector_item = List::new_from_item(mask_item);
 
 				(id, mask_type, vector_item)
 			});
@@ -1197,7 +1198,7 @@ impl Render for List<Vector> {
 					.style
 					.stroke()
 					.map(|stroke| {
-						if stroke_graphic_list.as_ref().and_then(|l| l.element(0)).is_some() {
+						if stroke_graphic_list.as_deref().is_some_and(is_paint_present) {
 							stroke.render(defs, item_transform, element_transform, applied_stroke_transform, bounds_matrix, &render_params, PaintTarget::Stroke)
 						} else {
 							String::new()
@@ -1474,11 +1475,12 @@ impl Render for List<Vector> {
 					if use_layer {
 						let mut cloned_element = element.clone();
 						cloned_element.style.clear_stroke();
-						cloned_element.style.set_fill(Fill::solid(Color::BLACK));
 
 						// The mask must draw at full alpha so `SrcOut` fully zeroes the path interior.
 						// The outer opacity/blend layer (above) handles the user-set opacity.
-						let vector_list = List::new_from_item(Item::new_from_element(cloned_element).with_attribute(ATTR_TRANSFORM, item_transform));
+						let mut mask_item = Item::new_from_element(cloned_element).with_attribute(ATTR_TRANSFORM, item_transform);
+						set_paint_attribute(mask_item.attributes_mut(), ATTR_FILL, List::new_from_element(Color::BLACK));
+						let vector_list = List::new_from_item(mask_item);
 
 						let bounds = element.bounding_box_with_transform(multiplied_transform).unwrap_or(layer_bounds);
 						// This branch is gated on `can_draw_aligned_stroke`, which already requires every subpath is closed

node-graph/libraries/vector-types/src/gradient.rs

@@ -458,6 +458,15 @@ impl GradientStops {
 
 		result
 	}
+
+	pub fn lerp(&self, other: &Self, time: f64) -> Self {
+		let stops = self.iter().zip(other.iter()).map(|(a, b)| {
+			let position = a.position + (b.position - a.position) * time;
+			let color = a.color.lerp(&b.color, time as f32);
+			GradientStop { position, midpoint: 0.5, color }
+		});
+		GradientStops::new(stops)
+	}
 }
 
 #[repr(C)]
@@ -601,30 +610,6 @@ impl Gradient {
 		}
 	}
 
-	pub fn lerp(&self, other: &Self, time: f64) -> Self {
-		let start = self.start + (other.start - self.start) * time;
-		let end = self.end + (other.end - self.end) * time;
-		let stops = self.stops.iter().zip(other.stops.iter()).map(|(a, b)| {
-			let position = a.position + (b.position - a.position) * time;
-			let color = a.color.lerp(&b.color, time as f32);
-			GradientStop { position, midpoint: 0.5, color }
-		});
-		let stops = GradientStops::new(stops);
-		let gradient_type = if time < 0.5 { self.gradient_type } else { other.gradient_type };
-		let spread_method = if time < 0.5 { self.spread_method } else { other.spread_method };
-
-		Self {
-			start,
-			end,
-			stops,
-			gradient_type,
-			spread_method,
-			// TODO: Eventually remove this document upgrade code
-			absolute: self.absolute,
-			transform: if time < 0.5 { self.transform } else { other.transform },
-		}
-	}
-
 	/// Insert a stop into the gradient, the index if successful
 	pub fn insert_stop(&mut self, mouse: DVec2, transform: DAffine2) -> Option<usize> {
 		// Transform the start and end positions to the same coordinate space as the mouse.
@@ -663,6 +648,54 @@ impl Gradient {
 	}
 }
 
+/// Rebuild the y-axis so its (parallel, perpendicular) components in the x-axis-aligned frame stay constant, both
+/// rescaled by `|new_x| / |old_x|`. This holds the (x, y) parallelogram's aspect ratio and skew fixed across an endpoint
+/// drag, so a radial ellipse stays the same shape (just rotated and resized) instead of distorting as x grows or shrinks.
+/// Falls back to a +90° rotation of `new_x` when `old_x` is degenerate.
+fn scale_y_axis_to_match_new_x(old_x: DVec2, old_y: DVec2, new_x: DVec2) -> DVec2 {
+	let old_x_length = old_x.length();
+	if old_x_length < 1e-9 {
+		return DVec2::new(-new_x.y, new_x.x);
+	}
+	let ex_old = old_x / old_x_length;
+	let ey_old = DVec2::new(-ex_old.y, ex_old.x);
+
+	let new_x_length = new_x.length();
+	if new_x_length < 1e-9 {
+		return DVec2::ZERO;
+	}
+	let ex_new = new_x / new_x_length;
+	let ey_new = DVec2::new(-ex_new.y, ex_new.x);
+
+	let parallel = old_y.dot(ex_old);
+	let perpendicular = old_y.dot(ey_old);
+	let scale = new_x_length / old_x_length;
+
+	scale * (parallel * ex_new + perpendicular * ey_new)
+}
+
+/// Build a new affine that maps canonical (0,0) -> (1,0) to (new_start, new_end), preserving the y-axis
+/// shape of `old` proportionally to the x-axis length change.
+pub fn build_transform_with_y_preservation(old: DAffine2, new_start: DVec2, new_end: DVec2) -> DAffine2 {
+	let new_x_axis = new_end - new_start;
+	let preserved_y_axis = scale_y_axis_to_match_new_x(old.matrix2.x_axis, old.matrix2.y_axis, new_x_axis);
+	DAffine2 {
+		matrix2: glam::DMat2::from_cols(new_x_axis, preserved_y_axis),
+		translation: new_start,
+	}
+}
+
+/// Build the default transform for a gradient not yet given one: a horizontal gradient spanning the
+/// bounding box's width, running through its vertical middle.
+pub fn initial_gradient_transform_for_bounding_box(bounds: [DVec2; 2]) -> DAffine2 {
+	let [min, max] = bounds;
+	let x_axis = DVec2::new(max.x - min.x, 0.);
+	DAffine2 {
+		matrix2: glam::DMat2::from_cols(x_axis, x_axis.perp()),
+		translation: DVec2::new(min.x, (min.y + max.y) / 2.),
+	}
+}
+
 // TODO: Eventually remove this migration document upgrade code
 pub fn migrate_to_gradient_stops<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Result<GradientStops, D::Error> {
 	use serde::Deserialize;

node-graph/libraries/vector-types/src/vector/style.rs

@@ -66,30 +66,6 @@ impl Fill {
 		}
 	}
 
-	pub fn lerp(&self, other: &Self, time: f64) -> Self {
-		let transparent = Self::solid(Color::TRANSPARENT);
-		let a = if *self == Self::None && *other != Self::None { &transparent } else { self };
-		let b = if *other == Self::None && *self != Self::None { &transparent } else { other };
-
-		match (a, b) {
-			(Self::Solid(a), Self::Solid(b)) => Self::Solid(a.lerp(b, time as f32)),
-			(Self::Solid(a), Self::Gradient(b)) => {
-				let mut solid_to_gradient = b.clone();
-				solid_to_gradient.stops.color.iter_mut().for_each(|color| *color = *a);
-				let a = &solid_to_gradient;
-				Self::Gradient(a.lerp(b, time))
-			}
-			(Self::Gradient(a), Self::Solid(b)) => {
-				let mut gradient_to_solid = a.clone();
-				gradient_to_solid.stops.color.iter_mut().for_each(|color| *color = *b);
-				let b = &gradient_to_solid;
-				Self::Gradient(a.lerp(b, time))
-			}
-			(Self::Gradient(a), Self::Gradient(b)) => Self::Gradient(a.lerp(b, time)),
-			(Self::None, _) | (_, Self::None) => Self::None,
-		}
-	}
-
 	/// Extract a gradient from the fill
 	pub fn as_gradient(&self) -> Option<&Gradient> {
 		match self {
@@ -389,7 +365,8 @@ fn daffine2_identity() -> DAffine2 {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(default))]
 pub struct Stroke {
-	/// Stroke color
+	/// Deprecated, use `ATTR_STROKE` instead.
+	/// TODO: Remove once all stroke paint sources flow through `List<Graphic>` directly without going through `Stroke.color`.
 	pub color: Option<Color>,
 	/// Line thickness
 	pub weight: f64,
@@ -632,30 +609,6 @@ impl PathStyle {
 		Self { stroke, fill }
 	}
 
-	pub fn lerp(&self, other: &Self, time: f64) -> Self {
-		Self {
-			fill: self.fill.lerp(&other.fill, time),
-			stroke: match (self.stroke.as_ref(), other.stroke.as_ref()) {
-				(Some(a), Some(b)) => Some(a.lerp(b, time)),
-				(Some(a), None) => {
-					if time < 0.5 {
-						Some(a.clone())
-					} else {
-						None
-					}
-				}
-				(None, Some(b)) => {
-					if time < 0.5 {
-						Some(b.clone())
-					} else {
-						None
-					}
-				}
-				(None, None) => None,
-			},
-		}
-	}
-
 	/// Get the current path's [Fill].
 	///
 	/// # Example
@@ -690,25 +643,6 @@ impl PathStyle {
 		self.stroke.clone()
 	}
 
-	/// Replace the path's [Fill] with a provided one.
-	///
-	/// # Example
-	/// ```
-	/// # use vector_types::vector::style::{Fill, PathStyle};
-	/// # use core_types::Color;
-	/// let mut style = PathStyle::default();
-	///
-	/// assert_eq!(*style.fill(), Fill::None);
-	///
-	/// let fill = Fill::solid(Color::RED);
-	/// style.set_fill(fill.clone());
-	///
-	/// assert_eq!(*style.fill(), fill);
-	/// ```
-	pub fn set_fill(&mut self, fill: Fill) {
-		self.fill = fill;
-	}
-
 	pub fn set_stroke_transform(&mut self, transform: DAffine2) {
 		if let Some(stroke) = &mut self.stroke {
 			stroke.transform = transform;