Skip to content

armgit / gecko

Public Imported from GitHub
0

A GameCube/Wii emulator and debugger written in Rust.

48.3 KB
Raw Blame
use super::slice::CmdKind;
use super::{DebugSession, RunState, disasm};
use crate::playback::PlayerSink;
use backend_wgpu::GxRenderer;
use backend_wgpu::sink::InlineSink;
use egui::ViewportId;
use egui_phosphor::regular as icons;
use gecko::flipper::gx::constants::{BP_GEN_MODE, BP_PE_ALPHA_COMPARE, BP_PE_CMODE0, BP_PE_ZMODE};
use gecko::flipper::gx::regs::{AlphaCompare, BlendMode, GenMode, ZMode};
use gecko::system::SystemId;
use std::collections::HashSet;
use std::path::PathBuf;
use std::sync::{Arc, Mutex};
use winit::application::ApplicationHandler;
use winit::event::WindowEvent;
use winit::event_loop::{ActiveEventLoop, EventLoop};
use winit::window::{Window, WindowId};

#[derive(Copy, Clone, PartialEq, Eq)]
enum ViewMode {
    Auto,
    Efb,
    Xfb,
    Depth,
}

#[derive(Copy, Clone, PartialEq, Eq)]
enum Tab {
    Disasm,
    Registers,
    Hex,
    Breakpoints,
}

#[derive(Copy, Clone, PartialEq, Eq)]
enum Selection {
    None,
    Cmd(usize),
    Child(usize, usize),
}

#[derive(Clone)]
enum Row {
    Cmd(usize),
    DlChild { parent: usize, child: usize },
    Update(usize),
    FrameEnd,
}

enum UiAction {
    SelectDraw(usize),
    CaptureDepth,
    StepCmd,
    StepDraw,
    StepFrame,
    RunPause,
    RunToSelection,
    Restart,
    RestartFrame,
    JumpTo(usize, usize),
    ToggleDisabled(usize),
    ToggleRowBp(usize),
    ToggleExpand(usize),
    ApplyHex(usize, Vec<u8>),
    Revert(usize),
    Save,
}

pub fn run_debug<const SYSTEM: SystemId>(file: dff::DffFile, path: PathBuf, start: usize, end: usize) {
    let (instance, adapter, device, queue) = crate::init_wgpu();

    let (gx, sink) = InlineSink::new(device.clone(), queue.clone(), wgpu::TextureFormat::Rgba8Unorm);
    let sink = PlayerSink::new(Box::new(sink));
    let session = DebugSession::<SYSTEM>::new(file, path, start, end, sink);

    let egui_ctx = egui::Context::default();

    let mut fonts = egui::FontDefinitions::default();
    egui_phosphor::add_to_fonts(&mut fonts, egui_phosphor::Variant::Regular);
    if let Some(mono) = fonts.families.get_mut(&egui::FontFamily::Monospace) {
        mono.push("phosphor".into());
    }
    fonts
        .font_data
        .insert("phosphor-fill".into(), egui_phosphor::Variant::Fill.font_data().into());
    fonts.families.insert(
        egui::FontFamily::Name("phosphor-fill".into()),
        vec!["phosphor-fill".into()],
    );

    egui_ctx.set_fonts(fonts);

    let mut app = DebugApp::<SYSTEM> {
        session,
        gx,
        instance,
        adapter,
        device,
        queue,
        window: None,
        surface: None,
        egui_ctx,
        egui_winit: None,
        egui_renderer: None,
        efb_tex: None,
        xfb_tex: None,
        xfb_size: (1, 1),
        seen_presents: 0,
        view_mode: ViewMode::Auto,
        inspector_tab: Tab::Disasm,
        selection: Selection::None,
        expanded: HashSet::new(),
        rows: Vec::new(),
        cmd_flat: Vec::new(),
        rows_key: (usize::MAX, 0, 0),
        expanded_version: 0,
        scroll_to_current: false,
        hex_text: String::new(),
        hex_for: None,
        bp_input: String::new(),
        status_msg: String::new(),
        geometry_subdraw: 0,
        depth_view: super::depth_view::DepthView::default(),
    };

    let event_loop = EventLoop::new().unwrap();
    event_loop.run_app(&mut app).unwrap();
}

pub fn run_headless<const SYSTEM: SystemId>(
    file: dff::DffFile,
    path: PathBuf,
    start: usize,
    end: usize,
    out: &std::path::Path,
    aspect: backend_wgpu::sink::TargetAspect,
) {
    let (_instance, _adapter, device, queue) = crate::init_wgpu();

    let (gx, sink) = InlineSink::new(device.clone(), queue.clone(), wgpu::TextureFormat::Rgba8Unorm);
    let sink = PlayerSink::new(Box::new(sink));
    let mut session = DebugSession::<SYSTEM>::new(file, path, start, end, sink);

    session.resume(RunState::Running);

    while !session.finished {
        session.run_tick();
    }

    eprintln!("debug-stepped frames {start}..={end}, {} presents", session.presents);

    let _ = device.poll(wgpu::PollType::Wait {
        submission_index: None,
        timeout: None,
    });

    let g = gx.lock().unwrap();
    let captured = backend_wgpu::capture::capture_texture(&device, &queue, &g.xfb_texture)
        .expect("XFB capture failed")
        .with_aspect(aspect);
    backend_wgpu::capture::write_png(out, captured, true).expect("failed to write PNG");
    eprintln!("wrote {}", out.display());
}

