gled 2.1.1

gled is an application for creating animations and effects on artnet or wled light installations
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

pub mod widget;

use crate::storage::asset::{
    scene::{effect::Effect, effect_state::EffectState},
    Asset,
};
use egui::{DragValue, Slider};

use super::ChangeButton;

impl Effect {
    pub fn config_ui(
        &mut self,
        state: &mut EffectState,
        ui: &mut egui::Ui,
        allow_animation_change: bool,
    ) -> bool {
        let mut changed = false;

        if allow_animation_change {
            ui.label("Animation");
            ui.vertical_centered_justified(|ui| {
                if self.animation.change_button(ui) {
                    state.update(self);
                }
            });
        }

        ui.label("Progression");
        ui.vertical_centered_justified(|ui| {
            changed |= self.beat_progression.change_button(ui);
        });

        ui.label("Colorshift");
        ui.vertical_centered_justified(|ui| {
            changed |= self.color_shift.change_button(ui);
        });

        ui.label("Opacity");
        ui.vertical_centered_justified(|ui| {
            changed |= self.opacity.change_button(ui);
        });

        ui.label("Beat offset");
        ui.vertical_centered_justified(|ui| {
            changed |= self.beat_progression_offset.change_button(ui);
        });

        ui.label("Speed");
        ui.horizontal(|ui| {
            ui.spacing_mut().slider_width = ui.available_width() - 60.0;
            changed |= ui
                .add(
                    Slider::new(&mut self.speed_exponent, -8..=8)
                        .step_by(1.0)
                        .custom_formatter(|n, _| {
                            format!(
                                "{} x",
                                if n > 0.0 {
                                    2i32.pow(n as u32).to_string()
                                } else if n > -0.1 {
                                    "1".to_string()
                                } else {
                                    format!("1/{}", 2i32.pow((-n) as u32))
                                }
                            )
                        })
                        .custom_parser(|s| {
                            let s = s.split(' ').next().unwrap_or(s);
                            let s = s.strip_suffix('x').unwrap_or(s);
                            let n = if let Some(n) =
                                s.strip_prefix("1/").and_then(|s| s.parse::<f32>().ok())
                            {
                                1f32 / n
                            } else {
                                s.parse::<f32>().ok()?
                            };

                            Some(n.log2() as f64)
                        }),
                )
                .changed();
        });

        if let Some(animation) = self
            .animation_overwrite
            .clone()
            .or_else(|| self.animation.and_then(Asset::get))
        {
            let rendered = state.texture_id();
            changed |= animation
                .data
                .config_ui(&mut self.animation_config, ui, rendered);
        }

        ui.separator();

        ui.label("Group index");
        ui.vertical_centered_justified(|ui| {
            changed |= ui.add(DragValue::new(&mut self.group_index)).changed();
        });

        changed
    }
}