Extract gsvg_renderer from gcore, remove gcore/vello feature (#2760)

Extract `gsvg_renderer` from `gcore`, remove `gcore/vello` feature

node-graph/gcore/src/blending.rs

@@ -238,34 +238,3 @@ impl std::fmt::Display for BlendMode {
 		}
 	}
 }
-
-#[cfg(feature = "vello")]
-impl From<BlendMode> for vello::peniko::Mix {
-	fn from(val: BlendMode) -> Self {
-		match val {
-			// Normal group
-			BlendMode::Normal => vello::peniko::Mix::Normal,
-			// Darken group
-			BlendMode::Darken => vello::peniko::Mix::Darken,
-			BlendMode::Multiply => vello::peniko::Mix::Multiply,
-			BlendMode::ColorBurn => vello::peniko::Mix::ColorBurn,
-			// Lighten group
-			BlendMode::Lighten => vello::peniko::Mix::Lighten,
-			BlendMode::Screen => vello::peniko::Mix::Screen,
-			BlendMode::ColorDodge => vello::peniko::Mix::ColorDodge,
-			// Contrast group
-			BlendMode::Overlay => vello::peniko::Mix::Overlay,
-			BlendMode::SoftLight => vello::peniko::Mix::SoftLight,
-			BlendMode::HardLight => vello::peniko::Mix::HardLight,
-			// Inversion group
-			BlendMode::Difference => vello::peniko::Mix::Difference,
-			BlendMode::Exclusion => vello::peniko::Mix::Exclusion,
-			// Component group
-			BlendMode::Hue => vello::peniko::Mix::Hue,
-			BlendMode::Saturation => vello::peniko::Mix::Saturation,
-			BlendMode::Color => vello::peniko::Mix::Color,
-			BlendMode::Luminosity => vello::peniko::Mix::Luminosity,
-			_ => todo!(),
-		}
-	}
-}

node-graph/gcore/src/bounds.rs

@@ -0,0 +1,24 @@
+use crate::Color;
+use glam::{DAffine2, DVec2};
+
+pub trait BoundingBox {
+	fn bounding_box(&self, transform: DAffine2, include_stroke: bool) -> Option<[DVec2; 2]>;
+}
+
+macro_rules! none_impl {
+	($t:path) => {
+		impl BoundingBox for $t {
+			fn bounding_box(&self, _transform: DAffine2, _include_stroke: bool) -> Option<[DVec2; 2]> {
+				None
+			}
+		}
+	};
+}
+
+none_impl!(String);
+none_impl!(bool);
+none_impl!(f32);
+none_impl!(f64);
+none_impl!(DVec2);
+none_impl!(Option<Color>);
+none_impl!(Vec<Color>);

node-graph/gcore/src/graphic_element.rs

@@ -1,5 +1,7 @@
 use crate::blending::AlphaBlending;
+use crate::bounds::BoundingBox;
 use crate::instances::{Instance, Instances};
+use crate::math::quad::Quad;
 use crate::raster::image::Image;
 use crate::raster_types::{CPU, GPU, Raster, RasterDataTable};
 use crate::transform::TransformMut;
@@ -7,11 +9,9 @@ use crate::uuid::NodeId;
 use crate::vector::{VectorData, VectorDataTable};
 use crate::{CloneVarArgs, Color, Context, Ctx, ExtractAll, OwnedContextImpl};
 use dyn_any::DynAny;
-use glam::{DAffine2, IVec2};
+use glam::{DAffine2, DVec2, IVec2};
 use std::hash::Hash;
 
-pub mod renderer;
-
 // TODO: Eventually remove this migration document upgrade code
 pub fn migrate_graphic_group<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Result<GraphicGroupTable, D::Error> {
 	use serde::Deserialize;
@@ -182,6 +182,25 @@ impl GraphicElement {
 	}
 }
 
