diff options
Diffstat (limited to 'gearboy/platforms/desktop-shared/gui.cpp')
| -rw-r--r-- | gearboy/platforms/desktop-shared/gui.cpp | 1446 |
1 files changed, 1446 insertions, 0 deletions
diff --git a/gearboy/platforms/desktop-shared/gui.cpp b/gearboy/platforms/desktop-shared/gui.cpp new file mode 100644 index 00000000..6e5a671b --- /dev/null +++ b/gearboy/platforms/desktop-shared/gui.cpp @@ -0,0 +1,1446 @@ +/* + * 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 "imgui/imgui.h" +#include "imgui/imgui_memory_editor.h" +#include "imgui/fonts/RobotoMedium.h" +#include "FileBrowser/ImGuiFileBrowser.h" +#include "config.h" +#include "emu.h" +#include "../../src/gearboy.h" +#include "renderer.h" +#include "application.h" +#include "license.h" +#include "backers.h" +#include "gui_debug.h" + +#define GUI_IMPORT +#include "gui.h" + +static imgui_addons::ImGuiFileBrowser file_dialog; +static int main_menu_height; +static bool dialog_in_use = false; +static SDL_Scancode* configured_key; +static int* configured_button; +static ImVec4 custom_palette[config_max_custom_palettes][4]; +static std::list<std::string> cheat_list; +static bool shortcut_open_rom = false; +static ImFont* default_font[4]; +static char dmg_bootrom_path[4096] = ""; +static char gbc_bootrom_path[4096] = ""; +static char savefiles_path[4096] = ""; +static char savestates_path[4096] = ""; +static bool show_main_menu = true; + +static void main_menu(void); +static void main_window(void); +static void file_dialog_open_rom(void); +static void file_dialog_load_ram(void); +static void file_dialog_save_ram(void); +static void file_dialog_load_state(void); +static void file_dialog_save_state(void); +static void file_dialog_choose_save_file_path(void); +static void file_dialog_choose_savestate_path(void); +static void file_dialog_load_dmg_bootrom(void); +static void file_dialog_load_gbc_bootrom(void); +static void file_dialog_load_symbols(void); +static void keyboard_configuration_item(const char* text, SDL_Scancode* key); +static void gamepad_configuration_item(const char* text, int* button); +static void popup_modal_keyboard(void); +static void popup_modal_gamepad(void); +static void popup_modal_about(void); +static GB_Color color_float_to_int(ImVec4 color); +static ImVec4 color_int_to_float(GB_Color color); +static void update_palette(void); +static void push_recent_rom(std::string path); +static void menu_reset(void); +static void menu_pause(void); +static void menu_ffwd(void); +static void show_info(void); +static void show_fps(void); +static Cartridge::CartridgeTypes get_mbc(int index); + +void gui_init(void) +{ + IMGUI_CHECKVERSION(); + ImGui::CreateContext(); + ImGui::StyleColorsDark(); + ImGuiIO& io = ImGui::GetIO(); + + io.IniFilename = config_imgui_file_path; + + io.FontGlobalScale /= application_display_scale; + + gui_roboto_font = io.Fonts->AddFontFromMemoryCompressedTTF(RobotoMedium_compressed_data, RobotoMedium_compressed_size, 17.0f * application_display_scale, NULL, io.Fonts->GetGlyphRangesCyrillic()); + + ImFontConfig font_cfg; + + for (int i = 0; i < 4; i++) + { + font_cfg.SizePixels = (13.0f + (i * 3)) * application_display_scale; + default_font[i] = io.Fonts->AddFontDefault(&font_cfg); + } + + gui_default_font = default_font[config_debug.font_size]; + + update_palette(); + + emu_audio_volume(config_audio.enable ? 1.0f: 0.0f); + emu_color_correction(config_video.color_correction); + + strcpy(dmg_bootrom_path, config_emulator.dmg_bootrom_path.c_str()); + strcpy(gbc_bootrom_path, config_emulator.gbc_bootrom_path.c_str()); + strcpy(savefiles_path, config_emulator.savefiles_path.c_str()); + strcpy(savestates_path, config_emulator.savestates_path.c_str()); + + if (strlen(dmg_bootrom_path) > 0) + emu_load_bootrom_dmg(dmg_bootrom_path); + if (strlen(gbc_bootrom_path) > 0) + emu_load_bootrom_gbc(gbc_bootrom_path); + + emu_enable_bootrom_dmg(config_emulator.dmg_bootrom); + emu_enable_bootrom_gbc(config_emulator.gbc_bootrom); +} + +void gui_destroy(void) +{ + ImGui::DestroyContext(); +} + +void gui_render(void) +{ + ImGui::NewFrame(); + + gui_in_use = dialog_in_use; + + main_menu(); + + if((!config_debug.debug && !emu_is_empty()) || (config_debug.debug && config_debug.show_gameboy)) + main_window(); + + gui_debug_windows(); + + ImGui::Render(); +} + +void gui_shortcut(gui_ShortCutEvent event) +{ + switch (event) + { + case gui_ShortcutOpenROM: + shortcut_open_rom = true; + break; + case gui_ShortcutReset: + menu_reset(); + break; + case gui_ShortcutPause: + menu_pause(); + break; + case gui_ShortcutFFWD: + config_emulator.ffwd = !config_emulator.ffwd; + menu_ffwd(); + break; + case gui_ShortcutSaveState: + emu_save_state_slot(config_emulator.save_slot + 1); + break; + case gui_ShortcutLoadState: + emu_load_state_slot(config_emulator.save_slot + 1); + break; + case gui_ShortcutDebugStep: + if (config_debug.debug) + emu_debug_step(); + break; + case gui_ShortcutDebugContinue: + if (config_debug.debug) + emu_debug_continue(); + break; + case gui_ShortcutDebugNextFrame: + if (config_debug.debug) + emu_debug_next_frame(); + break; + case gui_ShortcutDebugBreakpoint: + if (config_debug.debug) + gui_debug_toggle_breakpoint(); + break; + case gui_ShortcutDebugRuntocursor: + if (config_debug.debug) + gui_debug_runtocursor(); + break; + case gui_ShortcutDebugGoBack: + if (config_debug.debug) + gui_debug_go_back(); + break; + case gui_ShortcutShowMainMenu: + show_main_menu = !show_main_menu; + break; + default: + break; + } +} + +void gui_load_rom(const char* path) +{ + push_recent_rom(path); + emu_resume(); + emu_load_rom(path, config_emulator.force_dmg, get_mbc(config_emulator.mbc), config_emulator.force_gba); + cheat_list.clear(); + emu_clear_cheats(); + + gui_debug_reset(); + + std::string str(path); + str = str.substr(0, str.find_last_of(".")); + str += ".sym"; + gui_debug_load_symbols_file(str.c_str()); + + if (config_emulator.start_paused) + { + emu_pause(); + + for (int i=0; i < (GAMEBOY_WIDTH * GAMEBOY_HEIGHT); i++) + { + emu_frame_buffer[i].red = 0; + emu_frame_buffer[i].green = 0; + emu_frame_buffer[i].blue = 0; + } + } +} + +static void main_menu(void) +{ + bool open_rom = false; + bool open_ram = false; + bool save_ram = false; + bool open_state = false; + bool save_state = false; + bool open_about = false; + bool open_symbols = false; + bool choose_save_file_path = false; + bool choose_savestates_path = false; + bool open_dmg_bootrom = false; + bool open_gbc_bootrom = false; + + for (int i = 0; i < config_max_custom_palettes; i++) + for (int c = 0; c < 4; c++) + custom_palette[i][c] = color_int_to_float(config_video.color[i][c]); + + if (show_main_menu && ImGui::BeginMainMenuBar()) + { + if (ImGui::BeginMenu(GEARBOY_TITLE)) + { + gui_in_use = true; + + if (ImGui::MenuItem("Open ROM...", "Ctrl+O")) + { + open_rom = true; + } + + if (ImGui::BeginMenu("Open Recent")) + { + for (int i = 0; i < config_max_recent_roms; i++) + { + if (config_emulator.recent_roms[i].length() > 0) + { + if (ImGui::MenuItem(config_emulator.recent_roms[i].c_str())) + { + char rom_path[4096]; + strcpy(rom_path, config_emulator.recent_roms[i].c_str()); + gui_load_rom(rom_path); + } + } + } + + ImGui::EndMenu(); + } + + ImGui::Separator(); + + if (ImGui::MenuItem("Reset", "Ctrl+R")) + { + menu_reset(); + } + + if (ImGui::MenuItem("Pause", "Ctrl+P", &config_emulator.paused)) + { + menu_pause(); + } + + ImGui::Separator(); + + if (ImGui::MenuItem("Fast Forward", "Ctrl+F", &config_emulator.ffwd)) + { + menu_ffwd(); + } + + if (ImGui::BeginMenu("Fast Forward Speed")) + { + ImGui::PushItemWidth(100.0f); + ImGui::Combo("##fwd", &config_emulator.ffwd_speed, "X 1.5\0X 2\0X 2.5\0X 3\0Unlimited\0\0"); + ImGui::PopItemWidth(); + ImGui::EndMenu(); + } + + ImGui::Separator(); + + if (ImGui::MenuItem("Save RAM As...")) + { + save_ram = true; + } + + if (ImGui::MenuItem("Load RAM From...")) + { + open_ram = true; + } + + ImGui::Separator(); + + if (ImGui::MenuItem("Save State As...")) + { + save_state = true; + } + + if (ImGui::MenuItem("Load State From...")) + { + open_state = true; + } + + ImGui::Separator(); + + if (ImGui::BeginMenu("Save State Slot")) + { + ImGui::PushItemWidth(100.0f); + ImGui::Combo("##slot", &config_emulator.save_slot, "Slot 1\0Slot 2\0Slot 3\0Slot 4\0Slot 5\0\0"); + ImGui::PopItemWidth(); + ImGui::EndMenu(); + } + + if (ImGui::MenuItem("Save State", "Ctrl+S")) + { + emu_save_state_slot(config_emulator.save_slot + 1); + } + + if (ImGui::MenuItem("Load State", "Ctrl+L")) + { + emu_load_state_slot(config_emulator.save_slot + 1); + } + + ImGui::Separator(); + + if (ImGui::MenuItem("Quit", "ESC")) + { + application_trigger_quit(); + } + + ImGui::EndMenu(); + } + + if (ImGui::BeginMenu("Emulator")) + { + gui_in_use = true; + + if (ImGui::MenuItem("Force Game Boy (DMG)", "", &config_emulator.force_dmg)) + { + if (config_emulator.force_dmg) + config_emulator.force_gba = false; + } + + if (ImGui::MenuItem("Force Game Boy Advance", "", &config_emulator.force_gba)) + { + if (config_emulator.force_gba) + config_emulator.force_dmg = false; + } + + if (ImGui::BeginMenu("Memory Bank Controller")) + { + ImGui::PushItemWidth(140.0f); + ImGui::Combo("##mbc", &config_emulator.mbc, "Auto\0ROM Only\0MBC 1\0MBC 2\0MBC 3\0MBC 5\0MBC 1 Multicart\0\0"); + ImGui::PopItemWidth(); + ImGui::EndMenu(); + } + + ImGui::Separator(); + + if (ImGui::BeginMenu("DMG Bootrom")) + { + if (ImGui::MenuItem("Enable", "", &config_emulator.dmg_bootrom)) + { + emu_enable_bootrom_dmg(config_emulator.dmg_bootrom); + } + if (ImGui::IsItemHovered()) + ImGui::SetTooltip("When the bootrom is enabled it will execute as in original hardware,\ncausing invalid roms to lock or forcing hardware like GB Pocket or GBA."); + if (ImGui::MenuItem("Load Bootrom...")) + { + open_dmg_bootrom = true; + } + ImGui::PushItemWidth(350); + if (ImGui::InputText("##dmg_bootrom_path", dmg_bootrom_path, IM_ARRAYSIZE(dmg_bootrom_path), ImGuiInputTextFlags_AutoSelectAll)) + { + config_emulator.dmg_bootrom_path.assign(dmg_bootrom_path); + emu_load_bootrom_dmg(dmg_bootrom_path); + } + ImGui::PopItemWidth(); + ImGui::EndMenu(); + } + + if (ImGui::BeginMenu("GBC Bootrom")) + { + if (ImGui::MenuItem("Enable", "", &config_emulator.gbc_bootrom)) + { + emu_enable_bootrom_gbc(config_emulator.gbc_bootrom); + } + if (ImGui::IsItemHovered()) + ImGui::SetTooltip("When the bootrom is enabled it will execute as in original hardware,\ncausing invalid roms to lock or forcing hardware like GB Pocket or GBA."); + if (ImGui::MenuItem("Load Bootrom...")) + { + open_gbc_bootrom = true; + } + ImGui::PushItemWidth(350); + if (ImGui::InputText("##gbc_bootrom_path", gbc_bootrom_path, IM_ARRAYSIZE(gbc_bootrom_path), ImGuiInputTextFlags_AutoSelectAll)) + { + config_emulator.gbc_bootrom_path.assign(gbc_bootrom_path); + emu_load_bootrom_gbc(gbc_bootrom_path); + } + ImGui::PopItemWidth(); + ImGui::EndMenu(); + } + + ImGui::Separator(); + + ImGui::MenuItem("Start Paused", "", &config_emulator.start_paused); + + ImGui::Separator(); + + if (ImGui::BeginMenu("Save File Location")) + { + ImGui::PushItemWidth(220.0f); + if (ImGui::Combo("##savefile_option", &config_emulator.savefiles_dir_option, "Save Files In Custom Folder\0Save Files In ROM Folder\0\0")) + { + emu_savefiles_dir_option = config_emulator.savefiles_dir_option; + } + + if (config_emulator.savefiles_dir_option == 0) + { + if (ImGui::MenuItem("Choose Save File Folder...")) + { + choose_save_file_path = true; + } + + ImGui::PushItemWidth(350); + if (ImGui::InputText("##savefile_path", savefiles_path, IM_ARRAYSIZE(savefiles_path), ImGuiInputTextFlags_AutoSelectAll)) + { + config_emulator.savefiles_path.assign(savefiles_path); + strcpy(emu_savefiles_path, savefiles_path); + } + ImGui::PopItemWidth(); + } + + ImGui::EndMenu(); + } + + if (ImGui::BeginMenu("Save State Location")) + { + ImGui::PushItemWidth(220.0f); + if (ImGui::Combo("##savestate_option", &config_emulator.savestates_dir_option, "Savestates In Custom Folder\0Savestates In ROM Folder\0\0")) + { + emu_savestates_dir_option = config_emulator.savestates_dir_option; + } + + if (config_emulator.savestates_dir_option == 0) + { + if (ImGui::MenuItem("Choose Savestate Folder...")) + { + choose_savestates_path = true; + } + + ImGui::PushItemWidth(350); + if (ImGui::InputText("##savestate_path", savestates_path, IM_ARRAYSIZE(savestates_path), ImGuiInputTextFlags_AutoSelectAll)) + { + config_emulator.savestates_path.assign(savestates_path); + strcpy(emu_savestates_path, savestates_path); + } + ImGui::PopItemWidth(); + } + + ImGui::EndMenu(); + } + + ImGui::Separator(); + + ImGui::MenuItem("Show ROM info", "", &config_emulator.show_info); + + ImGui::Separator(); + + ImGui::SetNextWindowSizeConstraints({300.0f, 200.0f}, {300.0f, 500.0f}); + if (ImGui::BeginMenu("Cheats")) + { + ImGui::Text("Game Genie or GameShark codes\n(one code per line):"); + + ImGui::Columns(2, "cheats", false); + + static char cheat_buffer[20*50] = ""; + ImGui::PushItemWidth(150); + ImGui::InputTextMultiline("", cheat_buffer, IM_ARRAYSIZE(cheat_buffer)); + ImGui::PopItemWidth(); + + ImGui::NextColumn(); + + if (ImGui::Button("Add Cheat Codes")) + { + std::string cheats = cheat_buffer; + std::istringstream ss(cheats); + std::string cheat; + + while (getline(ss, cheat)) + { + if ((cheat_list.size() < 50) && ((cheat.length() == 7) || (cheat.length() == 8) || (cheat.length() == 11))) + { + cheat_list.push_back(cheat); + emu_add_cheat(cheat.c_str()); + cheat_buffer[0] = 0; + } + } + } + + if (cheat_list.size() > 0) + { + if (ImGui::Button("Clear All")) + { + cheat_list.clear(); + emu_clear_cheats(); + } + } + + ImGui::Columns(1); + + std::list<std::string>::iterator it; + + for (it = cheat_list.begin(); it != cheat_list.end(); it++) + { + if ((it->length() == 7) || (it->length() == 11)) + ImGui::Text("Game Genie: %s", it->c_str()); + else + ImGui::Text("GameShark: %s", it->c_str()); + } + + ImGui::EndMenu(); + } + + ImGui::EndMenu(); + } + + if (ImGui::BeginMenu("Video")) + { + gui_in_use = true; + + if (ImGui::MenuItem("Full Screen", "F11", &application_fullscreen)) + { + application_trigger_fullscreen(application_fullscreen); + } + + ImGui::MenuItem("Show Menu", "CTRL+M", &show_main_menu); + + ImGui::Separator(); + + if (ImGui::BeginMenu("Scale")) + { + ImGui::PushItemWidth(100.0f); + ImGui::Combo("##scale", &config_video.scale, "Auto\0Zoom X1\0Zoom X2\0Zoom X3\0Zoom X4\0\0"); + ImGui::PopItemWidth(); + ImGui::EndMenu(); + } + + if (ImGui::BeginMenu("Aspect Ratio")) + { + ImGui::PushItemWidth(130.0f); + ImGui::Combo("##ratio", &config_video.ratio, "Game Boy\0Standard (4:3)\0Wide (16:9)\0Fit Window\0\0"); + ImGui::PopItemWidth(); + ImGui::EndMenu(); + } + + ImGui::Separator(); + + if (ImGui::MenuItem("Vertical Sync", "", &config_video.sync)) + { + SDL_GL_SetSwapInterval(config_video.sync ? 1 : 0); + + if (config_video.sync) + { + config_audio.sync = true; + emu_audio_reset(); + } + } + + ImGui::MenuItem("Show FPS", "", &config_video.fps); + + ImGui::Separator(); + + ImGui::MenuItem("Bilinear Filtering", "", &config_video.bilinear); + + if (ImGui::MenuItem("Color Correction (GBC)", "", &config_video.color_correction)) + { + emu_color_correction(config_video.color_correction); + } + + if (ImGui::BeginMenu("Screen Ghosting")) + { + ImGui::MenuItem("Enable Screen Ghosting", "", &config_video.mix_frames); + ImGui::SliderFloat("##screen_ghosting", &config_video.mix_frames_intensity, 0.0f, 1.0f, "Intensity = %.2f"); + ImGui::EndMenu(); + } + + if (ImGui::BeginMenu("Dot Matrix")) + { + ImGui::MenuItem("Enable Dot Matrix", "", &config_video.matrix); + ImGui::SliderFloat("##dot_matrix", &config_video.matrix_intensity, 0.0f, 1.0f, "Intensity = %.2f"); + ImGui::EndMenu(); + } + + ImGui::Separator(); + + if (ImGui::BeginMenu("Palette")) + { + ImGui::PushItemWidth(130.0f); + if (ImGui::Combo("##palette", &config_video.palette, "Original\0Sharp\0Black & White\0Autumn\0Soft\0Slime\0Custom 1\0Custom 2\0Custom 3\0Custom 4\0Custom 5\0\0", 11)) + { + update_palette(); + } + ImGui::PopItemWidth(); + ImGui::EndMenu(); + } + + if (ImGui::BeginMenu("Custom Palettes")) + { + + for (int i = 0; i < config_max_custom_palettes; i++) + { + char menu_label[256]; + sprintf(menu_label, "Palette %i", i + 1); + + if (ImGui::BeginMenu(menu_label)) + { + if (ImGui::ColorEdit3("Color #1", (float*)&custom_palette[i][0], ImGuiColorEditFlags_NoInputs)) + { + update_palette(); + } + if (ImGui::ColorEdit3("Color #2", (float*)&custom_palette[i][1], ImGuiColorEditFlags_NoInputs)) + { + update_palette(); + } + if (ImGui::ColorEdit3("Color #3", (float*)&custom_palette[i][2], ImGuiColorEditFlags_NoInputs)) + { + update_palette(); + } + if (ImGui::ColorEdit3("Color #4", (float*)&custom_palette[i][3], ImGuiColorEditFlags_NoInputs)) + { + update_palette(); + } + ImGui::EndMenu(); + } + } + + ImGui::EndMenu(); + } + + ImGui::EndMenu(); + } + + if (ImGui::BeginMenu("Input")) + { + gui_in_use = true; + + if (ImGui::BeginMenu("Keyboard Configuration")) + { + keyboard_configuration_item("Left:", &config_input.key_left); + keyboard_configuration_item("Right:", &config_input.key_right); + keyboard_configuration_item("Up:", &config_input.key_up); + keyboard_configuration_item("Down:", &config_input.key_down); + keyboard_configuration_item("A:", &config_input.key_a); + keyboard_configuration_item("B:", &config_input.key_b); + keyboard_configuration_item("Start:", &config_input.key_start); + keyboard_configuration_item("Select:", &config_input.key_select); + + popup_modal_keyboard(); + + ImGui::EndMenu(); + } + + ImGui::Separator(); + + if (ImGui::BeginMenu("Gamepad")) + { + ImGui::MenuItem("Enable Gamepad", "", &config_input.gamepad); + + if (ImGui::BeginMenu("Directional Controls")) + { + ImGui::PushItemWidth(150.0f); + ImGui::Combo("##directional", &config_input.gamepad_directional, "D-pad\0Left Analog Stick\0\0"); + ImGui::PopItemWidth(); + ImGui::EndMenu(); + } + + if (ImGui::BeginMenu("Button Configuration")) + { + gamepad_configuration_item("A:", &config_input.gamepad_a); + gamepad_configuration_item("B:", &config_input.gamepad_b); + gamepad_configuration_item("START:", &config_input.gamepad_start); + gamepad_configuration_item("SELECT:", &config_input.gamepad_select); + + popup_modal_gamepad(); + + ImGui::EndMenu(); + } + ImGui::EndMenu(); + } + + ImGui::EndMenu(); + } + + if (ImGui::BeginMenu("Audio")) + { + gui_in_use = true; + + if (ImGui::MenuItem("Enable Audio", "", &config_audio.enable)) + { + emu_audio_volume(config_audio.enable ? 1.0f: 0.0f); + } + + if (ImGui::MenuItem("Sync With Emulator", "", &config_audio.sync)) + { + config_emulator.ffwd = false; + + if (!config_audio.sync) + { + config_video.sync = false; + SDL_GL_SetSwapInterval(0); + } + } + + ImGui::EndMenu(); + } + + if (ImGui::BeginMenu("Debug")) + { + gui_in_use = true; + + if (ImGui::MenuItem("Enable", "", &config_debug.debug)) + { + if (config_debug.debug) + emu_debug_step(); + else + emu_debug_continue(); + } + + ImGui::Separator(); + + if (ImGui::MenuItem("Step Over", "CTRL + F10", (void*)0, config_debug.debug)) + { + emu_debug_step(); + } + + if (ImGui::MenuItem("Step Frame", "CTRL + F6", (void*)0, config_debug.debug)) + { + emu_debug_next_frame(); + } + + if (ImGui::MenuItem("Continue", "CTRL + F5", (void*)0, config_debug.debug)) + { + emu_debug_continue(); + } + + if (ImGui::MenuItem("Run To Cursor", "CTRL + F8", (void*)0, config_debug.debug)) + { + gui_debug_runtocursor(); + } + + ImGui::Separator(); + + if (ImGui::MenuItem("Go Back", "CTRL + BACKSPACE", (void*)0, config_debug.debug)) + { + gui_debug_go_back(); + } + + ImGui::Separator(); + + if (ImGui::MenuItem("Toggle Breakpoint", "CTRL + F9", (void*)0, config_debug.debug)) + { + gui_debug_toggle_breakpoint(); + } + + if (ImGui::MenuItem("Clear All Processor Breakpoints", 0, (void*)0, config_debug.debug)) + { + gui_debug_reset_breakpoints_cpu(); + } + + if (ImGui::MenuItem("Clear All Memory Breakpoints", 0, (void*)0, config_debug.debug)) + { + gui_debug_reset_breakpoints_mem(); + } + + ImGui::MenuItem("Disable All Processor Breakpoints", 0, &emu_debug_disable_breakpoints_cpu, config_debug.debug); + + ImGui::MenuItem("Disable All Memory Breakpoints", 0, &emu_debug_disable_breakpoints_mem, config_debug.debug); + + ImGui::Separator(); + + if (ImGui::BeginMenu("Font Size", config_debug.debug)) + { + ImGui::PushItemWidth(110.0f); + if (ImGui::Combo("##font", &config_debug.font_size, "Very Small\0Small\0Medium\0Large\0\0")) + { + gui_default_font = default_font[config_debug.font_size]; + } + ImGui::PopItemWidth(); + ImGui::EndMenu(); + } + + ImGui::Separator(); + + ImGui::MenuItem("Show Game Boy Screen", "", &config_debug.show_gameboy, config_debug.debug); + + ImGui::MenuItem("Show Disassembler", "", &config_debug.show_disassembler, config_debug.debug); + + ImGui::MenuItem("Show Processor Status", "", &config_debug.show_processor, config_debug.debug); + + ImGui::MenuItem("Show Memory Editor", "", &config_debug.show_memory, config_debug.debug); + + ImGui::MenuItem("Show IO Map", "", &config_debug.show_iomap, config_debug.debug); + + ImGui::MenuItem("Show VRAM Viewer", "", &config_debug.show_video, config_debug.debug); + + ImGui::MenuItem("Show Sound Registers", "", &config_debug.show_audio, config_debug.debug); + + ImGui::Separator(); + + if (ImGui::MenuItem("Load Symbols...", "", (void*)0, config_debug.debug)) + { + open_symbols = true; + } + + if (ImGui::MenuItem("Clear Symbols", "", (void*)0, config_debug.debug)) + { + gui_debug_reset_symbols(); + } + + ImGui::EndMenu(); + } + + if (ImGui::BeginMenu("About")) + { + gui_in_use = true; + + if (ImGui::MenuItem("About " GEARBOY_TITLE " " GEARBOY_VERSION " ...")) + { + open_about = true; + } + ImGui::EndMenu(); + } + + main_menu_height = (int)ImGui::GetWindowSize().y; + + ImGui::EndMainMenuBar(); + } + + if (open_rom || shortcut_open_rom) + { + shortcut_open_rom = false; + ImGui::OpenPopup("Open ROM..."); + } + + if (open_ram) + ImGui::OpenPopup("Load RAM From..."); + + if (save_ram) + ImGui::OpenPopup("Save RAM As..."); + + if (open_state) + ImGui::OpenPopup("Load State From..."); + + if (save_state) + ImGui::OpenPopup("Save State As..."); + + if (choose_save_file_path) + ImGui::OpenPopup("Choose Save File Folder..."); + + if (choose_savestates_path) + ImGui::OpenPopup("Choose Savestate Folder..."); + + if (open_dmg_bootrom) + ImGui::OpenPopup("Load DMG Bootrom From..."); + + if (open_gbc_bootrom) + ImGui::OpenPopup("Load GBC Bootrom From..."); + + if (open_symbols) + ImGui::OpenPopup("Load Symbols File..."); + + if (open_about) + { + dialog_in_use = true; + ImGui::OpenPopup("About " GEARBOY_TITLE); + } + + popup_modal_about(); + file_dialog_open_rom(); + file_dialog_load_ram(); + file_dialog_save_ram(); + file_dialog_load_state(); + file_dialog_save_state(); + file_dialog_choose_save_file_path(); + file_dialog_choose_savestate_path(); + file_dialog_load_dmg_bootrom(); + file_dialog_load_gbc_bootrom(); + file_dialog_load_symbols(); + + for (int i = 0; i < config_max_custom_palettes; i++) + for (int c = 0; c < 4; c++) + config_video.color[i][c] = color_float_to_int(custom_palette[i][c]); +} + +static void main_window(void) +{ + int w = (int)ImGui::GetIO().DisplaySize.x; + int h = (int)ImGui::GetIO().DisplaySize.y - (show_main_menu ? main_menu_height : 0); + + int selected_ratio = config_debug.debug ? 0 : config_video.ratio; + float ratio = (float)GAMEBOY_WIDTH / (float)GAMEBOY_HEIGHT; + + switch (selected_ratio) + { + case 0: + ratio = (float)GAMEBOY_WIDTH / (float)GAMEBOY_HEIGHT; + break; + case 1: + ratio = 4.0f / 3.0f; + break; + case 2: + ratio = 16.0f / 9.0f; + break; + case 3: + ratio = (float)w / (float)h; + break; + default: + ratio = (float)GAMEBOY_WIDTH / (float)GAMEBOY_HEIGHT; + } + + int w_corrected = (int)(selected_ratio == 3 ? w : GAMEBOY_HEIGHT * ratio); + int h_corrected = selected_ratio == 3 ? h : GAMEBOY_HEIGHT; + + int factor = 0; + + if (config_video.scale > 0) + { + factor = config_video.scale; + } + else if (config_debug.debug) + { + factor = 1; + } + else + { + int factor_w = w / w_corrected; + int factor_h = h / h_corrected; + factor = (factor_w < factor_h) ? factor_w : factor_h; + } + + int main_window_width = w_corrected * factor; + int main_window_height = h_corrected * factor; + + int window_x = (w - (w_corrected * factor)) / 2; + int window_y = ((h - (h_corrected * factor)) / 2) + (show_main_menu ? main_menu_height : 0); + + ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0.0f, 0.0f)); + ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 0.0f); + + ImGuiWindowFlags flags = ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoScrollbar; + + if (config_debug.debug) + { + flags |= ImGuiWindowFlags_AlwaysAutoResize; + + ImGui::SetNextWindowPos(ImVec2(7, 32), ImGuiCond_FirstUseEver); + + ImGui::Begin(emu_is_cgb() ? "Game Boy Color###debug_output" : "Game Boy###debug_output", &config_debug.show_gameboy, flags); + } + else + { + ImGui::SetNextWindowSize(ImVec2((float)main_window_width, (float)main_window_height)); + ImGui::SetNextWindowPos(ImVec2((float)window_x, (float)window_y)); + ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f); + + flags |= ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoNav; + + ImGui::Begin(GEARBOY_TITLE, 0, flags); + } + + ImGui::Image((void*)(intptr_t)renderer_emu_texture, ImVec2((float)main_window_width, (float)main_window_height)); + + if (config_video.fps) + show_fps(); + + if (config_emulator.show_info) + show_info(); + + ImGui::End(); + + ImGui::PopStyleVar(); + ImGui::PopStyleVar(); + + if (!config_debug.debug) + { + + ImGui::PopStyleVar(); + } +} + +static void file_dialog_open_rom(void) +{ + if(file_dialog.showFileDialog("Open ROM...", imgui_addons::ImGuiFileBrowser::DialogMode::OPEN, ImVec2(700, 400), "*.*,.gb,.gbc,.cgb,.sgb,.dmg,.rom,.zip", &dialog_in_use)) + { + gui_load_rom(file_dialog.selected_path.c_str()); + } +} + +static void file_dialog_load_ram(void) +{ + if(file_dialog.showFileDialog("Load RAM From...", imgui_addons::ImGuiFileBrowser::DialogMode::OPEN, ImVec2(700, 310), ".sav,*.*", &dialog_in_use)) + { + emu_load_ram(file_dialog.selected_path.c_str(), config_emulator.force_dmg, get_mbc(config_emulator.mbc), config_emulator.force_gba); + } +} + +static void file_dialog_save_ram(void) +{ + if(file_dialog.showFileDialog("Save RAM As...", imgui_addons::ImGuiFileBrowser::DialogMode::SAVE, ImVec2(700, 310), ".sav", &dialog_in_use)) + { + std::string save_path = file_dialog.selected_path; + + if (save_path.rfind(file_dialog.ext) != (save_path.size()-file_dialog.ext.size())) + { + save_path += file_dialog.ext; + } + + emu_save_ram(save_path.c_str()); + } +} + +static void file_dialog_load_state(void) +{ + if(file_dialog.showFileDialog("Load State From...", imgui_addons::ImGuiFileBrowser::DialogMode::OPEN, ImVec2(700, 310), ".state,*.*", &dialog_in_use)) + { + emu_load_state_file(file_dialog.selected_path.c_str()); + } +} + +static void file_dialog_save_state(void) +{ + if(file_dialog.showFileDialog("Save State As...", imgui_addons::ImGuiFileBrowser::DialogMode::SAVE, ImVec2(700, 310), ".state", &dialog_in_use)) + { + std::string state_path = file_dialog.selected_path; + + if (state_path.rfind(file_dialog.ext) != (state_path.size()-file_dialog.ext.size())) + { + state_path += file_dialog.ext; + } + + emu_save_state_file(state_path.c_str()); + } +} + +static void file_dialog_choose_save_file_path(void) +{ + if(file_dialog.showFileDialog("Choose Save File Folder...", imgui_addons::ImGuiFileBrowser::DialogMode::SELECT, ImVec2(700, 310), "*.*", &dialog_in_use)) + { + strcpy(savefiles_path, file_dialog.selected_path.c_str()); + config_emulator.savefiles_path.assign(file_dialog.selected_path); + } +} + +static void file_dialog_choose_savestate_path(void) +{ + if(file_dialog.showFileDialog("Choose Savestate Folder...", imgui_addons::ImGuiFileBrowser::DialogMode::SELECT, ImVec2(700, 310), "*.*", &dialog_in_use)) + { + strcpy(savestates_path, file_dialog.selected_path.c_str()); + config_emulator.savestates_path.assign(file_dialog.selected_path); + } +} + +static void file_dialog_load_dmg_bootrom(void) +{ + if(file_dialog.showFileDialog("Load DMG Bootrom From...", imgui_addons::ImGuiFileBrowser::DialogMode::OPEN, ImVec2(700, 310), ".bin,.gb,*.*", &dialog_in_use)) + { + strcpy(dmg_bootrom_path, file_dialog.selected_path.c_str()); + config_emulator.dmg_bootrom_path.assign(file_dialog.selected_path); + + emu_load_bootrom_dmg(dmg_bootrom_path); + } +} + +static void file_dialog_load_gbc_bootrom(void) +{ + if(file_dialog.showFileDialog("Load GBC Bootrom From...", imgui_addons::ImGuiFileBrowser::DialogMode::OPEN, ImVec2(700, 310), ".bin,.gbc,*.*", &dialog_in_use)) + { + strcpy(gbc_bootrom_path, file_dialog.selected_path.c_str()); + config_emulator.gbc_bootrom_path.assign(file_dialog.selected_path); + + emu_load_bootrom_gbc(gbc_bootrom_path); + } +} + +static void file_dialog_load_symbols(void) +{ + if(file_dialog.showFileDialog("Load Symbols File...", imgui_addons::ImGuiFileBrowser::DialogMode::OPEN, ImVec2(700, 400), ".sym,*.*", &dialog_in_use)) + { + gui_debug_reset_symbols(); + gui_debug_load_symbols_file(file_dialog.selected_path.c_str()); + } +} + +static void keyboard_configuration_item(const char* text, SDL_Scancode* key) +{ + ImGui::Text("%s", text); + ImGui::SameLine(90); + + char button_label[256]; + sprintf(button_label, "%s##%s", SDL_GetScancodeName(*key), text); + + if (ImGui::Button(button_label, ImVec2(70,0))) + { + configured_key = key; + ImGui::OpenPopup("Keyboard Configuration"); + } +} + +static void gamepad_configuration_item(const char* text, int* button) +{ + ImGui::Text("%s", text); + ImGui::SameLine(70); + + static const char* gamepad_names[16] = {"A", "B", "X" ,"Y", "BACK", "GUID", "START", "L3", "R3", "L1", "R1", "UP", "DOWN", "LEFT", "RIGHT", "15"}; + + char button_label[256]; + sprintf(button_label, "%s##%s", gamepad_names[*button], text); + + if (ImGui::Button(button_label, ImVec2(70,0))) + { + configured_button = button; + ImGui::OpenPopup("Gamepad Configuration"); + } +} + +static void popup_modal_keyboard(void) +{ + if (ImGui::BeginPopupModal("Keyboard Configuration", NULL, ImGuiWindowFlags_AlwaysAutoResize)) + { + ImGui::Text("Press any key...\n\n"); + ImGui::Separator(); + + for (int i = 0; i < IM_ARRAYSIZE(ImGui::GetIO().KeysDown); i++) + { + if (ImGui::IsKeyPressed(i)) + { + SDL_Scancode key = (SDL_Scancode)i; + + if ((key != SDL_SCANCODE_LCTRL) && (key != SDL_SCANCODE_RCTRL) && (key != SDL_SCANCODE_CAPSLOCK)) + { + *configured_key = key; + ImGui::CloseCurrentPopup(); + break; + } + } + } + + if (ImGui::Button("Cancel", ImVec2(120, 0))) + { + ImGui::CloseCurrentPopup(); + } + ImGui::EndPopup(); + } +} + +static void popup_modal_gamepad(void) +{ + if (ImGui::BeginPopupModal("Gamepad Configuration", NULL, ImGuiWindowFlags_AlwaysAutoResize)) + { + ImGui::Text("Press any button in your gamepad...\n\n"); + ImGui::Separator(); + + for (int i = 0; i < SDL_CONTROLLER_BUTTON_MAX; i++) + { + if (SDL_GameControllerGetButton(application_gamepad, (SDL_GameControllerButton)i)) + { + *configured_button = i; + ImGui::CloseCurrentPopup(); + break; + } + } + + if (ImGui::Button("Cancel", ImVec2(120, 0))) + { + ImGui::CloseCurrentPopup(); + } + ImGui::EndPopup(); + } +} + +static void popup_modal_about(void) +{ + if (ImGui::BeginPopupModal("About " GEARBOY_TITLE, NULL, ImGuiWindowFlags_AlwaysAutoResize)) + { + ImGui::Text("%s %s", GEARBOY_TITLE, GEARBOY_VERSION); + ImGui::Text("Build: %s", EMULATOR_BUILD); + + ImGui::Separator(); + + ImGui::Text("By Ignacio Sánchez (twitter.com/drhelius)"); + ImGui::Text("%s is licensed under the GPL-3.0 License, see LICENSE for more information.", GEARBOY_TITLE); + + ImGui::Separator(); + + if (ImGui::BeginTabBar("##Tabs", ImGuiTabBarFlags_None)) + { + if (ImGui::BeginTabItem("Special thanks to")) + { + ImGui::BeginChild("backers", ImVec2(0, 100), false, ImGuiWindowFlags_AlwaysVerticalScrollbar); + ImGui::Text("%s", BACKERS_STR); + ImGui::EndChild(); + ImGui::EndTabItem(); + } + if (ImGui::BeginTabItem("LICENSE")) + { + ImGui::BeginChild("license", ImVec2(0, 100), false, ImGuiWindowFlags_AlwaysVerticalScrollbar); + ImGui::TextUnformatted(GPL_LICENSE_STR); + ImGui::EndChild(); + ImGui::EndTabItem(); + } + ImGui::EndTabBar(); + } + + ImGui::Separator(); + + #ifdef _WIN64 + ImGui::Text("Windows 64 bit build"); + #elif defined(_WIN32) + ImGui::Text("Windows 32 bit build"); + #endif + #ifdef __linux__ + ImGui::Text("Linux build"); + #endif + #ifdef __APPLE__ + ImGui::Text("macOS build"); + #endif + #ifdef _MSC_VER + ImGui::Text("Microsoft C++ %d.", _MSC_VER); + #endif + #ifdef __MINGW32__ + ImGui::Text("MinGW 32 bit (%d.%d)", __MINGW32_MAJOR_VERSION, __MINGW32_MINOR_VERSION); + #endif + #ifdef __MINGW64__ + ImGui::Text("MinGW 64 bit (%d.%d)", __MINGW64_VERSION_MAJOR, __MINGW64_VERSION_MINOR); + #endif + #if defined(__GNUC__) && !defined(__llvm__) && !defined(__INTEL_COMPILER) + ImGui::Text("GCC %d.%d.%d", (int)__GNUC__, (int)__GNUC_MINOR__, (int)__GNUC_PATCHLEVEL__); + #endif + #ifdef __clang_version__ + ImGui::Text("Clang %s", __clang_version__); + #endif + + ImGui::Separator(); + + #ifdef DEBUG + ImGui::Text("define: DEBUG"); + #endif + #ifdef DEBUG_GEARBOY + ImGui::Text("define: DEBUG_GEARBOY"); + #endif + #ifdef __cplusplus + ImGui::Text("define: __cplusplus = %d", (int)__cplusplus); + #endif + #ifdef __STDC__ + ImGui::Text("define: __STDC__ = %d", (int)__STDC__); + #endif + #ifdef __STDC_VERSION__ + ImGui::Text("define: __STDC_VERSION__ = %d", (int)__STDC_VERSION__); + #endif + + ImGui::Separator(); + + ImGui::Text("SDL %d.%d.%d (build)", application_sdl_build_version.major, application_sdl_build_version.minor, application_sdl_build_version.patch); + ImGui::Text("SDL %d.%d.%d (link) ", application_sdl_link_version.major, application_sdl_link_version.minor, application_sdl_link_version.patch); + ImGui::Text("OpenGL %s", renderer_opengl_version); + #ifndef __APPLE__ + ImGui::Text("GLEW %s", renderer_glew_version); + #endif + ImGui::Text("Dear ImGui %s (%d)", IMGUI_VERSION, IMGUI_VERSION_NUM); + + ImGui::Separator(); + + if (application_gamepad) + ImGui::Text("Gamepad detected"); + else + ImGui::Text("No gamepad detected"); + + if (application_gamepad_mappings > 0) + ImGui::Text("%d gamepad mappings loaded", application_gamepad_mappings); + else + ImGui::Text("Gamepad database not found"); + + ImGui::Separator(); + + if (ImGui::Button("OK", ImVec2(120, 0))) + { + ImGui::CloseCurrentPopup(); + dialog_in_use = false; + } + ImGui::SetItemDefaultFocus(); + + ImGui::EndPopup(); + } +} + +static GB_Color color_float_to_int(ImVec4 color) +{ + GB_Color ret; + ret.red = (u8)floor(color.x >= 1.0 ? 255.0 : color.x * 256.0); + ret.green = (u8)floor(color.y >= 1.0 ? 255.0 : color.y * 256.0); + ret.blue = (u8)floor(color.z >= 1.0 ? 255.0 : color.z * 256.0); + return ret; +} + +static ImVec4 color_int_to_float(GB_Color color) +{ + ImVec4 ret; + ret.w = 0; + ret.x = (1.0f / 255.0f) * color.red; + ret.y = (1.0f / 255.0f) * color.green; + ret.z = (1.0f / 255.0f) * color.blue; + return ret; +} + +static void update_palette(void) +{ + if (config_video.palette > 5) + { + int palette = config_video.palette - 6; + emu_dmg_palette(config_video.color[palette][0], config_video.color[palette][1], config_video.color[palette][2], config_video.color[palette][3]); + } + else + emu_dmg_predefined_palette(config_video.palette); +} + +static void push_recent_rom(std::string path) +{ + int slot = 0; + for (slot = 0; slot < config_max_recent_roms; slot++) + { + if (config_emulator.recent_roms[slot].compare(path) == 0) + { + break; + } + } + + slot = std::min(slot, config_max_recent_roms - 1); + + for (int i = slot; i > 0; i--) + { + config_emulator.recent_roms[i] = config_emulator.recent_roms[i - 1]; + } + + config_emulator.recent_roms[0] = path; +} + +static void menu_reset(void) +{ + emu_resume(); + emu_reset(config_emulator.force_dmg, get_mbc(config_emulator.mbc), config_emulator.force_gba); + + if (config_emulator.start_paused) + { + emu_pause(); + + for (int i=0; i < (GAMEBOY_WIDTH * GAMEBOY_HEIGHT); i++) + { + emu_frame_buffer[i].red = 0; + emu_frame_buffer[i].green = 0; + emu_frame_buffer[i].blue = 0; + } + } +} + +static void menu_pause(void) +{ + if (emu_is_paused()) + emu_resume(); + else + emu_pause(); +} + +static void menu_ffwd(void) +{ + config_audio.sync = !config_emulator.ffwd; + + if (config_emulator.ffwd) + SDL_GL_SetSwapInterval(0); + else + { + SDL_GL_SetSwapInterval(config_video.sync ? 1 : 0); + emu_audio_reset(); + } +} + +static void show_info(void) +{ + if (config_video.fps) + ImGui::SetCursorPosX(5.0f); + else + ImGui::SetCursorPos(ImVec2(5.0f, config_debug.debug ? 25.0f : 5.0f)); + + static char info[512]; + + emu_get_info(info); + ImGui::Text("%s", info); +} + +static void show_fps(void) +{ + ImGui::SetCursorPos(ImVec2(5.0f, config_debug.debug ? 25.0f : 5.0f )); + ImGui::Text("Frame Rate: %.2f FPS\nFrame Time: %.2f ms", ImGui::GetIO().Framerate, 1000.0f / ImGui::GetIO().Framerate); +} + +static Cartridge::CartridgeTypes get_mbc(int index) +{ + switch (index) + { + case 0: + return Cartridge::CartridgeNotSupported; + case 1: + return Cartridge::CartridgeNoMBC; + case 2: + return Cartridge::CartridgeMBC1; + case 3: + return Cartridge::CartridgeMBC2; + case 4: + return Cartridge::CartridgeMBC3; + case 5: + return Cartridge::CartridgeMBC5; + case 6: + return Cartridge::CartridgeMBC1Multi; + default: + return Cartridge::CartridgeNotSupported; + } +} |