struct DebugApp<const SYSTEM: SystemId> {
    session: DebugSession<SYSTEM>,
    gx: Arc<Mutex<GxRenderer>>,
    instance: wgpu::Instance,
    adapter: wgpu::Adapter,
    device: wgpu::Device,
    queue: wgpu::Queue,
    window: Option<Arc<Window>>,
    surface: Option<(wgpu::Surface<'static>, wgpu::SurfaceConfiguration)>,
    egui_ctx: egui::Context,
    egui_winit: Option<egui_winit::State>,
    egui_renderer: Option<egui_wgpu::Renderer>,
    efb_tex: Option<egui::TextureId>,
    xfb_tex: Option<egui::TextureId>,
    xfb_size: (u32, u32),
    seen_presents: u64,

    view_mode: ViewMode,
    inspector_tab: Tab,
    selection: Selection,
    expanded: HashSet<usize>,
    rows: Vec<Row>,
    cmd_flat: Vec<usize>,
    rows_key: (usize, u64, u64),
    expanded_version: u64,
    scroll_to_current: bool,
    hex_text: String,
    hex_for: Option<usize>,
    bp_input: String,
    status_msg: String,
    geometry_subdraw: usize,
    depth_view: super::depth_view::DepthView,
}

const SURFACE_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Bgra8Unorm;

impl<const SYSTEM: SystemId> DebugApp<SYSTEM> {
    fn flush_gx(&self) {
        self.gx.lock().unwrap().debug_flush(&self.device, &self.queue);
    }

    fn refresh_xfb_binding(&mut self) {
        if self.seen_presents == self.session.presents {
            return;
        }
        self.seen_presents = self.session.presents;

        let (Some(renderer), Some(id)) = (self.egui_renderer.as_mut(), self.xfb_tex) else {
            return;
        };
        let g = self.gx.lock().unwrap();
        renderer.update_egui_texture_from_wgpu_texture(&self.device, &g.xfb_view, wgpu::FilterMode::Linear, id);

        let size = g.xfb_texture.size();
        self.xfb_size = (size.width, size.height);
    }

    fn rebuild_rows(&mut self) {
        let key = (
            self.session.frame_idx,
            self.session.index_version,
            self.expanded_version,
        );
        if self.rows_key == key {
            return;
        }
        self.rows_key = key;

        let cmds = &self.session.index.commands;
        let updates = &self.session.cur.updates;
        let mut rows = Vec::with_capacity(cmds.len() + updates.len() + 1);
        let mut cmd_flat = vec![0usize; cmds.len() + 1];
        let mut u = 0usize;

        for (i, cmd) in cmds.iter().enumerate() {
            while u < updates.len() && (updates[u].fifo_position as usize) < cmd.end() {
                rows.push(Row::Update(u));
                u += 1;
            }

            cmd_flat[i] = rows.len();
            rows.push(Row::Cmd(i));

            if let CmdKind::CallDl { children, .. } = &cmd.kind
                && self.expanded.contains(&cmd.offset)
            {
                for j in 0..children.len() {
                    rows.push(Row::DlChild { parent: i, child: j });
                }
            }
        }
        while u < updates.len() {
            rows.push(Row::Update(u));
            u += 1;
        }
        cmd_flat[cmds.len()] = rows.len();
        rows.push(Row::FrameEnd);

        self.rows = rows;
        self.cmd_flat = cmd_flat;
    }

    fn selected_command(&self) -> Option<&super::slice::Command> {
        match self.selection {
            Selection::None => None,
            Selection::Cmd(i) => self.session.index.commands.get(i),
            Selection::Child(p, c) => match &self.session.index.commands.get(p)?.kind {
                CmdKind::CallDl { children, .. } => children.get(c),
                _ => None,
            },
        }
    }

    fn apply_action(&mut self, action: UiAction) {
        let mut stepped = true;
        match action {
            UiAction::CaptureDepth => {
                if let Some(draw) = self.selected_geometry() {
                    self.session.sink.depth_request = Some((draw.location, draw.subdraw));
                    self.session.rerender();
                    self.session.sink.depth_request = None;
                }
            }
            UiAction::SelectDraw(row) => {
                self.select_row(row);

                let eligible = self.session.index.commands.get(row).is_some_and(|cmd| {
                    matches!(cmd.kind, CmdKind::Draw { .. } | CmdKind::CallDl { .. })
                        && !self.session.cur.disabled.contains(&cmd.offset)
                });

                if !eligible {
                    stepped = false;
                } else if self.selected_geometry().is_some() {
                    self.session.pause();
                    stepped = false;
                } else {
                    let frame = self.session.frame_idx;
                    let ahead = !self.session.finished && row + 1 >= self.session.row;

                    self.session.jump_to(frame, row + 1);

                    if ahead {
                        self::rerender_if_in_frame(&mut self.session, frame);
                    }
                }
            }
            UiAction::StepCmd => {
                let f0 = self.session.frame_idx;
                self.session.step_command();
                self::rerender_if_in_frame(&mut self.session, f0);
            }
            UiAction::StepDraw => {
                let f0 = self.session.frame_idx;
                self.session.step_draw();
                self::rerender_if_in_frame(&mut self.session, f0);
            }
            UiAction::StepFrame => self.session.step_frame(),
            UiAction::RunPause => {
                stepped = false;

                if self.session.run_state == RunState::Paused {
                    if self.session.finished {
                        self.session.restart();
                        stepped = true;
                    }

                    self.session.resume(RunState::Running);
                } else {
                    self.session.pause();
                }
            }
            UiAction::RunToSelection => {
                if let Selection::Cmd(i) = self.selection {
                    let frame = self.session.frame_idx;

                    if i >= self.session.row {
                        self.session.resume(RunState::RunTo { frame, row: i });
                        stepped = false;
                    } else {
                        self.session.jump_to(frame, i);
                    }
                }
            }
            UiAction::Restart => self.session.restart(),
            UiAction::RestartFrame => self.session.restart_frame(),
            UiAction::JumpTo(frame, row) => {
                self.session.jump_to(frame, row);

                if self.view_mode == ViewMode::Depth {
                    self.apply_action(UiAction::SelectDraw(row));
                } else {
                    self.select_row(row);
                }
            }
            UiAction::ToggleDisabled(off) => self.session.toggle_disabled(off),
            UiAction::ToggleRowBp(row) => {
                stepped = false;

                let key = (self.session.frame_idx, row);
                if !self.session.breakpoints.rows.remove(&key) {
                    self.session.breakpoints.rows.insert(key);
                }
            }
            UiAction::ToggleExpand(off) => {
                stepped = false;

                if !self.expanded.remove(&off) {
                    self.expanded.insert(off);
                }

                self.expanded_version += 1;
            }
            UiAction::ApplyHex(off, bytes) => {
                self.session.replace_command(off, bytes);

                self.hex_for = None;
                self.status_msg = "edit applied".into();
            }
            UiAction::Revert(off) => {
                self.session.revert_command(off);
                self.hex_for = None;
            }
            UiAction::Save => {
                stepped = false;

                match self.session.save_dff() {
                    Ok(path) => self.status_msg = format!("saved {}", path.display()),
                    Err(err) => self.status_msg = format!("save failed: {err:?}"),
                }
            }
        }

        if stepped {
            self.flush_gx();
            self.scroll_to_current = true;
        }
    }

