initial commit

.gitignore

@@ -0,0 +1,5 @@
+.vs/
+.vscode/
+
+out/
+*.json

.gitmodules

@@ -0,0 +1,10 @@
+[submodule "vendor/spdlog"]
+	path = vendor/spdlog
+	url = https://github.com/gabime/spdlog
+[submodule "vendor/glfw"]
+	path = vendor/glfw
+	url = https://github.com/glfw/glfw
+[submodule "vendor/imgui"]
+	path = vendor/imgui
+	url = https://github.com/ocornut/imgui
+	branch = docking

CMakeLists.txt

@@ -0,0 +1,28 @@
+# CMakeList.txt : Top-level CMake project file, do global configuration
+# and include sub-projects here.
+#
+cmake_minimum_required (VERSION 3.8)
+
+project ("NES Emulator")
+
+add_subdirectory("vendor/glfw")
+add_subdirectory("vendor/glad")
+add_subdirectory("vendor/spdlog")
+
+set(IMGUI_SOURCES 
+	${CMAKE_SOURCE_DIR}/vendor/imgui/imgui.cpp
+	${CMAKE_SOURCE_DIR}/vendor/imgui/imgui_demo.cpp
+	${CMAKE_SOURCE_DIR}/vendor/imgui/imgui_draw.cpp
+	${CMAKE_SOURCE_DIR}/vendor/imgui/imgui_tables.cpp
+	${CMAKE_SOURCE_DIR}/vendor/imgui/imgui_widgets.cpp
+	${CMAKE_SOURCE_DIR}/vendor/imgui/backends/imgui_impl_glfw.cpp
+	${CMAKE_SOURCE_DIR}/vendor/imgui/backends/imgui_impl_opengl3.cpp
+)
+
+set(IMGUI_INCLUDE
+	${CMAKE_SOURCE_DIR}/vendor
+	${CMAKE_SOURCE_DIR}/vendor/imgui
+)
+
+# Include sub-projects.
+add_subdirectory ("src")

README.md

