gled 2.29.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
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

pub mod color;
pub mod effect;
pub mod effect_state;
pub(crate) mod grid;
pub mod instance;

use super::{AssetTrait, animation::Animation, palette::Palette};
use crate::{
    audio::sound_data::SoundData,
    pipeline::{
        gpu::{Gpu, OutputContext},
        group::{GroupIndices, Groups},
    },
    storage::{AssetId, collections::Collections},
    ui::pills::show_pills,
};
use effect::Effect;
use egui::{Color32, Vec2};
use serde::{Deserialize, Serialize};
use wgpu::{CommandEncoder, Queue};

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, Eq)]
pub struct Scene {
    pub effects: Vec<Effect>,
}

impl Scene {
    pub fn group_indices(&self) -> GroupIndices {
        self.effects
            .iter()
            .map(|effect| effect.group_index)
            .collect()
    }

    pub fn effect(&mut self, index: usize) -> Option<&mut Effect> {
        self.effects.get_mut(index)
    }

    pub fn effects(&self) -> &[Effect] {
        &self.effects
    }

    /// Add an effect. Its GPU pipeline is built lazily by `ensure_pipelines`
    /// on whichever thread renders this scene.
    pub fn add_effect(&mut self, effect: Effect) -> usize {
        self.effects.push(effect);

        self.effects.len() - 1
    }

    pub fn remove_effect(&mut self, index: usize) -> Option<Effect> {
        let mut effect = None;

        if self.effects.len() > index {
            effect = Some(self.effects.remove(index));
        }

        effect
    }

    /// Mark the pipelines of all effects using the given animation as outdated,
    /// or of all effects for `None`. Call after an animation was edited; the
    /// next `ensure_*_pipelines` rebuilds them.
    pub fn invalidate_pipelines(&mut self, animation: Option<AssetId<Animation>>) {
        for effect in self.effects.iter_mut() {
            if let Some(animation) = animation
                && effect.animation != Some(animation)
            {
                continue;
            }

            effect.invalidate_pipeline();
        }
    }

    /// Build missing thumbnail pipelines on the UI device and rebuild outdated ones.
    pub fn ensure_matrix_pipelines(&mut self, gpu: &Gpu, collections: &Collections) {
        for effect in self.effects.iter_mut() {
            effect.ensure_matrix_pipeline(gpu, collections);
        }
    }

    /// Build missing output pipelines on the output device and rebuild outdated ones.
    pub fn ensure_output_pipelines(&mut self, context: &OutputContext, collections: &Collections) {
        for effect in self.effects.iter_mut() {
            effect.ensure_output_pipeline(context, collections);
        }
    }

    pub fn prepare(
        &mut self,
        queue: &Queue,
        palette: Option<Palette>,
        groups: &Groups,
        main_opacity: f32,
        collections: &Collections,
        sound_data: &SoundData,
    ) {
        for effect in self.effects.iter_mut() {
            effect.prepare(
                queue,
                palette.clone(),
                groups,
                main_opacity,
                collections,
                sound_data,
            );
        }
    }

    #[cfg_attr(feature = "profiling", profiling::function)]
    pub fn render(&mut self, encoder: &mut CommandEncoder, render_matrix: bool, send_output: bool) {
        for effect in self.effects.iter_mut() {
            effect.render(encoder, render_matrix, send_output);
        }
    }
}

impl AssetTrait for Scene {
    const DIR_NAME: &'static str = "scenes";
    const NAME: &'static str = "Scene";
    const SHOW_NAME_IF_SELECTED: bool = true;

    fn show(&self, ui: &mut egui::Ui, rect: egui::Rect) {
        show_pills(
            ui,
            rect.right_top() + Vec2::new(0.0, 1.0),
            self.group_indices()
                .into_iter()
                .map(|index| (index.to_string(), Color32::GOLD))
                .collect(),
        );
    }
}