Skip to content

armgit / gecko

Public Imported from GitHub
0

A GameCube/Wii emulator and debugger written in Rust.

improved main launcher

Laylec7d099e97603
diff --git a/README.md b/README.md
index dbc4d96..c04a695 100644
--- a/README.md
+++ b/README.md
@@ -76,10 +76,11 @@ It scans the configured GameCube and Wii folders for `.iso`, `.rvz` and `.zip` f
```
<gecko exe dir>/
- config.toml # settings
- cache/library.bin # cached library
- system/ # system file folder (!)
- IPL.bin # GameCube only
+ config.toml # settings, auto-generated
+ cache/library.bin # cached library, auto-generated
+ screenshots/ # F12 screenshots, auto-generated
+ system/ # system file folder (user provided!)
+ IPL.bin # GameCube only (must be decoded! see multitool)
dsp_rom.bin # GameCube and Wii
dsp_coef.bin # GameCube and Wii
fs/ # Wii NAND, auto-generated if missing (or drop in a Dolphin/real dump)
@@ -131,6 +132,8 @@ Nunchuk:
#### Global
+`tinyapp` and `debugger`:
+
| Key | Action |
| ------- | ------------------------------------------------------------------ |
| `Space` | Start emulation from the splash screen (`--wait` flag) |
@@ -138,6 +141,14 @@ Nunchuk:
| `F11` | Screenshot the full window |
| `F12` | Screenshot the emulated framebuffer only |
+`gecko` player window:
+
+| Key | Action |
+| ----- | --------------------------------------------------------------------- |
+| `F10` | Toggle borderless fullscreen |
+| `F11` | Toggle the FPS and emulation speed overlay |
+| `F12` | Screenshot the emulated framebuffer to `<gecko exe dir>/screenshots/` |
+
## Projects
This is a table of the main projects. Refer to `crates/` to find out about all available projects.
@@ -148,7 +159,7 @@ This is a table of the main projects. Refer to `crates/` to find out about all a
| `debugger` | Interactive GUI debugger built on egui with rendering support, hooks and scripting capabilities |
| `web` | WebAssembly build of the emulator for browser deployment via wasm-bindgen, with optional debug UI |
| `multitool` | CLI utility for analyzing, disassembling and extracting GC/Wii binaries/images (DOL, IPL, ISO/RVZ) with support for PPC and DSP |
-| `fifoplayer` | Plays a recorded `.dff` fifo log. Supports replays generated from Dolphin and Gecko's debugger |
+| `fifoplayer` | Plays (and debugs via `--debug`) a recorded `.dff` fifo log. Supports replays generated from Dolphin and Gecko's debugger |
## Building
diff --git a/crates/app/Cargo.toml b/crates/app/Cargo.toml
index b25a401..0be30cd 100644
--- a/crates/app/Cargo.toml
+++ b/crates/app/Cargo.toml
@@ -9,7 +9,7 @@ path = "src/main.rs"
[dependencies]
image = { path = "../image" }
-gecko = { path = "../gecko" }
+gecko = { path = "../gecko", features = ["fps-counter"] }
backend-wgpu = { path = "../backend-wgpu" }
wgpu = "29.0.3"
cpal = "0.17.3"
diff --git a/crates/app/src/app.rs b/crates/app/src/app.rs
index 8d77e40..f77eafa 100644
--- a/crates/app/src/app.rs
+++ b/crates/app/src/app.rs
@@ -3,8 +3,9 @@ use std::path::PathBuf;
use std::sync::Arc;
use std::time::{Duration, Instant};
+use backend_wgpu::capture;
use iced::theme::Mode;
-use iced::widget::{button, column, container, mouse_area, scrollable, stack, text};
+use iced::widget::{Stack, button, column, container, mouse_area, scrollable, stack, text};
use iced::{Background, Border, Color, Element, Length, Padding, Subscription, Task, Theme, window};
use crate::cache::{self, LibraryCache};
@@ -17,6 +18,7 @@ use crate::widgets::{game_row, menubar, search_bar, statusbar};
const REPO_URL: &str = "https://github.com/ioncodes/gecko";
const DOUBLE_CLICK_WINDOW: Duration = Duration::from_millis(400);
+const TOAST_DURATION: Duration = Duration::from_secs(3);
#[derive(Debug, Clone)]
pub enum Message {
@@ -42,11 +44,23 @@ pub enum Message {
LaunchPlayer(usize),
SystemThemeLoaded(Mode),
SystemThemeChanged(Mode),
+ PlayerToggleFullscreen(window::Id),
+ PlayerToggleOverlay(window::Id),
+ PlayerScreenshot(window::Id),
+}
+
+pub struct Toast {
+ title: String,
+ detail: String,
+ expires: Instant,
}
pub struct PlayerWindow {
pub(crate) game: Game,
pub(crate) state: Arc<PlayerState>,
+ pub(crate) fullscreen: bool,
+ pub(crate) overlay: bool,
+ pub(crate) toast: Option<Toast>,
}
pub struct App {
@@ -146,10 +160,27 @@ impl App {
}
Message::PlayerWindowOpened(id, game, state) => {
tracing::info!(window = ?id, title = %game.title, "player window opened");
- self.players.insert(id, PlayerWindow { game: *game, state });
+ self.players.insert(
+ id,
+ PlayerWindow {
+ game: *game,
+ state,
+ fullscreen: false,
+ overlay: false,
+ toast: None,
+ },
+ );
+ Task::none()
+ }
+ Message::PlayerTick => {
+ let now = Instant::now();
+ for player in self.players.values_mut() {
+ if player.toast.as_ref().is_some_and(|t| now >= t.expires) {
+ player.toast = None;
+ }
+ }
Task::none()
}
- Message::PlayerTick => Task::none(),
Message::WindowClosed(id) => {
if Some(id) == self.library_window {
self.library_window = None;
@@ -297,6 +328,50 @@ impl App {
self.refresh_palette();
Task::none()
}
+ Message::PlayerToggleFullscreen(id) => {
+ let Some(player) = self.players.get_mut(&id) else {
+ return Task::none();
+ };
+
+ player.fullscreen = !player.fullscreen;
+ let mode = if player.fullscreen {
+ window::Mode::Fullscreen
+ } else {
+ window::Mode::Windowed
+ };
+ window::set_mode(id, mode)
+ }
+ Message::PlayerToggleOverlay(id) => {
+ if let Some(player) = self.players.get_mut(&id) {
+ player.overlay = !player.overlay;
+ }
+ Task::none()
+ }
+ Message::PlayerScreenshot(id) => {
+ let Some(player) = self.players.get_mut(&id) else {
+ return Task::none();
+ };
+
+ let (title, detail) = match player.state.capture_frame() {
+ Some(frame) => {
+ let path = self::screenshot_path(&player.game.game_id);
+ let name = path
+ .file_name()
+ .map(|n| n.to_string_lossy().into_owned())
+ .unwrap_or_default();
+ capture::save_png_async(path, frame, true);
+ ("Screenshot saved", name)
+ }
+ None => ("Screenshot failed", "No frame to capture yet".to_owned()),
+ };
+
+ player.toast = Some(Toast {
+ title: title.to_owned(),
+ detail,
+ expires: Instant::now() + TOAST_DURATION,
+ });
+ Task::none()
+ }
}
}
@@ -304,7 +379,7 @@ impl App {
if Some(window_id) == self.library_window {
self.library_view()
} else if let Some(player) = self.players.get(&window_id) {
- self.player_view(player)
+ self.player_view(window_id, player)
} else {
container(text("")).width(Length::Fill).height(Length::Fill).into()
}
@@ -359,13 +434,13 @@ impl App {
}
}
- fn player_view<'a>(&'a self, player: &'a PlayerWindow) -> Element<'a, Message> {
+ fn player_view<'a>(&'a self, window_id: window::Id, player: &'a PlayerWindow) -> Element<'a, Message> {
let palette = &self.palette;
let bg = palette.bg;
let text_color = palette.text;
let status = player.state.status();
- let shader: Element<'a, Message> = player::shader_widget(player.state.clone()).into();
+ let shader: Element<'a, Message> = player::shader_widget(player.state.clone(), window_id).into();
let overlay: Option<Element<'a, Message>> = match &status {
PlayerStatus::Ready => None,
@@ -378,11 +453,22 @@ impl App {
PlayerStatus::Failed(msg) => Some(self::overlay_card(palette, "Cannot start game", Some(msg), true)),
};
- let body: Element<'a, Message> = if let Some(ov) = overlay {
- stack![shader, ov].into()
- } else {
- shader
- };
+ let mut layers: Vec<Element<'a, Message>> = vec![shader];
+ if let Some(ov) = overlay {
+ layers.push(ov);
+ }
+ if player.overlay {
+ let (fps, native_pct) = player.state.fps();
+ layers.push(self::stats_overlay(palette, fps, native_pct));
+ }
+ if let Some(toast) = &player.toast {
+ layers.push(self::toast_overlay(palette, toast));
+ }
+
+ let body: Element<'a, Message> = Stack::with_children(layers)
+ .width(Length::Fill)
+ .height(Length::Fill)
+ .into();
container(body)
.width(Length::Fill)
@@ -452,6 +538,58 @@ fn resolve_palette(pref: ThemePreference, system_mode: Mode) -> Palette {
Palette::for_mode(effective)
}
+fn screenshot_path(game_id: &str) -> PathBuf {
+ config::exe_relative(capture::timestamped_path(game_id))
+}
+
+fn corner_card<'a>(palette: &Palette, content: Element<'a, Message>) -> Element<'a, Message> {
+ let card_bg = Color { a: 0.85, ..palette.bg };
+ let border_2 = palette.border_2;
+
+ container(content)
+ .padding(Padding::from([8, 12]))
+ .style(move |_: &Theme| container::Style {
+ background: Some(Background::Color(card_bg)),
+ border: Border {
+ color: border_2,
+ width: 1.0,
+ radius: 8.0.into(),
+ },
+ ..container::Style::default()
+ })
+ .into()
+}
+
+fn stats_overlay(palette: &Palette, fps: f32, native_pct: f32) -> Element<'static, Message> {
+ let label = text(format!("{fps:.1} FPS {native_pct:.0}%"))
+ .size(13)
+ .color(palette.text);
+ let card = self::corner_card(palette, label.into());
+
+ container(card)
+ .width(Length::Fill)
+ .align_x(iced::Alignment::End)
+ .padding(12)
+ .into()
+}
+
+fn toast_overlay<'a>(palette: &Palette, toast: &'a Toast) -> Element<'a, Message> {
+ let content = column![
+ text(&toast.title).size(13).color(palette.text),
+ text(&toast.detail).size(11).color(palette.text_dim),
+ ]
+ .spacing(2);
+ let card = self::corner_card(palette, content.into());
+
+ container(card)
+ .width(Length::Fill)
+ .height(Length::Fill)
+ .align_x(iced::Alignment::End)
+ .align_y(iced::Alignment::End)
+ .padding(12)
+ .into()
+}
+
fn overlay_card(palette: &Palette, title: &str, detail: Option<&str>, error: bool) -> Element<'static, Message> {
let bg = palette.bg;
let border_2 = palette.border_2;
diff --git a/crates/app/src/cache.rs b/crates/app/src/cache.rs
index 23b85bd..b5308b0 100644
--- a/crates/app/src/cache.rs
+++ b/crates/app/src/cache.rs
@@ -4,6 +4,7 @@ use std::time::UNIX_EPOCH;
use serde::{Deserialize, Serialize};
+use crate::config;
use crate::game::Game;
const CACHE_VERSION: u32 = 1;
@@ -54,13 +55,7 @@ impl Default for LibraryCache {
}
pub fn cache_path() -> PathBuf {
- match std::env::current_exe() {
- Ok(exe) => exe
- .parent()
- .map(|p| p.join(CACHE_DIR).join(CACHE_FILE))
- .unwrap_or_else(|| PathBuf::from(CACHE_FILE)),
- Err(_) => PathBuf::from(CACHE_FILE),
- }
+ config::exe_relative(Path::new(CACHE_DIR).join(CACHE_FILE))
}
pub fn load(path: &Path) -> LibraryCache {
diff --git a/crates/app/src/config.rs b/crates/app/src/config.rs
index e1a0589..f45d992 100644
--- a/crates/app/src/config.rs
+++ b/crates/app/src/config.rs
@@ -45,13 +45,7 @@ pub const IPL_FILE: &str = "IPL.bin";
impl Config {
pub fn system_dir_resolved(&self) -> PathBuf {
- if let Some(dir) = self.system_dir.as_ref() {
- return dir.clone();
- }
- std::env::current_exe()
- .ok()
- .and_then(|exe| exe.parent().map(|p| p.join("system")))
- .unwrap_or_else(|| PathBuf::from("system"))
+ self.system_dir.clone().unwrap_or_else(|| self::exe_relative("system"))
}
pub fn resolve_in_dir(override_path: &Option<PathBuf>, system_dir: &Path, name: &str) -> Option<PathBuf> {
@@ -63,14 +57,16 @@ impl Config {
}
}
+pub fn exe_relative(rel: impl AsRef<Path>) -> PathBuf {
+ let rel = rel.as_ref();
+ std::env::current_exe()
+ .ok()
+ .and_then(|exe| exe.parent().map(|p| p.join(rel)))
+ .unwrap_or_else(|| rel.to_path_buf())
+}
+
pub fn config_path() -> PathBuf {
- match std::env::current_exe() {
- Ok(exe) => exe
- .parent()
- .map(|p| p.join("config.toml"))
- .unwrap_or_else(|| PathBuf::from("config.toml")),
- Err(_) => PathBuf::from("config.toml"),
- }
+ self::exe_relative("config.toml")
}
pub fn load(path: &Path) -> Config {
diff --git a/crates/app/src/player/state.rs b/crates/app/src/player/state.rs
index 29e2668..f473f16 100644
--- a/crates/app/src/player/state.rs
+++ b/crates/app/src/player/state.rs
@@ -1,9 +1,11 @@
use std::path::{Path, PathBuf};
-use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::sync::{Arc, Mutex, OnceLock};
+use backend_wgpu::capture::CapturedFrame;
use backend_wgpu::sink::{Renderer, TargetAspect};
use gecko::audio::EmptyAudioSink;
+use gecko::fps::{self, FpsShared};
use gecko::gamecube::GameCube;
use gecko::hollywood::ipc::usb;
use gecko::wii::Wii;
@@ -38,6 +40,7 @@ pub struct PlayerState {
platform: Platform,
boot_error: Option<String>,
first_frame: Arc<AtomicBool>,
+ fps: FpsShared,
}
#[derive(Debug, Clone)]
@@ -86,6 +89,7 @@ impl PlayerState {
platform: game.platform,
boot_error,
first_frame: Arc::new(AtomicBool::new(false)),
+ fps: Arc::new(AtomicU64::new(0)),
})
}
@@ -185,6 +189,14 @@ impl PlayerState {
}
}
+ pub fn fps(&self) -> (f32, f32) {
+ fps::read(&self.fps)
+ }
+
+ pub fn capture_frame(&self) -> Option<CapturedFrame> {
+ self.initialized.get().and_then(|init| init.renderer.capture_xfb())
+ }
+
pub fn shutdown(&self) {
self.shutdown.store(true, Ordering::Relaxed);
}
@@ -255,7 +267,7 @@ fn player_thread(
match state.platform {
Platform::Wii => {
let mut emu = Wii::apploader_hle(dvd).build();
- self::configure_emu(&mut emu, &params, sink);
+ self::configure_emu(&mut emu, &params, sink, state.fps.clone());
emu.apply_host_input(&HostInput::neutral_for(system::WII));
let audio = self::install_audio_sink(&mut emu);
let _ = emu.load_jit_cache(&game_id);
@@ -264,7 +276,7 @@ fn player_thread(
}
Platform::Gcn => {
let mut emu = self::build_gamecube(dvd, &params);
- self::configure_emu(&mut emu, &params, sink);
+ self::configure_emu(&mut emu, &params, sink, state.fps.clone());
emu.apply_host_input(&HostInput::neutral_for(system::GC));
let audio = self::install_audio_sink(&mut emu);
let _ = emu.load_jit_cache(&game_id);
@@ -296,10 +308,12 @@ fn configure_emu<const S: gecko::system::SystemId>(
emu: &mut gecko::system::System<S>,
params: &BootParams,
sink: backend_wgpu::sink::ThreadedSink,
+ fps: FpsShared,
) {
emu.set_execution_mode(params.execution_mode);
self::load_dsp_roms(emu, params.dsp_path.as_deref(), params.coef_path.as_deref());
emu.render_sink = Box::new(sink);
+ emu.fps_counter.shared = fps;
}
fn set_initialized(state: &Arc<PlayerState>, renderer: Renderer, audio: Option<cpal::Stream>, game_id: &str) {
diff --git a/crates/app/src/player/widget.rs b/crates/app/src/player/widget.rs
index 2f2313d..c4a2724 100644
--- a/crates/app/src/player/widget.rs
+++ b/crates/app/src/player/widget.rs
@@ -1,20 +1,22 @@
use std::sync::Arc;
use iced::advanced::graphics::Viewport;
+use iced::keyboard::key::Code;
use iced::widget::shader::{self, Pipeline, Primitive, Program, Shader};
-use iced::{Rectangle, mouse};
+use iced::{Rectangle, mouse, window};
use crate::app::Message;
use crate::player::state::{self, PlayerState};
-pub fn shader_widget(state: Arc<PlayerState>) -> Shader<Message, PlayerProgram> {
- Shader::new(PlayerProgram { state })
+pub fn shader_widget(state: Arc<PlayerState>, window: window::Id) -> Shader<Message, PlayerProgram> {
+ Shader::new(PlayerProgram { state, window })
.width(iced::Length::Fill)
.height(iced::Length::Fill)
}
pub struct PlayerProgram {
state: Arc<PlayerState>,
+ window: window::Id,
}
impl Program<Message> for PlayerProgram {
@@ -37,10 +39,21 @@ impl Program<Message> for PlayerProgram {
match event {
iced::Event::Keyboard(kbd) => match kbd {
iced::keyboard::Event::KeyPressed { physical_key, .. } => {
- if let Some(code) = state::physical_to_code(physical_key) {
- self.state.handle_keyboard(code, true);
+ let hotkey = match state::physical_to_code(physical_key) {
+ Some(Code::F10) => Some(Message::PlayerToggleFullscreen(self.window)),
+ Some(Code::F11) => Some(Message::PlayerToggleOverlay(self.window)),
+ Some(Code::F12) => Some(Message::PlayerScreenshot(self.window)),
+ Some(code) => {
+ self.state.handle_keyboard(code, true);
+ None
+ }
+ None => None,
+ };
+
+ match hotkey {
+ Some(message) => Some(shader::Action::publish(message)),
+ None => Some(shader::Action::request_redraw()),
}
- Some(shader::Action::request_redraw())
}
iced::keyboard::Event::KeyReleased { physical_key, .. } => {
if let Some(code) = state::physical_to_code(physical_key) {
diff --git a/crates/backend-wgpu/src/sink.rs b/crates/backend-wgpu/src/sink.rs
index 7376c62..837f316 100644
--- a/crates/backend-wgpu/src/sink.rs
+++ b/crates/backend-wgpu/src/sink.rs
@@ -17,11 +17,11 @@ pub type FrameReadyCallback = Box<dyn Fn(Instant) + Send + Sync>;
#[cfg(not(target_arch = "wasm32"))]
const WORK_QUEUE_LIMIT: usize = 4096;
-/// Holds the XFB output texture view that the render worker updates and the
-/// windowing thread reads for blitting.
+/// Holds the XFB output texture that the render worker updates and the
+/// windowing thread reads for blitting and screenshots.
#[cfg(not(target_arch = "wasm32"))]
pub struct Shared {
- pub output: Mutex<wgpu::TextureView>,
+ pub output: Mutex<wgpu::Texture>,
}
/// How the XFB is fit into the present surface.
@@ -136,8 +136,7 @@ impl RenderWorker {
rd.begin_emulated_frame();
}
- let view = self.gx.xfb_view.clone();
- *self.shared.output.lock().unwrap() = view;
+ *self.shared.output.lock().unwrap() = self.gx.xfb_texture.clone();
if let Some(cb) = self.frame_ready_cb.get() {
cb(Instant::now());
}
@@ -312,6 +311,7 @@ pub fn action_resets_vertex_scratch(action: &GxAction) -> bool {
pub struct Renderer {
shared: Arc<Shared>,
device: wgpu::Device,
+ queue: wgpu::Queue,
blit_pipeline: wgpu::RenderPipeline,
blit_bind_group_layout: wgpu::BindGroupLayout,
blit_sampler: wgpu::Sampler,
@@ -332,9 +332,9 @@ impl Renderer {
let mut gx = GxRenderer::new(&device, &queue, surface_format);
gx.prewarm_pipeline_cache(&device);
- // Initial shared output: the XFB view (black until first PresentXfb).
+ // Initial shared output: the XFB texture (black until first PresentXfb).
let shared = Arc::new(Shared {
- output: Mutex::new(gx.xfb_view.clone()),
+ output: Mutex::new(gx.xfb_texture.clone()),
});
// Build the blit pipeline.
@@ -413,7 +413,7 @@ impl Renderer {
let worker = RenderWorker {
gx,
device: device.clone(),
- queue,
+ queue: queue.clone(),
shared: shared.clone(),
frame_ready_cb: frame_ready_cb.clone(),
recycled_draw_data_tx,
@@ -436,6 +436,7 @@ impl Renderer {
let renderer = Renderer {
shared,
device,
+ queue,
blit_pipeline,
blit_bind_group_layout,
blit_sampler,
@@ -487,6 +488,13 @@ impl Renderer {
self.target_aspect
}
+ /// Read back the most recently presented XFB frame at native emulated
+ /// resolution. Blocks until the GPU copy completes.
+ pub fn capture_xfb(&self) -> Option<crate::capture::CapturedFrame> {
+ let texture = self.shared.output.lock().unwrap().clone();
+ crate::capture::capture_texture(&self.device, &self.queue, &texture)
+ }
+
/// Blit the latest XFB output to the given render target. `target_size`
/// is the destination view's pixel size; used to letterbox/pillarbox the
/// XFB to `self.target_aspect`. Called by the windowing thread on each
@@ -514,14 +522,15 @@ impl Renderer {
target_size: (u32, u32),
load: wgpu::LoadOp<wgpu::Color>,
) {
- let output = self.shared.output.lock().unwrap();
+ let output = self.shared.output.lock().unwrap().clone();
+ let view = output.create_view(&Default::default());
let bind_group = self.device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("blit_bg"),
layout: &self.blit_bind_group_layout,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
- resource: wgpu::BindingResource::TextureView(&output),
+ resource: wgpu::BindingResource::TextureView(&view),
},
wgpu::BindGroupEntry {
binding: 1,
@@ -529,7 +538,6 @@ impl Renderer {
},
],
});
- drop(output);
encoder.push_debug_group("XFB Blit To Surface");
{