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
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
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178

//! Describes the colors of objects and lights for an environment/map.

pub mod presets;

#[allow(unused_imports)]
#[doc(hidden)]
pub use presets::*;

use serde::{Deserialize, Serialize};
use std::string::ToString;

#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
#[cfg_attr(
    feature = "bevy_reflect",
    derive(bevy_reflect::Reflect),
    reflect(Debug, Clone, PartialEq)
)]
#[serde(rename_all = "camelCase")]
pub struct ColorSchemeOverride {
    pub use_override: bool,
    pub color_scheme: ColorScheme,
}

/// The colors of objects and lights for an environment/map.
///
/// This does *not* currently support while light color overrides.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[cfg_attr(
    feature = "bevy_reflect",
    derive(bevy_reflect::Reflect),
    reflect(Debug, Clone, PartialEq)
)]
#[serde(rename_all = "camelCase")]
pub struct ColorScheme {
    /// The name of the color scheme.
    #[serde(rename = "colorSchemeId")]
    pub id: String,
    /// The color for the left saber/notes. Default is red.
    #[doc(alias = "saber_left")]
    #[serde(rename = "saberAColor")]
    pub note_left: Color,
    /// The color for the right saber/notes. Default is blue.
    #[doc(alias = "saber_right")]
    #[serde(rename = "saberBColor")]
    pub note_right: Color,

    /// The color of walls/obstacles.
    #[doc(alias = "obstacle")]
    #[serde(rename = "obstaclesColor")]
    pub wall: Color,

    /// The primary light color, often matching the [left note color](Self::note_left).
    #[doc(alias = "environment0")]
    #[serde(rename = "environmentColor0")]
    pub light_primary: Color,
    /// The secondary light color, often matching the [right note color](Self::note_right).
    #[doc(alias = "environment1")]
    #[serde(rename = "environmentColor1")]
    pub light_secondary: Color,

    /// The primary light color when [boost colors](crate::ColorBoostEvent) are enabled.
    #[doc(alias = "environment_boost_0")]
    #[serde(rename = "environmentColor0Boost")]
    pub boost_light_primary: Color,
    /// The secondary light color when [boost colors](crate::ColorBoostEvent) are enabled.
    #[doc(alias = "environment_boost_1")]
    #[serde(rename = "environmentColor1Boost")]
    pub boost_light_secondary: Color,
}

impl Default for ColorScheme {
    fn default() -> Self {
        ColorScheme {
            id: "Default".to_string(),
            note_left: Color {
                red: 0.7843137,
                green: 0.07843138,
                blue: 0.07843138,
                alpha: 1.0,
            },
            note_right: Color {
                red: 0.1568627,
                green: 0.5568627,
                blue: 0.8235294,
                alpha: 1.0,
            },
            wall: Color {
                red: 1.0,
                green: 0.1882353,
                blue: 0.1882353,
                alpha: 1.0,
            },
            light_primary: Color {
                red: 0.85,
                green: 0.08499997,
                blue: 0.08499997,
                alpha: 1.0,
            },
            light_secondary: Color {
                red: 0.1882353,
                green: 0.675294,
                blue: 1.0,
                alpha: 1.0,
            },
            boost_light_primary: Default::default(),
            boost_light_secondary: Default::default(),
        }
    }
}

/// The color of an object/light.
#[derive(Debug, Copy, Clone, PartialEq, Serialize, Deserialize)]
#[cfg_attr(
    feature = "bevy_reflect",
    derive(bevy_reflect::Reflect),
    reflect(Debug, Clone, PartialEq)
)]
pub struct Color {
    #[serde(rename = "r")]
    red: f32,
    #[serde(rename = "g")]
    green: f32,
    #[serde(rename = "b")]
    blue: f32,
    #[serde(rename = "a")]
    alpha: f32,
}

impl Default for Color {
    fn default() -> Self {
        Self {
            red: 1.0,
            green: 1.0,
            blue: 1.0,
            alpha: 1.0,
        }
    }
}

#[cfg(feature = "bevy_color")]
mod color_conversions {
    use crate::info::color_scheme::Color;
    use bevy_color::Srgba;

    impl From<Srgba> for Color {
        fn from(value: Srgba) -> Self {
            Self {
                red: value.red,
                green: value.green,
                blue: value.blue,
                alpha: value.alpha,
            }
        }
    }

    impl From<Color> for Srgba {
        fn from(value: Color) -> Self {
            Self {
                red: value.red,
                green: value.green,
                blue: value.blue,
                alpha: value.alpha,
            }
        }
    }

    impl From<bevy_color::Color> for Color {
        fn from(value: bevy_color::Color) -> Self {
            Srgba::from(value).into()
        }
    }

    impl From<Color> for bevy_color::Color {
        fn from(value: Color) -> Self {
            Self::Srgba(value.into())
        }
    }
}