@@ -0,0 +1,19 @@
+# NESemu
+
+NESemu is my fourth attempt at writing a working Nintendo NES Emulator.
+
+This time I'm also writing a Debugger that will hopefully help me finish the project this time.
+
+![View of the Debugger](imgs/debug_example.png)
+
+Also I'm writing it in C++ this time because jesus christ i hate C. My previous attempt is [here](https://github.com/Lauchmelder23/NESEmulator).
+
+## Libraries
+* [spdlog](https://github.com/gabime/spdlog) for logging
+* [GLFW](https://github.com/glfw/glfw) for window and event handling
+* [GLAD](https://glad.dav1d.de/) to load OpenGL
+* [ImGui](https://github.com/ocornut/imgui) for the GUI
+
+## Resources
+* [Nesdev Wiki](https://wiki.nesdev.org/w/index.php) - Probably the most exhaustive NES documentation available on the internet
+* [Masswerk](https://www.masswerk.at/6502/6502_instruction_set.html) - Exhaustive list of official and illegal instructions (there are some errors regarding the cycles of illegal opcodes)

src/Application.cpp

@@ -0,0 +1,109 @@
+#include "Application.hpp"
+
+#include <stdexcept>
+#include <glad/glad.h>
+#include <GLFW/glfw3.h>
+
+#include <imgui/backends/imgui_impl_glfw.h>
+#include <imgui/backends/imgui_impl_opengl3.h>
+#include <imgui/imgui.h>
+
+#include "Log.hpp"
+#include "Bus.hpp"
+#include "Debugger.hpp"
+#include "gfx/Window.hpp"
+
+void Application::Launch()
+{
+	glfwInit();
+
+	Application* app = nullptr;
+	try
+	{
+		app = new Application;
+	}
+	catch (const std::runtime_error& err)
+	{
+		LOG_CORE_FATAL(err.what());
+		delete app;
+		glfwTerminate();
+		return;
+	}
+
+	if (app == nullptr)
+	{
+		LOG_CORE_ERROR("Application object is nullptr");
+		glfwTerminate();
+		return;
+	}
+
+	while (app->Update());
+	delete app;
+	glfwTerminate();
+}
+
+Application::Application() :
+	bus(nullptr), window(nullptr)
+{
+	LOG_CORE_INFO("Creating window");
+	try
+	{
+		window = new Window(1280, 720, "NES Emulator");
+	}
+	catch (const std::runtime_error& err)
+	{
+		LOG_CORE_ERROR("Window creation failed");
+		throw err;
+	}
+
+	LOG_CORE_INFO("Loading OpenGL API");
+	if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
+		throw std::runtime_error("Failed to set up OpenGL loader");
+	
+	LOG_CORE_INFO("Setting up ImGui");
+	IMGUI_CHECKVERSION();
+	ImGui::CreateContext();
+	ImGuiIO& io = ImGui::GetIO();
+	io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;
+	io.ConfigFlags |= ImGuiConfigFlags_DockingEnable;
+	io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable;
+
+	ImGui_ImplGlfw_InitForOpenGL(window->GetNativeWindow(), true);
+	ImGui_ImplOpenGL3_Init("#version 460 core");
+
+	ImGui::StyleColorsDark();
+
+	ImGuiStyle& style = ImGui::GetStyle();
+	if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+	{
+		style.WindowRounding = 0.0f;
+		style.Colors[ImGuiCol_WindowBg].w = 1.0f;
+	}
+
+	bus = new Bus;
+	debugger = new Debugger(bus);
+}
+
+Application::~Application()
+{
+	delete debugger;
+
+	if(bus)
+		delete bus;
+
+	delete window;
+}
+
+bool Application::Update()
+{
+	glfwPollEvents();
+
+	if (!debugger->Update())
+		return false;
+
+	window->Begin();
+	debugger->Render();
+	window->End();
+
+	return !window->ShouldClose();
+}

src/Application.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+class Bus;
+class Window;
+class Debugger;
+
+class Application
+{
+public:
+	static void Launch();
+
+private:
+	Application();
+	~Application();
+
+	bool Update();
+
+private:
+	Window* window;
+	Bus* bus;
+	Debugger* debugger;
+};

src/Bus.cpp

@@ -0,0 +1,142 @@
+#include "Bus.hpp"
+#include "Log.hpp"
+
+#include <stdexcept>
+
+Bus::Bus() :
+	cpu(this), ppu(this), cartridge(this)
+{
+	LOG_CORE_INFO("Allocating RAM");
+	RAM = std::vector<Byte>(0x800);
+
+	LOG_CORE_INFO("Allocating VRAM");
+	VRAM = std::vector<Byte>(0x1000);
+
+	LOG_CORE_INFO("Inserting cartridge");
+	cartridge.Load("roms/nestest.nes");
+
+	LOG_CORE_INFO("Powering up CPU");
+	cpu.Powerup();
+
+	LOG_CORE_INFO("Powering up PPU");
+	ppu.Powerup();
+}
+
+void Bus::Reboot()
+{
+	cpu.Powerup();
+	ppu.Powerup();
+}
+
+void Bus::Reset()
+{
+	cpu.Reset();
+	ppu.Reset();
+}
+
+uint8_t Bus::Tick()
+{
+	uint8_t result = cpu.Tick();
+
+	// 3 ppu ticks per cpu tick
+	ppu.Tick();
+	ppu.Tick();
+	ppu.Tick();
+
+	return result;
+}
+
+bool Bus::Instruction()
+{
+	try
+	{
+		while (Tick());
+	}
+	catch (const std::runtime_error& err)
+	{
+		LOG_CORE_FATAL("Fatal Bus error: {0}", err.what());
+		cpu.Halt();
+		return true;
+	}
+
+	return true;
+}
+
+bool Bus::Frame()
+{
+	try
+	{
+		while (!ppu.IsFrameDone())
+			Tick();
+	}
+	catch (const std::runtime_error& err)
+	{
+		LOG_CORE_FATAL("Fatal Bus error: {0}", err.what());
+		cpu.Halt();
+		return true;
+	}
+
+	return true;
+}
+
+Byte Bus::ReadCPU(Word addr)
+{
+	if (0x0000 <= addr && addr < 0x2000)
+	{
+		return RAM[addr & 0x7FF];
+	}
+	else if (0x2000 <= addr && addr < 0x4000)
+	{
+		return ppu.ReadRegister(addr & 0x7);
+	}
+	else if (0x8000 <= addr && addr <= 0xFFFF)
+	{
+		return cartridge.ReadCPU(addr);
+	}
+}
+
+Byte Bus::ReadPPU(Word addr)
+{
+	addr &= 0x3FFF;
+
+	if (0x0000 <= addr && addr < 0x2000)
+	{
+		return cartridge.ReadPPU(addr);
+	}
+	else if(0x2000  <= addr && addr < 0x4000)
+	{
+		return VRAM[addr & 0xFFF];
+	}
+	
+	return 0x00;
+}
+
+void Bus::WriteCPU(Word addr, Byte val)
+{
+	if (0x0000 <= addr && addr < 0x2000)
+	{
+		RAM[addr & 0x7FF] = val;
+	}
+	else if (0x2000 <= addr && addr < 0x4000)
+	{
+		ppu.WriteRegister(addr & 0x7, val);
+	}
+	else if (0x8000 <= addr && addr <= 0xFFFF)
+	{
+		cartridge.WriteCPU(addr, val);
+	}
+}
+
+void Bus::WritePPU(Word addr, Byte val)
+{
+	addr &= 0x3FFF;
+
+	if (0x0000 <= addr && addr < 0x2000)
+	{
+		cartridge.WritePPU(addr, val);
+	}
+	else if (0x2000 <= addr && addr < 0x4000)
+	{
+		VRAM[addr & 0xFFF] = val;
+	}
+}

src/Bus.hpp

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <vector>
+
+#include "Types.hpp"
+#include "CPU.hpp"
+#include "PPU.hpp"
+#include "Cartridge.hpp"
+
+class Bus
+{
+	friend class Debugger;
+	friend class MemoryViewer;
+	friend class NametableViewer;
+
+public:
+	Bus();
+
+	void Reboot();
+	void Reset();
+
+	uint8_t Tick();
+	bool Instruction();
+	bool Frame();
+
+	Byte ReadCPU(Word addr);
+	Byte ReadPPU(Word addr);
+	void WriteCPU(Word addr, Byte val);
+	void WritePPU(Word addr, Byte val);
+
+	inline void NMI() { cpu.NMI(); }
+
+private:
+	std::vector<Byte> RAM, VRAM;
+	CPU cpu;
+	PPU ppu;
+	Cartridge cartridge;
+};

src/CMakeLists.txt

@@ -0,0 +1,33 @@
+add_executable(nesemu
+	"main.cpp"
+	"Application.cpp" 
+	"Bus.cpp"
+	"CPU.cpp"
+	"Cartridge.cpp"
+	"mappers/Mapper000.cpp" 
+	"Log.cpp" 
+	"PPU.cpp" 
+	"gfx/Window.cpp"
+	"debugger/CPUWatcher.cpp"
+ "debugger/Debugger.cpp" "debugger/PPUWatcher.cpp" "debugger/Disassembler.cpp" "debugger/MemoryViewer.cpp" "debugger/NametableViewer.cpp")
+
+target_include_directories(nesemu PRIVATE
+	mappers
+	gfx
+	debugger
+	${IMGUI_INCLUDE}
+)
+
+target_sources(nesemu PRIVATE
+	${IMGUI_SOURCES}
+)
+
+target_link_libraries(nesemu
+	spdlog
+	glfw
+	glad
+)
+
+add_custom_command(TARGET nesemu POST_BUILD
+	COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_SOURCE_DIR}/roms $<TARGET_FILE_DIR:nesemu>/roms
+)

src/CPU.hpp

@@ -0,0 +1,191 @@
+#pragma once
+
+#include <array>
+#include <functional>
+#include <sstream>
+#include <deque>
+#include "Types.hpp"
+
+class Bus;
+
+using Operation = std::function<void(void)>;
+using AddressingMode = std::function<void(void)>;
+
+enum class Addressing
+{
+	ABS,
+	ABX,
+	ABY,
+	ACC,
+	IDX,
+	IDY,
+	IMM,
+	IMP,
+	IND,
+	REL,
+	ZPG,
+	ZPX,
+	ZPY
+};
+
+union StatusFlag
+{
+	struct
+	{
+		Byte Carry : 1;
+		Byte Zero : 1;
+		Byte InterruptDisable : 1;
+		Byte Decimal : 1;
+		Byte Break : 1;
+		Byte NoEffect : 1;
+		Byte Overflow : 1;
+		Byte Negative : 1;
+	} Flag;
+
+	Word Raw;
+};
+
+struct Instruction
+{
+	Operation Operation = nullptr;
+	AddressingMode Mode = nullptr;
+	Addressing AddrType = Addressing::IMP;
+	uint8_t Size = 0;
+	uint8_t Cycles = 0;
+	char Mnemonic[5] = " XXX";
+};
+
+class CPU
+{
+	friend class Debugger;
+	friend class CPUWatcher;
+	friend class Disassembler;
+
+public:
+	CPU(Bus* bus);
+
+	uint8_t Tick();
+	void Powerup();
+	void Reset();
+	inline void Halt() { halted = true; }
+
+	void IRQ();
+	void NMI();
+
+private:
+	void CreateInstructionTable();
+
+	inline void Push(Byte val) { Write(0x0100 | (sp--), val); }
+	inline Byte Pop() { return Read(0x0100 | (++sp)); }
+
+	Byte Read(Word addr);
+	void Write(Word addr, Byte val);
+
+private:
+	Address rawAddress;
+	Address absoluteAddress;
+	Byte relativeAddress;
+	Byte fetchedVal;
+	bool accumulatorAddressing = false;
+	void ABS();
+	void ABX();
+	void ABY();
+	void ACC();
+	void IDX();
+	void IDY();
+	void IMM();
+	void IMP();
+	void IND();
+	void REL();
+	void ZPG();
+	void ZPX();
+	void ZPY();
+
+private:
+	void ADC();
+	void AND();
+	void ASL();
+	void BCC();
+	void BCS();
+	void BEQ();
+	void BIT();
+	void BMI();
+	void BNE();
+	void BPL();
+	void BRK();
+	void BVC();
+	void BVS();
+	void CLC();
+	void CLD();
+	void CLI();
+	void CLV();
+	void CMP();
+	void CPX();
+	void CPY();
+	void DCP();
+	void DEC();
+	void DEX();
+	void DEY();
+	void EOR();
+	void INC();
+	void INX();
+	void INY();
+	void ISC();
+	void JMP();
+	void JSR();
+	void LAX();
+	void LDA();
+	void LDX();
+	void LDY();
+	void LSR();
+	void NOP();
+	void ORA();
+	void PHA();
+	void PHP();
+	void PLA();
+	void PLP();
+	void RLA();
+	void ROL();
+	void ROR();
+	void RRA();
+	void RTI();
+	void RTS();
+	void SAX();
+	void SBC();
+	void SEC();
+	void SED();
+	void SEI();
+	void SLO();
+	void SRE();
+	void STA();
+	void STX();
+	void STY();
+	void TAX();
+	void TAY();
+	void TSX();
+	void TXA();
+	void TXS();
+	void TYA();
+
+private:
+	Byte acc;
+	Byte idx, idy;
+	Address pc;
+	Word sp;
+
+	StatusFlag status;
+
+	Instruction* currentInstruction = nullptr;
+	uint8_t remainingCycles = 0;
+	uint8_t additionalCycles = 0;
+	uint64_t totalCycles = 0;
+	std::deque<Word> pastPCs;
+	bool halted = false;
+#ifndef NDEBUG
+	std::stringstream debugString;
+#endif
+
+private:
+	std::array<Instruction, 256> InstructionTable;
+	Bus* bus;
+};

src/Cartridge.cpp

@@ -0,0 +1,59 @@
+#include "Cartridge.hpp"
+#include "Bus.hpp"
+#include "Log.hpp"
+
+#include <fstream>
+
+#include "Mapper.hpp"
+#include "mappers/Mapper000.hpp"
+
+Cartridge::Cartridge(Bus* bus) :
+	bus(bus)
+{
+}
+
+Cartridge::~Cartridge()
+{
+	delete mapper;
+}
+
+Byte Cartridge::ReadCPU(Word addr)
+{
+	return mapper->ReadCPU(addr);
+}
+
+Byte Cartridge::ReadPPU(Word addr)
+{
+	return mapper->ReadPPU(addr);
+}
+
+void Cartridge::WriteCPU(Word addr, Byte val)
+{
+	mapper->WriteCPU(addr, val);
+}
+
+void Cartridge::WritePPU(Word addr, Byte val)
+{
+	mapper->WritePPU(addr, val);
+}
+
+void Cartridge::Load(std::string path)
+{
+	std::ifstream file(path, std::ios::binary);
+	if (!file)
+		throw std::runtime_error("Failed to open file " + path);
+
+	LOG_CORE_INFO("Extracting header");
+	Header header;
+	file.read((char*)&header, sizeof(Header));
+
+	uint8_t mapperNumber = (header.MapperHi & 0xF0) | (header.MapperLo >> 4);
+	LOG_CORE_INFO("Cartridge requires Mapper {0:d}", mapperNumber);
+	switch (mapperNumber)
+	{
+	case 0:	mapper = new Mapper000(header, file);	break;
+
+	default:
+		throw std::runtime_error("Unsupported mapper ID " + std::to_string(mapperNumber));
+	}
+}

src/Cartridge.hpp

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <string>
+#include <memory>
+
+#include "Types.hpp"
+#include "Mapper.hpp"
+
+class Bus;
+
+struct Header
+{
+	Byte Signature[4];
+	Byte PrgROM;
+	Byte ChrROM;
+	Byte MapperLo;
+	Byte MapperHi;
+	Byte PrgRAM;
+	Byte TV1;
+	Byte TV2;
+	Byte Padding[5];
+};
+
+class Cartridge
+{
+public:
+	Cartridge(Bus* bus);
+	~Cartridge();
+
+	Byte ReadCPU(Word addr);
+	Byte ReadPPU(Word addr);
+	void WriteCPU(Word addr, Byte val);
+	void WritePPU(Word addr, Byte val);
+
+	void Load(std::string path);
+
+	inline Mapper* GetMapper() { return mapper; }
+
+private:
+	Mapper* mapper;
+	Bus* bus;
+};

src/Log.cpp

@@ -0,0 +1,18 @@
+#include "Log.hpp"
+#include "spdlog/sinks/stdout_color_sinks.h"
+
+std::shared_ptr<spdlog::logger> Log::coreLogger;
+std::shared_ptr<spdlog::logger> Log::debugLogger;
+
+void Log::Init()
+{
+	debugLogger = spdlog::stdout_color_mt("DEBUG");
+	debugLogger->set_pattern("%^[%T] %n: %v%$");
+	debugLogger->set_level(spdlog::level::trace);
+
+	coreLogger = spdlog::stdout_color_mt("CORE");
+	coreLogger->set_pattern("%^[%T] %n: %v%$");
+	coreLogger->set_level(spdlog::level::info);
+
+	LOG_CORE_INFO("Logger initialized");
+}

src/Log.hpp

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <spdlog/spdlog.h>
+#include <spdlog/fmt/ostr.h>
+
+#define FORCE_NO_DEBUG_LOG
+
+class Log
+{
+public:
+	static void Init();
+	inline static std::shared_ptr<spdlog::logger> GetCoreLogger() { return coreLogger; }
+	inline static std::shared_ptr<spdlog::logger> GetDebugLogger() { return debugLogger; }
+
+private:
+	static std::shared_ptr<spdlog::logger> coreLogger;
+	static std::shared_ptr<spdlog::logger> debugLogger;
+};
+
+#define LOG_CORE_TRACE(...)      ::Log::GetCoreLogger()->trace(__VA_ARGS__)
+#define LOG_CORE_INFO(...)       ::Log::GetCoreLogger()->info(__VA_ARGS__)
+#define LOG_CORE_WARN(...)       ::Log::GetCoreLogger()->warn(__VA_ARGS__)
+#define LOG_CORE_ERROR(...)      ::Log::GetCoreLogger()->error(__VA_ARGS__)
+#define LOG_CORE_FATAL(...)      ::Log::GetCoreLogger()->critical(__VA_ARGS__)
+
+#define LOG_DEBUG_TRACE(...)     ::Log::GetDebugLogger()->trace(__VA_ARGS__)
+#define LOG_DEBUG_INFO(...)      ::Log::GetDebugLogger()->info(__VA_ARGS__)
+#define LOG_DEBUG_WARN(...)      ::Log::GetDebugLogger()->warn(__VA_ARGS__)
+#define LOG_DEBUG_ERROR(...)     ::Log::GetDebugLogger()->error(__VA_ARGS__)
+#define LOG_DEBUG_FATAL(...)     ::Log::GetDebugLogger()->critical(__VA_ARGS__)

src/Mapper.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <vector>
+#include "Types.hpp"
+
+class Mapper
+{
+	friend class Disassembler;
+
+public:
+	virtual Byte ReadCPU(Word addr) = 0;
+	virtual Byte ReadPPU(Word addr) = 0;
+	virtual void WriteCPU(Word addr, Byte val) = 0;
+	virtual void WritePPU(Word addr, Byte val) = 0;
+
+protected:
+	Mapper() = default;
+
+protected:
+	std::vector<Byte> PRG_ROM;
+	std::vector<Byte> CHR_ROM;
+};

src/PPU.cpp

@@ -0,0 +1,156 @@
+#include "PPU.hpp"
+#include "Log.hpp"
+#include "Bus.hpp"
+
+PPU::PPU(Bus* bus) :
+	bus(bus), ppuctrl{0}, ppustatus{0}
+{
+}
+
+void PPU::Powerup()
+{
+	ppuctrl.Raw		= 0b00000000;
+	ppumask.Raw		= 0b00000000;
+	ppustatus.Raw	= 0b10100000;
+	ppuscroll.x		= 0x00;
+	ppuscroll.y		= 0x00;
+	ppuaddr.Raw		= 0x0000;
+
+	x = 0;
+	y = 0;
+	addressLatch = 0;
+}
+
+void PPU::Reset()
+{
+	ppuctrl.Raw = 0b00000000;
+	ppumask.Raw = 0b00000000;
+	ppuscroll.x = 0x00;
+	ppuscroll.y = 0x00;
+
+	x = 0;
+	y = 0;
+	addressLatch = 1;
+}
+
+void PPU::Tick()
+{
+	if (y == 241 && x == 1)
+	{
+		ppustatus.Flag.VBlankStarted = 1;
+		if (ppuctrl.Flag.VBlankNMI)
+			bus->NMI();
+
+		isFrameDone = true;
+	}
+
+	if (y == 261 && x == 1)
+		ppustatus.Flag.VBlankStarted = 0;
+
+	x++;
+	if (x > 340)
+	{
+		x = 0;
+		y++;
+		if (y > 261)
+			y = 0;
+	}
+}
+
+Byte PPU::ReadRegister(Byte id)
+{
+	Byte returnVal = 0x00;
+
+	switch (id)
+	{
+	case 0:
+		returnVal = ppuctrl.Raw;
+		break;
+
+	case 1:
+		returnVal = ppumask.Raw;
+		break;
+
+	case 2:
+		returnVal =  ppustatus.Raw;
+		ppustatus.Flag.VBlankStarted = 0;
+		addressLatch = 0;
+		break;
+
+	case 5:
+		returnVal = 0x00;
+		break;
+
+	case 6:
+		returnVal = 0x00;
+		break;
+
+	case 7:
+		returnVal = bus->ReadPPU(ppuaddr.Raw);
+		ppuaddr.Raw += (ppuctrl.Flag.VRAMAddrIncrement ? 32 : 1);
+		break;
+	
+	default:
+		LOG_CORE_WARN("Tried to read unimplemented PPU register $20{0:02X}", (Word)id);
+		break;
+	}
+
+	return returnVal;
+}
+
+void PPU::WriteRegister(Byte id, Byte val)
+{
+	switch (id)
+	{
+	case 0:
+		ppuctrl.Raw = val;
+		break;
+
+	case 1:
+		ppumask.Raw = val;
+		break;
+
+	case 2:
+		ppustatus.Raw = val;
+		break;
+
+	case 5:
+		if (addressLatch == 0)
+			ppuscroll.x = val;
+		else
+			ppuscroll.y = val;
+
+		addressLatch = 1 - addressLatch;
+		break;
+
+	case 6:
+		if (addressLatch == 0)
+			ppuaddr.Bytes.hi = val;
+		else
+			ppuaddr.Bytes.lo = val;
+
+		addressLatch = 1 - addressLatch;
+		break;
+
+	case 7:
+		bus->WritePPU(ppuaddr.Raw, val);
+		ppuaddr.Raw += (ppuctrl.Flag.VRAMAddrIncrement ? 32 : 1);
+		break;
+
+	default:
+		LOG_CORE_WARN("Tried to write unimplemented PPU register $20{0:02X}", (Word)id);
+		return;
+	}
+
+	ppustatus.Flag.Unused = val & 0x1F;
+}
+
+Byte PPU::Read(Word addr)
+{
+	return bus->ReadPPU(addr);
+}
+
+void PPU::Write(Word addr, Byte val)
+{
+	bus->WritePPU(addr, val);
+}

src/PPU.hpp

@@ -0,0 +1,90 @@
+#pragma once
+
+#include "Types.hpp"
+
+class Bus;
+
+class PPU
+{
+	friend class PPUWatcher;
+
+public:
+	PPU(Bus* bus);
+
+	void Powerup();
+	void Reset();
+
+	void Tick();
+
+	Byte ReadRegister(Byte id);
+	void WriteRegister(Byte id, Byte val);
+
+	inline bool IsFrameDone() { bool returnVal = isFrameDone; isFrameDone = false; return returnVal; }
+
+private:
+	Byte Read(Word addr);
+	void Write(Word addr, Byte val);
+
+private: // Registers
+
+	union
+	{
+		struct
+		{
+			Byte BaseNametableAddr : 2;
+			Byte VRAMAddrIncrement : 1;
+			Byte SpritePatternTableAddr : 1;
+			Byte BackgrPatternTableAddr : 1;
+			Byte SpriteSize : 1;
+			Byte MasterSlaveSelect : 1;
+			Byte VBlankNMI : 1;
+		} Flag;
+
+		Byte Raw;
+	} ppuctrl;
+
+	union
+	{
+		struct
+		{
+			Byte Greyscale : 1;
+			Byte BackgroundOnLeft : 1;
+			Byte SpriteOnLeft : 1;
+			Byte ShowBackground : 1;
+			Byte ShowSprites : 1;
+			Byte EmphasizeRed : 1;
+			Byte EmphasizeGreen : 1;
+			Byte EmphasizeBlue : 1;
+		} Flag;
+
+		Byte Raw;
+	} ppumask;
+
+	union
+	{
+		struct
+		{
+			Byte Unused : 5;
+			Byte SpriteOverflow : 1;
+			Byte SpriteZeroHit : 1;
+			Byte VBlankStarted : 1;
+		} Flag;
+
+		Byte Raw;
+	} ppustatus;
+
+	struct
+	{
+		Byte x;
+		Byte y;
+	} ppuscroll;
+
+	Address ppuaddr;
+
+	uint16_t x, y;
+	Byte addressLatch = 0;
+
+private:
+	bool isFrameDone = false;
+	Bus* bus;
+};

src/Types.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <cstdint>
+
+using Byte = uint8_t;
+using Word = uint16_t;
+
+union Address
+{
+	struct
+	{
+		Byte lo;
+		Byte hi;
+	} Bytes;
+
+	Word Raw;
+};

src/debugger/CPUWatcher.cpp

@@ -0,0 +1,101 @@
+#include "CPUWatcher.hpp"
+
+#include <iomanip>
+
+#include <imgui/imgui.h>
+#include "../CPU.hpp"
+
+CPUWatcher::CPUWatcher(CPU* cpu) :
+	DebugWindow("CPU Watch"), cpu(cpu)
+{
+}
+
+void CPUWatcher::OnRender()
+{
+	ImGui::SetNextWindowSize(ImVec2(400, 400), ImGuiCond_FirstUseEver);
+	if (!ImGui::Begin(title.c_str(), &isOpen))
+	{
+		ImGui::End();
+		return;
+	}
+
+	ImGui::Text("Registers");
+	if (ImGui::BeginTable("Registers", 6))
+	{
+		ImGui::TableNextColumn();
+		ImGui::Text("A");	
+		ImGui::TableNextColumn();
+		ImGui::Text("X");	
+		ImGui::TableNextColumn();
+		ImGui::Text("Y");	
+		ImGui::TableNextColumn();
+		ImGui::Text("PC");	
+		ImGui::TableNextColumn();
+		ImGui::Text("SP");
+		ImGui::TableNextColumn();
+		ImGui::Text("P");
+		ImGui::TableNextColumn();
+		ImGui::Text("%02X", cpu->acc);	
+		ImGui::TableNextColumn();
+		ImGui::Text("%02X", cpu->idx);	
+		ImGui::TableNextColumn();
+		ImGui::Text("%02X", cpu->idy);
+		ImGui::TableNextColumn();
+		ImGui::Text("%04X", cpu->pc);	
+		ImGui::TableNextColumn();
+		ImGui::Text("%02X", cpu->sp);
+		ImGui::TableNextColumn();
+		ImGui::Text("%02X", cpu->status.Raw);
+	
+		ImGui::EndTable();
+	}
+
+	ImGui::Separator();
+	ImGui::Text("Status Flag Breakdown");
+	if (ImGui::BeginTable("Status", 8))
+	{
+		ImGui::TableNextColumn();
+		ImGui::Text("N");
+		ImGui::TableNextColumn();
+		ImGui::Text("V");
+		ImGui::TableNextColumn();
+		ImGui::Text("U");
+		ImGui::TableNextColumn();
+		ImGui::Text("B");
+		ImGui::TableNextColumn();
+		ImGui::Text("D");
+		ImGui::TableNextColumn();
+		ImGui::Text("I");
+		ImGui::TableNextColumn();
+		ImGui::Text("Z");
+		ImGui::TableNextColumn();
+		ImGui::Text("C");
+
+
+		ImGui::TableNextColumn();
+		ImGui::Text(cpu->status.Flag.Negative ? "1" : "-");
+		ImGui::TableNextColumn();
+		ImGui::Text(cpu->status.Flag.Overflow ? "1" : "-");
+		ImGui::TableNextColumn();
+		ImGui::Text(cpu->status.Flag.NoEffect ? "1" : "-");
+		ImGui::TableNextColumn();
+		ImGui::Text(cpu->status.Flag.Break ? "1" : "-");
+		ImGui::TableNextColumn();
+		ImGui::Text(cpu->status.Flag.Decimal ? "1" : "-");
+		ImGui::TableNextColumn();
+		ImGui::Text(cpu->status.Flag.InterruptDisable ? "1" : "-");
+		ImGui::TableNextColumn();
+		ImGui::Text(cpu->status.Flag.Zero ? "1" : "-");
+		ImGui::TableNextColumn();
+		ImGui::Text(cpu->status.Flag.Carry ? "1" : "-");
+		ImGui::TableNextColumn();
+
+		ImGui::EndTable();
+	}
+
+	ImGui::Separator();
+
+	ImGui::Text("Halted: %s", cpu->halted ? "Yes" : "No");
+
+	ImGui::End();
+}

src/debugger/CPUWatcher.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "DebugWindow.hpp"
+
+class CPU;
+
+class CPUWatcher :
+	public DebugWindow
+{
+public:
+	CPUWatcher(CPU* cpu);
+
+	virtual void OnRender() override;
+
+private:
+	CPU* cpu;
+};

src/debugger/DebugWindow.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <string>
+
+class DebugWindow
+{
+public:
+	DebugWindow(const std::string& title) :
+		title(title)
+	{
+	}
+
+	virtual ~DebugWindow() = default;
+	virtual void OnRender() = 0;
+
+public:
+	const std::string title;
+	bool isOpen = false;
+};

src/debugger/Debugger.cpp

@@ -0,0 +1,127 @@
+#include "Debugger.hpp"
+
+#include <imgui/imgui.h>
+#include <imgui/imgui_internal.h>
+
+#include "../Bus.hpp"
+#include "CPUWatcher.hpp"
+#include "PPUWatcher.hpp"
+#include "Disassembler.hpp"
+#include "MemoryViewer.hpp"
+#include "NametableViewer.hpp"
+
+Debugger::Debugger(Bus* bus) :
+	bus(bus)
+{
+	windows.push_back(new CPUWatcher(&bus->cpu));
+	windows.push_back(new PPUWatcher(&bus->ppu));
+	windows.push_back(new Disassembler(&bus->cpu));
+	windows.push_back(new MemoryViewer(bus));
+	windows.push_back(new NametableViewer(bus));
+}
+
+Debugger::~Debugger()
+{
+	for (DebugWindow* window : windows)
+		delete window;
+}
+
+bool Debugger::Update()
+{
+	if (running)
+		return bus->Frame();
+
+	return true;
+}
+
+void Debugger::Render()
+{
+	ImGui::SetNextWindowSize(ImVec2(400, 600), ImGuiCond_FirstUseEver);
+	if (!ImGui::Begin("Debugger", (bool*)0, ImGuiWindowFlags_MenuBar))
+	{
+		ImGui::End();
+		return;
+	}
+
+	if (ImGui::BeginMenuBar())
+	{
+		if (ImGui::BeginMenu("Tools"))
+		{
+			for (DebugWindow* window : windows)
+			{
+				ImGui::MenuItem(window->title.c_str(), NULL, &window->isOpen);
+			}
+
+			ImGui::EndMenu();
+		}
+
+		ImGui::EndMenuBar();
+	}
+
+	ImGui::Separator();
+
+	if (ImGui::CollapsingHeader("Controls", ImGuiTreeNodeFlags_DefaultOpen))
+	{
+		ImGui::PushItemFlag(ImGuiItemFlags_Disabled, running);
+		if (running)
+			ImGui::PushStyleColor(ImGuiCol_Button, ImVec4{ 0.7f, 0.7f, 0.7f, 0.7f });
+
+		if (ImGui::Button("Single Step"))
+			bus->Instruction();
+
+		ImGui::SameLine();
+
+		if (ImGui::Button("Single Frame"))
+			bus->Frame();
+
+		if (running)
+			ImGui::PopStyleColor();
+		ImGui::PopItemFlag();
+
+		ImGui::SameLine();
+
+		if (ImGui::Button(running ? "Pause" : "Run"))
+			running = !running;
+
+		ImGui::PushItemFlag(ImGuiItemFlags_Disabled, running);
+		if (running)
+			ImGui::PushStyleColor(ImGuiCol_Button, ImVec4{ 0.7f, 0.7f, 0.7f, 0.7f });
+
+		if (ImGui::Button("Reset"))
+		{
+			bus->Reset();
+			if (overrideResetVector)
+				bus->cpu.pc.Raw = resetVector;
+		}
+
+		ImGui::SameLine();
+
+		if (ImGui::Button("Reboot"))
+		{
+			bus->Reboot();
+			if (overrideResetVector)
+				bus->cpu.pc.Raw = resetVector;
+		}
+
+		if (running)
+			ImGui::PopStyleColor();
+		ImGui::PopItemFlag();
+
+
+		ImGui::Separator();
+
+		ImGui::Text("Override Reset Vector: ");
+		ImGui::SameLine();
+		if (ImGui::Button(overrideResetVector ? "Yes" : "No"))
+			overrideResetVector = !overrideResetVector;
+
+		ImGui::InputScalar("Reset Vector", ImGuiDataType_U16, &resetVector, (const void*)0, (const void*)0, "%04X", ImGuiInputTextFlags_CharsHexadecimal);
+	}
+
+	for (DebugWindow* window : windows)
+	{
+		if (window->isOpen) window->OnRender();
+	}
+
+	ImGui::End();
+}

src/debugger/Debugger.hpp

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <vector>
+#include "DebugWindow.hpp"
+
+class Bus;
+
+class Debugger
+{
+public:
+	Debugger(Bus* bus);
+	~Debugger();
+
+	bool Update();
+	void Render();
+
+public:
+	bool isOpen = true;
+
+private:
+	Bus* bus;
+	bool running = false;
+	bool overrideResetVector = false;
+	uint16_t resetVector = 0x0000;
+
+	std::vector<DebugWindow*> windows;
+};

src/debugger/Disassembler.cpp

@@ -0,0 +1,177 @@
+#include "Disassembler.hpp"
+
+#include <iomanip>
+#include <imgui/imgui.h>
+#include "../Mapper.hpp"
+#include "../CPU.hpp"
+
+#define FORMAT std::setfill('0') << std::setw(4) << std::hex << std::uppercase
+
+Disassembler::Disassembler(CPU* cpu) :
+	DebugWindow("Disassembler"), cpu(cpu)
+{
+	
+}
+
+void Disassembler::OnRender()
+{
+	static bool scrollCenter = true;
+
+	ImGui::SetNextWindowSize(ImVec2(400, 400), ImGuiCond_FirstUseEver);
+
+	if (!ImGui::Begin(title.c_str(), &isOpen))
+	{
+		ImGui::End();
+		return;
+	}
+
+	std::string disassembly;
+
+	ImGui::PushStyleColor(ImGuiCol_Text, ImVec4{ 0.8f, 0.8f, 0.8f, 1.0f });
+	if (cpu->pastPCs.size() < 50)
+	{
+		for (int i = 0; i < 50 - cpu->pastPCs.size(); i++)
+		{
+			ImGui::Text("-");
+		}
+	}
+
+	for (Word pc : cpu->pastPCs)
+	{
+		Disassemble(disassembly, pc);
+		ImGui::Text("- %s", disassembly.c_str());
+	}
+	ImGui::PopStyleColor();
+
+	ImGui::Separator();
+
+	uint16_t pc = cpu->pc.Raw;
+	Disassemble(disassembly, pc);
+	ImGui::Text("> %s", disassembly.c_str());
+
+	if (scrollCenter)
+	{
+		ImGui::SetScrollHereY(0.5f);
+		scrollCenter = false;
+	}
+
+	ImGui::Separator();
+
+	ImGui::PushStyleColor(ImGuiCol_Text, ImVec4{ 0.8f, 0.8f, 0.8f, 1.0f });
+	for (int i = 0; i < 50; i++)
+	{
+		Disassemble(disassembly, pc);
+		ImGui::Text("+ %s", disassembly.c_str());
+	}
+	ImGui::PopStyleColor();
+
+	ImGui::End();
+}
+
+void Disassembler::Disassemble(std::string& target, uint16_t& pc)
+{
+	std::stringstream ss;
+	ss <<  FORMAT << pc << ": ";
+	Instruction* currentInstr = &cpu->InstructionTable[cpu->Read(pc)];
+
+	for (int i = 0; i < currentInstr->Size; i++)
+	{
+		ss << FORMAT << std::setw(2) << (Word)cpu->Read(pc + i) << " ";
+	}
+	ss << std::string(15 - ss.str().size(), ' ') << currentInstr->Mnemonic << " ";
+
+	Address absoluteAddress;
+	switch (currentInstr->AddrType)
+	{
+	case Addressing::ACC:
+		ss << "A";
+		break;
+
+	case Addressing::ABS:
+	{
+		absoluteAddress.Bytes.lo = cpu->Read(pc + 1);
+		absoluteAddress.Bytes.hi = cpu->Read(pc + 2);
+
+		ss << "$" << FORMAT << absoluteAddress.Raw;
+	} break;
+
+	case Addressing::ABX:
+	{
+		absoluteAddress.Bytes.lo = cpu->Read(pc + 1);
+		absoluteAddress.Bytes.hi = cpu->Read(pc + 2);
+
+		ss << "$" << FORMAT << absoluteAddress.Raw << ",X";
+	} break;
+
+	case Addressing::ABY:
+	{
+		absoluteAddress.Bytes.lo = cpu->Read(pc + 1);
+		absoluteAddress.Bytes.hi = cpu->Read(pc + 2);
+
+		ss << "$" << FORMAT << absoluteAddress.Raw << ",Y";
+	} break;
+
+	case Addressing::IMM:
+	{
+		Word value = cpu->Read(pc + 1);
+
+		ss << "#$" << FORMAT << std::setw(2) << value;
+	} break;
+
+	case Addressing::IMP: 
+		break;
+
+	case Addressing::IND:
+	{
+		absoluteAddress.Bytes.lo = cpu->Read(pc + 1);
+		absoluteAddress.Bytes.hi = cpu->Read(pc + 2);
+
+		ss << "($" << FORMAT << absoluteAddress.Raw << ")";
+	} break;
+
+	case Addressing::IDX:
+	{
+		absoluteAddress.Bytes.lo = cpu->Read(pc + 1);
+
+		ss << "($" << FORMAT << std::setw(2) << (Word)absoluteAddress.Bytes.lo << ",X)";
+	} break;
+
+	case Addressing::IDY:
+	{
+		absoluteAddress.Bytes.lo = cpu->Read(pc + 1);
+
+		ss << "($" << FORMAT << std::setw(2) << (Word)absoluteAddress.Bytes.lo << "),Y";
+	} break;
+
+	case Addressing::REL:
+	{
+		absoluteAddress.Bytes.lo = cpu->Read(pc + 1);
+
+		ss << "$" << FORMAT << std::setw(2) << (Word)absoluteAddress.Bytes.lo;
+	} break;
+
+	case Addressing::ZPG:
+	{
+		absoluteAddress.Bytes.lo = cpu->Read(pc + 1);
+
+		ss << "$" << FORMAT << std::setw(2) << (Word)absoluteAddress.Bytes.lo;
+	} break;
+
+	case Addressing::ZPX:
+	{
+		absoluteAddress.Bytes.lo = cpu->Read(pc + 1);
+
+		ss << "$" << FORMAT << std::setw(2) << (Word)absoluteAddress.Bytes.lo << ",X";
+	} break;
+
+	case Addressing::ZPY:
+	{
+		absoluteAddress.Bytes.lo = cpu->Read(pc + 1);
+
+		ss << "$" << FORMAT << std::setw(2) << (Word)absoluteAddress.Bytes.lo << ",Y";
+	} break;
+	}
+
+	pc += currentInstr->Size;
+	target = ss.str();
+}

src/debugger/Disassembler.hpp

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "DebugWindow.hpp"
+
+class CPU;
+
+class Disassembler :
+	public DebugWindow
+{
+public:
+	Disassembler(CPU* cpu);
+	
+	virtual void OnRender() override;
+
+private:
+	void Disassemble(std::string& target, uint16_t& pc);
+
+private:
+	CPU* cpu;
+};

src/debugger/MemoryViewer.cpp

@@ -0,0 +1,78 @@
+#include "MemoryViewer.hpp"
+
+#include <imgui/imgui.h>
+#include "../Bus.hpp"
+
+MemoryViewer::MemoryViewer(Bus* bus) :
+	DebugWindow("Memory Viewer"), bus(bus)
+{
+}
+
+void MemoryViewer::OnRender()
+{
+	ImGui::SetNextWindowSize(ImVec2(400, 400), ImGuiCond_FirstUseEver);
+
+	if (!ImGui::Begin(title.c_str(), &isOpen))
+	{
+		ImGui::End();
+		return;
+	}
+
+	ImGui::BeginTabBar("Pages");
+
+	for (Byte page = 0; page < 8; page++)
+	{
+		char title[7];
+		std::sprintf(title, "Page %d", page);
+		if (ImGui::BeginTabItem(title))
+		{
+			DrawPage(page);
+			ImGui::EndTabItem();
+		}
+	}
+
+	ImGui::EndTabBar();
+	ImGui::End();
+}
+
+void MemoryViewer::DrawPage(Byte page)
+{
+	Word baseAddr = ((Word)page << 8);
+	if (ImGui::BeginTable("memorymap", 17))
+	{
+		ImGui::TableNextColumn();
+		ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(0.7f, 0.7f, 0.7f, 1.0f));
+		for (Byte header = 0x0; header < 0x10; header++)
+		{
+			ImGui::TableNextColumn();
+			ImGui::Text("%X", header);
+		}
+		ImGui::PopStyleColor();
+
+		for (Byte hi = 0x0; hi <= 0xF; hi++)
+		{
+			Byte hiOffset = hi << 4;
+			ImGui::TableNextColumn();
+
+			ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(0.7f, 0.7f, 0.7f, 1.0f));
+			ImGui::Text("%04X", baseAddr | hiOffset);
+			ImGui::PopStyleColor();
+
+			for (Byte lo = 0x0; lo <= 0xF; lo++)
+			{
+				ImGui::TableNextColumn();
+
+				Byte entry = bus->RAM[baseAddr | hiOffset | lo];
+
+				if (entry == 0x00)
+					ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(0.7f, 0.7f, 0.7f, 1.0f));
+
+				ImGui::Text("%02X", entry);
+
+				if (entry == 0x00)
+					ImGui::PopStyleColor();
+			}
+		}
+		ImGui::EndTable();
+	}
+}

src/debugger/MemoryViewer.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "DebugWindow.hpp"
+#include "../Types.hpp"
+
+class Bus;
+
+class MemoryViewer :
+	public DebugWindow
+{
+public:
+	MemoryViewer(Bus* bus);
+
+	virtual void OnRender() override;
+
+private:
+	void DrawPage(Byte page);
+
+private:
+	Bus* bus;
+};

src/debugger/NametableViewer.cpp

@@ -0,0 +1,78 @@
+#include "NametableViewer.hpp"
+
+#include <imgui/imgui.h>
+#include "../Bus.hpp"
+
+NametableViewer::NametableViewer(Bus* bus) :
+	DebugWindow("Nametable Viewer"), bus(bus)
+{
+}
+
+void NametableViewer::OnRender()
+{
+	ImGui::SetNextWindowSize(ImVec2(400, 400), ImGuiCond_FirstUseEver);
+	if (!ImGui::Begin(title.c_str(), &isOpen))
+	{
+		ImGui::End();
+		return;
+	}
+
+	ImGui::BeginTabBar("Nametables");
+	for (uint8_t index = 0; index < 4; index++)
+	{
+		char baseAddress[6];
+		std::sprintf(baseAddress, "$2%X00", index * 4);
+		if (ImGui::BeginTabItem(baseAddress))
+		{
+			DisplayNametable(index);
+			ImGui::EndTabItem();
+		}
+
+	}
+	ImGui::EndTabBar();
+
+	ImGui::End();
+}
+
+void NametableViewer::DisplayNametable(uint8_t index)
+{
+	Word baseAddr = 0x400 * index;
+	Word displayBaseAddr = 0x2000 + baseAddr;
+	if (ImGui::BeginTable("memorymap", 17))
+	{
+		ImGui::TableNextColumn();
+		ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(0.7f, 0.7f, 0.7f, 1.0f));
+		for (Byte header = 0x0; header < 0x10; header++)
+		{
+			ImGui::TableNextColumn();
+			ImGui::Text("%X", header);
+		}
+		ImGui::PopStyleColor();
+
+		for (Word hi = 0x0; hi <= 0x3F; hi++)
+		{
+			Byte hiOffset = hi << 4;
+			ImGui::TableNextColumn();
+
+			ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(0.7f, 0.7f, 0.7f, 1.0f));
+			ImGui::Text("%04X", displayBaseAddr | hiOffset);
+			ImGui::PopStyleColor();
+
+			for (Byte lo = 0x0; lo <= 0xF; lo++)
+			{
+				ImGui::TableNextColumn();
+
+				Byte entry = bus->VRAM[baseAddr | hiOffset | lo];
+
+				if (entry == 0x00)
+					ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(0.7f, 0.7f, 0.7f, 1.0f));
+
+				ImGui::Text("%02X", entry);
+
+				if (entry == 0x00)
+					ImGui::PopStyleColor();
+			}
+		}
+		ImGui::EndTable();
+	}
+}

