show chord color in BarIndicator

yjpark · yjpark · commit 58a2edd5f6f0 · 2021-12-12T13:21:00.000+08:00
diff --git a/crates/notation_bevy/src/chord/chord_playing.rs b/crates/notation_bevy/src/chord/chord_playing.rs
@@ -26,7 +26,8 @@ impl ChordPlaying {
         query: &mut Query<(Entity, &mut ChordPlaying), With<ChordPlaying>>,
         tab_state: &TabState,
         new_position: &Position,
-    ) {
+    ) -> usize {
+        let mut changed = 0;
         let is_current = |c: Chord| {
             if tab_state.play_control.play_state.is_playing() {
                 let chord = tab_state
@@ -51,12 +52,15 @@ impl ChordPlaying {
             if is_current(chord_playing.value.chord) {
                 if chord_playing.value.state != PlayingState::Current {
                     chord_playing.value.state = PlayingState::Current;
+                    changed += 1;
                 }
             } else {
                 if chord_playing.value.state != PlayingState::Idle {
                     chord_playing.value.state = PlayingState::Idle;
+                    changed += 1;
                 }
             }
         }
+        changed
     }
 }
diff --git a/crates/notation_bevy/src/play/bar_indicator.rs b/crates/notation_bevy/src/play/bar_indicator.rs
@@ -1,21 +1,26 @@
+use std::sync::Arc;
 use bevy::prelude::*;
 use bevy_prototype_lyon::prelude::*;
 use notation_bevy_utils::prelude::{BevyUtil, LayoutData, StrokeRectangle, ShapeOp};
-use notation_model::prelude::TabBarProps;
+use notation_model::prelude::{TabBarProps, Chord, Tab, Units};
 
 use crate::prelude::{NotationTheme};
 
 #[derive(Clone, Debug)]
 pub struct BarIndicatorData {
+    pub tab: Arc<Tab>,
     pub bar_props: TabBarProps,
     pub bar_layout: LayoutData,
+    pub chord: Option<Chord>,
 }
 
 impl BarIndicatorData {
-    pub fn new() -> Self {
+    pub fn new(tab: Arc<Tab>) -> Self {
         BarIndicatorData {
+            tab,
             bar_props: TabBarProps::default(),
             bar_layout: LayoutData::ZERO,
+            chord: None,
         }
     }
 }
@@ -29,13 +34,50 @@ impl ShapeOp<NotationTheme, StrokeRectangle> for BarIndicatorData {
             let y = self.bar_layout.offset.y + theme.sizes.bar.bar_separator_extra;
             Vec3::new(x, y, theme.core.bar_indicator_z)
         };
+        let color = theme
+            .colors
+            .of_option_chord(self.chord);
         StrokeRectangle {
             width: self.bar_layout.size.width,
             height: self.bar_layout.size.height + theme.sizes.bar.bar_separator_extra * 2.0,
             origin: shapes::RectangleOrigin::TopLeft,
-            color: theme.colors.bar.bar_indicator,
+            color, //: theme.colors.bar.bar_indicator,
             line_width: theme.sizes.bar.pos_indicator_size,
             offset,
         }
     }
+}
+
+impl BarIndicatorData {
+    fn update_chord(&mut self,
+        bar_props: TabBarProps,
+        in_bar_pos: Option<Units>,
+    ) {
+        self.bar_props = bar_props;
+        self.chord = self.tab.get_bar_of_ordinal(bar_props.bar_ordinal).and_then(|x| x.get_chord(in_bar_pos));
+    }
+    pub fn update_data(&mut self,
+        commands: &mut Commands,
+        theme: &NotationTheme,
+        entity: Entity,
+        bar_props: TabBarProps,
+        bar_layout: LayoutData,
+        in_bar_pos: Option<Units>,
+    ) {
+        self.update_chord(bar_props, in_bar_pos);
+        self.bar_layout = bar_layout;
+        self.update(commands, theme, entity);
+    }
+    pub fn update_pos(
+        commands: &mut Commands,
+        theme: &NotationTheme,
+        bar_indicator_query: &mut Query<(Entity, &mut BarIndicatorData), With<BarIndicatorData>>,
+        bar_props: TabBarProps,
+        in_bar_pos: Units,
+    ) {
+        if let Ok((entity, mut data)) = bar_indicator_query.single_mut() {
+            data.update_chord(bar_props, Some(in_bar_pos));
+            data.update(commands, theme, entity);
+        }
+    }
 }
