feat: improve lerp utils for shadow/borders/vector

Author: Ericky Dos Santos

core/src/border.rs

@@ -112,6 +112,30 @@ impl Border {
     pub fn widths(&self) -> [f32; 4] {
         self.sides.unwrap_or([self.width; 4])
     }
+
+    /// Linearly interpolates between two [`Border`]s by the given amount.
+    ///
+    /// A uniform border and a per-side one blend through their resolved
+    /// [`widths`](Self::widths), so the result is per-side for as long as either
+    /// end is — stepping straight to `other`'s sides instead would pop the border
+    /// on and off mid-transition. Two uniform borders stay uniform.
+    pub fn lerp(self, other: Self, amount: f32) -> Self {
+        let lerp = |from: f32, to: f32| from + (to - from) * amount;
+
+        let sides = if self.sides.is_none() && other.sides.is_none() {
+            None
+        } else {
+            let (from, to) = (self.widths(), other.widths());
+            Some(std::array::from_fn(|i| lerp(from[i], to[i])))
+        };
+
+        Self {
+            color: self.color.lerp(other.color, amount),
+            width: lerp(self.width, other.width),
+            radius: self.radius.lerp(other.radius, amount),
+            sides,
+        }
+    }
 }
 
 /// The border radii for the corners of a graphics primitive in the order:
@@ -261,6 +285,22 @@ impl Radius {
             ..self
         }
     }
+
+    /// Linearly interpolates between `self` and `other` by the given amount,
+    /// corner by corner.
+    ///
+    /// At `amount = 0.0` returns `self`, at `amount = 1.0` returns `other`.
+    pub const fn lerp(self, other: Self, amount: f32) -> Self {
+        Self {
+            top_left: self.top_left + (other.top_left - self.top_left) * amount,
+            top_right: self.top_right
+                + (other.top_right - self.top_right) * amount,
+            bottom_right: self.bottom_right
+                + (other.bottom_right - self.bottom_right) * amount,
+            bottom_left: self.bottom_left
+                + (other.bottom_left - self.bottom_left) * amount,
+        }
+    }
 }
 
 impl From<f32> for Radius {

core/src/shadow.rs

@@ -58,4 +58,109 @@ impl Shadow {
         self.inset = inset;
         self
     }
+
+    /// Returns the [`Shadow`] with a fully transparent color.
+    ///
+    /// The geometry is kept, so this is the "absent" end of a fade — a shadow
+    /// appearing or disappearing rather than one moving.
+    pub const fn transparent(self) -> Self {
+        Self {
+            color: Color {
+                a: 0.0,
+                ..self.color
+            },
+            ..self
+        }
+    }
+
+    /// Linearly interpolates between two [`Shadow`]s by the given amount.
+    ///
+    /// `inset` has no representable in-between — an inset shadow and an outset one
+    /// are drawn by different branches entirely — so it steps to `other`'s.
+    pub const fn lerp(self, other: Self, amount: f32) -> Self {
+        Self {
+            color: self.color.lerp(other.color, amount),
+            offset: self.offset.lerp(other.offset, amount),
+            blur_radius: self.blur_radius
+                + (other.blur_radius - self.blur_radius) * amount,
+            spread_radius: self.spread_radius
+                + (other.spread_radius - self.spread_radius) * amount,
+            inset: other.inset,
+        }
+    }
+
+    /// Linearly interpolates between two stacks of [`Shadow`]s by the given
+    /// amount, pairing them up layer by layer.
+    ///
+    /// Elevation scales stack several layers, and the two ends of a transition
+    /// need not use the same number of them. A layer present at only one end keeps
+    /// that end's geometry and fades its alpha from (or to) zero, so a stack can
+    /// grow and shrink across a transition.
+    ///
+    /// The result always holds one layer per index rather than both stacks
+    /// concatenated: overlapping translucent layers composite, so drawing both
+    /// would darken the shadow mid-transition even when the endpoints match.
+    pub fn lerp_stacks(from: &[Self], to: &[Self], amount: f32) -> Vec<Self> {
+        (0..from.len().max(to.len()))
+            .filter_map(|i| match (from.get(i), to.get(i)) {
+                (Some(from), Some(to)) => Some(from.lerp(*to, amount)),
+                (Some(from), None) => {
+                    Some(from.lerp(from.transparent(), amount))
+                }
+                (None, Some(to)) => Some(to.transparent().lerp(*to, amount)),
+                // Unreachable: `i` is below the longer stack's length.
+                (None, None) => None,
+            })
+            .collect()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn shadow(alpha: f32, blur: f32) -> Shadow {
+        Shadow {
+            color: Color::from_rgba(0.0, 0.0, 0.0, alpha),
+            offset: Vector::new(0.0, 2.0),
+            blur_radius: blur,
+            spread_radius: -1.0,
+            inset: false,
+        }
+    }
+
+    #[test]
+    fn lerp_stacks_pairs_layers_instead_of_concatenating() {
+        // Two overlapping translucent layers composite to more than either one,
+        // so a stack transition that drew both ends would visibly darken halfway
+        // through even when the endpoints are identical.
+        let from = vec![shadow(0.1, 6.0), shadow(0.1, 15.0)];
+        let to = vec![shadow(0.2, 6.0), shadow(0.2, 15.0)];
+
+        assert_eq!(Shadow::lerp_stacks(&from, &to, 0.5).len(), 2);
+        assert_eq!(Shadow::lerp_stacks(&from, &to, 0.0), from);
+        assert_eq!(Shadow::lerp_stacks(&from, &to, 1.0), to);
+    }
+
+    #[test]
+    fn lerp_stacks_fades_unpaired_layers_from_transparent() {
+        // A stack that grows mid-transition (an extra ring layer appearing, say)
+        // must fade the new layer in by alpha while it already holds its final
+        // geometry — interpolating its geometry from a neighbour would slide it
+        // into place from the wrong shape.
+        let from = vec![shadow(0.1, 6.0)];
+        let to = vec![shadow(0.1, 6.0), shadow(0.4, 20.0)];
+
+        let mid = Shadow::lerp_stacks(&from, &to, 0.5);
+        assert_eq!(mid.len(), 2);
+        assert!((mid[1].color.a - 0.2).abs() < 1e-6, "alpha fades in");
+        assert!(
+            (mid[1].blur_radius - 20.0).abs() < 1e-6,
+            "geometry is already final"
+        );
+
+        // Endpoints stay exact in both directions.
+        assert_eq!(Shadow::lerp_stacks(&from, &to, 1.0), to);
+        assert_eq!(Shadow::lerp_stacks(&to, &from, 1.0)[1], to[1].transparent());
+    }
 }

core/src/vector.rs

@@ -27,6 +27,16 @@ impl Vector {
             y: self.y.round(),
         }
     }
+
+    /// Linearly interpolates between `self` and `other` by the given amount.
+    ///
+    /// At `amount = 0.0` returns `self`, at `amount = 1.0` returns `other`.
+    pub const fn lerp(self, other: Self, amount: f32) -> Self {
+        Self {
+            x: self.x + (other.x - self.x) * amount,
+            y: self.y + (other.y - self.y) * amount,
+        }
+    }
 }
 
 impl<T> std::ops::Neg for Vector<T>