Add reference point input to the Mirror node

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

@@ -275,7 +275,7 @@ pub trait GraphicElementRendered {
 
 	#[cfg(feature = "vello")]
 	fn render_to_vello(&self, scene: &mut Scene, transform: DAffine2, context: &mut RenderContext, _render_params: &RenderParams);
-	fn bounding_box(&self, transform: DAffine2) -> Option<[DVec2; 2]>;
+	fn bounding_box(&self, transform: DAffine2, include_stroke: bool) -> Option<[DVec2; 2]>;
 
 	// The upstream click targets for each layer are collected during the render so that they do not have to be calculated for each click detection
 	fn add_upstream_click_targets(&self, _click_targets: &mut Vec<ClickTarget>) {}
@@ -330,7 +330,11 @@ impl GraphicElementRendered for GraphicGroupTable {
 			let alpha_blending = *instance.alpha_blending;
 
 			let mut layer = false;
-			if let Some(bounds) = self.instance_ref_iter().filter_map(|element| element.instance.bounding_box(transform)).reduce(Quad::combine_bounds) {
+			if let Some(bounds) = self
+				.instance_ref_iter()
+				.filter_map(|element| element.instance.bounding_box(transform, true))
+				.reduce(Quad::combine_bounds)
+			{
 				let blend_mode = match render_params.view_mode {
 					ViewMode::Outline => peniko::Mix::Normal,
 					_ => alpha_blending.blend_mode.into(),
@@ -355,9 +359,9 @@ impl GraphicElementRendered for GraphicGroupTable {
 		}
 	}
 
-	fn bounding_box(&self, transform: DAffine2) -> Option<[DVec2; 2]> {
+	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))
+			.filter_map(|element| element.instance.bounding_box(transform * *element.transform, include_stroke))
 			.reduce(Quad::combine_bounds)
 	}
 
@@ -613,9 +617,13 @@ impl GraphicElementRendered for VectorDataTable {
 		}
 	}
 
-	fn bounding_box(&self, transform: DAffine2) -> Option<[DVec2; 2]> {
+	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.line_join_miter_limit).unwrap_or(1.);
@@ -761,12 +769,15 @@ impl GraphicElementRendered for Artboard {
 		}
 	}
 
-	fn bounding_box(&self, transform: DAffine2) -> Option<[DVec2; 2]> {
+	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), Some(artboard_bounds)].into_iter().flatten().reduce(Quad::combine_bounds)
+			[self.graphic_group.bounding_box(transform, include_stroke), Some(artboard_bounds)]
+				.into_iter()
+				.flatten()
+				.reduce(Quad::combine_bounds)
 		}
 	}
 
@@ -808,8 +819,10 @@ impl GraphicElementRendered for ArtboardGroupTable {
 		}
 	}
 
-	fn bounding_box(&self, transform: DAffine2) -> Option<[DVec2; 2]> {
-		self.instance_ref_iter().filter_map(|instance| instance.instance.bounding_box(transform)).reduce(Quad::combine_bounds)
+	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)
 	}
 
 	fn collect_metadata(&self, metadata: &mut RenderMetadata, footprint: Footprint, _element_id: Option<NodeId>) {
@@ -882,7 +895,7 @@ impl GraphicElementRendered for ImageFrameTable<Color> {
 		}
 	}
 