src/debugger/NametableViewer.hpp

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "DebugWindow.hpp"
+
+class Bus;
+
+class NametableViewer :
+	public DebugWindow
+{
+public:
+	NametableViewer(Bus* bus);
+
+	virtual void OnRender() override;
+	
+private:
+	void DisplayNametable(uint8_t index);
+
+private:
+	Bus* bus;
+};

src/debugger/PPUWatcher.cpp

@@ -0,0 +1,152 @@
+#include "PPUWatcher.hpp"
+
+#include <imgui/imgui.h>
+#include "../PPU.hpp"
+
+PPUWatcher::PPUWatcher(PPU* ppu) :
+	DebugWindow("PPU Watch"), ppu(ppu)
+{
+}
+
+void PPUWatcher::OnRender()
+{
+	ImGui::SetNextWindowSize(ImVec2(400, 400), ImGuiCond_FirstUseEver);
+	if (!ImGui::Begin(title.c_str(), &isOpen))
+	{
+		ImGui::End();
+		return;
+	}
+
+	ImGui::Text("On Pixel (%d, %d)", ppu->x, ppu->y);
+
+	ImGui::Separator();
+
+	if (ImGui::CollapsingHeader("PPUCTRL"))
+	{
+		if (ImGui::BeginTable("ppuctrl", 2))
+		{
+			ImGui::TableNextColumn();
+			ImGui::Text("Base Nametable Addr");
+			ImGui::TableNextColumn();
+			ImGui::Text("$%04X", 0x2000 + 0x400 * ppu->ppuctrl.Flag.BaseNametableAddr);
+
+			ImGui::TableNextColumn();
+			ImGui::Text("VRAM Addr Increment");
+			ImGui::TableNextColumn();
+			ImGui::Text("%d", ppu->ppuctrl.Flag.VRAMAddrIncrement ? 32 : 1);
+
+			ImGui::TableNextColumn();
+			ImGui::Text("Sprite Pattern Table Addr");
+			ImGui::TableNextColumn();
+			ImGui::Text("$%04X", ppu->ppuctrl.Flag.SpritePatternTableAddr ? 0x1000 : 0x0000);
+
+			ImGui::TableNextColumn();
+			ImGui::Text("Backgr Pattern Table Addr");
+			ImGui::TableNextColumn();
+			ImGui::Text("$%04X", ppu->ppuctrl.Flag.BackgrPatternTableAddr ? 0x1000 : 0x0000);
+
+			ImGui::TableNextColumn();
+			ImGui::Text("Master/Slave");
+			ImGui::TableNextColumn();
+			ImGui::Text(ppu->ppuctrl.Flag.MasterSlaveSelect ? "Output to EXT" : "Read from EXT");
+
+			ImGui::TableNextColumn();
+			ImGui::Text("VBlank NMI Generation");
+			ImGui::TableNextColumn();
+			ImGui::Text(ppu->ppuctrl.Flag.VBlankNMI ? "On" : "Off");
+
+			ImGui::EndTable();
+		}
+	}
+
+	if (ImGui::CollapsingHeader("PPUMASK"))
+	{
+		if (ImGui::BeginTable("ppumask", 2))
+		{
+			ImGui::TableNextColumn();
+			ImGui::Text("Greyscale");
+			ImGui::TableNextColumn();
+			ImGui::Text(ppu->ppumask.Flag.Greyscale ? "On" : "Off");
+
+			ImGui::TableNextColumn();
+			ImGui::Text("Left Col Background");
+			ImGui::TableNextColumn();
+			ImGui::Text(ppu->ppumask.Flag.BackgroundOnLeft ? "Show" : "Hide");
+
+			ImGui::TableNextColumn();
+			ImGui::Text("Left Col Sprites");
+			ImGui::TableNextColumn();
+			ImGui::Text(ppu->ppumask.Flag.SpriteOnLeft ? "Show" : "Hide");
+
+			ImGui::TableNextColumn();
+			ImGui::Text("Show Background");
+			ImGui::TableNextColumn();
+			ImGui::Text(ppu->ppumask.Flag.ShowBackground ? "On" : "Off");
+
+			ImGui::TableNextColumn();
+			ImGui::Text("Show Sprites");
+			ImGui::TableNextColumn();
+			ImGui::Text(ppu->ppumask.Flag.ShowSprites ? "On" : "Off");
+
+			ImGui::TableNextColumn();
+			ImGui::Text("Emphasized Colors");
+			ImGui::TableNextColumn();
+			ImGui::Text("%s%s%s", ppu->ppumask.Flag.EmphasizeRed ? "R" : "-", ppu->ppumask.Flag.EmphasizeGreen ? "G" : "-", ppu->ppumask.Flag.EmphasizeBlue ? "B" : "-");
+
+			ImGui::EndTable();
+		}
+	}
+
+	if (ImGui::CollapsingHeader("PPUSTATUS"))
+	{
+		if (ImGui::BeginTable("ppustatus", 2))
+		{
+			ImGui::TableNextColumn();
+			ImGui::Text("Lower 5 Bits");
+			ImGui::TableNextColumn();
+			ImGui::Text("%02X", ppu->ppustatus.Flag.Unused);
+
+			ImGui::TableNextColumn();
+			ImGui::Text("Sprite Overflow");
+			ImGui::TableNextColumn();
+			ImGui::Text(ppu->ppustatus.Flag.SpriteOverflow ? "Yes" : "No");
+
+			ImGui::TableNextColumn();
+			ImGui::Text("Sprite 0 Hit");
+			ImGui::TableNextColumn();
+			ImGui::Text(ppu->ppustatus.Flag.SpriteZeroHit ? "Yes" : "No");
+
+			ImGui::TableNextColumn();
+			ImGui::Text("VBlank Started");
+			ImGui::TableNextColumn();
+			ImGui::Text(ppu->ppustatus.Flag.VBlankStarted ? "Yes" : "No");
+
+			ImGui::EndTable();
+		}
+	}
+
+	if (ImGui::CollapsingHeader("PPUSCROLL & PPUADDR"))
+	{
+		if (ImGui::BeginTable("ppuscrolladdr", 2))
+		{
+			ImGui::TableNextColumn();
+			ImGui::Text("Scroll X");
+			ImGui::TableNextColumn();
+			ImGui::Text("%d", ppu->ppuscroll.x);
+
+			ImGui::TableNextColumn();
+			ImGui::Text("Scroll Y");
+			ImGui::TableNextColumn();
+			ImGui::Text("%d", ppu->ppuscroll.x);
+
+			ImGui::TableNextColumn();
+			ImGui::Text("Address");
+			ImGui::TableNextColumn();
+			ImGui::Text("$%04X", ppu->ppuaddr.Raw);
+
+			ImGui::EndTable();
+		}
+	}
+
+	ImGui::End();
+}