+impl BoundingBox for GraphicElement {
+	fn bounding_box(&self, transform: DAffine2, include_stroke: bool) -> Option<[DVec2; 2]> {
+		match self {
+			GraphicElement::VectorData(vector_data) => vector_data.bounding_box(transform, include_stroke),
+			GraphicElement::RasterDataCPU(raster) => raster.bounding_box(transform, include_stroke),
+			GraphicElement::RasterDataGPU(raster) => raster.bounding_box(transform, include_stroke),
+			GraphicElement::GraphicGroup(graphic_group) => graphic_group.bounding_box(transform, include_stroke),
+		}
+	}
+}
+
+impl BoundingBox for GraphicGroupTable {
+	fn bounding_box(&self, transform: DAffine2, include_stroke: bool) -> Option<[DVec2; 2]> {
+		self.instance_ref_iter()
+			.filter_map(|element| element.instance.bounding_box(transform * *element.transform, include_stroke))
+			.reduce(Quad::combine_bounds)
+	}
+}
+
 impl<'de> serde::Deserialize<'de> for Raster<CPU> {
 	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
 	where
@@ -247,6 +266,20 @@ impl Artboard {
 	}
 }
 
+impl BoundingBox for Artboard {
+	fn bounding_box(&self, transform: DAffine2, include_stroke: bool) -> Option<[DVec2; 2]> {
+		let artboard_bounds = (transform * Quad::from_box([self.location.as_dvec2(), self.location.as_dvec2() + self.dimensions.as_dvec2()])).bounding_box();
+		if self.clip {
+			Some(artboard_bounds)
+		} else {
+			[self.graphic_group.bounding_box(transform, include_stroke), Some(artboard_bounds)]
+				.into_iter()
+				.flatten()
+				.reduce(Quad::combine_bounds)
+		}
+	}
+}
+
 // TODO: Eventually remove this migration document upgrade code
 pub fn migrate_artboard_group<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Result<ArtboardGroupTable, D::Error> {
 	use serde::Deserialize;
@@ -282,6 +315,14 @@ pub fn migrate_artboard_group<'de, D: serde::Deserializer<'de>>(deserializer: D)
 
 pub type ArtboardGroupTable = Instances<Artboard>;
 
+impl BoundingBox for ArtboardGroupTable {
+	fn bounding_box(&self, transform: DAffine2, include_stroke: bool) -> Option<[DVec2; 2]> {
+		self.instance_ref_iter()
+			.filter_map(|instance| instance.instance.bounding_box(transform, include_stroke))
+			.reduce(Quad::combine_bounds)
+	}
+}
+
 #[node_macro::node(category(""))]
 async fn layer<I: 'n + Send + Clone>(
 	_: impl Ctx,
@@ -506,3 +547,7 @@ impl From<GraphicGroupTable> for GraphicElement {
 		GraphicElement::GraphicGroup(graphic_group)
 	}
 }
+
+pub trait ToGraphicElement {
+	fn to_graphic_element(&self) -> GraphicElement;
+}

node-graph/gcore/src/graphic_element/renderer/convert_usvg_path.rs

@@ -1,47 +0,0 @@
-use crate::vector::PointId;
-use bezier_rs::{ManipulatorGroup, Subpath};
-use glam::DVec2;
-
-pub fn convert_usvg_path(path: &usvg::Path) -> Vec<Subpath<PointId>> {
-	let mut subpaths = Vec::new();
-	let mut groups = Vec::new();
-
-	let mut points = path.data().points().iter();
-	let to_vec = |p: &usvg::tiny_skia_path::Point| DVec2::new(p.x as f64, p.y as f64);
-
-	for verb in path.data().verbs() {
-		match verb {
-			usvg::tiny_skia_path::PathVerb::Move => {
-				subpaths.push(Subpath::new(std::mem::take(&mut groups), false));
-				let Some(start) = points.next().map(to_vec) else { continue };
-				groups.push(ManipulatorGroup::new(start, Some(start), Some(start)));
-			}
-			usvg::tiny_skia_path::PathVerb::Line => {
-				let Some(end) = points.next().map(to_vec) else { continue };
-				groups.push(ManipulatorGroup::new(end, Some(end), Some(end)));
-			}
-			usvg::tiny_skia_path::PathVerb::Quad => {
-				let Some(handle) = points.next().map(to_vec) else { continue };
-				let Some(end) = points.next().map(to_vec) else { continue };
-				if let Some(last) = groups.last_mut() {
-					last.out_handle = Some(last.anchor + (2. / 3.) * (handle - last.anchor));
-				}
-				groups.push(ManipulatorGroup::new(end, Some(end + (2. / 3.) * (handle - end)), Some(end)));
-			}
-			usvg::tiny_skia_path::PathVerb::Cubic => {
-				let Some(first_handle) = points.next().map(to_vec) else { continue };
-				let Some(second_handle) = points.next().map(to_vec) else { continue };
-				let Some(end) = points.next().map(to_vec) else { continue };
-				if let Some(last) = groups.last_mut() {
-					last.out_handle = Some(first_handle);
-				}
-				groups.push(ManipulatorGroup::new(end, Some(second_handle), Some(end)));
-			}
-			usvg::tiny_skia_path::PathVerb::Close => {
-				subpaths.push(Subpath::new(std::mem::take(&mut groups), true));
-			}
-		}
-	}
-	subpaths.push(Subpath::new(groups, false));
-	subpaths
-}

