cranpose-animation 0.1.83

Animation system for Cranpose
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

//! Color animation for Cranpose
//!
//! Mirrors Jetpack Compose's `animateColorAsState` from
//! `androidx.compose.animation.SingleValueAnimation` by layering a [`Lerp`]
//! implementation for [`Color`] over the generic [`Animatable`] machinery.
//!
//! Note: This module uses camelCase for function names to maintain 1:1 API
//! parity with Jetpack Compose.

#![allow(non_snake_case)]

use crate::animation::{Animatable, AnimationType, Lerp, SpringScalar};
use cranpose_core::{with_current_composer, Owned, State};
use cranpose_ui_graphics::Color;

impl Lerp for Color {
    /// Linearly interpolate each RGBA channel, including alpha.
    ///
    /// Jetpack Compose's default `Color` lerp converts through the Oklab
    /// color space before interpolating. Cranpose colors carry no color-space
    /// information, so this implementation interpolates each channel linearly
    /// in the color's own (linear RGBA) space instead. For typical UI fades
    /// between colors in the same space this closely matches Compose's
    /// behavior; the results are clamped to `[0.0, 1.0]` per channel so
    /// overshooting springs still produce valid colors, matching Compose's
    /// gamut coercion.
    fn lerp(&self, target: &Self, fraction: f32) -> Self {
        Color(
            self.0.lerp(&target.0, fraction).clamp(0.0, 1.0),
            self.1.lerp(&target.1, fraction).clamp(0.0, 1.0),
            self.2.lerp(&target.2, fraction).clamp(0.0, 1.0),
            self.3.lerp(&target.3, fraction).clamp(0.0, 1.0),
        )
    }
}

/// Colors spring as four independent channels, mirroring how Compose animates
/// `Color` as an `AnimationVector4D`. Channels are clamped back into `[0, 1]`
/// when the vector is rebuilt, so overshooting springs still produce valid
/// colors (Compose's gamut coercion).
impl SpringScalar for Color {
    const DIMENSIONS: usize = 4;

    fn dimension(&self, index: usize) -> f32 {
        match index {
            0 => self.0,
            1 => self.1,
            2 => self.2,
            _ => self.3,
        }
    }

    fn from_dimensions(dimensions: [f32; crate::animation::SPRING_MAX_DIMENSIONS]) -> Self {
        Color(
            dimensions[0].clamp(0.0, 1.0),
            dimensions[1].clamp(0.0, 1.0),
            dimensions[2].clamp(0.0, 1.0),
            dimensions[3].clamp(0.0, 1.0),
        )
    }
}

/// Fire-and-forget color animation. Returns a [`State`] whose value is
/// updated by animations towards the provided `target` whenever `target`
/// changes.
///
/// Mirrors Jetpack Compose:
/// `animateColorAsState(targetValue, animationSpec, label)`.
///
/// The interpolation happens linearly per RGBA channel, including alpha (see
/// [`Lerp`] for [`Color`] for how this relates to Compose's Oklab lerp).
pub fn animateColorAsState(target: Color, animation: AnimationType, label: &str) -> State<Color> {
    let _ = label;
    with_current_composer(|composer| {
        let runtime = composer.runtime_handle();
        let anim: Owned<Animatable<Color>> = composer.remember(|| Animatable::new(target, runtime));
        anim.update(|animatable| {
            let is_new_target = animatable.target() != target;
            let is_new_animation = animatable.animation_type() != animation;
            if is_new_target || is_new_animation {
                animatable.animateTo(target, animation);
            }
        });
        anim.with(|animatable| animatable.state())
    })
}

#[cfg(test)]
#[path = "tests/color_tests.rs"]
mod tests;