gled 2.28.5

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

pub mod widget;

use crate::{
    audio::sound_data::SoundData,
    storage::{
        asset::{Asset, scene::effect::Effect},
        collections::Collections,
    },
    ui::asset::CollectionsChangeButton,
};
use egui::{DragValue, Slider};

impl Effect {
    pub fn config_ui(
        &mut self,
        ui: &mut egui::Ui,
        allow_animation_change: bool,
        svg: Option<egui::TextureHandle>,
        beat_progression: f32,
        collections: &mut Collections,
        sound_data: &mut SoundData,
    ) -> bool {
        let mut changed = false;

        if allow_animation_change {
            ui.label("Animation");
            ui.vertical_centered_justified(|ui| {
                if self.animation.collections_change_button(ui, collections) {
                    self.state
                        .set_shader_code(&self.shader_code_complete(collections));
                }
            });
        }

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

        let mut beat_progression = beat_progression;
        beat_progression +=
            self.beat_progression_offset
                .value(beat_progression, collections, sound_data);

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

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

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

        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(|id| Asset::get(id, collections)))
            && let Some(rendered) = self.state.texture_id()
        {
            changed |= animation.data.config_ui(
                &mut self.animation_config,
                ui,
                rendered,
                svg,
                beat_progression,
                collections,
                sound_data,
            );
        }

        ui.separator();

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

        changed
    }
}