gled-core 2.32.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

//! What a scene instance does: its own settings, inputs, curves and palette
//! overwrite, whichever way it is addressed.

use rosc::OscMessage;
use uuid::Uuid;

use super::args::{parse_bool, parse_curve_id, parse_f32, parse_rgb, parse_string, parse_u16};
use crate::action::UiAction;
use crate::input::event::InputEvent;
use crate::storage::asset::palette::Palette;
use crate::storage::asset::project::scene_instance_path::SceneInstanceUnion;
use crate::storage::asset::scene::color::SceneInstanceColor;
use crate::storage::asset_id::AssetId;

pub(super) fn parse_target_input_action(
    msg: &OscMessage,
    target: SceneInstanceUnion,
    input_kind: &str,
    mode: &str,
) -> Result<UiAction, ()> {
    let input = match mode {
        "clear" => None,
        "artnet" => Some(InputEvent::Artnet(parse_u16(msg, 0)?)),
        _ => return Err(()),
    };

    match input_kind {
        "activation_input" => Ok(UiAction::SetSceneActivationInput(target, input)),
        "flash_input" => Ok(UiAction::SetSceneFlashInput(target, input)),
        "dimmer_input" => Ok(UiAction::SetSceneDimmerInput(target, input)),
        _ => Err(()),
    }
}

pub(super) fn parse_target_action(
    msg: &OscMessage,
    target: SceneInstanceUnion,
    action: &str,
) -> Result<UiAction, ()> {
    match action {
        "opacity" => Ok(UiAction::SetSceneOpacity(target, parse_f32(msg, 0)?)),
        "active" => Ok(UiAction::SetSceneActive(target, parse_bool(msg, 0)?)),
        "toggle" => Ok(UiAction::ToggleSceneActive(target)),
        "select" => Ok(UiAction::SelectScene(target)),
        "name" => Ok(UiAction::SetSceneName(target, parse_string(msg, 0)?)),
        "color" => Ok(UiAction::SetSceneColor(target, parse_scene_color(msg, 0)?)),
        "input_dimmer" => Ok(UiAction::SetSceneInputDimmer(target, parse_f32(msg, 0)?)),
        "ignore_main_dimmer" => Ok(UiAction::SetSceneIgnoreMainDimmer(
            target,
            parse_bool(msg, 0)?,
        )),
        "beat_offset" => Ok(UiAction::SetSceneBeatOffset(target, parse_f32(msg, 0)?)),
        "set_offset_on_flash" => Ok(UiAction::SetSceneSetOffsetOnFlash(
            target,
            parse_bool(msg, 0)?,
        )),
        "palette_overwrite" => Ok(UiAction::SetScenePaletteOverwriteFromAsset(
            target,
            parse_scene_palette_overwrite(msg, 0)?,
        )),
        "delete" => Ok(UiAction::DeleteSceneInstancePath(target)),
        "clone" => Ok(UiAction::CloneSceneInstancePath(target)),
        _ => Err(()),
    }
}

pub(super) fn parse_target_palette_overwrite_action(
    msg: &OscMessage,
    target: SceneInstanceUnion,
    action: &str,
) -> Result<UiAction, ()> {
    match action {
        "primary" => Ok(UiAction::SetScenePaletteOverwritePrimary(
            target,
            parse_rgb(msg)?,
        )),
        "secondary" => Ok(UiAction::SetScenePaletteOverwriteSecondary(
            target,
            parse_rgb(msg)?,
        )),
        _ => Err(()),
    }
}

fn parse_scene_palette_overwrite(
    msg: &OscMessage,
    index: usize,
) -> Result<Option<Option<AssetId<Palette>>>, ()> {
    let raw = parse_string(msg, index)?;
    if raw.eq_ignore_ascii_case("inherit") {
        return Ok(None);
    }
    if raw.eq_ignore_ascii_case("none") {
        return Ok(Some(None));
    }
    let uuid = Uuid::parse_str(&raw).map_err(|_| ())?;
    Ok(Some(Some(AssetId::from_uuid(uuid))))
}

pub(super) fn parse_target_curve_action(
    msg: &OscMessage,
    target: SceneInstanceUnion,
    field: &str,
    sub_action: &str,
) -> Result<UiAction, ()> {
    match (field, sub_action) {
        ("opacity", "value") => Ok(UiAction::SetSceneOpacityMultiplier(
            target,
            parse_f32(msg, 0)?,
        )),
        ("opacity", "static") => Ok(UiAction::SetSceneOpacity(target, parse_f32(msg, 0)?)),
        ("opacity", "curve") => Ok(UiAction::SetSceneOpacityCurve(
            target,
            parse_curve_id(msg, 0)?,
        )),
        ("beat_offset", "value") => Ok(UiAction::SetSceneBeatOffsetMultiplier(
            target,
            parse_f32(msg, 0)?,
        )),
        ("beat_offset", "static") => Ok(UiAction::SetSceneBeatOffset(target, parse_f32(msg, 0)?)),
        ("beat_offset", "curve") => Ok(UiAction::SetSceneBeatOffsetCurve(
            target,
            parse_curve_id(msg, 0)?,
        )),
        _ => Err(()),
    }
}

fn parse_scene_color(msg: &OscMessage, index: usize) -> Result<SceneInstanceColor, ()> {
    parse_string(msg, index)?.parse().map_err(|_| ())
}