    fn build_ui(&mut self, ui: &mut egui::Ui, actions: &mut Vec<UiAction>) {
        let ctx = ui.ctx().clone();

        if !ctx.egui_wants_keyboard_input() {
            ctx.input(|i| {
                if i.key_pressed(egui::Key::F5) {
                    actions.push(UiAction::RunPause);
                }
                if i.key_pressed(egui::Key::F10) {
                    actions.push(UiAction::StepCmd);
                }
                if i.key_pressed(egui::Key::F11) {
                    actions.push(UiAction::StepDraw);
                }
                if i.key_pressed(egui::Key::F8) {
                    actions.push(UiAction::StepFrame);
                }
            });
        }

        self.toolbar(ui, actions);
        self.frame_panel(ui, actions);
        self.command_panel(ui, actions);
        self.inspector_panel(ui, actions);
        self.game_panel(ui, actions);
    }

    fn toolbar(&mut self, root: &mut egui::Ui, actions: &mut Vec<UiAction>) {
        let frame = egui::Frame::side_top_panel(root.style()).inner_margin(egui::Margin::symmetric(8, 6));

        egui::Panel::top("toolbar").frame(frame).show_inside(root, |ui| {
            ui.horizontal(|ui| {
                let running = self.session.run_state != RunState::Paused;

                if ui
                    .button(format!("{} Restart", icons::SKIP_BACK))
                    .on_hover_text("replay from the first frame")
                    .clicked()
                {
                    actions.push(UiAction::Restart);
                }

                if ui
                    .button(format!("{} Frame", icons::ARROW_COUNTER_CLOCKWISE))
                    .on_hover_text("restart the current frame")
                    .clicked()
                {
                    actions.push(UiAction::RestartFrame);
                }

                ui.separator();

                let run_label = if running {
                    format!("{} Pause", icons::PAUSE)
                } else {
                    format!("{} Run", icons::PLAY)
                };
                if ui.button(run_label).on_hover_text("F5").clicked() {
                    actions.push(UiAction::RunPause);
                }

                ui.add_enabled_ui(!running, |ui| {
                    if ui.button("Step").on_hover_text("F10: one command").clicked() {
                        actions.push(UiAction::StepCmd);
                    }

                    if ui.button("Draw").on_hover_text("F11: to the next draw").clicked() {
                        actions.push(UiAction::StepDraw);
                    }

                    if ui.button("Frame").on_hover_text("F8: to the next frame").clicked() {
                        actions.push(UiAction::StepFrame);
                    }

                    let has_sel = matches!(self.selection, Selection::Cmd(_));
                    if ui
                        .add_enabled(has_sel, egui::Button::new("To selection"))
                        .on_hover_text("run until the selected command")
                        .clicked()
                    {
                        actions.push(UiAction::RunToSelection);
                    }
                });

                ui.separator();

                egui::ComboBox::from_id_salt("view_mode")
                    .selected_text(match self.view_mode {
                        ViewMode::Auto => "Auto",
                        ViewMode::Efb => "EFB",
                        ViewMode::Xfb => "XFB",
                        ViewMode::Depth => "Depth",
                    })
                    .show_ui(ui, |ui| {
                        ui.selectable_value(&mut self.view_mode, ViewMode::Auto, "Auto");
                        ui.selectable_value(&mut self.view_mode, ViewMode::Efb, "EFB");
                        ui.selectable_value(&mut self.view_mode, ViewMode::Xfb, "XFB");

                        if ui
                            .selectable_value(&mut self.view_mode, ViewMode::Depth, "Depth")
                            .changed()
                            && let Selection::Cmd(row) = self.selection
                        {
                            actions.push(UiAction::SelectDraw(row));
                        }
                    });

                ui.separator();

                let dirty = self.session.edits.any();
                if ui
                    .add_enabled(dirty, egui::Button::new(format!("{} Save .dff", icons::FLOPPY_DISK)))
                    .on_hover_text("write edits to <name>.edited.dff")
                    .clicked()
                {
                    actions.push(UiAction::Save);
                }

                ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
                    let s = &self.session;
                    let state = if s.finished {
                        "finished"
                    } else if running {
                        "running"
                    } else {
                        "paused"
                    };

                    ui.label(
                        egui::RichText::new(format!(
                            "{state}  frame {}/{}  cmd {}/{}  presents {}",
                            s.frame_idx,
                            s.frame_count().saturating_sub(1),
                            s.row,
                            s.index.commands.len(),
                            s.presents,
                        ))
                        .monospace(),
                    );

                    if !self.status_msg.is_empty() {
                        ui.separator();
                        ui.label(egui::RichText::new(&self.status_msg).weak());
                    }
                });
            });
        });
    }

    fn frame_panel(&mut self, root: &mut egui::Ui, actions: &mut Vec<UiAction>) {
        egui::Panel::left("frames")
            .resizable(false)
            .exact_size(110.0)
            .show_inside(root, |ui| {
                ui.label(egui::RichText::new("Frames").strong());
                ui.separator();

                let row_h = ui.text_style_height(&egui::TextStyle::Monospace);
                let n = self.session.frame_count();

                let mut scroll = egui::ScrollArea::vertical().auto_shrink([false; 2]);
                if self.scroll_to_current {
                    let spacing = ui.spacing().item_spacing.y;
                    let target = (self.session.frame_idx as f32) * (row_h + spacing) - ui.available_height() * 0.4;

                    scroll = scroll.vertical_scroll_offset(target.max(0.0));
                }

                scroll.show_rows(ui, row_h, n, |ui, range| {
                    for f in range {
                        let current = f == self.session.frame_idx;
                        let in_range = (self.session.start..=self.session.end).contains(&f);

                        let mut text = egui::RichText::new(format!("{f:5}")).monospace();

                        if !in_range {
                            text = text.weak();
                        }
                        if self.session.edits.frame(f).is_some() {
                            text = text.color(egui::Color32::from_rgb(230, 180, 80));
                        }

                        if ui.selectable_label(current, text).clicked() && in_range {
                            actions.push(UiAction::JumpTo(f, 0));
                        }
                    }
                });
            });
    }

    fn command_panel(&mut self, root: &mut egui::Ui, actions: &mut Vec<UiAction>) {
        self.rebuild_rows();

        egui::Panel::left("commands")
            .resizable(true)
            .default_size(480.0)
            .show_inside(root, |ui| {
                ui.label(egui::RichText::new(format!("Frame {} commands", self.session.frame_idx)).strong());

                if self.session.index.truncated {
                    ui.label(
                        egui::RichText::new(format!("{} stream ends mid-command", icons::WARNING))
                            .color(egui::Color32::from_rgb(235, 160, 80)),
                    );
                }
                ui.separator();

                let row_h = ui.text_style_height(&egui::TextStyle::Monospace) + 2.0;
                let total = self.rows.len();

                let mut scroll = egui::ScrollArea::vertical().auto_shrink([false; 2]);
                if self.scroll_to_current {
                    let flat = self
                        .cmd_flat
                        .get(self.session.row)
                        .copied()
                        .unwrap_or(total.saturating_sub(1));
                    let spacing = ui.spacing().item_spacing.y;
                    let target = (flat as f32) * (row_h + spacing) - ui.available_height() * 0.4;

                    scroll = scroll.vertical_scroll_offset(target.max(0.0));
                    self.scroll_to_current = false;
                }

                scroll.show_rows(ui, row_h, total, |ui, range| {
                    for r in range {
                        let row = self.rows[r].clone();
                        self.command_row(ui, &row, actions);
                    }
                });
            });
    }

    fn command_row(&mut self, ui: &mut egui::Ui, row: &Row, actions: &mut Vec<UiAction>) {
        let s = &self.session;
        match *row {
            Row::Update(u) => {
                let update = &s.cur.updates[u];
                let applied = u < s.applied_updates();

                let mut text = egui::RichText::new(format!(
                    "        {} mem {:?} @{:08X} ({} bytes)",
                    icons::MEMORY,
                    update.kind,
                    update.address,
                    update.data.len()
                ))
                .monospace()
                .weak();

                if applied {
                    text = text.color(egui::Color32::from_gray(110));
                }

                ui.label(text);
            }
            Row::FrameEnd => {
                let current = s.at_frame_end();

                let text = egui::RichText::new("── frame end (present) ──").monospace();

                let text = if current {
                    text.color(egui::Color32::from_rgb(255, 220, 120))
                } else {
                    text.weak()
                };

                ui.label(text);
            }
            Row::DlChild { parent, child } => {
                let CmdKind::CallDl {
                    children, phys_addr, ..
                } = &s.index.commands[parent].kind
                else {
                    return;
                };

                let cmd = &children[child];
                let selected = self.selection == Selection::Child(parent, child);
                let label = format!(
                    "    {:08X}  {}",
                    (phys_addr & 0x3FFF_FFFF) as usize + cmd.offset,
                    disasm::summary(cmd)
                );

                if ui
                    .selectable_label(selected, egui::RichText::new(label).monospace().weak())
                    .clicked()
                {
                    self.selection = Selection::Child(parent, child);
                }
            }
            Row::Cmd(i) => {
                let cmd = &s.index.commands[i];
                let off = cmd.offset;
                let is_current = i == s.row && !s.finished;
                let is_selected = self.selection == Selection::Cmd(i);
                let is_disabled = s.cur.disabled.contains(&off);

                let is_edited = s
                    .cur
                    .pristine_offset(off)
                    .map(|orig| {
                        s.edits
                            .frame(s.frame_idx)
                            .is_some_and(|fe| fe.replacements.contains_key(&orig))
                    })
                    .unwrap_or(false);

                let has_bp = s.breakpoints.rows.contains(&(s.frame_idx, i));
                let executed = i < s.row;

                ui.horizontal(|ui| {
                    ui.spacing_mut().item_spacing.x = 4.0;

                    let font_id = egui::FontId::new(
                        ui.style().text_styles[&egui::TextStyle::Body].size,
                        egui::FontFamily::Name("phosphor-fill".into()),
                    );
                    let dot = egui::RichText::new(egui_phosphor::fill::CIRCLE)
                        .font(font_id)
                        .color(if has_bp {
                            egui::Color32::from_rgb(235, 80, 80)
                        } else {
                            egui::Color32::from_gray(60)
                        });

                    if ui.add(egui::Button::new(dot).frame(false).small()).clicked() {
                        actions.push(UiAction::ToggleRowBp(i));
                    }

                    let mut enabled = !is_disabled;
                    if ui.checkbox(&mut enabled, "").changed() {
                        actions.push(UiAction::ToggleDisabled(off));
                    }

                    if let CmdKind::CallDl { children, .. } = &cmd.kind
                        && !children.is_empty()
                    {
                        let arrow = if self.expanded.contains(&off) {
                            icons::CARET_DOWN
                        } else {
                            icons::CARET_RIGHT
                        };

                        if ui.add(egui::Button::new(arrow).frame(false).small()).clicked() {
                            actions.push(UiAction::ToggleExpand(off));
                        }
                    }

                    let mut text = egui::RichText::new(format!(
                        "{off:06X}  {}{}",
                        disasm::summary(cmd),
                        if is_edited { " *" } else { "" }
                    ))
                    .monospace();

                    if is_current {
                        text = text.color(egui::Color32::from_rgb(255, 220, 120));
                    } else if is_disabled {
                        text = text.strikethrough().weak();
                    } else if executed {
                        text = text.weak();
                    }

                    if matches!(cmd.kind, CmdKind::Draw { .. }) && !is_disabled && !executed && !is_current {
                        text = text.color(egui::Color32::from_rgb(140, 200, 255));
                    }

                    if ui.selectable_label(is_selected, text).clicked() {
                        if self.view_mode == ViewMode::Depth {
                            actions.push(UiAction::SelectDraw(i));
                        } else {
                            self.selection = Selection::Cmd(i);
                            self.geometry_subdraw = 0;
                        }
                    }
                });
            }
        }
    }

    fn inspector_panel(&mut self, root: &mut egui::Ui, actions: &mut Vec<UiAction>) {
        egui::Panel::right("inspector")
            .resizable(true)
            .default_size(360.0)
            .show_inside(root, |ui| {
                ui.horizontal_wrapped(|ui| {
                    ui.selectable_value(&mut self.inspector_tab, Tab::Disasm, "Disasm");
                    ui.selectable_value(&mut self.inspector_tab, Tab::Registers, "Registers");
                    ui.selectable_value(&mut self.inspector_tab, Tab::Hex, "Hex");
                    ui.selectable_value(&mut self.inspector_tab, Tab::Breakpoints, "Breakpoints");
                });
                ui.separator();

                egui::ScrollArea::vertical()
                    .auto_shrink([false; 2])
                    .show(ui, |ui| match self.inspector_tab {
                        Tab::Disasm => self.disasm_tab(ui),
                        Tab::Registers => self.registers_tab(ui),
                        Tab::Hex => self.hex_tab(ui, actions),
                        Tab::Breakpoints => self.breakpoints_tab(ui, actions),
                    });
            });
    }

    fn disasm_tab(&self, ui: &mut egui::Ui) {
        let Some(cmd) = self.selected_command() else {
            ui.label(egui::RichText::new("select a command").weak());
            return;
        };
        ui.label(egui::RichText::new(disasm::detail(cmd)).monospace());

        if matches!(self.selection, Selection::Child(..)) {
            ui.separator();
            ui.label(
                egui::RichText::new("display list commands live in RAM and cannot be edited or stepped individually")
                    .weak(),
            );
        }
    }

    fn select_row(&mut self, row: usize) {
        self.selection = Selection::Cmd(row);
        self.geometry_subdraw = 0;
    }

    fn selected_draws(&self) -> Option<&[Arc<super::geometry::Geometry>]> {
        let Selection::Cmd(row) = self.selection else {
            return None;
        };

        let cmd = self.session.index.commands.get(row)?;

        self.session
            .sink
            .inspection
            .as_ref()?
            .draws
            .get(&cmd.offset)
            .map(Vec::as_slice)
    }

    fn selected_geometry(&self) -> Option<Arc<super::geometry::Geometry>> {
        let draws = self.selected_draws()?;
        let idx = self.geometry_subdraw.min(draws.len().saturating_sub(1));

        draws.get(idx).cloned()
    }

    fn registers_tab(&self, ui: &mut egui::Ui) {
        let gx = &self.session.playback.gx;

        ui.collapsing("Pipeline state", |ui| {
            let genmode = GenMode::from_raw(gx.bp_regs[BP_GEN_MODE]);
            let z = ZMode::from_raw(gx.bp_regs[BP_PE_ZMODE]);
            let blend = BlendMode::from_raw(gx.bp_regs[BP_PE_CMODE0]);
            let alpha = AlphaCompare::from_raw(gx.bp_regs[BP_PE_ALPHA_COMPARE]);
            ui.label(egui::RichText::new(format!("{genmode:#?}\n{z:#?}\n{blend:#?}\n{alpha:#?}")).monospace());
        });

        ui.collapsing("Textures", |ui| {
            for (i, desc) in gx.cur_textures.iter().enumerate() {
                match desc {
                    Some(d) => ui.label(
                        egui::RichText::new(format!(
                            "{i}: {}x{} {:?} @{:08X}",
                            d.width, d.height, d.format, d.ram_addr
                        ))
                        .monospace(),
                    ),
                    None => ui.label(egui::RichText::new(format!("{i}: -")).monospace().weak()),
                };
            }
        });

        ui.collapsing("CP registers", |ui| {
            for (i, v) in gx.cp_regs.iter().enumerate() {
                if *v != 0 {
                    ui.label(egui::RichText::new(format!("{:18} {v:08X}", disasm::cp_reg_name(i as u8))).monospace());
                }
            }
        });

        ui.collapsing("BP registers", |ui| {
            for (i, v) in gx.bp_regs.iter().enumerate() {
                if *v != 0 {
                    ui.label(egui::RichText::new(format!("{:18} {v:06X}", disasm::bp_reg_name(i as u8))).monospace());
                }
            }
        });

        ui.collapsing("XF registers", |ui| {
            for (i, v) in gx.xf_mem.iter().enumerate().skip(0x1000) {
                if *v != 0 {
                    ui.label(egui::RichText::new(format!("{:18} {v:08X}", disasm::xf_addr_name(i as u16))).monospace());
                }
            }
        });
    }

    fn hex_tab(&mut self, ui: &mut egui::Ui, actions: &mut Vec<UiAction>) {
        let Selection::Cmd(i) = self.selection else {
            ui.label(egui::RichText::new("select a top-level command").weak());
            return;
        };

        let Some(cmd) = self.session.index.commands.get(i) else {
            return;
        };

        let off = cmd.offset;
        let editable = self.session.cur.pristine_offset(off).is_some();

        if self.hex_for != Some(off) {
            self.hex_for = Some(off);
            self.hex_text = self.session.cur.fifo[off..cmd.end()]
                .iter()
                .map(|b| format!("{b:02X}"))
                .collect::<Vec<_>>()
                .join(" ");
        }

        ui.label(egui::RichText::new(format!("command bytes @ {off:06X} ({} bytes)", cmd.len)).monospace());

        ui.add(
            egui::TextEdit::multiline(&mut self.hex_text)
                .font(egui::TextStyle::Monospace)
                .desired_width(f32::INFINITY),
        );

        let parsed = self::parse_hex(&self.hex_text);

        ui.horizontal(|ui| {
            match &parsed {
                Ok(bytes) => {
                    ui.label(egui::RichText::new(format!("{} bytes", bytes.len())).weak());
                }
                Err(err) => {
                    ui.label(egui::RichText::new(err.as_str()).color(egui::Color32::from_rgb(235, 80, 80)));
                }
            }

            if ui
                .add_enabled(editable && parsed.is_ok(), egui::Button::new("Apply"))
                .clicked()
                && let Ok(bytes) = parsed
            {
                actions.push(UiAction::ApplyHex(off, bytes));
            }

            if ui.add_enabled(editable, egui::Button::new("Revert")).clicked() {
                actions.push(UiAction::Revert(off));
            }
        });

        if !editable {
            ui.label(
                egui::RichText::new("this command cannot be mapped back to a pristine boundary, editing disabled")
                    .weak(),
            );
        }

        ui.label(
            egui::RichText::new(
                "size changes are allowed: later offsets shift and memory update positions are remapped",
            )
            .weak(),
        );
    }

    fn breakpoints_tab(&mut self, ui: &mut egui::Ui, actions: &mut Vec<UiAction>) {
        let bp = &mut self.session.breakpoints;

        ui.label(egui::RichText::new("Break on command kind").strong());
        ui.checkbox(&mut bp.on_draw, "draw");
        ui.checkbox(&mut bp.on_calldl, "display list call");
        ui.checkbox(&mut bp.on_efb_copy, "EFB copy execute");
        ui.checkbox(&mut bp.on_cp, "any CP write");
        ui.checkbox(&mut bp.on_bp, "any BP write");
        ui.checkbox(&mut bp.on_xf, "any XF write");

        ui.separator();
        ui.label(egui::RichText::new("Add breakpoint").strong());
        ui.label(egui::RichText::new("cmd <hex offset> (current frame)\ncp <hex> | bp <hex> | xf <hex>").weak());

        ui.horizontal(|ui| {
            let input = ui.add(
                egui::TextEdit::singleline(&mut self.bp_input)
                    .hint_text("cmd 0186A3")
                    .desired_width(170.0),
            );

            let enter = input.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter));

            if ui.button(format!("{} Add", icons::PLUS)).clicked() || enter {
                let frame = self.session.frame_idx;

                let added = match super::parse_breakpoint(&self.bp_input) {
                    Ok(super::BreakpointSpec::Cp(v)) => Ok(bp.cp_regs.insert(v)),
                    Ok(super::BreakpointSpec::Bp(v)) => Ok(bp.bp_regs.insert(v)),
                    Ok(super::BreakpointSpec::Xf(v)) => Ok(bp.xf_addrs.insert(v)),
                    Ok(super::BreakpointSpec::Command(offset)) => {
                        let row = self.session.index.commands.iter().position(|c| c.offset == offset);

                        match row {
                            Some(row) => {
                                self.status_msg = format!("Breakpoint: frame {frame} / {offset:06X}");
                                Ok(bp.rows.insert((frame, row)))
                            }
                            None => Err(format!("{offset:06X} is not within boundary in this frame")),
                        }
                    }
                    Err(err) => Err(err.into()),
                };

                match added {
                    Ok(_) => self.bp_input.clear(),
                    Err(msg) => self.status_msg = msg,
                }
            }
        });

        self::breakpoint_list(ui, &mut bp.cp_regs, |reg| format!("CP {}", disasm::cp_reg_name(reg)));
        self::breakpoint_list(ui, &mut bp.bp_regs, |reg| format!("BP {}", disasm::bp_reg_name(reg)));
        self::breakpoint_list(ui, &mut bp.xf_addrs, |addr| {
            format!("XF {}", disasm::xf_addr_name(addr))
        });

        if !bp.rows.is_empty() {
            ui.separator();
            ui.label(egui::RichText::new("Command breakpoints").strong());

            let mut remove_row = None;
            let mut rows: Vec<_> = bp.rows.iter().copied().collect();
            rows.sort();

            for (frame, row) in rows {
                ui.horizontal(|ui| {
                    let label = self
                        .session
                        .index
                        .commands
                        .get(row)
                        .filter(|_| frame == self.session.frame_idx)
                        .map(|c| format!("frame {frame} / {:06X}", c.offset))
                        .unwrap_or_else(|| format!("frame {frame} cmd {row}"));

                    ui.label(egui::RichText::new(label).monospace());

                    if ui.small_button("Go").clicked() {
                        actions.push(UiAction::JumpTo(frame, row));
                    }

                    if ui.small_button(icons::TRASH).clicked() {
                        remove_row = Some((frame, row));
                    }
                });
            }

            if let Some(key) = remove_row {
                bp.rows.remove(&key);
            }
        }
    }

    fn game_panel(&mut self, root: &mut egui::Ui, actions: &mut Vec<UiAction>) {
        egui::CentralPanel::default().show_inside(root, |ui| {
            if self.view_mode == ViewMode::Depth {
                let num_draws = self.selected_draws().map_or(0, |draws| draws.len());

                if num_draws > 1 {
                    ui.horizontal(|ui| {
                        ui.label("Draw");
                        ui.add(egui::DragValue::new(&mut self.geometry_subdraw).range(0..=num_draws - 1));
                        ui.weak(format!("/ {}", num_draws - 1));
                    });
                }

                let selected = self.selected_geometry();

                if let Some(capture) = &self.session.sink.inspection {
                    self.depth_view.show(ui, capture, selected.as_ref());
                }

                if self.depth_view.show_test
                    && self.session.run_state == RunState::Paused
                    && selected.as_ref().is_some_and(|d| d.depth_before.get().is_none())
                {
                    actions.push(UiAction::CaptureDepth);
                }

                return;
            }

            let show_xfb = match self.view_mode {
                ViewMode::Xfb => true,
                ViewMode::Efb | ViewMode::Depth => false,
                ViewMode::Auto => (self.session.row == 0 || self.session.finished) && self.session.presents > 0,
            };

            let (tex, size, label) = if show_xfb {
                (
                    self.xfb_tex,
                    egui::vec2(self.xfb_size.0 as f32, self.xfb_size.1 as f32),
                    "XFB",
                )
            } else {
                (
                    self.efb_tex,
                    egui::vec2(
                        gecko::flipper::gx::constants::EFB_WIDTH as f32,
                        gecko::flipper::gx::constants::EFB_HEIGHT as f32,
                    ),
                    "EFB",
                )
            };

            ui.label(egui::RichText::new(label).weak());

            let Some(tex) = tex else { return };
            let avail = ui.available_size();
            let scale = (avail.x / size.x).min(avail.y / size.y).max(0.01);
            let draw_size = egui::vec2(size.x * scale, size.y * scale);

            ui.centered_and_justified(|ui| {
                ui.image((tex, draw_size));
            });
        });
    }

    fn render(&mut self) {
        let Some(window) = self.window.clone() else { return };
        let (frame, width, height) = {
            let Some((surface, config)) = self.surface.as_ref() else {
                return;
            };
            let frame = match surface.get_current_texture() {
                wgpu::CurrentSurfaceTexture::Success(f) | wgpu::CurrentSurfaceTexture::Suboptimal(f) => f,
                status => {
                    tracing::error!(?status, "surface error");
                    return;
                }
            };
            (frame, config.width, config.height)
        };
        let view = frame.texture.create_view(&Default::default());

        let raw_input = self.egui_winit.as_mut().unwrap().take_egui_input(&window);
        let egui_ctx = self.egui_ctx.clone();
        let mut actions = Vec::new();
        let full_output = egui_ctx.run_ui(raw_input, |ui| {
            self.build_ui(ui, &mut actions);
        });

        self.egui_winit
            .as_mut()
            .unwrap()
            .handle_platform_output(&window, full_output.platform_output);

        for action in actions {
            self.apply_action(action);
        }
        self.refresh_xfb_binding();

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

        let egui_renderer = self.egui_renderer.as_mut().unwrap();

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

        let mut encoder = self.device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
            label: Some("debug_egui"),
        });
        egui_renderer.update_buffers(&self.device, &self.queue, &mut encoder, &tris, &screen_desc);
        {
            let rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                label: Some("debug_egui"),
                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
                    view: &view,
                    resolve_target: None,
                    ops: wgpu::Operations {
                        load: wgpu::LoadOp::Clear(wgpu::Color {
                            r: 0.07,
                            g: 0.07,
                            b: 0.08,
                            a: 1.0,
                        }),
                        store: wgpu::StoreOp::Store,
                    },
                    depth_slice: None,
                })],
                depth_stencil_attachment: None,
                timestamp_writes: None,
                occlusion_query_set: None,
                multiview_mask: None,
            });
            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.as_mut().unwrap().free_texture(&id);
        }

        frame.present();

        let wants_repaint = full_output
            .viewport_output
            .get(&ViewportId::ROOT)
            .is_some_and(|v| v.repaint_delay.is_zero());
        if self.session.run_state != RunState::Paused || wants_repaint {
            window.request_redraw();
        }
    }
}

