src/emu.zig

@@ -49,42 +49,28 @@ pub fn runEmuThread(quit: *Atomic(bool), pause: *Atomic(bool), fps: *Atomic(u64)
             // ns_late is non zero if we are late.
             var ns_late = timestamp -| wake_time;
 
-            // log.info("timestamp: {} | late: {}", .{ timestamp, ns_late });
+            // Calculate the new Thread wake time
+            wake_time += frame_period;
 
             // If we're more than a frame late, skip the rest of this loop
-            // Recalculate what our new wake time should be so that we can
-            // get "back on track"
-            if (ns_late > frame_period) {
-                wake_time = timestamp + frame_period;
-                continue;
-            }
+            if (ns_late > frame_period) continue;
 
-            if (sync_to_video) {
-                // Employ several sleep calls in periods of 10ms
-                // By doing this the behaviour should average out to be
-                // more consistent
+            if (sync_to_video) std.time.sleep(frame_period - ns_late);
 
-                const sleep_for = frame_period - ns_late;
-                const loop_count = sleep_for / (std.time.ns_per_ms * 10); // How many groups of 10ms
-
-                var i: usize = 0;
-                while (i < loop_count) : (i += 1) {
-                    std.time.sleep(std.time.ns_per_ms * 10);
-                }
-
-                // Spin to make up the difference if there is a need
-                // Make sure that we're using the old wake time and not the onne we recalcualted
-                spinLoop(&timer, wake_time);
-            }
-
-            // Update to the new wake time
-            wake_time += frame_period;
+            // Backup Busy Loop Routine
+            // if (sync_to_video) spinLoop(&timer, wake_time);
         }
     }
 }
 
 fn spinLoop(timer: *Timer, wake_time: u64) void {
-    while (true) if (timer.read() > wake_time) break;
+    while (true) {
+        const timestamp = timer.read();
+
+        if (timestamp >= wake_time) {
+            break;
+        }
+    }
 }
 
 fn emuFps(left: u64) u64 {

src/main.zig

@@ -177,7 +177,7 @@ pub fn main() anyerror!void {
         fps_avg.add(emu_fps.load(.Unordered));
         const avg = fps_avg.calc();
 
-        const dyn_title = std.fmt.bufPrint(&dyn_title_buf, "{s} [Emu: {d:0>3}fps, {d:0>3}%] ", .{ title, avg, (avg * 100 / 60) }) catch unreachable;
+        const dyn_title = std.fmt.bufPrint(&dyn_title_buf, "{s} [Emu: {d:0>3}fps, {d:0>3}%] ", .{ title, avg, (avg * 100 / 59) }) catch unreachable;
         SDL.SDL_SetWindowTitle(window, dyn_title.ptr);
     }
 

src/ppu.zig

@@ -121,36 +121,37 @@ pub const Ppu = struct {
 
     /// Draw all relevant sprites on a scanline
     fn drawSprites(self: *Self, prio: u2) void {
+        // Object VRAM 3rd and 4th (0-indexed) charblocks
         const char_base = 0x4000 * 4;
         const y = @bitCast(i8, self.vcount.scanline.read());
 
-        // Loop over every fetched sprite
-        sprite_loop: for (self.scanline_sprites) |maybe_sprites| {
-            if (maybe_sprites) |sprite| {
-                // Move on to the next sprite If its of a different priority
-                if (sprite.priority() != prio) continue :sprite_loop;
+        var i: u9 = 0;
+        while (i < width) : (i += 1) {
+            // Exit early if a pixel is already here
+            if (self.scanline_buf[i] != null) continue;
+
+            const x = i;
+
+            for (self.scanline_sprites) |maybe_sprite| {
+                if (maybe_sprite) |sprite| {
+                    if (sprite.priority() != prio) continue;
 
-                var i: u9 = 0;
-                px_loop: while (i < sprite.width) : (i += 1) {
-                    const x = (sprite.x() +% i) % 240;
                     const ix = @bitCast(i9, x);
 
-                    // If We've already rendered a pixel here don't overwrite it
-                    if (self.scanline_buf[x] != null) continue :px_loop;
-
                     const start = sprite.x();
                     const istart = @bitCast(i9, start);
 
                     const end = start +% sprite.width;
                     const iend = @bitCast(i9, end);
 
-                    // By comparing with both signed and unsigned values we ensure that sprites
-                    // are displayed in all valid (AFAIK) configuration
+                    // Sprites are expected to wrap, by performing the same check on both
+                    // signed and unsigned values we ensure that sprites are properly displayed
+                    // in all valid scenarios
                     if ((start <= x and x < end) or (istart <= ix and ix < iend)) {
                         self.drawSpritePixel(char_base, sprite, ix, y);
                     }
-                }
-            } else break;
+                } else break;
+            }
         }
     }
 
@@ -274,12 +275,12 @@ pub const Ppu = struct {
             0x0 => {
                 const start = framebuf_pitch * @as(usize, scanline);
 
-                if (obj_enable) self.fetchSprites();
+                self.fetchSprites();
 
                 var i: usize = 0;
                 while (i < 4) : (i += 1) {
                     // Draw Sprites Here
-                    self.drawSprites(@truncate(u2, i));
+                    if (obj_enable) self.drawSprites(@truncate(u2, i));
                     if (i == self.bg[0].cnt.priority.read() and bg_enable & 1 == 1) self.drawBackround(0);
                     if (i == self.bg[1].cnt.priority.read() and bg_enable >> 1 & 1 == 1) self.drawBackround(1);
                     if (i == self.bg[2].cnt.priority.read() and bg_enable >> 2 & 1 == 1) self.drawBackround(2);

src/util.zig

@@ -18,7 +18,7 @@ pub const FpsAverage = struct {
     }
 
     pub fn add(self: *Self, sample: u64) void {
-        if (self.sample_count == 600) return self.reset(sample);
+        if (self.sample_count == 1000) return self.reset(sample);
 
         self.total += sample;
         self.sample_count += 1;