use std::{
collections::{HashMap, HashSet},
sync::Arc,
time::Duration,
};
use super::{
animation::step_time,
easing::Easing,
interpolate::{
AnimatableProperty, AnimatableValue, TargetTheme, clear_overrides, property_accessors, read_target, write_property,
},
};
use crate::{app::theme::Theme, core::NodeId, time::Instant};
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum TransitionProperty {
All,
Single(AnimatableProperty),
}
#[derive(Clone, Debug)]
pub struct Transition {
pub property: TransitionProperty,
pub duration: Duration,
pub delay: Duration,
pub easing: Easing,
}
impl Transition {
fn single(prop: AnimatableProperty) -> Self {
Self {
property: TransitionProperty::Single(prop),
duration: Duration::from_millis(300),
delay: Duration::ZERO,
easing: Easing::EASE,
}
}
pub fn all() -> Self {
Self {
property: TransitionProperty::All,
duration: Duration::from_millis(300),
delay: Duration::ZERO,
easing: Easing::EASE,
}
}
pub fn duration(mut self, d: Duration) -> Self {
self.duration = d;
self
}
pub fn duration_ms(mut self, ms: u64) -> Self {
self.duration = Duration::from_millis(ms);
self
}
pub fn delay(mut self, d: Duration) -> Self {
self.delay = d;
self
}
pub fn delay_ms(mut self, ms: u64) -> Self {
self.delay = Duration::from_millis(ms);
self
}
pub fn easing(mut self, e: Easing) -> Self {
self.easing = e;
self
}
pub fn linear(mut self) -> Self {
self.easing = Easing::Linear;
self
}
}
property_accessors!(Transition {
BackgroundColor => background_color,
BorderColor => border_color,
BorderWidthTop => border_width_top,
BorderWidthRight => border_width_right,
BorderWidthBottom => border_width_bottom,
BorderWidthLeft => border_width_left,
BorderRadiusTopLeft => border_radius_top_left,
BorderRadiusTopRight => border_radius_top_right,
BorderRadiusBottomRight => border_radius_bottom_right,
BorderRadiusBottomLeft => border_radius_bottom_left,
OffsetX => offset_x,
OffsetY => offset_y,
Width => width,
Height => height,
Opacity => opacity,
Blur => blur,
BackdropBlur => backdrop_blur,
Transform => transform,
Foreground => foreground,
Outline => outline,
BoxShadow => box_shadow,
BorderDash => border_dash,
});
const ALL_PROPERTIES: &[AnimatableProperty] = &[
AnimatableProperty::BackgroundColor,
AnimatableProperty::BorderColor,
AnimatableProperty::BorderWidthTop,
AnimatableProperty::BorderWidthRight,
AnimatableProperty::BorderWidthBottom,
AnimatableProperty::BorderWidthLeft,
AnimatableProperty::BorderRadiusTopLeft,
AnimatableProperty::BorderRadiusTopRight,
AnimatableProperty::BorderRadiusBottomRight,
AnimatableProperty::BorderRadiusBottomLeft,
AnimatableProperty::OffsetX,
AnimatableProperty::OffsetY,
AnimatableProperty::Width,
AnimatableProperty::Height,
AnimatableProperty::Opacity,
AnimatableProperty::Blur,
AnimatableProperty::BackdropBlur,
AnimatableProperty::Transform,
AnimatableProperty::Foreground,
AnimatableProperty::Outline,
AnimatableProperty::BoxShadow,
AnimatableProperty::BorderDash,
];
fn moves(prop: AnimatableProperty) -> bool {
matches!(
prop,
AnimatableProperty::OffsetX
| AnimatableProperty::OffsetY
| AnimatableProperty::Width
| AnimatableProperty::Height
| AnimatableProperty::Transform
| AnimatableProperty::BorderDash
)
}
struct TransitionRun {
from: AnimatableValue,
to: AnimatableValue,
start_time: Instant,
duration: Duration,
delay: Duration,
easing: Easing,
}
impl TransitionRun {
fn progress(&self, elapsed: Duration) -> f64 {
if self.duration.is_zero() {
return 1.0;
}
elapsed.as_secs_f64() / self.duration.as_secs_f64()
}
fn next_change(&self, now: Instant, raw: f64) -> Option<Instant> {
match self.easing.distance_to_next_step(raw, true) {
Some(until) => step_time(now, self.duration, until),
None => Some(now),
}
}
}
pub struct TransitionEngine {
active: HashMap<(NodeId, AnimatableProperty), TransitionRun>,
prev_values: HashMap<(NodeId, AnimatableProperty), AnimatableValue>,
node_themes: HashMap<NodeId, usize>,
theme_identity: usize,
seen: HashSet<NodeId>,
next_change: Option<Instant>,
pub has_active: bool,
theme: TargetTheme,
theme_seen: Option<(Theme, u64)>,
theme_changed: bool,
scopes: Vec<(Theme, TargetTheme)>,
reduced_motion: bool,
epoch: u64,
child_results: Vec<Option<Option<Arc<crate::node::layout_cache::TickedIds>>>>,
}
fn next_epoch() -> u64 {
static EPOCH: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);
EPOCH.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
}
impl Default for TransitionEngine {
fn default() -> Self {
Self::new()
}
}
impl TransitionEngine {
pub fn new() -> Self {
Self {
active: HashMap::new(),
prev_values: HashMap::new(),
node_themes: HashMap::new(),
theme_identity: 0,
seen: HashSet::new(),
next_change: None,
has_active: false,
theme: TargetTheme::default(),
theme_seen: None,
theme_changed: false,
scopes: Vec::new(),
reduced_motion: false,
epoch: next_epoch(),
child_results: Vec::new(),
}
}
pub(crate) fn set_theme(&mut self, theme: &Theme) {
self.reduced_motion = theme.reduced_motion();
let version = theme.version();
if self
.theme_seen
.as_ref()
.is_some_and(|(seen, seen_version)| *seen_version == version && seen.same_theme(theme))
{
return;
}
let taken = TargetTheme {
palette: theme.palette().clone(),
border_sizes: theme.border_sizes().clone(),
shadows: theme.shared_shadows(),
};
self.theme_changed = self.theme_seen.is_some()
&& (taken.palette != self.theme.palette
|| taken.border_sizes != self.theme.border_sizes
|| taken.shadows != self.theme.shadows);
self.theme = taken;
self.theme_seen = Some((theme.clone(), version));
}
pub(crate) fn clear_state(&mut self) {
self.epoch = next_epoch();
self.active.clear();
self.prev_values.clear();
self.node_themes.clear();
self.seen.clear();
self.next_change = None;
self.has_active = false;
}
pub(crate) fn begin_frame(&mut self) {
self.seen.clear();
self.next_change = None;
self.theme_changed = false;
}
pub(crate) fn finish_frame(&mut self) {
let seen = &self.seen;
self.active.retain(|(node_id, _), _| seen.contains(node_id));
self.prev_values.retain(|(node_id, _), _| seen.contains(node_id));
self.node_themes.retain(|node_id, _| seen.contains(node_id));
self.has_active = !self.active.is_empty();
}
pub(crate) fn next_change(&self) -> Option<Instant> {
self.next_change
}
pub(crate) fn tick(&mut self, root: &mut crate::node::Node, now: Instant) -> bool {
self.theme_identity = 0;
clear_overrides(root);
self.has_active = false;
let needs_layout = self.tick_root(root, now);
self.has_active = !self.active.is_empty();
needs_layout
}
pub(crate) fn tick_preserving_active_state(&mut self, root: &mut crate::node::Node, now: Instant) -> bool {
self.theme_identity = 0;
clear_overrides(root);
let needs_layout = self.tick_root(root, now);
self.has_active = !self.active.is_empty();
needs_layout
}
fn tick_root(&mut self, root: &mut crate::node::Node, now: Instant) -> bool {
self.tick_subtree(root, now).0
}
fn tick_subtree(
&mut self,
node: &mut crate::node::Node,
now: Instant,
) -> (bool, Option<Option<Arc<crate::node::layout_cache::TickedIds>>>) {
if !node.prepare_layout_tracking().timeline {
return (false, Some(None));
}
let ticked = node.layout_cache.take_ticked();
let unchanged = ticked.as_ref().is_some_and(|ticked| {
!self.theme_changed && ticked.epoch == self.epoch && ticked.is_current(node.layout_cache.watch())
});
if let (true, Some(ticked)) = (unchanged, ticked) {
let ids = ticked.ids.clone();
if let Some(ids) = &ids {
let seen = &mut self.seen;
ids.each(&mut |id| {
seen.insert(id);
});
}
node.layout_cache.set_ticked(Some(ticked));
return (false, Some(ids));
}
let needs_layout = self.tick_recursive(node, now);
let node_id = node.node_id();
let children = std::mem::take(&mut self.child_results);
let clean = !needs_layout
&& node.playing_animation().is_none()
&& node.animation_overrides.is_empty()
&& !self.active.keys().any(|(id, _)| *id == node_id)
&& children.len() == node.children.len()
&& children.iter().all(Option::is_some);
if !clean {
return (needs_layout, None);
}
let own = (node_id.is_assigned() && !node.transitions.is_empty()).then_some(node_id);
let children: Vec<_> = children.into_iter().flatten().flatten().collect();
let ids =
(own.is_some() || !children.is_empty()).then(|| Arc::new(crate::node::layout_cache::TickedIds { own, children }));
node
.layout_cache
.set_ticked(Some(Box::new(crate::node::layout_cache::TickedClean {
generation: node.layout_cache.watch().generation(),
ticks: node.layout_cache.watch().ticks(),
epoch: self.epoch,
world: crate::node::layout_cache::world_changes(),
ids: ids.clone(),
})));
(needs_layout, Some(ids))
}
fn tick_recursive(&mut self, node: &mut crate::node::Node, now: Instant) -> bool {
#[cfg(test)]
crate::core::layout_dirty::visit();
let scope = node.theme_scope.as_deref().cloned().map(|theme| {
let outer = std::mem::replace(&mut self.theme_identity, theme.identity());
(self.enter_scope(&theme), outer)
});
let node_id = node.node_id();
let mut needs_layout = false;
if node_id.is_assigned() && !node.transitions.is_empty() {
self.seen.insert(node_id);
needs_layout = self.process_node(node, now);
}
let mut results = Vec::with_capacity(node.children.len());
for child in &mut node.children {
let (child_layout, clean) = self.tick_subtree(child, now);
needs_layout |= child_layout;
results.push(clean);
}
self.child_results = results;
if needs_layout {
node.layout_cache.invalidate();
}
if let Some(((theme, changed), outer)) = scope {
self.theme = theme;
self.theme_changed = changed;
self.theme_identity = outer;
}
needs_layout
}
fn enter_scope(&mut self, theme: &Theme) -> (TargetTheme, bool) {
let taken = TargetTheme {
palette: theme.palette().clone(),
border_sizes: theme.border_sizes().clone(),
shadows: theme.shared_shadows(),
};
let same = |a: &TargetTheme, b: &TargetTheme| {
a.palette == b.palette && a.border_sizes == b.border_sizes && a.shadows == b.shadows
};
let changed = match self.scopes.iter_mut().find(|(seen, _)| seen.same_theme(theme)) {
Some((_, values)) => {
let changed = !same(values, &taken);
*values = taken.clone();
changed
}
None => {
self.scopes.push((theme.clone(), taken.clone()));
false
}
};
let outer = (std::mem::replace(&mut self.theme, taken), self.theme_changed);
self.theme_changed = changed;
outer
}
fn process_node(&mut self, node: &mut crate::node::Node, now: Instant) -> bool {
let node_id = node.node_id();
let mut layout_affected = false;
let properties: Vec<(AnimatableProperty, Duration, Duration, Easing)> = node
.transitions
.iter()
.flat_map(|spec| {
let props: &[AnimatableProperty] = match spec.property {
TransitionProperty::All => ALL_PROPERTIES,
TransitionProperty::Single(ref p) => std::slice::from_ref(p),
};
props.iter().map(move |p| (*p, spec.duration, spec.delay, spec.easing))
})
.collect();
let moved = self
.node_themes
.insert(node_id, self.theme_identity)
.is_some_and(|before| before != self.theme_identity);
for (prop, duration, delay, easing) in &properties {
let key = (node_id, *prop);
let Some(current) = read_target(node, *prop, &self.theme) else {
if self.prev_values.remove(&key).is_some() {
self.active.remove(&key);
}
continue;
};
if (self.theme_changed || moved) && self.prev_values.get(&key).is_some_and(|prev| *prev != current) {
self.active.remove(&key);
self.prev_values.insert(key, current);
continue;
}
if let Some(prev) = self.prev_values.get(&key)
&& *prev != current
{
let from = if let Some(running) = self.active.get(&key) {
let elapsed = now.duration_since(running.start_time);
if elapsed >= running.delay {
let raw = running.progress(elapsed - running.delay);
let t = running.easing.evaluate(raw.clamp(0.0, 1.0)) as f32;
running.from.lerp(&running.to, t)
} else {
running.from
}
} else {
*prev
};
let (duration, delay) = if self.reduced_motion && moves(*prop) {
(Duration::ZERO, Duration::ZERO)
} else {
(*duration, *delay)
};
self.active.insert(
key,
TransitionRun {
from,
to: current,
start_time: now,
duration,
delay,
easing: *easing,
},
);
}
self.prev_values.insert(key, current);
}
let mut completed = Vec::new();
for (&(nid, prop), run) in &self.active {
if nid != node_id {
continue;
}
let elapsed = now.duration_since(run.start_time);
if elapsed < run.delay {
layout_affected |= write_property(node, prop, &run.from);
let at = run.start_time + run.delay;
self.next_change = Some(self.next_change.map_or(at, |next| next.min(at)));
continue;
}
let raw = run.progress(elapsed - run.delay);
if raw >= 1.0 {
layout_affected |= write_property(node, prop, &run.to);
completed.push((nid, prop));
} else {
let t = run.easing.evaluate(raw) as f32;
let interpolated = run.from.lerp(&run.to, t);
layout_affected |= write_property(node, prop, &interpolated);
if let Some(at) = run.next_change(now, raw) {
self.next_change = Some(self.next_change.map_or(at, |next| next.min(at)));
}
}
}
for key in completed {
self.active.remove(&key);
}
layout_affected
}
}