fn breakpoint_list<T: Copy + Eq + Ord + std::hash::Hash>(
    ui: &mut egui::Ui,
    set: &mut HashSet<T>,
    name: impl Fn(T) -> String,
) {
    let mut items: Vec<T> = set.iter().copied().collect();
    items.sort();

    let mut remove = None;

    for item in items {
        ui.horizontal(|ui| {
            ui.label(egui::RichText::new(name(item)).monospace());
            if ui.small_button(icons::TRASH).clicked() {
                remove = Some(item);
            }
        });
    }
    if let Some(item) = remove {
        set.remove(&item);
    }
}

fn rerender_if_in_frame<const SYSTEM: SystemId>(session: &mut DebugSession<SYSTEM>, prev_frame: usize) {
    if !session.finished && session.frame_idx == prev_frame {
        session.rerender();
    }
}

fn parse_hex(text: &str) -> Result<Vec<u8>, String> {
    let cleaned: String = text.chars().filter(|c| !c.is_whitespace()).collect();

    if cleaned.is_empty() {
        return Err("empty".into());
    }
    if cleaned.len() % 2 != 0 {
        return Err("odd number of hex digits".into());
    }

    (0..cleaned.len())
        .step_by(2)
        .map(|i| u8::from_str_radix(&cleaned[i..i + 2], 16).map_err(|_| "invalid hex".to_string()))
        .collect()
}

