Skip to content

armgit / gecko

Public Imported from GitHub
0

A GameCube/Wii emulator and debugger written in Rust.

fifo debugger

Layle55e6b355838e
diff --git a/Cargo.lock b/Cargo.lock
index a4eec6d..914b7fb 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2041,6 +2041,10 @@ dependencies = [
"backend-wgpu",
"clap",
"dff",
+ "egui",
+ "egui-phosphor",
+ "egui-wgpu",
+ "egui-winit",
"gecko",
"pollster",
"tracing",
diff --git a/crates/backend-wgpu/src/lib.rs b/crates/backend-wgpu/src/lib.rs
index 79dfc85..a7d3f5c 100644
--- a/crates/backend-wgpu/src/lib.rs
+++ b/crates/backend-wgpu/src/lib.rs
@@ -825,6 +825,15 @@ impl GxRenderer {
})
}
+ pub fn debug_flush(&mut self, device: &wgpu::Device, queue: &wgpu::Queue) {
+ self.flush_pending_draws(device, queue);
+ self.submit_pending(queue);
+ }
+
+ pub fn efb_view(&self) -> &wgpu::TextureView {
+ &self.efb_view
+ }
+
pub(crate) fn submit_pending(&mut self, queue: &wgpu::Queue) {
// Ship any staged texture-upload bytes through ONE `write_buffer_with`
// before finishing the encoder. wgpu orders queue writes ahead of
diff --git a/crates/dff/src/lib.rs b/crates/dff/src/lib.rs
index 937021a..eca4291 100644
--- a/crates/dff/src/lib.rs
+++ b/crates/dff/src/lib.rs
@@ -55,6 +55,7 @@ pub struct Frame {
pub memory_updates: Vec<MemoryUpdate>,
}
+#[derive(Clone)]
pub struct DffFile {
pub bp_mem: Vec<u32>,
pub cp_mem: Vec<u32>,
diff --git a/crates/fifoplayer/Cargo.toml b/crates/fifoplayer/Cargo.toml
index 90709c9..8024f89 100644
--- a/crates/fifoplayer/Cargo.toml
+++ b/crates/fifoplayer/Cargo.toml
@@ -8,6 +8,10 @@ dff = { path = "../dff" }
gecko = { path = "../gecko" }
backend-wgpu = { path = "../backend-wgpu" }
clap = { version = "4.6.1", features = ["derive"] }
+egui = "0.34.2"
+egui-phosphor = { version = "0.12.0", features = ["fill"] }
+egui-wgpu = "0.34.2"
+egui-winit = { version = "0.34.2", features = ["wayland", "x11"] }
pollster = "0.4.0"
tracing = "0.1.44"
tracing-subscriber = { version = "0.3.23", features = ["env-filter"] }
diff --git a/crates/fifoplayer/src/debug.rs b/crates/fifoplayer/src/debug.rs
new file mode 100644
index 0000000..931bedc
--- /dev/null
+++ b/crates/fifoplayer/src/debug.rs
@@ -0,0 +1,414 @@
+pub mod disasm;
+pub mod edits;
+pub mod slice;
+pub mod ui;
+
+use crate::playback::{Playback, PlayerSink};
+use edits::{EditModel, EffectiveFrame};
+use gecko::host::{GxAction, RenderSink};
+use gecko::system::SystemId;
+use slice::{CmdKind, Command, CommandIndex, RamOverlay, SliceCtx};
+use std::collections::HashSet;
+use std::path::PathBuf;
+
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+pub enum RunState {
+ Paused,
+ Running,
+ RunTo { frame: usize, row: usize },
+}
+
+#[derive(Default)]
+pub struct Breakpoints {
+ pub on_draw: bool,
+ pub on_cp: bool,
+ pub on_xf: bool,
+ pub on_bp: bool,
+ pub on_calldl: bool,
+ pub on_efb_copy: bool,
+ pub cp_regs: HashSet<u8>,
+ pub bp_regs: HashSet<u8>,
+ pub xf_addrs: HashSet<u16>,
+ pub rows: HashSet<(usize, usize)>,
+}
+
+impl Breakpoints {
+ fn hits(&self, frame: usize, row: usize, cmd: &Command) -> bool {
+ if self.rows.contains(&(frame, row)) {
+ return true;
+ }
+
+ match &cmd.kind {
+ CmdKind::Draw { .. } => self.on_draw,
+ CmdKind::Cp { reg, .. } => self.on_cp || self.cp_regs.contains(reg),
+ CmdKind::Bp { reg, .. } => {
+ self.on_bp
+ || self.bp_regs.contains(reg)
+ || (self.on_efb_copy && *reg as usize == gecko::flipper::gx::constants::BP_PE_COPY_CMD)
+ }
+ CmdKind::Xf { addr, values } => {
+ self.on_xf
+ || self
+ .xf_addrs
+ .iter()
+ .any(|a| (*addr..addr + values.len() as u16).contains(a))
+ }
+ CmdKind::CallDl { .. } => self.on_calldl,
+ _ => false,
+ }
+ }
+}
+
+pub struct DebugSession<const SYSTEM: SystemId> {
+ pub file: dff::DffFile,
+ pub path: PathBuf,
+ pub start: usize,
+ pub end: usize,
+
+ pub playback: Playback<SYSTEM>,
+ pub sink: PlayerSink,
+
+ pub edits: EditModel,
+ pub breakpoints: Breakpoints,
+ pub run_state: RunState,
+ skip_bp_once: bool,
+
+ pub frame_idx: usize,
+ pub row: usize,
+ next_update: usize,
+ pub cur: EffectiveFrame,
+ pub index: CommandIndex,
+ frame_start_cp: Vec<u32>,
+
+ pub finished: bool,
+ pub presents: u64,
+ pub index_version: u64,
+}
+
+impl<const SYSTEM: SystemId> DebugSession<SYSTEM> {
+ pub fn new(file: dff::DffFile, path: PathBuf, start: usize, end: usize, mut sink: PlayerSink) -> Self {
+ let mut playback = Playback::<SYSTEM>::new();
+ playback.load_state(&file, &mut sink);
+
+ let mut session = DebugSession {
+ file,
+ path,
+ start,
+ end,
+ playback,
+ sink,
+ edits: EditModel::default(),
+ breakpoints: Breakpoints::default(),
+ run_state: RunState::Paused,
+ skip_bp_once: false,
+ frame_idx: start,
+ row: 0,
+ next_update: 0,
+ cur: EffectiveFrame {
+ fifo: Vec::new(),
+ updates: Vec::new(),
+ disabled: HashSet::new(),
+ orig_of: Default::default(),
+ },
+ index: CommandIndex::default(),
+ frame_start_cp: Vec::new(),
+ finished: false,
+ presents: 0,
+ index_version: 0,
+ };
+
+ session.enter_frame(start);
+ session
+ }
+
+ pub fn frame_count(&self) -> usize {
+ self.file.frames.len()
+ }
+
+ pub fn byte_pos(&self) -> usize {
+ match self.index.commands.get(self.row) {
+ Some(cmd) => cmd.offset,
+ None => self.cur.fifo.len(),
+ }
+ }
+
+ pub fn at_frame_end(&self) -> bool {
+ self.row >= self.index.commands.len()
+ }
+
+ pub fn applied_updates(&self) -> usize {
+ self.next_update
+ }
+
+ fn enter_frame(&mut self, idx: usize) {
+ self.frame_idx = idx;
+ self.row = 0;
+ self.next_update = 0;
+
+ self.frame_start_cp = self.playback.gx.cp_regs.clone();
+ self.cur = EffectiveFrame::build(&self.file.frames[idx], self.edits.frame(idx));
+ self.rebuild_index();
+ }
+
+ fn rebuild_index(&mut self) {
+ let overlay = RamOverlay {
+ ram: self.playback.mmio.ram_view(),
+ updates: &self.cur.updates,
+ };
+ let ctx = SliceCtx {
+ overlay,
+ disabled: &self.cur.disabled,
+ };
+
+ self.index = slice::slice_frame(&self.cur.fifo, &self.frame_start_cp, &ctx);
+ self.index_version += 1;
+ }
+
+ fn apply_updates_through(&mut self, pos: usize) {
+ let updates = std::mem::take(&mut self.cur.updates);
+
+ while self.next_update < updates.len() && (updates[self.next_update].fifo_position as usize) < pos {
+ self.playback.apply_update(&updates[self.next_update], &mut self.sink);
+ self.next_update += 1;
+ }
+
+ self.cur.updates = updates;
+ }
+
+ fn exec_current(&mut self) -> bool {
+ let cmd = &self.index.commands[self.row];
+ let (off, end) = (cmd.offset, cmd.end());
+ let draws = matches!(cmd.kind, CmdKind::Draw { .. } | CmdKind::CallDl { .. });
+
+ self.apply_updates_through(end);
+
+ if !self.cur.disabled.contains(&off) {
+ let fifo = std::mem::take(&mut self.cur.fifo);
+ self.playback.feed(&fifo[off..end], &mut self.sink);
+ self.cur.fifo = fifo;
+ }
+
+ self.row += 1;
+ draws
+ }
+
+ fn finish_frame(&mut self) {
+ self.apply_updates_through(usize::MAX);
+
+ if self.playback.present(&mut self.sink) {
+ self.presents += 1;
+ }
+
+ if self.frame_idx >= self.end {
+ self.finished = true;
+ self.run_state = RunState::Paused;
+ } else {
+ self.enter_frame(self.frame_idx + 1);
+ }
+ }
+
+ pub fn step_command(&mut self) -> bool {
+ if self.finished {
+ return false;
+ }
+
+ if self.at_frame_end() {
+ self.finish_frame();
+ false
+ } else {
+ self.exec_current()
+ }
+ }
+
+ pub fn step_draw(&mut self) {
+ while !self.finished {
+ let crossed = self.at_frame_end();
+
+ if self.step_command() || crossed {
+ break;
+ }
+ }
+ }
+
+ pub fn step_frame(&mut self) {
+ let f = self.frame_idx;
+
+ while !self.finished && self.frame_idx == f {
+ self.step_command();
+ }
+ }
+
+ pub fn resume(&mut self, state: RunState) {
+ if self.finished {
+ return;
+ }
+
+ self.skip_bp_once = true;
+ self.run_state = state;
+ }
+
+ pub fn pause(&mut self) {
+ self.run_state = RunState::Paused;
+ }
+
+ pub fn run_tick(&mut self) {
+ loop {
+ if self.finished {
+ self.run_state = RunState::Paused;
+ return;
+ }
+
+ if let RunState::RunTo { frame, row } = self.run_state
+ && self.frame_idx == frame
+ && self.row == row
+ {
+ self.run_state = RunState::Paused;
+ return;
+ }
+
+ if self.at_frame_end() {
+ self.finish_frame();
+ return;
+ }
+
+ let cmd = &self.index.commands[self.row];
+ if !self.skip_bp_once && self.breakpoints.hits(self.frame_idx, self.row, cmd) {
+ self.run_state = RunState::Paused;
+ return;
+ }
+
+ self.skip_bp_once = false;
+ self.exec_current();
+ }
+ }
+
+ pub fn jump_to(&mut self, frame: usize, row: usize) {
+ let frame = frame.clamp(self.start, self.end);
+ let ahead = !self.finished && (frame > self.frame_idx || (frame == self.frame_idx && row >= self.row));
+
+ if ahead {
+ while !self.finished && (self.frame_idx, self.row) < (frame, row) {
+ if self.frame_idx == frame && self.at_frame_end() {
+ break;
+ }
+ self.step_command();
+ }
+ } else {
+ self.seek_to(frame, row);
+ }
+
+ self.run_state = RunState::Paused;
+ }
+
+ pub fn seek_to(&mut self, frame: usize, row: usize) {
+ let frame = frame.clamp(self.start, self.end);
+
+ self.playback = Playback::new();
+ self.finished = false;
+
+ self.sink.exec(GxAction::InvalidateCaches);
+ self.playback.load_state(&self.file, &mut self.sink);
+
+ for f in self.start..frame {
+ let presented = match self.edits.frame(f) {
+ None => self.playback.play_frame(&self.file.frames[f], &mut self.sink),
+ Some(fe) => {
+ let eff = EffectiveFrame::build(&self.file.frames[f], Some(fe));
+ let exec = eff.exec_fifo();
+ self.playback.play_frame_with(&exec, &eff.updates, &mut self.sink)
+ }
+ };
+
+ if presented {
+ self.presents += 1;
+ }
+ }
+
+ self.enter_frame(frame);
+
+ let row = row.min(self.index.commands.len());
+ for _ in 0..row {
+ if self.at_frame_end() {
+ break;
+ }
+
+ self.exec_current();
+ }
+
+ self.run_state = RunState::Paused;
+ }
+
+ pub fn restart_frame(&mut self) {
+ self.seek_to(self.frame_idx, 0);
+ }
+
+ pub fn restart(&mut self) {
+ self.seek_to(self.start, 0);
+ }
+
+ pub fn toggle_disabled(&mut self, display_off: usize) {
+ let Some(orig) = self.cur.pristine_offset(display_off) else {
+ return;
+ };
+
+ let index = &self.index;
+ let fe = self.edits.frame_mut(self.frame_idx, || self::boundaries_of(index));
+
+ if !fe.disabled.remove(&orig) {
+ fe.disabled.insert(orig);
+ }
+
+ self.after_edit(display_off);
+ }
+
+ pub fn replace_command(&mut self, display_off: usize, bytes: Vec<u8>) {
+ let Some(orig) = self.cur.pristine_offset(display_off) else {
+ return;
+ };
+
+ let index = &self.index;
+ let fe = self.edits.frame_mut(self.frame_idx, || self::boundaries_of(index));
+ fe.replacements.insert(orig, bytes);
+
+ self.after_edit(display_off);
+ }
+
+ pub fn revert_command(&mut self, display_off: usize) {
+ let Some(orig) = self.cur.pristine_offset(display_off) else {
+ return;
+ };
+
+ if let Some(fe) = self.edits.frames.get_mut(&self.frame_idx) {
+ fe.replacements.remove(&orig);
+ fe.disabled.remove(&orig);
+ }
+
+ self.after_edit(display_off);
+ }
+
+ fn after_edit(&mut self, display_off: usize) {
+ if display_off < self.byte_pos() {
+ self.restart_frame();
+ } else {
+ self.cur = EffectiveFrame::build(&self.file.frames[self.frame_idx], self.edits.frame(self.frame_idx));
+ self.rebuild_index();
+ }
+ }
+
+ pub fn save_dff(&self) -> Result<PathBuf, dff::DffError> {
+ let mut path = self.path.clone();
+ let stem = path
+ .file_stem()
+ .map(|s| s.to_string_lossy().into_owned())
+ .unwrap_or_else(|| "dump".into());
+
+ path.set_file_name(format!("{stem}.edited.dff"));
+ self.edits.save_to_dff(&self.file, &path)?;
+
+ Ok(path)
+ }
+}
+
+fn boundaries_of(index: &CommandIndex) -> Vec<(usize, usize)> {
+ index.commands.iter().map(|c| (c.offset, c.len)).collect()
+}
diff --git a/crates/fifoplayer/src/debug/disasm.rs b/crates/fifoplayer/src/debug/disasm.rs
new file mode 100644
index 0000000..cd71258
--- /dev/null
+++ b/crates/fifoplayer/src/debug/disasm.rs
@@ -0,0 +1,381 @@
+use super::slice::{CmdKind, Command};
+use gecko::flipper::gx::constants::*;
+use gecko::flipper::gx::draw::Primitive;
+use gecko::flipper::gx::regs::*;
+
+pub fn array_name(i: usize) -> String {
+ match i {
+ ARRAY_POS => "POS".into(),
+ ARRAY_NRM => "NRM".into(),
+ ARRAY_CLR0 => "CLR0".into(),
+ ARRAY_CLR1 => "CLR1".into(),
+ 4..=11 => format!("TEX{}", i - 4),
+ ARRAY_POS_NRM_MTX => "POS_NRM_MTX".into(),
+ ARRAY_NRM_MTX => "NRM_MTX".into(),
+ ARRAY_POST_MTX => "POST_MTX".into(),
+ ARRAY_LIGHT => "LIGHT".into(),
+ _ => format!("ARRAY{i}"),
+ }
+}
+
+pub fn cp_reg_name(reg: u8) -> String {
+ let r = reg as usize;
+ match r {
+ 0x30 => "MATINDEX_A".into(),
+ 0x40 => "MATINDEX_B".into(),
+ VCD_LO_REG => "VCD_LO".into(),
+ VCD_HI_REG => "VCD_HI".into(),
+ _ if (VATA_REG..VATA_REG + 8).contains(&r) => format!("VAT_A{}", r - VATA_REG),
+ _ if (VATB_REG..VATB_REG + 8).contains(&r) => format!("VAT_B{}", r - VATB_REG),
+ _ if (VATC_REG..VATC_REG + 8).contains(&r) => format!("VAT_C{}", r - VATC_REG),
+ _ if (ARRAY_BASE_REG..ARRAY_BASE_REG + 16).contains(&r) => {
+ format!("ARRAY_BASE_{}", self::array_name(r - ARRAY_BASE_REG))
+ }
+ _ if (ARRAY_STRIDE_REG..ARRAY_STRIDE_REG + 16).contains(&r) => {
+ format!("ARRAY_STRIDE_{}", self::array_name(r - ARRAY_STRIDE_REG))
+ }
+ _ => format!("CP_{r:02X}"),
+ }
+}
+
+pub fn bp_reg_name(reg: u8) -> String {
+ let r = reg as usize;
+ match r {
+ BP_GEN_MODE => "GEN_MODE".into(),
+ BP_IND_MTX_A0..=BP_IND_MTX_C2 => {
+ let i = r - BP_IND_MTX_A0;
+ format!("IND_MTX_{}{}", ['A', 'B', 'C'][i % 3], i / 3)
+ }
+ BP_BUMP_IMASK => "BUMP_IMASK".into(),
+ _ if (BP_IND_CMD_0..BP_IND_CMD_0 + BP_IND_CMD_COUNT).contains(&r) => {
+ format!("IND_CMD{}", r - BP_IND_CMD_0)
+ }
+ BP_SU_SCIS_TL => "SU_SCIS_TL".into(),
+ BP_SU_SCIS_BR => "SU_SCIS_BR".into(),
+ 0x22 => "SU_LPSIZE".into(),
+ BP_RAS1_SS0 => "RAS1_SS0".into(),
+ BP_RAS1_SS1 => "RAS1_SS1".into(),
+ BP_RAS1_IREF => "RAS1_IREF".into(),
+ _ if (BP_RAS1_TREF0..BP_RAS1_TREF0 + BP_RAS1_TREF_COUNT).contains(&r) => {
+ format!("RAS1_TREF{}", r - BP_RAS1_TREF0)
+ }
+ 0x30..=0x3F => {
+ let i = (r - 0x30) / 2;
+ if r % 2 == 0 {
+ format!("SU_SSIZE{i}")
+ } else {
+ format!("SU_TSIZE{i}")
+ }
+ }
+ BP_PE_ZMODE => "PE_ZMODE".into(),
+ BP_PE_CMODE0 => "PE_CMODE0(blend)".into(),
+ 0x42 => "PE_CMODE1".into(),
+ BP_PE_ZCOMPARE => "PE_CONTROL".into(),
+ 0x44 => "FIELD_MASK".into(),
+ BP_PE_DONE => "PE_DONE".into(),
+ BP_PE_TOKEN => "PE_TOKEN".into(),
+ BP_PE_TOKEN_INT => "PE_TOKEN_INT".into(),
+ BP_PE_COPY_SRC => "EFB_COPY_SRC".into(),
+ BP_PE_COPY_DIMS => "EFB_COPY_DIMS".into(),
+ BP_PE_COPY_DST => "EFB_COPY_DST".into(),
+ BP_PE_COPY_DST_STRIDE => "EFB_COPY_STRIDE".into(),
+ BP_PE_COPY_YSCALE => "COPY_YSCALE".into(),
+ BP_PE_COPY_CLEAR_AR => "PE_CLEAR_AR".into(),
+ BP_PE_COPY_CLEAR_GB => "PE_CLEAR_GB".into(),
+ BP_PE_COPY_CLEAR_Z => "PE_CLEAR_Z".into(),
+ BP_PE_COPY_CMD => "PE_COPY_EXECUTE".into(),
+ 0x53 => "COPY_FILTER0".into(),
+ 0x54 => "COPY_FILTER1".into(),
+ BP_SU_SCIS_OFFSET => "SU_SCIS_OFFSET".into(),
+ BP_LOAD_TLUT0 => "TX_LOADTLUT0".into(),
+ BP_LOAD_TLUT1 => "TX_LOADTLUT1".into(),
+ 0x80..=0xBF => {
+ let map = (r - 0x80) % 4 + if r >= 0xA0 { 4 } else { 0 };
+ let base = if r >= 0xA0 { r - 0x20 } else { r };
+ match base & !0x03 {
+ BP_TX_SETMODE0_I0 => format!("TX_SETMODE0[{map}]"),
+ BP_TX_SETMODE1_I0 => format!("TX_SETMODE1[{map}]"),
+ BP_TX_SETIMAGE0_I0 => format!("TX_SETIMAGE0[{map}]"),
+ BP_TX_SETIMAGE1_I0 => format!("TX_SETIMAGE1[{map}]"),
+ BP_TX_SETIMAGE2_I0 => format!("TX_SETIMAGE2[{map}]"),
+ BP_TX_SETIMAGE3_I0 => format!("TX_SETIMAGE3[{map}]"),
+ BP_TX_SETTLUT_I0 => format!("TX_SETTLUT[{map}]"),
+ _ => format!("BP_{r:02X}"),
+ }
+ }
+ 0xC0..=0xDF => {
+ let stage = (r - 0xC0) / 2;
+ if r % 2 == 0 {
+ format!("TEV_COLOR_ENV{stage}")
+ } else {
+ format!("TEV_ALPHA_ENV{stage}")
+ }
+ }
+ 0xE0..=0xE7 => {
+ let i = (r - 0xE0) / 2;
+ if r % 2 == 0 {
+ format!("TEV_REGISTERL{i}")
+ } else {
+ format!("TEV_REGISTERH{i}")
+ }
+ }
+ 0xE8..=0xEE => format!("TEV_FOG_PARAM{}", r - 0xE8),
+ 0xF2 => "TEV_FOG_COLOR".into(),
+ BP_PE_ALPHA_COMPARE => "TEV_ALPHAFUNC".into(),
+ BP_TEV_ZTEX1 => "TEV_ZTEX1".into(),
+ BP_TEV_ZTEX2 => "TEV_ZTEX2".into(),
+ _ if (BP_TEV_KSEL_0..BP_TEV_KSEL_0 + 8).contains(&r) => format!("TEV_KSEL{}", r - BP_TEV_KSEL_0),
+ BP_BP_MASK => "BP_MASK".into(),
+ _ => format!("BP_{r:02X}"),
+ }
+}
+
+pub fn xf_addr_name(addr: u16) -> String {
+ let a = addr as usize;
+ match a {
+ 0x0000..=0x00FF => format!("POS_TEX_MTX[{a:02X}]"),
+ 0x0400..=0x045F => format!("NRM_MTX[{:02X}]", a - 0x0400),
+ 0x0500..=0x05FF => format!("POST_MTX[{:02X}]", a - 0x0500),
+ 0x0600..=0x07FF => {
+ let light = (a - XF_LIGHT_BASE) / XF_LIGHT_STRIDE;
+ format!("LIGHT{}[{}]", light, (a - XF_LIGHT_BASE) % XF_LIGHT_STRIDE)
+ }
+ 0x1000 => "XF_ERROR".into(),
+ 0x1005 => "CLIP_DISABLE".into(),
+ 0x1008 => "INVTXSPEC".into(),
+ 0x1009 => "NUMCHAN".into(),
+ XF_AMBIENT_COLOR0 => "AMBIENT0".into(),
+ XF_AMBIENT_COLOR1 => "AMBIENT1".into(),
+ XF_MATERIAL_COLOR0 => "MATERIAL0".into(),
+ XF_MATERIAL_COLOR1 => "MATERIAL1".into(),
+ XF_COLOR_CTRL0 => "CHAN_COLOR0_CTRL".into(),
+ XF_COLOR_CTRL1 => "CHAN_COLOR1_CTRL".into(),
+ XF_ALPHA_CTRL0 => "CHAN_ALPHA0_CTRL".into(),
+ XF_ALPHA_CTRL1 => "CHAN_ALPHA1_CTRL".into(),
+ XF_DUAL_TEX_ENABLE => "DUALTEX_ENABLE".into(),
+ XF_MATRIX_INDEX_A => "MATINDEX_A".into(),
+ XF_MATRIX_INDEX_B => "MATINDEX_B".into(),
+ XF_VIEWPORT_SCALE_X => "VIEWPORT_SCALE_X".into(),
+ XF_VIEWPORT_SCALE_Y => "VIEWPORT_SCALE_Y".into(),
+ XF_VIEWPORT_SCALE_Z => "VIEWPORT_SCALE_Z".into(),
+ XF_VIEWPORT_OFFSET_X => "VIEWPORT_OFFSET_X".into(),
+ XF_VIEWPORT_OFFSET_Y => "VIEWPORT_OFFSET_Y".into(),
+ XF_VIEWPORT_OFFSET_Z => "VIEWPORT_OFFSET_Z".into(),
+ XF_PROJECTION_BASE..=XF_PROJECTION_END => format!("PROJECTION[{}]", a - XF_PROJECTION_BASE),
+ XF_NUM_TEXGENS => "NUMTEXGENS".into(),
+ 0x1040..=0x1047 => format!("TEXGEN{}", a - 0x1040),
+ 0x1050..=0x1057 => format!("DUALTEXGEN{}", a - 0x1050),
+ _ => format!("XF_{a:04X}"),
+ }
+}
+
+fn prim_name(cmd: u8) -> String {
+ match Primitive::from_cmd(cmd) {
+ Some(p) => format!("{p:?}"),
+ None => format!("PRIM_{cmd:02X}"),
+ }
+}
+
+fn load_indx_letter(cmd: u8) -> char {
+ match cmd {
+ LOAD_INDX_A_CMD => 'A',
+ LOAD_INDX_B_CMD => 'B',
+ LOAD_INDX_C_CMD => 'C',
+ _ => 'D',
+ }
+}
+
+pub fn summary(cmd: &Command) -> String {
+ match &cmd.kind {
+ CmdKind::Nop => "NOP".into(),
+ CmdKind::InvVtxCache => "INV_VTX_CACHE".into(),
+ CmdKind::Cp { reg, value } => {
+ format!("CP {} = {value:08X}", self::cp_reg_name(*reg))
+ }
+ CmdKind::Xf { addr, values } => {
+ format!("XF {} ({} words)", self::xf_addr_name(*addr), values.len())
+ }
+ CmdKind::Bp { reg, value } => {
+ format!("BP {} = {value:06X}", self::bp_reg_name(*reg))
+ }
+ CmdKind::LoadIndx {
+ cmd,
+ index,
+ xf_addr,
+ xf_count,
+ } => format!(
+ "LOAD_INDX_{} idx {index} -> xf[{xf_addr:03X}] x{xf_count}",
+ self::load_indx_letter(*cmd)
+ ),
+ CmdKind::CallDl {
+ phys_addr,
+ nbytes,
+ children,
+ missing,
+ } => {
+ if *missing {
+ format!("CALL_DL {phys_addr:08X} ({nbytes} bytes, unmapped)")
+ } else {
+ format!("CALL_DL {phys_addr:08X} ({nbytes} bytes, {} cmds)", children.len())
+ }
+ }
+ CmdKind::Draw {
+ cmd,
+ vat,
+ count,
+ stride,
+ } => format!(
+ "DRAW {} vat{vat} {count} verts (stride {stride})",
+ self::prim_name(*cmd)
+ ),
+ CmdKind::Unknown { opcode } => format!("UNKNOWN {opcode:02X}"),
+ CmdKind::Truncated { opcode } => format!("TRUNCATED {opcode:02X} ({} bytes)", cmd.len),
+ }
+}
+
+fn bp_detail(reg: u8, value: u32) -> String {
+ let r = reg as usize;
+ match r {
+ BP_GEN_MODE => format!("{:#?}", GenMode::from_raw(value)),
+ _ if (BP_IND_CMD_0..BP_IND_CMD_0 + BP_IND_CMD_COUNT).contains(&r) => {
+ format!("{:#?}", TevIndirect::from_raw(value))
+ }
+ BP_SU_SCIS_TL | BP_SU_SCIS_BR => format!("{:#?}", SuScisRect::from_raw(value)),
+ BP_RAS1_SS0 | BP_RAS1_SS1 => format!("{:#?}", Ras1Ss::from_raw(value)),
+ BP_RAS1_IREF => format!("{:#?}", Ras1IRef::from_raw(value)),
+ _ if (BP_RAS1_TREF0..BP_RAS1_TREF0 + BP_RAS1_TREF_COUNT).contains(&r) => {
+ format!("{:#?}", TevOrder::from_raw(value))
+ }
+ BP_PE_ZMODE => format!("{:#?}", ZMode::from_raw(value)),
+ BP_PE_CMODE0 => format!("{:#?}", BlendMode::from_raw(value)),
+ BP_PE_ZCOMPARE => format!("{:#?}", PeControl::from_raw(value)),
+ BP_PE_COPY_SRC => format!("{:#?}", EfbCopySrc::from_raw(value)),
+ BP_PE_COPY_DIMS => format!("{:#?}", EfbCopyDims::from_raw(value)),
+ BP_PE_COPY_DST => format!("{:#?}", EfbCopyDst::from_raw(value)),
+ BP_PE_COPY_DST_STRIDE => format!("{:#?}", EfbCopyDstStride::from_raw(value)),
+ BP_PE_COPY_YSCALE => format!("{:#?}", DispCopyYScale::from_raw(value)),
+ BP_PE_COPY_CLEAR_AR => format!("{:#?}", PeClearAr::from_raw(value)),
+ BP_PE_COPY_CLEAR_GB => format!("{:#?}", PeClearGb::from_raw(value)),
+ BP_PE_COPY_CLEAR_Z => format!("{:#?}", PeClearZ::from_raw(value)),
+ BP_PE_COPY_CMD => format!("{:#?}", PeCopyCmd::from_raw(value)),
+ BP_SU_SCIS_OFFSET => format!("{:#?}", SuScisOffset::from_raw(value)),
+ 0x80..=0x83 | 0xA0..=0xA3 => format!("{:#?}", TxSetMode0::from_raw(value)),
+ 0x88..=0x8B | 0xA8..=0xAB => format!("{:#?}", TxSetImage0::from_raw(value)),
+ 0x94..=0x97 | 0xB4..=0xB7 => {
+ let img = TxSetImage3::from_raw(value);
+ format!("{img:#?}\nram addr: {:#010X}", img.image_base() << 5)
+ }
+ 0xC0..=0xDF if r % 2 == 0 => format!("{:#?}", TevColorEnv::from_raw(value)),
+ 0xC0..=0xDF => format!("{:#?}", TevAlphaEnv::from_raw(value)),
+ 0xE0..=0xE7 if r % 2 == 0 => format!("{:#?}", TevRegisterL::from_raw(value)),
+ 0xE0..=0xE7 => format!("{:#?}", TevRegisterH::from_raw(value)),
+ BP_PE_ALPHA_COMPARE => format!("{:#?}", AlphaCompare::from_raw(value)),
+ BP_TEV_ZTEX1 => format!("{:#?}", TevZtex1::from_raw(value)),
+ BP_TEV_ZTEX2 => format!("{:#?}", TevZtex2::from_raw(value)),
+ _ => String::new(),
+ }
+}
+
+fn cp_detail(reg: u8, value: u32) -> String {
+ let r = reg as usize;
+ match r {
+ 0x30 => format!("{:#?}", MatrixIndex0::from_raw(value)),
+ 0x40 => format!("{:#?}", MatrixIndex1::from_raw(value)),
+ VCD_LO_REG => format!("{:#?}", VcdLo::from_raw(value)),
+ VCD_HI_REG => format!("{:#?}", VcdHi::from_raw(value)),
+ _ if (VATA_REG..VATA_REG + 8).contains(&r) => format!("{:#?}", VatA::from_raw(value)),
+ _ if (VATB_REG..VATB_REG + 8).contains(&r) => format!("{:#?}", VatB::from_raw(value)),
+ _ if (VATC_REG..VATC_REG + 8).contains(&r) => format!("{:#?}", VatC::from_raw(value)),
+ _ if (ARRAY_BASE_REG..ARRAY_BASE_REG + 16).contains(&r) => {
+ format!("base: {:#010X}", value & 0x03FF_FFFF)
+ }
+ _ if (ARRAY_STRIDE_REG..ARRAY_STRIDE_REG + 16).contains(&r) => {
+ format!("stride: {}", value & 0xFF)
+ }
+ _ => String::new(),
+ }
+}
+
+fn xf_detail(addr: u16, values: &[u32]) -> String {
+ let mut out = String::new();
+ let a = addr as usize;
+ let float_region = a < 0x0800
+ || (XF_VIEWPORT_BASE..=XF_VIEWPORT_END).contains(&a)
+ || (XF_PROJECTION_BASE..=XF_PROJECTION_END).contains(&a);
+ for (i, v) in values.iter().enumerate() {
+ let reg = a + i;
+ let name = self::xf_addr_name(reg as u16);
+ if float_region {
+ out.push_str(&format!("{name}: {} ({v:08X})\n", f32::from_bits(*v)));
+ } else {
+ out.push_str(&format!("{name}: {v:08X}\n"));
+ }
+ }
+
+ match a {
+ XF_COLOR_CTRL0 | XF_COLOR_CTRL1 | XF_ALPHA_CTRL0 | XF_ALPHA_CTRL1 => {
+ out.push_str(&format!("{:#?}\n", ChanCtrl::from_raw(values[0])));
+ }
+ 0x1040..=0x1047 => out.push_str(&format!("{:#?}\n", TexGenReg::from_raw(values[0]))),
+ 0x1050..=0x1057 => out.push_str(&format!("{:#?}\n", DualTexGenReg::from_raw(values[0]))),
+ XF_MATRIX_INDEX_A => out.push_str(&format!("{:#?}\n", MatrixIndex0::from_raw(values[0]))),
+ XF_MATRIX_INDEX_B => out.push_str(&format!("{:#?}\n", MatrixIndex1::from_raw(values[0]))),
+ _ => {}
+ }
+
+ out
+}
+
+pub fn detail(cmd: &Command) -> String {
+ match &cmd.kind {
+ CmdKind::Cp { reg, value } => {
+ let decoded = self::cp_detail(*reg, *value);
+ format!("CP[{reg:02X}] {} = {value:08X}\n{decoded}", self::cp_reg_name(*reg))
+ }
+ CmdKind::Bp { reg, value } => {
+ let decoded = self::bp_detail(*reg, *value);
+ format!("BP[{reg:02X}] {} = {value:06X}\n{decoded}", self::bp_reg_name(*reg))
+ }
+ CmdKind::Xf { addr, values } => {
+ format!(
+ "XF[{addr:04X}..{:04X}]\n{}",
+ *addr as usize + values.len(),
+ self::xf_detail(*addr, values)
+ )
+ }
+ CmdKind::LoadIndx {
+ cmd,
+ index,
+ xf_addr,
+ xf_count,
+ } => format!(
+ "LOAD_INDX_{}\narray index: {index}\nxf dest: {xf_addr:03X}\ncount: {xf_count}",
+ self::load_indx_letter(*cmd)
+ ),
+ CmdKind::CallDl {
+ phys_addr,
+ nbytes,
+ children,
+ missing,
+ } => format!(
+ "CALL_DL\naddr: {phys_addr:#010X}\nsize: {nbytes} bytes\ncommands: {}{}",
+ children.len(),
+ if *missing { "\n(source unmapped)" } else { "" }
+ ),
+ CmdKind::Draw {
+ cmd,
+ vat,
+ count,
+ stride,
+ } => format!(
+ "DRAW {}\nvat: {vat}\nvertices: {count}\nstride: {stride} bytes\ndata: {} bytes",
+ self::prim_name(*cmd),
+ *count as usize * stride
+ ),
+ other => self::summary(&Command {
+ offset: cmd.offset,
+ len: cmd.len,
+ kind: other.clone(),
+ }),
+ }
+}
diff --git a/crates/fifoplayer/src/debug/edits.rs b/crates/fifoplayer/src/debug/edits.rs
new file mode 100644
index 0000000..f4f3ab1
--- /dev/null
+++ b/crates/fifoplayer/src/debug/edits.rs
@@ -0,0 +1,160 @@
+use gecko::flipper::gx::constants::NOP_CMD;
+use std::collections::{BTreeMap, HashMap, HashSet};
+use std::path::Path;
+
+#[derive(Clone, Default)]
+pub struct FrameEdits {
+ pub boundaries: Vec<(usize, usize)>,
+ pub disabled: HashSet<usize>,
+ pub replacements: BTreeMap<usize, Vec<u8>>,
+}
+
+impl FrameEdits {
+ pub fn is_empty(&self) -> bool {
+ self.disabled.is_empty() && self.replacements.is_empty()
+ }
+}
+
+#[derive(Default)]
+pub struct EditModel {
+ pub frames: HashMap<usize, FrameEdits>,
+}
+
+impl EditModel {
+ pub fn frame(&self, idx: usize) -> Option<&FrameEdits> {
+ self.frames.get(&idx).filter(|fe| !fe.is_empty())
+ }
+
+ pub fn frame_mut(&mut self, idx: usize, boundaries: impl FnOnce() -> Vec<(usize, usize)>) -> &mut FrameEdits {
+ let fe = self.frames.entry(idx).or_default();
+
+ if fe.boundaries.is_empty() {
+ fe.boundaries = boundaries();
+ }
+
+ fe
+ }
+
+ pub fn any(&self) -> bool {
+ self.frames.values().any(|fe| !fe.is_empty())
+ }
+
+ pub fn save_to_dff(&self, file: &dff::DffFile, path: &Path) -> Result<(), dff::DffError> {
+ let mut out = file.clone();
+
+ for (idx, frame) in out.frames.iter_mut().enumerate() {
+ let Some(fe) = self.frame(idx) else { continue };
+
+ let eff = EffectiveFrame::build(frame, Some(fe));
+ frame.fifo_data = eff.exec_fifo().into_owned();
+ frame.memory_updates = eff.updates;
+ }
+
+ out.save(path)
+ }
+}
+
+pub struct EffectiveFrame {
+ pub fifo: Vec<u8>,
+ pub updates: Vec<dff::MemoryUpdate>,
+ pub disabled: HashSet<usize>,
+ pub orig_of: BTreeMap<usize, (usize, usize)>,
+}
+
+impl EffectiveFrame {
+ pub fn build(frame: &dff::Frame, fe: Option<&FrameEdits>) -> Self {
+ let Some(fe) = fe.filter(|fe| !fe.is_empty()) else {
+ return EffectiveFrame {
+ fifo: frame.fifo_data.clone(),
+ updates: frame.memory_updates.clone(),
+ disabled: HashSet::new(),
+ orig_of: BTreeMap::new(),
+ };
+ };
+
+ let orig = &frame.fifo_data;
+ let mut fifo = Vec::with_capacity(orig.len());
+ let mut disabled = HashSet::new();
+ let mut orig_of = BTreeMap::new();
+ let mut offset_map: Vec<(usize, usize)> = Vec::with_capacity(fe.boundaries.len() + 1);
+
+ let mut covered = 0usize;
+ for &(off, len) in &fe.boundaries {
+ if off > covered {
+ fifo.extend_from_slice(&orig[covered..off]);
+ }
+
+ let display_off = fifo.len();
+ offset_map.push((off, display_off));
+
+ match fe.replacements.get(&off) {
+ Some(bytes) => fifo.extend_from_slice(bytes),
+ None => fifo.extend_from_slice(&orig[off..off + len]),
+ }
+
+ orig_of.insert(display_off, (off, fifo.len() - display_off));
+ if fe.disabled.contains(&off) {
+ disabled.insert(display_off);
+ }
+
+ covered = off + len;
+ }
+
+ if covered < orig.len() {
+ fifo.extend_from_slice(&orig[covered..]);
+ }
+
+ offset_map.push((covered, fifo.len().min(usize::MAX)));
+
+ let remap = |p: usize| -> usize {
+ match offset_map.binary_search_by_key(&p, |&(o, _)| o) {
+ Ok(i) => offset_map[i].1,
+ Err(0) => p,
+ Err(i) => {
+ let (orig_start, disp_start) = offset_map[i - 1];
+ let span_end = offset_map.get(i).map_or(fifo.len(), |&(_, d)| d);
+ (disp_start + (p - orig_start)).min(span_end)
+ }
+ }
+ };
+
+ let mut updates = frame.memory_updates.clone();
+
+ for update in &mut updates {
+ update.fifo_position = remap(update.fifo_position as usize) as u32;
+ }
+
+ updates.sort_by_key(|u| u.fifo_position);
+
+ EffectiveFrame {
+ fifo,
+ updates,
+ disabled,
+ orig_of,
+ }
+ }
+
+ pub fn exec_fifo(&self) -> std::borrow::Cow<'_, [u8]> {
+ if self.disabled.is_empty() {
+ return std::borrow::Cow::Borrowed(&self.fifo);
+ }
+
+ let mut out = self.fifo.clone();
+
+ for &off in &self.disabled {
+ if let Some(&(_, len)) = self.orig_of.get(&off) {
+ out[off..off + len].fill(NOP_CMD);
+ }
+ }
+
+ std::borrow::Cow::Owned(out)
+ }
+
+ pub fn pristine_offset(&self, display_off: usize) -> Option<usize> {
+ if self.orig_of.is_empty() {
+ return Some(display_off);
+ }
+
+ self.orig_of.get(&display_off).map(|&(o, _)| o)
+ }
+}
diff --git a/crates/fifoplayer/src/debug/slice.rs b/crates/fifoplayer/src/debug/slice.rs
new file mode 100644
index 0000000..6c8e4fb
--- /dev/null
+++ b/crates/fifoplayer/src/debug/slice.rs
@@ -0,0 +1,328 @@
+use gecko::flipper::gx::constants::*;
+use gecko::flipper::gx::fifo::vertex_stride_from_cp;
+use gecko::mmio::RamView;
+use std::collections::HashSet;
+
+pub const MAX_DL_DEPTH: u8 = 4;
+
+#[derive(Clone, Debug)]
+pub enum CmdKind {
+ Nop,
+ InvVtxCache,
+ Cp {
+ reg: u8,
+ value: u32,
+ },
+ Xf {
+ addr: u16,
+ values: Vec<u32>,
+ },
+ Bp {
+ reg: u8,
+ value: u32,
+ },
+ LoadIndx {
+ cmd: u8,
+ index: u16,
+ xf_addr: u16,
+ xf_count: u8,
+ },
+ CallDl {
+ phys_addr: u32,
+ nbytes: u32,
+ children: Vec<Command>,
+ missing: bool,
+ },
+ Draw {
+ cmd: u8,
+ vat: u8,
+ count: u16,
+ stride: usize,
+ },
+ Unknown {
+ opcode: u8,
+ },
+ Truncated {
+ opcode: u8,
+ },
+}
+
+#[derive(Clone, Debug)]
+pub struct Command {
+ pub offset: usize,
+ pub len: usize,
+ pub kind: CmdKind,
+}
+
+impl Command {
+ pub fn end(&self) -> usize {
+ self.offset + self.len
+ }
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct CommandIndex {
+ pub commands: Vec<Command>,
+ pub truncated: bool,
+}
+
+pub struct RamOverlay<'a> {
+ pub ram: RamView<'a>,
+ pub updates: &'a [dff::MemoryUpdate],
+}
+
+impl RamOverlay<'_> {
+ pub fn read(&self, addr: usize, len: usize, upto: u32) -> Option<Vec<u8>> {
+ let mut buf = self.ram.slice(addr, len)?.to_vec();
+ let end = addr + len;
+
+ for update in self.updates {
+ if update.fifo_position > upto {
+ break;
+ }
+
+ let ua = update.address as usize;
+ let ue = ua + update.data.len();
+ if ua < end && addr < ue {
+ let s = ua.max(addr);
+ let e = ue.min(end);
+ buf[s - addr..e - addr].copy_from_slice(&update.data[s - ua..e - ua]);
+ }
+ }
+
+ Some(buf)
+ }
+}
+
+pub struct SliceCtx<'a> {
+ pub overlay: RamOverlay<'a>,
+ pub disabled: &'a HashSet<usize>,
+}
+
+pub fn slice_frame(fifo: &[u8], cp_seed: &[u32], ctx: &SliceCtx) -> CommandIndex {
+ let mut shadow = cp_seed.to_vec();
+ let mut commands = Vec::new();
+
+ let truncated = self::slice_buf(fifo, &mut shadow, ctx, 0, None, true, &mut commands);
+
+ CommandIndex { commands, truncated }
+}
+
+fn slice_buf(
+ buf: &[u8],
+ shadow: &mut [u32],
+ ctx: &SliceCtx,
+ depth: u8,
+ inherited_upto: Option<u32>,
+ apply: bool,
+ out: &mut Vec<Command>,
+) -> bool {
+ let mut pos = 0usize;
+ loop {
+ let remaining = buf.len() - pos;
+ if remaining == 0 {
+ return false;
+ }
+
+ let cmd = buf[pos];
+ let offset = pos;
+ let upto = inherited_upto.unwrap_or(offset as u32);
+ let enabled = apply && (depth > 0 || !ctx.disabled.contains(&offset));
+
+ let truncate = |out: &mut Vec<Command>| {
+ out.push(Command {
+ offset,
+ len: remaining,
+ kind: CmdKind::Truncated { opcode: cmd },
+ });
+ };
+
+ match cmd {
+ NOP_CMD => {
+ out.push(Command {
+ offset,
+ len: 1,
+ kind: CmdKind::Nop,
+ });
+
+ pos += 1;
+ }
+ INV_VTX_CACHE_CMD => {
+ out.push(Command {
+ offset,
+ len: 1,
+ kind: CmdKind::InvVtxCache,
+ });
+
+ pos += 1;
+ }
+ CP_CMD => {
+ if remaining < 6 {
+ truncate(out);
+ return true;
+ }
+
+ let reg = buf[pos + 1];
+ let value = u32::from_be_bytes(buf[pos + 2..pos + 6].try_into().unwrap());
+ if enabled && (reg as usize) < shadow.len() {
+ shadow[reg as usize] = value;
+ }
+
+ out.push(Command {
+ offset,
+ len: 6,
+ kind: CmdKind::Cp { reg, value },
+ });
+
+ pos += 6;
+ }
+ XF_CMD => {
+ if remaining < 5 {
+ truncate(out);
+ return true;
+ }
+
+ let length = u16::from_be_bytes([buf[pos + 1], buf[pos + 2]]) as usize;
+ let n = length + 1;
+ let total = 5 + n * 4;
+ if remaining < total {
+ truncate(out);
+ return true;
+ }
+
+ let addr = u16::from_be_bytes([buf[pos + 3], buf[pos + 4]]);
+ let values = (0..n)
+ .map(|i| {
+ let o = pos + 5 + i * 4;
+ u32::from_be_bytes(buf[o..o + 4].try_into().unwrap())
+ })
+ .collect();
+
+ out.push(Command {
+ offset,
+ len: total,
+ kind: CmdKind::Xf { addr, values },
+ });
+
+ pos += total;
+ }
+ BP_CMD => {
+ if remaining < 5 {
+ truncate(out);
+ return true;
+ }
+
+ let reg = buf[pos + 1];
+ let value = u32::from_be_bytes([0, buf[pos + 2], buf[pos + 3], buf[pos + 4]]);
+
+ out.push(Command {
+ offset,
+ len: 5,
+ kind: CmdKind::Bp { reg, value },
+ });
+
+ pos += 5;
+ }
+ LOAD_INDX_A_CMD | LOAD_INDX_B_CMD | LOAD_INDX_C_CMD | LOAD_INDX_D_CMD => {
+ if remaining < 5 {
+ truncate(out);
+ return true;
+ }
+
+ let index = u16::from_be_bytes([buf[pos + 1], buf[pos + 2]]);
+ let descriptor = u16::from_be_bytes([buf[pos + 3], buf[pos + 4]]);
+ let xf_addr = descriptor & 0x0FFF;
+ let xf_count = ((descriptor >> 12) & 0xF) as u8 + 1;
+
+ out.push(Command {
+ offset,
+ len: 5,
+ kind: CmdKind::LoadIndx {
+ cmd,
+ index,
+ xf_addr,
+ xf_count,
+ },
+ });
+
+ pos += 5;
+ }
+ CALL_DL_CMD => {
+ if remaining < 9 {
+ truncate(out);
+ return true;
+ }
+
+ let phys_addr = u32::from_be_bytes(buf[pos + 1..pos + 5].try_into().unwrap());
+ let nbytes = u32::from_be_bytes(buf[pos + 5..pos + 9].try_into().unwrap());
+
+ let addr = (phys_addr & 0x3FFFFFFF) as usize;
+ let mut children = Vec::new();
+ let mut missing = false;
+
+ if depth < MAX_DL_DEPTH {
+ match ctx.overlay.read(addr, nbytes as usize, upto) {
+ Some(dl_buf) => {
+ let _ =
+ self::slice_buf(&dl_buf, shadow, ctx, depth + 1, Some(upto), enabled, &mut children);
+ }
+ None => missing = true,
+ }
+ } else {
+ missing = true;
+ }
+
+ out.push(Command {
+ offset,
+ len: 9,
+ kind: CmdKind::CallDl {
+ phys_addr,
+ nbytes,
+ children,
+ missing,
+ },
+ });
+
+ pos += 9;
+ }
+ DRAW_COMMANDS_START..=DRAW_COMMANDS_END => {
+ if remaining < 3 {
+ truncate(out);
+ return true;
+ }
+
+ let count = u16::from_be_bytes([buf[pos + 1], buf[pos + 2]]);
+ let vat = cmd & 0b111;
+ let stride = vertex_stride_from_cp(shadow, vat as usize);
+
+ let total = 3 + count as usize * stride;
+ if remaining < total {
+ truncate(out);
+ return true;
+ }
+
+ out.push(Command {
+ offset,
+ len: total,
+ kind: CmdKind::Draw {
+ cmd,
+ vat,
+ count,
+ stride,
+ },
+ });
+
+ pos += total;
+ }
+ _ => {
+ out.push(Command {
+ offset,
+ len: 1,
+ kind: CmdKind::Unknown { opcode: cmd },
+ });
+
+ pos += 1;
+ }
+ }
+ }
+}
diff --git a/crates/fifoplayer/src/debug/ui.rs b/crates/fifoplayer/src/debug/ui.rs
new file mode 100644
index 0000000..dd29ec9
--- /dev/null
+++ b/crates/fifoplayer/src/debug/ui.rs
@@ -0,0 +1,1225 @@
+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,
+}
+
+#[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 {
+ 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(),
+ };
+
+ 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,
+) {
+ 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");
+ 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,
+}
+
+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::StepCmd => {
+ self.session.step_command();
+ }
+ UiAction::StepDraw => self.session.step_draw(),
+ 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),
+ 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);
+ }
+
+ 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",
+ })
+ .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");
+ });
+
+ 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() {
+ self.selection = Selection::Cmd(i);
+ }
+ });
+ }
+ }
+ }
+
+ 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(|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),
+ });
+ });
+ }
+
+ 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 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) {
+ 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("Register breakpoints").strong());
+ ui.label(egui::RichText::new("cp <hex> | bp <hex> | xf <hex>").weak());
+
+ ui.horizontal(|ui| {
+ ui.add(egui::TextEdit::singleline(&mut self.bp_input).desired_width(120.0));
+
+ if ui.button(format!("{} Add", icons::PLUS)).clicked() {
+ let input = self.bp_input.trim().to_lowercase();
+ let mut parts = input.split_whitespace();
+ let kind = parts.next().unwrap_or("");
+ let val = parts.next().and_then(|v| u16::from_str_radix(v, 16).ok());
+
+ match (kind, val) {
+ ("cp", Some(v)) if v <= 0xFF => {
+ bp.cp_regs.insert(v as u8);
+ self.bp_input.clear();
+ }
+ ("bp", Some(v)) if v <= 0xFF => {
+ bp.bp_regs.insert(v as u8);
+ self.bp_input.clear();
+ }
+ ("xf", Some(v)) => {
+ bp.xf_addrs.insert(v);
+ self.bp_input.clear();
+ }
+ _ => self.status_msg = "expected: cp|bp|xf <hex>".into(),
+ }
+ }
+ });
+
+ 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| {
+ ui.label(egui::RichText::new(format!("frame {frame} cmd {row}")).monospace());
+ 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) {
+ egui::CentralPanel::default().show_inside(root, |ui| {
+ let show_xfb = match self.view_mode {
+ ViewMode::Xfb => true,
+ ViewMode::Efb => false,
+ ViewMode::Auto => self.session.row == 0 && 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 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();
+ self.flush_gx();
+ self.scroll_to_current = true;
+ }
+
+ self.render();
+ }
+ _ => {}
+ }
+ }
+}
diff --git a/crates/fifoplayer/src/main.rs b/crates/fifoplayer/src/main.rs
index 2ae2b8a..6c52d47 100644
--- a/crates/fifoplayer/src/main.rs
+++ b/crates/fifoplayer/src/main.rs
@@ -1,3 +1,4 @@
+mod debug;
mod playback;
use backend_wgpu::sink::{InlineSink, TargetAspect};
@@ -42,6 +43,11 @@ struct Args {
/// Display aspect ratio: auto (16:9 Wii / 4:3 GC), 4:3, 16:9, stretch
#[arg(long, default_value = "auto")]
aspect: String,
+
+ /// Open the FIFO debugger (stepping, disassembly, editing). With
+ /// --screenshot, replays through the stepping engine headlessly instead.
+ #[arg(long)]
+ debug: bool,
}
fn main() {
@@ -65,6 +71,7 @@ fn main() {
eprintln!("failed to load {}: {e}", args.file.display());
std::process::exit(1);
});
+
if file.frames.is_empty() {
eprintln!("{}: no frames", args.file.display());
std::process::exit(1);
@@ -95,26 +102,35 @@ fn run<const SYSTEM: gecko::SystemId>(file: dff::DffFile, args: Args) {
let start = args.start.min(last);
let end = args.end.unwrap_or(last).clamp(start, last);
- if let Some(ref out) = args.screenshot {
+ if args.debug {
+ if let Some(ref out) = args.screenshot {
+ debug::ui::run_headless::<SYSTEM>(file, args.file, start, end, out);
+ } else {
+ debug::ui::run_debug::<SYSTEM>(file, args.file, start, end);
+ }
+ } else if let Some(ref out) = args.screenshot {
self::run_headless::<SYSTEM>(&file, start, end, out, args.dump_textures.as_deref());
} else {
self::run_windowed::<SYSTEM>(file, start, end, args.once, &args.aspect);
}
}
-fn init_wgpu() -> (wgpu::Instance, wgpu::Adapter, wgpu::Device, wgpu::Queue) {
+pub(crate) fn init_wgpu() -> (wgpu::Instance, wgpu::Adapter, wgpu::Device, wgpu::Queue) {
let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
backends: wgpu::Backends::all(),
..wgpu::InstanceDescriptor::new_without_display_handle()
});
+
let adapter = pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions {
power_preference: wgpu::PowerPreference::default(),
compatible_surface: None,
force_fallback_adapter: false,
}))
.expect("no compatible wgpu adapter");
+
let (device, queue) = pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor::default()))
.expect("failed to acquire wgpu device");
+
(instance, adapter, device, queue)
}
@@ -134,11 +150,13 @@ fn run_headless<const SYSTEM: gecko::SystemId>(
playback.load_state(file, &mut sink);
let mut presented = 0usize;
+
for frame in &file.frames[start..=end] {
if playback.play_frame(frame, &mut sink) {
presented += 1;
}
}
+
eprintln!("played frames {start}..={end}, {presented} presents");
if let Some(dir) = dump_textures {
@@ -181,8 +199,10 @@ impl<const SYSTEM: gecko::SystemId> WindowedApp<SYSTEM> {
if self.finished {
return;
}
+
self.playback
.play_frame(&self.file.frames[self.frame_idx], &mut self.sink);
+
if self.frame_idx >= self.end {
if self.once {
self.finished = true;
@@ -202,7 +222,7 @@ impl<const SYSTEM: gecko::SystemId> ApplicationHandler for WindowedApp<SYSTEM> {
event_loop
.create_window(
Window::default_attributes()
- .with_title("gecko FIFO player")
+ .with_title("Gecko — FIFO Player")
.with_inner_size(winit::dpi::PhysicalSize::new(1280, 960)),
)
.unwrap(),
@@ -210,11 +230,13 @@ impl<const SYSTEM: gecko::SystemId> ApplicationHandler for WindowedApp<SYSTEM> {
let surface = self.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), self.renderer.target_aspect());
if (sw, sh) != (actual.width, actual.height) {
let _ = window.request_inner_size(winit::dpi::PhysicalSize::new(sw, sh));
}
+
let surface_caps = surface.get_capabilities(&self.adapter);
let surface_config = wgpu::SurfaceConfiguration {
usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
@@ -226,9 +248,11 @@ impl<const SYSTEM: gecko::SystemId> ApplicationHandler for WindowedApp<SYSTEM> {
view_formats: vec![],
desired_maximum_frame_latency: 2,
};
+
surface.configure(&self.device, &surface_config);
window.request_redraw();
+
self.window = Some(window);
self.surface = Some((surface, surface_config));
}
@@ -241,6 +265,7 @@ impl<const SYSTEM: gecko::SystemId> ApplicationHandler for WindowedApp<SYSTEM> {
if size.width == 0 || size.height == 0 {
return;
}
+
let (sw, sh) = backend_wgpu::sink::snap_size_to_aspect(
(size.width, size.height),
self.renderer.target_aspect(),
@@ -248,6 +273,7 @@ impl<const SYSTEM: gecko::SystemId> ApplicationHandler for WindowedApp<SYSTEM> {
if (sw, sh) != (size.width, size.height) {
let _ = window.request_inner_size(winit::dpi::PhysicalSize::new(sw, sh));
}
+
config.width = sw;
config.height = sh;
surface.configure(&self.device, config);
@@ -265,6 +291,7 @@ impl<const SYSTEM: gecko::SystemId> ApplicationHandler for WindowedApp<SYSTEM> {
}
};
let view = frame.texture.create_view(&Default::default());
+
self.renderer.blit(&self.queue, &view, (config.width, config.height));
frame.present();
diff --git a/crates/fifoplayer/src/playback.rs b/crates/fifoplayer/src/playback.rs
index 39ee569..f29a9a2 100644
--- a/crates/fifoplayer/src/playback.rs
+++ b/crates/fifoplayer/src/playback.rs
@@ -100,32 +100,36 @@ impl<const SYSTEM: SystemId> Playback<SYSTEM> {
self.feed(&stream, sink);
}
- fn feed(&mut self, bytes: &[u8], sink: &mut PlayerSink) {
+ pub fn feed(&mut self, bytes: &[u8], sink: &mut PlayerSink) {
self.gx.fifo.extend_from_slice(bytes);
self.gx.drain_fifo(&mut self.mmio, sink);
}
pub fn play_frame(&mut self, frame: &dff::Frame, sink: &mut PlayerSink) -> bool {
+ self.play_frame_with(&frame.fifo_data, &frame.memory_updates, sink)
+ }
+
+ pub fn play_frame_with(&mut self, fifo_data: &[u8], updates: &[dff::MemoryUpdate], sink: &mut PlayerSink) -> bool {
let mut pos = 0usize;
- for update in &frame.memory_updates {
- let p = (update.fifo_position as usize).min(frame.fifo_data.len());
+ for update in updates {
+ let p = (update.fifo_position as usize).min(fifo_data.len());
if p > pos {
- self.feed(&frame.fifo_data[pos..p], sink);
+ self.feed(&fifo_data[pos..p], sink);
pos = p;
}
self.apply_update(update, sink);
}
- if pos < frame.fifo_data.len() {
- self.feed(&frame.fifo_data[pos..], sink);
+ if pos < fifo_data.len() {
+ self.feed(&fifo_data[pos..], sink);
}
self.present(sink)
}
- fn apply_update(&mut self, update: &dff::MemoryUpdate, sink: &mut PlayerSink) {
+ pub fn apply_update(&mut self, update: &dff::MemoryUpdate, sink: &mut PlayerSink) {
{
let mut ram = self.mmio.ram_view_mut();
match ram.slice_mut(update.address as usize, update.data.len()) {
@@ -150,15 +154,18 @@ impl<const SYSTEM: SystemId> Playback<SYSTEM> {
fn update_overlaps_bound_texture(&self, update: &dff::MemoryUpdate) -> bool {
let a = update.address as usize;
let a_end = a + update.data.len();
+
self.gx.cur_textures.iter().flatten().any(|desc| {
let t = desc.ram_addr;
let t_end = t + texture::raw_data_size(desc.width, desc.height, desc.format);
+
a < t_end && t < a_end
})
}
- fn present(&mut self, sink: &mut PlayerSink) -> bool {
+ pub fn present(&mut self, sink: &mut PlayerSink) -> bool {
let heights = std::mem::take(&mut sink.xfb_heights);
+
if self.gx.xfb_copies.is_empty() {
return false;
}
@@ -169,20 +176,25 @@ impl<const SYSTEM: SystemId> Playback<SYSTEM> {
let mut parts: Vec<XfbPart> = Vec::new();
let mut frame_h = 0u32;
+
for copy in &self.gx.xfb_copies {
let delta_px = (copy.dest_addr - min_base) / 2;
let offset_x = delta_px % stride_px;
let offset_y = delta_px / stride_px;
+
if offset_x != 0 {
continue;
}
+
let dst_h = heights
.iter()
.rev()
.find(|(id, _)| *id == copy.dest_addr)
.map(|(_, h)| *h)
.unwrap_or(copy.src_h);
+
frame_h = frame_h.max(offset_y + dst_h);
+
if !parts.iter().any(|p| p.id == copy.dest_addr) {
parts.push(XfbPart {
id: copy.dest_addr,
@@ -191,11 +203,13 @@ impl<const SYSTEM: SystemId> Playback<SYSTEM> {
});
}
}
+
self.gx.xfb_copies.clear();
if parts.is_empty() || frame_h == 0 {
return false;
}
+
sink.exec(GxAction::PresentXfb {
width: stride_px,
height: frame_h,
diff --git a/crates/gecko/src/flipper/gx/fifo.rs b/crates/gecko/src/flipper/gx/fifo.rs
index 529f1e5..83cc20a 100644
--- a/crates/gecko/src/flipper/gx/fifo.rs
+++ b/crates/gecko/src/flipper/gx/fifo.rs
@@ -173,33 +173,37 @@ fn drain_buf<const SYSTEM: SystemId>(
impl GraphicsProcessor {
fn vertex_stride(&self, vertex_format_index: usize) -> usize {
- let vcd_lo = VcdLo::from_raw(self.cp_regs[VCD_LO_REG]);
- let vcd_hi = VcdHi::from_raw(self.cp_regs[VCD_HI_REG]);
- let vat_a = VatA::from_raw(self.cp_regs[VATA_REG + vertex_format_index]);
- let vat_b = VatB::from_raw(self.cp_regs[VATB_REG + vertex_format_index]);
- let vat_c = VatC::from_raw(self.cp_regs[VATC_REG + vertex_format_index]);
-
- let attr_size = |attr: AttributeType, direct_size: usize| -> usize {
- match attr {
- AttributeType::Direct => direct_size,
- AttributeType::Index8 => 1,
- AttributeType::Index16 => 2,
- AttributeType::None => 0,
- }
- };
-
- vcd_lo.mtx_idx_count()
- + attr_size(vcd_lo.position(), vat_a.pos_data_size())
- + vat_a.nrm_stream_size(vcd_lo.normal())
- + attr_size(vcd_lo.color0(), vat_a.clr0_data_size())
- + attr_size(vcd_lo.color1(), vat_a.clr1_data_size())
- + attr_size(vcd_hi.tex0(), vat_a.tex0_data_size())
- + attr_size(vcd_hi.tex1(), vat_b.tex1_data_size())
- + attr_size(vcd_hi.tex2(), vat_b.tex2_data_size())
- + attr_size(vcd_hi.tex3(), vat_b.tex3_data_size())
- + attr_size(vcd_hi.tex4(), vat_b.tex4_data_size())
- + attr_size(vcd_hi.tex5(), vat_c.tex5_data_size())
- + attr_size(vcd_hi.tex6(), vat_c.tex6_data_size())
- + attr_size(vcd_hi.tex7(), vat_c.tex7_data_size())
+ self::vertex_stride_from_cp(&self.cp_regs, vertex_format_index)
}
}
+
+pub fn vertex_stride_from_cp(cp_regs: &[u32], vertex_format_index: usize) -> usize {
+ let vcd_lo = VcdLo::from_raw(cp_regs[VCD_LO_REG]);
+ let vcd_hi = VcdHi::from_raw(cp_regs[VCD_HI_REG]);
+ let vat_a = VatA::from_raw(cp_regs[VATA_REG + vertex_format_index]);
+ let vat_b = VatB::from_raw(cp_regs[VATB_REG + vertex_format_index]);
+ let vat_c = VatC::from_raw(cp_regs[VATC_REG + vertex_format_index]);
+
+ let attr_size = |attr: AttributeType, direct_size: usize| -> usize {
+ match attr {
+ AttributeType::Direct => direct_size,
+ AttributeType::Index8 => 1,
+ AttributeType::Index16 => 2,
+ AttributeType::None => 0,
+ }
+ };
+
+ vcd_lo.mtx_idx_count()
+ + attr_size(vcd_lo.position(), vat_a.pos_data_size())
+ + vat_a.nrm_stream_size(vcd_lo.normal())
+ + attr_size(vcd_lo.color0(), vat_a.clr0_data_size())
+ + attr_size(vcd_lo.color1(), vat_a.clr1_data_size())
+ + attr_size(vcd_hi.tex0(), vat_a.tex0_data_size())
+ + attr_size(vcd_hi.tex1(), vat_b.tex1_data_size())
+ + attr_size(vcd_hi.tex2(), vat_b.tex2_data_size())
+ + attr_size(vcd_hi.tex3(), vat_b.tex3_data_size())
+ + attr_size(vcd_hi.tex4(), vat_b.tex4_data_size())
+ + attr_size(vcd_hi.tex5(), vat_c.tex5_data_size())
+ + attr_size(vcd_hi.tex6(), vat_c.tex6_data_size())
+ + attr_size(vcd_hi.tex7(), vat_c.tex7_data_size())
+}