nooise 1.9.0

Ambient music generator for the terminal
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
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203

//! The Arp voice: cycles the Pad's current chord tones on its own grid.

use super::*;

pub(crate) const ARP_RATE_BEATS_MIN: f32 = 0.125;
pub(crate) const ARP_RATE_BEATS_MAX: f32 = 4.0;
pub(crate) const ARP_OCTAVES_MIN: f32 = 1.0;
pub(crate) const ARP_OCTAVES_MAX: f32 = 3.0;
pub(crate) const ARP_CHORD_TONES: usize = 4;

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum ArpPattern {
    Up,
    Down,
    UpDown,
    Random,
}

pub(crate) fn arp_pattern_index(value: f32) -> usize {
    (value.round() as i64).rem_euclid(4) as usize
}

pub(crate) fn arp_pattern_from_control(value: f32) -> ArpPattern {
    match arp_pattern_index(value) {
        0 => ArpPattern::Up,
        1 => ArpPattern::Down,
        2 => ArpPattern::UpDown,
        _ => ArpPattern::Random,
    }
}

pub(crate) fn arp_pattern_label(value: f32) -> &'static str {
    match arp_pattern_from_control(value) {
        ArpPattern::Up => "Up",
        ArpPattern::Down => "Down",
        ArpPattern::UpDown => "Up-Down",
        ArpPattern::Random => "Random",
    }
}

pub(crate) fn arp_octave_span(value: f32) -> usize {
    (value.round() as i32).clamp(ARP_OCTAVES_MIN as i32, ARP_OCTAVES_MAX as i32) as usize
}

/// Build the cycled tone list for a chord: the 4 chord tones duplicated up
/// whole octaves (+12, +24 semitones) for each extra octave of span, sorted
/// ascending. Span 1 keeps just the 4 chord tones; span 3 yields 12 tones.
pub(crate) fn arp_cycle_notes(chord: [i32; ARP_CHORD_TONES], octaves: usize) -> Vec<i32> {
    let mut notes = Vec::with_capacity(ARP_CHORD_TONES * octaves.max(1));
    for octave in 0..octaves.max(1) {
        for tone in chord {
            notes.push(tone + 12 * octave as i32);
        }
    }
    notes.sort_unstable();
    notes
}

/// Advance the ping-pong (up-down) cursor by one step without repeating
/// either endpoint: bounces at 0 and `len - 1`, reversing direction there.
pub(crate) fn arp_ping_pong_advance(pos: usize, dir: i32, len: usize) -> (usize, i32) {
    if len <= 1 {
        return (0, dir);
    }
    let proposed = pos as i32 + dir;
    if proposed < 0 {
        (1, 1)
    } else if proposed >= len as i32 {
        (len - 2, -1)
    } else {
        (proposed as usize, dir)
    }
}

/// Compute the next cycle position (and, for Up-Down, the next travel
/// direction) after emitting the tone at `pos`. `len` is the current cycle
/// list length; `rng` is only consumed by the Random pattern. Shared by
/// `ArpEngine::next` and its tests so pattern-sequencing logic is exercised
/// exactly as production runs it.
pub(crate) fn arp_advance(
    pos: usize,
    pattern: ArpPattern,
    len: usize,
    dir: i32,
    rng: &mut StdRng,
) -> (usize, i32) {
    match pattern {
        ArpPattern::Up => ((pos + 1) % len, dir),
        ArpPattern::Down => ((pos + len - 1) % len, dir),
        ArpPattern::UpDown => arp_ping_pong_advance(pos, dir, len),
        ArpPattern::Random => (rng.gen_range(0..len), dir),
    }
}

pub(crate) struct ArpEngine {
    pub(crate) sample_rate: f32,
    pub(crate) chord_trigger: GridTrigger,
    pub(crate) step_index: usize,
    pub(crate) active_chord_count: Option<usize>,
    pub(crate) active_progression: Option<usize>,
    pub(crate) note_trigger: GridTrigger,
    pub(crate) cycle_pos: usize,
    pub(crate) ping_pong_dir: i32,
    pub(crate) voices: Vec<TonalVoice>,
    pub(crate) rng: StdRng,
}

impl ArpEngine {
    pub(crate) fn new(sample_rate: f32) -> Self {
        Self {
            sample_rate,
            chord_trigger: GridTrigger::after_start(),
            step_index: 0,
            active_chord_count: None,
            active_progression: None,
            note_trigger: GridTrigger::new(),
            cycle_pos: 0,
            ping_pong_dir: 1,
            voices: Vec::with_capacity(8),
            rng: StdRng::from_entropy(),
        }
    }

    pub(crate) fn next(
        &mut self,
        c: &ArpControls,
        pad: &PadControls,
        tune: f32,
        timing: TimingContext,
    ) -> (f32, f32) {
        // Follow the pad's current chord: an independent trigger synced to
        // the same chord-length grid as the pad/bass engines, so this
        // engine's step_index always matches the pad's, without reaching
        // into the pad engine directly. `pad_chord_tones` is the same
        // chord-source path Pad and Bass resolve through, so a custom
        // progression drives all three identically.
        let active_chord_count = self.active_chord_count.get_or_insert(pad_chord_count(pad));
        let progression = progression_index(pad.progression);
        let active_progression = self.active_progression.get_or_insert(progression);
        advance_pad_progression(
            &mut self.step_index,
            active_chord_count,
            active_progression,
            pad_chord_count(pad),
            progression,
            self.chord_trigger.pop(timing, pad.chord_bars * 4.0, 0.0),
        );

        let rate_beats = c.rate_beats.clamp(ARP_RATE_BEATS_MIN, ARP_RATE_BEATS_MAX);
        if self
            .note_trigger
            .pop_swung(timing, rate_beats, c.offset_beats, c.swing)
        {
            let chord = pad_chord_tones(pad, *active_progression, self.step_index);
            let octaves = arp_octave_span(c.octaves);
            let notes = arp_cycle_notes(chord, octaves);
            let len = notes.len().max(1);
            // Chord/octave changes never reset the cycle position — just
            // clamp it into the (possibly resized) list so there's no click.
            self.cycle_pos = self.cycle_pos.min(len - 1);

            let pattern = arp_pattern_from_control(c.pattern);
            let note = notes[self.cycle_pos];

            let (next_pos, next_dir) = arp_advance(
                self.cycle_pos,
                pattern,
                len,
                self.ping_pong_dir,
                &mut self.rng,
            );
            self.cycle_pos = next_pos;
            self.ping_pong_dir = next_dir;

            let hz = midi_to_hz(note) * tune_ratio(tune);
            // A note sounds for `attack + decay`, decoupled from the step grid,
            // so a longer decay lets consecutive notes overlap and ring out
            // instead of being cut at the step. `rate_beats` only sets the
            // trigger spacing below.
            let pan = self.rng.gen_range(-0.4f32..0.4);
            // A voice captures its gain at trigger time, so a gain of exactly
            // 0 (the default) would stay silent for its whole life — skip
            // creating it. Every RNG draw above still happens, keeping seeded
            // renders byte-identical.
            if c.gain != 0.0 {
                self.voices.push(TonalVoice::new(
                    tonal_synth_type_index(c.voice_type),
                    TonalNote {
                        midi: note,
                        hz,
                        pan,
                        level: c.gain,
                        sample_rate: self.sample_rate,
                        attack_time: c.attack,
                        decay_time: c.decay,
                    },
                ));
            }
        }

        mix_and_retain(&mut self.voices, TonalVoice::next, TonalVoice::is_done)
    }
}