impl<const SYSTEM: SystemId> ApplicationHandler for DebugApp<SYSTEM> {
    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
        let window = Arc::new(
            event_loop
                .create_window(
                    Window::default_attributes()
                        .with_title("Gecko — FIFO Debugger")
                        .with_inner_size(winit::dpi::PhysicalSize::new(1760, 990)),
                )
                .unwrap(),
        );

        let surface = self.instance.create_surface(window.clone()).unwrap();
        let size = window.inner_size();

        let surface_caps = surface.get_capabilities(&self.adapter);
        let surface_config = wgpu::SurfaceConfiguration {
            usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
            format: SURFACE_FORMAT,
            width: size.width.max(1),
            height: size.height.max(1),
            present_mode: wgpu::PresentMode::Fifo,
            alpha_mode: surface_caps.alpha_modes[0],
            view_formats: vec![],
            desired_maximum_frame_latency: 2,
        };

        surface.configure(&self.device, &surface_config);

        let mut egui_renderer =
            egui_wgpu::Renderer::new(&self.device, SURFACE_FORMAT, egui_wgpu::RendererOptions::default());
        let egui_winit = egui_winit::State::new(
            self.egui_ctx.clone(),
            ViewportId::ROOT,
            window.as_ref(),
            None,
            None,
            None,
        );