node-graph/gcore/src/lib.rs

@@ -4,6 +4,7 @@ extern crate log;
 pub mod animation;
 pub mod blending;
 pub mod blending_nodes;
+pub mod bounds;
 pub mod color;
 pub mod consts;
 pub mod context;

node-graph/gcore/src/raster_types.rs

@@ -1,8 +1,11 @@
 use crate::Color;
+use crate::bounds::BoundingBox;
 use crate::instances::Instances;
+use crate::math::quad::Quad;
 use crate::raster::Image;
 use core::ops::Deref;
 use dyn_any::DynAny;
+use glam::{DAffine2, DVec2};
 #[cfg(feature = "wgpu")]
 use std::sync::Arc;
 
@@ -11,18 +14,18 @@ pub struct CPU;
 #[derive(Clone, Debug, Hash, PartialEq, Eq, Copy)]
 pub struct GPU;
 
-trait Storage {}
+trait Storage: 'static {}
 impl Storage for CPU {}
 impl Storage for GPU {}
 
 #[derive(Clone, Debug, Hash, PartialEq)]
 #[allow(private_bounds)]
-pub struct Raster<T: 'static + Storage> {
+pub struct Raster<T: Storage> {
 	data: RasterStorage,
 	storage: T,
 }
 
-unsafe impl<T: 'static + Storage> dyn_any::StaticType for Raster<T> {
+unsafe impl<T: Storage> dyn_any::StaticType for Raster<T> {
 	type Static = Raster<T>;
 }
 #[derive(Clone, Debug, Hash, PartialEq, DynAny)]
@@ -100,3 +103,14 @@ impl Deref for Raster<GPU> {
 	}
 }
 pub type RasterDataTable<Storage> = Instances<Raster<Storage>>;
+
+impl<S: Storage> BoundingBox for RasterDataTable<S> {
+	fn bounding_box(&self, transform: DAffine2, _include_stroke: bool) -> Option<[DVec2; 2]> {
+		self.instance_ref_iter()
+			.flat_map(|instance| {
+				let transform = transform * *instance.transform;
+				(transform.matrix2.determinant() != 0.).then(|| (transform * Quad::from_box([DVec2::ZERO, DVec2::ONE])).bounding_box())
+			})
+			.reduce(Quad::combine_bounds)
+	}
+}

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

@@ -1,5 +1,5 @@
 use crate::math::math_ext::QuadExt;
-use crate::renderer::Quad;
+use crate::math::quad::Quad;
 use crate::vector::PointId;
 use bezier_rs::Subpath;
 use glam::{DAffine2, DMat2, DVec2};

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

@@ -1,70 +1,9 @@
 //! Contains stylistic options for SVG elements.
 
 use crate::Color;
-use crate::consts::{LAYER_OUTLINE_STROKE_COLOR, LAYER_OUTLINE_STROKE_WEIGHT};
 pub use crate::gradient::*;
-use crate::renderer::{RenderParams, format_transform_matrix};
 use dyn_any::DynAny;
