core: Consolidate top-level system state into a singleton.

This commit is contained in:
bunnei 2016-11-04 23:14:38 -04:00
parent 81e22ae8c7
commit 198b6c9bdd
8 changed files with 167 additions and 106 deletions

View File

@ -64,7 +64,7 @@ int main(int argc, char** argv) {
return -1; return -1;
} }
#endif #endif
std::string boot_filename; std::string filepath;
static struct option long_options[] = { static struct option long_options[] = {
{"gdbport", required_argument, 0, 'g'}, {"gdbport", required_argument, 0, 'g'},
@ -97,9 +97,9 @@ int main(int argc, char** argv) {
} }
} else { } else {
#ifdef _WIN32 #ifdef _WIN32
boot_filename = Common::UTF16ToUTF8(argv_w[optind]); filepath = Common::UTF16ToUTF8(argv_w[optind]);
#else #else
boot_filename = argv[optind]; filepath = argv[optind];
#endif #endif
optind++; optind++;
} }
@ -115,7 +115,7 @@ int main(int argc, char** argv) {
MicroProfileOnThreadCreate("EmuThread"); MicroProfileOnThreadCreate("EmuThread");
SCOPE_EXIT({ MicroProfileShutdown(); }); SCOPE_EXIT({ MicroProfileShutdown(); });
if (boot_filename.empty()) { if (filepath.empty()) {
LOG_CRITICAL(Frontend, "Failed to load ROM: No ROM specified"); LOG_CRITICAL(Frontend, "Failed to load ROM: No ROM specified");
return -1; return -1;
} }
@ -127,27 +127,20 @@ int main(int argc, char** argv) {
Settings::values.use_gdbstub = use_gdbstub; Settings::values.use_gdbstub = use_gdbstub;
Settings::Apply(); Settings::Apply();
std::unique_ptr<EmuWindow_SDL2> emu_window = std::make_unique<EmuWindow_SDL2>(); std::unique_ptr<EmuWindow_SDL2> emu_window{ std::make_unique<EmuWindow_SDL2>() };
std::unique_ptr<Loader::AppLoader> loader = Loader::GetLoader(boot_filename); Core::System& system{ Core::System::GetInstance() };
if (!loader) {
LOG_CRITICAL(Frontend, "Failed to obtain loader for %s!", boot_filename.c_str()); SCOPE_EXIT({ system.Shutdown(); });
const Core::System::ResultStatus load_result{ system.Load(emu_window.get(), filepath) };
switch (load_result) {
case Core::System::ResultStatus::ErrorGetLoader:
LOG_CRITICAL(Frontend, "Failed to obtain loader for %s!", filepath.c_str());
return -1; return -1;
} case Core::System::ResultStatus::ErrorLoader:
LOG_CRITICAL(Frontend, "Failed to load ROM!");
boost::optional<u32> system_mode = loader->LoadKernelSystemMode();
if (!system_mode) {
LOG_CRITICAL(Frontend, "Failed to load ROM (Could not determine system mode)!");
return -1;
}
System::Init(emu_window.get(), system_mode.get());
SCOPE_EXIT({ System::Shutdown(); });
Loader::ResultStatus load_result = loader->Load();
if (Loader::ResultStatus::Success != load_result) {
LOG_CRITICAL(Frontend, "Failed to load ROM (Error %i)!", load_result);
return -1; return -1;
} }

View File

@ -60,7 +60,7 @@ void EmuThread::run() {
} }
// Shutdown the core emulation // Shutdown the core emulation
System::Shutdown(); Core::System::GetInstance().Shutdown();
#if MICROPROFILE_ENABLED #if MICROPROFILE_ENABLED
MicroProfileOnThreadExit(); MicroProfileOnThreadExit();

View File

@ -14,7 +14,7 @@ ConfigureGeneral::ConfigureGeneral(QWidget* parent)
ui->setupUi(this); ui->setupUi(this);
this->setConfiguration(); this->setConfiguration();
ui->toggle_cpu_jit->setEnabled(!System::IsPoweredOn()); ui->toggle_cpu_jit->setEnabled(!Core::System::GetInstance().IsPoweredOn());
} }
ConfigureGeneral::~ConfigureGeneral() {} ConfigureGeneral::~ConfigureGeneral() {}

View File

@ -13,7 +13,7 @@ ConfigureGraphics::ConfigureGraphics(QWidget* parent)
ui->setupUi(this); ui->setupUi(this);
this->setConfiguration(); this->setConfiguration();
ui->toggle_vsync->setEnabled(!System::IsPoweredOn()); ui->toggle_vsync->setEnabled(!Core::System::GetInstance().IsPoweredOn());
} }
ConfigureGraphics::~ConfigureGraphics() {} ConfigureGraphics::~ConfigureGraphics() {}

View File

