yuno 0.1.1

A declarative UI layout and rendering framework powered by Skia.
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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use std::time::{Duration, Instant};

pub mod easing {
    use std::f64::consts::PI;

    #[allow(unused)]
    pub fn cubic_fly_hover_out(t: f64) -> f64 {
        let t_in = 500.0 / 4500.0;
        let t_out = 4000.0 / 4500.0;

        if t <= t_in {
            let u = t / t_in;
            let inv = 1.0 - u;
            1.0 - inv * inv * inv
        } else if t <= t_out {
            1.0
        } else {
            let u = (t - t_out) / (1.0 - t_out);
            1.0 - u * u * u
        }
    }

    #[allow(unused)]
    pub fn linear(t: f64) -> f64 {
        t
    }

    #[allow(unused)]
    pub fn quad_in(t: f64) -> f64 {
        t * t
    }

    #[allow(unused)]
    pub fn quad_out(t: f64) -> f64 {
        t * (2.0 - t)
    }

    #[allow(unused)]
    pub fn quad_in_out(t: f64) -> f64 {
        if t < 0.5 {
            2.0 * t * t
        } else {
            -1.0 + (4.0 - 2.0 * t) * t
        }
    }

    #[allow(unused)]
    pub fn sine_in(t: f64) -> f64 {
        1.0 - (t * PI / 2.0).cos()
    }

    #[allow(unused)]
    pub fn sine_out(t: f64) -> f64 {
        (t * PI / 2.0).sin()
    }

    #[allow(unused)]
    pub fn sine_in_out(t: f64) -> f64 {
        -0.5 * ((t * PI).cos() - 1.0)
    }

    #[allow(unused)]
    pub fn cubic_in_out(t: f64) -> f64 {
        if t < 0.5 {
            4.0 * t * t * t
        } else {
            let f = 2.0 * t - 2.0;
            0.5 * f * f * f + 1.0
        }
    }
}

pub struct StoryBoard {
    beginning: Instant,
    start: f64,
    end: f64,
    duration: f64,        // ms
    conv: fn(f64) -> f64, // Easing Functions [0, 1] -> [0, 1]
    r#loop: bool,
}

impl StoryBoard {
    pub fn init(start: f64, end: f64, duration: f64, r#loop: bool, f: fn(f64) -> f64) -> Self {
        Self {
            beginning: Instant::now(),
            start,
            end,
            duration,
            conv: f,
            r#loop,
        }
    }

    pub fn set_loop(&mut self, r#loop: bool) {
        self.r#loop = r#loop;
    }

    pub fn restart(&mut self) {
        self.beginning = Instant::now();
    }

    pub fn reverse(&mut self) {
        (self.start, self.end) = (self.end, self.start)
    }

    pub fn get_progress(&self) -> f64 {
        if self.duration <= 0.0 {
            return 1.0;
        }

        let pasted = Instant::now().duration_since(self.beginning).as_millis() as f64;
        let ratio = pasted / self.duration;

        if self.r#loop {
            ratio.rem_euclid(1.0)
        } else {
            ratio.clamp(0.0, 1.0)
        }
    }

    pub fn seek(&mut self, progress: f64) {
        if self.duration <= 0.0 {
            return;
        }

        let target_progress = if self.r#loop {
            progress.rem_euclid(1.0)
        } else {
            progress.clamp(0.0, 1.0)
        };

        let pasted_ms = target_progress * self.duration;
        self.beginning = Instant::now() - Duration::from_secs_f64(pasted_ms / 1000.0);
    }
}

impl From<&StoryBoard> for f64 {
    fn from(value: &StoryBoard) -> Self {
        if value.duration <= 0.0 {
            return value.end;
        }

        let r = value.get_progress();
        let x = (value.conv)(r);

        x * (value.end - value.start) + value.start
    }
}