added BpmList component for time <-> beat convertion

Author: Ivan-1F

src/chart/beat.rs

@@ -1,9 +1,13 @@
-use std::{cmp::Ordering, ops::Sub};
+use std::{cmp::Ordering, ops::{Add, Sub}};
 
-use num::{Rational32, FromPrimitive};
+use num::{FromPrimitive, Rational32};
 
 #[derive(Clone, Copy, Debug)]
-pub struct Beat(i32, pub Rational32);
+pub struct Beat(i32, Rational32);
+
+impl Beat {
+    pub const ZERO: Self = Beat(0, Rational32::ZERO);
+}
 
 impl Into<f32> for Beat {
     fn into(self) -> f32 {
@@ -59,6 +63,14 @@ impl Sub for Beat {
     }
 }
 
+impl Add for Beat {
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self::Output {
+        Self(self.0 + rhs.0, self.1 + rhs.1)
+    }
+}
+
 impl PartialEq for Beat {
     fn eq(&self, other: &Self) -> bool {
         self.0 == other.0 && self.1 == other.1

src/hit_sound.rs

@@ -3,7 +3,7 @@ use bevy_kira_audio::prelude::*;
 
 use crate::{
     chart::note::{Note, NoteKind},
-    timing::ChartTime,
+    timing::{BpmList, ChartTime},
 };
 
 pub struct HitSoundPlugin;
@@ -20,9 +20,14 @@ struct PlayHitSound(NoteKind);
 #[derive(Component, Debug)]
 struct PlayedHitSound;
 
-fn add_marker_system(mut commands: Commands, query: Query<(&Note, Entity), Without<PlayedHitSound>>, time: Res<ChartTime>) {
+fn add_marker_system(
+    mut commands: Commands,
+    query: Query<(&Note, Entity), Without<PlayedHitSound>>,
+    time: Res<ChartTime>,
+    bpm_list: Res<BpmList>,
+) {
     for (note, entity) in &query {
-        if note.beat.value() * (60.0 / 174.0) < time.0 {
+        if bpm_list.time_at(note.beat) < time.0 {
             commands.entity(entity).insert(PlayHitSound(note.kind));
         }
     }

src/loader/official.rs

@@ -4,7 +4,7 @@ use crate::{
         event::{LineEvent, LineEventBundle, LineEventKind},
         line::LineBundle,
         note::NoteBundle,
-    }, constants::{CANVAS_HEIGHT, CANVAS_WIDTH}, selection::SelectedLine
+    }, constants::{CANVAS_HEIGHT, CANVAS_WIDTH}, selection::SelectedLine, timing::{BpmList, BpmPoint}
 };
 
 use super::Loader;
@@ -71,6 +71,8 @@ struct SpeedEvent {
 
 #[derive(Serialize, Deserialize, Debug)]
 struct Line {
+    bpm: f32,
+
     #[serde(rename(deserialize = "judgeLineMoveEvents"))]
     move_events: Vec<PositionLineEvent>,
     #[serde(rename(deserialize = "judgeLineRotateEvents"))]
@@ -98,6 +100,10 @@ pub struct OfficialLoader;
 impl Loader for OfficialLoader {
     fn load(file: std::fs::File, mut commands: Commands) {
         let chart: Chart = serde_json::from_reader(file).expect("Failed to load chart");
+
+        let first_line = chart.lines.first().expect("The chart should has at least one line");
+        commands.insert_resource(BpmList::new(vec![BpmPoint::new(Beat::ZERO, first_line.bpm)]));
+
         let mut first_line_id: Option<Entity> = None;
         for line in chart.lines.iter() {
             let t: fn(f32) -> Beat = |x| Beat::from(x * 1.875 / 60.0);

src/main.rs

@@ -40,6 +40,7 @@ use bevy_mod_picking::prelude::*;
 use constants::{CANVAS_HEIGHT, CANVAS_WIDTH};
 use egui_dock::{DockArea, DockState, NodeIndex, Style};
 use num::{FromPrimitive, Rational32};
+use timing::BpmList;
 
 fn main() {
     App::new()
@@ -306,8 +307,9 @@ fn update_note_system(
     mut query: Query<(&mut Transform, &mut Sprite, &Note)>,
     game_viewport: Res<GameViewport>,
     time: Res<ChartTime>,
+    bpm_list: Res<BpmList>,
 ) {
-    let beat = time.0 / (60.0 / 174.0);
+    let beat = bpm_list.beat_at(time.0);
     for (mut transform, mut sprite, note) in &mut query {
         transform.translation.x = (note.x / CANVAS_WIDTH) * game_viewport.0.width()
             / (game_viewport.0.width() * 3.0 / 1920.0);
@@ -316,7 +318,7 @@ fn update_note_system(
         } else {
             0.0
         };
-        sprite.color = Color::WHITE.with_a(if note.beat.value() + hold_beat < beat {
+        sprite.color = Color::WHITE.with_a(if note.beat.value() + hold_beat < beat.into() {
             0.0
         } else {
             1.0
@@ -337,8 +339,9 @@ fn compute_line_system(
         With<Line>,
     >,
     time: Res<ChartTime>,
+    bpm_list: Res<BpmList>,
 ) {
-    let beat = time.0 / (60.0 / 174.0);
+    let beat: f32 = bpm_list.beat_at(time.0).into();
     for (mut position, mut rotation, mut opacity, entity) in &mut line_query {
         let mut events: Vec<_> = event_query.iter().filter(|e| e.line_id == entity).collect();
         events.sort_by_key(|e| e.start_beat);
@@ -391,6 +394,7 @@ fn update_note_y_system(
     speed_event_query: Query<(&SpeedEvent, &LineEvent)>,
     mut note_query: Query<(&mut Transform, &mut Sprite, &Note)>,
     time: Res<ChartTime>,
+    bpm_list: Res<BpmList>,
 ) {
     let all_speed_events: Vec<(&SpeedEvent, &LineEvent)> = speed_event_query.iter().collect();
     for (children, entity) in &query {
@@ -410,12 +414,12 @@ fn update_note_y_system(
         let current_distance = distance(time.0);
         for child in children {
             if let Ok((mut transform, mut sprite, note)) = note_query.get_mut(*child) {
-                let mut y = distance(note.beat.value() * (60.0 / 174.0)) - current_distance;
+                let mut y = distance(bpm_list.time_at(note.beat)) - current_distance;
                 match note.kind {
                     NoteKind::Hold { hold_beat } => {
                         y = y.max(0.0);
                         let height = distance(
-                            note.beat.value() * (60.0 / 174.0) + hold_beat.value() * (60.0 / 174.0),
+                            bpm_list.time_at(note.beat + hold_beat),
                         ) - current_distance
                             - y;
                         sprite.anchor = Anchor::BottomCenter;
@@ -478,13 +482,17 @@ impl SpeedEvent {
     }
 }
 
-fn calculate_speed_events_system(mut commands: Commands, query: Query<(&LineEvent, Entity)>) {
+fn calculate_speed_events_system(
+    mut commands: Commands,
+    query: Query<(&LineEvent, Entity)>,
+    bpm_list: Res<BpmList>,
+) {
     for (event, entity) in &query {
         match event.kind {
             LineEventKind::Speed => {
                 commands.entity(entity).insert(SpeedEvent::new(
-                    event.start_beat.value() * (60.0 / 174.0),
-                    event.end_beat.value() * (60.0 / 174.0),
+                    bpm_list.time_at(event.start_beat),
+                    bpm_list.time_at(event.end_beat),
                     event.start,
                     event.end,
                 ));

src/tab/timeline.rs

@@ -6,7 +6,7 @@ use crate::{
     chart::{
         event::LineEvent,
         note::{Note, NoteKind},
-    }, constants::CANVAS_WIDTH, misc::WorkingDirectory, selection::{SelectNoteEvent, Selected, SelectedLine}, timing::ChartTime
+    }, constants::CANVAS_WIDTH, misc::WorkingDirectory, selection::{SelectNoteEvent, Selected, SelectedLine}, timing::{BpmList, ChartTime}
 };
 
 pub struct TimelineTabPlugin;
@@ -22,6 +22,7 @@ pub fn timeline_ui_system(
     selected_line_query: Res<SelectedLine>,
     timeline_viewport: Res<TimelineViewport>,
     time: Res<ChartTime>,
+    bpm_list: Res<BpmList>,
     event_query: Query<&LineEvent>,
     note_query: Query<(&Note, &Parent, Entity, Option<&Selected>)>,
     working_dir: Res<WorkingDirectory>,
@@ -61,12 +62,12 @@ pub fn timeline_ui_system(
         let x = event_timeline_viewport.width() / 5.0 * track as f32
             - event_timeline_viewport.width() / 5.0 / 2.0
             + event_timeline_viewport.min.x;
-        let y: f32 = (time - event.start_beat.value() * (60.0 / 174.0)) * 400.0 * 2.0
+        let y: f32 = (time - bpm_list.time_at(event.start_beat)) * 400.0 * 2.0
             + event_timeline_viewport.height() * 0.9;
 
         let size = egui::Vec2::new(
             event_timeline_viewport.width() / 8000.0 * 989.0,
-            event.duration().value() * (60.0 / 174.0) * 400.0 * 2.0,
+            bpm_list.time_at(event.duration()) * 400.0 * 2.0,
         );
 
         let center = egui::Pos2::new(x, y - size.y / 2.0);
@@ -87,7 +88,7 @@ pub fn timeline_ui_system(
         }
 
         let x = (note.x / CANVAS_WIDTH + 0.5) * note_timeline_viewport.width();
-        let y: f32 = (time - note.beat.value() * (60.0 / 174.0)) * 400.0 * 2.0
+        let y: f32 = (time - bpm_list.time_at(note.beat)) * 400.0 * 2.0
             + note_timeline_viewport.height() * 0.9;
 
         let image = match note.kind {
@@ -109,7 +110,7 @@ pub fn timeline_ui_system(
         let size = match note.kind {
             NoteKind::Hold { hold_beat } => egui::Vec2::new(
                 note_timeline_viewport.width() / 8000.0 * image_size.x,
-                hold_beat.value() * (60.0 / 174.0) * 400.0 * 2.0,
+                bpm_list.time_at(hold_beat) * 400.0 * 2.0,
             ),
             _ => egui::Vec2::new(
                 note_timeline_viewport.width() / 8000.0 * image_size.x,

src/timing.rs

@@ -1,5 +1,7 @@
 use bevy::prelude::*;
 
+use crate::chart::beat::Beat;
+
 /// Represents the current time in seconds
 #[derive(Resource)]
 pub struct ChartTime(pub f32);
@@ -43,3 +45,65 @@ fn space_pause_resume_control(
         }
     }
 }
+
+#[derive(Debug)]
+pub struct BpmPoint {
+    beat: Beat,
+    bpm: f32,
+
+    time: f32,
+}
+
+impl BpmPoint {
+    pub fn new(beat: Beat, bpm: f32) -> Self {
+        Self {
+            beat,
+            bpm,
+            time: 0.0,
+        }
+    }
+}
+
+#[derive(Resource, Debug)]
+pub struct BpmList(Vec<BpmPoint>);
+
+impl BpmList {
+    pub fn new(points: Vec<BpmPoint>) -> Self {
+        let mut list = Self(points);
+        list.compute();
+        list
+    }
+
+    fn compute(&mut self) {
+        let mut time = 0.0;
+        let mut last_beat = 0.0;
+        let mut last_bpm = -1.0;
+        for point in &mut self.0 {
+            if last_bpm != -1.0 {
+                time += (point.beat.value() - last_beat) * (60.0 / last_bpm);
+            }
+            last_beat = point.beat.value();
+            last_bpm = point.bpm;
+            point.time = time;
+        }
+    }
+
+    pub fn time_at(&self, beat: Beat) -> f32 {
+        let point = self.0.iter()
+            .take_while(|p| p.beat.value() < beat.value())
+            .last()
+            .or_else(|| self.0.first())
+            .expect("No bpm points available");
+
+        point.time + (beat.value() - point.beat.value()) * (60.0 / point.bpm)
+    }
+
+    pub fn beat_at(&self, time: f32) -> Beat {
+        let point = self.0.iter()
+            .take_while(|p| p.time <= time)
+            .last()
+            .expect("No bpm points available");
+
+        Beat::from(point.beat.value() + (time - point.time) * point.bpm / 60.0)
+    }
+}