Skip to content

armgit / gecko

Public Imported from GitHub
0

A GameCube/Wii emulator and debugger written in Rust.

renderdoc capture for debugger and aspect ratio

Layle6d395edd9d0c
diff --git a/Cargo.lock b/Cargo.lock
index 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.toml
index 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.rs
index 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.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
index 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.toml
index 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.rs
index 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.rs
index 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.rs
index 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? TODO
if 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.rs
index 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.rs
index 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());