ezy 0.1.1

Easy to use tweening library
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

use std::{
    sync::{Arc, Mutex},
    thread,
    time::Duration,
};

use ezy::*;

#[test]
fn float() {
    fn generate_tween() -> Tween<f32> {
        Tween::new(1.0, Duration::from_secs(2))
    }
    let mut val = 0.0;

    // Define a tween
    let tween = generate_tween();

    let mut anim = tween.start(val);
    for _ in 0..5 {
        anim.progress(&mut val, Duration::from_secs_f32(0.2))
    }

    assert_eq!(val, 0.5);
}

#[test]
fn thread() {
    fn generate_tween() -> Tween<f32> {
        Tween::new(1.0, Duration::from_secs(2))
    }
    let val = Arc::new(Mutex::new(0.0));

    // Define a tween
    let tween = generate_tween();
    let thread_val = val.clone();

    let thread = thread::spawn(move || {
        let mut anim = tween.start(*thread_val.lock().unwrap());
        for _ in 0..5 {
            anim.progress(
                &mut thread_val.lock().unwrap(),
                Duration::from_secs_f32(0.2),
            )
        }
    });

    thread.join().unwrap();

    assert_eq!(*val.lock().unwrap(), 0.5);
}

#[test]
#[cfg(feature = "glam")]
fn tuple() {
    use glam::vec3;
    let mut val = (0.0, vec3(0.0, 1.0, 0.0));
    let tween = Tween::new((5.0, vec3(0.0, 2.0, -10.0)), Duration::from_secs(5));
    let mut anim = tween.start(val);
    for _ in 0..10 {
        anim.progress((&mut val.0, &mut val.1), Duration::from_millis(100));
    }

    assert_eq!(val, (1.0, vec3(0.0, 1.2, -2.0)));
}