Add Table<Gradient> as a graphical type (#3051)

editor/src/messages/message.rs

@@ -69,7 +69,7 @@ mod test {
 
 	fn print_tree_node(tree: &DebugMessageTree, prefix: &str, is_last: bool, file: &mut std::fs::File) {
 		// Print the current node
-		let (branch, child_prefix) = if tree.has_message_handler_data_fields() || tree.has_message_handler_fields() {
+		let (branch, child_prefix) = if tree.message_handler_data_fields().is_some() || tree.message_handler_fields().is_some() {
 			("├── ", format!("{}│   ", prefix))
 		} else {
 			if is_last {
@@ -97,7 +97,7 @@ mod test {
 		// Print handler field if any
 		if let Some(data) = tree.message_handler_fields() {
 			let len = data.fields().len();
-			let (branch, child_prefix) = if tree.has_message_handler_data_fields() {
+			let (branch, child_prefix) = if tree.message_handler_data_fields().is_some() {
 				("├── ", format!("{}│   ", prefix))
 			} else {
 				("└── ", format!("{}    ", prefix))

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

@@ -7,6 +7,7 @@ use crate::messages::tool::tool_messages::tool_prelude::*;
 use graph_craft::document::NodeId;
 use graphene_std::Color;
 use graphene_std::Context;
+use graphene_std::gradient::GradientStops;
 use graphene_std::memo::IORecord;
 use graphene_std::raster_types::{CPU, GPU, Raster};
 use graphene_std::table::Table;
@@ -153,7 +154,6 @@ macro_rules! generate_layout_downcast {
 		else { None }
 	}
 }
-
 // TODO: We simply try all these types sequentially. Find a better strategy.
 fn generate_layout(introspected_data: &Arc<dyn std::any::Any + Send + Sync + 'static>, data: &mut LayoutData) -> Option<Vec<LayoutGroup>> {
 	generate_layout_downcast!(introspected_data, data, [
@@ -163,6 +163,7 @@ fn generate_layout(introspected_data: &Arc<dyn std::any::Any + Send + Sync + 'st
 		Table<Raster<CPU>>,
 		Table<Raster<GPU>>,
 		Table<Color>,
+		Table<GradientStops>,
 		f64,
 		u32,
 		u64,
@@ -263,6 +264,7 @@ impl TableRowLayout for Graphic {
 			Self::RasterCPU(table) => table.identifier(),
 			Self::RasterGPU(table) => table.identifier(),
 			Self::Color(table) => table.identifier(),
+			Self::Gradient(table) => table.identifier(),
 		}
 	}
 	// Don't put a breadcrumb for Graphic
@@ -276,6 +278,7 @@ impl TableRowLayout for Graphic {
 			Self::RasterCPU(table) => table.layout_with_breadcrumb(data),
 			Self::RasterGPU(table) => table.layout_with_breadcrumb(data),
 			Self::Color(table) => table.layout_with_breadcrumb(data),
+			Self::Gradient(table) => table.layout_with_breadcrumb(data),
 		}
 	}
 }
@@ -335,10 +338,6 @@ impl TableRowLayout for Vector {
 							TextLabel::new(format_dvec2(gradient.start)).widget_holder(),
 						]);
 						table_rows.push(vec![TextLabel::new("Fill Gradient End").widget_holder(), TextLabel::new(format_dvec2(gradient.end)).widget_holder()]);
-						table_rows.push(vec![
-							TextLabel::new("Fill Gradient Transform").widget_holder(),
-							TextLabel::new(format_transform_matrix(&gradient.transform)).widget_holder(),
-						]);
 					}
 				}
 
@@ -485,6 +484,25 @@ impl TableRowLayout for Color {
 	}
 }
 
+impl TableRowLayout for GradientStops {
+	fn type_name() -> &'static str {
+		"Gradient"
+	}
+	fn identifier(&self) -> String {
+		format!("Gradient ({} stops)", self.0.len())
+	}
+	fn element_widget(&self, _index: usize) -> WidgetHolder {
+		ColorInput::new(FillChoice::Gradient(self.clone()))
+			.disabled(true)
+			.menu_direction(Some(MenuDirection::Top))
+			.widget_holder()
+	}
+	fn element_page(&self, _data: &mut LayoutData) -> Vec<LayoutGroup> {
+		let widgets = vec![self.element_widget(0)];
+		vec![LayoutGroup::Row { widgets }]
+	}
+}
+
 impl TableRowLayout for f64 {
 	fn type_name() -> &'static str {
 		"Number (f64)"
@@ -545,7 +563,7 @@ impl TableRowLayout for String {
 		"String".to_string()
 	}
 	fn element_page(&self, _data: &mut LayoutData) -> Vec<LayoutGroup> {
-		let widgets = vec![TextLabel::new(self.to_string()).widget_holder()];
+		let widgets = vec![TextAreaInput::new(self.to_string()).disabled(true).widget_holder()];
 		vec![LayoutGroup::Row { widgets }]
 	}
 }

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

@@ -426,7 +426,6 @@ fn apply_usvg_fill(fill: &usvg::Fill, modify_inputs: &mut ModifyInputsContext, t
 			Fill::Gradient(Gradient {
 				start,
 				end,
-				transform: DAffine2::IDENTITY,
 				gradient_type: GradientType::Linear,
 				stops,
 			})
@@ -453,7 +452,6 @@ fn apply_usvg_fill(fill: &usvg::Fill, modify_inputs: &mut ModifyInputsContext, t
 			Fill::Gradient(Gradient {
 				start,
 				end,
-				transform: DAffine2::IDENTITY,
 				gradient_type: GradientType::Radial,
 				stops,
 			})

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

@@ -182,6 +182,7 @@ pub(crate) fn property_from_type(
 						// STRUCT TYPES
 						// ============
 						Some(x) if x == TypeId::of::<Table<Color>>() => color_widget(default_info, ColorInput::default().allow_none(true)),
+						Some(x) if x == TypeId::of::<Table<GradientStops>>() => color_widget(default_info, ColorInput::default().allow_none(false)),
 						Some(x) if x == TypeId::of::<GradientStops>() => color_widget(default_info, ColorInput::default().allow_none(false)),
 						Some(x) if x == TypeId::of::<Font>() => font_widget(default_info),
 						Some(x) if x == TypeId::of::<Curve>() => curve_widget(default_info),
@@ -922,6 +923,20 @@ pub fn color_widget(parameter_widgets_info: ParameterWidgetsInfo, color_button:
 				.on_commit(commit_value)
 				.widget_holder(),
 		),
+		TaggedValue::GradientTable(gradient_table) => widgets.push(
+			color_button
+				.value(match gradient_table.iter().next() {
+					Some(row) => FillChoice::Gradient(row.element.clone()),
+					None => FillChoice::None,
+				})
+				.on_update(update_value(
+					|input: &ColorInput| TaggedValue::GradientTable(input.value.as_gradient().iter().map(|&gradient| TableRow::new_from_element(gradient.clone())).collect()),
+					node_id,
+					index,
+				))
+				.on_commit(commit_value)
+				.widget_holder(),
+		),
 		TaggedValue::GradientStops(gradient_stops) => widgets.push(
 			color_button
 				.value(FillChoice::Gradient(gradient_stops.clone()))

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

@@ -14,6 +14,8 @@ pub enum FrontendGraphDataType {
 	Raster,
 	Vector,
 	Color,
+	Gradient,
+	Typography,
 }
 
 impl FrontendGraphDataType {
@@ -32,6 +34,8 @@ impl FrontendGraphDataType {
 			TaggedValue::Raster(_) => Self::Raster,
 			TaggedValue::Vector(_) => Self::Vector,
 			TaggedValue::Color(_) => Self::Color,
+			TaggedValue::Gradient(_) | TaggedValue::GradientStops(_) | TaggedValue::GradientTable(_) => Self::Gradient,
+			TaggedValue::String(_) => Self::Typography,
 			_ => Self::General,
 		}
 	}

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

@@ -204,7 +204,6 @@ impl SelectedGradient {
 
 	/// Update the layer fill to the current gradient
 	pub fn render_gradient(&mut self, responses: &mut VecDeque<Message>) {
-		self.gradient.transform = self.transform;
 		if let Some(layer) = self.layer {
 			responses.add(GraphOperationMessage::FillSet {
 				layer,
@@ -436,14 +435,7 @@ impl Fsm for GradientToolFsmState {
 							gradient.clone()
 						} else {
 							// Generate a new gradient
-							Gradient::new(
+							Gradient::new(DVec2::ZERO, global_tool_data.secondary_color, DVec2::ONE, global_tool_data.primary_color, tool_options.gradient_type)
-								DVec2::ZERO,
-								global_tool_data.secondary_color,
-								DVec2::ONE,
-								global_tool_data.primary_color,
-								DAffine2::IDENTITY,
-								tool_options.gradient_type,
-							)
 						};
 						let selected_gradient = SelectedGradient::new(gradient, layer, document).with_gradient_start(input.mouse.position);
 

editor/src/node_graph_executor.rs

@@ -8,13 +8,10 @@ use graph_craft::proto::GraphErrors;
 use graph_craft::wasm_application_io::EditorPreferences;
 use graphene_std::application_io::TimingInformation;
 use graphene_std::application_io::{NodeGraphUpdateMessage, RenderConfig};
-use graphene_std::renderer::RenderSvgSegmentList;
-use graphene_std::renderer::{Render, RenderParams, SvgRender};
 use graphene_std::renderer::{RenderMetadata, format_transform_matrix};
 use graphene_std::text::FontCache;
 use graphene_std::transform::Footprint;
 use graphene_std::vector::Vector;
-use graphene_std::vector::style::ViewMode;
 use graphene_std::wasm_application_io::RenderOutputType;
 use interpreted_executor::dynamic_executor::ResolvedDocumentNodeTypesDelta;
 
@@ -34,7 +31,6 @@ pub struct ExecutionResponse {
 	execution_id: u64,
 	result: Result<TaggedValue, String>,
 	responses: VecDeque<FrontendMessage>,
-	footprint: Footprint,
 	vector_modify: HashMap<NodeId, Vector>,
 	/// The resulting value from the temporary inspected during execution
 	inspect_result: Option<InspectResult>,
@@ -131,6 +127,7 @@ impl NodeGraphExecutor {
 				.send(GraphRuntimeRequest::GraphUpdate(GraphUpdate { network, node_to_inspect }))
 				.map_err(|e| e.to_string())?;
 		}
+
 		Ok(())
 	}
 
@@ -252,6 +249,7 @@ impl NodeGraphExecutor {
 			let size = (size * scale_factor).into();
 			responses.add(FrontendMessage::TriggerExportImage { svg, name, mime, size });
 		}
+
 		Ok(())
 	}
 
@@ -264,7 +262,6 @@ impl NodeGraphExecutor {
 						execution_id,
 						result,
 						responses: existing_responses,
-						footprint,
 						vector_modify,
 						inspect_result,
 					} = execution_response;
@@ -289,7 +286,7 @@ impl NodeGraphExecutor {
 						// Special handling for exporting the artwork
 						self.export(node_graph_output, export_config, responses)?;
 					} else {
-						self.process_node_graph_output(node_graph_output, footprint, responses)?;
+						self.process_node_graph_output(node_graph_output, responses)?;
 					}
 					responses.add_front(DeferMessage::TriggerGraphRun(execution_id, execution_context.document_id));
 
@@ -330,73 +327,41 @@ impl NodeGraphExecutor {
 				}
 			}
 		}
+
 		Ok(())
 	}
 
-	fn debug_render(render_object: impl Render, footprint: Footprint, responses: &mut VecDeque<Message>) {
+	fn process_node_graph_output(&mut self, node_graph_output: TaggedValue, responses: &mut VecDeque<Message>) -> Result<(), String> {
-		// Setup rendering
+		let TaggedValue::RenderOutput(render_output) = node_graph_output else {
-		let mut render = SvgRender::new();
+			return Err(format!("Invalid node graph output type: {node_graph_output:#?}"));
-		let render_params = RenderParams {
-			view_mode: ViewMode::Normal,
-			footprint,
-			thumbnail: false,
-			hide_artboards: false,
-			for_export: false,
-			for_mask: false,
-			alignment_parent_transform: None,
 		};
 
-		// Render SVG
+		match render_output.data {
-		render_object.render_svg(&mut render, &render_params);
+			RenderOutputType::Svg { svg, image_data } => {
-
+				// Send to frontend
-		// Concatenate the defs and the SVG into one string
+				responses.add(FrontendMessage::UpdateImageData { image_data });
-		render.wrap_with_transform(footprint.transform, None);
+				responses.add(FrontendMessage::UpdateDocumentArtwork { svg });
-		let svg = render.svg.to_svg_string();
-
-		// Send to frontend
-		responses.add(FrontendMessage::UpdateDocumentArtwork { svg });
-	}
-
-	fn process_node_graph_output(&mut self, node_graph_output: TaggedValue, footprint: Footprint, responses: &mut VecDeque<Message>) -> Result<(), String> {
-		let mut render_output_metadata = RenderMetadata::default();
-
-		match node_graph_output {
-			TaggedValue::RenderOutput(render_output) => {
-				match render_output.data {
-					RenderOutputType::Svg { svg, image_data } => {
-						// Send to frontend
-						responses.add(FrontendMessage::UpdateImageData { image_data });
-						responses.add(FrontendMessage::UpdateDocumentArtwork { svg });
-					}
-					RenderOutputType::CanvasFrame(frame) => {
-						let matrix = format_transform_matrix(frame.transform);
-						let transform = if matrix.is_empty() { String::new() } else { format!(" transform=\"{matrix}\"") };
-						let svg = format!(
-							r#"<svg><foreignObject width="{}" height="{}"{transform}><div data-canvas-placeholder="{}"></div></foreignObject></svg>"#,
-							frame.resolution.x, frame.resolution.y, frame.surface_id.0
-						);
-						responses.add(FrontendMessage::UpdateDocumentArtwork { svg });
-					}
-					RenderOutputType::Texture { .. } => {}
-					_ => return Err(format!("Invalid node graph output type: {:#?}", render_output.data)),
-				}
-
-				render_output_metadata = render_output.metadata;
 			}
-			TaggedValue::Bool(render_object) => Self::debug_render(render_object, footprint, responses),
+			RenderOutputType::CanvasFrame(frame) => {
-			TaggedValue::F64(render_object) => Self::debug_render(render_object, footprint, responses),
+				let matrix = format_transform_matrix(frame.transform);
-			TaggedValue::DVec2(render_object) => Self::debug_render(render_object, footprint, responses),
+				let transform = if matrix.is_empty() { String::new() } else { format!(" transform=\"{matrix}\"") };
-			TaggedValue::String(render_object) => Self::debug_render(render_object, footprint, responses),
+				let svg = format!(
-			_ => return Err(format!("Invalid node graph output type: {node_graph_output:#?}")),
+					r#"<svg><foreignObject width="{}" height="{}"{transform}><div data-canvas-placeholder="{}"></div></foreignObject></svg>"#,
-		};
+					frame.resolution.x, frame.resolution.y, frame.surface_id.0
+				);
+				responses.add(FrontendMessage::UpdateDocumentArtwork { svg });
+			}
+			RenderOutputType::Texture { .. } => {}
+			_ => return Err(format!("Invalid node graph output type: {:#?}", render_output.data)),
+		}
 
-		let graphene_std::renderer::RenderMetadata {
+		let RenderMetadata {
 			upstream_footprints,
 			local_transforms,
 			first_element_source_id,
 			click_targets,
 			clip_targets,
-		} = render_output_metadata;
+		} = render_output.metadata;
 
 		// Run these update state messages immediately
 		responses.add(DocumentMessage::UpdateUpstreamTransforms {
@@ -409,6 +374,7 @@ impl NodeGraphExecutor {
 		responses.add(DocumentMessage::RenderScrollbars);
 		responses.add(DocumentMessage::RenderRulers);
 		responses.add(OverlaysMessage::Draw);
+
 		Ok(())
 	}
 }

editor/src/node_graph_executor/runtime.rs

@@ -16,7 +16,6 @@ use graphene_std::table::{Table, TableRow};
 use graphene_std::text::FontCache;
 use graphene_std::transform::RenderQuality;
 use graphene_std::vector::Vector;
-use graphene_std::vector::style::ViewMode;
 use graphene_std::wasm_application_io::{RenderOutputType, WasmApplicationIo, WasmEditorApi};
 use graphene_std::{Artboard, Context, Graphic};
 use interpreted_executor::dynamic_executor::{DynamicExecutor, IntrospectError, ResolvedDocumentNodeTypesDelta};
@@ -228,7 +227,6 @@ impl NodeRuntime {
 						execution_id,
 						result,
 						responses,
-						footprint: render_config.viewport,
 						vector_modify: self.vector_modify.clone(),
 						inspect_result,
 					});
@@ -361,13 +359,9 @@ impl NodeRuntime {
 
 		// Render the thumbnail from a `Graphic` into an SVG string
 		let render_params = RenderParams {
-			view_mode: ViewMode::Normal,
 			footprint,
 			thumbnail: true,
-			hide_artboards: false,
+			..Default::default()
-			for_export: false,
-			for_mask: false,
-			alignment_parent_transform: None,
 		};
 		let mut render = SvgRender::new();
 		graphic.render_svg(&mut render, &render_params);

editor/src/utility_types.rs

@@ -82,18 +82,4 @@ impl DebugMessageTree {
 	pub fn message_handler_fields(&self) -> Option<&MessageData> {
 		self.message_handler.as_ref()
 	}
-
-	pub fn has_message_handler_data_fields(&self) -> bool {
-		match self.message_handler_data_fields() {
-			Some(_) => true,
-			None => false,
-		}
-	}
-
-	pub fn has_message_handler_fields(&self) -> bool {
-		match self.message_handler_fields() {
-			Some(_) => true,
-			None => false,
-		}
-	}
 }

frontend/src/components/Editor.svelte

@@ -123,8 +123,12 @@
 		--color-data-raster-dim: #9a7b43;
 		--color-data-vector: #65bbe5;
 		--color-data-vector-dim: #417892;
-		--color-data-color: #af81eb;
+		--color-data-color: #ce6ea7;
-		--color-data-color-dim: #6c489b;
+		--color-data-color-dim: #924071;
+		--color-data-gradient: #af81eb;
+		--color-data-gradient-dim: #6c489b;
+		--color-data-typography: #eea7a7;
+		--color-data-typography-dim: #955252;
 
 		--color-none: white;
 		--color-none-repeat: no-repeat;

node-graph/gcore/src/artboard.rs

@@ -1,5 +1,6 @@
 use crate::blending::AlphaBlending;
 use crate::bounds::{BoundingBox, RenderBoundingBox};
+use crate::gradient::GradientStops;
 use crate::math::quad::Quad;
 use crate::raster_types::{CPU, GPU, Raster};
 use crate::table::{Table, TableRow};
@@ -98,6 +99,7 @@ async fn create_artboard<T: Into<Table<Graphic>> + 'n>(
 		Context -> Table<Raster<CPU>>,
 		Context -> Table<Raster<GPU>>,
 		Context -> Table<Color>,
+		Context -> Table<GradientStops>,
 		Context -> DAffine2,
 	)]
 	content: impl Node<Context<'static>, Output = T>,

node-graph/gcore/src/blending_nodes.rs

@@ -1,3 +1,4 @@
+use crate::gradient::GradientStops;
 use crate::raster_types::{CPU, Raster};
 use crate::registry::types::Percentage;
 use crate::table::Table;
@@ -41,6 +42,13 @@ impl MultiplyAlpha for Table<Color> {
 		}
 	}
 }
+impl MultiplyAlpha for Table<GradientStops> {
+	fn multiply_alpha(&mut self, factor: f64) {
+		for row in self.iter_mut() {
+			row.alpha_blending.opacity *= factor as f32;
+		}
+	}
+}
 
 pub(super) trait MultiplyFill {
 	fn multiply_fill(&mut self, factor: f64);
@@ -78,6 +86,13 @@ impl MultiplyFill for Table<Color> {
 		}
 	}
 }
+impl MultiplyFill for Table<GradientStops> {
+	fn multiply_fill(&mut self, factor: f64) {
+		for row in self.iter_mut() {
+			row.alpha_blending.fill *= factor as f32;
+		}
+	}
+}
 
 trait SetBlendMode {
 	fn set_blend_mode(&mut self, blend_mode: BlendMode);
@@ -111,6 +126,13 @@ impl SetBlendMode for Table<Color> {
 		}
 	}
 }
+impl SetBlendMode for Table<GradientStops> {
+	fn set_blend_mode(&mut self, blend_mode: BlendMode) {
+		for row in self.iter_mut() {
+			row.alpha_blending.blend_mode = blend_mode;
+		}
+	}
+}
 
 trait SetClip {
 	fn set_clip(&mut self, clip: bool);
@@ -144,6 +166,13 @@ impl SetClip for Table<Color> {
 		}
 	}
 }
+impl SetClip for Table<GradientStops> {
+	fn set_clip(&mut self, clip: bool) {
+		for row in self.iter_mut() {
+			row.alpha_blending.clip = clip;
+		}
+	}
+}
 
 #[node_macro::node(category("Style"))]
 fn blend_mode<T: SetBlendMode>(
@@ -153,6 +182,7 @@ fn blend_mode<T: SetBlendMode>(
 		Table<Vector>,
 		Table<Raster<CPU>>,
 		Table<Color>,
+		Table<GradientStops>,
 	)]
 	mut value: T,
 	blend_mode: BlendMode,
@@ -170,6 +200,7 @@ fn opacity<T: MultiplyAlpha>(
 		Table<Vector>,
 		Table<Raster<CPU>>,
 		Table<Color>,
+		Table<GradientStops>,
 	)]
 	mut value: T,
 	#[default(100.)] opacity: Percentage,
@@ -187,6 +218,7 @@ fn blending<T: SetBlendMode + MultiplyAlpha + MultiplyFill + SetClip>(
 		Table<Vector>,
 		Table<Raster<CPU>>,
 		Table<Color>,
+		Table<GradientStops>,
 	)]
 	mut value: T,
 	blend_mode: BlendMode,

node-graph/gcore/src/bounds.rs

@@ -1,4 +1,4 @@
-use crate::Color;
+use crate::{Color, gradient::GradientStops};
 use glam::{DAffine2, DVec2};
 
 #[derive(Clone, Copy, Default, Debug, PartialEq)]
@@ -33,3 +33,8 @@ impl BoundingBox for Color {
 		RenderBoundingBox::Infinite
 	}
 }
+impl BoundingBox for GradientStops {
+	fn bounding_box(&self, _transform: DAffine2, _include_stroke: bool) -> RenderBoundingBox {
+		RenderBoundingBox::Infinite
+	}
+}

node-graph/gcore/src/gradient.rs

@@ -126,7 +126,6 @@ pub struct Gradient {
 	pub gradient_type: GradientType,
 	pub start: DVec2,
 	pub end: DVec2,
-	pub transform: DAffine2,
 }
 
 impl Default for Gradient {
@@ -136,7 +135,6 @@ impl Default for Gradient {
 			gradient_type: GradientType::Linear,
 			start: DVec2::new(0., 0.5),
 			end: DVec2::new(1., 0.5),
-			transform: DAffine2::IDENTITY,
 		}
 	}
 }
@@ -147,7 +145,6 @@ impl std::hash::Hash for Gradient {
 		[].iter()
 			.chain(self.start.to_array().iter())
 			.chain(self.end.to_array().iter())
-			.chain(self.transform.to_cols_array().iter())
 			.chain(self.stops.0.iter().map(|(position, _)| position))
 			.for_each(|x| x.to_bits().hash(state));
 		self.stops.0.iter().for_each(|(_, color)| color.hash(state));
@@ -171,20 +168,15 @@ impl std::fmt::Display for Gradient {
 
 impl Gradient {
 	/// Constructs a new gradient with the colors at 0 and 1 specified.
-	pub fn new(start: DVec2, start_color: Color, end: DVec2, end_color: Color, transform: DAffine2, gradient_type: GradientType) -> Self {
+	pub fn new(start: DVec2, start_color: Color, end: DVec2, end_color: Color, gradient_type: GradientType) -> Self {
-		Gradient {
+		let stops = GradientStops::new(vec![(0., start_color.to_gamma_srgb()), (1., end_color.to_gamma_srgb())]);
-			start,
+
-			end,
+		Self { start, end, stops, gradient_type }
-			stops: GradientStops::new(vec![(0., start_color.to_gamma_srgb()), (1., end_color.to_gamma_srgb())]),
-			transform,
-			gradient_type,
-		}
 	}
 
 	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 transform = self.transform;
 		let stops = self
 			.stops
 			.0
@@ -199,13 +191,7 @@ impl Gradient {
 		let stops = GradientStops::new(stops);
 		let gradient_type = if time < 0.5 { self.gradient_type } else { other.gradient_type };
 
-		Self {
+		Self { start, end, stops, gradient_type }
-			start,
-			end,
-			transform,
-			stops,
-			gradient_type,
-		}
 	}
 
 	/// Insert a stop into the gradient, the index if successful

node-graph/gcore/src/graphic.rs

@@ -1,5 +1,6 @@
 use crate::blending::AlphaBlending;
 use crate::bounds::{BoundingBox, RenderBoundingBox};
+use crate::gradient::GradientStops;
 use crate::raster_types::{CPU, GPU, Raster};
 use crate::table::{Table, TableRow};
 use crate::uuid::NodeId;
@@ -17,6 +18,7 @@ pub enum Graphic {
 	RasterCPU(Table<Raster<CPU>>),
 	RasterGPU(Table<Raster<GPU>>),
 	Color(Table<Color>),
+	Gradient(Table<GradientStops>),
 }
 
 impl Default for Graphic {
@@ -145,6 +147,28 @@ impl From<Table<Color>> for Option<Color> {
 	}
 }
 
+// GradientStops
+impl From<GradientStops> for Graphic {
+	fn from(gradient: GradientStops) -> Self {
+		Graphic::Gradient(Table::new_from_element(gradient))
+	}
+}
+impl From<Table<GradientStops>> for Graphic {
+	fn from(gradient: Table<GradientStops>) -> Self {
+		Graphic::Gradient(gradient)
+	}
+}
+impl From<GradientStops> for Table<Graphic> {
+	fn from(gradient: GradientStops) -> Self {
+		Table::new_from_element(Graphic::Gradient(Table::new_from_element(gradient)))
+	}
+}
+impl From<Table<GradientStops>> for Table<Graphic> {
+	fn from(gradient: Table<GradientStops>) -> Self {
+		Table::new_from_element(Graphic::Gradient(gradient))
+	}
+}
+
 // DAffine2
 impl From<DAffine2> for Graphic {
 	fn from(_: DAffine2) -> Self {
@@ -207,6 +231,7 @@ impl Graphic {
 			Graphic::RasterCPU(raster) => raster.iter().all(|row| row.alpha_blending.clip),
 			Graphic::RasterGPU(raster) => raster.iter().all(|row| row.alpha_blending.clip),
 			Graphic::Color(color) => color.iter().all(|row| row.alpha_blending.clip),
+			Graphic::Gradient(gradient) => gradient.iter().all(|row| row.alpha_blending.clip),
 		}
 	}
 
@@ -230,6 +255,7 @@ impl BoundingBox for Graphic {
 			Graphic::RasterGPU(raster) => raster.bounding_box(transform, include_stroke),
 			Graphic::Graphic(graphic) => graphic.bounding_box(transform, include_stroke),
 			Graphic::Color(color) => color.bounding_box(transform, include_stroke),
+			Graphic::Gradient(gradient) => gradient.bounding_box(transform, include_stroke),
 		}
 	}
 }
@@ -237,7 +263,7 @@ impl BoundingBox for Graphic {
 #[node_macro::node(category(""))]
 async fn source_node_id<I: 'n + Send + Clone>(
 	_: impl Ctx,
-	#[implementations(Table<Artboard>, Table<Graphic>, Table<Vector>, Table<Raster<CPU>>, Table<Raster<GPU>>, Table<Color>)] content: Table<I>,
+	#[implementations(Table<Artboard>, Table<Graphic>, Table<Vector>, Table<Raster<CPU>>, Table<Raster<GPU>>, Table<Color>, Table<GradientStops>)] content: Table<I>,
 	node_path: Vec<NodeId>,
 ) -> Table<I> {
 	// Get the penultimate element of the node path, or None if the path is too short
@@ -257,11 +283,11 @@ async fn source_node_id<I: 'n + Send + Clone>(
 async fn extend<I: 'n + Send + Clone>(
 	_: impl Ctx,
 	/// The table whose rows will appear at the start of the extended table.
-	#[implementations(Table<Artboard>, Table<Graphic>, Table<Vector>, Table<Raster<CPU>>, Table<Raster<GPU>>, Table<Color>)]
+	#[implementations(Table<Artboard>, Table<Graphic>, Table<Vector>, Table<Raster<CPU>>, Table<Raster<GPU>>, Table<Color>, Table<GradientStops>)]
 	base: Table<I>,
 	/// The table whose rows will appear at the end of the extended table.
 	#[expose]
-	#[implementations(Table<Artboard>, Table<Graphic>, Table<Vector>, Table<Raster<CPU>>, Table<Raster<GPU>>, Table<Color>)]
+	#[implementations(Table<Artboard>, Table<Graphic>, Table<Vector>, Table<Raster<CPU>>, Table<Raster<GPU>>, Table<Color>, Table<GradientStops>)]
 	new: Table<I>,
 ) -> Table<I> {
 	let mut base = base;
@@ -274,9 +300,9 @@ async fn extend<I: 'n + Send + Clone>(
 #[node_macro::node(category(""))]
 async fn legacy_layer_extend<I: 'n + Send + Clone>(
 	_: impl Ctx,
-	#[implementations(Table<Artboard>, Table<Graphic>, Table<Vector>, Table<Raster<CPU>>, Table<Raster<GPU>>, Table<Color>)] base: Table<I>,
+	#[implementations(Table<Artboard>, Table<Graphic>, Table<Vector>, Table<Raster<CPU>>, Table<Raster<GPU>>, Table<Color>, Table<GradientStops>)] base: Table<I>,
 	#[expose]
-	#[implementations(Table<Artboard>, Table<Graphic>, Table<Vector>, Table<Raster<CPU>>, Table<Raster<GPU>>, Table<Color>)]
+	#[implementations(Table<Artboard>, Table<Graphic>, Table<Vector>, Table<Raster<CPU>>, Table<Raster<GPU>>, Table<Color>, Table<GradientStops>)]
 	new: Table<I>,
 	nested_node_path: Vec<NodeId>,
 ) -> Table<I> {
@@ -302,6 +328,7 @@ async fn wrap_graphic<T: Into<Graphic> + 'n>(
 		Table<Raster<CPU>>,
 	 	Table<Raster<GPU>>,
 	 	Table<Color>,
+		Table<GradientStops>,
 		DAffine2,
 	)]
 	content: T,
@@ -320,6 +347,7 @@ async fn to_graphic<T: Into<Table<Graphic>> + 'n>(
 		Table<Raster<CPU>>,
 		Table<Raster<GPU>>,
 		Table<Color>,
+		Table<GradientStops>,
 	)]
 	content: T,
 ) -> Table<Graphic> {
@@ -427,6 +455,7 @@ fn index<T: AtIndex + Clone + Default>(
 		Table<Raster<CPU>>,
 		Table<Raster<GPU>>,
 		Table<Color>,
+		Table<GradientStops>,
 	)]
 	collection: T,
 	/// The index of the item to retrieve, starting from 0 for the first item.

node-graph/gcore/src/logic.rs

@@ -17,7 +17,7 @@ fn to_string<T: std::fmt::Debug>(_: impl Ctx, #[implementations(bool, f64, u32,
 #[node_macro::node(category("Text"))]
 fn serialize<T: serde::Serialize>(
 	_: impl Ctx,
-	#[implementations(String, bool, f64, u32, u64, DVec2, DAffine2, Table<Artboard>, Table<Graphic>, Table<Vector>, Table<Raster<CPU>>, Table<Color>)] value: T,
+	#[implementations(String, bool, f64, u32, u64, DVec2, DAffine2, Table<Artboard>, Table<Graphic>, Table<Vector>, Table<Raster<CPU>>, Table<Color>, Table<GradientStops>)] value: T,
 ) -> String {
 	serde_json::to_string(&value).unwrap_or_else(|_| "Serialization Error".to_string())
 }

node-graph/gcore/src/render_complexity.rs

@@ -1,8 +1,8 @@
+use crate::gradient::GradientStops;
 use crate::raster_types::{CPU, GPU, Raster};
 use crate::table::Table;
 use crate::vector::Vector;
 use crate::{Artboard, Color, Graphic};
-use glam::DVec2;
 
 pub trait RenderComplexity {
 	fn render_complexity(&self) -> usize {
@@ -30,6 +30,7 @@ impl RenderComplexity for Graphic {
 			Self::RasterCPU(table) => table.render_complexity(),
 			Self::RasterGPU(table) => table.render_complexity(),
 			Self::Color(table) => table.render_complexity(),
+			Self::Gradient(table) => table.render_complexity(),
 		}
 	}
 }
@@ -59,8 +60,8 @@ impl RenderComplexity for Color {
 	}
 }
 
-impl RenderComplexity for String {}
+impl RenderComplexity for GradientStops {
-impl RenderComplexity for bool {}
+	fn render_complexity(&self) -> usize {
-impl RenderComplexity for f32 {}
+		1
-impl RenderComplexity for f64 {}
+	}
-impl RenderComplexity for DVec2 {}
+}

node-graph/gcore/src/transform_nodes.rs

@@ -1,3 +1,4 @@
+use crate::gradient::GradientStops;
 use crate::raster_types::{CPU, GPU, Raster};
 use crate::table::Table;
 use crate::transform::{ApplyTransform, Footprint, Transform};
@@ -17,6 +18,8 @@ async fn transform<T: ApplyTransform + 'n + 'static>(
 		Context -> Table<Graphic>,
 		Context -> Table<Raster<CPU>>,
 		Context -> Table<Raster<GPU>>,
+		Context -> Table<Color>,
+		Context -> Table<GradientStops>,
 	)]
 	value: impl Node<Context<'static>, Output = T>,
 	translate: DVec2,
@@ -44,7 +47,7 @@ async fn transform<T: ApplyTransform + 'n + 'static>(
 #[node_macro::node(category(""))]
 fn replace_transform<Data, TransformInput: Transform>(
 	_: impl Ctx,
-	#[implementations(Table<Vector>, Table<Raster<CPU>>, Table<Graphic>, Table<Color>)] mut data: Table<Data>,
+	#[implementations(Table<Vector>, Table<Raster<CPU>>, Table<Graphic>, Table<Color>, Table<GradientStops>)] mut data: Table<Data>,
 	#[implementations(DAffine2)] transform: TransformInput,
 ) -> Table<Data> {
 	for data_transform in data.iter_mut() {
@@ -62,6 +65,7 @@ async fn extract_transform<T>(
 		Table<Raster<CPU>>,
 		Table<Raster<GPU>>,
 		Table<Color>,
+		Table<GradientStops>,
 	)]
 	vector: Table<T>,
 ) -> DAffine2 {
@@ -97,6 +101,7 @@ async fn boundless_footprint<T: 'n + 'static>(
 		Context -> Table<Raster<CPU>>,
 		Context -> Table<Raster<GPU>>,
 		Context -> Table<Color>,
+		Context -> Table<GradientStops>,
 		Context -> String,
 		Context -> f64,
 	)]
@@ -116,6 +121,7 @@ async fn freeze_real_time<T: 'n + 'static>(
 		Context -> Table<Raster<CPU>>,
 		Context -> Table<Raster<GPU>>,
 		Context -> Table<Color>,
+		Context -> Table<GradientStops>,
 		Context -> String,
 		Context -> f64,
 	)]

node-graph/gcore/src/vector/algorithms/instance.rs

@@ -1,3 +1,4 @@
+use crate::gradient::GradientStops;
 use crate::raster_types::{CPU, Raster};
 use crate::table::{Table, TableRowRef};
 use crate::vector::Vector;
@@ -14,6 +15,7 @@ async fn instance_on_points<T: Into<Graphic> + Default + Send + Clone + 'static>
 		Context -> Table<Vector>,
 		Context -> Table<Raster<CPU>>,
 		Context -> Table<Color>,
+		Context -> Table<GradientStops>,
 	)]
 	instance: impl Node<'n, Context<'static>, Output = Table<T>>,
 	reverse: bool,