-use glam::{DAffine2, DVec2};
-use std::fmt::Write;
-
-impl Gradient {
-	/// Adds the gradient def through mutating the first argument, returning the gradient ID.
-	fn render_defs(&self, svg_defs: &mut String, element_transform: DAffine2, stroke_transform: DAffine2, bounds: [DVec2; 2], transformed_bounds: [DVec2; 2], _render_params: &RenderParams) -> u64 {
-		// 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");
-			if *position != 0. {
-				let _ = write!(stop, r#" offset="{}""#, (position * 1_000_000.).round() / 1_000_000.);
-			}
-			let _ = write!(stop, r##" stop-color="#{}""##, color.to_rgb_hex_srgb_from_gamma());
-			if color.a() < 1. {
-				let _ = write!(stop, r#" stop-opacity="{}""#, (color.a() * 1000.).round() / 1000.);
-			}
-			stop.push_str(" />")
-		}
-
-		let mod_gradient = if transformed_bound_transform.matrix2.determinant() != 0. {
-			transformed_bound_transform.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 start = mod_points.transform_point2(self.start);
-		let end = mod_points.transform_point2(self.end);
-
-		let gradient_id = crate::uuid::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>"#,
-					gradient_id, start.x, end.x, start.y, end.y, stop
-				);
-			}
-			GradientType::Radial => {
-				let radius = (f64::powi(start.x - end.x, 2) + f64::powi(start.y - end.y, 2)).sqrt();
-				let _ = write!(
-					svg_defs,
-					r#"<radialGradient id="{}" cx="{}" cy="{}" r="{}"{gradient_transform}>{}</radialGradient>"#,
-					gradient_id, start.x, start.y, radius, stop
-				);
-			}
-		}
-
-		gradient_id
-	}
-}
+use glam::DAffine2;
 
 /// Describes the fill of a layer.
 ///
@@ -138,24 +77,6 @@ impl Fill {
 		}
 	}
 
