2014-04-08 19:15:46 -04:00
|
|
|
// Copyright 2014 Citra Emulator Project
|
2014-12-17 00:38:14 -05:00
|
|
|
// Licensed under GPLv2 or any later version
|
2014-04-08 19:15:46 -04:00
|
|
|
// Refer to the license.txt file included.
|
2013-09-05 18:33:46 -04:00
|
|
|
|
2014-04-08 19:15:46 -04:00
|
|
|
#pragma once
|
2013-09-05 18:33:46 -04:00
|
|
|
|
2018-08-31 12:21:34 -04:00
|
|
|
#include <cstddef>
|
2015-12-29 18:03:08 -05:00
|
|
|
#include <memory>
|
2016-12-15 19:01:48 -05:00
|
|
|
#include <string>
|
2019-11-24 20:15:51 -05:00
|
|
|
#include <vector>
|
2018-08-31 12:21:34 -04:00
|
|
|
|
2014-12-22 01:30:09 -05:00
|
|
|
#include "common/common_types.h"
|
2018-11-28 14:00:44 -05:00
|
|
|
#include "core/file_sys/vfs_types.h"
|
2018-08-01 22:40:00 -04:00
|
|
|
#include "core/hle/kernel/object.h"
|
2014-12-22 01:30:09 -05:00
|
|
|
|
2018-08-11 20:20:19 -04:00
|
|
|
namespace Core::Frontend {
|
|
|
|
class EmuWindow;
|
2018-08-31 12:21:34 -04:00
|
|
|
} // namespace Core::Frontend
|
|
|
|
|
|
|
|
namespace FileSys {
|
2018-12-28 00:03:01 -05:00
|
|
|
class ContentProvider;
|
|
|
|
class ContentProviderUnion;
|
|
|
|
enum class ContentProviderUnionSlot;
|
2018-08-31 12:21:34 -04:00
|
|
|
class VfsFilesystem;
|
|
|
|
} // namespace FileSys
|
|
|
|
|
|
|
|
namespace Kernel {
|
2019-06-19 09:11:18 -04:00
|
|
|
class GlobalScheduler;
|
2018-08-31 12:21:34 -04:00
|
|
|
class KernelCore;
|
|
|
|
class Process;
|
|
|
|
class Scheduler;
|
|
|
|
} // namespace Kernel
|
|
|
|
|
|
|
|
namespace Loader {
|
|
|
|
class AppLoader;
|
|
|
|
enum class ResultStatus : u16;
|
|
|
|
} // namespace Loader
|
2018-08-11 20:20:19 -04:00
|
|
|
|
2019-05-30 19:36:18 -04:00
|
|
|
namespace Memory {
|
|
|
|
struct CheatEntry;
|
|
|
|
} // namespace Memory
|
|
|
|
|
2019-03-11 19:33:49 -04:00
|
|
|
namespace Service {
|
|
|
|
|
|
|
|
namespace AM::Applets {
|
|
|
|
struct AppletFrontendSet;
|
|
|
|
class AppletManager;
|
|
|
|
} // namespace AM::Applets
|
|
|
|
|
2019-06-28 22:46:31 -04:00
|
|
|
namespace APM {
|
|
|
|
class Controller;
|
|
|
|
}
|
|
|
|
|
2019-04-23 08:35:33 -04:00
|
|
|
namespace FileSystem {
|
|
|
|
class FileSystemController;
|
|
|
|
} // namespace FileSystem
|
|
|
|
|
2019-06-24 19:27:35 -04:00
|
|
|
namespace Glue {
|
|
|
|
class ARPManager;
|
|
|
|
}
|
|
|
|
|
2019-06-29 17:17:35 -04:00
|
|
|
namespace LM {
|
|
|
|
class Manager;
|
|
|
|
} // namespace LM
|
|
|
|
|
2019-03-11 19:33:49 -04:00
|
|
|
namespace SM {
|
2018-04-20 19:29:04 -04:00
|
|
|
class ServiceManager;
|
2019-03-11 19:33:49 -04:00
|
|
|
} // namespace SM
|
|
|
|
|
|
|
|
} // namespace Service
|
2018-08-31 12:21:34 -04:00
|
|
|
|
|
|
|
namespace Tegra {
|
|
|
|
class DebugContext;
|
|
|
|
class GPU;
|
|
|
|
} // namespace Tegra
|
2018-04-20 19:29:04 -04:00
|
|
|
|
2018-08-03 12:55:58 -04:00
|
|
|
namespace VideoCore {
|
|
|
|
class RendererBase;
|
2018-08-31 12:21:34 -04:00
|
|
|
} // namespace VideoCore
|
2018-08-03 12:55:58 -04:00
|
|
|
|
2019-02-14 12:42:58 -05:00
|
|
|
namespace Core::Timing {
|
|
|
|
class CoreTiming;
|
|
|
|
}
|
|
|
|
|
2019-06-07 20:41:06 -04:00
|
|
|
namespace Core::Hardware {
|
|
|
|
class InterruptManager;
|
|
|
|
}
|
|
|
|
|
2019-11-26 12:33:20 -05:00
|
|
|
namespace Memory {
|
|
|
|
class Memory;
|
|
|
|
}
|
|
|
|
|
2013-09-05 18:33:46 -04:00
|
|
|
namespace Core {
|
|
|
|
|
2018-08-24 21:43:32 -04:00
|
|
|
class ARM_Interface;
|
2018-08-31 12:21:34 -04:00
|
|
|
class Cpu;
|
|
|
|
class ExclusiveMonitor;
|
|
|
|
class FrameLimiter;
|
|
|
|
class PerfStats;
|
2019-05-17 21:45:56 -04:00
|
|
|
class Reporter;
|
2018-08-31 12:21:34 -04:00
|
|
|
class TelemetrySession;
|
|
|
|
|
|
|
|
struct PerfStatsResults;
|
2018-08-24 21:43:32 -04:00
|
|
|
|
2018-11-28 14:00:44 -05:00
|
|
|
FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
|
|
|
|
const std::string& path);
|
|
|
|
|
2016-12-15 19:01:48 -05:00
|
|
|
class System {
|
|
|
|
public:
|
2019-10-06 13:02:23 -04:00
|
|
|
using CurrentBuildProcessID = std::array<u8, 0x20>;
|
|
|
|
|
2018-08-16 10:15:00 -04:00
|
|
|
System(const System&) = delete;
|
|
|
|
System& operator=(const System&) = delete;
|
|
|
|
|
|
|
|
System(System&&) = delete;
|
|
|
|
System& operator=(System&&) = delete;
|
|
|
|
|
2018-04-20 19:29:04 -04:00
|
|
|
~System();
|
|
|
|
|
2016-12-15 19:01:48 -05:00
|
|
|
/**
|
|
|
|
* 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 {
|
2018-08-09 21:06:44 -04:00
|
|
|
Success, ///< Succeeded
|
|
|
|
ErrorNotInitialized, ///< Error trying to use core prior to initialization
|
|
|
|
ErrorGetLoader, ///< Error finding the correct application loader
|
|
|
|
ErrorSystemFiles, ///< Error in finding system files
|
|
|
|
ErrorSharedFont, ///< Error in finding shared font
|
|
|
|
ErrorVideoCore, ///< Error in the video core
|
|
|
|
ErrorUnknown, ///< Any other error
|
|
|
|
ErrorLoader, ///< The base for loader errors (too many to repeat)
|
2016-12-15 19:01:48 -05:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Run the core CPU loop
|
2016-12-17 01:20:47 -05:00
|
|
|
* This function runs the core for the specified number of CPU instructions before trying to
|
|
|
|
* update hardware. This is much faster than SingleStep (and should be equivalent), as the CPU
|
|
|
|
* is not required to do a full dispatch with each instruction. NOTE: the number of instructions
|
|
|
|
* requested is not guaranteed to run, as this will be interrupted preemptively if a hardware
|
|
|
|
* update is requested (e.g. on a thread switch).
|
2018-02-14 12:47:48 -05:00
|
|
|
* @param tight_loop If false, the CPU single-steps.
|
2018-01-23 08:20:18 -05:00
|
|
|
* @return Result status, indicating whether or not the operation succeeded.
|
2016-12-15 19:01:48 -05:00
|
|
|
*/
|
2018-02-14 12:47:48 -05:00
|
|
|
ResultStatus RunLoop(bool tight_loop = true);
|
2016-12-15 19:01:48 -05:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Step the CPU one instruction
|
2018-01-23 08:20:18 -05:00
|
|
|
* @return Result status, indicating whether or not the operation succeeded.
|
2016-12-15 19:01:48 -05:00
|
|
|
*/
|
|
|
|
ResultStatus SingleStep();
|
|
|
|
|
2018-08-06 22:01:24 -04:00
|
|
|
/**
|
|
|
|
* Invalidate the CPU instruction caches
|
|
|
|
* This function should only be used by GDB Stub to support breakpoints, memory updates and
|
|
|
|
* step/continue commands.
|
|
|
|
*/
|
2018-08-30 10:50:54 -04:00
|
|
|
void InvalidateCpuInstructionCaches();
|
2018-08-06 22:01:24 -04:00
|
|
|
|
2016-12-15 19:01:48 -05:00
|
|
|
/// Shutdown the emulated system.
|
|
|
|
void Shutdown();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Load an executable application.
|
2018-08-01 20:59:42 -04:00
|
|
|
* @param emu_window Reference to the host-system window used for video output and keyboard
|
|
|
|
* input.
|
2016-12-15 19:01:48 -05:00
|
|
|
* @param filepath String path to the executable application to load on the host file system.
|
|
|
|
* @returns ResultStatus code, indicating if the operation succeeded.
|
|
|
|
*/
|
2018-08-11 20:20:19 -04:00
|
|
|
ResultStatus Load(Frontend::EmuWindow& emu_window, const std::string& filepath);
|
2016-12-15 19:01:48 -05:00
|
|
|
|
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*/
|
2018-08-30 10:50:54 -04:00
|
|
|
bool IsPoweredOn() const;
|
2016-12-15 19:01:48 -05:00
|
|
|
|
2018-10-28 17:37:31 -04:00
|
|
|
/// Gets a reference to the telemetry session for this emulation session.
|
|
|
|
Core::TelemetrySession& TelemetrySession();
|
|
|
|
|
|
|
|
/// Gets a reference to the telemetry session for this emulation session.
|
|
|
|
const Core::TelemetrySession& TelemetrySession() const;
|
2017-05-02 00:09:15 -04:00
|
|
|
|
2016-12-16 00:37:38 -05:00
|
|
|
/// Prepare the core emulation for a reschedule
|
|
|
|
void PrepareReschedule();
|
|
|
|
|
2019-04-02 09:22:53 -04:00
|
|
|
/// Prepare the core emulation for a reschedule
|
2019-06-19 09:11:18 -04:00
|
|
|
void PrepareReschedule(u32 core_index);
|
2019-04-02 09:22:53 -04:00
|
|
|
|
2018-05-10 19:34:21 -04:00
|
|
|
/// Gets and resets core performance statistics
|
2018-08-31 12:21:34 -04:00
|
|
|
PerfStatsResults GetAndResetPerfStats();
|
2017-02-19 17:34:47 -05:00
|
|
|
|
2018-05-10 19:34:21 -04:00
|
|
|
/// Gets an ARM interface to the CPU core that is currently running
|
2018-08-30 10:50:54 -04:00
|
|
|
ARM_Interface& CurrentArmInterface();
|
2018-05-02 22:36:51 -04:00
|
|
|
|
2018-10-28 17:37:31 -04:00
|
|
|
/// Gets an ARM interface to the CPU core that is currently running
|
|
|
|
const ARM_Interface& CurrentArmInterface() const;
|
|
|
|
|
2018-07-03 09:28:46 -04:00
|
|
|
/// Gets the index of the currently running CPU core
|
2018-10-28 17:37:31 -04:00
|
|
|
std::size_t CurrentCoreIndex() const;
|
2018-08-30 10:50:54 -04:00
|
|
|
|
|
|
|
/// Gets the scheduler for the CPU core that is currently running
|
|
|
|
Kernel::Scheduler& CurrentScheduler();
|
2018-07-03 09:28:46 -04:00
|
|
|
|
2018-10-28 17:37:31 -04:00
|
|
|
/// Gets the scheduler for the CPU core that is currently running
|
|
|
|
const Kernel::Scheduler& CurrentScheduler() const;
|
|
|
|
|
|
|
|
/// Gets a reference to an ARM interface for the CPU core with the specified index
|
2018-09-15 09:21:06 -04:00
|
|
|
ARM_Interface& ArmInterface(std::size_t core_index);
|
2016-12-15 19:01:48 -05:00
|
|
|
|
2018-10-28 17:37:31 -04:00
|
|
|
/// Gets a const reference to an ARM interface from the CPU core with the specified index
|
|
|
|
const ARM_Interface& ArmInterface(std::size_t core_index) const;
|
|
|
|
|
2018-05-10 19:34:21 -04:00
|
|
|
/// Gets a CPU interface to the CPU core with the specified index
|
2018-09-15 09:21:06 -04:00
|
|
|
Cpu& CpuCore(std::size_t core_index);
|
2018-05-05 23:54:43 -04:00
|
|
|
|
2018-10-15 09:25:11 -04:00
|
|
|
/// Gets a CPU interface to the CPU core with the specified index
|
|
|
|
const Cpu& CpuCore(std::size_t core_index) const;
|
|
|
|
|
2018-10-28 17:37:31 -04:00
|
|
|
/// Gets a reference to the exclusive monitor
|
2018-08-30 10:50:54 -04:00
|
|
|
ExclusiveMonitor& Monitor();
|
|
|
|
|
2018-10-28 17:37:31 -04:00
|
|
|
/// Gets a constant reference to the exclusive monitor
|
|
|
|
const ExclusiveMonitor& Monitor() const;
|
|
|
|
|
2019-11-26 12:33:20 -05:00
|
|
|
/// Gets a mutable reference to the system memory instance.
|
|
|
|
Memory::Memory& Memory();
|
|
|
|
|
|
|
|
/// Gets a constant reference to the system memory instance.
|
|
|
|
const Memory::Memory& Memory() const;
|
|
|
|
|
2018-08-03 12:55:58 -04:00
|
|
|
/// Gets a mutable reference to the GPU interface
|
2018-08-30 10:50:54 -04:00
|
|
|
Tegra::GPU& GPU();
|
2018-02-11 23:44:12 -05:00
|
|
|
|
2018-08-03 12:55:58 -04:00
|
|
|
/// Gets an immutable reference to the GPU interface.
|
2018-08-30 10:50:54 -04:00
|
|
|
const Tegra::GPU& GPU() const;
|
2018-08-03 12:55:58 -04:00
|
|
|
|
|
|
|
/// Gets a mutable reference to the renderer.
|
2018-08-30 10:50:54 -04:00
|
|
|
VideoCore::RendererBase& Renderer();
|
2018-08-03 12:55:58 -04:00
|
|
|
|
|
|
|
/// Gets an immutable reference to the renderer.
|
2018-08-30 10:50:54 -04:00
|
|
|
const VideoCore::RendererBase& Renderer() const;
|
2018-07-03 09:28:46 -04:00
|
|
|
|
2018-05-10 19:34:21 -04:00
|
|
|
/// Gets the scheduler for the CPU core with the specified index
|
2018-10-15 09:25:11 -04:00
|
|
|
Kernel::Scheduler& Scheduler(std::size_t core_index);
|
|
|
|
|
|
|
|
/// Gets the scheduler for the CPU core with the specified index
|
|
|
|
const Kernel::Scheduler& Scheduler(std::size_t core_index) const;
|
2018-02-18 15:17:16 -05:00
|
|
|
|
2019-03-29 17:02:57 -04:00
|
|
|
/// Gets the global scheduler
|
|
|
|
Kernel::GlobalScheduler& GlobalScheduler();
|
|
|
|
|
|
|
|
/// Gets the global scheduler
|
|
|
|
const Kernel::GlobalScheduler& GlobalScheduler() const;
|
|
|
|
|
2018-10-10 00:42:10 -04:00
|
|
|
/// Provides a pointer to the current process
|
|
|
|
Kernel::Process* CurrentProcess();
|
2018-03-13 17:49:59 -04:00
|
|
|
|
2018-10-10 00:42:10 -04:00
|
|
|
/// Provides a constant pointer to the current process.
|
|
|
|
const Kernel::Process* CurrentProcess() const;
|
2018-09-06 20:34:51 -04:00
|
|
|
|
2019-02-14 12:42:58 -05:00
|
|
|
/// Provides a reference to the core timing instance.
|
|
|
|
Timing::CoreTiming& CoreTiming();
|
|
|
|
|
|
|
|
/// Provides a constant reference to the core timing instance.
|
|
|
|
const Timing::CoreTiming& CoreTiming() const;
|
|
|
|
|
2019-06-07 20:41:06 -04:00
|
|
|
/// Provides a reference to the interrupt manager instance.
|
|
|
|
Core::Hardware::InterruptManager& InterruptManager();
|
|
|
|
|
|
|
|
/// Provides a constant reference to the interrupt manager instance.
|
|
|
|
const Core::Hardware::InterruptManager& InterruptManager() const;
|
|
|
|
|
2018-08-28 12:30:33 -04:00
|
|
|
/// Provides a reference to the kernel instance.
|
|
|
|
Kernel::KernelCore& Kernel();
|
|
|
|
|
|
|
|
/// Provides a constant reference to the kernel instance.
|
|
|
|
const Kernel::KernelCore& Kernel() const;
|
|
|
|
|
2018-08-30 10:50:54 -04:00
|
|
|
/// Provides a reference to the internal PerfStats instance.
|
|
|
|
Core::PerfStats& GetPerfStats();
|
2018-08-23 14:12:56 -04:00
|
|
|
|
2018-08-30 10:50:54 -04:00
|
|
|
/// Provides a constant reference to the internal PerfStats instance.
|
|
|
|
const Core::PerfStats& GetPerfStats() const;
|
2017-02-19 17:34:47 -05:00
|
|
|
|
2018-08-30 10:50:54 -04:00
|
|
|
/// Provides a reference to the frame limiter;
|
|
|
|
Core::FrameLimiter& FrameLimiter();
|
2017-04-13 01:15:23 -04:00
|
|
|
|
2018-08-30 10:50:54 -04:00
|
|
|
/// Provides a constant referent to the frame limiter
|
|
|
|
const Core::FrameLimiter& FrameLimiter() const;
|
2017-03-08 16:28:30 -05:00
|
|
|
|
2018-08-30 10:50:54 -04:00
|
|
|
/// Gets the name of the current game
|
|
|
|
Loader::ResultStatus GetGameName(std::string& out) const;
|
|
|
|
|
|
|
|
void SetStatus(ResultStatus new_status, const char* details);
|
|
|
|
|
|
|
|
const std::string& GetStatusDetails() const;
|
|
|
|
|
|
|
|
Loader::AppLoader& GetAppLoader() const;
|
2017-08-01 19:53:35 -04:00
|
|
|
|
2018-04-20 19:29:04 -04:00
|
|
|
Service::SM::ServiceManager& ServiceManager();
|
|
|
|
const Service::SM::ServiceManager& ServiceManager() const;
|
|
|
|
|
2018-08-30 10:50:54 -04:00
|
|
|
void SetGPUDebugContext(std::shared_ptr<Tegra::DebugContext> context);
|
2018-03-25 00:35:06 -04:00
|
|
|
|
2018-09-04 08:06:52 -04:00
|
|
|
Tegra::DebugContext* GetGPUDebugContext() const;
|
2018-03-25 00:35:06 -04:00
|
|
|
|
2018-08-31 12:21:34 -04:00
|
|
|
void SetFilesystem(std::shared_ptr<FileSys::VfsFilesystem> vfs);
|
2018-08-03 11:51:48 -04:00
|
|
|
|
2018-08-31 12:21:34 -04:00
|
|
|
std::shared_ptr<FileSys::VfsFilesystem> GetFilesystem() const;
|
2018-08-03 11:51:48 -04:00
|
|
|
|
2019-05-30 19:36:18 -04:00
|
|
|
void RegisterCheatList(const std::vector<Memory::CheatEntry>& list,
|
|
|
|
const std::array<u8, 0x20>& build_id, VAddr main_region_begin,
|
|
|
|
u64 main_region_size);
|
2018-12-22 21:32:05 -05:00
|
|
|
|
2019-03-11 19:33:49 -04:00
|
|
|
void SetAppletFrontendSet(Service::AM::Applets::AppletFrontendSet&& set);
|
2018-11-11 16:39:25 -05:00
|
|
|
|
2019-03-11 19:33:49 -04:00
|
|
|
void SetDefaultAppletFrontendSet();
|
2018-11-11 16:39:25 -05:00
|
|
|
|
2019-03-11 19:33:49 -04:00
|
|
|
Service::AM::Applets::AppletManager& GetAppletManager();
|
2018-12-24 16:22:07 -05:00
|
|
|
|
2019-03-11 19:33:49 -04:00
|
|
|
const Service::AM::Applets::AppletManager& GetAppletManager() const;
|
2018-12-24 16:22:07 -05:00
|
|
|
|
2018-12-28 00:03:01 -05:00
|
|
|
void SetContentProvider(std::unique_ptr<FileSys::ContentProviderUnion> provider);
|
|
|
|
|
|
|
|
FileSys::ContentProvider& GetContentProvider();
|
|
|
|
|
|
|
|
const FileSys::ContentProvider& GetContentProvider() const;
|
|
|
|
|
2019-04-23 08:35:33 -04:00
|
|
|
Service::FileSystem::FileSystemController& GetFileSystemController();
|
|
|
|
|
|
|
|
const Service::FileSystem::FileSystemController& GetFileSystemController() const;
|
|
|
|
|
2018-12-28 00:03:01 -05:00
|
|
|
void RegisterContentProvider(FileSys::ContentProviderUnionSlot slot,
|
|
|
|
FileSys::ContentProvider* provider);
|
|
|
|
|
|
|
|
void ClearContentProvider(FileSys::ContentProviderUnionSlot slot);
|
|
|
|
|
2019-05-17 21:45:56 -04:00
|
|
|
const Reporter& GetReporter() const;
|
|
|
|
|
2019-06-24 19:27:35 -04:00
|
|
|
Service::Glue::ARPManager& GetARPManager();
|
|
|
|
|
|
|
|
const Service::Glue::ARPManager& GetARPManager() const;
|
|
|
|
|
2019-06-28 22:46:31 -04:00
|
|
|
Service::APM::Controller& GetAPMController();
|
|
|
|
|
|
|
|
const Service::APM::Controller& GetAPMController() const;
|
|
|
|
|
2019-06-29 17:17:35 -04:00
|
|
|
Service::LM::Manager& GetLogManager();
|
|
|
|
|
|
|
|
const Service::LM::Manager& GetLogManager() const;
|
|
|
|
|
2019-07-06 13:08:33 -04:00
|
|
|
void SetExitLock(bool locked);
|
|
|
|
|
|
|
|
bool GetExitLock() const;
|
|
|
|
|
2019-10-06 13:02:23 -04:00
|
|
|
void SetCurrentProcessBuildID(const CurrentBuildProcessID& id);
|
2019-04-28 18:43:48 -04:00
|
|
|
|
2019-10-06 13:02:23 -04:00
|
|
|
const CurrentBuildProcessID& GetCurrentProcessBuildID() const;
|
2019-04-28 18:43:48 -04:00
|
|
|
|
2016-12-15 19:01:48 -05:00
|
|
|
private:
|
2018-07-18 18:15:16 -04:00
|
|
|
System();
|
|
|
|
|
2018-05-07 22:57:39 -04:00
|
|
|
/// Returns the currently running CPU core
|
|
|
|
Cpu& CurrentCpuCore();
|
2018-05-02 21:26:14 -04:00
|
|
|
|
2018-10-28 17:37:31 -04:00
|
|
|
/// Returns the currently running CPU core
|
|
|
|
const Cpu& CurrentCpuCore() const;
|
|
|
|
|
2016-12-16 00:37:38 -05:00
|
|
|
/**
|
|
|
|
* Initialize the emulated system.
|
2018-08-01 20:59:42 -04:00
|
|
|
* @param emu_window Reference to the host-system window used for video output and keyboard
|
|
|
|
* input.
|
2016-12-16 00:37:38 -05:00
|
|
|
* @return ResultStatus code, indicating if the operation succeeded.
|
|
|
|
*/
|
2018-08-11 20:20:19 -04:00
|
|
|
ResultStatus Init(Frontend::EmuWindow& emu_window);
|
2016-12-16 00:37:38 -05:00
|
|
|
|
2018-08-30 10:50:54 -04:00
|
|
|
struct Impl;
|
|
|
|
std::unique_ptr<Impl> impl;
|
2017-05-02 00:09:15 -04:00
|
|
|
|
2016-12-15 19:01:48 -05:00
|
|
|
static System s_instance;
|
|
|
|
};
|
2013-09-05 18:33:46 -04:00
|
|
|
|
2016-12-15 19:01:48 -05:00
|
|
|
} // namespace Core
|