@@ -56,6 +58,7 @@ async fn instance_repeat<T: Into<Graphic> + Default + Send + Clone + 'static>(
 		Context -> Table<Vector>,
 		Context -> Table<Raster<CPU>>,
 		Context -> Table<Color>,
+		Context -> Table<GradientStops>,
 	)]
 	instance: impl Node<'n, Context<'static>, Output = Table<T>>,
 	#[default(1)] count: u64,

node-graph/gcore/src/vector/style.rs

@@ -127,6 +127,15 @@ impl From<Table<Color>> for Fill {
 	}
 }
 
+impl From<Table<GradientStops>> for Fill {
+	fn from(gradient: Table<GradientStops>) -> Fill {
+		Fill::Gradient(Gradient {
+			stops: gradient.iter().nth(0).map(|row| row.element.clone()).unwrap_or_default(),
+			..Default::default()
+		})
+	}
+}
+
 impl From<Gradient> for Fill {
 	fn from(gradient: Gradient) -> Fill {
 		Fill::Gradient(gradient)

node-graph/gcore/src/vector/vector_nodes.rs

@@ -113,6 +113,8 @@ async fn fill<F: Into<Fill> + 'n + Send, V: VectorTableIterMut + 'n + Send>(
 		Table<Vector>,
 		Table<Vector>,
 		Table<Vector>,
+		Table<Vector>,
+		Table<Graphic>,
 		Table<Graphic>,
 		Table<Graphic>,
 		Table<Graphic>,
@@ -122,9 +124,11 @@ async fn fill<F: Into<Fill> + 'n + Send, V: VectorTableIterMut + 'n + Send>(
 	#[implementations(
 		Fill,
 		Table<Color>,
+		Table<GradientStops>,
 		Gradient,
 		Fill,
 		Table<Color>,
+		Table<GradientStops>,
 		Gradient,
 	)]
 	#[default(Color::BLACK)]
@@ -134,11 +138,7 @@ async fn fill<F: Into<Fill> + 'n + Send, V: VectorTableIterMut + 'n + Send>(
 ) -> V {
 	let fill: Fill = fill.into();
 	for vector in content.vector_iter_mut() {
-		let mut fill = fill.clone();
+		vector.element.style.set_fill(fill.clone());
-		if let Fill::Gradient(gradient) = &mut fill {
-			gradient.transform *= *vector.transform;
-		}
-		vector.element.style.set_fill(fill);
 	}
 
 	content
@@ -206,7 +206,7 @@ where
 async fn repeat<I: 'n + Send + Clone>(
 	_: impl Ctx,
 	// TODO: Implement other graphical types.
-	#[implementations(Table<Graphic>, Table<Vector>, Table<Raster<CPU>>, Table<Color>)] instance: Table<I>,
+	#[implementations(Table<Graphic>, Table<Vector>, Table<Raster<CPU>>, Table<Color>, Table<GradientStops>)] instance: Table<I>,
 	#[default(100., 100.)]
 	// TODO: When using a custom Properties panel layout in document_node_definitions.rs and this default is set, the widget weirdly doesn't show up in the Properties panel. Investigation is needed.
 	direction: PixelSize,
@@ -242,7 +242,7 @@ async fn repeat<I: 'n + Send + Clone>(
 async fn circular_repeat<I: 'n + Send + Clone>(
 	_: impl Ctx,
 	// TODO: Implement other graphical types.
-	#[implementations(Table<Graphic>, Table<Vector>, Table<Raster<CPU>>, Table<Color>)] instance: Table<I>,
+	#[implementations(Table<Graphic>, Table<Vector>, Table<Raster<CPU>>, Table<Color>, Table<GradientStops>)] instance: Table<I>,
 	angle_offset: Angle,
 	#[unit(" px")]
 	#[default(5)]
@@ -278,7 +278,7 @@ async fn copy_to_points<I: 'n + Send + Clone>(
 	points: Table<Vector>,
 	/// Artwork to be copied and placed at each point.
 	#[expose]
-	#[implementations(Table<Graphic>, Table<Vector>, Table<Raster<CPU>>, Table<Color>)]
+	#[implementations(Table<Graphic>, Table<Vector>, Table<Raster<CPU>>, Table<Color>, Table<GradientStops>)]
 	instance: Table<I>,
 	/// Minimum range of randomized sizes given to each instance.
 	#[default(1)]
@@ -353,7 +353,7 @@ async fn copy_to_points<I: 'n + Send + Clone>(
 #[node_macro::node(category("Instancing"), path(graphene_core::vector))]
 async fn mirror<I: 'n + Send + Clone>(
 	_: impl Ctx,
-	#[implementations(Table<Graphic>, Table<Vector>, Table<Raster<CPU>>, Table<Color>)] content: Table<I>,
+	#[implementations(Table<Graphic>, Table<Vector>, Table<Raster<CPU>>, Table<Color>, Table<GradientStops>)] content: Table<I>,
 	#[default(ReferencePoint::Center)] relative_to_bounds: ReferencePoint,
 	#[unit(" px")] offset: f64,
 	#[range((-90., 90.))] angle: Angle,
@@ -1888,7 +1888,7 @@ fn point_inside(_: impl Ctx, source: Table<Vector>, point: DVec2) -> bool {
 }
 
 #[node_macro::node(category("General"), path(graphene_core::vector))]
-async fn count_elements<I>(_: impl Ctx, #[implementations(Table<Graphic>, Table<Vector>, Table<Raster<CPU>>, Table<Raster<GPU>>, Table<Color>)] source: Table<I>) -> u64 {
+async fn count_elements<I>(_: impl Ctx, #[implementations(Table<Graphic>, Table<Vector>, Table<Raster<CPU>>, Table<Raster<GPU>>, Table<Color>, Table<GradientStops>)] source: Table<I>) -> u64 {
 	source.len() as u64
 }
 

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

@@ -664,6 +664,18 @@ fn color_value(_: impl Ctx, _primary: (), #[default(Color::RED)] color: Table<Co
 	color
 }
 
+/// Constructs a gradient value which may be set to any sequence of color stops to represent the transition between colors.
+#[node_macro::node(category("Value"))]
+fn gradient_value(_: impl Ctx, _primary: (), gradient: GradientStops) -> GradientStops {
+	gradient
+}
+
+/// Constructs a gradient value which may be set to any sequence of color stops to represent the transition between colors.
+#[node_macro::node(category("Value"))]
+fn gradient_table_value(_: impl Ctx, _primary: (), gradient: GradientStops) -> Table<GradientStops> {
+	Table::new_from_element(gradient)
+}
+
 /// Gets the color at the specified position along the gradient, given a position from 0 (left) to 1 (right).
 #[node_macro::node(category("Color"))]
 fn sample_gradient(_: impl Ctx, _primary: (), gradient: GradientStops, position: Fraction) -> Table<Color> {
@@ -672,12 +684,6 @@ fn sample_gradient(_: impl Ctx, _primary: (), gradient: GradientStops, position:
 	Table::new_from_element(color)
 }
 
-/// Constructs a gradient value which may be set to any sequence of color stops to represent the transition between colors.
-#[node_macro::node(category("Value"))]
-fn gradient_value(_: impl Ctx, _primary: (), gradient: GradientStops) -> GradientStops {
-	gradient
-}
-
 /// Constructs a string value which may be set to any plain text.
 #[node_macro::node(category("Value"))]
 fn string_value(_: impl Ctx, _primary: (), string: TextArea) -> String {

node-graph/gpath-bool/src/lib.rs

@@ -295,6 +295,24 @@ fn flatten_vector(graphic_table: &Table<Graphic>) -> Table<Vector> {
 						}
 					})
 					.collect::<Vec<_>>(),
+				Graphic::Gradient(gradient) => gradient
+					.into_iter()
+					.map(|row| {
+						let mut element = Vector::default();
+						element.style.set_fill(Fill::Gradient(graphene_core::gradient::Gradient {
+							stops: row.element,
+							..Default::default()
+						}));
+						element.style.set_stroke_transform(DAffine2::IDENTITY);
+
+						TableRow {
+							element,
+							transform: row.transform,
+							alpha_blending: row.alpha_blending,
+							source_node_id: row.source_node_id,
+						}
+					})
+					.collect::<Vec<_>>(),
 			}
 		})
 		.collect()

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

@@ -14,6 +14,7 @@ use graphene_core::transform::ReferencePoint;
 use graphene_core::uuid::NodeId;
 use graphene_core::vector::Vector;
 use graphene_core::vector::style::Fill;
+use graphene_core::vector::style::GradientStops;
 use graphene_core::{Artboard, Color, Graphic, MemoHash, Node, Type};
 use graphene_svg_renderer::RenderMetadata;
 use std::fmt::Display;
@@ -196,6 +197,7 @@ tagged_value! {
 	#[cfg_attr(target_family = "wasm", serde(deserialize_with = "graphene_core::misc::migrate_color"))] // TODO: Eventually remove this migration document upgrade code
 	#[serde(alias = "ColorTable", alias = "OptionalColor")]
 	Color(Table<Color>),
+	GradientTable(Table<GradientStops>),
 	// ============
 	// STRUCT TYPES
 	// ============
@@ -205,7 +207,7 @@ tagged_value! {
 	Stroke(graphene_core::vector::style::Stroke),
 	Gradient(graphene_core::vector::style::Gradient),
 	#[serde(alias = "GradientPositions")] // TODO: Eventually remove this alias document upgrade code
-	GradientStops(graphene_core::vector::style::GradientStops),
+	GradientStops(GradientStops),
 	Font(graphene_core::text::Font),
 	BrushStrokes(Vec<BrushStroke>),
 	BrushCache(BrushCache),

node-graph/graster-nodes/src/adjust.rs

@@ -27,8 +27,15 @@ mod adjust_std {
 	}
 	impl Adjust<Color> for Table<Color> {
 		fn adjust(&mut self, map_fn: impl Fn(&Color) -> Color) {
-			for color in self.iter_mut() {
+			for row in self.iter_mut() {
-				*color.element = map_fn(color.element);
+				*row.element = map_fn(row.element);
+			}
+		}
+	}
+	impl Adjust<Color> for Table<GradientStops> {
+		fn adjust(&mut self, map_fn: impl Fn(&Color) -> Color) {
+			for row in self.iter_mut() {
+				row.element.adjust(&map_fn);
 			}
 		}
 	}

node-graph/graster-nodes/src/adjustments.rs

@@ -46,6 +46,7 @@ fn luminance<T: Adjust<Color>>(
 	#[implementations(
 		Table<Raster<CPU>>,
 		Table<Color>,
+		Table<GradientStops>,
 		GradientStops,
 	)]
 	mut input: T,
@@ -70,6 +71,7 @@ fn gamma_correction<T: Adjust<Color>>(
 	#[implementations(
 		Table<Raster<CPU>>,
 		Table<Color>,
+		Table<GradientStops>,
 		GradientStops,
 	)]
 	mut input: T,
@@ -90,6 +92,7 @@ fn extract_channel<T: Adjust<Color>>(
 	#[implementations(
 		Table<Raster<CPU>>,
 		Table<Color>,
+		Table<GradientStops>,
 		GradientStops,
 	)]
 	mut input: T,
@@ -113,6 +116,7 @@ fn make_opaque<T: Adjust<Color>>(
 	#[implementations(
 		Table<Raster<CPU>>,
 		Table<Color>,
+		Table<GradientStops>,
 		GradientStops,
 	)]
 	mut input: T,
