photonic-effects 0.1.0

Dynamic light controller and animator
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
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

use std::fmt::Debug;
use std::time::Duration;

use num_traits::Float;

#[derive(Debug)]
pub struct Easing<F: Float> {
    pub func: fn(F) -> F,
    pub speed: Duration,
}

impl<F: Float> Easing<F> {
    pub fn new(func: fn(F) -> F) -> Self {
        return Self {
            func,
            speed: Duration::from_secs(1),
        };
    }

    pub fn with_speed(mut self, speed: Duration) -> Self {
        self.speed = speed;
        return self;
    }
}

impl<F: Float> From<fn(F) -> F> for Easing<F> {
    fn from(func: fn(F) -> F) -> Self {
        return Self::new(func);
    }
}

#[derive(Debug)]
#[cfg_attr(feature = "dynamic", derive(photonic_dynamic::serde::Deserialize))]
#[cfg_attr(feature = "dynamic", serde(rename_all = "snake_case"))]
pub enum EasingDirection {
    In,
    Out,
    InOut,
}

#[derive(Debug)]
#[cfg_attr(feature = "dynamic", derive(photonic_dynamic::serde::Deserialize))]
#[cfg_attr(feature = "dynamic", serde(rename_all = "snake_case"))]
pub enum Easings {
    Instant,
    Linear,
    Quadratic(EasingDirection),
    Cubic(EasingDirection),
    Quartic(EasingDirection),
    Quintic(EasingDirection),
    Sine(EasingDirection),
    Circular(EasingDirection),
    Exponential(EasingDirection),
    Elastic(EasingDirection),
    Back(EasingDirection),
    Bounce(EasingDirection),
}

impl Easings {
    pub fn with_speed<F: Float>(self, speed: Duration) -> Easing<F> {
        return Easing::from(self).with_speed(speed);
    }
}

impl<F: Float> From<Easings> for Easing<F> {
    fn from(value: Easings) -> Self {
        use ezing::*;
        return match value {
            Easings::Instant => |_| F::one(),
            Easings::Linear => linear,
            Easings::Quadratic(EasingDirection::In) => quad_in,
            Easings::Quadratic(EasingDirection::Out) => quad_out,
            Easings::Quadratic(EasingDirection::InOut) => quad_inout,
            Easings::Cubic(EasingDirection::In) => cubic_in,
            Easings::Cubic(EasingDirection::Out) => cubic_out,
            Easings::Cubic(EasingDirection::InOut) => cubic_inout,
            Easings::Quartic(EasingDirection::In) => quart_in,
            Easings::Quartic(EasingDirection::Out) => quart_out,
            Easings::Quartic(EasingDirection::InOut) => quad_inout,
            Easings::Quintic(EasingDirection::In) => quint_in,
            Easings::Quintic(EasingDirection::Out) => quint_out,
            Easings::Quintic(EasingDirection::InOut) => quint_inout,
            Easings::Sine(EasingDirection::In) => sine_in,
            Easings::Sine(EasingDirection::Out) => sine_out,
            Easings::Sine(EasingDirection::InOut) => sine_inout,
            Easings::Circular(EasingDirection::In) => circ_in,
            Easings::Circular(EasingDirection::Out) => circ_out,
            Easings::Circular(EasingDirection::InOut) => circ_inout,
            Easings::Exponential(EasingDirection::In) => expo_in,
            Easings::Exponential(EasingDirection::Out) => expo_out,
            Easings::Exponential(EasingDirection::InOut) => expo_inout,
            Easings::Elastic(EasingDirection::In) => elastic_in,
            Easings::Elastic(EasingDirection::Out) => elastic_out,
            Easings::Elastic(EasingDirection::InOut) => elastic_inout,
            Easings::Back(EasingDirection::In) => back_in,
            Easings::Back(EasingDirection::Out) => back_out,
            Easings::Back(EasingDirection::InOut) => back_inout,
            Easings::Bounce(EasingDirection::In) => bounce_in,
            Easings::Bounce(EasingDirection::Out) => bounce_out,
            Easings::Bounce(EasingDirection::InOut) => bounce_inout,
        }
        .into();
    }
}

#[cfg(feature = "dynamic")]
impl<'de, F: Float> serde::Deserialize<'de> for Easing<F> {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where D: serde::Deserializer<'de> {
        #[derive(Debug, serde::Deserialize)]
        struct S {
            func: Easings,

            #[serde(with = "humantime_serde")]
            speed: Duration,
        }

        let s = S::deserialize(deserializer)?;

        return Ok(s.func.with_speed(s.speed));
    }
}