fixes #121, adjust guitar view y based on shape and pick, the logic is a bit messy, and might got corner cases not covered

Author: yjpark

apps/notation_viewer/assets/tabs/test.ron

@@ -240,7 +240,7 @@ fn handle_keyboard_inputs(
     if app_state.tab.is_none() {
         return;
     }
-    if keyboard_input.just_released(KeyCode::LControl) {
+    if keyboard_input.just_released(KeyCode::Tab) {
         app_state.hide_control = !app_state.hide_control;
         if !ControlView::HUD_MODE {
             window_resized_evts.send(WindowResizedEvent());

crates/notation_bevy/src/app/app.rs

@@ -17,7 +17,6 @@ pub struct FretFingerExtra {
     pub fret: Option<u8>,
     pub finger: Option<Finger>,
     pub capo: u8,
-    pub barre: u8,
     pub in_chord: bool,
     pub guitar_size: LayoutSize,
 }
@@ -33,7 +32,6 @@ impl FretFingerExtra {
             fret,
             finger,
             capo: 0,
-            barre: 0,
             in_chord: false,
             guitar_size: LayoutSize::ZERO,
         }
@@ -142,7 +140,7 @@ impl FretFingerData {
         if self.value.extra.pick {
             self.value.extra.fret = pick_note.and_then(|x| x.fret);
         } else {
-            self.value.extra.fret = shape.string_fret(self.value.extra.string);
+            self.value.extra.fret = shape.string_fret_with_barre(self.value.extra.string);
         }
         if let Some(fretboard) = fretboard {
             self.value.extra.capo = fretboard.capo;
@@ -153,7 +151,6 @@ impl FretFingerData {
             };
             self.set_chord_meta_note(chord, meta, note);
         }
-        self.value.extra.barre = shape.barre.unwrap_or(0);
     }
     pub fn update_with_syllable(
         &self,
@@ -165,7 +162,7 @@ impl FretFingerData {
     ) {
         self.update(commands, theme, entity);
         let scale = theme.guitar.calc_scale(self.value.extra.guitar_size.width);
-        if settings.show_guitar_syllable {
+        if settings.show_guitar_syllable && self.value.extra.fret.is_some() {
             theme.guitar.syllable_text.spawn_scaled_syllable_text(commands, entity, assets, settings, &self.value.calc_syllable(), scale)
         }
     }
@@ -186,7 +183,7 @@ impl ChordNoteExtra for FretFingerExtra {
         let fret = self.fret.unwrap_or(0);
         let y = theme
             .guitar
-            .calc_fret_y(fret + self.capo + self.barre, self.guitar_size.height);
+            .calc_fret_y(fret + self.capo, self.guitar_size.height);
         Vec2::new(x, y)
     }
     fn get_color(&self, theme: &NotationTheme, color: Color) -> Color {

crates/notation_bevy/src/guitar/fret_finger.rs

@@ -1,40 +1,63 @@
 use bevy::prelude::*;
 use bevy_prototype_lyon::prelude::*;
 use notation_bevy_utils::prelude::{BevyUtil, FillRectangle, LayoutSize, ShapeOp};
+use notation_model::prelude::{HandShape6, Pick};
 
 use crate::prelude::{NotationTheme};
 
 #[derive(Clone, Debug)]
 pub struct GuitarBarreData {
     pub capo: u8,
-    pub barre: u8,
+    pub shape: Option<HandShape6>,
+    pub pick: Option<Pick>,
     pub view_size: LayoutSize,
     pub guitar_size: LayoutSize,
 }
 
-impl GuitarBarreData {
-    pub fn new(capo: u8, barre: u8) -> Self {
+impl Default for GuitarBarreData {
+    fn default() -> Self {
         Self {
-            capo,
-            barre,
+            capo: 0,
+            shape: None,
+            pick: None,
             view_size: LayoutSize::ZERO,
             guitar_size: LayoutSize::ZERO,
         }
     }
 }
+impl GuitarBarreData {
+    pub fn update_pick(&mut self, pick: &Pick) {
+        if self.pick.is_none() || self.pick.unwrap().max_fret() < pick.max_fret() {
+            self.pick = Some(pick.clone());
+        }
+    }
+    pub fn barre(&self) -> u8 {
+        self.shape.and_then(|x| x.barre).unwrap_or(0)
+    }
+    pub fn max_fret(&self) -> u8 {
+        let mut max = self.shape.map(|x| x.max_fret_with_barre()).unwrap_or(0);
+        if let Some(pick) = self.pick {
+            let pick_max = pick.max_fret();
+            if pick_max > max {
+                max = pick_max
+            }
+        }
+        max + self.capo
+    }
+}
 
 impl ShapeOp<NotationTheme, FillRectangle> for GuitarBarreData {
     fn get_shape(&self, theme: &NotationTheme) -> FillRectangle {
         let width = self.guitar_size.width * theme.guitar.barre_width_factor;
         let height = self.guitar_size.height * theme.guitar.barre_height_factor;
         let color = theme.colors.strings.barre;
-        let offset = if self.barre == 0 || self.guitar_size.width <= 0.0 {
+        let offset = if self.barre() == 0 || self.guitar_size.width <= 0.0 {
             BevyUtil::offscreen_offset()
         } else {
             let finger_radius = theme.guitar.string_x_factor * self.guitar_size.width / 2.0;
             let y = theme
                 .guitar
-                .calc_fret_y(self.capo + self.barre, self.guitar_size.height)
+                .calc_fret_y(self.capo + self.barre(), self.guitar_size.height)
                 + height * 0.5
                 - finger_radius;
             Vec3::new(0.0, y, theme.z.guitar_barre)

crates/notation_bevy/src/guitar/guitar_barre.rs

@@ -11,10 +11,10 @@ pub struct GuitarCapoData {
     pub guitar_size: LayoutSize,
 }
 
-impl GuitarCapoData {
-    pub fn new(capo: u8) -> Self {
+impl Default for GuitarCapoData {
+    fn default() -> Self {
         Self {
-            capo,
+            capo: 0,
             view_size: LayoutSize::ZERO,
             guitar_size: LayoutSize::ZERO,
         }

crates/notation_bevy/src/guitar/guitar_capo.rs

@@ -126,7 +126,7 @@ impl GuitarStringData {
     ) {
         let pick_note = pick.and_then(|x| x.get_pick_note(self.string));
         self.pick_fret = pick_note.and_then(|x| x.fret);
-        self.fret = shape.string_fret(self.string);
+        self.fret = shape.string_fret_with_barre(self.string);
         if let Some(fretboard) = fretboard {
             self.capo = fretboard.capo;
         } else {

crates/notation_bevy/src/guitar/guitar_string.rs

@@ -78,9 +78,9 @@ impl GuitarView {
                 );
             }
         }
-        let capo_data = GuitarCapoData::new(0);
+        let capo_data = GuitarCapoData::default();
         capo_data.create(commands, theme, guitar_entity);
-        let barre_data = GuitarBarreData::new(0, 0);
+        let barre_data = GuitarBarreData::default();
         barre_data.create(commands, theme, guitar_entity);
         if Self::CHECKING_FRETS {
             let mut string = 1;
@@ -186,6 +186,7 @@ impl GuitarView {
         query: Query<(&Arc<LaneEntry>, &Pick, &EntryPlaying), Changed<EntryPlaying>>,
         mut string_query: Query<(Entity, &mut GuitarStringData), With<GuitarStringData>>,
         mut finger_query: Query<(Entity, &mut FretFingerData), With<FretFingerData>>,
+        mut barre_query: Query<(Entity, &mut GuitarBarreData), With<GuitarBarreData>>,
         dot_query: Query<&Children>,
     ) {
         if Self::CHECKING_FRETS {
@@ -246,6 +247,9 @@ impl GuitarView {
                     finger_data.update_with_syllable(&mut commands, &assets, &theme, &settings, finger_entity);
                 }
             }
+            for (_barre_entity, mut barre_data) in barre_query.iter_mut() {
+                barre_data.update_pick(pick);
+            }
         }
     }
     pub fn update_hand_shape6(
@@ -311,19 +315,15 @@ impl GuitarView {
                         capo_data.update(&mut commands, &theme, capo_entity);
                     }
                 }
-                let barre = shape.barre.unwrap_or(0);
                 for (barre_entity, mut barre_data) in barre_query.iter_mut() {
-                    if fretboard.capo != barre_data.capo ||
-                            barre != barre_data.barre {
-                        barre_data.capo = fretboard.capo;
-                        barre_data.barre = barre;
-                        barre_data.update(&mut commands, &theme, barre_entity);
-                    }
+                    barre_data.capo = fretboard.capo;
+                    barre_data.shape = Some(shape.clone());
+                    barre_data.pick = None;
+                    barre_data.update(&mut commands, &theme, barre_entity);
                 }
             }
         } else {
-            let position =
-                TabState::get_position(&tab_state_query, None);
+            let position = TabState::get_position(&tab_state_query, None);
             if position.is_some() && position.unwrap().bar.bar_ordinal == 0 {
                 for (finger_entity, mut finger_data) in finger_query.iter_mut() {
                     finger_data.reset();
@@ -333,6 +333,13 @@ impl GuitarView {
                     string_data.reset();
                     string_data.update(&mut commands, &theme, string_entity);
                 }
+                for (barre_entity, mut barre_data) in barre_query.iter_mut() {
+                    if barre_data.shape.is_some() {
+                        barre_data.shape = None;
+                        barre_data.pick = None;
+                        barre_data.update(&mut commands, &theme, barre_entity);
+                    }
+                }
             }
         }
     }
@@ -342,36 +349,57 @@ impl GuitarView {
     ) {
         if let Ok(mut transform) = guitar_view_query.single_mut() {
             let trans = transform.translation;
-            println!("GuitarView::update_y {} -> {}", trans.y, y);
             if float_ne!(trans.y, y, abs <= 0.01) {
+                println!("GuitarView::update_y {} -> {}", trans.y, y);
                 *transform = Transform::from_xyz(trans.x, y, trans.z);
             }
         }
     }
-    pub fn adjust_y_by_capo(
+    pub fn adjust_y_by_frets(
+        theme: &NotationTheme,
+        guitar_view_query: &mut Query<&mut Transform, With<Arc<GuitarView>>>,
+        view_size: LayoutSize,
+        guitar_size: LayoutSize,
+        min_fret: u8,
+        max_fret: u8,
+    ) {
+        let calc_y = |fret:u8| {
+            let fret_y = theme
+                    .guitar
+                    .calc_fret_y(fret, guitar_size.height);
+            -(fret_y + guitar_size.height * theme.guitar.capo_height_factor)
+        };
+        let top_y = calc_y(min_fret);
+        let bottom_y = calc_y(max_fret + 1);
+        let y = if bottom_y - top_y > view_size.height {
+            bottom_y - view_size.height
+        } else {
+            top_y
+        };
+        println!("GuitarView::adjust_y_by_frets {} {} [{} - {}] -> {} {} -> {}", view_size, guitar_size, min_fret, max_fret, top_y, bottom_y, y);
+        Self::update_y(guitar_view_query, y);
+    }
+    pub fn adjust_y_by_barre(
         theme: Res<NotationTheme>,
         settings: Res<NotationSettings>,
-        capo_query: Query<&GuitarCapoData, Changed<GuitarCapoData>>,
+        barre_query: Query<&GuitarBarreData, Changed<GuitarBarreData>>,
         mut guitar_view_query: Query<&mut Transform, With<Arc<GuitarView>>>,
     ) {
+        if Self::CHECKING_FRETS {
+            return;
+        }
         if theme._bypass_systems { return; }
         if settings.override_guitar_y.is_some() {
             return;
         }
-        for capo_data in capo_query.iter() {
-            if capo_data.view_size.height <= 0.0 {
-                return;
-            }
-            let y = if capo_data.view_size.height > capo_data.guitar_size.height {
-                -capo_data.guitar_size.height / 2.0
+        for barre_data in barre_query.iter() {
+            if barre_data.view_size.height > barre_data.guitar_size.height {
+                Self::update_y(&mut guitar_view_query, -barre_data.guitar_size.height / 2.0);
             } else {
-                let capo_y = theme
-                        .guitar
-                        .calc_fret_y(capo_data.capo, capo_data.guitar_size.height);
-                -(capo_y + capo_data.guitar_size.height * theme.guitar.capo_height_factor)
-            };
-            println!("adjust_y_by_capo {} {} {} -> {}", capo_data.guitar_size, capo_data.view_size, capo_data.capo, y);
-            Self::update_y(&mut guitar_view_query, y);
+                let min_fret = barre_data.capo;
+                let max_fret = barre_data.max_fret();
+                Self::adjust_y_by_frets(&theme, &mut guitar_view_query, barre_data.view_size, barre_data.guitar_size, min_fret, max_fret);
+            }
         }
     }
 }

crates/notation_bevy/src/guitar/guitar_view.rs

@@ -44,7 +44,7 @@ impl Plugin for TabViewerPlugin {
                 .with_system(GuitarView::on_layout_changed.system())
                 .with_system(GuitarView::update_hand_shape6.system().label("GuitarView::update_hand_shape6"))
                 .with_system(GuitarView::update_string_state.system().label("GuitarView::update_string_state").after("GuitarView::update_hand_shape6"))
-                .with_system(GuitarView::adjust_y_by_capo.system())
+                .with_system(GuitarView::adjust_y_by_barre.system())
                 .with_system(TabViewer::do_layout.system()),
         );
     }

crates/notation_bevy/src/ui/viewer.rs

@@ -61,6 +61,11 @@ pub struct Units(pub f32);
 impl Units {
     pub const _MIN_ACCURACY: f32 = 0.00001;
     pub const MIN_ACCURACY: Units = Units(Self::_MIN_ACCURACY);
+    /*
+     * This i quite messy here, the pasition passed checking needs some cleanup,
+     * mainly for control the guitar view timing, and seeking next note
+     */
+    pub const HALF_MIN_ACCURACY: Units = Units(Self::_MIN_ACCURACY * 0.5);
 
     pub fn is_bigger_than(&self, other: &Units) -> bool {
         self.0 > other.0 + Self::_MIN_ACCURACY

crates/notation_core/src/duration.rs

@@ -72,12 +72,12 @@ macro_rules! impl_fretboard {
             }
             pub fn shape_note(&self, shape: &$hand_shape, string: u8) -> Option<Note> {
                 shape
-                    .string_fret(string)
+                    .string_fret_with_barre(string)
                     .and_then(|fret| self.fretted_note(string, fret))
             }
             pub fn shape_fret_note(&self, shape: &$hand_shape, string: u8) -> Option<(u8, Note)> {
                 shape
-                    .string_fret(string)
+                    .string_fret_with_barre(string)
                     .and_then(|fret| self.fretted_note(string, fret).map(|n| (fret, n)))
             }
             pub fn shape_pick_note(