@@ -138,6 +142,7 @@ fn brightness_contrast<T: Adjust<Color>>(
 	#[implementations(
 		Table<Raster<CPU>>,
 		Table<Color>,
+		Table<GradientStops>,
 		GradientStops,
 	)]
 	mut input: T,
@@ -227,6 +232,7 @@ fn levels<T: Adjust<Color>>(
 	#[implementations(
 		Table<Raster<CPU>>,
 		Table<Color>,
+		Table<GradientStops>,
 		GradientStops,
 	)]
 	mut image: T,
@@ -294,6 +300,7 @@ async fn black_and_white<T: Adjust<Color>>(
 	#[implementations(
 		Table<Raster<CPU>>,
 		Table<Color>,
+		Table<GradientStops>,
 		GradientStops,
 	)]
 	mut image: T,
@@ -369,6 +376,7 @@ async fn hue_saturation<T: Adjust<Color>>(
 	#[implementations(
 		Table<Raster<CPU>>,
 		Table<Color>,
+		Table<GradientStops>,
 		GradientStops,
 	)]
 	mut input: T,
@@ -403,6 +411,7 @@ async fn invert<T: Adjust<Color>>(
 	#[implementations(
 		Table<Raster<CPU>>,
 		Table<Color>,
+		Table<GradientStops>,
 		GradientStops,
 	)]
 	mut input: T,
