mtrack 0.12.0

A multitrack audio and MIDI player for live performances.
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

// Copyright (C) 2026 Michael Wilson <mike@mdwn.dev>
//
// This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software
// Foundation, version 3.
//
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along with
// this program. If not, see <https://www.gnu.org/licenses/>.
//
use crate::lighting::effects::*;
use crate::lighting::engine::tests::common::create_test_fixture;
use crate::lighting::engine::EffectEngine;

use std::time::Duration;

#[test]
fn test_rainbow_hue_wraparound() {
    // Test that rainbow effect wraps hue correctly at 360 degrees
    let mut engine = EffectEngine::new();
    let fixture = create_test_fixture("test_fixture", 1, 1);
    engine.register_fixture(fixture);

    // Speed of 1.0 = 1 full hue rotation per second (360 degrees/sec)
    let effect = EffectInstance::new(
        "test_effect".to_string(),
        EffectType::Rainbow {
            speed: TempoAwareSpeed::Fixed(1.0),
            saturation: 1.0,
            brightness: 1.0,
            duration: Duration::from_secs(10),
        },
        vec!["test_fixture".to_string()],
        None,
        None,
        None,
    );

    engine.start_effect(effect).unwrap();

    // At t=0ms: hue=0 (red)
    let commands_start = engine.update(Duration::from_millis(0), None).unwrap();
    let red_start = commands_start
        .iter()
        .find(|cmd| cmd.channel == 2)
        .unwrap()
        .value;
    let green_start = commands_start
        .iter()
        .find(|cmd| cmd.channel == 3)
        .unwrap()
        .value;
    let blue_start = commands_start
        .iter()
        .find(|cmd| cmd.channel == 4)
        .unwrap()
        .value;

    // At hue=0 (red), should be approximately (255, 0, 0)
    assert!(
        red_start > 200 && green_start < 50 && blue_start < 50,
        "At t=0ms should be red-ish, got ({}, {}, {})",
        red_start,
        green_start,
        blue_start
    );

    // At t=1000ms: hue should wrap back to 0 (red again)
    let commands_end = engine.update(Duration::from_millis(1000), None).unwrap();
    let red_end = commands_end
        .iter()
        .find(|cmd| cmd.channel == 2)
        .unwrap()
        .value;
    let green_end = commands_end
        .iter()
        .find(|cmd| cmd.channel == 3)
        .unwrap()
        .value;
    let blue_end = commands_end
        .iter()
        .find(|cmd| cmd.channel == 4)
        .unwrap()
        .value;

    // Should be back to approximately red
    assert!(
        red_end > 200 && green_end < 50 && blue_end < 50,
        "At t=1000ms should wrap back to red-ish, got ({}, {}, {})",
        red_end,
        green_end,
        blue_end
    );

    // Colors at start and end should be very similar (wrapped)
    assert!(
        (red_start as i16 - red_end as i16).abs() < 10,
        "Red should be similar after full cycle"
    );
}

#[test]
fn test_rainbow_effect() {
    let mut engine = EffectEngine::new();
    let fixture = create_test_fixture("test_fixture", 1, 1);
    engine.register_fixture(fixture);

    let effect = EffectInstance::new(
        "test_effect".to_string(),
        EffectType::Rainbow {
            speed: TempoAwareSpeed::Fixed(1.0),
            saturation: 1.0,
            brightness: 1.0,
            duration: Duration::from_secs(10),
        },
        vec!["test_fixture".to_string()],
        None,
        None,
        None,
    );

    engine.start_effect(effect).unwrap();

    // Update the engine
    let commands = engine.update(Duration::from_millis(16), None).unwrap();

    // Should have RGB commands
    assert_eq!(commands.len(), 3);

    let red_cmd = commands.iter().find(|cmd| cmd.channel == 2);
    let green_cmd = commands.iter().find(|cmd| cmd.channel == 3);
    let blue_cmd = commands.iter().find(|cmd| cmd.channel == 4);

    assert!(red_cmd.is_some());
    assert!(green_cmd.is_some());
    assert!(blue_cmd.is_some());
}