gled-core 2.31.1

The engine of gled without a user interface: inputs, timing, rendering, Art-Net/DMX output and storage
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

//! Actions on the project's settings: dimmer, palette, patch, grid, inputs,
//! outputs and the network controls.

use std::sync::Arc;

use crate::action::{UiAction, apply_palette_action};
use crate::engine::Engine;
use crate::input::{artnet::set_artnet_control_config, event::InputEvent};

use super::ignore_without_project;

impl Engine {
    /// Changes the loaded project's settings.
    pub(super) fn apply_project_action(&mut self, action: UiAction) {
        match (self.project.as_mut().map(Arc::make_mut), action) {
            (Some(project), UiAction::SetMainDimmer(dimmer)) => {
                project.main_dimmer = dimmer;
            }
            (Some(project), UiAction::AddMainDimmer(delta)) => {
                project.main_dimmer = (project.main_dimmer + delta).clamp(0.0, 1.0);
            }
            (Some(project), UiAction::SetProjectArtnetControlActive(active)) => {
                set_artnet_control_config(project, |config| config.active = active);
            }
            (Some(project), UiAction::SetProjectArtnetControlUniverse(universe)) => {
                set_artnet_control_config(project, |config| config.universe = universe);
            }
            (Some(project), UiAction::SetProjectOscActive(active)) => {
                project.osc_config.active = active;
            }
            (Some(project), UiAction::SetProjectOscPort(port)) => {
                project.osc_config.port = port;
            }
            (Some(project), UiAction::AddProjectTapInputArtnet(channel)) => {
                project.tap_input_events.insert(InputEvent::Artnet(channel));
            }
            (Some(project), UiAction::RemoveProjectTapInputArtnet(channel)) => {
                project
                    .tap_input_events
                    .remove(&InputEvent::Artnet(channel));
            }
            (Some(project), UiAction::ClearProjectTapInput) => {
                project.tap_input_events.clear();
            }
            (Some(project), UiAction::AddProjectBlackoutInputArtnet(channel)) => {
                project
                    .blackout_input_events
                    .insert(InputEvent::Artnet(channel));
            }
            (Some(project), UiAction::RemoveProjectBlackoutInputArtnet(channel)) => {
                project
                    .blackout_input_events
                    .remove(&InputEvent::Artnet(channel));
            }
            (Some(project), UiAction::ClearProjectBlackoutInput) => {
                project.blackout_input_events.clear();
            }
            (Some(project), UiAction::AddProjectBlackoutHoldInputArtnet(channel)) => {
                project
                    .blackout_hold_input_events
                    .insert(InputEvent::Artnet(channel));
            }
            (Some(project), UiAction::RemoveProjectBlackoutHoldInputArtnet(channel)) => {
                project
                    .blackout_hold_input_events
                    .remove(&InputEvent::Artnet(channel));
            }
            (Some(project), UiAction::ClearProjectBlackoutHoldInput) => {
                project.blackout_hold_input_events.clear();
            }
            (Some(project), UiAction::AddProjectHalfInputArtnet(channel)) => {
                project
                    .half_input_events
                    .insert(InputEvent::Artnet(channel));
            }
            (Some(project), UiAction::RemoveProjectHalfInputArtnet(channel)) => {
                project
                    .half_input_events
                    .remove(&InputEvent::Artnet(channel));
            }
            (Some(project), UiAction::ClearProjectHalfInput) => {
                project.half_input_events.clear();
            }
            (Some(project), UiAction::AddProjectDoubleInputArtnet(channel)) => {
                project
                    .double_input_events
                    .insert(InputEvent::Artnet(channel));
            }
            (Some(project), UiAction::RemoveProjectDoubleInputArtnet(channel)) => {
                project
                    .double_input_events
                    .remove(&InputEvent::Artnet(channel));
            }
            (Some(project), UiAction::ClearProjectDoubleInput) => {
                project.double_input_events.clear();
            }
            (
                Some(project),
                action @ (UiAction::SetProjectPaletteFromAsset(_)
                | UiAction::SetProjectPalettePrimary(_)
                | UiAction::SetProjectPaletteSecondary(_)
                | UiAction::SetProjectPaletteGradient(_, _)
                | UiAction::SetScenePaletteOverwriteFromAsset(_, _)
                | UiAction::SetScenePaletteOverwritePrimary(_, _)
                | UiAction::SetScenePaletteOverwriteSecondary(_, _)
                | UiAction::SetScenePaletteOverwriteGradient(_, _, _)),
            ) => {
                apply_palette_action(
                    project,
                    self.selected_scene_instance,
                    &self.collections,
                    &action,
                );
            }

            (Some(project), UiAction::SetProjectPalette(palette)) => {
                project.palette = *palette;
            }
            (Some(_), UiAction::SetProjectPatch(patch)) => self.replace_patch(*patch),
            (Some(project), UiAction::SetGridSize(width, height)) => {
                project.set_grid_size(width, height);
                let selected = &mut self.selected_scene_instance;
                selected.col = selected.col.min(project.grid_width() - 1);
                selected.row = selected.row.min(project.grid_height() - 1);
            }
            (Some(project), UiAction::SetGridHighlight(grid_highlight)) => {
                project.grid_highlight = grid_highlight;
            }
            (Some(project), UiAction::SetProjectChannelOverwrites(overwrites)) => {
                project.channel_overwrites = overwrites;
            }
            (Some(project), UiAction::SetProjectOutputRoutings(routings)) => {
                project.output_routings = routings;
            }
            (Some(project), UiAction::SetProjectArtnetConfig(artnet_config)) => {
                project.artnet_config = *artnet_config;
            }
            (Some(project), UiAction::SetProjectTriggerInputs(inputs)) => {
                inputs.apply_to(project);
            }
            (Some(project), UiAction::SetMidiActiveMappings(mappings)) => {
                project.midi_active_mappings = mappings;
            }
            (Some(project), UiAction::SetProjectArtnetControl(config)) => {
                set_artnet_control_config(project, |current| *current = config);
            }
            (Some(project), UiAction::SetProjectOsc(osc_config)) => {
                project.osc_config = osc_config;
            }
            (None, _) => ignore_without_project(),
            // `apply_action` routes only project settings here.
            (Some(_), _) => {}
        }
    }
}