A GameCube/Wii emulator and debugger written in Rust.
fifo debugger
Layle55e6b355838e
diff --git a/Cargo.lock b/Cargo.lockindex 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.rsindex 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 ofdiff --git a/crates/dff/src/lib.rs b/crates/dff/src/lib.rsindex 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.tomlindex 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsindex 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.rsindex 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.rsindex 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())+}