src/debugger/PPUWatcher.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "DebugWindow.hpp"
+
+class PPU;
+
+class PPUWatcher :
+	public DebugWindow
+{
+public:
+	PPUWatcher(PPU* ppu);
+
+	virtual void OnRender() override;
+
+private:
+	PPU* ppu;
+};

src/gfx/Window.cpp

@@ -0,0 +1,52 @@
+#include "Window.hpp"
+
+#include <stdexcept>
+#include <imgui/backends/imgui_impl_glfw.h>
+#include <imgui/backends/imgui_impl_opengl3.h>
+#include <imgui/imgui.h>
+
+Window::Window(uint16_t width, uint16_t height, const std::string& title) :
+	handle(nullptr)
+{
+	handle = glfwCreateWindow(width, height, title.c_str(), nullptr, nullptr);
+	if (handle == nullptr)
+	{
+		const char* err;
+		int code = glfwGetError(&err);
+		throw std::runtime_error(std::string(err) + " (" + std::to_string(code) + ")");
+	}
+
+	glfwMakeContextCurrent(handle);
+}
+
+Window::~Window()
+{
+	if(handle)
+		glfwDestroyWindow(handle);
+}
+
+void Window::Begin()
+{
+	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
+	glClear(GL_COLOR_BUFFER_BIT);
+
+	ImGui_ImplOpenGL3_NewFrame();
+	ImGui_ImplGlfw_NewFrame();
+	ImGui::NewFrame();
+}
+
+void Window::End()
+{
+	ImGui::Render();
+	ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
+
+	if (ImGui::GetIO().ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+	{
+		GLFWwindow* backup_current_context = glfwGetCurrentContext();
+		ImGui::UpdatePlatformWindows();
+		ImGui::RenderPlatformWindowsDefault();
+		glfwMakeContextCurrent(backup_current_context);
+	}
+
+	glfwSwapBuffers(handle);
+}

src/gfx/Window.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <cstdint>
+#include <string>
+
+#include <glad/glad.h>
+#include <glfw/glfw3.h>
+
+class Window
+{
+public:
+	Window(uint16_t width, uint16_t height, const std::string& title);
+	~Window();
+
+	inline bool ShouldClose() { return glfwWindowShouldClose(handle); }
+	inline GLFWwindow* GetNativeWindow() { return handle; }
+	
+	void Begin();
+	void End();
+
+private:
+	GLFWwindow* handle;
+};

src/main.cpp

@@ -0,0 +1,10 @@
+#include "Application.hpp"
+#include "Log.hpp"
+
+int main(int argc, char** argv)
+{
+	Log::Init();
+	Application::Launch();
+
+	return 0;
+}

src/mappers/Mapper000.cpp

@@ -0,0 +1,40 @@
+#include "Mapper000.hpp"
+#include "../Log.hpp"
+
+#include <fstream>
+#include "../Cartridge.hpp"
+
+Mapper000::Mapper000(Header& header, std::ifstream& ifs)
+{
+	LOG_CORE_INFO("Allocating PRG ROM");
+	PRG_ROM = std::vector<Byte>(0x4000);
+	ifs.read((char*)PRG_ROM.data(), 0x4000);
+
+	LOG_CORE_INFO("Allocating CHR ROM");
+	CHR_ROM = std::vector<Byte>(0x2000);
+	ifs.read((char*)CHR_ROM.data(), 0x2000);
+}
+
+Byte Mapper000::ReadCPU(Word addr)
+{
+	if (0x8000 <= addr && addr <= 0xFFFF)
+	{
+		return PRG_ROM[addr & 0x03FFF];
+	}
+}
+
+Byte Mapper000::ReadPPU(Word addr)
+{
+	if (0x0000 <= addr && addr <= 0x1FFF)
+	{
+		return CHR_ROM[addr];
+	}
+}
+
+void Mapper000::WriteCPU(Word addr, Byte val)
+{
+}
+
+void Mapper000::WritePPU(Word addr, Byte val)
+{
+}

src/mappers/Mapper000.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <vector>
+#include <fstream>
+#include "../Mapper.hpp"
+
+struct Header;
+
+class Mapper000 :
+	public Mapper
+{
+public:
+	Mapper000(Header& header, std::ifstream& ifs);
+
+	virtual Byte ReadCPU(Word addr) override;
+	virtual Byte ReadPPU(Word addr) override;
+	virtual void WriteCPU(Word addr, Byte val) override;
+	virtual void WritePPU(Word addr, Byte val) override;
+};

vendor/glad/CMakeLists.txt

@@ -0,0 +1,9 @@
+project(glad)
+
+add_library(glad STATIC 
+	"src/glad.c"
+)
+
+target_include_directories(glad PUBLIC
+	"include"
+)

vendor/glad/include/KHR/khrplatform.h

@@ -0,0 +1,311 @@
+#ifndef __khrplatform_h_
+#define __khrplatform_h_
+
+/*
+** Copyright (c) 2008-2018 The Khronos Group Inc.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a
+** copy of this software and/or associated documentation files (the
+** "Materials"), to deal in the Materials without restriction, including
+** without limitation the rights to use, copy, modify, merge, publish,
+** distribute, sublicense, and/or sell copies of the Materials, and to
+** permit persons to whom the Materials are furnished to do so, subject to
+** the following conditions:
+**
+** The above copyright notice and this permission notice shall be included
+** in all copies or substantial portions of the Materials.
+**
+** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+*/
+
+/* Khronos platform-specific types and definitions.
+ *
+ * The master copy of khrplatform.h is maintained in the Khronos EGL
+ * Registry repository at https://github.com/KhronosGroup/EGL-Registry
+ * The last semantic modification to khrplatform.h was at commit ID:
+ *      67a3e0864c2d75ea5287b9f3d2eb74a745936692
+ *
+ * Adopters may modify this file to suit their platform. Adopters are
+ * encouraged to submit platform specific modifications to the Khronos
+ * group so that they can be included in future versions of this file.
+ * Please submit changes by filing pull requests or issues on
+ * the EGL Registry repository linked above.
+ *
+ *
+ * See the Implementer's Guidelines for information about where this file
+ * should be located on your system and for more details of its use:
+ *    http://www.khronos.org/registry/implementers_guide.pdf
+ *
+ * This file should be included as
+ *        #include <KHR/khrplatform.h>
+ * by Khronos client API header files that use its types and defines.
+ *
+ * The types in khrplatform.h should only be used to define API-specific types.
+ *
+ * Types defined in khrplatform.h:
+ *    khronos_int8_t              signed   8  bit
+ *    khronos_uint8_t             unsigned 8  bit
+ *    khronos_int16_t             signed   16 bit
+ *    khronos_uint16_t            unsigned 16 bit
+ *    khronos_int32_t             signed   32 bit
+ *    khronos_uint32_t            unsigned 32 bit
+ *    khronos_int64_t             signed   64 bit
+ *    khronos_uint64_t            unsigned 64 bit
+ *    khronos_intptr_t            signed   same number of bits as a pointer
+ *    khronos_uintptr_t           unsigned same number of bits as a pointer
+ *    khronos_ssize_t             signed   size
+ *    khronos_usize_t             unsigned size
+ *    khronos_float_t             signed   32 bit floating point
+ *    khronos_time_ns_t           unsigned 64 bit time in nanoseconds
+ *    khronos_utime_nanoseconds_t unsigned time interval or absolute time in
+ *                                         nanoseconds
+ *    khronos_stime_nanoseconds_t signed time interval in nanoseconds
+ *    khronos_boolean_enum_t      enumerated boolean type. This should
+ *      only be used as a base type when a client API's boolean type is
+ *      an enum. Client APIs which use an integer or other type for
+ *      booleans cannot use this as the base type for their boolean.
+ *
+ * Tokens defined in khrplatform.h:
+ *
+ *    KHRONOS_FALSE, KHRONOS_TRUE Enumerated boolean false/true values.
+ *
+ *    KHRONOS_SUPPORT_INT64 is 1 if 64 bit integers are supported; otherwise 0.
+ *    KHRONOS_SUPPORT_FLOAT is 1 if floats are supported; otherwise 0.
+ *
+ * Calling convention macros defined in this file:
+ *    KHRONOS_APICALL
+ *    KHRONOS_APIENTRY
+ *    KHRONOS_APIATTRIBUTES
+ *
+ * These may be used in function prototypes as:
+ *
+ *      KHRONOS_APICALL void KHRONOS_APIENTRY funcname(
+ *                                  int arg1,
+ *                                  int arg2) KHRONOS_APIATTRIBUTES;
+ */
+
+#if defined(__SCITECH_SNAP__) && !defined(KHRONOS_STATIC)
+#   define KHRONOS_STATIC 1
+#endif
+
+/*-------------------------------------------------------------------------
+ * Definition of KHRONOS_APICALL
+ *-------------------------------------------------------------------------
+ * This precedes the return type of the function in the function prototype.
+ */
+#if defined(KHRONOS_STATIC)
+    /* If the preprocessor constant KHRONOS_STATIC is defined, make the
+     * header compatible with static linking. */
+#   define KHRONOS_APICALL
+#elif defined(_WIN32)
+#   define KHRONOS_APICALL __declspec(dllimport)
+#elif defined (__SYMBIAN32__)
+#   define KHRONOS_APICALL IMPORT_C
+#elif defined(__ANDROID__)
+#   define KHRONOS_APICALL __attribute__((visibility("default")))
+#else
+#   define KHRONOS_APICALL
+#endif
+
+/*-------------------------------------------------------------------------
+ * Definition of KHRONOS_APIENTRY
+ *-------------------------------------------------------------------------
+ * This follows the return type of the function  and precedes the function
+ * name in the function prototype.
+ */
+#if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(__SCITECH_SNAP__)
+    /* Win32 but not WinCE */
+#   define KHRONOS_APIENTRY __stdcall
+#else
+#   define KHRONOS_APIENTRY
+#endif
+
+/*-------------------------------------------------------------------------
+ * Definition of KHRONOS_APIATTRIBUTES
+ *-------------------------------------------------------------------------
+ * This follows the closing parenthesis of the function prototype arguments.
+ */
+#if defined (__ARMCC_2__)
+#define KHRONOS_APIATTRIBUTES __softfp
+#else
+#define KHRONOS_APIATTRIBUTES
+#endif
+
+/*-------------------------------------------------------------------------
+ * basic type definitions
+ *-----------------------------------------------------------------------*/
+#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__GNUC__) || defined(__SCO__) || defined(__USLC__)
+
+
+/*
+ * Using <stdint.h>
+ */
+#include <stdint.h>
+typedef int32_t                 khronos_int32_t;
+typedef uint32_t                khronos_uint32_t;
+typedef int64_t                 khronos_int64_t;
+typedef uint64_t                khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+/*
+ * To support platform where unsigned long cannot be used interchangeably with
+ * inptr_t (e.g. CHERI-extended ISAs), we can use the stdint.h intptr_t.
+ * Ideally, we could just use (u)intptr_t everywhere, but this could result in
+ * ABI breakage if khronos_uintptr_t is changed from unsigned long to
+ * unsigned long long or similar (this results in different C++ name mangling).
+ * To avoid changes for existing platforms, we restrict usage of intptr_t to
+ * platforms where the size of a pointer is larger than the size of long.
+ */
+#if defined(__SIZEOF_LONG__) && defined(__SIZEOF_POINTER__)
+#if __SIZEOF_POINTER__ > __SIZEOF_LONG__
+#define KHRONOS_USE_INTPTR_T
+#endif
+#endif
+
+#elif defined(__VMS ) || defined(__sgi)
+
+/*
+ * Using <inttypes.h>
+ */
+#include <inttypes.h>
+typedef int32_t                 khronos_int32_t;
+typedef uint32_t                khronos_uint32_t;
+typedef int64_t                 khronos_int64_t;
+typedef uint64_t                khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#elif defined(_WIN32) && !defined(__SCITECH_SNAP__)
+
+/*
+ * Win32
+ */
+typedef __int32                 khronos_int32_t;
+typedef unsigned __int32        khronos_uint32_t;
+typedef __int64                 khronos_int64_t;
+typedef unsigned __int64        khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#elif defined(__sun__) || defined(__digital__)
+
+/*
+ * Sun or Digital
+ */
+typedef int                     khronos_int32_t;
+typedef unsigned int            khronos_uint32_t;
+#if defined(__arch64__) || defined(_LP64)
+typedef long int                khronos_int64_t;
+typedef unsigned long int       khronos_uint64_t;
+#else
+typedef long long int           khronos_int64_t;
+typedef unsigned long long int  khronos_uint64_t;
+#endif /* __arch64__ */
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#elif 0
+
+/*
+ * Hypothetical platform with no float or int64 support
+ */
+typedef int                     khronos_int32_t;
+typedef unsigned int            khronos_uint32_t;
+#define KHRONOS_SUPPORT_INT64   0
+#define KHRONOS_SUPPORT_FLOAT   0
+
+#else
+
+/*
+ * Generic fallback
+ */
+#include <stdint.h>
+typedef int32_t                 khronos_int32_t;
+typedef uint32_t                khronos_uint32_t;
+typedef int64_t                 khronos_int64_t;
+typedef uint64_t                khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#endif
+
+
+/*
+ * Types that are (so far) the same on all platforms
+ */
+typedef signed   char          khronos_int8_t;
+typedef unsigned char          khronos_uint8_t;
+typedef signed   short int     khronos_int16_t;
+typedef unsigned short int     khronos_uint16_t;
+
+/*
+ * Types that differ between LLP64 and LP64 architectures - in LLP64,
+ * pointers are 64 bits, but 'long' is still 32 bits. Win64 appears
+ * to be the only LLP64 architecture in current use.
+ */
+#ifdef KHRONOS_USE_INTPTR_T
+typedef intptr_t               khronos_intptr_t;
+typedef uintptr_t              khronos_uintptr_t;
+#elif defined(_WIN64)
+typedef signed   long long int khronos_intptr_t;
+typedef unsigned long long int khronos_uintptr_t;
+#else
+typedef signed   long  int     khronos_intptr_t;
+typedef unsigned long  int     khronos_uintptr_t;
+#endif
+
+#if defined(_WIN64)
+typedef signed   long long int khronos_ssize_t;
+typedef unsigned long long int khronos_usize_t;
+#else
+typedef signed   long  int     khronos_ssize_t;
+typedef unsigned long  int     khronos_usize_t;
+#endif
+
+#if KHRONOS_SUPPORT_FLOAT
+/*
+ * Float type
+ */
+typedef          float         khronos_float_t;
+#endif
+
+#if KHRONOS_SUPPORT_INT64
+/* Time types
+ *
+ * These types can be used to represent a time interval in nanoseconds or
+ * an absolute Unadjusted System Time.  Unadjusted System Time is the number
+ * of nanoseconds since some arbitrary system event (e.g. since the last
+ * time the system booted).  The Unadjusted System Time is an unsigned
+ * 64 bit value that wraps back to 0 every 584 years.  Time intervals
+ * may be either signed or unsigned.
+ */
+typedef khronos_uint64_t       khronos_utime_nanoseconds_t;
+typedef khronos_int64_t        khronos_stime_nanoseconds_t;
+#endif
+
+/*
+ * Dummy value used to pad enum types to 32 bits.
+ */
+#ifndef KHRONOS_MAX_ENUM
+#define KHRONOS_MAX_ENUM 0x7FFFFFFF
+#endif
+
+/*
+ * Enumerated boolean type
+ *
+ * Values other than zero should be considered to be true.  Therefore
+ * comparisons should not be made against KHRONOS_TRUE.
+ */
+typedef enum {
+    KHRONOS_FALSE = 0,
+    KHRONOS_TRUE  = 1,
+    KHRONOS_BOOLEAN_ENUM_FORCE_SIZE = KHRONOS_MAX_ENUM
+} khronos_boolean_enum_t;
+
+#endif /* __khrplatform_h_ */

vendor/glfw

@@ -0,0 +1 @@
+Subproject commit 97da62a027794d9ff0f4512268cb9a73a8fb5073

vendor/imgui

@@ -0,0 +1 @@
+Subproject commit 8639a2f9f8d6d53f4c7a221579de5871051153d9

vendor/spdlog

@@ -0,0 +1 @@
+Subproject commit 2f2d04b3e840428a18942ca2d3d65203ec564647