chore

Author: mohan-bee

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

@@ -36,6 +36,30 @@ pub trait Transform {
 		// Non-orthogonal columns or different lengths indicate skew/non-uniform scaling
 		col0.dot(col1).abs() > EPSILON || (col0.length() - col1.length()).abs() > EPSILON
 	}
+
+	/// Decomposes the transform into its rotation (angle), scale, and skew components.
+	fn decompose_rotation_scale_skew(&self) -> (f64, DVec2, DVec2) {
+		let transform = self.transform();
+		let x_axis = transform.matrix2.x_axis;
+		let y_axis = transform.matrix2.y_axis;
+
+		// Assuming there is no vertical shear
+		let angle = x_axis.y.atan2(x_axis.x);
+		let (sin, cos) = angle.sin_cos();
+		let scale_x = if cos.abs() > 1e-10 { x_axis.x / cos } else { x_axis.y / sin };
+
+		let mut shear_x = (sin * y_axis.y + cos * y_axis.x) / (sin * sin * scale_x + cos * cos * scale_x);
+		if !shear_x.is_finite() {
+			shear_x = 0.;
+		}
+		let scale_y = if cos.abs() > 1e-10 {
+			(y_axis.y - scale_x * sin * shear_x) / cos
+		} else {
+			(scale_x * cos * shear_x - y_axis.x) / sin
+		};
+
+		(angle, DVec2::new(scale_x, scale_y), DVec2::new(shear_x, 0.))
+	}
 }
 
 pub trait TransformMut: Transform {

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

@@ -6,8 +6,10 @@ use core_types::bounds::{BoundingBox, RenderBoundingBox};
 use core_types::color::Alpha;
 use core_types::render_complexity::RenderComplexity;
 use core_types::table::Table;
+use core_types::transform::Transform;
 use dyn_any::DynAny;
 use glam::DAffine2;
+use std::f64::consts::{PI, TAU};
 
 /// Describes the fill of a layer.
 ///
@@ -85,8 +87,8 @@ impl Fill {
 
 	pub fn lerp(&self, other: &Self, time: f64) -> Self {
 		let transparent = Self::solid(Color::TRANSPARENT);
-		let a = if *self == Self::None { &transparent } else { self };
-		let b = if *other == Self::None { &transparent } else { other };
+		let a = if *self == Self::None && *other != Self::None { &transparent } else { self };
+		let b = if *other == Self::None && *self != Self::None { &transparent } else { other };
 
 		match (a, b) {
 			(Self::Solid(a), Self::Solid(b)) => Self::Solid(a.lerp(b, time as f32)),
@@ -103,7 +105,7 @@ impl Fill {
 				Self::Gradient(a.lerp(b, time))
 			}
 			(Self::Gradient(a), Self::Gradient(b)) => Self::Gradient(a.lerp(b, time)),
-			_ => Self::None,
+			(Self::None, _) | (_, Self::None) => Self::None,
 		}
 	}
 
@@ -461,10 +463,32 @@ impl Stroke {
 			join: if time < 0.5 { self.join } else { other.join },
 			join_miter_limit: self.join_miter_limit + (other.join_miter_limit - self.join_miter_limit) * time,
 			align: if time < 0.5 { self.align } else { other.align },
-			transform: DAffine2::from_mat2_translation(
-				time * self.transform.matrix2 + (1. - time) * other.transform.matrix2,
-				self.transform.translation * time + other.transform.translation * (1. - time),
-			),
+transform: {
+				// Decompose into scale/rotation/skew and interpolate each component separately.
+				// We do this instead of linear matrix interpolation because that passes through a zero matrix
+				// (and thus a division by 0 when rendering) when transforms have opposing rotations (e.g. 0° vs 180°).
+
+				let (s_angle, s_scale, s_skew) = self.transform.decompose_rotation_scale_skew();
+				let (t_angle, t_scale, t_skew) = other.transform.decompose_rotation_scale_skew();
+
+				let lerped_translation = self.transform.translation.lerp(other.transform.translation, time);
+
+				// Shortest-arc rotation interpolation
+				let mut rotation_diff = t_angle - s_angle;
+				if rotation_diff > PI {
+					rotation_diff -= TAU;
+				} else if rotation_diff < -PI {
+					rotation_diff += TAU;
+				}
+				let lerped_angle = s_angle + rotation_diff * time;
+
+				let lerped_scale = s_scale.lerp(t_scale, time);
+				let lerped_skew = s_skew.lerp(t_skew, time);
+
+				let trs = DAffine2::from_scale_angle_translation(lerped_scale, lerped_angle, lerped_translation);
+				let skew = DAffine2::from_cols_array(&[1., lerped_skew.y, lerped_skew.x, 1., 0., 0.]);
+				trs * skew
+			},
 			non_scaling: if time < 0.5 { self.non_scaling } else { other.non_scaling },
 			paint_order: if time < 0.5 { self.paint_order } else { other.paint_order },
 		}
@@ -775,8 +799,8 @@ pub enum RenderMode {
 	Normal = 0,
 	/// Render only the outlines of shapes at the current viewport resolution
 	Outline,
-	// /// Render with normal coloration at the document resolution, showing the pixels when the current viewport resolution is higher
-	// PixelPreview,
+	/// Render with normal coloration at the document export resolution; at zoom > 100% this shows individual export pixels upscaled with nearest-neighbor filtering
+	PixelPreview,
 	/// Render a preview of how the object would be exported as an SVG.
 	SvgPreview,
 }