-	fn bounding_box(&self, transform: DAffine2) -> Option<[DVec2; 2]> {
+	fn bounding_box(&self, transform: DAffine2, _include_stroke: bool) -> Option<[DVec2; 2]> {
 		self.instance_ref_iter()
 			.flat_map(|instance| {
 				let transform = transform * *instance.transform;
@@ -924,7 +937,7 @@ impl GraphicElementRendered for RasterFrame {
 			let image_transform = transform * self.transform() * DAffine2::from_scale(1. / DVec2::new(image.width as f64, image.height as f64));
 			let layer = blend_mode != Default::default();
 
-			let Some(bounds) = self.bounding_box(transform) else { return };
+			let Some(bounds) = self.bounding_box(transform, true) else { return };
 			let blending = vello::peniko::BlendMode::new(blend_mode.blend_mode.into(), vello::peniko::Compose::SrcOver);
 
 			if layer {
@@ -964,7 +977,7 @@ impl GraphicElementRendered for RasterFrame {
 		}
 	}
 
-	fn bounding_box(&self, transform: DAffine2) -> Option<[DVec2; 2]> {
+	fn bounding_box(&self, transform: DAffine2, _include_stroke: bool) -> Option<[DVec2; 2]> {
 		let transform = transform * self.transform();
 		(transform.matrix2.determinant() != 0.).then(|| (transform * Quad::from_box([DVec2::ZERO, DVec2::ONE])).bounding_box())
 	}
@@ -1002,11 +1015,11 @@ impl GraphicElementRendered for GraphicElement {
 		}
 	}
 
-	fn bounding_box(&self, transform: DAffine2) -> Option<[DVec2; 2]> {
+	fn bounding_box(&self, transform: DAffine2, include_stroke: bool) -> Option<[DVec2; 2]> {
 		match self {
-			GraphicElement::VectorData(vector_data) => vector_data.bounding_box(transform),
-			GraphicElement::RasterFrame(raster) => raster.bounding_box(transform),
-			GraphicElement::GraphicGroup(graphic_group) => graphic_group.bounding_box(transform),
+			GraphicElement::VectorData(vector_data) => vector_data.bounding_box(transform, include_stroke),
+			GraphicElement::RasterFrame(raster) => raster.bounding_box(transform, include_stroke),
+			GraphicElement::GraphicGroup(graphic_group) => graphic_group.bounding_box(transform, include_stroke),
 		}
 	}
 
@@ -1078,7 +1091,7 @@ impl<P: Primitive> GraphicElementRendered for P {
 		render.parent_tag("text", text_attributes, |render| render.leaf_node(format!("{self}")));
 	}
 
-	fn bounding_box(&self, _transform: DAffine2) -> Option<[DVec2; 2]> {
+	fn bounding_box(&self, _transform: DAffine2, _include_stroke: bool) -> Option<[DVec2; 2]> {
 		None
 	}
 
@@ -1106,7 +1119,7 @@ impl GraphicElementRendered for Option<Color> {
 		render.parent_tag("text", text_attributes, |render| render.leaf_node(color_info))
 	}
 
-	fn bounding_box(&self, _transform: DAffine2) -> Option<[DVec2; 2]> {
+	fn bounding_box(&self, _transform: DAffine2, _include_stroke: bool) -> Option<[DVec2; 2]> {
 		None
 	}
 
@@ -1130,7 +1143,7 @@ impl GraphicElementRendered for Vec<Color> {
 		}
 	}
 
-	fn bounding_box(&self, _transform: DAffine2) -> Option<[DVec2; 2]> {
+	fn bounding_box(&self, _transform: DAffine2, _include_stroke: bool) -> Option<[DVec2; 2]> {
 		None
 	}
 

node-graph/gcore/src/raster/bbox.rs

@@ -54,6 +54,12 @@ impl AxisAlignedBbox {
 	}
 }
 
+impl From<(DVec2, DVec2)> for AxisAlignedBbox {
+	fn from((start, end): (DVec2, DVec2)) -> Self {
+		Self { start, end }
+	}
+}
+
 #[cfg_attr(not(target_arch = "spirv"), derive(Debug))]
 #[derive(Clone)]
 pub struct Bbox {

node-graph/gcore/src/transform.rs

@@ -242,3 +242,104 @@ async fn freeze_real_time<T: 'n + 'static>(
 
 	transform_target.eval(ctx.into_context()).await
 }
+
+#[derive(Clone, Copy, Debug, Default, Hash, Eq, PartialEq, dyn_any::DynAny, serde::Serialize, serde::Deserialize, specta::Type)]
+pub enum ReferencePoint {
+	#[default]
+	None,
+	TopLeft,
+	TopCenter,
+	TopRight,
+	CenterLeft,
+	Center,
+	CenterRight,
+	BottomLeft,
+	BottomCenter,
+	BottomRight,
+}
+
+impl ReferencePoint {
+	pub fn point_in_bounding_box(&self, bounding_box: AxisAlignedBbox) -> Option<DVec2> {
+		let size = bounding_box.size();
+		let offset = match self {
+			ReferencePoint::None => return None,
+			ReferencePoint::TopLeft => DVec2::ZERO,
+			ReferencePoint::TopCenter => DVec2::new(size.x / 2., 0.),
+			ReferencePoint::TopRight => DVec2::new(size.x, 0.),
+			ReferencePoint::CenterLeft => DVec2::new(0., size.y / 2.),
+			ReferencePoint::Center => DVec2::new(size.x / 2., size.y / 2.),
+			ReferencePoint::CenterRight => DVec2::new(size.x, size.y / 2.),
+			ReferencePoint::BottomLeft => DVec2::new(0., size.y),
+			ReferencePoint::BottomCenter => DVec2::new(size.x / 2., size.y),
+			ReferencePoint::BottomRight => DVec2::new(size.x, size.y),
+		};
+		Some(bounding_box.start + offset)
+	}
+}
+
+impl From<&str> for ReferencePoint {
+	fn from(input: &str) -> Self {
+		match input {
+			"None" => ReferencePoint::None,
+			"TopLeft" => ReferencePoint::TopLeft,
+			"TopCenter" => ReferencePoint::TopCenter,
+			"TopRight" => ReferencePoint::TopRight,
+			"CenterLeft" => ReferencePoint::CenterLeft,
+			"Center" => ReferencePoint::Center,
+			"CenterRight" => ReferencePoint::CenterRight,
+			"BottomLeft" => ReferencePoint::BottomLeft,
+			"BottomCenter" => ReferencePoint::BottomCenter,
+			"BottomRight" => ReferencePoint::BottomRight,
+			_ => panic!("Failed parsing unrecognized ReferencePosition enum value '{input}'"),
+		}
+	}
+}
+
+impl From<ReferencePoint> for Option<DVec2> {
+	fn from(input: ReferencePoint) -> Self {
+		match input {
+			ReferencePoint::None => None,
+			ReferencePoint::TopLeft => Some(DVec2::new(0., 0.)),
+			ReferencePoint::TopCenter => Some(DVec2::new(0.5, 0.)),
+			ReferencePoint::TopRight => Some(DVec2::new(1., 0.)),
+			ReferencePoint::CenterLeft => Some(DVec2::new(0., 0.5)),
+			ReferencePoint::Center => Some(DVec2::new(0.5, 0.5)),
+			ReferencePoint::CenterRight => Some(DVec2::new(1., 0.5)),
+			ReferencePoint::BottomLeft => Some(DVec2::new(0., 1.)),
+			ReferencePoint::BottomCenter => Some(DVec2::new(0.5, 1.)),
+			ReferencePoint::BottomRight => Some(DVec2::new(1., 1.)),
+		}
+	}
+}
+
+impl From<DVec2> for ReferencePoint {
+	fn from(input: DVec2) -> Self {
+		const TOLERANCE: f64 = 1e-5_f64;
+		if input.y.abs() < TOLERANCE {
+			if input.x.abs() < TOLERANCE {
+				return ReferencePoint::TopLeft;
+			} else if (input.x - 0.5).abs() < TOLERANCE {
+				return ReferencePoint::TopCenter;
+			} else if (input.x - 1.).abs() < TOLERANCE {
+				return ReferencePoint::TopRight;
+			}
+		} else if (input.y - 0.5).abs() < TOLERANCE {
+			if input.x.abs() < TOLERANCE {
+				return ReferencePoint::CenterLeft;
+			} else if (input.x - 0.5).abs() < TOLERANCE {
+				return ReferencePoint::Center;
+			} else if (input.x - 1.).abs() < TOLERANCE {
+				return ReferencePoint::CenterRight;
+			}
+		} else if (input.y - 1.).abs() < TOLERANCE {
+			if input.x.abs() < TOLERANCE {
+				return ReferencePoint::BottomLeft;
+			} else if (input.x - 0.5).abs() < TOLERANCE {
+				return ReferencePoint::BottomCenter;
+			} else if (input.x - 1.).abs() < TOLERANCE {
+				return ReferencePoint::BottomRight;
+			}
+		}
+		ReferencePoint::None
+	}
+}

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

@@ -6,7 +6,7 @@ use crate::instances::{Instance, InstanceMut, Instances};
 use crate::raster::image::ImageFrameTable;
 use crate::registry::types::{Angle, Fraction, IntegerCount, Length, Multiplier, Percentage, PixelLength, SeedValue};
 use crate::renderer::GraphicElementRendered;
-use crate::transform::{Footprint, Transform, TransformMut};
+use crate::transform::{Footprint, ReferencePoint, Transform, TransformMut};
 use crate::vector::PointDomain;
 use crate::vector::style::{LineCap, LineJoin};
 use crate::{CloneVarArgs, Color, Context, Ctx, ExtractAll, GraphicElement, GraphicGroupTable, OwnedContextImpl};
@@ -217,7 +217,9 @@ where
 
 	let mut result_table = GraphicGroupTable::default();
 
-	let Some(bounding_box) = instance.bounding_box(DAffine2::IDENTITY) else { return result_table };
+	let Some(bounding_box) = instance.bounding_box(DAffine2::IDENTITY, false) else {
+		return result_table;
+	};
 
 	let center = (bounding_box[0] + bounding_box[1]) / 2.;
 
@@ -253,7 +255,9 @@ where
 
 	let mut result_table = GraphicGroupTable::default();
 
-	let Some(bounding_box) = instance.bounding_box(DAffine2::IDENTITY) else { return result_table };
+	let Some(bounding_box) = instance.bounding_box(DAffine2::IDENTITY, false) else {
+		return result_table;
+	};
 
 	let center = (bounding_box[0] + bounding_box[1]) / 2.;
 	let base_transform = DVec2::new(0., radius) - center;
@@ -310,7 +314,7 @@ where
 
 	let random_scale_difference = random_scale_max - random_scale_min;
 
-	let instance_bounding_box = instance.bounding_box(DAffine2::IDENTITY).unwrap_or_default();
+	let instance_bounding_box = instance.bounding_box(DAffine2::IDENTITY, false).unwrap_or_default();
 	let instance_center = -0.5 * (instance_bounding_box[0] + instance_bounding_box[1]);
 
 	let mut scale_rng = rand::rngs::StdRng::seed_from_u64(random_scale_seed.into());
@@ -364,7 +368,8 @@ where
 async fn mirror<I: 'n + Send>(
 	_: impl Ctx,
 	#[implementations(GraphicGroupTable, VectorDataTable, ImageFrameTable<Color>)] instance: Instances<I>,
-	#[default(0., 0.)] center: DVec2,
+	#[default(ReferencePoint::Center)] reference_point: ReferencePoint,
+	offset: f64,
 	#[range((-90., 90.))] angle: Angle,
 	#[default(true)] keep_original: bool,
 ) -> GraphicGroupTable
@@ -373,13 +378,18 @@ where
 {
 	let mut result_table = GraphicGroupTable::default();
 
-	// The mirror center is based on the bounding box for now
-	let Some(bounding_box) = instance.bounding_box(DAffine2::IDENTITY) else { return result_table };
-	let mirror_center = (bounding_box[0] + bounding_box[1]) / 2. + center;
-
 	// Normalize the direction vector
 	let normal = DVec2::from_angle(angle.to_radians());
 
+	// The mirror reference is based on the bounding box (at least for now, until we have proper local layer origins)
+	let Some(bounding_box) = instance.bounding_box(DAffine2::IDENTITY, false) else {
+		return result_table;
+	};
+	let mirror_reference_point = reference_point
+		.point_in_bounding_box((bounding_box[0], bounding_box[1]).into())
+		.unwrap_or_else(|| (bounding_box[0] + bounding_box[1]) / 2.)
+		+ normal * offset;
+
 	// Create the reflection matrix
 	let reflection = DAffine2::from_mat2_translation(
 		glam::DMat2::from_cols(
@@ -389,8 +399,8 @@ where
 		DVec2::ZERO,
 	);
 
-	// Apply reflection around the center point
-	let transform = DAffine2::from_translation(mirror_center) * reflection * DAffine2::from_translation(-mirror_center);
+	// Apply reflection around the reference point
+	let transform = DAffine2::from_translation(mirror_reference_point) * reflection * DAffine2::from_translation(-mirror_reference_point);
 
 	// Add original instance depending on the keep_original flag
 	if keep_original {

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

@@ -7,6 +7,7 @@ pub use glam::{DAffine2, DVec2, IVec2, UVec2};
 use graphene_core::raster::brush_cache::BrushCache;
 use graphene_core::raster::{BlendMode, LuminanceCalculation};
 use graphene_core::renderer::RenderMetadata;
+use graphene_core::transform::ReferencePoint;
 use graphene_core::uuid::NodeId;
 use graphene_core::vector::style::Fill;
 use graphene_core::{Color, MemoHash, Node, Type};
@@ -233,6 +234,7 @@ tagged_value! {
 	DocumentNode(DocumentNode),
 	Curve(graphene_core::raster::curve::Curve),
 	Footprint(graphene_core::transform::Footprint),
+	ReferencePoint(graphene_core::transform::ReferencePoint),
 	Palette(Vec<Color>),
 	VectorModification(Box<graphene_core::vector::VectorModification>),
 	CentroidType(graphene_core::vector::misc::CentroidType),
@@ -302,6 +304,32 @@ impl TaggedValue {
 			None
 		}
 
+		fn to_reference_point(input: &str) -> Option<ReferencePoint> {
+			let mut choices = input.split("::");
+			let (first, second) = (choices.next()?.trim(), choices.next()?.trim());
+			if first == "ReferencePoint" {
+				return Some(match second {
+					"None" => ReferencePoint::None,
+					"TopLeft" => ReferencePoint::TopLeft,
+					"TopCenter" => ReferencePoint::TopCenter,
+					"TopRight" => ReferencePoint::TopRight,
+					"CenterLeft" => ReferencePoint::CenterLeft,
+					"Center" => ReferencePoint::Center,
+					"CenterRight" => ReferencePoint::CenterRight,
+					"BottomLeft" => ReferencePoint::BottomLeft,
+					"BottomCenter" => ReferencePoint::BottomCenter,
+					"BottomRight" => ReferencePoint::BottomRight,
+					_ => {
+						log::error!("Invalid ReferencePoint default type variant: {}", input);
+						return None;
+					}
+				});
+			}
+
+			log::error!("Invalid ReferencePoint default type: {}", input);
+			None
+		}
+
 		match ty {
 			Type::Generic(_) => None,
 			Type::Concrete(concrete_type) => {
@@ -320,6 +348,7 @@ impl TaggedValue {
 					x if x == TypeId::of::<Color>() => to_color(string).map(TaggedValue::Color)?,
 					x if x == TypeId::of::<Option<Color>>() => to_color(string).map(|color| TaggedValue::OptionalColor(Some(color)))?,
 					x if x == TypeId::of::<Fill>() => to_color(string).map(|color| TaggedValue::Fill(Fill::solid(color)))?,
+					x if x == TypeId::of::<ReferencePoint>() => to_reference_point(string).map(TaggedValue::ReferencePoint)?,
 					_ => return None,
 				};
 				Some(ty)

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

@@ -58,6 +58,7 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => ()]),
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => Vec<f64>]),
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => BlendMode]),
+		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => graphene_std::transform::ReferencePoint]),
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => graphene_core::vector::misc::BooleanOperation]),
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => Option<graphene_core::Color>]),
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => graphene_core::vector::style::Fill]),