aura-anim 0.2.2

Convenience facade for aura animation core and Iced integration.
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

//! Integration tests for the aura-anim facade crate.

use aura_anim::prelude::*;
use float_cmp::assert_approx_eq;

#[derive(Clone, Debug, Animatable)]
struct PanelMotion {
    opacity: f32,
    scale: f32,
}

#[derive(Clone, Debug, Animatable)]
struct Offset(f32, f32);

#[derive(Clone, Debug, Animatable)]
struct Marker;

#[test]
fn prelude_exports_core_runtime_and_derive_macro() {
    let mut runtime = MotionRuntime::new();
    let panel = runtime.motion_with(
        PanelMotion {
            opacity: 0.0,
            scale: 0.8,
        },
        Timing::new(100.0),
    );

    assert!(panel.transition_to(
        PanelMotion {
            opacity: 1.0,
            scale: 1.0,
        },
        &mut runtime,
    ));
    runtime.tick(Duration::from_millis(50.0));

    let value = panel.value(&runtime);
    assert_approx_eq!(f32, value.opacity, 0.5, epsilon = 0.000_1);
    assert_approx_eq!(f32, value.scale, 0.9, epsilon = 0.000_1);
}

#[test]
fn prelude_exports_composition_types() {
    let mut sequence = Sequence::new(0.0_f32)
        .then(Tween::between(0.0, 1.0, Timing::new(25.0)))
        .then(Tween::between(1.0, 2.0, Timing::new(25.0)));

    sequence.tick(Duration::from_millis(50.0));

    assert_eq!(sequence.state(), AnimationState::Completed);
    assert_approx_eq!(f32, *sequence.value(), 2.0);
}

#[test]
fn derive_macro_supports_tuple_structs() {
    let midpoint = Offset::interpolate(&Offset(0.0, 10.0), &Offset(10.0, 30.0), 0.5);

    assert_approx_eq!(f32, midpoint.0, 5.0);
    assert_approx_eq!(f32, midpoint.1, 20.0);
}

#[test]
fn derive_macro_supports_unit_structs() {
    let _marker = Marker::interpolate(&Marker, &Marker, 0.5);
}

#[test]
fn facade_reexports_core_and_iced_crates() {
    let duration = aura_anim::core::timing::Duration::from_millis(16.0);
    let policy = aura_anim::iced::TickPolicy::interval(std::time::Duration::from_millis(16));

    assert_approx_eq!(f64, duration.as_millis(), 16.0);
    assert_eq!(
        policy,
        aura_anim::iced::TickPolicy::Interval(std::time::Duration::from_millis(16))
    );
}