Skip to content

armgit / gecko

Public Imported from GitHub
0

A GameCube/Wii emulator and debugger written in Rust.

23.9 KB
Raw Blame
use backend_wgpu::capture::{self, CaptureRequest, ScreenshotControl};
use egui::ViewportId;
use gecko::HostInput;
#[cfg(feature = "fps-counter")]
use gecko::fps::{self, FpsShared};
use gecko::hollywood::ipc::usb;
use spin_sleep::SpinSleeper;
use std::collections::VecDeque;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};
use winit::application::ApplicationHandler;
use winit::event::{MouseButton, WindowEvent};
use winit::event_loop::ActiveEventLoop;
use winit::keyboard::{KeyCode, PhysicalKey};
use winit::window::{Window, WindowId};

const PACER_OFFSET: Duration = Duration::from_millis(1);
const FRAME_PERIOD_60HZ: Duration = Duration::from_nanos(16_666_667);
const CADENCE_WINDOW: usize = 16;
const CADENCE_MIN_SAMPLES: usize = 4;
const CADENCE_MIN: Duration = Duration::from_micros(500);
const CADENCE_MAX: Duration = Duration::from_millis(200);

pub struct State {
    surface: wgpu::Surface<'static>,
    surface_config: wgpu::SurfaceConfiguration,
    device: wgpu::Device,
    queue: wgpu::Queue,
    renderer: backend_wgpu::sink::Renderer,

    egui_ctx: egui::Context,
    egui_renderer: egui_wgpu::Renderer,
    egui_winit: egui_winit::State,
    #[cfg(not(feature = "fps-counter"))]
    last_frame: Instant,
    screenshots: ScreenshotControl,
    #[cfg(feature = "fps-counter")]
    fps_shared: FpsShared,
    intended_present_time: Option<Instant>,
    frame_period: Duration,
    pacer_offset: Duration,
    pacer_sleeper: SpinSleeper,
    last_frame_ready_at: Option<Instant>,
    recent_intervals: VecDeque<Duration>,
}

impl State {
    pub fn new(
        window: Arc<Window>,
        device: wgpu::Device,
        queue: wgpu::Queue,
        surface: wgpu::Surface<'static>,
        surface_config: wgpu::SurfaceConfiguration,
        renderer: backend_wgpu::sink::Renderer,
        #[cfg(feature = "fps-counter")] fps_shared: FpsShared,
    ) -> Self {
        let egui_ctx = egui::Context::default();
        let egui_renderer =
            egui_wgpu::Renderer::new(&device, surface_config.format, egui_wgpu::RendererOptions::default());
        let egui_winit = egui_winit::State::new(egui_ctx.clone(), ViewportId::ROOT, window.as_ref(), None, None, None);

        State {
            surface,
            surface_config,
            device,
            queue,
            renderer,
            egui_ctx,
            egui_renderer,
            egui_winit,
            #[cfg(not(feature = "fps-counter"))]
            last_frame: Instant::now(),
            screenshots: ScreenshotControl::new(),
            #[cfg(feature = "fps-counter")]
            fps_shared,
            intended_present_time: None,
            frame_period: FRAME_PERIOD_60HZ,
            pacer_offset: PACER_OFFSET,
            pacer_sleeper: SpinSleeper::default(),
            last_frame_ready_at: None,
            recent_intervals: VecDeque::with_capacity(CADENCE_WINDOW),
        }
    }

    pub fn observe_frame_ready(&mut self, at: Instant) {
        let Some(prev) = self.last_frame_ready_at.replace(at) else {
            return;
        };

        let Some(delta) = at.checked_duration_since(prev) else {
            return;
        };

        if !(CADENCE_MIN..=CADENCE_MAX).contains(&delta) {
            return;
        }

        if self.recent_intervals.len() == CADENCE_WINDOW {
            self.recent_intervals.pop_front();
        }

        self.recent_intervals.push_back(delta);
        let n = self.recent_intervals.len();
        if n < CADENCE_MIN_SAMPLES {
            return;
        }

        let mut buf = [Duration::ZERO; CADENCE_WINDOW];
        for (slot, d) in buf.iter_mut().zip(self.recent_intervals.iter()) {
            *slot = *d;
        }
        buf[..n].sort();

        self.frame_period = buf[n / 2];
    }

