gled-ui 2.30.1

gled's egui interface, shared by the desktop app and the browser
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

use crate::ui::{group::GroupColor, pills::show_pills};
use egui::{
    Button, Color32, CornerRadius, Image, Margin, Rect, Response, Sense, Shape, TextureHandle, Ui,
    Vec2, Widget, load::SizedTexture, pos2,
};
use epaint::RectShape;
use gled_model::{
    asset::{group::Groups, scene::effect::Effect},
    collection::Collections,
};
use gled_protocol::state::SoundSnapshot;

impl std::fmt::Debug for EffectWidget<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("EffectWidget")
            .field("effect", &self.effect)
            .finish_non_exhaustive()
    }
}

pub(crate) struct EffectWidget<'a> {
    pub(crate) selectable: Option<(&'a mut usize, usize)>,
    pub(crate) show_group: bool,
    pub(crate) effect: &'a Effect,
    /// The rendered effect, once its pipeline exists.
    pub(crate) thumbnail: Option<egui::TextureId>,
    pub(crate) svg: Option<TextureHandle>,
    pub(crate) groups: Option<&'a Groups>,
    pub(crate) groups_show_index: bool,
    /// used for showing the dimmer
    pub(crate) beat_progression: Option<f32>,
    pub(crate) collections: &'a Collections,
    pub(crate) sound_data: &'a SoundSnapshot,
}

impl Widget for EffectWidget<'_> {
    fn ui(self, ui: &mut Ui) -> Response {
        let frame = if let Some((selected_effect, index)) = &self.selectable {
            egui::Frame::NONE
                .fill(if *selected_effect == index {
                    Color32::GOLD
                } else {
                    Color32::TRANSPARENT
                })
                .inner_margin(Margin::from(10.0))
                .corner_radius(CornerRadius::from(4.0))
        } else {
            egui::Frame::NONE
                .inner_margin(Margin::from(10.0))
                .corner_radius(CornerRadius::from(4.0))
        };

        let response = frame
            .show(ui, |ui| {
                let mut bg_rect = ui.available_rect_before_wrap() + Margin::same(5);
                ui.painter()
                    .rect_filled(bg_rect, CornerRadius::ZERO, Color32::BLACK);
                if let Some(beat_progression) = self.beat_progression {
                    let dimmer = self.effect.opacity.value(
                        beat_progression,
                        self.collections,
                        self.sound_data,
                    );
                    bg_rect.min.y += (bg_rect.height() * (1.0 - dimmer)).round().max(0.0);
                    ui.painter()
                        .rect_filled(bg_rect, CornerRadius::ZERO, Color32::DARK_GREEN);
                }

                let size = ui.available_size();
                let rect = ui.available_rect_before_wrap();
                ui.allocate_rect(rect, Sense::hover());
                ui.painter().add(Shape::Rect(RectShape::filled(
                    rect,
                    CornerRadius::default(),
                    Color32::BLACK,
                )));

                ui.painter().add(Shape::Rect({
                    let mut shape =
                        RectShape::filled(rect, CornerRadius::default(), Color32::WHITE);
                    if let Some(texture_id) = self.thumbnail {
                        shape = shape.with_texture(
                            texture_id,
                            Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)),
                        );
                    }
                    shape
                }));
                if let Some(svg_texture_handle) = self.svg {
                    ui.put(rect, {
                        Image::new(SizedTexture::new(svg_texture_handle.id(), size))
                    });
                }

                if self.show_group {
                    let texts = self
                        .groups
                        .as_ref()
                        .and_then(|groups| groups.get(self.effect.group_index))
                        .map(|group| {
                            vec![(
                                if self.groups_show_index {
                                    format!("{}: {}", self.effect.group_index, group.0)
                                } else {
                                    group.0.clone()
                                },
                                group.color(),
                            )]
                        })
                        .unwrap_or_else(|| {
                            vec![(self.effect.group_index.to_string(), Color32::GOLD)]
                        });
                    show_pills(ui, rect.right_top() + Vec2::new(0.0, 5.0), texts);
                }
            })
            .response;

        if let Some((selected_effect, index)) = self.selectable {
            let res = ui.put(response.rect, Button::new("").fill(Color32::TRANSPARENT));
            if res.clicked() {
                *selected_effect = index;
            }
        }

        response
    }
}