bsru 0.7.0

Beatsaber Rust Utilities: A Beatsaber V3 parsing 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
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

//! The easing that a [transition](crate::lightshow::TransitionType::Transition) event will use.

use loose_enum::loose_enum;
use simple_easing::*;

loose_enum! {
    /// The easing that a [transition](crate::lightshow::TransitionType::Transition) event will use.
    #[derive(Default, Debug, Clone, Copy, Eq, PartialEq, Hash)]
    #[cfg_attr(
        feature = "bevy_reflect",
        derive(bevy_reflect::Reflect),
        reflect(Debug, Clone, PartialEq)
    )]
    pub enum Easing: i32 {
        #[default]
        None = -1,

        Linear = 0,
        InQuad = 1,
        OutQuad = 2,
        InOutQuad = 3,
        InSine = 4,
        OutSine = 5,
        InOutSine = 6,
        InCubic = 7,
        OutCubic = 8,
        InOutCubic = 9,
        InQuart = 10,
        OutQuart = 11,
        InOutQuart = 12,
        InQuint = 13,
        OutQuint = 14,
        InOutQuint = 15,
        InExpo = 16,
        OutExpo = 17,
        InOutExpo = 18,
        InCirc = 19,
        OutCirc = 20,
        InOutCirc = 21,
        InBack = 22,
        OutBack = 23,
        InOutBack = 24,
        InElastic = 25,
        OutElastic = 26,
        InOutElastic = 27,
        InBounce = 28,
        OutBounce = 29,
        InOutBounce = 30,

        /// Note: For [`Easing::ease`], the result will be the same as [`Easing::InOutBack`].
        BeatSaberInOutBack = 100,
        /// Note: For [`Easing::ease`], the result will be the same as [`Easing::InOutElastic`].
        BeatSaberInOutElastic = 101,
        /// Note: For [`Easing::ease`], the result will be the same as [`Easing::InOutBounce`].
        BeatSaberInOutBounce = 102,
    }
}

impl Easing {
    /// Applies the relevant easing function.
    ///
    /// The Beatsaber specific easing use the standard equivalent instead.
    /// If the easing is [`None`](Self::None) or [`Undefined`](Self::Undefined), then the result will be zero.
    pub fn ease(&self, num: f32) -> f32 {
        match self {
            Easing::None => 0.0,

            Easing::Linear => linear(num),
            Easing::InQuad => quad_in(num),
            Easing::OutQuad => quad_out(num),
            Easing::InOutQuad => quad_in_out(num),
            Easing::InSine => sine_in(num),
            Easing::OutSine => sine_out(num),
            Easing::InOutSine => sine_in_out(num),
            Easing::InCubic => cubic_in(num),
            Easing::OutCubic => cubic_out(num),
            Easing::InOutCubic => cubic_in_out(num),
            Easing::InQuart => quart_in(num),
            Easing::OutQuart => quart_out(num),
            Easing::InOutQuart => quart_in_out(num),
            Easing::InQuint => quint_in(num),
            Easing::OutQuint => quint_out(num),
            Easing::InOutQuint => quint_in_out(num),
            Easing::InExpo => expo_in(num),
            Easing::OutExpo => expo_out(num),
            Easing::InOutExpo => expo_in_out(num),
            Easing::InCirc => circ_in(num),
            Easing::OutCirc => circ_out(num),
            Easing::InOutCirc => circ_in_out(num),
            Easing::InBack => back_in(num),
            Easing::OutBack => back_out(num),
            Easing::InOutBack => back_in_out(num),
            Easing::InElastic => elastic_in(num),
            Easing::OutElastic => elastic_out(num),
            Easing::InOutElastic => elastic_in_out(num),
            Easing::InBounce => bounce_in(num),
            Easing::OutBounce => bounce_out(num),
            Easing::InOutBounce => bounce_in_out(num),

            Easing::BeatSaberInOutBack => back_in_out(num),
            Easing::BeatSaberInOutElastic => elastic_in_out(num),
            Easing::BeatSaberInOutBounce => bounce_in_out(num),
            Easing::Undefined(_) => 0.0,
        }
    }
}