A GameCube/Wii emulator and debugger written in Rust.
renderdoc capture for debugger and aspect ratio
Layle6d395edd9d0c
diff --git a/Cargo.lock b/Cargo.lockindex 2addfe7..1ba4b10 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -237,6 +237,7 @@ dependencies = ["gecko","glam","png",+ "renderdoc","rustc-hash 2.1.2","tracing","wesl",@@ -1149,6 +1150,15 @@ dependencies = ["zlib-rs",]+[[package]]+name = "float-cmp"+version = "0.9.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "98de4bbd547a563b716d8dfa9aad1cb19bfab00f4fa09a6a4ed21dbcf44ce9c4"+dependencies = [+ "num-traits",+]+[[package]]name = "fnv"version = "1.0.7"@@ -2897,6 +2907,21 @@ version = "1.9.3"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "ba39f3699c378cd8970968dcbff9c43159ea4cfbd88d43c00b22f2ef10a435d2"+[[package]]+name = "renderdoc"+version = "0.12.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ac633a08f39bf3268714799bd8c4a1a19c19c203d817d3448bb8b91c97817cf0"+dependencies = [+ "bitflags 2.11.0",+ "float-cmp",+ "libloading",+ "once_cell",+ "renderdoc-sys",+ "winapi",+ "wio",+]+[[package]]name = "renderdoc-sys"version = "1.1.0"@@ -4553,6 +4578,15 @@ version = "0.0.19"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "d135d17ab770252ad95e9a872d365cf3090e3be864a34ab46f48555993efc904"+[[package]]+name = "wio"+version = "0.2.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "5d129932f4644ac2396cb456385cbf9e63b5b30c6e8dc4820bdca4eb082037a5"+dependencies = [+ "winapi",+]+[[package]]name = "wit-bindgen"version = "0.51.0"diff --git a/crates/backend-wgpu/Cargo.toml b/crates/backend-wgpu/Cargo.tomlindex 3328e70..d3e9166 100644--- a/crates/backend-wgpu/Cargo.toml+++ b/crates/backend-wgpu/Cargo.toml@@ -5,6 +5,7 @@ edition = "2024"[features]efb-writeback = ["gecko/efb-writeback"]+renderdoc-capture = ["dep:renderdoc"][dependencies]wgpu = "28.0.0"@@ -17,6 +18,7 @@ crossbeam-channel = "0.5.15"tracing = "0.1.44"rustc-hash = "2.1.2"png = "0.18.1"+renderdoc = { version = "0.12.1", optional = true }[build-dependencies]wesl = "0.3.2"diff --git a/crates/backend-wgpu/src/action.rs b/crates/backend-wgpu/src/action.rsindex b930ae0..c72d909 100644--- a/crates/backend-wgpu/src/action.rs+++ b/crates/backend-wgpu/src/action.rs@@ -234,6 +234,8 @@ impl GxRenderer {self.draw_bg_keys.push(self.current_bind_group_key());self.draw_viewports.push(self.current_viewport);self.draw_scissors.push(self.current_scissor);+ #[cfg(feature = "renderdoc-capture")]+ self.draw_primitives.push(draw.primitive);self.scratch_draws.push((prev_len as u32, added as u32));}@@ -375,6 +377,8 @@ impl GxRenderer {self.draw_bg_keys.clear();self.draw_viewports.clear();self.draw_scissors.clear();+ #[cfg(feature = "renderdoc-capture")]+ self.draw_primitives.clear();}fn execute_action_render_pass(&mut self, device: &wgpu::Device, queue: &wgpu::Queue) {@@ -446,7 +450,7 @@ impl GxRenderer {}let group_label = format!(- "GX Draw Flush: draws={} vertices={}",+ "GX FIFO Execution / EFB Rendering: draws={} vertices={}",self.scratch_draws.len(),self.scratch_vertices.len());@@ -469,7 +473,7 @@ impl GxRenderer {};let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {- label: Some("gx_action_render_pass"),+ label: Some("efb_rendering"),color_attachments: &[Some(wgpu::RenderPassColorAttachment {view: if crate::EFB_SAMPLE_COUNT == 1 {&self.efb_view@@ -512,6 +516,14 @@ impl GxRenderer {}for (index, (first_vertex, vertex_count)) in self.scratch_draws.iter().copied().enumerate() {+ #[cfg(feature = "renderdoc-capture")]+ let draw_label = {+ let primitive = self.draw_primitives[index];+ format!(+ "GX Primitive Batch {index}: primitive={primitive:?} first_vertex={first_vertex} vertex_count={vertex_count}"+ )+ };+ #[cfg(not(feature = "renderdoc-capture"))]let draw_label = format!("GX Draw {index}: first_vertex={first_vertex} vertex_count={vertex_count}");rpass.push_debug_group(&draw_label);let pipeline_key = &self.draw_pipeline_keys[index];diff --git a/crates/backend-wgpu/src/lib.rs b/crates/backend-wgpu/src/lib.rsindex 5e8633c..c112d13 100644--- a/crates/backend-wgpu/src/lib.rs+++ b/crates/backend-wgpu/src/lib.rs@@ -6,10 +6,14 @@ mod dump;mod helpers;mod pipeline;mod render;+#[cfg(feature = "renderdoc-capture")]+mod renderdoc_capture;pub mod sink;use encase::ShaderType as _;use gecko::common::Address;+#[cfg(feature = "renderdoc-capture")]+use gecko::flipper::gx::draw::Primitive;use gecko::flipper::gx::draw::{Scissor, TextureFormat, Viewport};use gecko::flipper::gx::regs::{AlphaCompare, BlendMode, CompareFunc, CullMode, MagFilter, MinFilter, WrapMode, ZMode};#[cfg(feature = "efb-writeback")]@@ -148,6 +152,8 @@ pub struct GxRenderer {pub(crate) draw_bg_keys: Vec<BindGroupCacheKey>,pub(crate) draw_viewports: Vec<Viewport>,pub(crate) draw_scissors: Vec<Scissor>,+ #[cfg(feature = "renderdoc-capture")]+ pub(crate) draw_primitives: Vec<Primitive>,pub(crate) frame_stride: usize,pub(crate) frame_encase_size: usize,// Tracked GX state (updated by state-change actions)@@ -637,6 +643,8 @@ impl GxRenderer {draw_bg_keys: Vec::new(),draw_viewports: Vec::new(),draw_scissors: Vec::new(),+ #[cfg(feature = "renderdoc-capture")]+ draw_primitives: Vec::new(),frame_stride: align_up(FrameUniforms::min_size().get(),device.limits().min_uniform_buffer_offset_alignment as u64,diff --git a/crates/backend-wgpu/src/render.rs b/crates/backend-wgpu/src/render.rsindex 7caa64e..b80ea6e 100644--- a/crates/backend-wgpu/src/render.rs+++ b/crates/backend-wgpu/src/render.rs@@ -364,6 +364,7 @@ impl GxRenderer {});rpass.set_pipeline(&self.efb_copy_pipeline);rpass.set_bind_group(0, &bind_group, &[]);+ rpass.insert_debug_marker("EFB copy: resolved color to texture cache");rpass.draw(0..3, 0..1);}encoder.pop_debug_group();@@ -489,6 +490,7 @@ impl GxRenderer {});rpass.set_pipeline(&self.efb_depth_resolve_pipeline);rpass.set_bind_group(0, &bind_group, &[]);+ rpass.insert_debug_marker("EFB copy: resolve depth to texture cache");rpass.draw(0..3, 0..1);}encoder.pop_debug_group();diff --git a/crates/backend-wgpu/src/renderdoc_capture.rs b/crates/backend-wgpu/src/renderdoc_capture.rsnew file mode 100644index 0000000..647c172--- /dev/null+++ b/crates/backend-wgpu/src/renderdoc_capture.rs@@ -0,0 +1,97 @@+use renderdoc::{RenderDoc, V100};++pub(crate) struct RenderDocCapture {+ api: Option<RenderDoc<V100>>,+ capture_next_emulated_frame: bool,+ active_frame_capture: bool,+}++impl RenderDocCapture {+ pub(crate) fn new() -> Self {+ let api = match RenderDoc::<V100>::new() {+ Ok(api) => {+ let version = api.get_api_version();+ tracing::info!(+ major = version.0,+ minor = version.1,+ patch = version.2,+ "RenderDoc API initialized"+ );+ Some(api)+ }+ Err(err) => {+ tracing::warn!(+ ?err,+ "RenderDoc API unavailable; captures are disabled until RenderDoc is injected or on PATH"+ );+ None+ }+ };++ Self {+ api,+ capture_next_emulated_frame: false,+ active_frame_capture: false,+ }+ }++ pub(crate) fn request_next_emulated_frame(&mut self) {+ if self.api.is_some() {+ self.capture_next_emulated_frame = true;+ tracing::info!("RenderDoc will capture the next emulated frame");+ } else {+ tracing::warn!("RenderDoc capture requested, but the RenderDoc API is unavailable");+ }+ }++ pub(crate) fn begin_emulated_frame(&mut self) {+ if self.capture_next_emulated_frame {+ self.capture_next_emulated_frame = false;+ self.start_frame_capture();+ }+ }++ pub(crate) fn end_emulated_frame(&mut self) {+ if self.active_frame_capture {+ self.end_frame_capture();+ }+ }++ pub(crate) fn start_frame_capture(&mut self) {+ let Some(api) = &mut self.api else {+ tracing::warn!("RenderDoc start_frame_capture requested, but the RenderDoc API is unavailable");+ return;+ };++ if api.is_frame_capturing() {+ tracing::warn!("RenderDoc is already capturing; ignoring start_frame_capture");+ return;+ }++ api.start_frame_capture(std::ptr::null(), std::ptr::null());+ self.active_frame_capture = true;+ tracing::info!("RenderDoc emulated frame capture started");+ }++ pub(crate) fn end_frame_capture(&mut self) {+ let Some(api) = &mut self.api else {+ tracing::warn!("RenderDoc end_frame_capture requested, but the RenderDoc API is unavailable");+ self.active_frame_capture = false;+ return;+ };++ api.end_frame_capture(std::ptr::null(), std::ptr::null());+ self.active_frame_capture = false;+ tracing::info!("RenderDoc emulated frame capture ended");+ }++ pub(crate) fn trigger_capture(&mut self) {+ let Some(api) = &mut self.api else {+ tracing::warn!("RenderDoc trigger_capture requested, but the RenderDoc API is unavailable");+ return;+ };++ api.trigger_capture();+ tracing::info!("RenderDoc host-frame trigger_capture requested");+ }+}diff --git a/crates/backend-wgpu/src/sink.rs b/crates/backend-wgpu/src/sink.rsindex 68c54b1..753ba19 100644--- a/crates/backend-wgpu/src/sink.rs+++ b/crates/backend-wgpu/src/sink.rs@@ -4,6 +4,8 @@ use crossbeam_channel::{Receiver, Sender, bounded};use gecko::host::EfbWriteback;use gecko::host::{GxAction, RenderSink};use std::sync::{Arc, Mutex};+#[cfg(feature = "renderdoc-capture")]+use std::time::Duration;const CHANNEL_CAPACITY: usize = 8192;@@ -13,8 +15,75 @@ pub struct Shared {pub output: Mutex<wgpu::TextureView>,}-fn worker(mut gx: GxRenderer, device: wgpu::Device, queue: wgpu::Queue, shared: Arc<Shared>, rx: Receiver<GxAction>) {- while let Ok(action) = rx.recv() {+/// How the XFB is fit into the present surface.+#[derive(Copy, Clone, Debug)]+pub enum TargetAspect {+ /// Fill the surface, ignoring aspect ratio.+ Stretch,+ /// Letterbox/pillarbox to the given width:height ratio.+ Ratio(f32),+}++enum WorkerMsg {+ Action(GxAction),+ #[cfg(feature = "renderdoc-capture")]+ BeginEmulatedFrame {+ ack: Sender<()>,+ },+ #[cfg(feature = "renderdoc-capture")]+ EndEmulatedFrame,+ #[cfg(feature = "renderdoc-capture")]+ CaptureNextEmulatedFrame,+ #[cfg(feature = "renderdoc-capture")]+ StartFrameCapture,+ #[cfg(feature = "renderdoc-capture")]+ EndFrameCapture,+ #[cfg(feature = "renderdoc-capture")]+ TriggerCapture,+}++fn worker(mut gx: GxRenderer, device: wgpu::Device, queue: wgpu::Queue, shared: Arc<Shared>, rx: Receiver<WorkerMsg>) {+ #[cfg(feature = "renderdoc-capture")]+ let mut renderdoc = crate::renderdoc_capture::RenderDocCapture::new();++ while let Ok(msg) = rx.recv() {+ let action = match msg {+ WorkerMsg::Action(action) => action,+ #[cfg(feature = "renderdoc-capture")]+ WorkerMsg::BeginEmulatedFrame { ack } => {+ renderdoc.begin_emulated_frame();+ submit_debug_marker(&device, &queue, "Emulated Frame Begin", "GX FIFO execution begins");+ let _ = ack.send(());+ continue;+ }+ #[cfg(feature = "renderdoc-capture")]+ WorkerMsg::EndEmulatedFrame => {+ submit_debug_marker(&device, &queue, "Emulated Frame End", "GX FIFO execution ends");+ renderdoc.end_emulated_frame();+ continue;+ }+ #[cfg(feature = "renderdoc-capture")]+ WorkerMsg::CaptureNextEmulatedFrame => {+ renderdoc.request_next_emulated_frame();+ continue;+ }+ #[cfg(feature = "renderdoc-capture")]+ WorkerMsg::StartFrameCapture => {+ renderdoc.start_frame_capture();+ continue;+ }+ #[cfg(feature = "renderdoc-capture")]+ WorkerMsg::EndFrameCapture => {+ renderdoc.end_frame_capture();+ continue;+ }+ #[cfg(feature = "renderdoc-capture")]+ WorkerMsg::TriggerCapture => {+ renderdoc.trigger_capture();+ continue;+ }+ };+gx.process_action(&device, &queue, &action);// After a PresentXfb, update the shared output so the main thread@@ -26,14 +95,24 @@ fn worker(mut gx: GxRenderer, device: wgpu::Device, queue: wgpu::Queue, shared:}}+#[cfg(feature = "renderdoc-capture")]+fn submit_debug_marker(device: &wgpu::Device, queue: &wgpu::Queue, group: &'static str, marker: &'static str) {+ let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: Some(group) });+ encoder.push_debug_group(group);+ encoder.insert_debug_marker(marker);+ encoder.pop_debug_group();+ queue.submit([encoder.finish()]);+}+#[derive(Clone)]pub struct Renderer {- tx: Sender<GxAction>,+ tx: Sender<WorkerMsg>,shared: Arc<Shared>,device: wgpu::Device,blit_pipeline: wgpu::RenderPipeline,blit_bind_group_layout: wgpu::BindGroupLayout,blit_sampler: wgpu::Sampler,+ target_aspect: TargetAspect,/// Receiver end of the EFB-to-texture writeback channel. Taken by the/// emulator setup code (via [`Renderer::take_writeback_rx`]) and/// installed into `GraphicsProcessor::efb_writeback_rx`. Wrapped in@@ -46,7 +125,12 @@ pub struct Renderer {impl Renderer {/// Create the renderer, spawning the worker thread. The caller must/// provide a wgpu device and queue.- pub fn new(device: wgpu::Device, queue: wgpu::Queue, surface_format: wgpu::TextureFormat) -> Self {+ pub fn new(+ device: wgpu::Device,+ queue: wgpu::Queue,+ surface_format: wgpu::TextureFormat,+ target_aspect: TargetAspect,+ ) -> Self {#[cfg(feature = "efb-writeback")]let mut gx = GxRenderer::new(&device, &queue, surface_format);#[cfg(not(feature = "efb-writeback"))]@@ -151,6 +235,7 @@ impl Renderer {blit_pipeline,blit_bind_group_layout,blit_sampler,+ target_aspect,#[cfg(feature = "efb-writeback")]writeback_rx: Arc::new(Mutex::new(Some(writeback_rx))),}@@ -165,9 +250,52 @@ impl Renderer {self.writeback_rx.lock().ok()?.take()}- /// Blit the latest XFB output to the given render target. Called by the- /// main thread on each redraw.- pub fn blit(&self, queue: &wgpu::Queue, target: &wgpu::TextureView) {+ pub fn target_aspect(&self) -> TargetAspect {+ self.target_aspect+ }++ #[cfg(feature = "renderdoc-capture")]+ pub fn begin_renderdoc_emulated_frame(&self) {+ let (ack_tx, ack_rx) = bounded(0);+ if self.tx.send(WorkerMsg::BeginEmulatedFrame { ack: ack_tx }).is_err() {+ tracing::warn!("failed to send RenderDoc frame-begin marker to renderer worker");+ return;+ }++ if ack_rx.recv_timeout(Duration::from_secs(1)).is_err() {+ tracing::warn!("timed out waiting for renderer worker to begin RenderDoc frame");+ }+ }++ #[cfg(feature = "renderdoc-capture")]+ pub fn end_renderdoc_emulated_frame(&self) {+ let _ = self.tx.send(WorkerMsg::EndEmulatedFrame);+ }++ #[cfg(feature = "renderdoc-capture")]+ pub fn capture_next_renderdoc_emulated_frame(&self) {+ let _ = self.tx.send(WorkerMsg::CaptureNextEmulatedFrame);+ }++ #[cfg(feature = "renderdoc-capture")]+ pub fn start_renderdoc_frame_capture(&self) {+ let _ = self.tx.send(WorkerMsg::StartFrameCapture);+ }++ #[cfg(feature = "renderdoc-capture")]+ pub fn end_renderdoc_frame_capture(&self) {+ let _ = self.tx.send(WorkerMsg::EndFrameCapture);+ }++ #[cfg(feature = "renderdoc-capture")]+ pub fn trigger_renderdoc_capture(&self) {+ let _ = self.tx.send(WorkerMsg::TriggerCapture);+ }++ /// 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 main thread on each redraw.+ pub fn blit(&self, queue: &wgpu::Queue, target: &wgpu::TextureView, target_size: (u32, u32)) {let output = self.shared.output.lock().unwrap();let bind_group = self.device.create_bind_group(&wgpu::BindGroupDescriptor {label: Some("blit_bg"),@@ -206,6 +334,8 @@ impl Renderer {timestamp_writes: None,multiview_mask: None,});+ let (vx, vy, vw, vh) = self::viewport_for_aspect(target_size, self.target_aspect);+ rpass.set_viewport(vx, vy, vw, vh, 0.0, 1.0);rpass.set_pipeline(&self.blit_pipeline);rpass.set_bind_group(0, &bind_group, &[]);rpass.insert_debug_marker("Draw fullscreen XFB blit");@@ -218,6 +348,49 @@ impl Renderer {impl RenderSink for Renderer {fn exec(&mut self, action: GxAction) {- let _ = self.tx.send(action);+ let _ = self.tx.send(WorkerMsg::Action(action));+ }+}++/// Snap a requested window size to the largest rectangle with+/// `target_aspect` that fits inside it. For Stretch this returns the input+/// unchanged. The window code calls this on resize so the OS window itself+/// matches the target AR (no letterbox bars in the surface).+pub fn snap_size_to_aspect(requested: (u32, u32), target_aspect: TargetAspect) -> (u32, u32) {+ let (w, h) = (requested.0.max(1), requested.1.max(1));+ match target_aspect {+ TargetAspect::Stretch => (w, h),+ TargetAspect::Ratio(ar) => {+ let surface_ar = w as f32 / h as f32;+ if surface_ar > ar {+ let new_w = ((h as f32) * ar).round() as u32;+ (new_w.max(1), h)+ } else {+ let new_h = ((w as f32) / ar).round() as u32;+ (w, new_h.max(1))+ }+ }+ }+}++/// Compute the (x, y, w, h) viewport rect that fits `target_aspect` inside+/// `target_size`. Stretch returns the full surface; Ratio centers a maximal+/// sub-rect with the requested width:height, leaving the cleared surface+/// visible as letterbox/pillarbox bars.+#[inline(always)]+pub(crate) fn viewport_for_aspect(target_size: (u32, u32), target_aspect: TargetAspect) -> (f32, f32, f32, f32) {+ let (w, h) = (target_size.0.max(1) as f32, target_size.1.max(1) as f32);+ match target_aspect {+ TargetAspect::Stretch => (0.0, 0.0, w, h),+ TargetAspect::Ratio(ar) => {+ let surface_ar = w / h;+ if surface_ar > ar {+ let vw = h * ar;+ ((w - vw) * 0.5, 0.0, vw, h)+ } else {+ let vh = w / ar;+ (0.0, (h - vh) * 0.5, w, vh)+ }+ }}}diff --git a/crates/debugger/Cargo.toml b/crates/debugger/Cargo.tomlindex 54c6e1e..c3c4209 100644--- a/crates/debugger/Cargo.toml+++ b/crates/debugger/Cargo.toml@@ -7,6 +7,7 @@ edition = "2024"idle-skip = ["gecko/idle-skip"]hooks-mut-traps = ["gecko/hooks-mut-traps", "scripting/hooks-mut-traps"]efb-writeback = ["backend-wgpu/efb-writeback", "gecko/efb-writeback"]+renderdoc-capture = ["backend-wgpu/renderdoc-capture"][dependencies]gecko = { path = "../gecko", features = ["hooks"] }diff --git a/crates/debugger/src/main.rs b/crates/debugger/src/main.rsindex 8ca5368..760dec8 100644--- a/crates/debugger/src/main.rs+++ b/crates/debugger/src/main.rs@@ -1,4 +1,5 @@use backend_wgpu::capture::CaptureRequest;+use backend_wgpu::sink::TargetAspect;use clap::Parser;use std::sync::Arc;use winit::application::ApplicationHandler;@@ -119,9 +120,18 @@ fn try_load_lua<const SYSTEM: gecko::SystemId>(emu: &mut gecko::System<SYSTEM>,impl ApplicationHandler for App {fn resumed(&mut self, event_loop: &ActiveEventLoop) {+ let initial_size = self+ .init+ .as_ref()+ .map(|i| initial_window_size(i.renderer.target_aspect()))+ .unwrap_or((1280, 720));let window = Arc::new(event_loop- .create_window(Window::default_attributes().with_title("Gecko"))+ .create_window(+ Window::default_attributes()+ .with_title("Gecko")+ .with_inner_size(winit::dpi::PhysicalSize::new(initial_size.0, initial_size.1)),+ ).unwrap(),);@@ -131,7 +141,13 @@ impl ApplicationHandler for App {};let surface = init.instance.create_surface(window.clone()).unwrap();- let size = window.inner_size();+ let actual = window.inner_size();+ let (sw, sh) =+ backend_wgpu::sink::snap_size_to_aspect((actual.width, actual.height), init.renderer.target_aspect());+ if (sw, sh) != (actual.width, actual.height) {+ let _ = window.request_inner_size(winit::dpi::PhysicalSize::new(sw, sh));+ }+ let size = winit::dpi::PhysicalSize::new(sw, sh);let surface_caps = surface.get_capabilities(&init.adapter);let surface_config = wgpu::SurfaceConfiguration {usage: wgpu::TextureUsages::RENDER_ATTACHMENT@@ -171,8 +187,8 @@ impl ApplicationHandler for App {match event {WindowEvent::CloseRequested => event_loop.exit(),WindowEvent::Resized(size) => {- if let Some(state) = &mut self.state {- state.resize(size.width, size.height);+ if let (Some(state), Some(window)) = (&mut self.state, &self.window) {+ state.resize(window, size.width, size.height);}}WindowEvent::KeyboardInput { event, .. } => {@@ -181,6 +197,8 @@ impl ApplicationHandler for App {if pressed && !event.repeat {if let Some(state) = &mut self.state {match key {+ #[cfg(feature = "renderdoc-capture")]+ KeyCode::F10 => state.request_renderdoc_capture(),KeyCode::F11 => state.request_screenshot(CaptureRequest::FullWindow),KeyCode::F12 => state.request_screenshot(CaptureRequest::GameOnly),_ => {}@@ -243,6 +261,37 @@ struct Args {/// Path to a Lua script for scripting hooks#[arg(long)]script: Option<String>,++ /// Display aspect ratio: auto (16:9 Wii / 4:3 GC), 4:3, 16:9, stretch+ #[arg(long, default_value = "auto")]+ aspect: String,+}++fn initial_window_size(target_aspect: TargetAspect) -> (u32, u32) {+ match target_aspect {+ TargetAspect::Stretch => (1280, 720),+ TargetAspect::Ratio(ar) => {+ let h: u32 = 720;+ let w = ((h as f32) * ar).round() as u32;+ (w, h)+ }+ }+}++fn resolve_aspect(arg: &str, is_wii: bool) -> TargetAspect {+ match arg {+ "auto" => {+ if is_wii {+ TargetAspect::Ratio(16.0 / 9.0)+ } else {+ TargetAspect::Ratio(4.0 / 3.0)+ }+ }+ "4:3" => TargetAspect::Ratio(4.0 / 3.0),+ "16:9" => TargetAspect::Ratio(16.0 / 9.0),+ "stretch" => TargetAspect::Stretch,+ other => panic!("--aspect must be auto|4:3|16:9|stretch, got {other:?}"),+ }}fn main() {@@ -330,7 +379,8 @@ fn main() {let surface_format = wgpu::TextureFormat::Bgra8Unorm;- let renderer = backend_wgpu::sink::Renderer::new(device.clone(), queue.clone(), surface_format);+ let target_aspect = resolve_aspect(&args.aspect, matches!(emulator, EmulatorVariant::Wii(_)));+ let renderer = backend_wgpu::sink::Renderer::new(device.clone(), queue.clone(), surface_format, target_aspect);emulator.install_render_sink(Box::new(renderer.clone()));diff --git a/crates/debugger/src/render.rs b/crates/debugger/src/render.rsindex 0fe95f7..227baa6 100644--- a/crates/debugger/src/render.rs+++ b/crates/debugger/src/render.rs@@ -65,12 +65,21 @@ impl RenderState {self.screenshots.request(req);}- pub fn resize(&mut self, width: u32, height: u32) {+ #[cfg(feature = "renderdoc-capture")]+ pub fn request_renderdoc_capture(&self) {+ self.renderer.capture_next_renderdoc_emulated_frame();+ }++ pub fn resize(&mut self, window: &Window, width: u32, height: u32) {if width == 0 || height == 0 {return;}- self.surface_config.width = width;- self.surface_config.height = height;+ let (sw, sh) = backend_wgpu::sink::snap_size_to_aspect((width, height), self.renderer.target_aspect());+ if (sw, sh) != (width, height) {+ let _ = window.request_inner_size(winit::dpi::PhysicalSize::new(sw, sh));+ }+ self.surface_config.width = sw;+ self.surface_config.height = sh;self.surface.configure(&self.device, &self.surface_config);}@@ -98,12 +107,17 @@ impl RenderState {debugger_ui.lua_log.extend(host.drain_logs());}+ #[cfg(feature = "renderdoc-capture")]+ self.renderer.begin_renderdoc_emulated_frame();+debugger_ui.debugger.tick(emulator);let frame = match self.surface.get_current_texture() {Ok(f) => f,Err(e) => {eprintln!("surface error: {e}");+ #[cfg(feature = "renderdoc-capture")]+ self.renderer.end_renderdoc_emulated_frame();return;}};@@ -111,7 +125,11 @@ impl RenderState {let pending_capture = self.screenshots.take_pending();// Blit the latest XFB output from the renderer worker to the swapchain.- self.renderer.blit(&self.queue, &view);+ self.renderer.blit(+ &self.queue,+ &view,+ (self.surface_config.width, self.surface_config.height),+ );// Capture the game-only screen before the egui overlay is drawn. Reads// the swapchain instead of the XFB directly so the blit's fullscreen@@ -369,6 +387,22 @@ impl RenderState {capture::save_png_async(capture::timestamped_path("full"), cap, true);}+ #[cfg(feature = "renderdoc-capture")]+ self.submit_swapchain_present_marker();frame.present();++ #[cfg(feature = "renderdoc-capture")]+ self.renderer.end_renderdoc_emulated_frame();+ }++ #[cfg(feature = "renderdoc-capture")]+ fn submit_swapchain_present_marker(&self) {+ let mut encoder = self.device.create_command_encoder(&wgpu::CommandEncoderDescriptor {+ label: Some("swapchain_present_marker_encoder"),+ });+ encoder.push_debug_group("Swapchain Present");+ encoder.insert_debug_marker("SurfaceTexture::present follows this marker");+ encoder.pop_debug_group();+ self.queue.submit([encoder.finish()]);}}diff --git a/crates/gecko/src/flipper/gx.rs b/crates/gecko/src/flipper/gx.rsindex 12cf5c1..9a69ecd 100644--- a/crates/gecko/src/flipper/gx.rs+++ b/crates/gecko/src/flipper/gx.rs@@ -215,6 +215,13 @@ pub fn present_xfb<const SYSTEM: SystemId>(gc: &mut System<SYSTEM>) {// A non-zero offset_x means this copy belongs to a different// buffer that happens to sit nearby in memory, reject it? TODOif offset_x != 0 || offset_y >= frame_h as u32 {+ tracing::warn!(+ copy_dest = copy.dest_addr,+ base = base_addr,+ offset_x,+ offset_y,+ "present_xfb: rejecting XFB copy with invalid offset"+ );continue;}diff --git a/crates/tinyapp/src/app.rs b/crates/tinyapp/src/app.rsindex f06d7ef..4f9a4dd 100644--- a/crates/tinyapp/src/app.rs+++ b/crates/tinyapp/src/app.rs@@ -60,12 +60,19 @@ impl State {}}- fn resize(&mut self, width: u32, height: u32) {+ fn resize(&mut self, window: &Window, width: u32, height: u32) {if width == 0 || height == 0 {return;}- self.surface_config.width = width;- self.surface_config.height = height;+ // Snap so the OS window matches the target aspect ratio (no bars).+ // Skip when already matching to avoid feedback from the next Resized+ // event triggered by request_inner_size.+ let (sw, sh) = backend_wgpu::sink::snap_size_to_aspect((width, height), self.renderer.target_aspect());+ if (sw, sh) != (width, height) {+ let _ = window.request_inner_size(winit::dpi::PhysicalSize::new(sw, sh));+ }+ self.surface_config.width = sw;+ self.surface_config.height = sh;self.surface.configure(&self.device, &self.surface_config);}@@ -100,7 +107,11 @@ impl State {let pending_capture = self.screenshots.take_pending();// Blit the latest XFB output from the renderer worker to the swapchain.- self.renderer.blit(&self.queue, &view);+ self.renderer.blit(+ &self.queue,+ &view,+ (self.surface_config.width, self.surface_config.height),+ );// Capture the game-only screen before the egui overlay is drawn. Reads// the swapchain instead of the XFB directly so the blit's fullscreen@@ -219,9 +230,18 @@ pub struct AppInit {impl ApplicationHandler for App {fn resumed(&mut self, event_loop: &ActiveEventLoop) {+ let initial_size = self+ .init+ .as_ref()+ .map(|i| initial_window_size(i.renderer.target_aspect()))+ .unwrap_or((1280, 720));let window = Arc::new(event_loop- .create_window(Window::default_attributes().with_title("Gecko"))+ .create_window(+ Window::default_attributes()+ .with_title("Gecko")+ .with_inner_size(winit::dpi::PhysicalSize::new(initial_size.0, initial_size.1)),+ ).unwrap(),);@@ -231,7 +251,13 @@ impl ApplicationHandler for App {};let surface = init.instance.create_surface(window.clone()).unwrap();- let size = window.inner_size();+ let actual = window.inner_size();+ let (sw, sh) =+ backend_wgpu::sink::snap_size_to_aspect((actual.width, actual.height), init.renderer.target_aspect());+ if (sw, sh) != (actual.width, actual.height) {+ let _ = window.request_inner_size(winit::dpi::PhysicalSize::new(sw, sh));+ }+ let size = winit::dpi::PhysicalSize::new(sw, sh);let surface_caps = surface.get_capabilities(&init.adapter);let surface_config = wgpu::SurfaceConfiguration {usage: wgpu::TextureUsages::RENDER_ATTACHMENT@@ -269,8 +295,8 @@ impl ApplicationHandler for App {match event {WindowEvent::CloseRequested => event_loop.exit(),WindowEvent::Resized(size) => {- if let Some(state) = &mut self.state {- state.resize(size.width, size.height);+ if let (Some(state), Some(window)) = (&mut self.state, &self.window) {+ state.resize(window, size.width, size.height);}}WindowEvent::KeyboardInput { event, .. } => {@@ -304,3 +330,17 @@ impl ApplicationHandler for App {}}}++/// Pick a sensible initial window size for the given target aspect.+fn initial_window_size(target_aspect: backend_wgpu::sink::TargetAspect) -> (u32, u32) {+ use backend_wgpu::sink::TargetAspect;+ match target_aspect {+ TargetAspect::Stretch => (1280, 720),+ TargetAspect::Ratio(ar) => {+ // 720 lines tall, width derived from AR.+ let h: u32 = 720;+ let w = ((h as f32) * ar).round() as u32;+ (w, h)+ }+ }+}diff --git a/crates/tinyapp/src/main.rs b/crates/tinyapp/src/main.rsindex 9e802b4..ebdcde5 100644--- a/crates/tinyapp/src/main.rs+++ b/crates/tinyapp/src/main.rs@@ -1,11 +1,12 @@mod app;mod thread;+use backend_wgpu::sink::TargetAspect;use clap::Parser;use crossbeam_channel::bounded;use gecko::flipper::si::pad::{self, PadStatus, STICK_CENTER};use gecko::gamecube::GameCube;-use gecko::system::{System, SystemId};+use gecko::system::{self, System, SystemId};use gecko::wii::Wii;use image::Dol;use std::sync::{Arc, Mutex};@@ -52,6 +53,26 @@ struct Args {#[cfg(feature = "scripting")]#[arg(long)]script: Option<String>,++ /// Display aspect ratio: auto (16:9 Wii / 4:3 GC), 4:3, 16:9, stretch+ #[arg(long, default_value = "auto")]+ aspect: String,+}++fn resolve_aspect(arg: &str, system: SystemId) -> TargetAspect {+ match arg {+ "auto" => {+ if system == system::WII {+ TargetAspect::Ratio(16.0 / 9.0)+ } else {+ TargetAspect::Ratio(4.0 / 3.0)+ }+ }+ "4:3" => TargetAspect::Ratio(4.0 / 3.0),+ "16:9" => TargetAspect::Ratio(16.0 / 9.0),+ "stretch" => TargetAspect::Stretch,+ other => panic!("--aspect must be auto|4:3|16:9|stretch, got {other:?}"),+ }}fn main() {@@ -81,11 +102,11 @@ fn main() {if args.wii {let mut emulator = Wii::with_image(&dol);configure(&mut emulator, &args);- run(emulator, present_mode);+ run(emulator, present_mode, &args.aspect);} else {let mut emulator = GameCube::with_image(&dol);configure(&mut emulator, &args);- run(emulator, present_mode);+ run(emulator, present_mode, &args.aspect);}} else if let Some(ref ipl_path) = args.ipl {let ipl_data = std::fs::read(ipl_path).expect("failed to read IPL");@@ -95,7 +116,7 @@ fn main() {emulator.insert_dvd(image::load_dvd(dvd_data));}configure(&mut emulator, &args);- run(emulator, present_mode);+ run(emulator, present_mode, &args.aspect);} else if let Some(ref dvd_path) = args.dvd {let dvd_data = std::fs::read(dvd_path).expect("failed to read DVD");let dvd = image::load_dvd(dvd_data);@@ -111,12 +132,12 @@ fn main() {};let mut emulator = builder.build();configure(&mut emulator, &args);- run(emulator, present_mode);+ run(emulator, present_mode, &args.aspect);} else {println!("Detected GameCube disc, booting via IPL HLE");let mut emulator = GameCube::with_ipl_hle(dvd);configure(&mut emulator, &args);- run(emulator, present_mode);+ run(emulator, present_mode, &args.aspect);}} else {panic!("provide one of --dol, --ipl, or --dvd");@@ -145,7 +166,8 @@ fn configure<const SYSTEM: SystemId>(emulator: &mut System<SYSTEM>, args: &Args)});}-fn run<const SYSTEM: SystemId>(mut emulator: System<SYSTEM>, present_mode: wgpu::PresentMode) {+fn run<const SYSTEM: SystemId>(mut emulator: System<SYSTEM>, present_mode: wgpu::PresentMode, aspect_arg: &str) {+ let target_aspect = resolve_aspect(aspect_arg, SYSTEM);let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor {backends: wgpu::Backends::all(),..Default::default()@@ -163,7 +185,7 @@ fn run<const SYSTEM: SystemId>(mut emulator: System<SYSTEM>, present_mode: wgpu:let surface_format = wgpu::TextureFormat::Bgra8Unorm;- let renderer = backend_wgpu::sink::Renderer::new(device.clone(), queue.clone(), surface_format);+ let renderer = backend_wgpu::sink::Renderer::new(device.clone(), queue.clone(), surface_format, target_aspect);emulator.render_sink = Box::new(renderer.clone());