@ -24,7 +24,7 @@ ConfigureSystem::ConfigureSystem(QWidget* parent) : QWidget(parent), ui(new Ui::
ConfigureSystem::~ConfigureSystem() {} ConfigureSystem::~ConfigureSystem() {}
void ConfigureSystem::setConfiguration() { void ConfigureSystem::setConfiguration() {
enabled = !System::IsPoweredOn(); enabled = !Core::System::GetInstance().IsPoweredOn();
if (!enabled) { if (!enabled) {
ReadSystemSettings(); ReadSystemSettings();

View File

@ -274,7 +274,7 @@ void GMainWindow::OnDisplayTitleBars(bool show) {
} }
} }
bool GMainWindow::InitializeSystem(u32 system_mode) { bool GMainWindow::LoadROM(const std::string& filename) {
// Shutdown previous session if the emu thread is still active... // Shutdown previous session if the emu thread is still active...
if (emu_thread != nullptr) if (emu_thread != nullptr)
ShutdownGame(); ShutdownGame();
@ -290,54 +290,26 @@ bool GMainWindow::InitializeSystem(u32 system_mode) {
return false; return false;
} }
// Initialize the core emulation Core::System& system{ Core::System::GetInstance() };
System::Result system_result = System::Init(render_window, system_mode);
if (System::Result::Success != system_result) {
switch (system_result) {
case System::Result::ErrorInitVideoCore:
QMessageBox::critical(this, tr("Error while starting Citra!"),
tr("Failed to initialize the video core!\n\n"
"Please ensure that your GPU supports OpenGL 3.3 and that you "
"have the latest graphics driver."));
break;
default: const Core::System::ResultStatus result{ system.Load(render_window, filename) };
QMessageBox::critical(this, tr("Error while starting Citra!"),
tr("Unknown error (please check the log)!"));
break;
}
return false;
}
return true;
}
bool GMainWindow::LoadROM(const std::string& filename) { if (result != Core::System::ResultStatus::Success) {
std::unique_ptr<Loader::AppLoader> app_loader = Loader::GetLoader(filename); switch (result) {
if (!app_loader) { case Core::System::ResultStatus::ErrorGetLoader:
LOG_CRITICAL(Frontend, "Failed to obtain loader for %s!", filename.c_str()); LOG_CRITICAL(Frontend, "Failed to obtain loader for %s!", filename.c_str());
QMessageBox::critical(this, tr("Error while loading ROM!"), QMessageBox::critical(this, tr("Error while loading ROM!"),
tr("The ROM format is not supported.")); tr("The ROM format is not supported."));
return false; break;
}
boost::optional<u32> system_mode = app_loader->LoadKernelSystemMode(); case Core::System::ResultStatus::ErrorSystemMode:
if (!system_mode) {
LOG_CRITICAL(Frontend, "Failed to load ROM!"); LOG_CRITICAL(Frontend, "Failed to load ROM!");
QMessageBox::critical(this, tr("Error while loading ROM!"), QMessageBox::critical(this, tr("Error while loading ROM!"),
tr("Could not determine the system mode.")); tr("Could not determine the system mode."));
return false; break;
}
if (!InitializeSystem(system_mode.get())) case Core::System::ResultStatus::ErrorLoader_ErrorEncrypted:
return false; {
Loader::ResultStatus result = app_loader->Load();
if (Loader::ResultStatus::Success != result) {
System::Shutdown();
LOG_CRITICAL(Frontend, "Failed to load ROM!");
switch (result) {
case Loader::ResultStatus::ErrorEncrypted: {
// Build the MessageBox ourselves to have clickable link // Build the MessageBox ourselves to have clickable link
QMessageBox popup_error; QMessageBox popup_error;
popup_error.setTextFormat(Qt::RichText); popup_error.setTextFormat(Qt::RichText);
@ -352,11 +324,10 @@ bool GMainWindow::LoadROM(const std::string& filename) {
popup_error.exec(); popup_error.exec();
break; break;
} }
case Loader::ResultStatus::ErrorInvalidFormat: case Core::System::ResultStatus::ErrorLoader_ErrorInvalidFormat:
QMessageBox::critical(this, tr("Error while loading ROM!"), QMessageBox::critical(this, tr("Error while loading ROM!"),
tr("The ROM format is not supported.")); tr("The ROM format is not supported."));
break; break;
case Loader::ResultStatus::Error:
default: default:
QMessageBox::critical(this, tr("Error while loading ROM!"), tr("Unknown error!")); QMessageBox::critical(this, tr("Error while loading ROM!"), tr("Unknown error!"));

View File

@ -13,33 +13,30 @@
#include "core/system.h" #include "core/system.h"
#include "video_core/video_core.h" #include "video_core/video_core.h"
namespace System { namespace Core {
static bool is_powered_on{false}; /*static*/ System System::s_instance;
Result Init(EmuWindow* emu_window, u32 system_mode) { System::ResultStatus System::Init(EmuWindow* emu_window, u32 system_mode) {
Core::Init(); Core::Init();
CoreTiming::Init(); CoreTiming::Init();
Memory::Init(); Memory::Init();
HW::Init(); HW::Init();
Kernel::Init(system_mode); Kernel::Init(system_mode);
HLE::Init(); HLE::Init();
if (!VideoCore::Init(emu_window)) {
return Result::ErrorInitVideoCore;
}
AudioCore::Init(); AudioCore::Init();
GDBStub::Init(); GDBStub::Init();
if (!VideoCore::Init(emu_window)) {
return ResultStatus::ErrorVideoCore;
}
is_powered_on = true; is_powered_on = true;
return Result::Success; return ResultStatus::Success;
} }
bool IsPoweredOn() { void System::Shutdown() {
return is_powered_on;
}
void Shutdown() {
GDBStub::Shutdown(); GDBStub::Shutdown();
AudioCore::Shutdown(); AudioCore::Shutdown();
VideoCore::Shutdown(); VideoCore::Shutdown();
@ -52,4 +49,42 @@ void Shutdown() {
is_powered_on = false; is_powered_on = false;
} }
} // namespace System::ResultStatus System::Load(EmuWindow* emu_window, const std::string& filepath) {
state.app_loader = Loader::GetLoader(filepath);
if (!state.app_loader) {
LOG_CRITICAL(Frontend, "Failed to obtain loader for %s!", filepath.c_str());
return ResultStatus::ErrorGetLoader;
}
boost::optional<u32> system_mode{ state.app_loader->LoadKernelSystemMode() };
if (!system_mode) {
LOG_CRITICAL(Frontend, "Failed to determine system mode!");
return ResultStatus::ErrorSystemMode;
}
ResultStatus init_result{ Init(emu_window, system_mode.get()) };
if (init_result != ResultStatus::Success) {
LOG_CRITICAL(Frontend, "Failed to initialize system (Error %i)!", init_result);
System::Shutdown();
return init_result;
}
const Loader::ResultStatus load_result{ state.app_loader->Load() };
if (Loader::ResultStatus::Success != load_result) {
LOG_CRITICAL(Frontend, "Failed to load ROM (Error %i)!", load_result);
System::Shutdown();
switch (load_result) {
case Loader::ResultStatus::ErrorEncrypted:
return ResultStatus::ErrorLoader_ErrorEncrypted;
case Loader::ResultStatus::ErrorInvalidFormat:
return ResultStatus::ErrorLoader_ErrorInvalidFormat;
default:
return ResultStatus::ErrorLoader;
}
}
return ResultStatus::Success;
}
} // namespace Core

View File

@ -4,18 +4,80 @@
#pragma once #pragma once
#include <string>
#include "core/loader/loader.h"
class EmuWindow; class EmuWindow;
namespace System { namespace Core {
enum class Result { class System {
Success, ///< Everything is fine public:
Error, ///< Something went wrong (no module specified) struct State {
ErrorInitCore, ///< Something went wrong during core init std::unique_ptr<Loader::AppLoader> app_loader;
ErrorInitVideoCore, ///< Something went wrong during video core init };
/**
* Gets the instance of the System singleton class.
* @returns Reference to the instance of the System singleton class.
*/
static System& GetInstance() {
return s_instance;
}
/// Enumeration representing the return values of the System Initialize and Load process.
enum class ResultStatus : u32 {
Success, ///< Succeeded
ErrorGetLoader, ///< Error finding the correct application loader
ErrorSystemMode, ///< Error determining the system mode
ErrorLoader, ///< Error loading the specified application
ErrorLoader_ErrorEncrypted, ///< Error loading the specified application due to encryption
ErrorLoader_ErrorInvalidFormat, ///< Error loading the specified application due to an invalid format
ErrorVideoCore, ///< Error in the video core
};
/**
* Initialize the emulated system.
* @param emu_window Pointer to the host-system window used for video output and keyboard input.
* @param system_mode The system mode.
* @returns ResultStatus code, indicating if the operation succeeded.
*/
ResultStatus Init(EmuWindow* emu_window, u32 system_mode);
/// Shutdown the emulated system.
void Shutdown();
/**
* Load an executable application.
* @param emu_window Pointer to the host-system window used for video output and keyboard input.
* @param filepath String path to the executable application to load on the host file system.
* @returns ResultStatus code, indicating if the operation succeeded.
*/
ResultStatus Load(EmuWindow* emu_window, const std::string& filepath);
/**
* Indicates if the emulated system is powered on (all subsystems initialized and able to run an
* application).
* @returns True if the emulated system is powered on, otherwise false.
*/
bool IsPoweredOn() const {
return is_powered_on;
}
/**
* Gets the internal state of the emulated system.
* @returns The internal state of the emulated system
*/
State& GetState() {
return state;
}
private:
bool is_powered_on{};
State state;
static System s_instance;
}; };
Result Init(EmuWindow* emu_window, u32 system_mode); } // namespace Core
bool IsPoweredOn();
void Shutdown();
}