    fn resize(&mut self, window: &Window, width: u32, height: u32) {
        if width == 0 || height == 0 {
            return;
        }
        // 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);
    }

    fn render(&mut self, window: &Window, waiting: bool, notice: Option<&str>) {
        if !waiting && let Some(intended) = self.intended_present_time {
            let target = intended + self.pacer_offset;
            let now = Instant::now();
            if target > now {
                self.pacer_sleeper.sleep(target - now);
            }
        }

        let frame = match self.surface.get_current_texture() {
            wgpu::CurrentSurfaceTexture::Success(f) | wgpu::CurrentSurfaceTexture::Suboptimal(f) => f,
            status => {
                tracing::error!(?status, "surface error");
                return;
            }
        };
        let view = frame.texture.create_view(&Default::default());

        #[cfg(feature = "fps-counter")]
        let (fps, native_pct) = if waiting {
            (0.0, 0.0)
        } else {
            fps::read(&self.fps_shared)
        };
        #[cfg(not(feature = "fps-counter"))]
        let fps = if waiting {
            0.0
        } else {
            let delta = self.last_frame.elapsed().as_secs_f64();
            self.last_frame = Instant::now();
            if delta > 0.0 { 1.0 / delta } else { 0.0 }
        };

        let pending_capture = if waiting {
            CaptureRequest::None
        } else {
            self.screenshots.take_pending()
        };

        if !waiting {
            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
            // sample resolves any partial-update state in the XFB accumulator.
            if let CaptureRequest::GameOnly = pending_capture
                && let Some(cap) = capture::capture_texture(&self.device, &self.queue, &frame.texture)
            {
                capture::save_png_async(capture::timestamped_path("game"), cap, true);
            }
        }

        let raw_input = self.egui_winit.take_egui_input(window);
        let full_output = self.egui_ctx.run_ui(raw_input, |ui| {
            let ctx = ui.ctx().clone();
            if let Some(message) = notice {
                egui::Window::new("Wii input")
                    .title_bar(false)
                    .resizable(false)
                    .movable(false)
                    .anchor(egui::Align2::CENTER_TOP, [0.0, 12.0])
                    .show(&ctx, |ui| {
                        ui.label(message);
                    });
            }
            if waiting {
                let frame = egui::Frame::window(&ctx.global_style())
                    .fill(egui::Color32::from_rgba_unmultiplied(20, 20, 20, 220));
                egui::Window::new("wait_modal")
                    .title_bar(false)
                    .resizable(false)
                    .movable(false)
                    .anchor(egui::Align2::CENTER_CENTER, [0.0, 0.0])
                    .frame(frame)
                    .default_width(280.0)
                    .show(&ctx, |ui| {
                        ui.vertical_centered(|ui| {
                            ui.add_space(4.0);
                            ui.label(egui::RichText::new("Gecko").size(20.0).strong());
                            ui.label("GameCube / Wii emulator");
                            ui.add_space(6.0);
                            ui.hyperlink_to("https://github.com/ioncodes/gecko", "https://github.com/ioncodes/gecko");
                            ui.add_space(8.0);
                        });

                        ui.separator();
                        ui.add_space(4.0);

                        ui.label(egui::RichText::new("Author").strong());
                        ui.label("Layle");

                        ui.add_space(8.0);

                        ui.label(egui::RichText::new("Acknowledgements").strong());
                        ui.label("zayd");
                        ui.label("vxpm");
                        ui.label("hazelwiss");
                        ui.label("Dolphin team");

                        ui.add_space(10.0);
                        ui.separator();
                        ui.add_space(4.0);
                        ui.vertical_centered(|ui| {
                            ui.label(
                                egui::RichText::new("press space to start")
                                    .size(13.0)
                                    .color(egui::Color32::from_gray(170)),
                            );
                        });
                    });
            } else {
                let frame = egui::Frame::window(&ctx.global_style())
                    .fill(egui::Color32::from_rgba_unmultiplied(20, 20, 20, 180));
                egui::Window::new("perf_hud")
                    .title_bar(false)
                    .resizable(false)
                    .movable(false)
                    .anchor(egui::Align2::RIGHT_TOP, [-8.0, 8.0])
                    .frame(frame)
                    .show(&ctx, |ui| {
                        #[cfg(feature = "fps-counter")]
                        ui.label(egui::RichText::new(format!("{fps:.1} FPS  {native_pct:.1}%")).monospace());
                        #[cfg(not(feature = "fps-counter"))]
                        ui.label(egui::RichText::new(format!("{fps:.1} FPS")).monospace());
                    });
            }
        });

        self.egui_winit
            .handle_platform_output(window, full_output.platform_output);

        let screen_desc = egui_wgpu::ScreenDescriptor {
            size_in_pixels: [self.surface_config.width, self.surface_config.height],
            pixels_per_point: window.scale_factor() as f32,
        };
        let tris = self
            .egui_ctx
            .tessellate(full_output.shapes, screen_desc.pixels_per_point);

        for (id, delta) in full_output.textures_delta.set {
            self.egui_renderer.update_texture(&self.device, &self.queue, id, &delta);
        }

        let mut encoder = self
            .device
            .create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
        self.egui_renderer
            .update_buffers(&self.device, &self.queue, &mut encoder, &tris, &screen_desc);
        {
            let load = if waiting {
                wgpu::LoadOp::Clear(wgpu::Color {
                    r: 0.07,
                    g: 0.07,
                    b: 0.08,
                    a: 1.0,
                })
            } else {
                wgpu::LoadOp::Load
            };
            let rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                label: Some("egui"),
                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
                    view: &view,
                    resolve_target: None,
                    ops: wgpu::Operations {
                        load,
                        store: wgpu::StoreOp::Store,
                    },
                    depth_slice: None,
                })],
                depth_stencil_attachment: None,
                timestamp_writes: None,
                occlusion_query_set: None,
                multiview_mask: None,
            });
            self.egui_renderer
                .render(&mut rpass.forget_lifetime(), &tris, &screen_desc);
        }
        self.queue.submit([encoder.finish()]);

        for id in full_output.textures_delta.free {
            self.egui_renderer.free_texture(&id);
        }

        if let CaptureRequest::FullWindow = pending_capture
            && let Some(cap) = capture::capture_texture(&self.device, &self.queue, &frame.texture)
        {
            capture::save_png_async(capture::timestamped_path("full"), cap, true);
        }

        frame.present();

        if !waiting {
            let now = Instant::now();
            let base = self.intended_present_time.unwrap_or(now);
            let next = (base + self.frame_period).max(now);
            self.intended_present_time = Some(next);
        }
    }
}

