simplified framecounting

emu/src/frame_timer.rs

@@ -1,7 +1,7 @@
 use instant::Instant;
 
 pub struct FrameTimer {
-    pub frames_to_render: u64,
+    pub frame_count: u64,
     pub frames: u64,
     pub epoch: Instant,
 }
@@ -10,20 +10,20 @@ impl Default for FrameTimer {
     fn default() -> Self {
         Self {
             frames: 0,
-            frames_to_render: 0,
+            frame_count: 0,
             epoch: Instant::now(),
         }
     }
 }
 
 impl FrameTimer {
-    pub fn frames_to_render(&mut self) -> u64 {
+    pub fn frame_count(&mut self) -> u64 {
         let diff = Instant::now().duration_since(self.epoch);
         let frames = (diff.as_millis() as f64 * 0.05992274) as u64; // TODO: PAL
         // self.emu.gfx.framerate()
-        self.frames_to_render = frames - self.frames;
+        self.frame_count = frames - self.frames;
         self.frames = frames;
-        self.frames_to_render
+        self.frame_count
     }
     /// use when unpausing
     pub fn reset_epoch(&mut self) {

emu/src/lib.rs

@@ -44,17 +44,19 @@ impl Megadrive {
         }
     }
 
-    /// render frame at current instant
-    pub fn render(&mut self) {
-        let frames_to_render = self.frame_timer.frames_to_render();
-        if frames_to_render > 3 { // magic number
+    /// render frame(s) at current instant
+    /// returns number of rendered frames
+    pub fn render(&mut self) -> u64 {
+        let frame_count = self.frame_timer.frame_count();
+        if frame_count > 3 { // magic number
             self.frame(true);
-        } else if frames_to_render > 0 {
-            for _ in 0..frames_to_render - 1 {
+        } else if frame_count > 0 {
+            for _ in 0..frame_count - 1 {
                 self.frame(false);
             }
             self.frame(true);
         }
+        frame_count
     }
 
     /// renders a single frame

frontend-minimal/src/lib.rs

@@ -14,8 +14,9 @@ impl MDEmu {
         ))
     }
 
-    pub fn frame(&mut self, render: bool)  {
-        self.0.frame(render);
+
+    pub fn render(&mut self) -> u64  {
+        self.0.render()
     }
 
     pub fn screen(&self) -> *const u8 {

frontend-minimal/static/frontend_minimal.js

@@ -211,10 +211,11 @@ export class MDEmu {
         return MDEmu.__wrap(ret);
     }
     /**
-    * @param {boolean} render
+    * @returns {bigint}
     */
-    frame(render) {
-        wasm.mdemu_frame(this.ptr, render);
+    render() {
+        const ret = wasm.mdemu_render(this.ptr);
+        return BigInt.asUintN(64, ret);
     }
     /**
     * @returns {number}

frontend-minimal/static/index.html

@@ -82,34 +82,18 @@
                 }
 
                 const frameCount = document.querySelector('.frameCount');
-                const epoch = performance.now();
-                let framesDone = 0;
-                const loop = () => {
+                (function loop() {
                     requestAnimationFrame(loop);
-
-                    const diff = performance.now() - epoch;
-                    const frames = diff * 0.05992274 | 0;
-                    const frameAmount = frames - framesDone;
-                    frameCount.textContent = String(frameAmount);
+                    frameCount.textContent = String('???');
 
                     if (document.visibilityState !== 'hidden') {
-
                         emu.gamepad_p1(gamepad());
 
-                        if (frameAmount > 5) {
-                            emu.frame(true);
-                        } else {
-                            for (let i = 0; i < frameAmount; i++) {
-                                emu.frame(i === frameAmount - 1);
-                            }
-                        }
-                        if (frameAmount > 0) {
+                        if (emu.render()) {
                             draw();
                         }
                     }
-                    framesDone = frames;
-                };
-                loop();
+                })();
             })();
         </script>
     </body>

frontend/src/app.rs

@@ -105,7 +105,7 @@ impl eframe::App for App {
             egui::warn_if_debug_build(ui);
             // ctx.inspection_ui(ui);
 
-            ui.label(&format!("MD frames this frame: {}", self.emu.frame_timer.frames_to_render));
+            ui.label(&format!("MD frames this frame: {}", self.emu.frame_timer.frame_count));
             ui.label(&format!("avg frames {:.1}", self.test_vec.iter().sum::<u64>() as f32 / self.test_vec.len() as f32));
 
             if ui.button(if self.running { "pause" } else { "play" }).clicked() {
@@ -114,7 +114,7 @@ impl eframe::App for App {
             ui.radio_value(&mut self.vsync, true, "vsync");
             ui.radio_value(&mut self.vsync, false, "not vsync");
 
-            self.test_vec.push_back(self.emu.frame_timer.frames_to_render.min(4));
+            self.test_vec.push_back(self.emu.frame_timer.frame_count.min(4));
 
             if self.test_vec.len() > 60 {
                 self.test_vec.pop_front();