diff --git a/crates/notation_bevy/src/play/play_plugin.rs b/crates/notation_bevy/src/play/play_plugin.rs
@@ -3,7 +3,7 @@ use std::sync::Arc;
 use notation_bevy_utils::prelude::{DoLayoutEvent, GridData, LayoutData, ShapeOp};
 use notation_midi::prelude::PlayControlEvent;
 use notation_model::prelude::{
-    LaneEntry, PlayState, PlayingState, Position, Tab, TabBarProps, TickResult,
+    LaneEntry, PlayState, PlayingState, Position, Tab, TickResult,
 };
 
 use bevy::prelude::*;
@@ -51,9 +51,9 @@ impl PlayPlugin {
         commands: &mut Commands,
         theme: &NotationTheme,
         entity: Entity,
-        tab: &Tab,
+        tab: &Arc<Tab>,
     ) {
-        let bar_data = BarIndicatorData::new();
+        let bar_data = BarIndicatorData::new(tab.clone());
         bar_data.create(commands, &theme, entity);
         let pos_data = PosIndicatorData::new(tab.bar_units());
         pos_data.create(commands, &theme, entity);
@@ -73,21 +73,24 @@ fn update_indicators(
         &LayoutData,
         &Arc<GridData>,
     )>,
-    bar_props: TabBarProps,
+    bar_playing: &BarPlaying,
     bar_layout: LayoutData,
 ) {
-    for (entity, mut data) in bar_indicator_query.iter_mut() {
-        data.bar_props = bar_props;
-        data.bar_layout = bar_layout;
-        data.update(commands, &theme, entity);
-    }
+    let bar_props = bar_playing.bar_props;
+    let mut in_bar_pos = None;
     for (entity, mut data) in pos_indicator_query.iter_mut() {
         data.bar_props = bar_props;
         data.bar_layout = bar_layout;
         data.update(commands, &theme, entity);
         settings
             .layout
             .focus_bar(commands, theme, tab_bars_query, &data);
+        in_bar_pos = Some(data.bar_position.in_bar_pos);
+    }
+    for (entity, mut data) in bar_indicator_query.iter_mut() {
+        data.bar_props = bar_props;
+        data.bar_layout = bar_layout;
+        data.update_data(commands, theme, entity, bar_props, bar_layout, in_bar_pos);
     }
 }
 
@@ -136,7 +139,7 @@ fn on_tab_resized(
                 &mut bar_indicator_query,
                 &mut pos_indicator_query,
                 &mut tab_bars_query,
-                playing.bar_props,
+                playing,
                 layout.clone(),
             );
         }
@@ -167,7 +170,7 @@ fn on_bar_playing_changed(
                 &mut bar_indicator_query,
                 &mut pos_indicator_query,
                 &mut tab_bars_query,
-                playing.bar_props,
+                playing,
                 layout.clone(),
             );
             break;