-	/// Renders the fill, adding necessary defs through mutating the first argument.
-	pub fn render(&self, svg_defs: &mut String, element_transform: DAffine2, stroke_transform: DAffine2, bounds: [DVec2; 2], transformed_bounds: [DVec2; 2], render_params: &RenderParams) -> String {
-		match self {
-			Self::None => r#" fill="none""#.to_string(),
-			Self::Solid(color) => {
-				let mut result = format!(r##" fill="#{}""##, color.to_rgb_hex_srgb_from_gamma());
-				if color.a() < 1. {
-					let _ = write!(result, r#" fill-opacity="{}""#, (color.a() * 1000.).round() / 1000.);
-				}
-				result
-			}
-			Self::Gradient(gradient) => {
-				let gradient_id = gradient.render_defs(svg_defs, element_transform, stroke_transform, bounds, transformed_bounds, render_params);
-				format!(r##" fill="url('#{gradient_id}')""##)
-			}
-		}
-	}
-
 	/// Extract a gradient from the fill
 	pub fn as_gradient(&self) -> Option<&Gradient> {
 		match self {
@@ -279,7 +200,7 @@ pub enum StrokeCap {
 }
 
 impl StrokeCap {
-	fn svg_name(&self) -> &'static str {
+	pub fn svg_name(&self) -> &'static str {
 		match self {
 			StrokeCap::Butt => "butt",
 			StrokeCap::Round => "round",
@@ -299,7 +220,7 @@ pub enum StrokeJoin {
 }
 
 impl StrokeJoin {
-	fn svg_name(&self) -> &'static str {
+	pub fn svg_name(&self) -> &'static str {
 		match self {
 			StrokeJoin::Bevel => "bevel",
 			StrokeJoin::Miter => "miter",
@@ -469,60 +390,6 @@ impl Stroke {
 		self.join_miter_limit as f32
 	}
 
-	/// Provide the SVG attributes for the stroke.
-	pub fn render(&self, aligned_strokes: bool, override_paint_order: bool, _render_params: &RenderParams) -> String {
-		// Don't render a stroke at all if it would be invisible
-		let Some(color) = self.color else { return String::new() };
-		if !self.has_renderable_stroke() {
-			return String::new();
-		}
-
-		// Set to None if the value is the SVG default
-		let weight = (self.weight != 1.).then_some(self.weight);
-		let dash_array = (!self.dash_lengths.is_empty()).then_some(self.dash_lengths());
-		let dash_offset = (self.dash_offset != 0.).then_some(self.dash_offset);
-		let stroke_cap = (self.cap != StrokeCap::Butt).then_some(self.cap);
-		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);
-
-		// Render the needed stroke attributes
-		let mut attributes = format!(r##" stroke="#{}""##, color.to_rgb_hex_srgb_from_gamma());
-		if color.a() < 1. {
-			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 {
-				weight *= 2.;
-			}
-			let _ = write!(&mut attributes, r#" stroke-width="{}""#, weight);
-		}
-		if let Some(dash_array) = 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);
-		}
-		if let Some(stroke_cap) = stroke_cap {
-			let _ = write!(&mut attributes, r#" stroke-linecap="{}""#, stroke_cap.svg_name());
-		}
-		if let Some(stroke_join) = stroke_join {
-			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);
-		}
-		// Add vector-effect attribute to make strokes non-scaling
-		if self.non_scaling {
-			let _ = write!(&mut attributes, r#" vector-effect="non-scaling-stroke""#);
-		}
-		if paint_order.is_some() {
-			let _ = write!(&mut attributes, r#" style="paint-order: stroke;" "#);
-		}
-		attributes
-	}
-
 	pub fn with_color(mut self, color: &Option<Color>) -> Option<Self> {
 		self.color = *color;
 
@@ -604,8 +471,8 @@ impl Default for Stroke {
 #[repr(C)]
 #[derive(Debug, Clone, PartialEq, Default, serde::Serialize, serde::Deserialize, DynAny, specta::Type)]
 pub struct PathStyle {
-	stroke: Option<Stroke>,
-	fill: Fill,
+	pub stroke: Option<Stroke>,
+	pub fill: Fill,
 }
 
 impl std::hash::Hash for PathStyle {
@@ -766,41 +633,6 @@ impl PathStyle {
 	pub fn clear_stroke(&mut self) {
 		self.stroke = None;
 	}
-
-	/// Renders the shape's fill and stroke attributes as a string with them concatenated together.
-	#[allow(clippy::too_many_arguments)]
-	pub fn render(
-		&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(svg_defs, element_transform, stroke_transform, bounds, transformed_bounds, 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(aligned_strokes, override_paint_order, render_params);
-				format!("{fill_attribute}{stroke_attribute}")
-			}
-			_ => {
-				let fill_attribute = self.fill.render(svg_defs, element_transform, stroke_transform, bounds, transformed_bounds, render_params);
-				let stroke_attribute = self
-					.stroke
-					.as_ref()
-					.map(|stroke| stroke.render(aligned_strokes, override_paint_order, render_params))
-					.unwrap_or_default();
-				format!("{fill_attribute}{stroke_attribute}")
-			}
-		}
-	}
 }
 
 /// Represents different ways of rendering an object

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

@@ -4,7 +4,10 @@ mod modification;
 
 use super::misc::{dvec2_to_point, point_to_dvec2};
 use super::style::{PathStyle, Stroke};
+use crate::bounds::BoundingBox;
 use crate::instances::Instances;
+use crate::math::quad::Quad;
+use crate::transform::Transform;
 use crate::vector::click_target::{ClickTargetType, FreePoint};
 use crate::{AlphaBlending, Color, GraphicGroupTable};
 pub use attributes::*;
@@ -487,6 +490,29 @@ impl VectorData {
 	}
 }
 
+impl BoundingBox for VectorDataTable {
+	fn bounding_box(&self, transform: DAffine2, include_stroke: bool) -> Option<[DVec2; 2]> {
+		self.instance_ref_iter()
+			.flat_map(|instance| {
+				if !include_stroke {
+					return instance.instance.bounding_box_with_transform(transform * *instance.transform);
+				}
+
+				let stroke_width = instance.instance.style.stroke().map(|s| s.weight()).unwrap_or_default();
+
+				let miter_limit = instance.instance.style.stroke().map(|s| s.join_miter_limit).unwrap_or(1.);
+
+				let scale = transform.decompose_scale();
+
+				// We use the full line width here to account for different styles of stroke caps
+				let offset = DVec2::splat(stroke_width * scale.x.max(scale.y) * miter_limit);
+
+				instance.instance.bounding_box_with_transform(transform * *instance.transform).map(|[a, b]| [a - offset, b + offset])
+			})
+			.reduce(Quad::combine_bounds)
+	}
+}
+
 /// A selectable part of a curve, either an anchor (start or end of a bézier) or a handle (doesn't necessarily go through the bézier but influences curvature).
 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, DynAny, serde::Serialize, serde::Deserialize)]
 pub enum ManipulatorPointId {

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

@@ -4,10 +4,10 @@ use super::algorithms::spline::{solve_spline_first_handle_closed, solve_spline_f
 use super::misc::{CentroidType, point_to_dvec2};
 use super::style::{Fill, Gradient, GradientStops, Stroke};
 use super::{PointId, SegmentDomain, SegmentId, StrokeId, VectorData, VectorDataExt, VectorDataTable};
+use crate::bounds::BoundingBox;
 use crate::instances::{Instance, InstanceMut, Instances};
 use crate::raster_types::{CPU, GPU, RasterDataTable};
 use crate::registry::types::{Angle, Fraction, IntegerCount, Length, Multiplier, Percentage, PixelLength, PixelSize, SeedValue};
-use crate::renderer::GraphicElementRendered;
 use crate::transform::{Footprint, ReferencePoint, Transform};
 use crate::vector::algorithms::merge_by_distance::MergeByDistanceExt;
 use crate::vector::misc::{MergeByDistanceAlgorithm, PointSpacingType};
@@ -221,10 +221,7 @@ async fn repeat<I: 'n + Send + Clone>(
 	direction: PixelSize,
 	angle: Angle,
 	#[default(4)] instances: IntegerCount,
-) -> Instances<I>
-where
-	Instances<I>: GraphicElementRendered,
-{
+) -> Instances<I> {
 	let angle = angle.to_radians();
 	let count = instances.max(1);
 	let total = (count - 1) as f64;
@@ -258,10 +255,7 @@ async fn circular_repeat<I: 'n + Send + Clone>(
 	angle_offset: Angle,
 	#[default(5)] radius: f64,
 	#[default(5)] instances: IntegerCount,
-) -> Instances<I>
-where
-	Instances<I>: GraphicElementRendered,
-{
+) -> Instances<I> {
 	let count = instances.max(1);
 
 	let mut result_table = Instances::<I>::default();
@@ -313,10 +307,7 @@ async fn copy_to_points<I: 'n + Send + Clone>(
 	random_rotation: Angle,
 	/// Seed to determine unique variations on all the randomized instance angles.
 	random_rotation_seed: SeedValue,
-) -> Instances<I>
-where
-	Instances<I>: GraphicElementRendered,
-{
+) -> Instances<I> {
 	let mut result_table = Instances::<I>::default();
 
 	let random_scale_difference = random_scale_max - random_scale_min;
@@ -377,7 +368,7 @@ async fn mirror<I: 'n + Send + Clone>(
 	#[default(true)] keep_original: bool,
 ) -> Instances<I>
 where
-	Instances<I>: GraphicElementRendered,
+	Instances<I>: BoundingBox,
 {
 	let mut result_table = Instances::default();
 
@@ -1090,7 +1081,7 @@ async fn solidify_stroke(_: impl Ctx, vector_data: VectorDataTable) -> VectorDat
 #[node_macro::node(category("Vector"), path(graphene_core::vector))]
 async fn flatten_path<I: 'n + Send>(_: impl Ctx, #[implementations(GraphicGroupTable, VectorDataTable)] graphic_group_input: Instances<I>) -> VectorDataTable
 where
-	Instances<I>: GraphicElementRendered,
+	GraphicElement: From<Instances<I>>,
 {
 	// A node based solution to support passing through vector data could be a network node with a cache node connected to
 	// a Flatten Path connected to an if else node, another connection from the cache directly
@@ -1135,7 +1126,7 @@ where
 	};
 
 	// Flatten the graphic group input into the output VectorData instance
-	let base_graphic_group = GraphicGroupTable::new(graphic_group_input.to_graphic_element());
+	let base_graphic_group = GraphicGroupTable::new(GraphicElement::from(graphic_group_input));
 	flatten_group(&base_graphic_group, &mut output);
 
 	// Return the single-row VectorDataTable containing the flattened VectorData subpaths