@@ -425,6 +434,7 @@ async fn threshold<T: Adjust<Color>>(
 	#[implementations(
 		Table<Raster<CPU>>,
 		Table<Color>,
+		Table<GradientStops>,
 		GradientStops,
 	)]
 	mut image: T,
@@ -470,6 +480,7 @@ async fn vibrance<T: Adjust<Color>>(
 	#[implementations(
 		Table<Raster<CPU>>,
 		Table<Color>,
+		Table<GradientStops>,
 		GradientStops,
 	)]
 	mut image: T,
@@ -635,6 +646,7 @@ async fn channel_mixer<T: Adjust<Color>>(
 	#[implementations(
 		Table<Raster<CPU>>,
 		Table<Color>,
+		Table<GradientStops>,
 		GradientStops,
 	)]
 	mut image: T,
@@ -763,6 +775,7 @@ async fn selective_color<T: Adjust<Color>>(
 	#[implementations(
 		Table<Raster<CPU>>,
 		Table<Color>,
+		Table<GradientStops>,
 		GradientStops,
 	)]
 	mut image: T,
@@ -905,6 +918,7 @@ async fn posterize<T: Adjust<Color>>(
 	#[implementations(
 		Table<Raster<CPU>>,
 		Table<Color>,
+		Table<GradientStops>,
 		GradientStops,
 	)]
 	mut input: T,
@@ -938,6 +952,7 @@ async fn exposure<T: Adjust<Color>>(
 	#[implementations(
 		Table<Raster<CPU>>,
 		Table<Color>,
+		Table<GradientStops>,
 		GradientStops,
 	)]
 	mut input: T,

node-graph/graster-nodes/src/blending_nodes.rs

@@ -51,6 +51,15 @@ mod blend_std {
 			result_table
 		}
 	}
