fixes #114, add a simple click sound

Author: yjpark

crates/notation_bevy/src/viewer/control_view.rs

@@ -186,13 +186,17 @@ impl ControlView {
             }
             if !midi_settings.bypass_hub {
                 ui.separator();
+                ui.horizontal(|ui| {
+                    ui.checkbox(&mut midi_settings.click_mute, "Mute");
+                    ui.add(Slider::new(&mut midi_settings.click_velocity, 0..=127).text("Click"));
+                });
                 ui.horizontal(|ui| {
                     ui.checkbox(&mut midi_settings.vocal_mute, "Mute");
-                    ui.add(Slider::new(&mut midi_settings.vocal_velocity, 0..=128).text("Vocal"));
+                    ui.add(Slider::new(&mut midi_settings.vocal_velocity, 0..=127).text("Vocal"));
                 });
                 ui.horizontal(|ui| {
                     ui.checkbox(&mut midi_settings.guitar_mute, "Mute");
-                    ui.add(Slider::new(&mut midi_settings.guitar_velocity, 0..=128).text("Guitar"));
+                    ui.add(Slider::new(&mut midi_settings.guitar_velocity, 0..=127).text("Guitar"));
                 });
                 if ui.button("Reset Audio").clicked() {
                     let default = MidiSettings::default();

crates/notation_core/src/entry.rs

@@ -1,5 +1,6 @@
 use crate::prelude::{Duration, Units};
 
+#[derive(Copy, Clone, Debug)]
 pub enum EntryPassMode {
     Immediate,
     Delayed,

crates/notation_core/src/scale.rs

@@ -1,7 +1,7 @@
 use serde::{Deserialize, Serialize};
 use std::fmt::Display;
 
-use crate::prelude::{Key, Note, Pitch, Semitones, Syllable, SyllableNote, Chord};
+use crate::{prelude::{Key, Note, Pitch, Semitones, Syllable, SyllableNote, Chord, Octave}, tone::Tone};
 
 // https://hellomusictheory.com/learn/music-scales-beginners-guide/
 #[derive(Copy, Clone, PartialEq, Eq, Serialize, Deserialize, Debug)]
@@ -95,4 +95,11 @@ impl Scale {
     pub fn calc_note(&self, key: &Key, syllable_note: &SyllableNote) -> Note {
         (Semitones::from(*syllable_note) + self.calc_do_semitones(key)).into()
     }
+    pub fn calc_click_note(&self, key: &Key, octave: &Octave, syllable: &Syllable) -> Note {
+        let pitch = self.calc_pitch(key, syllable);
+        Note::new(*octave, pitch)
+    }
+    pub fn calc_click_tone(&self, key: &Key, octave: &Octave, syllable: &Syllable) -> Tone {
+        Tone::Single(self.calc_click_note(key, octave, syllable))
+    }
 }

crates/notation_midi/src/midi_hub.rs

@@ -19,6 +19,8 @@ impl Default for MidiHub {
 }
 
 impl MidiHub {
+    pub const PRINT_SYNTH_ERROR: bool = false;
+    pub const PRINT_MIDI_ERROR: bool = false;
     pub fn new_output() -> Option<MidiOutput> {
         if let Ok(output) = MidiOutput::new("MidiHub") {
             let ports = output.ports();
@@ -81,13 +83,17 @@ impl MidiHub {
         if let Some(synth) = &self.output_synth {
             //println!("send to synth: {:?}", msg);
             if let Err(err) = synth.send(speed, msg, velocity) {
-                println!("send to synth failed: {:?} -> {:?}", msg, err);
+                if Self::PRINT_SYNTH_ERROR {
+                    println!("send to synth failed: {:?} -> {:?}", msg, err);
+                }
             }
         }
         if let Some(conn) = &self.output_conn {
             //println!("send to midi: {:?}", msg);
             if let Err(err) = conn.lock().unwrap().send(&msg.to_midi()) {
-                println!("send to midi failed: {:?} -> {:?}", msg, err);
+                if Self::PRINT_MIDI_ERROR {
+                    println!("send to midi failed: {:?} -> {:?}", msg, err);
+                }
             }
         }
     }

crates/notation_midi/src/midi_message.rs

@@ -1,26 +1,37 @@
-use std::sync::Arc;
-
 use helgoboss_midi::{ShortMessage, StructuredShortMessage};
 use notation_model::prelude::*;
 
 #[derive(Clone, Debug)]
 pub struct MidiMessage {
-    pub entry: Arc<LaneEntry>,
-    pub delay: Option<Units>,
+    pub pass_mode: EntryPassMode,
+    pos: BarPosition,
+    delay: Option<Units>,
     pub midi: StructuredShortMessage,
 }
 impl MidiMessage {
-    pub fn new(entry: &Arc<LaneEntry>, delay: Option<Units>, midi: StructuredShortMessage) -> Self {
+    pub fn new(pass_mode: EntryPassMode, pos: BarPosition, delay: Option<Units>, midi: StructuredShortMessage) -> Self {
         Self {
-            entry: entry.clone(),
+            pass_mode,
+            pos,
             delay,
             midi,
         }
     }
+    pub fn of_entry(entry: &LaneEntry, delay: Option<Units>, midi: StructuredShortMessage) -> Self {
+        Self {
+            pass_mode: entry.pass_mode(),
+            pos: entry.bar_position(),
+            delay,
+            midi,
+        }
+    }
+    pub fn bar_ordinal(&self) -> usize {
+        self.pos.bar_ordinal
+    }
     pub fn bar_position(&self) -> BarPosition {
         match self.delay {
-            Some(delay) => self.entry.bar_position().with_delay(delay),
-            None => self.entry.bar_position(),
+            Some(delay) => self.pos.with_delay(delay),
+            None => self.pos,
         }
     }
     pub fn units_position(&self) -> Units {

crates/notation_midi/src/midi_settings.rs

@@ -1,5 +1,5 @@
 use midi_msg::GMSoundSet;
-use notation_model::prelude::TrackKind;
+use notation_model::prelude::{TrackKind, Octave};
 
 #[cfg(feature = "inspector")]
 use bevy_inspector_egui::Inspectable;
@@ -8,13 +8,17 @@ use bevy_inspector_egui::Inspectable;
 #[cfg_attr(feature = "inspector", derive(Inspectable))]
 pub struct MidiSettings {
     pub bypass_hub: bool,
+    pub click_mute: bool,
+    pub click_velocity: u8,
+    pub click_octave: Octave,
     pub vocal_mute: bool,
     pub vocal_velocity: u8,
     pub guitar_mute: bool,
     pub guitar_velocity: u8,
     pub piano_mute: bool,
     pub piano_velocity: u8,
     pub use_internal_synth: bool,
+    pub click_sound: u8,
     pub vocal_sound: u8,
     pub guitar_sound: u8,
     pub piano_sound: u8,
@@ -26,13 +30,17 @@ impl Default for MidiSettings {
     fn default() -> Self {
         Self {
             bypass_hub: false,
+            click_mute: false,
+            click_velocity: 40,
+            click_octave: Octave::P7,
             vocal_mute: false,
             vocal_velocity: 110,
             guitar_mute: false,
             guitar_velocity: 120,
             piano_mute: false,
             piano_velocity: 110,
             use_internal_synth: Self::default_use_internal_synth(),
+            click_sound: GMSoundSet::Dulcimer as u8,
             vocal_sound: GMSoundSet::Cello as u8,
             guitar_sound: GMSoundSet::AcousticGuitarSteel as u8,
             piano_sound: GMSoundSet::AcousticGrandPiano as u8,
@@ -59,4 +67,7 @@ impl MidiSettings {
             _ => None,
         }
     }
+    pub fn get_click_channel_params(&self) -> (u8, u8) {
+        (self.click_sound, self.click_velocity)
+    }
 }

crates/notation_midi/src/midi_state.rs

@@ -106,28 +106,33 @@ impl MidiChannel {
         };
         let mut velocity = self.velocity.into();
         if !bypass {
-            self.track.as_ref().map(|x| {
-                match x.kind {
-                    TrackKind::Vocal => {
-                        velocity = if settings.vocal_mute { 0 } else { settings.vocal_velocity };
-                    },
-                    TrackKind::Guitar => {
-                        velocity = if settings.guitar_mute { 0 } else { settings.guitar_velocity };
-                    },
-                    TrackKind::Piano => {
-                        velocity = if settings.piano_mute { 0 } else { settings.piano_velocity };
-                    },
-                    _ => (),
+            match &self.track {
+                Some(track) => {
+                    match track.kind {
+                        TrackKind::Vocal => {
+                            velocity = if settings.vocal_mute { 0 } else { settings.vocal_velocity };
+                        },
+                        TrackKind::Guitar => {
+                            velocity = if settings.guitar_mute { 0 } else { settings.guitar_velocity };
+                        },
+                        TrackKind::Piano => {
+                            velocity = if settings.piano_mute { 0 } else { settings.piano_velocity };
+                        },
+                        _ => (),
+                    }
+                },
+                None => {
+                    velocity = if settings.click_mute { 0 } else { settings.click_velocity };
                 }
-            });
+            }
         }
         let mut count = 0;
         loop {
             if let Some(next) = self.messages.get(self.next_index) {
-                if play_control.is_bar_in_range(next.entry.bar_props().bar_ordinal)
+                if play_control.is_bar_in_range(next.bar_ordinal())
                     && play_control
                         .position
-                        .is_passed(next.entry.pass_mode(), &next.bar_position())
+                        .is_passed(next.pass_mode, &next.bar_position())
                 {
                     self.next_index += 1;
                     count += 1;
@@ -156,7 +161,7 @@ impl MidiChannel {
             hub.send(
                 settings,
                 speed,
-                &MidiMessage::new(&first_msg.entry, None, msg),
+                &MidiMessage::new(first_msg.pass_mode, first_msg.bar_position(), None, msg),
                 self.velocity.into(),
             );
             let msg = StructuredShortMessage::ControlChange {
@@ -167,7 +172,7 @@ impl MidiChannel {
             hub.send(
                 settings,
                 speed,
-                &MidiMessage::new(&first_msg.entry, None, msg),
+                &MidiMessage::new(first_msg.pass_mode, first_msg.bar_position(), None, msg),
                 self.velocity.into(),
             );
         }
@@ -183,6 +188,16 @@ impl MidiChannel {
         self.program = U7::new(params.0);
         self.velocity = U7::new(params.1);
     }
+    pub fn setup_no_track(
+        &mut self,
+        _settings: &MidiSettings,
+        _hub: &mut MidiHub,
+        params: (u8, u8),
+    ) {
+        self.track = None;
+        self.program = U7::new(params.0);
+        self.velocity = U7::new(params.1);
+    }
 }
 
 pub struct MidiState {
@@ -241,10 +256,37 @@ impl MidiState {
         }
         None
     }
+    fn create_click_channel(&mut self, settings: &MidiSettings, hub: &mut MidiHub, tab: &Tab, index: &mut usize) {
+        let params = settings.get_click_channel_params();
+        if let Some(channel) = self.channels.get_mut(*index) {
+            channel.setup_no_track(settings, hub, params);
+            println!("switch_tab(), setup click channel: [{}] -> {}, {}", index, params.0, params.1);
+            *index += 1;
+            let scale_root = tab.meta.scale.calc_root_syllable();
+            let signature = tab.signature();
+            let bar_units = tab.bar_units();
+            let beat_delay = Some(Units::from(signature.beat_unit));
+            for bar in tab.bars.iter() {
+                for beat in 0..signature.bar_beats {
+                    let in_bar_pos = Units(beat as f32 * Units::from(signature.beat_unit).0);
+                    let root = bar.get_chord(Some(in_bar_pos)).map(|x| x.root).unwrap_or(scale_root);
+                    let note = tab.meta.scale.calc_click_note(&tab.meta.key, &settings.click_octave, &root);
+                    let pos = BarPosition::new(bar_units, bar.props.bar_ordinal, in_bar_pos);
+                    if let Some(midi_msg) = MidiUtil::note_midi_on_msg(&note, channel.channel, channel.velocity) {
+                        channel.add_message(MidiMessage::new(EntryPassMode::Immediate, pos, None, midi_msg));
+                    }
+                    if let Some(midi_msg) = MidiUtil::note_midi_off_msg(&note, channel.channel, channel.velocity) {
+                        channel.add_message(MidiMessage::new(EntryPassMode::Immediate, pos, beat_delay, midi_msg));
+                    }
+                }
+            }
+        }
+    }
     pub fn switch_tab(&mut self, settings: &MidiSettings, hub: &mut MidiHub, tab: Arc<Tab>) {
         self.tab = Some(tab.clone());
         self.reset_channels();
         let mut index: usize = 0;
+        self.create_click_channel(settings, hub, &tab, &mut index);
         for track in tab.tracks.iter() {
             if index >= self.channels.len() {
                 return;
@@ -263,7 +305,7 @@ impl MidiState {
                     for entry in lane.entries.iter() {
                         if let Some(msgs) = MidiUtil::get_midi_msgs(channel, bar, &entry) {
                             for msg in msgs {
-                                channel.add_message(MidiMessage::new(entry, msg.0, msg.1));
+                                channel.add_message(MidiMessage::of_entry(entry, msg.0, msg.1));
                             }
                         }
                     }