        {
            let g = self.gx.lock().unwrap();
            self.efb_tex =
                Some(egui_renderer.register_native_texture(&self.device, g.efb_view(), wgpu::FilterMode::Linear));
            self.xfb_tex =
                Some(egui_renderer.register_native_texture(&self.device, &g.xfb_view, wgpu::FilterMode::Linear));
            let size = g.xfb_texture.size();
            self.xfb_size = (size.width, size.height);
        }

        self.flush_gx();

        window.request_redraw();

        self.window = Some(window);
        self.surface = Some((surface, surface_config));
        self.egui_winit = Some(egui_winit);
        self.egui_renderer = Some(egui_renderer);
    }

    fn exiting(&mut self, _event_loop: &ActiveEventLoop) {
        self.egui_winit = None;
        self.egui_renderer = None;
        self.surface = None;
        self.window = None;
    }

    fn window_event(&mut self, event_loop: &ActiveEventLoop, _id: WindowId, event: WindowEvent) {
        if let (Some(state), Some(window)) = (self.egui_winit.as_mut(), self.window.as_ref()) {
            let response = state.on_window_event(window, &event);

            if response.repaint {
                window.request_redraw();
            }
            if response.consumed {
                return;
            }
        }

        match event {
            WindowEvent::CloseRequested => event_loop.exit(),
            WindowEvent::Resized(size) => {
                if size.width == 0 || size.height == 0 {
                    return;
                }

                if let Some((surface, config)) = &mut self.surface {
                    config.width = size.width;
                    config.height = size.height;

                    surface.configure(&self.device, config);
                }
            }
            WindowEvent::RedrawRequested => {
                if self.session.run_state != RunState::Paused {
                    self.session.run_tick();

                    if self.session.run_state == RunState::Paused && !self.session.finished {
                        self.select_row(self.session.row);
                    }

                    self.flush_gx();
                    self.scroll_to_current = true;
                }

                self.render();
            }
            _ => {}
        }
    }
}