A GameCube/Wii emulator and debugger written in Rust.
implement more debugger windows
Layle5e69c2f2f90a
diff --git a/crates/debugger/src/windows/controls.rs b/crates/debugger/src/windows/controls.rsnew file mode 100644index 0000000..0bb1c0b--- /dev/null+++ b/crates/debugger/src/windows/controls.rs@@ -0,0 +1,77 @@+use egui::Context;+use egui_material_icons::icons;++use crate::debugger::EmulatorState;++pub fn show_controls(ctx: &Context, open: &mut bool, state: &mut EmulatorState, run_until_addr_input: &mut String) {+ egui::Window::new("Controls")+ .open(open)+ .resizable(false)+ .default_size(egui::vec2(160.0, 0.0))+ .show(ctx, |ui| {+ let is_paused = *state == EmulatorState::Paused;+ let is_running = *state == EmulatorState::Running;++ ui.set_min_width(140.0);++ let btn_size = egui::vec2(ui.available_width(), 0.0);++ if ui+ .add_enabled(+ is_paused,+ egui::Button::new(format!("{} Continue", icons::ICON_PLAY_ARROW)).min_size(btn_size),+ )+ .clicked()+ {+ *state = EmulatorState::Running;+ }++ if ui+ .add_enabled(+ is_running,+ egui::Button::new(format!("{} Pause", icons::ICON_PAUSE)).min_size(btn_size),+ )+ .clicked()+ {+ *state = EmulatorState::Paused;+ }++ if ui+ .add_enabled(+ is_paused,+ egui::Button::new(format!("{} Step", icons::ICON_SKIP_NEXT)).min_size(btn_size),+ )+ .clicked()+ {+ *state = EmulatorState::Step;+ }++ if ui+ .add(egui::Button::new(format!("{} Run Until VSync", icons::ICON_FAST_FORWARD)).min_size(btn_size))+ .clicked()+ {+ *state = EmulatorState::RunUntilVsync;+ }++ ui.separator();++ ui.horizontal(|ui| {+ let resp = ui.add_enabled(+ is_paused,+ egui::TextEdit::singleline(run_until_addr_input)+ .hint_text("address")+ .desired_width(80.0)+ .font(egui::TextStyle::Monospace),+ );+ let go = ui+ .add_enabled(is_paused, egui::Button::new(format!("{} Run", icons::ICON_PLAY_ARROW)))+ .clicked();+ if go || (resp.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter))) {+ let s = run_until_addr_input.trim().trim_start_matches("0x");+ if let Ok(addr) = u32::from_str_radix(s, 16) {+ *state = EmulatorState::RunUntilAddress(addr);+ }+ }+ });+ });+}diff --git a/crates/debugger/src/windows/exi.rs b/crates/debugger/src/windows/exi.rsnew file mode 100644index 0000000..ce4edb0--- /dev/null+++ b/crates/debugger/src/windows/exi.rs@@ -0,0 +1,253 @@+use egui::{Color32, Context, Grid, RichText};+use egui_material_icons::icons;+use gekko::exi::Exi;++fn flag(ui: &mut egui::Ui, val: bool) {+ let (icon, color) = if val {+ (icons::ICON_RADIO_BUTTON_CHECKED, Color32::from_rgb(100, 220, 100))+ } else {+ (icons::ICON_RADIO_BUTTON_UNCHECKED, Color32::from_rgb(70, 70, 70))+ };+ ui.label(RichText::new(icon).color(color));+}++fn chip_select_str(cs: u8) -> &'static str {+ match cs {+ 0b001 => "slot 0",+ 0b010 => "slot 1",+ 0b100 => "slot 2",+ 0b000 => "none",+ _ => "invalid",+ }+}++fn clock_mhz(clk: u8) -> &'static str {+ match clk {+ 0 => "~1 MHz",+ 1 => "~4 MHz",+ 2 => "~8 MHz",+ 3 => "~16 MHz",+ 4 => "~32 MHz",+ _ => "?",+ }+}++struct ChannelInfo {+ name: &'static str,+ csr_raw: u32,+ exi_int_mask: bool,+ exi_int: bool,+ tc_int_mask: bool,+ tc_int: bool,+ ext_int_mask: bool,+ ext_int: bool,+ device_connected: bool,+ clock: u8,+ chip_select: u8,+ transfer_start: bool,+ dma_mode: bool,+ transfer_type: &'static str,+ transfer_length: u8,+ dma_addr: u32,+ dma_length: u32,+ data_raw: u32,+}++fn channel_info(exi: &Exi, ch: usize) -> ChannelInfo {+ use gekko::exi::regs::TransferType;+ match ch {+ 0 => ChannelInfo {+ name: "CH0",+ csr_raw: exi.ch0_csr.raw(),+ exi_int_mask: exi.ch0_csr.exi_interrupt_mask(),+ exi_int: exi.ch0_csr.exi_interrupt(),+ tc_int_mask: exi.ch0_csr.tc_interrupt_mask(),+ tc_int: exi.ch0_csr.tc_interrupt(),+ ext_int_mask: exi.ch0_csr.ext_interrupt_mask(),+ ext_int: exi.ch0_csr.ext_interrupt(),+ device_connected: exi.ch0_csr.device_connected(),+ clock: exi.ch0_csr.clock(),+ chip_select: exi.ch0_csr.chip_select(),+ transfer_start: exi.ch0_cr.transfer_start(),+ dma_mode: exi.ch0_cr.dma_mode(),+ transfer_type: match exi.ch0_cr.transfer_type() {+ TransferType::Read => "read",+ TransferType::Write => "write",+ TransferType::ReadAndWrite => "read+write",+ TransferType::Reserved => "reserved",+ },+ transfer_length: exi.ch0_cr.transfer_length(),+ dma_addr: exi.ch0_mar.address() << 5,+ dma_length: exi.ch0_length.length() << 5,+ data_raw: exi.ch0_data.raw(),+ },+ 1 => ChannelInfo {+ name: "CH1",+ csr_raw: exi.ch1_csr.raw(),+ exi_int_mask: exi.ch1_csr.exi_interrupt_mask(),+ exi_int: exi.ch1_csr.exi_interrupt(),+ tc_int_mask: exi.ch1_csr.tc_interrupt_mask(),+ tc_int: exi.ch1_csr.tc_interrupt(),+ ext_int_mask: exi.ch1_csr.ext_interrupt_mask(),+ ext_int: exi.ch1_csr.ext_interrupt(),+ device_connected: exi.ch1_csr.device_connected(),+ clock: exi.ch1_csr.clock(),+ chip_select: exi.ch1_csr.chip_select(),+ transfer_start: exi.ch1_cr.transfer_start(),+ dma_mode: exi.ch1_cr.dma_mode(),+ transfer_type: match exi.ch1_cr.transfer_type() {+ TransferType::Read => "read",+ TransferType::Write => "write",+ TransferType::ReadAndWrite => "read+write",+ TransferType::Reserved => "reserved",+ },+ transfer_length: exi.ch1_cr.transfer_length(),+ dma_addr: exi.ch1_mar.address() << 5,+ dma_length: exi.ch1_length.length() << 5,+ data_raw: exi.ch1_data.raw(),+ },+ 2 => ChannelInfo {+ name: "CH2",+ csr_raw: exi.ch2_csr.raw(),+ exi_int_mask: exi.ch2_csr.exi_interrupt_mask(),+ exi_int: exi.ch2_csr.exi_interrupt(),+ tc_int_mask: exi.ch2_csr.tc_interrupt_mask(),+ tc_int: exi.ch2_csr.tc_interrupt(),+ ext_int_mask: exi.ch2_csr.ext_interrupt_mask(),+ ext_int: exi.ch2_csr.ext_interrupt(),+ device_connected: exi.ch2_csr.device_connected(),+ clock: exi.ch2_csr.clock(),+ chip_select: exi.ch2_csr.chip_select(),+ transfer_start: exi.ch2_cr.transfer_start(),+ dma_mode: exi.ch2_cr.dma_mode(),+ transfer_type: match exi.ch2_cr.transfer_type() {+ TransferType::Read => "read",+ TransferType::Write => "write",+ TransferType::ReadAndWrite => "read+write",+ TransferType::Reserved => "reserved",+ },+ transfer_length: exi.ch2_cr.transfer_length(),+ dma_addr: exi.ch2_mar.address() << 5,+ dma_length: exi.ch2_length.length() << 5,+ data_raw: exi.ch2_data.raw(),+ },+ _ => unreachable!(),+ }+}++fn show_channel(ui: &mut egui::Ui, ch: &ChannelInfo) {+ ui.push_id(ch.name, |ui| {+ ui.strong(ch.name);+ ui.separator();++ Grid::new(format!("{}_csr", ch.name))+ .num_columns(4)+ .striped(true)+ .show(ui, |ui| {+ ui.label("CSR");+ ui.monospace(format!("{:#010X}", ch.csr_raw));+ ui.label("");+ ui.label("");+ ui.end_row();++ ui.label("Device");+ flag(ui, ch.device_connected);+ ui.label("Clock");+ ui.monospace(format!("{} ({})", ch.clock, clock_mhz(ch.clock)));+ ui.end_row();++ ui.label("CS");+ ui.monospace(chip_select_str(ch.chip_select));+ ui.label("");+ ui.label("");+ ui.end_row();++ // Interrupt status row+ ui.label("EXIINT");+ ui.horizontal(|ui| {+ flag(ui, ch.exi_int);+ ui.label("Mask");+ flag(ui, ch.exi_int_mask);+ });+ ui.label("TCINT");+ ui.horizontal(|ui| {+ flag(ui, ch.tc_int);+ ui.label("Mask");+ flag(ui, ch.tc_int_mask);+ });+ ui.end_row();++ ui.label("EXTINT");+ ui.horizontal(|ui| {+ flag(ui, ch.ext_int);+ ui.label("Mask");+ flag(ui, ch.ext_int_mask);+ });+ ui.label("");+ ui.label("");+ ui.end_row();+ });++ ui.add_space(4.0);++ Grid::new(format!("{}_cr", ch.name))+ .num_columns(4)+ .striped(true)+ .show(ui, |ui| {+ ui.label("CR");+ ui.label("");+ ui.label("");+ ui.label("");+ ui.end_row();++ ui.label("TSTART");+ flag(ui, ch.transfer_start);+ ui.label("DMA");+ flag(ui, ch.dma_mode);+ ui.end_row();++ ui.label("RW");+ ui.monospace(ch.transfer_type);+ ui.label("TLEN");+ ui.monospace(format!("{} B", ch.transfer_length + 1));+ ui.end_row();+ });++ ui.add_space(4.0);++ Grid::new(format!("{}_dma", ch.name))+ .num_columns(2)+ .striped(true)+ .show(ui, |ui| {+ ui.label("DMA");+ ui.label("");+ ui.end_row();++ ui.label("Addr");+ ui.monospace(format!("{:#010X}", ch.dma_addr));+ ui.end_row();++ ui.label("Length");+ ui.monospace(format!("{} B", ch.dma_length));+ ui.end_row();++ ui.label("Data");+ ui.monospace(format!("{:#010X}", ch.data_raw));+ ui.end_row();+ });+ });+}++pub fn show_exi(ctx: &Context, open: &mut bool, exi: &Exi) {+ egui::Window::new("EXI")+ .open(open)+ .default_size(egui::vec2(600.0, 400.0))+ .show(ctx, |ui| {+ ui.columns(3, |cols| {+ for (i, col) in cols.iter_mut().enumerate() {+ let ch = channel_info(exi, i);+ show_channel(col, &ch);+ }+ });+ });+}diff --git a/crates/debugger/src/windows/irq.rs b/crates/debugger/src/windows/irq.rsnew file mode 100644index 0000000..d64c99e--- /dev/null+++ b/crates/debugger/src/windows/irq.rs@@ -0,0 +1,121 @@+use egui::{Align, Color32, Context, Grid, Layout, RichText};+use egui_material_icons::icons;+use gekko::cpu::Cpu;+use gekko::flipper::pi::Pi;++fn centered_icon(ui: &mut egui::Ui, icon: &str, color: Color32) {+ ui.with_layout(Layout::top_down(Align::Center), |ui| {+ ui.label(RichText::new(icon).color(color));+ });+}++fn interrupt_row(ui: &mut egui::Ui, name: &str, pending: bool, masked: bool) {+ let name_color = if pending && masked {+ Color32::from_rgb(255, 180, 60)+ } else {+ Color32::PLACEHOLDER+ };++ let (pending_icon, pending_color) = if pending {+ (icons::ICON_RADIO_BUTTON_CHECKED, Color32::from_rgb(255, 180, 60))+ } else {+ (icons::ICON_RADIO_BUTTON_UNCHECKED, Color32::from_rgb(70, 70, 70))+ };++ let (mask_icon, mask_color) = if masked {+ (icons::ICON_CHECK_BOX, Color32::from_rgb(100, 180, 255))+ } else {+ (icons::ICON_CHECK_BOX_OUTLINE_BLANK, Color32::from_rgb(70, 70, 70))+ };++ ui.label(RichText::new(name).color(name_color));+ centered_icon(ui, pending_icon, pending_color);+ ui.label(RichText::new(mask_icon).color(mask_color));+ ui.end_row();+}++pub fn show_irq(ctx: &Context, open: &mut bool, cpu: &Cpu, pi: &Pi) {+ egui::Window::new("IRQ")+ .open(open)+ .default_size(egui::vec2(380.0, 480.0))+ .show(ctx, |ui| {+ let msr = &cpu.msr;+ let spr = &cpu.spr;+ let ee = msr.external_interrupt_enable();++ // MSR.EE, SRR0/SRR1+ Grid::new("top_state").num_columns(2).striped(true).show(ui, |ui| {+ ui.label("MSR.EE");+ ui.horizontal(|ui| {+ let (icon, color) = if ee {+ (icons::ICON_CHECK_CIRCLE, Color32::from_rgb(80, 220, 80))+ } else {+ (icons::ICON_CANCEL, Color32::from_rgb(200, 60, 60))+ };+ ui.label(RichText::new(icon).color(color));+ ui.label(if ee {+ "interrupts enabled"+ } else {+ "interrupts disabled"+ });+ });+ ui.end_row();++ ui.label("SRR0");+ ui.monospace(format!("{:#010X}", spr.srr0.raw()));+ ui.end_row();++ ui.label("SRR1");+ ui.monospace(format!("{:#010X}", spr.srr1));+ ui.end_row();+ });++ ui.add_space(8.0);++ // PI Table+ ui.strong("PI Interrupts");+ ui.separator();++ Grid::new("pi_ints")+ .num_columns(3)+ .striped(true)+ .min_col_width(0.0)+ .show(ui, |ui| {+ ui.label(RichText::new("Source").strong());+ ui.label(RichText::new("Pending").strong());+ ui.label(RichText::new("Masked").strong());+ ui.end_row();++ let sr = &pi.intsr;+ let mr = &pi.intmr;++ interrupt_row(ui, "GP Error", sr.gp_runtime_error(), mr.gp_runtime_error());+ interrupt_row(ui, "Reset Switch", sr.reset_switch(), mr.reset_switch());+ interrupt_row(ui, "DVD", sr.dvd(), mr.dvd());+ interrupt_row(ui, "Serial", sr.serial(), mr.serial());+ interrupt_row(ui, "EXI", sr.exi(), mr.exi());+ interrupt_row(ui, "Streaming", sr.streaming(), mr.streaming());+ interrupt_row(ui, "DSP", sr.dsp(), mr.dsp());+ interrupt_row(ui, "Memory", sr.memory(), mr.memory());+ interrupt_row(ui, "Video", sr.video(), mr.video());+ interrupt_row(+ ui,+ "PE Token",+ sr.token_assertion_in_cmd_list(),+ mr.token_assertion_in_cmd_list(),+ );+ interrupt_row(ui, "PE Finish", sr.frame_is_ready(), mr.frame_is_ready());+ interrupt_row(ui, "Cmd FIFO", sr.command_fifo(), mr.command_fifo());+ interrupt_row(ui, "Debug", sr.debug(), mr.debug());+ interrupt_row(ui, "Hi-Speed Port", sr.highspeed_port(), mr.highspeed_port());+ });++ ui.horizontal(|ui| {+ ui.label("INTSR");+ ui.monospace(format!("{:#010X}", pi.intsr.raw()));+ ui.add_space(12.0);+ ui.label("INTMR");+ ui.monospace(format!("{:#010X}", pi.intmr.raw()));+ });+ });+}