Show effective speed in the UI when running in fast-forward mode

Makes it easier to see how fast things are actually running.

Author: mihaip

core/src/emulator/comm.rs

@@ -114,6 +114,7 @@ pub struct EmulatorStatus {
     pub fdd: [FddStatus; 3],
     pub model: MacModel,
     pub speed: EmulatorSpeed,
+    pub effective_speed: f64,
     pub scsi: [Option<ScsiTargetStatus>; 7],
 }
 

core/src/emulator/mod.rs

@@ -187,6 +187,7 @@ dispatch! {
         fn cpu_breakpoints(&self) -> &[Breakpoint] { breakpoints() }
         fn cpu_get_step_over(&self) -> Option<Address> { get_step_over() }
         fn speed(&self) -> EmulatorSpeed { bus.speed }
+        fn effective_speed(&self) -> f64 { bus.get_effective_speed() }
         fn debug_properties(&self) -> DebuggableProperties { bus.get_debug_properties() }
         fn get_audio_channel(&self) -> AudioReceiver { bus.get_audio_channel() }
     }
@@ -589,6 +590,7 @@ impl Emulator {
                         })
                 }),
                 speed: self.config.speed(),
+                effective_speed: self.config.effective_speed(),
             })))?;
 
         // Next code stream for disassembly listing

core/src/mac/compact/bus.rs

@@ -228,6 +228,10 @@ where
         self.model
     }
 
+    pub fn get_effective_speed(&self) -> f64 {
+        self.via.rtc.effective_speed()
+    }
+
     pub(crate) fn get_audio_channel(&self) -> AudioReceiver {
         self.audio.receiver.as_ref().unwrap().clone()
     }

core/src/mac/macii/bus.rs

@@ -270,6 +270,10 @@ where
         self.model
     }
 
+    pub fn get_effective_speed(&self) -> f64 {
+        self.via1.rtc.effective_speed()
+    }
+
     pub(crate) fn get_audio_channel(&self) -> AudioReceiver {
         self.asc.receiver.as_ref().unwrap().clone()
     }

core/src/mac/rtc.rs

@@ -60,6 +60,16 @@ pub struct Rtc {
     data_out: Option<u8>,
 
     data: RtcData,
+
+    // Computed on the fly, no need to save the state.
+    #[serde(skip, default = "default_effective_speed")]
+    effective_speed: f64,
+    #[serde(skip)]
+    last_second_real_time_ms: Option<i64>,
+}
+
+fn default_effective_speed() -> f64 {
+    1.0
 }
 
 #[derive(Serialize, Deserialize)]
@@ -175,6 +185,8 @@ impl Default for Rtc {
                 seconds,
                 pram: RtcData::empty_pram(),
             },
+            effective_speed: 1.0,
+            last_second_real_time_ms: Some(Local::now().timestamp_millis()),
         }
     }
 }
@@ -202,12 +214,27 @@ impl Rtc {
             .and_hms_opt(0, 0, 0)
             .unwrap();
         self.data.seconds = dt.signed_duration_since(mac_epoch).num_seconds() as u32;
+        self.last_second_real_time_ms = Some(Local::now().timestamp_millis());
     }
 
     /// Pokes the RTC that one second has passed
     /// In the emulator, one second interrupt is driven by the VIA for ease.
     pub fn second(&mut self) {
         self.data.seconds = self.data.seconds.wrapping_add(1);
+
+        let now_ms = Local::now().timestamp_millis();
+        if let Some(last_ms) = self.last_second_real_time_ms {
+            let real_elapsed_secs = (now_ms - last_ms) as f64 / 1000.0;
+            if real_elapsed_secs > 0.0 {
+                let instantaneous = 1.0 / real_elapsed_secs;
+                self.effective_speed = self.effective_speed.mul_add(0.8, instantaneous * 0.2);
+            }
+        }
+        self.last_second_real_time_ms = Some(now_ms);
+    }
+
+    pub fn effective_speed(&self) -> f64 {
+        self.effective_speed
     }
 
     /// Updates RTC I/O lines from the VIA.

frontend_egui/src/app.rs

@@ -1558,6 +1558,40 @@ impl SnowGui {
         }
     }
 
+    fn draw_fast_forward_button(&self, ui: &mut egui::Ui) -> egui::Response {
+        let is_active = self.emu.is_fastforward();
+        let selection_color = ui.visuals().selection.stroke.color;
+        let icon = egui_material_icons::icons::ICON_FAST_FORWARD;
+        let mut text = egui::RichText::new(icon);
+        if is_active {
+            text = text.color(selection_color);
+        }
+
+        let response = ui
+            .add_enabled(self.emu.is_running(), egui::Button::new(text))
+            .on_hover_text("Fast-forward execution");
+
+        if is_active {
+            let font_id = egui::FontId::proportional(9.0);
+            let badge_text = egui::WidgetText::from(
+                egui::RichText::new(self.emu.effective_speed_label()).font(font_id),
+            );
+            let galley = badge_text.into_galley(
+                ui,
+                Some(egui::TextWrapMode::Extend),
+                f32::MAX,
+                egui::FontSelection::Default,
+            );
+            let badge_pos = egui::pos2(
+                response.rect.right() - galley.size().x - 1.0,
+                response.rect.top() + 1.0,
+            );
+            ui.painter().galley(badge_pos, galley, selection_color);
+        }
+
+        response
+    }
+
     fn draw_toolbar(&mut self, ctx: &egui::Context, ui: &mut egui::Ui) {
         ui.horizontal(|ui| {
             ui.style_mut().text_styles.insert(
@@ -1606,15 +1640,7 @@ impl SnowGui {
                     self.emu.run();
                 }
 
-                if ui
-                    .add_enabled(
-                        self.emu.is_running(),
-                        egui::Button::new(egui_material_icons::icons::ICON_FAST_FORWARD)
-                            .selected(self.emu.is_fastforward()),
-                    )
-                    .on_hover_text("Fast-forward execution")
-                    .clicked()
-                {
+                if self.draw_fast_forward_button(ui).clicked() {
                     self.emu.toggle_fastforward();
                 }
 

frontend_egui/src/emulator.rs

@@ -854,6 +854,16 @@ impl EmulatorState {
         }
     }
 
+    pub fn effective_speed_label(&self) -> String {
+        let Some(ref status) = self.status else {
+            return String::new();
+        };
+        if status.speed == EmulatorSpeed::Accurate {
+            return String::new();
+        }
+        format!("{:.1}x", status.effective_speed)
+    }
+
     /// Returns the currently emulated Macintosh model
     pub fn get_model(&self) -> Option<MacModel> {
         let status = self.status.as_ref()?;