glissade 0.2.10

Rust library that provides various utilities for animations and transitions
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
91
92
93
94
95
96
97

use crate::{Distance, Mix};
use std::fmt::Debug;

#[derive(Clone)]
pub(crate) struct Poly<T: Mix + Distance + Clone> {
    points: Vec<T>,
    offsets: Vec<f32>,
}

impl<T: Mix + Distance + Clone + Debug> Debug for Poly<T> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("Poly")
            .field("points", &self.points)
            .field("offsets", &self.offsets)
            .finish()
    }
}

impl<T: Mix + Distance + Clone + PartialEq> PartialEq for Poly<T> {
    fn eq(&self, other: &Self) -> bool {
        self.points == other.points
    }
}

impl<T: Mix + Distance + Clone + Eq> Eq for Poly<T> {}

impl<T: Mix + Distance + Clone> Poly<T> {
    pub fn new(points: Vec<T>) -> Self {
        assert!(!points.is_empty());
        Self {
            offsets: points
                .windows(2)
                .map(|points| points[0].clone().distance(points[1].clone()))
                .fold(
                    {
                        let mut result = Vec::with_capacity(points.len());
                        result.push(0.0);
                        result
                    },
                    |mut acc, w| {
                        acc.push(acc.last().copied().unwrap_or_default() + w);
                        acc
                    },
                ),
            points,
        }
    }

    /// Returns the value at the given time `t` in the range [0.0, 1.0].
    pub fn value_at(&self, t: f32) -> T {
        let offset = self.length() * t.clamp(0.0, 1.0);

        let mut i1 = 0;
        let mut i2 = self.offsets.len() - 1;
        while i2 - i1 > 1 {
            let i = (i1 + i2) >> 1;
            if offset > self.offsets[i] {
                i1 = i;
            } else {
                i2 = i;
            }
        }

        let o1 = self.offsets[i1];
        let o2 = self.offsets[i2];

        let f = (offset - o1) / (o2 - o1);

        self.points[i1].clone().mix(self.points[i2].clone(), f)
    }

    pub(self) fn length(&self) -> f32 {
        self.offsets.last().copied().unwrap_or_default()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn it_works() {
        let poly = Poly::new(vec![0.0, 1.0, 2.0]);
        assert_eq!(poly.value_at(0.0), 0.0);
        assert_eq!(poly.value_at(0.25), 0.5);
        assert_eq!(poly.value_at(0.5), 1.0);
        assert_eq!(poly.value_at(0.75), 1.5);
        assert_eq!(poly.value_at(1.0), 2.0);
    }

    #[test]
    fn test_two_lines() {
        let poly = Poly::new(vec![(0.0, 0.0), (2.0, 0.0), (2.0, 8.0)]);
        assert_eq!(poly.value_at(0.5), (2.0, 3.0));
        assert_eq!(poly.value_at(0.75), (2.0, 5.5));
    }
}