+	impl Blend<Color> for Table<GradientStops> {
+		fn blend(&self, under: &Self, blend_fn: impl Fn(Color, Color) -> Color) -> Self {
+			let mut result_table = self.clone();
+			for (over, under) in result_table.iter_mut().zip(under.iter()) {
+				*over.element = over.element.blend(under.element, &blend_fn);
+			}
+			result_table
+		}
+	}
 	impl Blend<Color> for GradientStops {
 		fn blend(&self, under: &Self, blend_fn: impl Fn(Color, Color) -> Color) -> Self {
 			let mut combined_stops = self.iter().map(|(position, _)| position).chain(under.iter().map(|(position, _)| position)).collect::<Vec<_>>();
@@ -128,6 +137,7 @@ async fn blend<T: Blend<Color> + Send>(
 	#[implementations(
 		Table<Raster<CPU>>,
 		Table<Color>,
+		Table<GradientStops>,
 		GradientStops,
 	)]
 	over: T,
@@ -135,6 +145,7 @@ async fn blend<T: Blend<Color> + Send>(
 	#[implementations(
 		Table<Raster<CPU>>,
 		Table<Color>,
+		Table<GradientStops>,
 		GradientStops,
 	)]
 	under: T,
@@ -150,6 +161,7 @@ fn color_overlay<T: Adjust<Color>>(
 	#[implementations(
 		Table<Raster<CPU>>,
 		Table<Color>,
+		Table<GradientStops>,
 		GradientStops,
 	)]
 	mut image: T,

node-graph/graster-nodes/src/gradient_map.rs

@@ -15,6 +15,7 @@ async fn gradient_map<T: Adjust<Color>>(
 	#[implementations(
 		Table<Raster<CPU>>,
 		Table<Color>,
+		Table<GradientStops>,
 		GradientStops,
 	)]
 	mut image: T,

node-graph/gstd/src/wasm_application_io.rs

@@ -3,6 +3,7 @@ pub use graph_craft::document::value::RenderOutputType;
 pub use graph_craft::wasm_application_io::*;
 use graphene_application_io::{ApplicationIo, ExportFormat, RenderConfig};
 use graphene_core::Artboard;
+use graphene_core::gradient::GradientStops;
 #[cfg(target_family = "wasm")]
 use graphene_core::math::bbox::Bbox;
 use graphene_core::raster::image::Image;
@@ -221,6 +222,7 @@ async fn rasterize<T: WasmNotSend + 'n>(
 		Table<Raster<CPU>>,
 		Table<Graphic>,
 		Table<Color>,
+		Table<GradientStops>,
 	)]
 	mut data: Table<T>,
 	footprint: Footprint,
@@ -291,10 +293,7 @@ async fn render<'a: 'n, T: 'n + Render + WasmNotSend>(
 		Context -> Table<Vector>,
 		Context -> Table<Raster<CPU>>,
 		Context -> Table<Color>,
-		Context -> bool,
+		Context -> Table<GradientStops>,
-		Context -> f32,
-		Context -> f64,
-		Context -> String,
 	)]
 	data: impl Node<Context<'static>, Output = T>,
 	_surface_handle: impl Node<Context<'static>, Output = Option<wgpu_executor::WgpuSurface>>,
@@ -307,15 +306,12 @@ async fn render<'a: 'n, T: 'n + Render + WasmNotSend>(
 		.into_context();
 	ctx.footprint();
 
-	let RenderConfig { hide_artboards, for_export, .. } = render_config;
 	let render_params = RenderParams {
 		view_mode: render_config.view_mode,
+		hide_artboards: render_config.hide_artboards,
+		for_export: render_config.for_export,
 		footprint,
-		thumbnail: false,
+		..Default::default()
-		hide_artboards,
-		for_export,
-		for_mask: false,
-		alignment_parent_transform: None,
 	};
 
 	let data = data.eval(ctx.clone()).await;

node-graph/gsvg-renderer/src/render_ext.rs

@@ -1,5 +1,5 @@
 use crate::renderer::{RenderParams, format_transform_matrix};
-use glam::{DAffine2, DVec2};
+use glam::DAffine2;
 use graphene_core::consts::{LAYER_OUTLINE_STROKE_COLOR, LAYER_OUTLINE_STROKE_WEIGHT};
 use graphene_core::gradient::{Gradient, GradientType};
 use graphene_core::uuid::generate_uuid;