@@ -218,6 +221,7 @@ fn on_tick(
     commands: &mut Commands,
     theme: &NotationTheme,
     settings: &mut NotationSettings,
+    bar_indicator_query: &mut Query<(Entity, &mut BarIndicatorData), With<BarIndicatorData>>,
     pos_indicator_query: &mut Query<(Entity, &mut PosIndicatorData), With<PosIndicatorData>>,
     bar_playing_query: &mut Query<(Entity, &mut BarPlaying), With<BarPlaying>>,
     entry_playing_query: &mut Query<
@@ -247,25 +251,28 @@ fn on_tick(
     if *stopped {
         tab_state.set_play_state(commands, state_entity, PlayState::Stopped);
     } else {
-        if let Some(pos_data) =
-            PosIndicatorData::update_pos(commands, theme, pos_indicator_query, *new_position)
-        {
-            if settings.layout.mode == LayoutMode::Line && pos_data.is_synced() {
-                settings
-                    .layout
-                    .focus_bar(commands, theme, tab_bars_query, &pos_data);
-            }
-        }
         let playing_bar_ordinal = new_position.bar.bar_ordinal;
         BarPlaying::update(bar_playing_query, tab_state, playing_bar_ordinal);
-        ChordPlaying::update(chord_playing_query, tab_state, new_position);
         EntryPlaying::update_with_pos(
             entry_playing_query,
             tab_state,
             new_position,
             *end_passed,
             *jumped,
         );
+        let chord_changed = ChordPlaying::update(chord_playing_query, tab_state, new_position);
+        if let Some(pos_data) =
+            PosIndicatorData::update_pos(commands, theme, pos_indicator_query, *new_position)
+        {
+            if settings.layout.mode == LayoutMode::Line && pos_data.is_synced() {
+                settings
+                    .layout
+                    .focus_bar(commands, theme, tab_bars_query, &pos_data);
+            }
+            if chord_changed > 0 {
+                BarIndicatorData::update_pos(commands, theme, bar_indicator_query, pos_data.bar_props, pos_data.bar_position.in_bar_pos);
+            }
+        }
     }
 }
 
@@ -275,6 +282,7 @@ fn on_play_control_evt(
     mut settings: ResMut<NotationSettings>,
     mut evts: EventReader<PlayControlEvent>,
     mut tab_state_query: Query<(Entity, &mut TabState)>,
+    mut bar_indicator_query: Query<(Entity, &mut BarIndicatorData), With<BarIndicatorData>>,
     mut pos_indicator_query: Query<(Entity, &mut PosIndicatorData), With<PosIndicatorData>>,
     mut bar_playing_query: Query<(Entity, &mut BarPlaying), With<BarPlaying>>,
     mut entry_playing_query: Query<
@@ -304,6 +312,7 @@ fn on_play_control_evt(
                     &mut commands,
                     &theme,
                     &mut settings,
+                    &mut bar_indicator_query,
                     &mut pos_indicator_query,
                     &mut bar_playing_query,
                     &mut entry_playing_query,
diff --git a/crates/notation_bevy/src/play/pos_indicator.rs b/crates/notation_bevy/src/play/pos_indicator.rs
@@ -38,7 +38,7 @@ impl ShapeOp<NotationTheme, OutlineRectangle> for PosIndicatorData {
         let height = self.bar_layout.size.height + theme.sizes.bar.bar_separator_extra * 2.0;
         let color = theme
                 .colors
-                .of_section(self.bar_props.section_index);
+                .of_section(self.bar_props.section_ordinal);
         let outline_color = theme.colors.bar.pos_indicator_color;
         let outline_width = theme.sizes.bar.pos_indicator_outline;
         let offset = if self.bar_layout.size.width <= 0.0 {
diff --git a/crates/notation_bevy/src/tab/tab_bars.rs b/crates/notation_bevy/src/tab/tab_bars.rs
@@ -187,7 +187,7 @@ impl TabBars {
         let view_bundle = ViewBundle::from(TabBars::new(tab.clone(), Arc::new(bar_layouts)));
         let view = view_bundle.view.clone();
         let bars_entity = BevyUtil::spawn_child_bundle(commands, entity, view_bundle);
-        PlayPlugin::spawn_indicators(commands, theme, bars_entity, &view.tab);
+        PlayPlugin::spawn_indicators(commands, theme, bars_entity, tab);
         let bar_bundles: Vec<(&Arc<TabBar>, &BarLayoutData)> = view
             .tab
             .bars

Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,8 @@ impl ChordPlaying {`
`26`	`26`	`query: &mut Query<(Entity, &mut ChordPlaying), With<ChordPlaying>>,`
`27`	`27`	`tab_state: &TabState,`
`28`	`28`	`new_position: &Position,`
`29`		`- ) {`
	`29`	`+ ) -> usize {`
	`30`	`+ let mut changed = 0;`
`30`	`31`	`let is_current = \|c: Chord\| {`
`31`	`32`	`if tab_state.play_control.play_state.is_playing() {`
`32`	`33`	`let chord = tab_state`
`@@ -51,12 +52,15 @@ impl ChordPlaying {`
`51`	`52`	`if is_current(chord_playing.value.chord) {`
`52`	`53`	`if chord_playing.value.state != PlayingState::Current {`
`53`	`54`	`chord_playing.value.state = PlayingState::Current;`
	`55`	`+ changed += 1;`
`54`	`56`	`}`
`55`	`57`	`} else {`
`56`	`58`	`if chord_playing.value.state != PlayingState::Idle {`
`57`	`59`	`chord_playing.value.state = PlayingState::Idle;`
	`60`	`+ changed += 1;`
`58`	`61`	`}`
`59`	`62`	`}`
`60`	`63`	`}`
	`64`	`+ changed`
`61`	`65`	`}`
`62`	`66`	`}`