pub struct App {
    pub input: Arc<Mutex<HostInput>>,
    pub wii_notice: Option<(Instant, &'static str)>,
    pub window: Option<Arc<Window>>,
    pub state: Option<State>,
    pub present_mode: wgpu::PresentMode,
    pub init: Option<AppInit>,
    pub _audio_stream: Option<cpal::Stream>,
    pub shutdown_requested: Arc<AtomicBool>,
    pub start_gate: Arc<AtomicBool>,
    pub savestate_requests: Arc<crate::SavestateRequests>,
    #[cfg(feature = "fps-counter")]
    pub fps_shared: FpsShared,
}

impl App {
    fn waiting(&self) -> bool {
        !self.start_gate.load(Ordering::Acquire)
    }
}

pub struct AppInit {
    pub instance: wgpu::Instance,
    pub adapter: wgpu::Adapter,
    pub device: wgpu::Device,
    pub queue: wgpu::Queue,
    pub renderer: backend_wgpu::sink::Renderer,
    pub surface_format: wgpu::TextureFormat,
}

impl ApplicationHandler<crate::UserEvent> 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("Tiny Gecko")
                        .with_inner_size(winit::dpi::PhysicalSize::new(initial_size.0, initial_size.1)),
                )
                .unwrap(),
        );

        let Some(init) = self.init.take() else {
            self.window = Some(window);
            return;
        };

        let surface = init.instance.create_surface(window.clone()).unwrap();
        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
                | wgpu::TextureUsages::COPY_DST
                | wgpu::TextureUsages::COPY_SRC,
            format: init.surface_format,
            width: size.width.max(1),
            height: size.height.max(1),
            present_mode: self.present_mode,
            alpha_mode: surface_caps.alpha_modes[0],
            view_formats: vec![],
            desired_maximum_frame_latency: 2,
        };
        surface.configure(&init.device, &surface_config);

        let state = State::new(
            window.clone(),
            init.device,
            init.queue,
            surface,
            surface_config,
            init.renderer,
            #[cfg(feature = "fps-counter")]
            self.fps_shared.clone(),
        );
        window.request_redraw();
        self.window = Some(window);
        self.state = Some(state);
    }

    fn window_event(&mut self, event_loop: &ActiveEventLoop, _id: WindowId, event: WindowEvent) {
        let mut egui_consumed = false;
        // Forward events to egui first
        if let (Some(state), Some(window)) = (&mut self.state, &self.window) {
            egui_consumed = state.egui_winit.on_window_event(window, &event).consumed;
        }

        match event {
            WindowEvent::CloseRequested => {
                self.shutdown_requested.store(true, Ordering::Relaxed);
                event_loop.exit();
            }
            WindowEvent::Resized(size) => {
                if let (Some(state), Some(window)) = (&mut self.state, &self.window) {
                    state.resize(window, size.width, size.height);
                }
            }
            WindowEvent::KeyboardInput { event, .. } => {
                let pressed = event.state.is_pressed();
                if let PhysicalKey::Code(key) = event.physical_key {
                    if !egui_consumed && pressed && !event.repeat && matches!(key, KeyCode::F8 | KeyCode::F9) {
                        if let HostInput::Wii {
                            nunchuk_attached,
                            sideways,
                            ..
                        } = &mut *self.input.lock().unwrap()
                        {
                            let message = if key == KeyCode::F8 {
                                *nunchuk_attached = !*nunchuk_attached;
                                if *nunchuk_attached {
                                    "Nunchuk attached"
                                } else {
                                    "Nunchuk detached"
                                }
                            } else {
                                *sideways = !*sideways;
                                if *sideways {
                                    "Wiimote sideways"
                                } else {
                                    "Wiimote upright"
                                }
                            };
                            self.wii_notice = Some((Instant::now(), message));
                            if let Some(window) = &self.window {
                                window.request_redraw();
                            }
                        }
                        return;
                    }
                    if self.waiting() {
                        if pressed && !event.repeat && key == KeyCode::Space {
                            self.start_gate.store(true, Ordering::Release);
                            if let Some(window) = &self.window {
                                window.request_redraw();
                            }
                        }
                        return;
                    }

                    if pressed && !event.repeat {
                        if let Some(state) = &mut self.state {
                            match key {
                                #[cfg(feature = "renderdoc-capture")]
                                KeyCode::F10 => state.renderer.capture_next_renderdoc_emulated_frame(),
                                KeyCode::F11 => state.screenshots.request(CaptureRequest::FullWindow),
                                KeyCode::F12 => state.screenshots.request(CaptureRequest::GameOnly),
                                _ => {}
                            }
                        }

                        match key {
                            KeyCode::F5 => self.savestate_requests.save.store(true, Ordering::Relaxed),
                            KeyCode::F7 => self.savestate_requests.load.store(true, Ordering::Relaxed),
                            _ => {}
                        }
                    }

                    let mut input = self.input.lock().unwrap();
                    match &mut *input {
                        HostInput::Gc(pad) => crate::update_pad(pad, key, pressed),
                        HostInput::Wii {
                            wiimote_buttons,
                            wiimote_shake,
                            nunchuk_buttons,
                            nunchuk_stick_x,
                            nunchuk_stick_y,
                            ..
                        } => {
                            crate::update_wiimote_keys(wiimote_buttons, key, pressed);
                            crate::update_wiimote_motion_keys(wiimote_shake, key, pressed);
                            crate::update_nunchuk_keys(nunchuk_buttons, nunchuk_stick_x, nunchuk_stick_y, key, pressed);
                        }
                    }
                }
            }
            WindowEvent::MouseInput { state, button, .. } => {
                let pressed = state.is_pressed();
                let mask = match button {
                    MouseButton::Left => Some(usb::BTN_A),
                    MouseButton::Right => Some(usb::BTN_B),
                    _ => None,
                };
                if let Some(mask) = mask {
                    let mut input = self.input.lock().unwrap();

                    if let HostInput::Wii { wiimote_buttons, .. } = &mut *input {
                        let next = if pressed {
                            *wiimote_buttons | mask
                        } else {
                            *wiimote_buttons & !mask
                        };

                        if next != *wiimote_buttons {
                            *wiimote_buttons = next;
                            tracing::debug!(
                                mask = format!("{mask:#06x}"),
                                pressed,
                                "host mouse button mapped to Wiimote"
                            );
                        }
                    }
                }
            }
            WindowEvent::CursorMoved { position, .. } => {
                let Some(window) = &self.window else {
                    return;
                };

                let size = window.inner_size();
                if size.width == 0 || size.height == 0 {
                    return;
                }

                let aim_x = (position.x / size.width as f64) as f32;
                let aim_y = (position.y / size.height as f64) as f32;
                let (ir_x, ir_y) = gecko::input::aim_to_ir(aim_x, aim_y);

                let mut input = self.input.lock().unwrap();
                if let HostInput::Wii { ir_pointer, .. } = &mut *input
                    && *ir_pointer != Some((ir_x, ir_y))
                {
                    *ir_pointer = Some((ir_x, ir_y));
                }
            }
            WindowEvent::CursorLeft { .. } => {
                let mut input = self.input.lock().unwrap();
                if let HostInput::Wii { ir_pointer, .. } = &mut *input {
                    *ir_pointer = None;
                }
            }
            WindowEvent::RedrawRequested => {
                let waiting = self.waiting();
                if let (Some(state), Some(window)) = (&mut self.state, &self.window) {
                    let notice = self
                        .wii_notice
                        .filter(|(at, _)| at.elapsed() < Duration::from_secs(3))
                        .map(|(_, text)| text);
                    state.render(window, waiting, notice);
                }
            }
            _ => {}
        }
    }

    fn user_event(&mut self, event_loop: &ActiveEventLoop, event: crate::UserEvent) {
        match event {
            crate::UserEvent::Shutdown => {
                self.shutdown_requested.store(true, Ordering::Relaxed);
                event_loop.exit();
            }
            crate::UserEvent::FrameReady { at } => {
                if self.shutdown_requested.load(Ordering::Relaxed) {
                    event_loop.exit();
                    return;
                }

                if let Some(state) = self.state.as_mut() {
                    state.observe_frame_ready(at);
                }

                if let Some(window) = &self.window {
                    window.request_redraw();
                }
            }
        }
    }
}

/// 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)
        }
    }
}