UI: Add MemoryInspector

emu/src/arm7tdmi.rs

@@ -1,4 +1,4 @@
-use std::cell::RefCell;
+use std::cell::{Ref, RefCell};
 use std::convert::TryInto;
 use std::rc::Rc;
 
@@ -57,6 +57,7 @@ const OPCODE_ARM_SIZE: usize = 4;
 
 impl Cpu for Arm7tdmi {
     type OpCodeType = ArmModeOpcode;
+    type Memory = InternalMemory;
 
     fn fetch(&self) -> u32 {
         let instruction_index = self.registers.program_counter();
@@ -110,6 +111,10 @@ impl Cpu for Arm7tdmi {
     fn registers(&self) -> Vec<u32> {
         self.registers.to_vec()
     }
+
+    fn get_memory(&self) -> Ref<'_, InternalMemory> {
+        self.memory.borrow()
+    }
 }
 
 impl Arm7tdmi {

emu/src/cpu.rs

@@ -1,6 +1,11 @@
+use std::cell::Ref;
+
+use crate::memory::io_device::IoDevice;
+
 pub trait Cpu {
     /// Size of Opcode: it can be changed
     type OpCodeType;
+    type Memory: IoDevice<Address = u32, Value = u8>;
 
     /// It generally takes the next instruction from PC
     fn fetch(&self) -> u32;
@@ -17,4 +22,6 @@ pub trait Cpu {
 
     /// Get the value of all registers
     fn registers(&self) -> Vec<u32>;
+
+    fn get_memory(&self) -> Ref<'_, Self::Memory>;
 }

ui/src/dashboard.rs

@@ -3,7 +3,10 @@ use emu::{arm7tdmi::Arm7tdmi, cartridge_header::CartridgeHeader, gba::Gba};
 
 use super::about::About;
 use super::cpu_inspector::CpuInspector;
-use crate::{gba_display::GbaDisplay, palette_visualizer::PaletteVisualizer, ui_traits::UiTool};
+use crate::{
+    gba_display::GbaDisplay, memory_inspector::MemoryInspector,
+    palette_visualizer::PaletteVisualizer, ui_traits::UiTool,
+};
 
 use std::{
     collections::BTreeSet,
@@ -40,7 +43,8 @@ impl UiTools {
             Box::new(About::default()),
             Box::new(CpuInspector::new(arc_gba.clone())),
             Box::new(GbaDisplay::new(arc_gba.clone())),
-            Box::new(PaletteVisualizer::new(arc_gba)),
+            Box::new(PaletteVisualizer::new(arc_gba.clone())),
+            Box::new(MemoryInspector::new(arc_gba)),
         ])
     }
 
@@ -51,6 +55,7 @@ impl UiTools {
         open.insert(tools[1].name().to_owned());
         open.insert(tools[2].name().to_owned());
         open.insert(tools[3].name().to_owned());
+        open.insert(tools[4].name().to_owned());
 
         Self { tools, open }
     }

ui/src/lib.rs

@@ -3,5 +3,6 @@ pub mod app;
 pub mod cpu_inspector;
 pub mod dashboard;
 pub mod gba_display;
+pub mod memory_inspector;
 pub mod palette_visualizer;
 pub mod ui_traits;

ui/src/memory_inspector.rs

@@ -0,0 +1,73 @@
+use emu::{cpu::Cpu, gba::Gba, memory::io_device::IoDevice};
+
+use crate::ui_traits::{UiTool, View};
+
+use std::{
+    borrow::Borrow,
+    sync::{Arc, Mutex},
+};
+
+pub struct MemoryInspector<T: Cpu> {
+    address_string: String,
+    value: u8,
+    base: Base,
+    gba: Arc<Mutex<Gba<T>>>,
+}
+
+impl<T: Cpu> MemoryInspector<T> {
+    pub fn new(gba: Arc<Mutex<Gba<T>>>) -> Self {
+        Self {
+            gba,
+            address_string: String::from("0"),
+            value: 0,
+            base: Base::Dec,
+        }
+    }
+}
+
+impl<T: Cpu> UiTool for MemoryInspector<T> {
+    fn name(&self) -> &'static str {
+        "Memory Inspector"
+    }
+
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
+        egui::Window::new(self.name())
+            .default_width(320.0)
+            .open(open)
+            .show(ctx, |ui| {
+                use View as _;
+                self.ui(ui);
+            });
+    }
+}
+
+#[derive(PartialEq)]
+enum Base {
+    Dec,
+    Hex,
+}
+
+impl<T: Cpu> View for MemoryInspector<T> {
+    fn ui(&mut self, ui: &mut egui::Ui) {
+        ui.radio_value(&mut self.base, Base::Dec, "Dec");
+        ui.radio_value(&mut self.base, Base::Hex, "Hex");
+
+        ui.horizontal(|ui| {
+            ui.label("Memory address:");
+            ui.text_edit_singleline(&mut self.address_string);
+            if ui.button("Read").clicked() {
+                if let Ok(gba) = self.gba.lock() {
+                    let radix = match self.base {
+                        Base::Dec => 10,
+                        Base::Hex => 16,
+                    };
+
+                    let address = u32::from_str_radix(&self.address_string, radix).unwrap();
+                    self.value = gba.borrow().cpu.get_memory().borrow().read_at(address);
+                }
+            }
+        });
+
+        ui.label(format!("Value: {}", self.value));
+    }
+}