gled 2.11.0

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

use super::App;
use crate::{
    app::PersistantState,
    pipeline::transition::{Transition, TransitionGoal},
    storage::asset::project::scene_instance_path::SceneInstancePath,
    ui::scene_instance::widget::SceneInstanceWidget,
};
use egui::{Color32, Rect, TextureHandle, Ui, Vec2, scroll_area::ScrollBarVisibility};

impl App {
    pub fn effects_grid(
        &mut self,
        ui: &mut Ui,
        svg: Option<TextureHandle>,
        uv: Option<Rect>,
        path: SceneInstancePath,
    ) {
        let Some(project) = self.project.as_mut() else {
            return;
        };

        let effects_size = PersistantState::effects_size();

        egui::ScrollArea::vertical()
            .id_salt(format!("{path:?} scroll"))
            .auto_shrink([false, false])
            .scroll_bar_visibility(ScrollBarVisibility::AlwaysVisible)
            .show(ui, |ui| {
                ui.set_max_width(ui.available_width() - 30.0);
                ui.horizontal_wrapped(|ui| {
                    let mut changed = None;
                    let deck_groups = project.deck(path).groups.clone();
                    for (path, scene_instance) in project.scene_instances(path) {
                        let response = ui.add_sized(
                            Vec2::new(effects_size + 40.0, effects_size + 60.0),
                            SceneInstanceWidget {
                                selected_scene_instance: &mut self.selected_scene_instance,
                                hovered_scene_instance: &mut self.hovered_scene_instance,
                                path,
                                scene_instance,
                                svg: svg.clone(),
                                effects_size,
                                live_color: Color32::DARK_GREEN,
                                uv,
                                deck_groups: &deck_groups,
                            },
                        );
                        if response.changed()
                            || scene_instance
                                .activation_input
                                .as_ref()
                                .map(|event| event.is_new())
                                .unwrap_or_default()
                        {
                            changed = Some(path);
                        }
                    }

                    if let Some(changed_path) = changed {
                        if let Some(scene_instance) = project.scene_instance(changed_path) {
                            scene_instance.set_transition(Transition::new(
                                if scene_instance.active {
                                    TransitionGoal::TurnOff
                                } else {
                                    TransitionGoal::TurnOn
                                },
                                self.timing.fade_duration(),
                            ));
                        }
                    }
                });
            });
    }
}