@@ -8,39 +8,14 @@ use std::fmt::Write;
 
 pub trait RenderExt {
 	type Output;
-	fn render(
+	fn render(&self, svg_defs: &mut String, element_transform: DAffine2, stroke_transform: DAffine2, bounds: DAffine2, transformed_bounds: DAffine2, render_params: &RenderParams) -> Self::Output;
-		&self,
-		svg_defs: &mut String,
-		element_transform: DAffine2,
-		stroke_transform: DAffine2,
-		bounds: [DVec2; 2],
-		transformed_bounds: [DVec2; 2],
-		aligned_strokes: bool,
-		override_paint_order: bool,
-		render_params: &RenderParams,
-	) -> Self::Output;
 }
 
 impl RenderExt for Gradient {
 	type Output = u64;
 
 	// /// Adds the gradient def through mutating the first argument, returning the gradient ID.
-	fn render(
+	fn render(&self, svg_defs: &mut String, element_transform: DAffine2, stroke_transform: DAffine2, bounds: DAffine2, transformed_bounds: DAffine2, _render_params: &RenderParams) -> Self::Output {
-		&self,
-		svg_defs: &mut String,
-		element_transform: DAffine2,
-		stroke_transform: DAffine2,
-		bounds: [DVec2; 2],
-		transformed_bounds: [DVec2; 2],
-		_aligned_strokes: bool,
-		_override_paint_order: bool,
-		_render_params: &RenderParams,
-	) -> Self::Output {
-		// TODO: Figure out how to use `self.transform` as part of the gradient transform, since that field (`Gradient::transform`) is currently never read from, it's only written to.
-
-		let bound_transform = DAffine2::from_scale_angle_translation(bounds[1] - bounds[0], 0., bounds[0]);
-		let transformed_bound_transform = element_transform * DAffine2::from_scale_angle_translation(transformed_bounds[1] - transformed_bounds[0], 0., transformed_bounds[0]);
-
 		let mut stop = String::new();
 		for (position, color) in self.stops.0.iter() {
 			stop.push_str("<stop");
@@ -54,27 +29,30 @@ impl RenderExt for Gradient {
 			stop.push_str(" />")
 		}
 
-		let mod_gradient = if transformed_bound_transform.matrix2.determinant() != 0. {
+		let transform_points = element_transform * stroke_transform * bounds;
-			transformed_bound_transform.inverse()
+		let start = transform_points.transform_point2(self.start);
+		let end = transform_points.transform_point2(self.end);
+
+		let gradient_transform = if transformed_bounds.matrix2.determinant() != 0. {
+			transformed_bounds.inverse()
 		} else {
 			DAffine2::IDENTITY // Ignore if the transform cannot be inverted (the bounds are zero). See issue #1944.
 		};
-		let mod_points = element_transform * stroke_transform * bound_transform;
+		let gradient_transform = format_transform_matrix(gradient_transform);
-
+		let gradient_transform = if gradient_transform.is_empty() {
-		let start = mod_points.transform_point2(self.start);
+			String::new()
-		let end = mod_points.transform_point2(self.end);
+		} else {
+			format!(r#" gradientTransform="{gradient_transform}""#)
+		};
 
 		let gradient_id = generate_uuid();
 
-		let matrix = format_transform_matrix(mod_gradient);
-		let gradient_transform = if matrix.is_empty() { String::new() } else { format!(r#" gradientTransform="{}""#, matrix) };
-
 		match self.gradient_type {
 			GradientType::Linear => {
 				let _ = write!(
 					svg_defs,
-					r#"<linearGradient id="{}" x1="{}" x2="{}" y1="{}" y2="{}"{gradient_transform}>{}</linearGradient>"#,
+					r#"<linearGradient id="{}" x1="{}" y1="{}" x2="{}" y2="{}"{gradient_transform}>{}</linearGradient>"#,
-					gradient_id, start.x, end.x, start.y, end.y, stop
+					gradient_id, start.x, start.y, end.x, end.y, stop
 				);
 			}
 			GradientType::Radial => {
@@ -95,17 +73,7 @@ impl RenderExt for Fill {
 	type Output = String;
 
 	/// Renders the fill, adding necessary defs through mutating the first argument.
-	fn render(
+	fn render(&self, svg_defs: &mut String, element_transform: DAffine2, stroke_transform: DAffine2, bounds: DAffine2, transformed_bounds: DAffine2, render_params: &RenderParams) -> Self::Output {
-		&self,
-		svg_defs: &mut String,
-		element_transform: DAffine2,
-		stroke_transform: DAffine2,
-		bounds: [DVec2; 2],
-		transformed_bounds: [DVec2; 2],
-		aligned_strokes: bool,
-		override_paint_order: bool,
-		render_params: &RenderParams,
-	) -> Self::Output {
 		match self {
 			Self::None => r#" fill="none""#.to_string(),
 			Self::Solid(color) => {
@@ -116,16 +84,7 @@ impl RenderExt for Fill {
 				result
 			}
 			Self::Gradient(gradient) => {
-				let gradient_id = gradient.render(
+				let gradient_id = gradient.render(svg_defs, element_transform, stroke_transform, bounds, transformed_bounds, render_params);
-					svg_defs,
-					element_transform,
-					stroke_transform,
-					bounds,
-					transformed_bounds,
-					aligned_strokes,
-					override_paint_order,
-					render_params,
-				);
 				format!(r##" fill="url('#{gradient_id}')""##)
 			}
 		}
@@ -141,11 +100,9 @@ impl RenderExt for Stroke {
 		_svg_defs: &mut String,
 		_element_transform: DAffine2,
 		_stroke_transform: DAffine2,
-		_bounds: [DVec2; 2],
+		_bounds: DAffine2,
-		_transformed_bounds: [DVec2; 2],
+		_transformed_bounds: DAffine2,
-		aligned_strokes: bool,
+		render_params: &RenderParams,
-		override_paint_order: bool,
-		_render_params: &RenderParams,
 	) -> Self::Output {
 		// Don't render a stroke at all if it would be invisible
 		let Some(color) = self.color else { return String::new() };
@@ -161,7 +118,7 @@ impl RenderExt for Stroke {
 		let stroke_join = (self.join != StrokeJoin::Miter).then_some(self.join);
 		let stroke_join_miter_limit = (self.join_miter_limit != 4.).then_some(self.join_miter_limit);
 		let stroke_align = (self.align != StrokeAlign::Center).then_some(self.align);
-		let paint_order = (self.paint_order != PaintOrder::StrokeAbove || override_paint_order).then_some(PaintOrder::StrokeBelow);
+		let paint_order = (self.paint_order != PaintOrder::StrokeAbove || render_params.override_paint_order).then_some(PaintOrder::StrokeBelow);
 
 		// Render the needed stroke attributes
 		let mut attributes = format!(r##" stroke="#{}""##, color.to_rgb_hex_srgb_from_gamma());
@@ -169,16 +126,16 @@ impl RenderExt for Stroke {
 			let _ = write!(&mut attributes, r#" stroke-opacity="{}""#, (color.a() * 1000.).round() / 1000.);
 		}
 		if let Some(mut weight) = weight {
-			if stroke_align.is_some() && aligned_strokes {
+			if stroke_align.is_some() && render_params.aligned_strokes {
 				weight *= 2.;
 			}
-			let _ = write!(&mut attributes, r#" stroke-width="{}""#, weight);
+			let _ = write!(&mut attributes, r#" stroke-width="{weight}""#);
 		}
 		if let Some(dash_array) = dash_array {
-			let _ = write!(&mut attributes, r#" stroke-dasharray="{}""#, dash_array);
+			let _ = write!(&mut attributes, r#" stroke-dasharray="{dash_array}""#);
 		}
 		if let Some(dash_offset) = dash_offset {
-			let _ = write!(&mut attributes, r#" stroke-dashoffset="{}""#, dash_offset);
+			let _ = write!(&mut attributes, r#" stroke-dashoffset="{dash_offset}""#);
 		}
 		if let Some(stroke_cap) = stroke_cap {
 			let _ = write!(&mut attributes, r#" stroke-linecap="{}""#, stroke_cap.svg_name());
@@ -187,7 +144,7 @@ impl RenderExt for Stroke {
 			let _ = write!(&mut attributes, r#" stroke-linejoin="{}""#, stroke_join.svg_name());
 		}
 		if let Some(stroke_join_miter_limit) = stroke_join_miter_limit {
-			let _ = write!(&mut attributes, r#" stroke-miterlimit="{}""#, stroke_join_miter_limit);
+			let _ = write!(&mut attributes, r#" stroke-miterlimit="{stroke_join_miter_limit}""#);
 		}
 		// Add vector-effect attribute to make strokes non-scaling
 		if self.non_scaling {
@@ -205,71 +162,23 @@ impl RenderExt for PathStyle {
 
 	/// Renders the shape's fill and stroke attributes as a string with them concatenated together.
 	#[allow(clippy::too_many_arguments)]
-	fn render(
+	fn render(&self, svg_defs: &mut String, element_transform: DAffine2, stroke_transform: DAffine2, bounds: DAffine2, transformed_bounds: DAffine2, render_params: &RenderParams) -> String {
-		&self,
-		svg_defs: &mut String,
-		element_transform: DAffine2,
-		stroke_transform: DAffine2,
-		bounds: [DVec2; 2],
-		transformed_bounds: [DVec2; 2],
-		aligned_strokes: bool,
-		override_paint_order: bool,
-		render_params: &RenderParams,
-	) -> String {
 		let view_mode = render_params.view_mode;
 		match view_mode {
 			ViewMode::Outline => {
-				let fill_attribute = Fill::None.render(
+				let fill_attribute = Fill::None.render(svg_defs, element_transform, stroke_transform, bounds, transformed_bounds, render_params);
-					svg_defs,
-					element_transform,
-					stroke_transform,
-					bounds,
-					transformed_bounds,
-					aligned_strokes,
-					override_paint_order,
-					render_params,
-				);
 				let mut outline_stroke = Stroke::new(Some(LAYER_OUTLINE_STROKE_COLOR), LAYER_OUTLINE_STROKE_WEIGHT);
 				// Outline strokes should be non-scaling by default
 				outline_stroke.non_scaling = true;
-				let stroke_attribute = outline_stroke.render(
+				let stroke_attribute = outline_stroke.render(svg_defs, element_transform, stroke_transform, bounds, transformed_bounds, render_params);
-					svg_defs,
-					element_transform,
-					stroke_transform,
-					bounds,
-					transformed_bounds,
-					aligned_strokes,
-					override_paint_order,
-					render_params,
-				);
 				format!("{fill_attribute}{stroke_attribute}")
 			}
 			_ => {
-				let fill_attribute = self.fill.render(
+				let fill_attribute = self.fill.render(svg_defs, element_transform, stroke_transform, bounds, transformed_bounds, render_params);
-					svg_defs,
-					element_transform,
-					stroke_transform,
-					bounds,
-					transformed_bounds,
-					aligned_strokes,
-					override_paint_order,
-					render_params,
-				);
 				let stroke_attribute = self
 					.stroke
 					.as_ref()
-					.map(|stroke| {
+					.map(|stroke| stroke.render(svg_defs, element_transform, stroke_transform, bounds, transformed_bounds, render_params))
-						stroke.render(
-							svg_defs,
-							element_transform,
-							stroke_transform,
-							bounds,
-							transformed_bounds,
-							aligned_strokes,
-							override_paint_order,
-							render_params,
-						)
-					})
 					.unwrap_or_default();
 				format!("{fill_attribute}{stroke_attribute}")
 			}

node-graph/gsvg-renderer/src/renderer.rs

@@ -7,6 +7,8 @@ use graphene_core::blending::BlendMode;
 use graphene_core::bounds::BoundingBox;
 use graphene_core::bounds::RenderBoundingBox;
 use graphene_core::color::Color;
+use graphene_core::gradient::GradientStops;
+use graphene_core::gradient::GradientType;
 use graphene_core::math::quad::Quad;
 use graphene_core::raster::BitmapMut;
 use graphene_core::raster::Image;
@@ -154,7 +156,7 @@ pub struct RenderContext {
 }
 
 /// Static state used whilst rendering
-#[derive(Default)]
+#[derive(Default, Clone)]
 pub struct RenderParams {
 	pub view_mode: ViewMode,
 	pub footprint: Footprint,
@@ -167,6 +169,8 @@ pub struct RenderParams {
 	pub for_mask: bool,
 	/// Are we generating a mask for alignment? Used to prevent unnecessary transforms in masks
 	pub alignment_parent_transform: Option<DAffine2>,
+	pub aligned_strokes: bool,
+	pub override_paint_order: bool,
 }
 
 impl RenderParams {
@@ -236,6 +240,251 @@ pub trait Render: BoundingBox + RenderComplexity {
 	fn new_ids_from_hash(&mut self, _reference: Option<NodeId>) {}
 }
 
+impl Render for Graphic {
+	fn render_svg(&self, render: &mut SvgRender, render_params: &RenderParams) {
+		match self {
+			Graphic::Graphic(table) => table.render_svg(render, render_params),
+			Graphic::Vector(table) => table.render_svg(render, render_params),
+			Graphic::RasterCPU(table) => table.render_svg(render, render_params),
+			Graphic::RasterGPU(_) => (),
+			Graphic::Color(table) => table.render_svg(render, render_params),
+			Graphic::Gradient(table) => table.render_svg(render, render_params),
+		}
+	}
+
+	#[cfg(feature = "vello")]
+	fn render_to_vello(&self, scene: &mut Scene, transform: DAffine2, context: &mut RenderContext, render_params: &RenderParams) {
+		match self {
+			Graphic::Graphic(table) => table.render_to_vello(scene, transform, context, render_params),
+			Graphic::Vector(table) => table.render_to_vello(scene, transform, context, render_params),
+			Graphic::RasterCPU(table) => table.render_to_vello(scene, transform, context, render_params),
+			Graphic::RasterGPU(table) => table.render_to_vello(scene, transform, context, render_params),
+			Graphic::Color(table) => table.render_to_vello(scene, transform, context, render_params),
+			Graphic::Gradient(table) => table.render_to_vello(scene, transform, context, render_params),
+		}
+	}
+
+	fn collect_metadata(&self, metadata: &mut RenderMetadata, footprint: Footprint, element_id: Option<NodeId>) {
+		if let Some(element_id) = element_id {
+			match self {
+				Graphic::Graphic(_) => {
+					metadata.upstream_footprints.insert(element_id, footprint);
+				}
+				Graphic::Vector(table) => {
+					metadata.upstream_footprints.insert(element_id, footprint);
+					// TODO: Find a way to handle more than the first row
+					if let Some(row) = table.iter().next() {
+						metadata.first_element_source_id.insert(element_id, *row.source_node_id);
+						metadata.local_transforms.insert(element_id, *row.transform);
+					}
+				}
+				Graphic::RasterCPU(table) => {
+					metadata.upstream_footprints.insert(element_id, footprint);
+
+					// TODO: Find a way to handle more than the first row
+					if let Some(row) = table.iter().next() {
+						metadata.local_transforms.insert(element_id, *row.transform);
+					}
+				}
+				Graphic::RasterGPU(table) => {
+					metadata.upstream_footprints.insert(element_id, footprint);
+
+					// TODO: Find a way to handle more than the first row
+					if let Some(row) = table.iter().next() {
+						metadata.local_transforms.insert(element_id, *row.transform);
+					}
+				}
+				Graphic::Color(table) => {
+					metadata.upstream_footprints.insert(element_id, footprint);
+
+					// TODO: Find a way to handle more than the first row
+					if let Some(row) = table.iter().next() {
+						metadata.local_transforms.insert(element_id, *row.transform);
+					}
+				}
+				Graphic::Gradient(table) => {
+					metadata.upstream_footprints.insert(element_id, footprint);
+
+					// TODO: Find a way to handle more than the first row
+					if let Some(row) = table.iter().next() {
+						metadata.local_transforms.insert(element_id, *row.transform);
+					}
+				}
+			}
+		}
+
+		match self {
+			Graphic::Graphic(table) => table.collect_metadata(metadata, footprint, element_id),
+			Graphic::Vector(table) => table.collect_metadata(metadata, footprint, element_id),
+			Graphic::RasterCPU(table) => table.collect_metadata(metadata, footprint, element_id),
+			Graphic::RasterGPU(table) => table.collect_metadata(metadata, footprint, element_id),
+			Graphic::Color(table) => table.collect_metadata(metadata, footprint, element_id),
+			Graphic::Gradient(table) => table.collect_metadata(metadata, footprint, element_id),
+		}
+	}
+
+	fn add_upstream_click_targets(&self, click_targets: &mut Vec<ClickTarget>) {
+		match self {
+			Graphic::Graphic(table) => table.add_upstream_click_targets(click_targets),
+			Graphic::Vector(table) => table.add_upstream_click_targets(click_targets),
+			Graphic::RasterCPU(table) => table.add_upstream_click_targets(click_targets),
+			Graphic::RasterGPU(table) => table.add_upstream_click_targets(click_targets),
+			Graphic::Color(table) => table.add_upstream_click_targets(click_targets),
+			Graphic::Gradient(table) => table.add_upstream_click_targets(click_targets),
+		}
+	}
+
+	fn contains_artboard(&self) -> bool {
+		match self {
+			Graphic::Graphic(table) => table.contains_artboard(),
+			Graphic::Vector(table) => table.contains_artboard(),
+			Graphic::RasterCPU(table) => table.contains_artboard(),
+			Graphic::RasterGPU(table) => table.contains_artboard(),
+			Graphic::Color(table) => table.contains_artboard(),
+			Graphic::Gradient(table) => table.contains_artboard(),
+		}
+	}
+
+	fn new_ids_from_hash(&mut self, reference: Option<NodeId>) {
+		match self {
+			Graphic::Graphic(table) => table.new_ids_from_hash(reference),
+			Graphic::Vector(table) => table.new_ids_from_hash(reference),
+			Graphic::RasterCPU(_) => (),
+			Graphic::RasterGPU(_) => (),
+			Graphic::Color(_) => (),
+			Graphic::Gradient(_) => (),
+		}
+	}
+}
+
+impl Render for Artboard {
+	fn render_svg(&self, render: &mut SvgRender, render_params: &RenderParams) {
+		// Rectangle for the artboard
+		if !render_params.hide_artboards {
+			// Background
+			render.leaf_tag("rect", |attributes| {
+				attributes.push("fill", format!("#{}", self.background.to_rgb_hex_srgb_from_gamma()));
+				if self.background.a() < 1. {
+					attributes.push("fill-opacity", ((self.background.a() * 1000.).round() / 1000.).to_string());
+				}
+				attributes.push("x", self.location.x.min(self.location.x + self.dimensions.x).to_string());
+				attributes.push("y", self.location.y.min(self.location.y + self.dimensions.y).to_string());
+				attributes.push("width", self.dimensions.x.abs().to_string());
+				attributes.push("height", self.dimensions.y.abs().to_string());
+			});
+		}
+
+		// Artwork
+		render.parent_tag(
+			// SVG group tag
+			"g",
+			// Group tag attributes
+			|attributes| {
+				let matrix = format_transform_matrix(self.transform());
+				if !matrix.is_empty() {
+					attributes.push("transform", matrix);
+				}
+
+				if self.clip {
+					let id = format!("artboard-{}", generate_uuid());
+					let selector = format!("url(#{id})");
+
+					write!(
+						&mut attributes.0.svg_defs,
+						r##"<clipPath id="{id}"><rect x="0" y="0" width="{}" height="{}"/></clipPath>"##,
+						self.dimensions.x, self.dimensions.y,
+					)
+					.unwrap();
+					attributes.push("clip-path", selector);
+				}
+			},
+			// Artwork content
+			|render| {
+				self.content.render_svg(render, render_params);
+			},
+		);
+	}
+
+	#[cfg(feature = "vello")]
+	fn render_to_vello(&self, scene: &mut Scene, transform: DAffine2, context: &mut RenderContext, render_params: &RenderParams) {
+		use vello::peniko;
+
+		// Render background
+		let color = peniko::Color::new([self.background.r(), self.background.g(), self.background.b(), self.background.a()]);
+		let [a, b] = [self.location.as_dvec2(), self.location.as_dvec2() + self.dimensions.as_dvec2()];
+		let rect = kurbo::Rect::new(a.x.min(b.x), a.y.min(b.y), a.x.max(b.x), a.y.max(b.y));
+
+		scene.push_layer(peniko::Mix::Normal, 1., kurbo::Affine::new(transform.to_cols_array()), &rect);
+		scene.fill(peniko::Fill::NonZero, kurbo::Affine::new(transform.to_cols_array()), color, None, &rect);
+		scene.pop_layer();
+
+		if self.clip {
+			let blend_mode = peniko::BlendMode::new(peniko::Mix::Clip, peniko::Compose::SrcOver);
+			scene.push_layer(blend_mode, 1., kurbo::Affine::new(transform.to_cols_array()), &rect);
+		}
+		// Since the content's transform is right multiplied in when rendering the content, we just need to right multiply by the artboard offset here.
+		let child_transform = transform * DAffine2::from_translation(self.location.as_dvec2());
+		self.content.render_to_vello(scene, child_transform, context, render_params);
+		if self.clip {
+			scene.pop_layer();
+		}
+	}
+
+	fn collect_metadata(&self, metadata: &mut RenderMetadata, mut footprint: Footprint, element_id: Option<NodeId>) {
+		if let Some(element_id) = element_id {
+			let subpath = Subpath::new_rect(DVec2::ZERO, self.dimensions.as_dvec2());
+			metadata.click_targets.insert(element_id, vec![ClickTarget::new_with_subpath(subpath, 0.)]);
+			metadata.upstream_footprints.insert(element_id, footprint);
+			metadata.local_transforms.insert(element_id, DAffine2::from_translation(self.location.as_dvec2()));
+			if self.clip {
+				metadata.clip_targets.insert(element_id);
+			}
+		}
+		footprint.transform *= self.transform();
+		self.content.collect_metadata(metadata, footprint, None);
+	}
+
+	fn add_upstream_click_targets(&self, click_targets: &mut Vec<ClickTarget>) {
+		let subpath_rectangle = Subpath::new_rect(DVec2::ZERO, self.dimensions.as_dvec2());
+		click_targets.push(ClickTarget::new_with_subpath(subpath_rectangle, 0.));
+	}
+
+	fn contains_artboard(&self) -> bool {
+		true
+	}
+}
+
+impl Render for Table<Artboard> {
+	fn render_svg(&self, render: &mut SvgRender, render_params: &RenderParams) {
+		for artboard in self.iter() {
+			artboard.element.render_svg(render, render_params);
+		}
+	}
+
+	#[cfg(feature = "vello")]
+	fn render_to_vello(&self, scene: &mut Scene, transform: DAffine2, context: &mut RenderContext, render_params: &RenderParams) {
+		for row in self.iter() {
+			row.element.render_to_vello(scene, transform, context, render_params);
+		}
+	}
+
+	fn collect_metadata(&self, metadata: &mut RenderMetadata, footprint: Footprint, _element_id: Option<NodeId>) {
+		for row in self.iter() {
+			row.element.collect_metadata(metadata, footprint, *row.source_node_id);
+		}
+	}
+
+	fn add_upstream_click_targets(&self, click_targets: &mut Vec<ClickTarget>) {
+		for row in self.iter() {
+			row.element.add_upstream_click_targets(click_targets);
+		}
+	}
+
+	fn contains_artboard(&self) -> bool {
+		self.iter().count() > 0
+	}
+}
+
 impl Render for Table<Graphic> {
 	fn render_svg(&self, render: &mut SvgRender, render_params: &RenderParams) {
 		let mut iter = self.iter().peekable();
@@ -425,41 +674,41 @@ impl Render for Table<Vector> {
 			let layer_bounds = vector.bounding_box().unwrap_or_default();
 			let transformed_bounds = vector.bounding_box_with_transform(applied_stroke_transform).unwrap_or_default();
 
-			let mut path = String::new();
+			let bounds_matrix = DAffine2::from_scale_angle_translation(layer_bounds[1] - layer_bounds[0], 0., layer_bounds[0]);
+			let transformed_bounds_matrix = element_transform * DAffine2::from_scale_angle_translation(transformed_bounds[1] - transformed_bounds[0], 0., transformed_bounds[0]);
 
+			let mut path = String::new();
 			for subpath in row.element.stroke_bezier_paths() {
 				let _ = subpath.subpath_to_svg(&mut path, applied_stroke_transform);
 			}
 
-			let connected = vector.stroke_bezier_paths().all(|path| path.closed());
+			let mask_type = if vector.style.stroke().map(|x| x.align) == Some(StrokeAlign::Inside) {
-			let can_draw_aligned_stroke = vector.style.stroke().is_some_and(|stroke| stroke.has_renderable_stroke() && stroke.align.is_not_centered()) && connected;
+				MaskType::Clip
-			let mut push_id = None;
+			} else {
+				MaskType::Mask
+			};
+			let path_is_closed = vector.stroke_bezier_paths().all(|path| path.closed());
+			let can_draw_aligned_stroke = path_is_closed && vector.style.stroke().is_some_and(|stroke| stroke.has_renderable_stroke() && stroke.align.is_not_centered());
+			let can_use_paint_order = !(row.element.style.fill().is_none() || mask_type == MaskType::Clip);
 
-			if can_draw_aligned_stroke {
+			let push_id = if can_draw_aligned_stroke && !can_use_paint_order {
-				let mask_type = if vector.style.stroke().unwrap().align == StrokeAlign::Inside {
+				let id = format!("alignment-{}", generate_uuid());
-					MaskType::Clip
-				} else {
-					MaskType::Mask
-				};
 
-				let can_use_order = !row.element.style.fill().is_none() && mask_type == MaskType::Mask;
+				let mut element = row.element.clone();
-				if !can_use_order {
+				element.style.clear_stroke();
-					let id = format!("alignment-{}", generate_uuid());
+				element.style.set_fill(Fill::solid(Color::BLACK));
 
-					let mut element = row.element.clone();
+				let vector_row = Table::new_from_row(TableRow {
-					element.style.clear_stroke();
+					element,
-					element.style.set_fill(Fill::solid(Color::BLACK));
+					alpha_blending: *row.alpha_blending,
+					transform: *row.transform,
+					source_node_id: None,
+				});
 
-					let vector_row = Table::new_from_row(TableRow {
+				Some((id, mask_type, vector_row))
-						element,
+			} else {
-						alpha_blending: *row.alpha_blending,
+				None
-						transform: *row.transform,
+			};
-						source_node_id: None,
-					});
-
-					push_id = Some((id, mask_type, vector_row));
-				}
-			}
 
 			render.leaf_tag("path", |attributes| {
 				attributes.push("d", path);
@@ -485,16 +734,14 @@ impl Render for Table<Vector> {
 					}
 				}
 
-				let fill_and_stroke = row.element.style.render(
+				let mut render_params = render_params.clone();
-					defs,
+				render_params.aligned_strokes = can_draw_aligned_stroke;
-					element_transform,
+				render_params.override_paint_order = can_draw_aligned_stroke && can_use_paint_order;
-					applied_stroke_transform,
+
-					layer_bounds,
+				let fill_and_stroke = row
-					transformed_bounds,
+					.element
-					can_draw_aligned_stroke,
+					.style
-					can_draw_aligned_stroke && push_id.is_none(),
+					.render(defs, element_transform, applied_stroke_transform, bounds_matrix, transformed_bounds_matrix, &render_params);
-					render_params,
-				);
 
 				if let Some((id, mask_type, _)) = push_id {
 					let selector = format!("url(#{id})");
@@ -813,134 +1060,6 @@ impl Render for Table<Vector> {
 	}
 }
 
-impl Render for Artboard {
-	fn render_svg(&self, render: &mut SvgRender, render_params: &RenderParams) {
-		// Rectangle for the artboard
-		if !render_params.hide_artboards {
-			// Background
-			render.leaf_tag("rect", |attributes| {
-				attributes.push("fill", format!("#{}", self.background.to_rgb_hex_srgb_from_gamma()));
-				if self.background.a() < 1. {
-					attributes.push("fill-opacity", ((self.background.a() * 1000.).round() / 1000.).to_string());
-				}
-				attributes.push("x", self.location.x.min(self.location.x + self.dimensions.x).to_string());
-				attributes.push("y", self.location.y.min(self.location.y + self.dimensions.y).to_string());
-				attributes.push("width", self.dimensions.x.abs().to_string());
-				attributes.push("height", self.dimensions.y.abs().to_string());
-			});
-		}
-
-		// Artwork
-		render.parent_tag(
-			// SVG group tag
-			"g",
-			// Group tag attributes
-			|attributes| {
-				let matrix = format_transform_matrix(self.transform());
-				if !matrix.is_empty() {
-					attributes.push("transform", matrix);
-				}
-
-				if self.clip {
-					let id = format!("artboard-{}", generate_uuid());
-					let selector = format!("url(#{id})");
-
-					write!(
-						&mut attributes.0.svg_defs,
-						r##"<clipPath id="{id}"><rect x="0" y="0" width="{}" height="{}"/></clipPath>"##,
-						self.dimensions.x, self.dimensions.y,
-					)
-					.unwrap();
-					attributes.push("clip-path", selector);
-				}
-			},
-			// Artwork content
-			|render| {
-				self.content.render_svg(render, render_params);
-			},
-		);
-	}
-
-	#[cfg(feature = "vello")]
-	fn render_to_vello(&self, scene: &mut Scene, transform: DAffine2, context: &mut RenderContext, render_params: &RenderParams) {
-		use vello::peniko;
-
-		// Render background
-		let color = peniko::Color::new([self.background.r(), self.background.g(), self.background.b(), self.background.a()]);
-		let [a, b] = [self.location.as_dvec2(), self.location.as_dvec2() + self.dimensions.as_dvec2()];
-		let rect = kurbo::Rect::new(a.x.min(b.x), a.y.min(b.y), a.x.max(b.x), a.y.max(b.y));
-
-		scene.push_layer(peniko::Mix::Normal, 1., kurbo::Affine::new(transform.to_cols_array()), &rect);
-		scene.fill(peniko::Fill::NonZero, kurbo::Affine::new(transform.to_cols_array()), color, None, &rect);
-		scene.pop_layer();
-
-		if self.clip {
-			let blend_mode = peniko::BlendMode::new(peniko::Mix::Clip, peniko::Compose::SrcOver);
-			scene.push_layer(blend_mode, 1., kurbo::Affine::new(transform.to_cols_array()), &rect);
-		}
-		// Since the content's transform is right multiplied in when rendering the content, we just need to right multiply by the artboard offset here.
-		let child_transform = transform * DAffine2::from_translation(self.location.as_dvec2());
-		self.content.render_to_vello(scene, child_transform, context, render_params);
-		if self.clip {
-			scene.pop_layer();
-		}
-	}
-
-	fn collect_metadata(&self, metadata: &mut RenderMetadata, mut footprint: Footprint, element_id: Option<NodeId>) {
-		if let Some(element_id) = element_id {
-			let subpath = Subpath::new_rect(DVec2::ZERO, self.dimensions.as_dvec2());
-			metadata.click_targets.insert(element_id, vec![ClickTarget::new_with_subpath(subpath, 0.)]);
-			metadata.upstream_footprints.insert(element_id, footprint);
-			metadata.local_transforms.insert(element_id, DAffine2::from_translation(self.location.as_dvec2()));
-			if self.clip {
-				metadata.clip_targets.insert(element_id);
-			}
-		}
-		footprint.transform *= self.transform();
-		self.content.collect_metadata(metadata, footprint, None);
-	}
-
-	fn add_upstream_click_targets(&self, click_targets: &mut Vec<ClickTarget>) {
-		let subpath_rectangle = Subpath::new_rect(DVec2::ZERO, self.dimensions.as_dvec2());
-		click_targets.push(ClickTarget::new_with_subpath(subpath_rectangle, 0.));
-	}
-
-	fn contains_artboard(&self) -> bool {
-		true
-	}
-}
-
-impl Render for Table<Artboard> {
-	fn render_svg(&self, render: &mut SvgRender, render_params: &RenderParams) {
-		for artboard in self.iter() {
-			artboard.element.render_svg(render, render_params);
-		}
-	}
-
-	#[cfg(feature = "vello")]
-	fn render_to_vello(&self, scene: &mut Scene, transform: DAffine2, context: &mut RenderContext, render_params: &RenderParams) {
-		for row in self.iter() {
-			row.element.render_to_vello(scene, transform, context, render_params);
-		}
-	}
-
-	fn collect_metadata(&self, metadata: &mut RenderMetadata, footprint: Footprint, _element_id: Option<NodeId>) {
-		for row in self.iter() {
-			row.element.collect_metadata(metadata, footprint, *row.source_node_id);
-		}
-	}
-
-	fn add_upstream_click_targets(&self, click_targets: &mut Vec<ClickTarget>) {
-		for row in self.iter() {
-			row.element.add_upstream_click_targets(click_targets);
-		}
-	}
-
-	fn contains_artboard(&self) -> bool {
-		self.iter().count() > 0
-	}
-}
-
 impl Render for Table<Raster<CPU>> {
 	fn render_svg(&self, render: &mut SvgRender, render_params: &RenderParams) {
 		for row in self.iter() {
@@ -1142,109 +1261,6 @@ impl Render for Table<Raster<GPU>> {
 	}
 }
 
-impl Render for Graphic {
-	fn render_svg(&self, render: &mut SvgRender, render_params: &RenderParams) {
-		match self {
-			Graphic::Graphic(graphic) => graphic.render_svg(render, render_params),
-			Graphic::Vector(vector) => vector.render_svg(render, render_params),
-			Graphic::RasterCPU(raster) => raster.render_svg(render, render_params),
-			Graphic::RasterGPU(_) => (),
-			Graphic::Color(color) => color.render_svg(render, render_params),
-		}
-	}
-
-	#[cfg(feature = "vello")]
-	fn render_to_vello(&self, scene: &mut Scene, transform: DAffine2, context: &mut RenderContext, render_params: &RenderParams) {
-		match self {
-			Graphic::Graphic(graphic) => graphic.render_to_vello(scene, transform, context, render_params),
-			Graphic::Vector(vector) => vector.render_to_vello(scene, transform, context, render_params),
-			Graphic::RasterCPU(raster) => raster.render_to_vello(scene, transform, context, render_params),
-			Graphic::RasterGPU(raster) => raster.render_to_vello(scene, transform, context, render_params),
-			Graphic::Color(color) => color.render_to_vello(scene, transform, context, render_params),
-		}
-	}
-
-	fn collect_metadata(&self, metadata: &mut RenderMetadata, footprint: Footprint, element_id: Option<NodeId>) {
-		if let Some(element_id) = element_id {
-			match self {
-				Graphic::Graphic(_) => {
-					metadata.upstream_footprints.insert(element_id, footprint);
-				}
-				Graphic::Vector(vector) => {
-					metadata.upstream_footprints.insert(element_id, footprint);
-					// TODO: Find a way to handle more than one row of the vector table
-					if let Some(vector) = vector.iter().next() {
-						metadata.first_element_source_id.insert(element_id, *vector.source_node_id);
-						metadata.local_transforms.insert(element_id, *vector.transform);
-					}
-				}
-				Graphic::RasterCPU(raster) => {
-					metadata.upstream_footprints.insert(element_id, footprint);
-
-					// TODO: Find a way to handle more than one row of images
-					if let Some(raster) = raster.iter().next() {
-						metadata.local_transforms.insert(element_id, *raster.transform);
-					}
-				}
-				Graphic::RasterGPU(raster) => {
-					metadata.upstream_footprints.insert(element_id, footprint);
-
-					// TODO: Find a way to handle more than one row of images
-					if let Some(raster) = raster.iter().next() {
-						metadata.local_transforms.insert(element_id, *raster.transform);
-					}
-				}
-				Graphic::Color(color) => {
-					metadata.upstream_footprints.insert(element_id, footprint);
-
-					// TODO: Find a way to handle more than one row of images
-					if let Some(color) = color.iter().next() {
-						metadata.local_transforms.insert(element_id, *color.transform);
-					}
-				}
-			}
-		}
-
-		match self {
-			Graphic::Graphic(graphic) => graphic.collect_metadata(metadata, footprint, element_id),
-			Graphic::Vector(vector) => vector.collect_metadata(metadata, footprint, element_id),
-			Graphic::RasterCPU(raster) => raster.collect_metadata(metadata, footprint, element_id),
-			Graphic::RasterGPU(raster) => raster.collect_metadata(metadata, footprint, element_id),
-			Graphic::Color(color) => color.collect_metadata(metadata, footprint, element_id),
-		}
-	}
-
-	fn add_upstream_click_targets(&self, click_targets: &mut Vec<ClickTarget>) {
-		match self {
-			Graphic::Graphic(graphic) => graphic.add_upstream_click_targets(click_targets),
-			Graphic::Vector(vector) => vector.add_upstream_click_targets(click_targets),
-			Graphic::RasterCPU(raster) => raster.add_upstream_click_targets(click_targets),
-			Graphic::RasterGPU(raster) => raster.add_upstream_click_targets(click_targets),
-			Graphic::Color(color) => color.add_upstream_click_targets(click_targets),
-		}
-	}
-
-	fn contains_artboard(&self) -> bool {
-		match self {
-			Graphic::Graphic(graphic) => graphic.contains_artboard(),
-			Graphic::Vector(vector) => vector.contains_artboard(),
-			Graphic::RasterCPU(raster) => raster.contains_artboard(),
-			Graphic::RasterGPU(raster) => raster.contains_artboard(),
-			Graphic::Color(color) => color.contains_artboard(),
-		}
-	}
-
-	fn new_ids_from_hash(&mut self, reference: Option<NodeId>) {
-		match self {
-			Graphic::Graphic(graphic) => graphic.new_ids_from_hash(reference),
-			Graphic::Vector(vector) => vector.new_ids_from_hash(reference),
-			Graphic::RasterCPU(_) => (),
-			Graphic::RasterGPU(_) => (),
-			Graphic::Color(_) => (),
-		}
-	}
-}
-
 impl Render for Table<Color> {
 	fn render_svg(&self, render: &mut SvgRender, render_params: &RenderParams) {
 		for row in self.iter() {
@@ -1309,26 +1325,104 @@ impl Render for Table<Color> {
 	}
 }
 
-trait Primitive: std::fmt::Display + BoundingBox + RenderComplexity {}
+impl Render for Table<GradientStops> {
-impl Primitive for bool {}
+	fn render_svg(&self, render: &mut SvgRender, render_params: &RenderParams) {
-impl Primitive for f32 {}
+		for row in self.iter() {
-impl Primitive for f64 {}
+			render.leaf_tag("rect", |attributes| {
-impl Primitive for DVec2 {}
+				attributes.push("width", render_params.footprint.resolution.x.to_string());
-impl Primitive for String {}
+				attributes.push("height", render_params.footprint.resolution.y.to_string());
 
-fn text_attributes(attributes: &mut SvgRenderAttrs) {
+				let matrix = format_transform_matrix(render_params.footprint.transform.inverse());
-	attributes.push("fill", "white");
+				if !matrix.is_empty() {
-	attributes.push("y", "30");
+					attributes.push("transform", matrix);
-	attributes.push("font-size", "30");
+				}
-}
 
-impl<P: Primitive> Render for P {
+				let mut stop_string = String::new();
-	fn render_svg(&self, render: &mut SvgRender, _render_params: &RenderParams) {
+				for (position, color) in row.element.0.iter() {
-		render.parent_tag("text", text_attributes, |render| render.leaf_node(format!("{self}")));
+					let _ = write!(stop_string, r##"<stop offset="{}" stop-color="#{}""##, position, color.to_rgb_hex_srgb_from_gamma());
+					if color.a() < 1. {
+						let _ = write!(stop_string, r#" stop-opacity="{}""#, color.a());
+					}
+					stop_string.push_str(" />");
+				}
+
+				let gradient_transform = render_params.footprint.transform * *row.transform;
+				let gradient_transform_matrix = format_transform_matrix(gradient_transform);
+				let gradient_transform_attribute = if gradient_transform_matrix.is_empty() {
+					String::new()
+				} else {
+					format!(r#" gradientTransform="{gradient_transform_matrix}""#)
+				};
+
+				let gradient_id = generate_uuid();
+				let start = DVec2::ZERO;
+				let end = DVec2::X;
+
+				match GradientType::Radial {
+					GradientType::Linear => {
+						let (x1, y1) = (start.x, start.y);
+						let (x2, y2) = (end.x, end.y);
+						let _ = write!(
+							&mut attributes.0.svg_defs,
+							r#"<linearGradient id="{gradient_id}" gradientUnits="userSpaceOnUse" x1="{x1}" y1="{y1}" x2="{x2}" y2="{y2}"{gradient_transform_attribute}>{stop_string}</linearGradient>"#
+						);
+					}
+					GradientType::Radial => {
+						let (cx, cy) = (start.x, start.y);
+						let r = start.distance(end);
+						let _ = write!(
+							&mut attributes.0.svg_defs,
+							r#"<radialGradient id="{gradient_id}" gradientUnits="userSpaceOnUse" cx="{cx}" cy="{cy}" r="{r}"{gradient_transform_attribute}>{stop_string}</radialGradient>"#
+						);
+					}
+				}
+
+				attributes.push("fill", format!("url('#{gradient_id}')"));
+
+				let opacity = row.alpha_blending.opacity(render_params.for_mask);
+				if opacity < 1. {
+					attributes.push("opacity", opacity.to_string());
+				}
+
+				if row.alpha_blending.blend_mode != BlendMode::default() {
+					attributes.push("style", row.alpha_blending.blend_mode.render());
+				}
+			});
+		}
 	}
 
 	#[cfg(feature = "vello")]
-	fn render_to_vello(&self, _scene: &mut Scene, _transform: DAffine2, _context: &mut RenderContext, _render_params: &RenderParams) {}
+	fn render_to_vello(&self, scene: &mut Scene, parent_transform: DAffine2, _context: &mut RenderContext, render_params: &RenderParams) {
+		use vello::peniko;
+
+		for row in self.iter() {
+			let alpha_blending = *row.alpha_blending;
+			let blend_mode = alpha_blending.blend_mode.to_peniko();
+			let opacity = alpha_blending.opacity(render_params.for_mask);
+
+			let transform = parent_transform * render_params.footprint.transform.inverse();
+			let color = row.element.0.first().map(|stop| stop.1).unwrap_or(Color::MAGENTA);
+			let vello_color = peniko::Color::new([color.r(), color.g(), color.b(), color.a()]);
+
+			let rect = kurbo::Rect::from_origin_size(
+				kurbo::Point::ZERO,
+				kurbo::Size::new(render_params.footprint.resolution.x as f64, render_params.footprint.resolution.y as f64),
+			);
+
+			let mut layer = false;
+			if opacity < 1. || alpha_blending.blend_mode != BlendMode::default() {
+				let blending = peniko::BlendMode::new(blend_mode, peniko::Compose::SrcOver);
+				scene.push_layer(blending, opacity, kurbo::Affine::IDENTITY, &rect);
+				layer = true;
+			}
+
+			scene.fill(peniko::Fill::NonZero, kurbo::Affine::new(transform.to_cols_array()), vello_color, None, &rect);
+
+			if layer {
+				scene.pop_layer();
+			}
+		}
+	}
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]

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

@@ -20,6 +20,7 @@ use graphene_std::any::{ComposeTypeErased, DynAnyNode, IntoTypeErasedNode};
 use graphene_std::application_io::{ImageTexture, SurfaceFrame};
 use graphene_std::brush::brush_cache::BrushCache;
 use graphene_std::brush::brush_stroke::BrushStroke;
+use graphene_std::gradient::GradientStops;
 use graphene_std::table::Table;
 use graphene_std::uuid::NodeId;
 use graphene_std::vector::Vector;
@@ -63,6 +64,7 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 		#[cfg(feature = "gpu")]
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => Table<Raster<GPU>>]),
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => Table<Color>]),
+		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => Table<GradientStops>]),
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => String]),
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => IVec2]),
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => DVec2]),
@@ -83,7 +85,7 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => graphene_core::vector::style::StrokeAlign]),
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => graphene_core::vector::style::Stroke]),
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => graphene_core::vector::style::Gradient]),
-		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => graphene_core::vector::style::GradientStops]),
+		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => GradientStops]),
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => Vec<graphene_core::uuid::NodeId>]),
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => Box<graphene_core::vector::VectorModification>]),
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => graphene_std::vector::misc::CentroidType]),
@@ -130,6 +132,7 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 		async_node!(graphene_core::memo::MemoNode<_, _>, input: Context, fn_params: [Context => Table<Raster<CPU>>]),
 		async_node!(graphene_core::memo::MemoNode<_, _>, input: Context, fn_params: [Context => Table<Color>]),
 		async_node!(graphene_core::memo::MemoNode<_, _>, input: Context, fn_params: [Context => Image<Color>]),
+		async_node!(graphene_core::memo::MemoNode<_, _>, input: Context, fn_params: [Context => Table<GradientStops>]),
 		async_node!(graphene_core::memo::MemoNode<_, _>, input: Context, fn_params: [Context => Vec<DVec2>]),
 		#[cfg(feature = "gpu")]
 		async_node!(graphene_core::memo::MemoNode<_, _>, input: Context, fn_params: [Context => Arc<WasmSurfaceHandle>]),
@@ -154,6 +157,7 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 		#[cfg(feature = "gpu")]
 		async_node!(graphene_core::memo::ImpureMemoNode<_, _, _>, input: Context, fn_params: [Context => Table<Raster<GPU>>]),
 		async_node!(graphene_core::memo::ImpureMemoNode<_, _, _>, input: Context, fn_params: [Context => Table<Color>]),
+		async_node!(graphene_core::memo::ImpureMemoNode<_, _, _>, input: Context, fn_params: [Context => Table<GradientStops>]),
 		async_node!(graphene_core::memo::ImpureMemoNode<_, _, _>, input: Context, fn_params: [Context => WgpuSurface]),
 		async_node!(graphene_core::memo::ImpureMemoNode<_, _, _>, input: Context, fn_params: [Context => Option<WgpuSurface>]),
 		async_node!(graphene_core::memo::ImpureMemoNode<_, _, _>, input: Context, fn_params: [Context => ImageTexture]),

node-graph/node-macro/src/parsing.rs

@@ -1276,9 +1276,11 @@ mod tests {
 				#[implementations(
 					() -> Table<Raster<CPU>>,
 					() -> Table<Color>,
+					() -> Table<GradientStops>,
 					() -> GradientStops,
 					Footprint -> Table<Raster<CPU>>,
 					Footprint -> Table<Color>,
+					Footprint -> Table<GradientStops>,
 					Footprint -> GradientStops,
 				)]
 				image: impl Node<F, Output = T>,