emulator.h

Go to the documentation of this file.

#ifndef YAZE_APP_CORE_EMULATOR_H
#define YAZE_APP_CORE_EMULATOR_H
 
#include "imgui/imgui.h"
 
#include <cstdint>
#include <vector>
 
#include "app/emu/snes.h"
#include "app/gui/zeml.h"
#include "app/rom.h"
 
namespace yaze {
namespace app {
 
namespace emu {
 
class Emulator : public SharedRom {
 public:
  Emulator() {
    std::string emulator_layout = R"(
      Table id="Emulator" count="2" flags="Resizable|ScrollY" {
        TableSetupColumn title="CPU",
        TableSetupColumn title="PPU",
 
        TableHeadersRow,
        TableNextColumn,
 
        CollapsingHeader id="cpuState" title="Register Values" flags="DefaultOpen" {
          BeginChild id="##CpuState" size="0,100" flags="NoMove|NoScrollbar" {
            Columns id="registersColumns" count="2" {
              Text text="A: 0x%04X" data="cpu.A",
              Text text="D: 0x%04X" data="cpu.D",
              Text text="X: 0x%04X" data="cpu.X",
              Text text="DB: 0x%02X" data="cpu.DB",
              Text text="Y: 0x%04X" data="cpu.Y",
              Text text="PB: 0x%02X" data="cpu.PB",
              Text text="PC: 0x%04X" data="cpu.PC",
              Text text="PS: 0x%02X" data="cpu.status",
              Text text="SP: 0x%02X" data="cpu.SP",
              Text text="Cycle: %d" data="snes.cycle_count",
            }
          }
        }
        CollapsingHeader id="spcState" title="SPC Registers" flags="DefaultOpen" {
          BeginChild id="##SpcState" size="0,100" flags="NoMove|NoScrollbar" {
            Columns id="spcRegistersColumns" count="2" {
              Text text="A: 0x%02X" data="spc.A",
              Text text="PC: 0x%04X" data="spc.PC",
              Text text="X: 0x%02X" data="spc.X",
              Text text="SP: 0x%02X" data="spc.SP",
              Text text="Y: 0x%02X" data="spc.Y",
              Text text="PSW: 0x%02X" data="spc.PSW",
            }
          }
        }
        Function id="CpuInstructionLog",
 
        TableNextColumn,
        Function id="SnesPpu",
        Function id="BreakpointList"
      }
    )";
    const std::map<std::string, void*> data_bindings = {
        {"cpu.A", &snes_.cpu().A},
        {"cpu.D", &snes_.cpu().D},
        {"cpu.X", &snes_.cpu().X},
        {"cpu.DB", &snes_.cpu().DB},
        {"cpu.Y", &snes_.cpu().Y},
        {"cpu.PB", &snes_.cpu().PB},
        {"cpu.PC", &snes_.cpu().PC},
        {"cpu.status", &snes_.cpu().status},
        {"snes.cycle_count", &snes_.mutable_cycles()},
        {"cpu.SP", &snes_.Memory().mutable_sp()},
        {"spc.A", &snes_.apu().spc700().A},
        {"spc.X", &snes_.apu().spc700().X},
        {"spc.Y", &snes_.apu().spc700().Y},
        {"spc.PC", &snes_.apu().spc700().PC},
        {"spc.SP", &snes_.apu().spc700().SP},
        {"spc.PSW", &snes_.apu().spc700().PSW}};
    emulator_node_ = gui::zeml::Parse(emulator_layout, data_bindings);
    Bind(emulator_node_.GetNode("CpuInstructionLog"),
         [&]() { RenderCpuInstructionLog(snes_.cpu().instruction_log_); });
    Bind(emulator_node_.GetNode("SnesPpu"), [&]() { RenderSnesPpu(); });
    Bind(emulator_node_.GetNode("BreakpointList"),
         [&]() { RenderBreakpointList(); });
  }
  void Run();
 
  auto snes() -> SNES& { return snes_; }
  auto running() const -> bool { return running_; }
  void set_audio_buffer(int16_t* audio_buffer) { audio_buffer_ = audio_buffer; }
  auto set_audio_device_id(SDL_AudioDeviceID audio_device) {
    audio_device_ = audio_device;
  }
  auto wanted_samples() const -> int { return wanted_samples_; }
 
 private:
  void RenderNavBar();
  void HandleEvents();
 
  void RenderSnesPpu();
  void RenderBreakpointList();
  void RenderMemoryViewer();
 
  struct Bookmark {
    std::string name;
    uint64_t value;
  };
  std::vector<Bookmark> bookmarks;
 
  void RenderCpuInstructionLog(
      const std::vector<InstructionEntry>& instructionLog);
 
  bool step_ = true;
  bool power_ = false;
  bool loading_ = false;
  bool running_ = false;
  bool turbo_mode_ = false;
 
  float wanted_frames_;
  int wanted_samples_;
 
  uint8_t manual_pb_ = 0;
  uint16_t manual_pc_ = 0;
 
  // timing
  uint64_t count_frequency;
  uint64_t last_count;
  float time_adder = 0.0;
 
  int16_t* audio_buffer_;
  SDL_AudioDeviceID audio_device_;
 
  SNES snes_;
  SDL_Texture* ppu_texture_;
 
  std::vector<uint8_t> rom_data_;
 
  gui::zeml::Node emulator_node_;
};
 
}  // namespace emu
}  // namespace app
}  // namespace yaze
 
#endif  // YAZE_APP_CORE_EMULATOR_H