diff options
Diffstat (limited to 'gearboy/platforms/desktop-shared/gui_debug.cpp')
| -rw-r--r-- | gearboy/platforms/desktop-shared/gui_debug.cpp | 2060 |
1 files changed, 2060 insertions, 0 deletions
diff --git a/gearboy/platforms/desktop-shared/gui_debug.cpp b/gearboy/platforms/desktop-shared/gui_debug.cpp new file mode 100644 index 00000000..b2bfd8e0 --- /dev/null +++ b/gearboy/platforms/desktop-shared/gui_debug.cpp @@ -0,0 +1,2060 @@ +/* + * Gearboy - Nintendo Game Boy Emulator + * Copyright (C) 2012 Ignacio Sanchez + + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program. If not, see http://www.gnu.org/licenses/ + * + */ + +#include <math.h> +#include "imgui/imgui.h" +#include "imgui/imgui_memory_editor.h" +#include "FileBrowser/ImGuiFileBrowser.h" +#include "config.h" +#include "emu.h" +#include "renderer.h" +#include "../../src/gearboy.h" +#include "gui.h" +#include "gui_debug_constants.h" + +#define GUI_DEBUG_IMPORT +#include "gui_debug.h" + +struct DebugSymbol +{ + int bank; + u16 address; + std::string text; +}; + +struct DisassmeblerLine +{ + bool is_symbol; + bool is_breakpoint; + Memory::stDisassembleRecord* record; + std::string symbol; +}; + +static MemoryEditor mem_edit; +static ImVec4 cyan = ImVec4(0.0f,1.0f,1.0f,1.0f); +static ImVec4 magenta = ImVec4(1.0f,0.502f,0.957f,1.0f); +static ImVec4 yellow = ImVec4(1.0f,1.0f,0.0f,1.0f); +static ImVec4 red = ImVec4(1.0f,0.149f,0.447f,1.0f); +static ImVec4 green = ImVec4(0.0f,1.0f,0.0f,1.0f); +static ImVec4 white = ImVec4(1.0f,1.0f,1.0f,1.0f); +static ImVec4 gray = ImVec4(0.5f,0.5f,0.5f,1.0f); +static ImVec4 dark_gray = ImVec4(0.1f,0.1f,0.1f,1.0f); +static std::vector<DebugSymbol> symbols; +static Memory::stDisassembleRecord* selected_record = NULL; +static char brk_address_cpu[8] = ""; +static char brk_address_mem[10] = ""; +static bool brk_new_mem_read = true; +static bool brk_new_mem_write = true; +static char goto_address[5] = ""; +static bool goto_address_requested = false; +static u16 goto_address_target = 0; +static bool goto_back_requested = false; +static int goto_back = 0; + +static void debug_window_processor(void); +static void debug_window_io(void); +static void debug_window_audio(void); +static void debug_window_memory(void); +static void debug_window_disassembler(void); +static void debug_window_vram(void); +static void debug_window_vram_background(void); +static void debug_window_vram_tiles(void); +static void debug_window_vram_oam(void); +static void debug_window_vram_palettes(void); +static void add_symbol(const char* line); +static void add_breakpoint_cpu(void); +static void add_breakpoint_mem(void); +static void request_goto_address(u16 addr); +static ImVec4 color_565_to_float(u16 color); + +void gui_debug_windows(void) +{ + if (config_debug.debug) + { + if (config_debug.show_processor) + debug_window_processor(); + if (config_debug.show_memory) + debug_window_memory(); + if (config_debug.show_disassembler) + debug_window_disassembler(); + if (config_debug.show_iomap) + debug_window_io(); + if (config_debug.show_audio) + debug_window_audio(); + if (config_debug.show_video) + debug_window_vram(); + + //ImGui::ShowDemoWindow(&config_debug.debug); + } +} + + +void gui_debug_reset(void) +{ + gui_debug_reset_breakpoints_cpu(); + gui_debug_reset_breakpoints_mem(); + gui_debug_reset_symbols(); + selected_record = NULL; +} + +void gui_debug_reset_symbols(void) +{ + symbols.clear(); + + for (int i = 0; i < gui_debug_symbols_count; i++) + add_symbol(gui_debug_symbols[i]); +} + +void gui_debug_load_symbols_file(const char* path) +{ + Log("Loading symbol file %s", path); + + std::ifstream file(path); + + if (file.is_open()) + { + std::string line; + + while (std::getline(file, line)) + { + add_symbol(line.c_str()); + } + + file.close(); + } +} + +void gui_debug_toggle_breakpoint(void) +{ + if (IsValidPointer(selected_record)) + { + bool found = false; + std::vector<Memory::stDisassembleRecord*>* breakpoints = emu_get_core()->GetMemory()->GetBreakpointsCPU(); + + for (long unsigned int b = 0; b < breakpoints->size(); b++) + { + if ((*breakpoints)[b] == selected_record) + { + found = true; + InitPointer((*breakpoints)[b]); + break; + } + } + + if (!found) + { + breakpoints->push_back(selected_record); + } + } +} + +void gui_debug_runtocursor(void) +{ + if (IsValidPointer(selected_record)) + { + emu_get_core()->GetMemory()->SetRunToBreakpoint(selected_record); + emu_debug_continue(); + } +} + +void gui_debug_reset_breakpoints_cpu(void) +{ + emu_get_core()->GetMemory()->GetBreakpointsCPU()->clear(); + brk_address_cpu[0] = 0; +} + +void gui_debug_reset_breakpoints_mem(void) +{ + emu_get_core()->GetMemory()->GetBreakpointsMem()->clear(); + brk_address_mem[0] = 0; +} + +void gui_debug_go_back(void) +{ + goto_back_requested = true; +} + +static void debug_window_memory(void) +{ + ImGui::SetNextWindowPos(ImVec2(180, 382), ImGuiCond_FirstUseEver); + ImGui::SetNextWindowSize(ImVec2(482, 308), ImGuiCond_FirstUseEver); + + ImGui::Begin("Memory Editor", &config_debug.show_memory); + + GearboyCore* core = emu_get_core(); + Memory* memory = core->GetMemory(); + + ImGui::PushFont(gui_default_font); + + ImGui::TextColored(cyan, " BANKS: ");ImGui::SameLine(); + + ImGui::TextColored(magenta, "ROM1");ImGui::SameLine(); + ImGui::Text("$%02X", memory->GetCurrentRule()->GetCurrentRomBank1Index()); ImGui::SameLine(); + ImGui::TextColored(magenta, " RAM");ImGui::SameLine(); + ImGui::Text("$%02X", memory->GetCurrentRule()->GetCurrentRamBankIndex()); ImGui::SameLine(); + ImGui::TextColored(magenta, " WRAM1");ImGui::SameLine(); + ImGui::Text("$%02X", memory->GetCurrentCGBRAMBank()); ImGui::SameLine(); + ImGui::TextColored(magenta, " VRAM");ImGui::SameLine(); + ImGui::Text("$%02X", memory->GetCurrentLCDRAMBank()); + + ImGui::PopFont(); + + if (ImGui::BeginTabBar("##memory_tabs", ImGuiTabBarFlags_None)) + { + if (ImGui::BeginTabItem("ROM0")) + { + ImGui::PushFont(gui_default_font); + mem_edit.DrawContents(memory->GetROM0(), 0x4000, 0); + ImGui::PopFont(); + ImGui::EndTabItem(); + } + + if (ImGui::BeginTabItem("ROM1")) + { + ImGui::PushFont(gui_default_font); + mem_edit.DrawContents(memory->GetROM1(), 0x4000, 0x4000); + ImGui::PopFont(); + ImGui::EndTabItem(); + } + + if (ImGui::BeginTabItem("VRAM")) + { + ImGui::PushFont(gui_default_font); + mem_edit.DrawContents(memory->GetVRAM(), 0x2000, 0x8000); + ImGui::PopFont(); + ImGui::EndTabItem(); + } + + if (ImGui::BeginTabItem("RAM")) + { + ImGui::PushFont(gui_default_font); + mem_edit.DrawContents(memory->GetRAM(), 0x2000, 0xA000); + ImGui::PopFont(); + ImGui::EndTabItem(); + } + + if (emu_is_cgb()) + { + if (ImGui::BeginTabItem("WRAM0")) + { + ImGui::PushFont(gui_default_font); + mem_edit.DrawContents(memory->GetWRAM0(), 0x1000, 0xC000); + ImGui::PopFont(); + ImGui::EndTabItem(); + } + if (ImGui::BeginTabItem("WRAM1")) + { + ImGui::PushFont(gui_default_font); + mem_edit.DrawContents(memory->GetWRAM1(), 0x1000, 0xD000); + ImGui::PopFont(); + ImGui::EndTabItem(); + } + } + else + { + if (ImGui::BeginTabItem("WRAM")) + { + ImGui::PushFont(gui_default_font); + mem_edit.DrawContents(memory->GetWRAM0(), 0x2000, 0xC000); + ImGui::PopFont(); + ImGui::EndTabItem(); + } + } + + if (ImGui::BeginTabItem("OAM")) + { + ImGui::PushFont(gui_default_font); + mem_edit.DrawContents(memory->GetMemoryMap() + 0xFE00, 0x00A0, 0xFE00); + ImGui::PopFont(); + ImGui::EndTabItem(); + } + + if (ImGui::BeginTabItem("IO")) + { + ImGui::PushFont(gui_default_font); + mem_edit.DrawContents(memory->GetMemoryMap() + 0xFF00, 0x0080, 0xFF00); + ImGui::PopFont(); + ImGui::EndTabItem(); + } + + if (ImGui::BeginTabItem("HIRAM")) + { + ImGui::PushFont(gui_default_font); + mem_edit.DrawContents(memory->GetMemoryMap() + 0xFF80, 0x007F, 0xFF80); + ImGui::PopFont(); + ImGui::EndTabItem(); + } + ImGui::EndTabBar(); + } + + ImGui::End(); +} + +static void debug_window_disassembler(void) +{ + ImGui::SetNextWindowPos(ImVec2(180, 30), ImGuiCond_FirstUseEver); + ImGui::SetNextWindowSize(ImVec2(482, 344), ImGuiCond_FirstUseEver); + + ImGui::Begin("Disassembler", &config_debug.show_disassembler); + + GearboyCore* core = emu_get_core(); + Processor* processor = core->GetProcessor(); + Processor::ProcessorState* proc_state = processor->GetState(); + Memory* memory = core->GetMemory(); + std::vector<Memory::stDisassembleRecord*>* breakpoints_cpu = memory->GetBreakpointsCPU(); + std::vector<Memory::stMemoryBreakpoint>* breakpoints_mem = memory->GetBreakpointsMem(); + Memory::stDisassembleRecord** memory_map = memory->GetDisassembledMemoryMap(); + Memory::stDisassembleRecord** rom_map = memory->GetDisassembledROMMemoryMap(); + Memory::stDisassembleRecord** map = NULL; + + int pc = proc_state->PC->GetValue(); + + if (ImGui::Button("Step Over")) + emu_debug_step(); + ImGui::SameLine(); + if (ImGui::Button("Step Frame")) + emu_debug_next_frame(); + ImGui::SameLine(); + if (ImGui::Button("Continue")) + emu_debug_continue(); + ImGui::SameLine(); + if (ImGui::Button("Run To Cursor")) + gui_debug_runtocursor(); + + static bool follow_pc = true; + static bool show_mem = true; + static bool show_symbols = true; + + ImGui::Checkbox("Follow PC", &follow_pc); ImGui::SameLine(); + ImGui::Checkbox("Show Memory", &show_mem); ImGui::SameLine(); + ImGui::Checkbox("Show Symbols", &show_symbols); + + ImGui::Separator(); + + ImGui::Text("Go To Address: "); + ImGui::SameLine(); + ImGui::PushItemWidth(45); + if (ImGui::InputTextWithHint("##goto_address", "XXXX", goto_address, IM_ARRAYSIZE(goto_address), ImGuiInputTextFlags_AutoSelectAll | ImGuiInputTextFlags_EnterReturnsTrue)) + { + try + { + request_goto_address((u16)std::stoul(goto_address, 0, 16)); + follow_pc = false; + } + catch(const std::invalid_argument&) + { + } + goto_address[0] = 0; + } + ImGui::PopItemWidth(); + ImGui::SameLine(); + if (ImGui::Button("Go", ImVec2(30, 0))) + { + try + { + request_goto_address((u16)std::stoul(goto_address, 0, 16)); + follow_pc = false; + } + catch(const std::invalid_argument&) + { + } + goto_address[0] = 0; + } + ImGui::SameLine(); + if (ImGui::Button("Back", ImVec2(50, 0))) + { + goto_back_requested = true; + follow_pc = false; + } + + ImGui::Separator(); + + if (ImGui::CollapsingHeader("Processor Breakpoints")) + { + ImGui::Checkbox("Disable All##disable_all_cpu", &emu_debug_disable_breakpoints_cpu); + + ImGui::Columns(2, "breakpoints_cpu"); + ImGui::SetColumnOffset(1, 85); + + ImGui::Separator(); + + if (IsValidPointer(selected_record)) + sprintf(brk_address_cpu, "%02X:%04X", selected_record->bank, selected_record->address); + + ImGui::PushItemWidth(70); + if (ImGui::InputTextWithHint("##add_breakpoint_cpu", "XX:XXXX", brk_address_cpu, IM_ARRAYSIZE(brk_address_cpu), ImGuiInputTextFlags_AutoSelectAll | ImGuiInputTextFlags_EnterReturnsTrue)) + { + add_breakpoint_cpu(); + } + ImGui::PopItemWidth(); + + if (ImGui::IsItemHovered()) + ImGui::SetTooltip("Use XXXX format for addresses in bank 0 or XX:XXXX for selecting bank and address"); + + if (ImGui::Button("Add##add_cpu", ImVec2(70, 0))) + { + add_breakpoint_cpu(); + } + + if (ImGui::Button("Clear All##clear_all_cpu", ImVec2(70, 0))) + { + gui_debug_reset_breakpoints_cpu(); + } + + ImGui::NextColumn(); + + ImGui::BeginChild("breakpoints_cpu", ImVec2(0, 80), false); + + int remove = -1; + + for (long unsigned int b = 0; b < breakpoints_cpu->size(); b++) + { + if (!IsValidPointer((*breakpoints_cpu)[b])) + continue; + + ImGui::PushID(b); + if (ImGui::SmallButton("X")) + { + remove = b; + ImGui::PopID(); + continue; + } + + ImGui::PopID(); + + ImGui::PushFont(gui_default_font); + ImGui::SameLine(); + ImGui::TextColored(red, "%02X:%04X", (*breakpoints_cpu)[b]->bank, (*breakpoints_cpu)[b]->address); + ImGui::SameLine(); + ImGui::TextColored(gray, "%s", (*breakpoints_cpu)[b]->name); + ImGui::PopFont(); + } + + if (remove >= 0) + { + breakpoints_cpu->erase(breakpoints_cpu->begin() + remove); + } + + ImGui::EndChild(); + ImGui::Columns(1); + ImGui::Separator(); + } + + if (ImGui::CollapsingHeader("Memory Breakpoints")) + { + ImGui::Checkbox("Disable All##diable_all_mem", &emu_debug_disable_breakpoints_mem); + + ImGui::Columns(2, "breakpoints_mem"); + ImGui::SetColumnOffset(1, 100); + + ImGui::Separator(); + + ImGui::PushItemWidth(85); + if (ImGui::InputTextWithHint("##add_breakpoint_mem", "XXXX-XXXX", brk_address_mem, IM_ARRAYSIZE(brk_address_mem), ImGuiInputTextFlags_AutoSelectAll | ImGuiInputTextFlags_EnterReturnsTrue)) + { + add_breakpoint_mem(); + } + ImGui::PopItemWidth(); + + if (ImGui::IsItemHovered()) + ImGui::SetTooltip("Use XXXX format for single addresses or XXXX-XXXX for address ranges"); + + ImGui::Checkbox("Read", &brk_new_mem_read); + ImGui::Checkbox("Write", &brk_new_mem_write); + + if (ImGui::Button("Add##add_mem", ImVec2(85, 0))) + { + add_breakpoint_mem(); + } + + if (ImGui::Button("Clear All##clear_all_mem", ImVec2(85, 0))) + { + gui_debug_reset_breakpoints_mem(); + } + + ImGui::NextColumn(); + + ImGui::BeginChild("breakpoints_mem", ImVec2(0, 130), false); + + int remove = -1; + + for (long unsigned int b = 0; b < breakpoints_mem->size(); b++) + { + ImGui::PushID(10000 + b); + if (ImGui::SmallButton("X")) + { + remove = b; + ImGui::PopID(); + continue; + } + + ImGui::PopID(); + + ImGui::PushFont(gui_default_font); + ImGui::SameLine(); + if ((*breakpoints_mem)[b].range) + ImGui::TextColored(red, "%04X-%04X", (*breakpoints_mem)[b].address1, (*breakpoints_mem)[b].address2); + else + ImGui::TextColored(red, "%04X", (*breakpoints_mem)[b].address1); + if ((*breakpoints_mem)[b].read) + { + ImGui::SameLine(); ImGui::TextColored(gray, "R"); + } + if ((*breakpoints_mem)[b].write) + { + ImGui::SameLine(); ImGui::TextColored(gray, "W"); + } + ImGui::PopFont(); + } + + if (remove >= 0) + { + breakpoints_mem->erase(breakpoints_mem->begin() + remove); + } + + ImGui::EndChild(); + ImGui::Columns(1); + ImGui::Separator(); + } + + ImGui::PushFont(gui_default_font); + + bool window_visible = ImGui::BeginChild("##dis", ImVec2(ImGui::GetWindowContentRegionWidth(), 0), true, 0); + + if (window_visible) + { + int dis_size = 0; + int pc_pos = 0; + int goto_address_pos = 0; + + std::vector<DisassmeblerLine> vec(0x10000); + + for (int i = 0; i < 0x10000; i++) + { + int offset = i; + int bank = 0; + + if ((i & 0xC000) == 0x0000) + { + bank = memory->GetCurrentRule()->GetCurrentRomBank0Index(); + offset = (0x4000 * bank) + i; + map = rom_map; + } + else if ((i & 0xC000) == 0x4000) + { + bank = memory->GetCurrentRule()->GetCurrentRomBank1Index(); + offset = (0x4000 * bank) + (i & 0x3FFF); + map = rom_map; + } + else + { + map = memory_map; + } + + if (IsValidPointer(map[offset]) && map[offset]->name[0] != 0) + { + for (long unsigned int s = 0; s < symbols.size(); s++) + { + if ((symbols[s].bank == bank) && (symbols[s].address == offset) && show_symbols) + { + vec[dis_size].is_symbol = true; + vec[dis_size].symbol = symbols[s].text; + dis_size ++; + } + } + + vec[dis_size].is_symbol = false; + vec[dis_size].record = map[offset]; + + if (vec[dis_size].record->address == pc) + pc_pos = dis_size; + + if (goto_address_requested && (vec[dis_size].record->address <= goto_address_target)) + goto_address_pos = dis_size; + + vec[dis_size].is_breakpoint = false; + + for (long unsigned int b = 0; b < breakpoints_cpu->size(); b++) + { + if ((*breakpoints_cpu)[b] == vec[dis_size].record) + { + vec[dis_size].is_breakpoint = true; + break; + } + } + + dis_size++; + } + } + + if (follow_pc) + { + float window_offset = ImGui::GetWindowHeight() / 2.0f; + float offset = window_offset - (ImGui::GetTextLineHeightWithSpacing() - 2.0f); + ImGui::SetScrollY((pc_pos * ImGui::GetTextLineHeightWithSpacing()) - offset); + } + + if (goto_address_requested) + { + goto_address_requested = false; + goto_back = (int)ImGui::GetScrollY(); + ImGui::SetScrollY((goto_address_pos * ImGui::GetTextLineHeightWithSpacing()) + 2); + } + + if (goto_back_requested) + { + goto_back_requested = false; + ImGui::SetScrollY((float)goto_back); + } + + ImGuiListClipper clipper(dis_size, ImGui::GetTextLineHeightWithSpacing()); + + while (clipper.Step()) + { + for (int item = clipper.DisplayStart; item < clipper.DisplayEnd; item++) + { + if (vec[item].is_symbol) + { + ImGui::TextColored(green, "%s:", vec[item].symbol.c_str()); + continue; + } + + ImGui::PushID(item); + + bool is_selected = (selected_record == vec[item].record); + + if (ImGui::Selectable("", is_selected, ImGuiSelectableFlags_AllowDoubleClick)) + { + if (ImGui::IsMouseDoubleClicked(0) && vec[item].record->jump) + { + follow_pc = false; + request_goto_address(vec[item].record->jump_address); + } + else if (is_selected) + { + InitPointer(selected_record); + brk_address_cpu[0] = 0; + } + else + selected_record = vec[item].record; + } + + if (is_selected) + ImGui::SetItemDefaultFocus(); + + if (vec[item].is_breakpoint) + { + ImGui::SameLine(); + if (vec[item].record->address == pc) + { + if (show_mem) + ImGui::TextColored(red, " %02X:%04X %s", vec[item].record->bank, vec[item].record->address, vec[item].record->bytes); + else + ImGui::TextColored(red, " %02X:%04X ", vec[item].record->bank, vec[item].record->address); + ImGui::SameLine(); + ImGui::TextColored(yellow, "->"); + ImGui::SameLine(); + ImGui::TextColored(red, "%s", vec[item].record->name); + } + else + { + if (show_mem) + ImGui::TextColored(red, " %02X:%04X %s %s", vec[item].record->bank, vec[item].record->address, vec[item].record->bytes, vec[item].record->name); + else + ImGui::TextColored(red, " %02X:%04X %s", vec[item].record->bank, vec[item].record->address, vec[item].record->name); + } + } + else if (vec[item].record->address == pc) + { + ImGui::SameLine(); + if (show_mem) + ImGui::TextColored(yellow, " %02X:%04X %s -> %s", vec[item].record->bank, vec[item].record->address, vec[item].record->bytes, vec[item].record->name); + else + ImGui::TextColored(yellow, " %02X:%04X -> %s", vec[item].record->bank, vec[item].record->address, vec[item].record->name); + } + else + { + ImGui::SameLine(); + ImGui::TextColored(cyan, " %02X:%04X ", vec[item].record->bank, vec[item].record->address); + ImGui::SameLine(); + if (show_mem) + ImGui::TextColored(gray, "%s ", vec[item].record->bytes); + else + ImGui::TextColored(gray, " "); + + ImGui::SameLine(); + ImGui::TextColored(white, "%s", vec[item].record->name); + } + + ImGui::PopID(); + } + } + } + + ImGui::EndChild(); + + ImGui::PopFont(); + + ImGui::End(); +} + +static void debug_window_processor(void) +{ + ImGui::SetNextWindowPos(ImVec2(14, 210), ImGuiCond_FirstUseEver); + + ImGui::Begin("Processor", &config_debug.show_processor, ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoResize); + + ImGui::PushFont(gui_default_font); + + GearboyCore* core = emu_get_core(); + Processor* processor = core->GetProcessor(); + Processor::ProcessorState* proc_state = processor->GetState(); + Memory* memory = core->GetMemory(); + + ImGui::Separator(); + + u8 flags = proc_state->AF->GetLow(); + + ImGui::TextColored(magenta, " Z"); ImGui::SameLine(); + ImGui::Text("= %d", (bool)(flags & FLAG_ZERO)); ImGui::SameLine(); + + ImGui::TextColored(magenta, " N"); ImGui::SameLine(); + ImGui::Text("= %d", (bool)(flags & FLAG_SUB)); + + ImGui::TextColored(magenta, " H"); ImGui::SameLine(); + ImGui::Text("= %d", (bool)(flags & FLAG_HALF)); ImGui::SameLine(); + + ImGui::TextColored(magenta, " C"); ImGui::SameLine(); + ImGui::Text("= %d", (bool)(flags & FLAG_CARRY)); + + ImGui::Columns(2, "registers"); + ImGui::Separator(); + ImGui::TextColored(cyan, " A"); ImGui::SameLine(); + ImGui::Text("= $%02X", proc_state->AF->GetHigh()); + ImGui::Text(BYTE_TO_BINARY_PATTERN_SPACED, BYTE_TO_BINARY(proc_state->AF->GetHigh())); + + ImGui::NextColumn(); + ImGui::TextColored(cyan, " F"); ImGui::SameLine(); + ImGui::Text("= $%02X", proc_state->AF->GetLow()); + ImGui::Text(BYTE_TO_BINARY_PATTERN_SPACED, BYTE_TO_BINARY(proc_state->AF->GetLow())); + + ImGui::NextColumn(); + ImGui::Separator(); + ImGui::TextColored(cyan, " B"); ImGui::SameLine(); + ImGui::Text("= $%02X", proc_state->BC->GetHigh()); + ImGui::Text(BYTE_TO_BINARY_PATTERN_SPACED, BYTE_TO_BINARY(proc_state->BC->GetHigh())); + + ImGui::NextColumn(); + ImGui::TextColored(cyan, " C"); ImGui::SameLine(); + ImGui::Text("= $%02X", proc_state->BC->GetLow()); + ImGui::Text(BYTE_TO_BINARY_PATTERN_SPACED, BYTE_TO_BINARY(proc_state->BC->GetLow())); + + ImGui::NextColumn(); + ImGui::Separator(); + ImGui::TextColored(cyan, " D"); ImGui::SameLine(); + ImGui::Text("= $%02X", proc_state->DE->GetHigh()); + ImGui::Text(BYTE_TO_BINARY_PATTERN_SPACED, BYTE_TO_BINARY(proc_state->DE->GetHigh())); + + ImGui::NextColumn(); + ImGui::TextColored(cyan, " E"); ImGui::SameLine(); + ImGui::Text("= $%02X", proc_state->DE->GetLow()); + ImGui::Text(BYTE_TO_BINARY_PATTERN_SPACED, BYTE_TO_BINARY(proc_state->DE->GetLow())); + + ImGui::NextColumn(); + ImGui::Separator(); + ImGui::TextColored(cyan, " H"); ImGui::SameLine(); + ImGui::Text("= $%02X", proc_state->HL->GetHigh()); + ImGui::Text(BYTE_TO_BINARY_PATTERN_SPACED, BYTE_TO_BINARY(proc_state->HL->GetHigh())); + + ImGui::NextColumn(); + ImGui::TextColored(cyan, " L"); ImGui::SameLine(); + ImGui::Text("= $%02X", proc_state->HL->GetLow()); + ImGui::Text(BYTE_TO_BINARY_PATTERN_SPACED, BYTE_TO_BINARY(proc_state->HL->GetLow())); + + ImGui::NextColumn(); + ImGui::Columns(1); + ImGui::Separator(); + ImGui::TextColored(yellow, " SP"); ImGui::SameLine(); + ImGui::Text("= $%04X", proc_state->SP->GetValue()); + ImGui::Text(BYTE_TO_BINARY_PATTERN_SPACED " " BYTE_TO_BINARY_PATTERN_SPACED, BYTE_TO_BINARY(proc_state->SP->GetHigh()), BYTE_TO_BINARY(proc_state->SP->GetLow())); + + ImGui::Separator(); + ImGui::TextColored(yellow, " PC"); ImGui::SameLine(); + ImGui::Text("= $%04X", proc_state->PC->GetValue()); + ImGui::Text(BYTE_TO_BINARY_PATTERN_SPACED " " BYTE_TO_BINARY_PATTERN_SPACED, BYTE_TO_BINARY(proc_state->PC->GetHigh()), BYTE_TO_BINARY(proc_state->PC->GetLow())); + + + ImGui::Columns(2); + ImGui::Separator(); + + ImGui::TextColored(magenta, " IME"); ImGui::SameLine(); + ImGui::Text("= %d", *proc_state->IME); + + ImGui::NextColumn(); + + ImGui::TextColored(magenta, "HALT"); ImGui::SameLine(); + ImGui::Text("= %d", *proc_state->Halt); + + ImGui::NextColumn(); + + ImGui::Columns(1); + + ImGui::Separator(); + + ImGui::TextColored(cyan, " DOUBLE SPEED "); ImGui::SameLine(); + processor->CGBSpeed() ? ImGui::TextColored(green, "ON") : ImGui::TextColored(gray, "OFF"); + + ImGui::Separator(); + + ImGui::TextColored(cyan, " BOOTROM "); ImGui::SameLine(); + memory->IsBootromRegistryEnabled() ? ImGui::TextColored(green, "ON") : ImGui::TextColored(gray, "OFF"); + + ImGui::PopFont(); + + ImGui::End(); +} + +static void debug_window_audio(void) +{ + ImGui::SetNextWindowPos(ImVec2(130, 264), ImGuiCond_FirstUseEver); + ImGui::SetNextWindowSize(ImVec2(417, 0), ImGuiCond_FirstUseEver); + + ImGui::Begin("Sound Registers", &config_debug.show_audio); + + ImGui::PushFont(gui_default_font); + + GearboyCore* core = emu_get_core(); + Audio* audio = core->GetAudio(); + + gb_apu_state_t apu_state; + audio->GetApu()->save_state(&apu_state); + + ImGui::Columns(2, "audio"); + + ImGui::TextColored(yellow, "CHANNEL 1 - TONE & SWEEP:"); + + u8 value = apu_state.regs[0xFF10 - 0xFF10]; + ImGui::TextColored(cyan, " $FF10"); ImGui::SameLine(); + ImGui::TextColored(magenta, "NR10"); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", value, BYTE_TO_BINARY(value)); + + value = apu_state.regs[0xFF11 - 0xFF10]; + ImGui::TextColored(cyan, " $FF11"); ImGui::SameLine(); + ImGui::TextColored(magenta, "NR11"); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", value, BYTE_TO_BINARY(value)); + + value = apu_state.regs[0xFF12 - 0xFF10]; + ImGui::TextColored(cyan, " $FF12"); ImGui::SameLine(); + ImGui::TextColored(magenta, "NR12"); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", value, BYTE_TO_BINARY(value)); + + value = apu_state.regs[0xFF13 - 0xFF10]; + ImGui::TextColored(cyan, " $FF13"); ImGui::SameLine(); + ImGui::TextColored(magenta, "NR13"); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", value, BYTE_TO_BINARY(value)); + + value = apu_state.regs[0xFF14 - 0xFF10]; + ImGui::TextColored(cyan, " $FF14"); ImGui::SameLine(); + ImGui::TextColored(magenta, "NR14"); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", value, BYTE_TO_BINARY(value)); + + ImGui::NextColumn(); + + ImGui::TextColored(yellow, "CHANNEL 3 - WAVE:"); + + value = apu_state.regs[0xFF1A - 0xFF10]; + ImGui::TextColored(cyan, " $FF1A"); ImGui::SameLine(); + ImGui::TextColored(magenta, "NR30"); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", value, BYTE_TO_BINARY(value)); + + value = apu_state.regs[0xFF1B - 0xFF10]; + ImGui::TextColored(cyan, " $FF1B"); ImGui::SameLine(); + ImGui::TextColored(magenta, "NR31"); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", value, BYTE_TO_BINARY(value)); + + value = apu_state.regs[0xFF1C - 0xFF10]; + ImGui::TextColored(cyan, " $FF1C"); ImGui::SameLine(); + ImGui::TextColored(magenta, "NR32"); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", value, BYTE_TO_BINARY(value)); + + value = apu_state.regs[0xFF1D - 0xFF10]; + ImGui::TextColored(cyan, " $FF1D"); ImGui::SameLine(); + ImGui::TextColored(magenta, "NR33"); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", value, BYTE_TO_BINARY(value)); + + value = apu_state.regs[0xFF1E - 0xFF10]; + ImGui::TextColored(cyan, " $FF1E"); ImGui::SameLine(); + ImGui::TextColored(magenta, "NR34"); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", value, BYTE_TO_BINARY(value)); + + ImGui::NextColumn(); + ImGui::Separator(); + + ImGui::TextColored(yellow, "CHANNEL 2 - TONE:"); + + value = apu_state.regs[0xFF16 - 0xFF10]; + ImGui::TextColored(cyan, " $FF16"); ImGui::SameLine(); + ImGui::TextColored(magenta, "NR21"); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", value, BYTE_TO_BINARY(value)); + + value = apu_state.regs[0xFF17 - 0xFF10]; + ImGui::TextColored(cyan, " $FF17"); ImGui::SameLine(); + ImGui::TextColored(magenta, "NR22"); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", value, BYTE_TO_BINARY(value)); + + value = apu_state.regs[0xFF18 - 0xFF10]; + ImGui::TextColored(cyan, " $FF18"); ImGui::SameLine(); + ImGui::TextColored(magenta, "NR23"); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", value, BYTE_TO_BINARY(value)); + + value = apu_state.regs[0xFF19 - 0xFF10]; + ImGui::TextColored(cyan, " $FF19"); ImGui::SameLine(); + ImGui::TextColored(magenta, "NR24"); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", value, BYTE_TO_BINARY(value)); + + ImGui::NextColumn(); + + ImGui::TextColored(yellow, "CHANNEL 4 - NOISE:"); + + value = apu_state.regs[0xFF20 - 0xFF10]; + ImGui::TextColored(cyan, " $FF20"); ImGui::SameLine(); + ImGui::TextColored(magenta, "NR41"); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", value, BYTE_TO_BINARY(value)); + + value = apu_state.regs[0xFF21 - 0xFF10]; + ImGui::TextColored(cyan, " $FF21"); ImGui::SameLine(); + ImGui::TextColored(magenta, "NR42"); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", value, BYTE_TO_BINARY(value)); + + value = apu_state.regs[0xFF22 - 0xFF10]; + ImGui::TextColored(cyan, " $FF22"); ImGui::SameLine(); + ImGui::TextColored(magenta, "NR43"); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", value, BYTE_TO_BINARY(value)); + + value = apu_state.regs[0xFF23 - 0xFF10]; + ImGui::TextColored(cyan, " $FF23"); ImGui::SameLine(); + ImGui::TextColored(magenta, "NR44"); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", value, BYTE_TO_BINARY(value)); + + ImGui::NextColumn(); + ImGui::Separator(); + + ImGui::TextColored(yellow, "CONTROL:"); + + value = apu_state.regs[0xFF24 - 0xFF10]; + ImGui::TextColored(cyan, " $FF24"); ImGui::SameLine(); + ImGui::TextColored(magenta, "NR50"); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", value, BYTE_TO_BINARY(value)); + + value = apu_state.regs[0xFF25 - 0xFF10]; + ImGui::TextColored(cyan, " $FF25"); ImGui::SameLine(); + ImGui::TextColored(magenta, "NR51"); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", value, BYTE_TO_BINARY(value)); + + value = apu_state.regs[0xFF26 - 0xFF10]; + ImGui::TextColored(cyan, " $FF26"); ImGui::SameLine(); + ImGui::TextColored(magenta, "NR52"); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", value, BYTE_TO_BINARY(value)); + + ImGui::NextColumn(); + + ImGui::TextColored(yellow, "WAVE ($FF30 - $FF37):" ); + + ImGui::Text(" %02X%02X %02X%02X %02X%02X %02X%02X", apu_state.regs[0x20], apu_state.regs[0x21], apu_state.regs[0x22], apu_state.regs[0x23], apu_state.regs[0x24], apu_state.regs[0x25], apu_state.regs[0x26], apu_state.regs[0x27]); + + ImGui::TextColored(yellow, "WAVE ($FF38 - $FF3F):" ); + + ImGui::Text(" %02X%02X %02X%02X %02X%02X %02X%02X", apu_state.regs[0x28], apu_state.regs[0x29], apu_state.regs[0x2A], apu_state.regs[0x2B], apu_state.regs[0x2C], apu_state.regs[0x2D], apu_state.regs[0x2E], apu_state.regs[0x2F]); + + ImGui::NextColumn(); + + ImGui::Columns(1); + + ImGui::PopFont(); + + ImGui::End(); +} + +static void debug_window_io(void) +{ + ImGui::SetNextWindowPos(ImVec2(121, 164), ImGuiCond_FirstUseEver); + ImGui::SetNextWindowSize(ImVec2(420, 0), ImGuiCond_FirstUseEver); + + ImGui::Begin("IO Map", &config_debug.show_iomap); + + ImGui::PushFont(gui_default_font); + + GearboyCore* core = emu_get_core(); + Memory* memory = core->GetMemory(); + + ImGui::Columns(2, "iomap"); + + ImGui::TextColored(yellow, "INTERRUPTS:"); + + ImGui::TextColored(cyan, " $FFFF"); ImGui::SameLine(); + ImGui::TextColored(magenta, "IE "); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", memory->Retrieve(0xFFFF), BYTE_TO_BINARY(memory->Retrieve(0xFFFF))); + + ImGui::TextColored(cyan, " $FF0F"); ImGui::SameLine(); + ImGui::TextColored(magenta, "IF "); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", memory->Retrieve(0xFF0F), BYTE_TO_BINARY(memory->Retrieve(0xFF0F))); + + ImGui::TextColored(cyan, " VBLNK "); ImGui::SameLine(); + IsSetBit(memory->Retrieve(0xFF0F), 0) && IsSetBit(memory->Retrieve(0xFFFF), 0) ? ImGui::TextColored(green, "ON ") : ImGui::TextColored(gray, "OFF "); ImGui::SameLine(); + ImGui::TextColored(magenta, "IF:"); ImGui::SameLine(); + ImGui::Text("%d", IsSetBit(memory->Retrieve(0xFF0F), 0)); ImGui::SameLine(); + ImGui::TextColored(magenta, " IE:"); ImGui::SameLine(); + ImGui::Text("%d", IsSetBit(memory->Retrieve(0xFFFF), 0)); + + ImGui::TextColored(cyan, " STAT "); ImGui::SameLine(); + IsSetBit(memory->Retrieve(0xFF0F), 1) && IsSetBit(memory->Retrieve(0xFFFF), 1) ? ImGui::TextColored(green, "ON ") : ImGui::TextColored(gray, "OFF "); ImGui::SameLine(); + ImGui::TextColored(magenta, "IF:"); ImGui::SameLine(); + ImGui::Text("%d", IsSetBit(memory->Retrieve(0xFF0F), 1)); ImGui::SameLine(); + ImGui::TextColored(magenta, " IE:"); ImGui::SameLine(); + ImGui::Text("%d", IsSetBit(memory->Retrieve(0xFFFF), 1)); + + ImGui::TextColored(cyan, " TIMER "); ImGui::SameLine(); + IsSetBit(memory->Retrieve(0xFF0F), 2) && IsSetBit(memory->Retrieve(0xFFFF), 2) ? ImGui::TextColored(green, "ON ") : ImGui::TextColored(gray, "OFF "); ImGui::SameLine(); + ImGui::TextColored(magenta, "IF:"); ImGui::SameLine(); + ImGui::Text("%d", IsSetBit(memory->Retrieve(0xFF0F), 2)); ImGui::SameLine(); + ImGui::TextColored(magenta, " IE:"); ImGui::SameLine(); + ImGui::Text("%d", IsSetBit(memory->Retrieve(0xFFFF), 2)); + + ImGui::TextColored(cyan, " SERIAL "); ImGui::SameLine(); + IsSetBit(memory->Retrieve(0xFF0F), 3) && IsSetBit(memory->Retrieve(0xFFFF), 3) ? ImGui::TextColored(green, "ON ") : ImGui::TextColored(gray, "OFF "); ImGui::SameLine(); + ImGui::TextColored(magenta, "IF:"); ImGui::SameLine(); + ImGui::Text("%d", IsSetBit(memory->Retrieve(0xFF0F), 3)); ImGui::SameLine(); + ImGui::TextColored(magenta, " IE:"); ImGui::SameLine(); + ImGui::Text("%d", IsSetBit(memory->Retrieve(0xFFFF), 3)); + + ImGui::TextColored(cyan, " JOYPAD "); ImGui::SameLine(); + IsSetBit(memory->Retrieve(0xFF0F), 4) && IsSetBit(memory->Retrieve(0xFFFF), 4) ? ImGui::TextColored(green, "ON ") : ImGui::TextColored(gray, "OFF "); ImGui::SameLine(); + ImGui::TextColored(magenta, "IF:"); ImGui::SameLine(); + ImGui::Text("%d", IsSetBit(memory->Retrieve(0xFF0F), 4)); ImGui::SameLine(); + ImGui::TextColored(magenta, " IE:"); ImGui::SameLine(); + ImGui::Text("%d", IsSetBit(memory->Retrieve(0xFFFF), 4)); + + ImGui::TextColored(yellow, "GBC:"); + + ImGui::TextColored(cyan, " $FF4D"); ImGui::SameLine(); + ImGui::TextColored(magenta, "KEY1"); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", memory->Retrieve(0xFF4D), BYTE_TO_BINARY(memory->Retrieve(0xFF4D))); + + ImGui::TextColored(cyan, " $FF70"); ImGui::SameLine(); + ImGui::TextColored(magenta, "SVBK"); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", memory->Retrieve(0xFF70), BYTE_TO_BINARY(memory->Retrieve(0xFF70))); + + ImGui::TextColored(yellow, "GBC LCD:"); + + ImGui::TextColored(cyan, " $FF68"); ImGui::SameLine(); + ImGui::TextColored(magenta, "BCPS"); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", memory->Retrieve(0xFF68), BYTE_TO_BINARY(memory->Retrieve(0xFF68))); + + ImGui::TextColored(cyan, " $FF69"); ImGui::SameLine(); + ImGui::TextColored(magenta, "BCPD"); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", memory->Retrieve(0xFF69), BYTE_TO_BINARY(memory->Retrieve(0xFF69))); + + ImGui::TextColored(cyan, " $FF6A"); ImGui::SameLine(); + ImGui::TextColored(magenta, "OCPS"); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", memory->Retrieve(0xFF6A), BYTE_TO_BINARY(memory->Retrieve(0xFF6A))); + + ImGui::TextColored(cyan, " $FF6B"); ImGui::SameLine(); + ImGui::TextColored(magenta, "OCPD"); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", memory->Retrieve(0xFF6B), BYTE_TO_BINARY(memory->Retrieve(0xFF6B))); + + ImGui::TextColored(cyan, " $FF4F"); ImGui::SameLine(); + ImGui::TextColored(magenta, "VBK "); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", memory->Retrieve(0xFF4F), BYTE_TO_BINARY(memory->Retrieve(0xFF4F))); + + ImGui::TextColored(yellow, "GBC HDMA:"); + + ImGui::TextColored(cyan, " $FF51:$FF52"); ImGui::SameLine(); + ImGui::TextColored(magenta, "SOURCE "); ImGui::SameLine(); + ImGui::Text("$%04X", (memory->Retrieve(0xFF51) << 8) | memory->Retrieve(0xFF52)); + + ImGui::TextColored(cyan, " $FF53:$FF54"); ImGui::SameLine(); + ImGui::TextColored(magenta, "DEST "); ImGui::SameLine(); + ImGui::Text("$%04X", (memory->Retrieve(0xFF53) << 8) | memory->Retrieve(0xFF54)); + + ImGui::TextColored(cyan, " $FF55"); ImGui::SameLine(); + ImGui::TextColored(magenta, "LEN "); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", memory->Retrieve(0xFF55), BYTE_TO_BINARY(memory->Retrieve(0xFF55))); + + ImGui::TextColored(yellow, "GBC INFRARED:"); + + ImGui::TextColored(cyan, " $FF56"); ImGui::SameLine(); + ImGui::TextColored(magenta, "RP "); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", memory->Retrieve(0xFF56), BYTE_TO_BINARY(memory->Retrieve(0xFF56))); + + ImGui::NextColumn(); + + ImGui::TextColored(yellow, "LCD:"); + + ImGui::TextColored(cyan, " $FF40"); ImGui::SameLine(); + ImGui::TextColored(magenta, "LCDC"); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", memory->Retrieve(0xFF40), BYTE_TO_BINARY(memory->Retrieve(0xFF40))); + + ImGui::TextColored(cyan, " $FF41"); ImGui::SameLine(); + ImGui::TextColored(magenta, "STAT"); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", memory->Retrieve(0xFF41), BYTE_TO_BINARY(memory->Retrieve(0xFF41))); + + ImGui::TextColored(cyan, " $FF42"); ImGui::SameLine(); + ImGui::TextColored(magenta, "SCY "); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", memory->Retrieve(0xFF42), BYTE_TO_BINARY(memory->Retrieve(0xFF42))); + + ImGui::TextColored(cyan, " $FF43"); ImGui::SameLine(); + ImGui::TextColored(magenta, "SCX "); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", memory->Retrieve(0xFF43), BYTE_TO_BINARY(memory->Retrieve(0xFF43))); + + ImGui::TextColored(cyan, " $FF44"); ImGui::SameLine(); + ImGui::TextColored(magenta, "LY "); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", memory->Retrieve(0xFF44), BYTE_TO_BINARY(memory->Retrieve(0xFF44))); + + ImGui::TextColored(cyan, " $FF45"); ImGui::SameLine(); + ImGui::TextColored(magenta, "LYC "); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", memory->Retrieve(0xFF45), BYTE_TO_BINARY(memory->Retrieve(0xFF45))); + + ImGui::TextColored(cyan, " $FF46"); ImGui::SameLine(); + ImGui::TextColored(magenta, "DMA "); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", memory->Retrieve(0xFF46), BYTE_TO_BINARY(memory->Retrieve(0xFF46))); + + ImGui::TextColored(cyan, " $FF47"); ImGui::SameLine(); + ImGui::TextColored(magenta, "BGP "); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", memory->Retrieve(0xFF47), BYTE_TO_BINARY(memory->Retrieve(0xFF47))); + + ImGui::TextColored(cyan, " $FF48"); ImGui::SameLine(); + ImGui::TextColored(magenta, "OBP0"); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", memory->Retrieve(0xFF48), BYTE_TO_BINARY(memory->Retrieve(0xFF48))); + + ImGui::TextColored(cyan, " $FF49"); ImGui::SameLine(); + ImGui::TextColored(magenta, "OBP1"); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", memory->Retrieve(0xFF49), BYTE_TO_BINARY(memory->Retrieve(0xFF49))); + + ImGui::TextColored(cyan, " $FF4A"); ImGui::SameLine(); + ImGui::TextColored(magenta, "WY "); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", memory->Retrieve(0xFF4A), BYTE_TO_BINARY(memory->Retrieve(0xFF4A))); + + ImGui::TextColored(cyan, " $FF4B"); ImGui::SameLine(); + ImGui::TextColored(magenta, "WX "); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", memory->Retrieve(0xFF4B), BYTE_TO_BINARY(memory->Retrieve(0xFF4B))); + + ImGui::TextColored(yellow, "TIMER:"); + + ImGui::TextColored(cyan, " $FF04"); ImGui::SameLine(); + ImGui::TextColored(magenta, "DIV "); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", memory->Retrieve(0xFF04), BYTE_TO_BINARY(memory->Retrieve(0xFF04))); + + ImGui::TextColored(cyan, " $FF05"); ImGui::SameLine(); + ImGui::TextColored(magenta, "TIMA"); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", memory->Retrieve(0xFF05), BYTE_TO_BINARY(memory->Retrieve(0xFF05))); + + ImGui::TextColored(cyan, " $FF06"); ImGui::SameLine(); + ImGui::TextColored(magenta, "TMA "); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", memory->Retrieve(0xFF06), BYTE_TO_BINARY(memory->Retrieve(0xFF06))); + + ImGui::TextColored(cyan, " $FF07"); ImGui::SameLine(); + ImGui::TextColored(magenta, "TAC "); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", memory->Retrieve(0xFF07), BYTE_TO_BINARY(memory->Retrieve(0xFF07))); + + ImGui::TextColored(yellow, "INPUT:"); + + ImGui::TextColored(cyan, " $FF00"); ImGui::SameLine(); + ImGui::TextColored(magenta, "JOYP"); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", memory->Retrieve(0xFF00), BYTE_TO_BINARY(memory->Retrieve(0xFF00))); + + ImGui::TextColored(yellow, "SERIAL:"); + + ImGui::TextColored(cyan, " $FF01"); ImGui::SameLine(); + ImGui::TextColored(magenta, "SB "); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", memory->Retrieve(0xFF01), BYTE_TO_BINARY(memory->Retrieve(0xFF01))); + + ImGui::TextColored(cyan, " $FF02"); ImGui::SameLine(); + ImGui::TextColored(magenta, "SC "); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ")", memory->Retrieve(0xFF02), BYTE_TO_BINARY(memory->Retrieve(0xFF02))); + + ImGui::Columns(1); + + ImGui::PopFont(); + + ImGui::End(); +} + +static void debug_window_vram(void) +{ + ImGui::SetNextWindowPos(ImVec2(60, 60), ImGuiCond_FirstUseEver); + ImGui::SetNextWindowSize(ImVec2(544, 534), ImGuiCond_FirstUseEver); + + ImGui::Begin("VRAM Viewer", &config_debug.show_video); + + if (ImGui::BeginTabBar("##vram_tabs", ImGuiTabBarFlags_None)) + { + if (ImGui::BeginTabItem("Background")) + { + debug_window_vram_background(); + ImGui::EndTabItem(); + } + + if (ImGui::BeginTabItem("Tiles")) + { + debug_window_vram_tiles(); + ImGui::EndTabItem(); + } + + if (ImGui::BeginTabItem("OAM")) + { + debug_window_vram_oam(); + ImGui::EndTabItem(); + } + + if (ImGui::BeginTabItem("Palettes")) + { + debug_window_vram_palettes(); + ImGui::EndTabItem(); + } + + ImGui::EndTabBar(); + } + + ImGui::End(); +} + +static void debug_window_vram_background(void) +{ + Memory* memory = emu_get_core()->GetMemory(); + + static bool show_grid = true; + static bool show_screen = true; + static int tile_address_radio = 0; + static int map_address_radio = 0; + float scale = 1.5f; + float size = 256.0f * scale; + float spacing = 8.0f * scale; + + ImGui::Checkbox("Show Grid##grid_bg", &show_grid); ImGui::SameLine(); + ImGui::Checkbox("Show Screen Rect", &show_screen); + + ImGui::PushFont(gui_default_font); + + ImGui::Columns(2, "bg", false); + ImGui::SetColumnOffset(1, size + 10.0f); + + ImVec2 p = ImGui::GetCursorScreenPos(); + ImDrawList* draw_list = ImGui::GetWindowDrawList(); + ImGuiIO& io = ImGui::GetIO(); + + ImGui::Image((void*)(intptr_t)renderer_emu_debug_vram_background, ImVec2(size, size)); + + if (show_grid) + { + float x = p.x; + for (int n = 0; n <= 32; n++) + { + draw_list->AddLine(ImVec2(x, p.y), ImVec2(x, p.y + size), ImColor(dark_gray), 1.0f); + x += spacing; + } + + float y = p.y; + for (int n = 0; n <= 32; n++) + { + draw_list->AddLine(ImVec2(p.x, y), ImVec2(p.x + size, y), ImColor(dark_gray), 1.0f); + y += spacing; + } + } + + if (show_screen) + { + u8 scroll_x = memory->Retrieve(0xFF43); + u8 scroll_y = memory->Retrieve(0xFF42); + + float grid_x_max = p.x + size; + float grid_y_max = p.y + size; + + float rect_x_min = p.x + (scroll_x * scale); + float rect_y_min = p.y + (scroll_y * scale); + float rect_x_max = p.x + ((scroll_x + GAMEBOY_WIDTH) * scale); + float rect_y_max = p.y + ((scroll_y + GAMEBOY_HEIGHT) * scale); + + float x_overflow = 0.0f; + float y_overflow = 0.0f; + + if (rect_x_max > grid_x_max) + x_overflow = rect_x_max - grid_x_max; + if (rect_y_max > grid_y_max) + y_overflow = rect_y_max - grid_y_max; + + draw_list->AddLine(ImVec2(rect_x_min, rect_y_min), ImVec2(fminf(rect_x_max, grid_x_max), rect_y_min), ImColor(green), 2.0f); + if (x_overflow > 0.0f) + draw_list->AddLine(ImVec2(p.x, rect_y_min), ImVec2(p.x + x_overflow, rect_y_min), ImColor(green), 2.0f); + + draw_list->AddLine(ImVec2(rect_x_min, rect_y_min), ImVec2(rect_x_min, fminf(rect_y_max, grid_y_max)), ImColor(green), 2.0f); + if (y_overflow > 0.0f) + draw_list->AddLine(ImVec2(rect_x_min, p.y), ImVec2(rect_x_min, p.y + y_overflow), ImColor(green), 2.0f); + + draw_list->AddLine(ImVec2(rect_x_min, (y_overflow > 0.0f) ? p.y + y_overflow : rect_y_max), ImVec2(fminf(rect_x_max, grid_x_max), (y_overflow > 0.0f) ? p.y + y_overflow : rect_y_max), ImColor(green), 2.0f); + if (x_overflow > 0.0f) + draw_list->AddLine(ImVec2(p.x, (y_overflow > 0.0f) ? p.y + y_overflow : rect_y_max), ImVec2(p.x + x_overflow, (y_overflow > 0.0f) ? p.y + y_overflow : rect_y_max), ImColor(green), 2.0f); + + draw_list->AddLine(ImVec2((x_overflow > 0.0f) ? p.x + x_overflow : rect_x_max, rect_y_min), ImVec2((x_overflow > 0.0f) ? p.x + x_overflow : rect_x_max, fminf(rect_y_max, grid_y_max)), ImColor(green), 2.0f); + if (y_overflow > 0.0f) + draw_list->AddLine(ImVec2((x_overflow > 0.0f) ? p.x + x_overflow : rect_x_max, p.y), ImVec2((x_overflow > 0.0f) ? p.x + x_overflow : rect_x_max, p.y + y_overflow), ImColor(green), 2.0f); + } + + float mouse_x = io.MousePos.x - p.x; + float mouse_y = io.MousePos.y - p.y; + + int tile_x = -1; + int tile_y = -1; + if ((mouse_x >= 0.0f) && (mouse_x < size) && (mouse_y >= 0.0f) && (mouse_y < size)) + { + tile_x = (int)(mouse_x / spacing); + tile_y = (int)(mouse_y / spacing); + + draw_list->AddRect(ImVec2(p.x + (tile_x * spacing), p.y + (tile_y * spacing)), ImVec2(p.x + ((tile_x + 1) * spacing), p.y + ((tile_y + 1) * spacing)), ImColor(cyan), 2.0f, 15, 2.0f); + + ImGui::NextColumn(); + + ImGui::Image((void*)(intptr_t)renderer_emu_debug_vram_background, ImVec2(128.0f, 128.0f), ImVec2((1.0f / 32.0f) * tile_x, (1.0f / 32.0f) * tile_y), ImVec2((1.0f / 32.0f) * (tile_x + 1), (1.0f / 32.0f) * (tile_y + 1))); + + ImGui::TextColored(yellow, "DMG:"); + + ImGui::TextColored(cyan, " X:"); ImGui::SameLine(); + ImGui::Text("$%02X", tile_x); ImGui::SameLine(); + ImGui::TextColored(cyan, " Y:"); ImGui::SameLine(); + ImGui::Text("$%02X", tile_y); + + u8 lcdc = memory->Retrieve(0xFF40); + + int tile_start_addr = emu_debug_background_tile_address >= 0 ? emu_debug_background_tile_address : IsSetBit(lcdc, 4) ? 0x8000 : 0x8800; + int map_start_addr = emu_debug_background_map_address >= 0 ? emu_debug_background_map_address : IsSetBit(lcdc, 3) ? 0x9C00 : 0x9800; + + u16 map_addr = map_start_addr + (32 * tile_y) + tile_x; + + ImGui::TextColored(cyan, " Map Addr: "); ImGui::SameLine(); + ImGui::Text("$%04X", map_addr); + + int map_tile = 0; + + if (tile_start_addr == 0x8800) + { + map_tile = static_cast<s8> (memory->Retrieve(map_addr)); + map_tile += 128; + } + else + { + map_tile = memory->Retrieve(map_addr); + } + + ImGui::TextColored(cyan, " Tile Addr:"); ImGui::SameLine(); + ImGui::Text("$%04X", tile_start_addr + (map_tile << 4)); + ImGui::TextColored(cyan, " Tile Number:"); ImGui::SameLine(); + ImGui::Text("$%02X", memory->Retrieve(map_addr)); + + if (emu_is_cgb()) + { + ImGui::TextColored(yellow, "GBC:"); + + u8 cgb_tile_attr = memory->ReadCGBLCDRAM(map_addr, true); + int cgb_tile_pal = cgb_tile_attr & 0x07; + int cgb_tile_bank = IsSetBit(cgb_tile_attr, 3) ? 1 : 0; + bool cgb_tile_xflip = IsSetBit(cgb_tile_attr, 5); + bool cgb_tile_yflip = IsSetBit(cgb_tile_attr, 6); + + ImGui::TextColored(cyan, " Attributes:"); ImGui::SameLine(); + ImGui::Text("$%02X", cgb_tile_attr); + ImGui::TextColored(cyan, " Palette:"); ImGui::SameLine(); + ImGui::Text("%d", cgb_tile_pal); + ImGui::TextColored(cyan, " Bank:"); ImGui::SameLine(); + ImGui::Text("%d", cgb_tile_bank); + + ImGui::TextColored(cyan, " X-Flip:"); ImGui::SameLine(); + cgb_tile_xflip ? ImGui::TextColored(green, "ON") : ImGui::TextColored(gray, "OFF"); + + ImGui::TextColored(cyan, " Y-Flip:"); ImGui::SameLine(); + cgb_tile_yflip ? ImGui::TextColored(green, "ON") : ImGui::TextColored(gray, "OFF"); + } + } + + ImGui::Columns(1); + + ImGui::PopFont(); + + ImGui::Text("Tile address:"); ImGui::SameLine(); + ImGui::RadioButton("Auto##tile", &tile_address_radio, 0); ImGui::SameLine(); + ImGui::RadioButton("0x8000", &tile_address_radio, 1); ImGui::SameLine(); + ImGui::RadioButton("0x8800", &tile_address_radio, 2); + + switch (tile_address_radio) + { + case 0: + emu_debug_background_tile_address = -1; + break; + case 1: + emu_debug_background_tile_address = 0x8000; + break; + case 2: + emu_debug_background_tile_address = 0x8800; + break; + default: + emu_debug_background_tile_address = -1; + break; + } + + ImGui::Text("Map address:"); ImGui::SameLine(); + ImGui::RadioButton("Auto##map", &map_address_radio, 0); ImGui::SameLine(); + ImGui::RadioButton("0x9C00", &map_address_radio, 1); ImGui::SameLine(); + ImGui::RadioButton("0x9800", &map_address_radio, 2); + + switch (map_address_radio) + { + case 0: + emu_debug_background_map_address = -1; + break; + case 1: + emu_debug_background_map_address = 0x9C00; + break; + case 2: + emu_debug_background_map_address = 0x9800; + break; + default: + emu_debug_background_map_address = -1; + break; + } +} + +static void debug_window_vram_tiles(void) +{ + static bool show_grid = true; + float scale = 1.5f; + float width = 8.0f * 16.0f * scale; + float height = 8.0f * 24.0f * scale; + float spacing = 8.0f * scale; + ImDrawList* draw_list = ImGui::GetWindowDrawList(); + ImGuiIO& io = ImGui::GetIO(); + ImVec2 p[2]; + + ImGui::Checkbox("Show Grid##grid_tiles", &show_grid); + ImGui::SameLine(150.0f); + + ImGui::PushItemWidth(80.0f); + + if (!emu_is_cgb()) + { + ImGui::Combo("Palette##dmg_tile_palette", &emu_debug_tile_dmg_palette, "BGP\0OBP0\0OBP1\0\0"); + } + else + { + ImGui::Combo("Palette##cgb_tile_palette", &emu_debug_tile_color_palette, "BCP0\0BCP1\0BCP2\0BCP3\0BCP4\0BCP5\0BCP6\0BCP7\0OCP0\0OCP1\0OCP2\0OCP3\0OCP4\0OCP5\0OCP6\0OCP7\0\0"); + } + + ImGui::PopItemWidth(); + + ImGui::Columns(2, "bg", false); + ImGui::SetColumnOffset(1, (width * 2.0f) + 16.0f); + + p[0] = ImGui::GetCursorScreenPos(); + + ImGui::Image((void*)(intptr_t)renderer_emu_debug_vram_tiles[0], ImVec2(width, height)); + + ImGui::SameLine(); + + p[1] = ImGui::GetCursorScreenPos(); + + ImGui::Image((void*)(intptr_t)renderer_emu_debug_vram_tiles[1], ImVec2(width, height)); + + for (int i = 0; i < 2; i++) + { + if (show_grid) + { + float x = p[i].x; + for (int n = 0; n <= 16; n++) + { + draw_list->AddLine(ImVec2(x, p[i].y), ImVec2(x, p[i].y + height), ImColor(dark_gray), 1.0f); + x += spacing; + } + + float y = p[i].y; + for (int n = 0; n <= 24; n++) + { + draw_list->AddLine(ImVec2(p[i].x, y), ImVec2(p[i].x + width, y), ImColor(dark_gray), ((n == 8) || (n == 16)) ? 3.0f : 1.0f); + y += spacing; + } + } + } + + for (int i = 0; i < 2; i++) + { + float mouse_x = io.MousePos.x - p[i].x; + float mouse_y = io.MousePos.y - p[i].y; + + int tile_x = -1; + int tile_y = -1; + + if ((mouse_x >= 0.0f) && (mouse_x < width) && (mouse_y >= 0.0f) && (mouse_y < height)) + { + tile_x = (int)(mouse_x / spacing); + tile_y = (int)(mouse_y / spacing); + + draw_list->AddRect(ImVec2(p[i].x + (tile_x * spacing), p[i].y + (tile_y * spacing)), ImVec2(p[i].x + ((tile_x + 1) * spacing), p[i].y + ((tile_y + 1) * spacing)), ImColor(cyan), 2.0f, 15, 2.0f); + + ImGui::NextColumn(); + + ImGui::Image((void*)(intptr_t)renderer_emu_debug_vram_tiles[i], ImVec2(128.0f, 128.0f), ImVec2((1.0f / 16.0f) * tile_x, (1.0f / 24.0f) * tile_y), ImVec2((1.0f / 16.0f) * (tile_x + 1), (1.0f / 24.0f) * (tile_y + 1))); + + ImGui::PushFont(gui_default_font); + + ImGui::TextColored(yellow, "DETAILS:"); + + int tile_full = (tile_y << 4) + tile_x; + int tile = tile_full & 0xFF; + + ImGui::TextColored(cyan, " Tile Number:"); ImGui::SameLine(); + ImGui::Text("$%02X", tile); + ImGui::TextColored(cyan, " Tile Addr:"); ImGui::SameLine(); + ImGui::Text("$%04X", 0x8000 + (tile_full << 4)); + + ImGui::PopFont(); + } + } + + ImGui::Columns(1); +} + +static void debug_window_vram_oam(void) +{ + float scale = 5.0f; + float width = 8.0f * scale; + float height_8 = 8.0f * scale; + float height_16 = 16.0f * scale; + + GearboyCore* core = emu_get_core(); + Memory* memory = core->GetMemory(); + + ImVec2 p[40]; + + ImGuiIO& io = ImGui::GetIO(); + + u8 lcdc = memory->Retrieve(0xFF40); + bool sprites_16 = IsSetBit(lcdc, 2); + + ImGui::PushFont(gui_default_font); + + ImGui::Columns(2, "oam", false); + ImGui::SetColumnOffset(1, 280.0f); + + ImGui::BeginChild("sprites", ImVec2(0, 0), true); + + for (int s = 0; s < 40; s++) + { + p[s] = ImGui::GetCursorScreenPos(); + + ImGui::Image((void*)(intptr_t)renderer_emu_debug_vram_oam[s], ImVec2(width, sprites_16 ? height_16 : height_8), ImVec2(0.0f, 0.0f), ImVec2(1.0f, sprites_16 ? 1.0f : 0.5f)); + + float mouse_x = io.MousePos.x - p[s].x; + float mouse_y = io.MousePos.y - p[s].y; + + if ((mouse_x >= 0.0f) && (mouse_x < width) && (mouse_y >= 0.0f) && (mouse_y < (sprites_16 ? height_16 : height_8))) + { + ImDrawList* draw_list = ImGui::GetWindowDrawList(); + draw_list->AddRect(ImVec2(p[s].x, p[s].y), ImVec2(p[s].x + width, p[s].y + (sprites_16 ? height_16 : height_8)), ImColor(cyan), 2.0f, 15, 3.0f); + } + + if (s % 5 < 4) + ImGui::SameLine(); + } + + ImGui::EndChild(); + + ImGui::NextColumn(); + + ImVec2 p_screen = ImGui::GetCursorScreenPos(); + + float screen_scale = 1.5f; + + ImGui::Image((void*)(intptr_t)renderer_emu_texture, ImVec2(GAMEBOY_WIDTH * screen_scale, GAMEBOY_HEIGHT * screen_scale)); + + for (int s = 0; s < 40; s++) + { + if ((p[s].x == 0) && (p[s].y == 0)) + continue; + + float mouse_x = io.MousePos.x - p[s].x; + float mouse_y = io.MousePos.y - p[s].y; + + if ((mouse_x >= 0.0f) && (mouse_x < width) && (mouse_y >= 0.0f) && (mouse_y < (sprites_16 ? height_16 : height_8))) + { + u16 address = 0xFE00 + (4 * s); + + u8 y = memory->Retrieve(address); + u8 x = memory->Retrieve(address + 1); + u8 tile = memory->Retrieve(address + 2); + u8 flags = memory->Retrieve(address + 3); + int palette = IsSetBit(flags, 4) ? 1 : 0; + bool xflip = IsSetBit(flags, 5); + bool yflip = IsSetBit(flags, 6); + bool priority = !IsSetBit(flags, 7); + bool cgb_bank = IsSetBit(flags, 3); + int cgb_pal = flags & 0x07; + + float real_x = x - 8.0f; + float real_y = y - 16.0f; + float rectx_min = p_screen.x + (real_x * screen_scale); + float rectx_max = p_screen.x + ((real_x + 8.0f) * screen_scale); + float recty_min = p_screen.y + (real_y * screen_scale); + float recty_max = p_screen.y + ((real_y + (sprites_16 ? 16.0f : 8.0f)) * screen_scale); + + rectx_min = fminf(fmaxf(rectx_min, p_screen.x), p_screen.x + (GAMEBOY_WIDTH * screen_scale)); + rectx_max = fminf(fmaxf(rectx_max, p_screen.x), p_screen.x + (GAMEBOY_WIDTH * screen_scale)); + recty_min = fminf(fmaxf(recty_min, p_screen.y), p_screen.y + (GAMEBOY_HEIGHT * screen_scale)); + recty_max = fminf(fmaxf(recty_max, p_screen.y), p_screen.y + (GAMEBOY_HEIGHT * screen_scale)); + + ImDrawList* draw_list = ImGui::GetWindowDrawList(); + draw_list->AddRect(ImVec2(rectx_min, recty_min), ImVec2(rectx_max, recty_max), ImColor(cyan), 2.0f, 15, 2.0f); + + ImGui::TextColored(yellow, "DETAILS:"); + ImGui::TextColored(cyan, " X:"); ImGui::SameLine(); + ImGui::Text("$%02X", x); ImGui::SameLine(); + ImGui::TextColored(cyan, " Y:"); ImGui::SameLine(); + ImGui::Text("$%02X", y); ImGui::SameLine(); + + ImGui::TextColored(cyan, " Tile:"); ImGui::SameLine(); + ImGui::Text("$%02X", tile); + + ImGui::TextColored(cyan, " Tile Addr:"); ImGui::SameLine(); + ImGui::Text("$%04X", 0x8000 + (tile * 16)); ImGui::SameLine(); + + ImGui::TextColored(cyan, " Bank:"); ImGui::SameLine(); + ImGui::Text("%d", cgb_bank); + + ImGui::TextColored(cyan, " OAM Addr:"); ImGui::SameLine(); + ImGui::Text("$%04X", address); ImGui::SameLine(); + + + ImGui::TextColored(cyan, " Flags:"); ImGui::SameLine(); + ImGui::Text("$%02X", flags); + + ImGui::TextColored(cyan, " Priority:"); ImGui::SameLine(); + priority ? ImGui::TextColored(green, "ON ") : ImGui::TextColored(gray, "OFF"); ImGui::SameLine(); + + ImGui::TextColored(cyan, " Palette:"); ImGui::SameLine(); + ImGui::Text("%d", emu_is_cgb() ? cgb_pal : palette); + + ImGui::TextColored(cyan, " X-Flip:"); ImGui::SameLine(); + xflip ? ImGui::TextColored(green, "ON ") : ImGui::TextColored(gray, "OFF"); ImGui::SameLine(); + + ImGui::TextColored(cyan, " Y-Flip:"); ImGui::SameLine(); + yflip ? ImGui::TextColored(green, "ON") : ImGui::TextColored(gray, "OFF"); + } + } + + ImGui::Columns(1); + + ImGui::PopFont(); +} + +static void debug_window_vram_palettes(void) +{ + GearboyCore* core = emu_get_core(); + Video* video = core->GetVideo(); + Memory* memory = core->GetMemory(); + u16* palette = core->GetDMGInternalPalette(); + + ImGui::PushFont(gui_default_font); + + ImGui::TextColored(yellow, "DMG:"); ImGui::SameLine(); + ImGui::TextColored(cyan, " 0 1 2 3"); + + u8 bgp = memory->Retrieve(0xFF47); + u8 obp0 = memory->Retrieve(0xFF48); + u8 obp1 = memory->Retrieve(0xFF49); + + ImGui::TextColored(cyan, " $FF47"); ImGui::SameLine(); + ImGui::TextColored(magenta, "BGP "); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ") ", bgp, BYTE_TO_BINARY(bgp)); ImGui::SameLine(); + + for (int i = 0; i < 4; i++) + { + int index = (bgp >> (i * 2)) & 0x03; + int color = palette[index]; + ImVec4 float_color = color_565_to_float(color); + char id[16]; + sprintf(id, "##dmg_bg_%d", i); + ImGui::ColorEdit3(id, (float*)&float_color, ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_NoPicker); ImGui::SameLine(); + ImGui::Text("%d ", index); + if (i < 3) + ImGui::SameLine(); + } + + ImGui::TextColored(cyan, " $FF48"); ImGui::SameLine(); + ImGui::TextColored(magenta, "OBP0"); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ") ", obp0, BYTE_TO_BINARY(obp0)); ImGui::SameLine(); + + for (int i = 0; i < 4; i++) + { + int index = (obp0 >> (i * 2)) & 0x03; + int color = palette[index]; + ImVec4 float_color = color_565_to_float(color); + char id[16]; + sprintf(id, "##dmg_bg_%d", i); + ImGui::ColorEdit3(id, (float*)&float_color, ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_NoPicker); ImGui::SameLine(); + ImGui::Text("%d ", index); + if (i < 3) + ImGui::SameLine(); + } + + ImGui::TextColored(cyan, " $FF49"); ImGui::SameLine(); + ImGui::TextColored(magenta, "OBP1"); ImGui::SameLine(); + ImGui::Text("$%02X (" BYTE_TO_BINARY_PATTERN_SPACED ") ", obp1, BYTE_TO_BINARY(obp1)); ImGui::SameLine(); + + for (int i = 0; i < 4; i++) + { + int index = (obp1 >> (i * 2)) & 0x03; + int color = palette[index]; + ImVec4 float_color = color_565_to_float(color); + char id[16]; + sprintf(id, "##dmg_bg_%d", i); + ImGui::ColorEdit3(id, (float*)&float_color, ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_NoPicker); ImGui::SameLine(); + ImGui::Text("%d ", index); + if (i < 3) + ImGui::SameLine(); + } + + ImGui::Text(" "); + + PaletteMatrix bg_palettes = video->GetCGBBackgroundPalettes(); + PaletteMatrix sprite_palettes = video->GetCGBSpritePalettes(); + + ImGui::Columns(2, "palettes"); + + ImGui::TextColored(yellow, "GBC BACKGROUND:"); + + ImGui::NextColumn(); + + ImGui::TextColored(yellow, "GBC SPRITES:"); + + ImGui::NextColumn(); + + ImGui::Separator(); + + for (int p = 0; p < 8; p++) + { + ImGui::TextColored(cyan, " %d ", p); ImGui::SameLine(); + + for (int c = 0; c < 4; c++) + { + u16 color = (*bg_palettes)[p][c][1]; + ImVec4 float_color = color_565_to_float(color); + char id[16]; + sprintf(id, "##cgb_bg_%d_%d", p, c); + ImGui::ColorEdit3(id, (float*)&float_color, ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_NoPicker); + if (c < 3) + { + ImGui::SameLine(); ImGui::Dummy(ImVec2(8.0f, 0.0f)); + ImGui::SameLine(); + } + } + + ImGui::Text(" "); ImGui::SameLine(); + + for (int c = 0; c < 4; c++) + { + u16 color = (*bg_palettes)[p][c][1]; + ImGui::Text("%04X ", color); + if (c < 3) + ImGui::SameLine(); + } + } + + ImGui::NextColumn(); + + for (int p = 0; p < 8; p++) + { + ImGui::TextColored(cyan, " %d ", p); ImGui::SameLine(); + + for (int c = 0; c < 4; c++) + { + u16 color = (*sprite_palettes)[p][c][1]; + ImVec4 float_color = color_565_to_float(color); + char id[16]; + sprintf(id, "##cgb_bg_%d_%d", p, c); + ImGui::ColorEdit3(id, (float*)&float_color, ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_NoPicker); + if (c < 3) + { + ImGui::SameLine(); ImGui::Dummy(ImVec2(8.0f, 0.0f)); + ImGui::SameLine(); + } + } + + ImGui::Text(" "); ImGui::SameLine(); + + for (int c = 0; c < 4; c++) + { + u16 color = (*sprite_palettes)[p][c][1]; + ImGui::Text("%04X ", color); + if (c < 3) + ImGui::SameLine(); + } + } + + ImGui::Columns(1); + + ImGui::PopFont(); +} + +static void add_symbol(const char* line) +{ + Log("Loading symbol %s", line); + + DebugSymbol s; + + std::string str(line); + + str.erase(std::remove(str.begin(), str.end(), '\r'), str.end()); + str.erase(std::remove(str.begin(), str.end(), '\n'), str.end()); + + size_t first = str.find_first_not_of(' '); + if (std::string::npos == first) + { + str = ""; + } + else + { + size_t last = str.find_last_not_of(' '); + str = str.substr(first, (last - first + 1)); + } + + std::size_t comment = str.find(";"); + + if (comment != std::string::npos) + str = str.substr(0 , comment); + + std::size_t space = str.find(" "); + + if (space != std::string::npos) + { + s.text = str.substr(space + 1 , std::string::npos); + str = str.substr(0, space); + + std::size_t separator = str.find(":"); + + try + { + if (separator != std::string::npos) + { + s.address = (u16)std::stoul(str.substr(separator + 1 , std::string::npos), 0, 16); + s.bank = std::stoul(str.substr(0, separator), 0 , 16); + } + else + { + s.address = (u16)std::stoul(str, 0, 16); + s.bank = 0; + } + + symbols.push_back(s); + } + catch(const std::invalid_argument&) + { + } + } +} + +static void add_breakpoint_cpu(void) +{ + int input_len = (int)strlen(brk_address_cpu); + u16 target_address = 0; + int target_bank = 0; + int target_offset = 0; + + try + { + if ((input_len == 7) && (brk_address_cpu[2] == ':')) + { + std::string str(brk_address_cpu); + std::size_t separator = str.find(":"); + + if (separator != std::string::npos) + { + target_address = (u16)std::stoul(str.substr(separator + 1 , std::string::npos), 0, 16); + + target_bank = std::stoul(str.substr(0, separator), 0 , 16); + target_bank &= 0xFF; + } + } + else if (input_len == 4) + { + target_bank = 0; + target_address = (u16)std::stoul(brk_address_cpu, 0, 16); + } + else + { + return; + } + } + catch(const std::invalid_argument&) + { + return; + } + + Memory::stDisassembleRecord** memoryMap = emu_get_core()->GetMemory()->GetDisassembledMemoryMap(); + Memory::stDisassembleRecord** romMap = emu_get_core()->GetMemory()->GetDisassembledROMMemoryMap(); + Memory::stDisassembleRecord** map = NULL; + + bool rom = true; + + if ((target_address & 0xC000) == 0x0000) + { + target_offset = (0x4000 * target_bank) + target_address; + map = romMap; + } + else if ((target_address & 0xC000) == 0x4000) + { + target_offset = (0x4000 * target_bank) + (target_address & 0x3FFF); + map = romMap; + } + else + { + target_offset = target_address; + map = memoryMap; + rom = false; + } + + brk_address_cpu[0] = 0; + + bool found = false; + std::vector<Memory::stDisassembleRecord*>* breakpoints = emu_get_core()->GetMemory()->GetBreakpointsCPU(); + + if (IsValidPointer(map[target_offset])) + { + for (long unsigned int b = 0; b < breakpoints->size(); b++) + { + if ((*breakpoints)[b] == map[target_offset]) + { + found = true; + break; + } + } + } + + if (!found) + { + if (!IsValidPointer(map[target_offset])) + { + map[target_offset] = new Memory::stDisassembleRecord; + + if (rom) + { + map[target_offset]->address = target_offset & 0x3FFF; + map[target_offset]->bank = target_offset >> 14; + } + else + { + map[target_offset]->address = 0; + map[target_offset]->bank = 0; + } + + map[target_offset]->name[0] = 0; + map[target_offset]->bytes[0] = 0; + map[target_offset]->size = 0; + map[target_offset]->jump = false; + map[target_offset]->jump_address = 0; + for (int i = 0; i < 4; i++) + map[target_offset]->opcodes[i] = 0; + } + + breakpoints->push_back(map[target_offset]); + } +} + +static void add_breakpoint_mem(void) +{ + int input_len = (int)strlen(brk_address_mem); + u16 address1 = 0; + u16 address2 = 0; + bool range = false; + + try + { + if ((input_len == 9) && (brk_address_mem[4] == '-')) + { + std::string str(brk_address_mem); + std::size_t separator = str.find("-"); + + if (separator != std::string::npos) + { + address1 = (u16)std::stoul(str.substr(0, separator), 0 , 16); + address2 = (u16)std::stoul(str.substr(separator + 1 , std::string::npos), 0, 16); + range = true; + } + } + else if (input_len == 4) + { + address1 = (u16)std::stoul(brk_address_mem, 0, 16); + } + else + { + return; + } + } + catch(const std::invalid_argument&) + { + return; + } + + bool found = false; + std::vector<Memory::stMemoryBreakpoint>* breakpoints = emu_get_core()->GetMemory()->GetBreakpointsMem(); + + for (long unsigned int b = 0; b < breakpoints->size(); b++) + { + Memory::stMemoryBreakpoint temp = (*breakpoints)[b]; + if ((temp.address1 == address1) && (temp.address2 == address2) && (temp.range == range)) + { + found = true; + break; + } + } + + if (!found) + { + Memory::stMemoryBreakpoint new_breakpoint; + new_breakpoint.address1 = address1; + new_breakpoint.address2 = address2; + new_breakpoint.range = range; + new_breakpoint.read = brk_new_mem_read; + new_breakpoint.write = brk_new_mem_write; + + breakpoints->push_back(new_breakpoint); + } + + brk_address_mem[0] = 0; +} + +static void request_goto_address(u16 address) +{ + goto_address_requested = true; + goto_address_target = address; +} + +static ImVec4 color_565_to_float(u16 color) +{ + ImVec4 ret; + ret.w = 0; + ret.x = (1.0f / 31.0f) * ((color >> 11) & 0x1F); + ret.y = (1.0f / 63.0f) * ((color >> 5) & 0x3F); + ret.z = (1.0f / 31.0f) * (color & 0x1F); + return ret; +} |