Duckstation/src/core/system.h

229 lines
6.9 KiB
C
Raw Normal View History

2019-09-09 07:01:26 +00:00
#pragma once
#include "common/timer.h"
2019-11-07 15:07:39 +00:00
#include "host_interface.h"
#include "timing_event.h"
#include "types.h"
#include <memory>
#include <optional>
#include <string>
2019-09-09 07:01:26 +00:00
2019-09-14 10:28:47 +00:00
class ByteStream;
class CDImage;
2019-09-14 10:28:47 +00:00
class StateWrapper;
namespace CPU {
2019-09-12 02:53:04 +00:00
class Core;
class CodeCache;
} // namespace CPU
2019-09-12 02:53:04 +00:00
class Bus;
class DMA;
2019-09-17 06:26:00 +00:00
class InterruptController;
2019-09-12 02:53:04 +00:00
class GPU;
2019-09-17 09:22:39 +00:00
class CDROM;
class Pad;
class Controller;
2019-09-20 13:40:19 +00:00
class Timers;
class SPU;
2019-09-29 02:51:34 +00:00
class MDEC;
class SIO;
2019-09-12 02:53:04 +00:00
struct SystemBootParameters
{
SystemBootParameters();
SystemBootParameters(std::string filename_);
~SystemBootParameters();
std::string filename;
std::string state_filename;
std::optional<bool> override_fast_boot;
std::optional<bool> override_fullscreen;
};
2019-09-09 07:01:26 +00:00
class System
{
public:
friend TimingEvent;
2019-09-09 07:01:26 +00:00
~System();
/// Returns the preferred console type for a disc.
static ConsoleRegion GetConsoleRegionForDiscRegion(DiscRegion region);
/// Creates a new System.
static std::unique_ptr<System> Create(HostInterface* host_interface);
// Accessing components.
2019-09-12 14:18:13 +00:00
HostInterface* GetHostInterface() const { return m_host_interface; }
CPU::Core* GetCPU() const { return m_cpu.get(); }
Bus* GetBus() const { return m_bus.get(); }
DMA* GetDMA() const { return m_dma.get(); }
InterruptController* GetInterruptController() const { return m_interrupt_controller.get(); }
GPU* GetGPU() const { return m_gpu.get(); }
CDROM* GetCDROM() const { return m_cdrom.get(); }
Pad* GetPad() const { return m_pad.get(); }
Timers* GetTimers() const { return m_timers.get(); }
2019-10-10 16:20:21 +00:00
SPU* GetSPU() const { return m_spu.get(); }
MDEC* GetMDEC() const { return m_mdec.get(); }
2019-09-12 14:18:13 +00:00
ConsoleRegion GetRegion() const { return m_region; }
bool IsPALRegion() const { return m_region == ConsoleRegion::PAL; }
u32 GetFrameNumber() const { return m_frame_number; }
u32 GetInternalFrameNumber() const { return m_internal_frame_number; }
2019-10-04 10:48:29 +00:00
u32 GetGlobalTickCounter() const { return m_global_tick_counter; }
void IncrementFrameNumber()
{
m_frame_number++;
m_frame_done = true;
}
void IncrementInternalFrameNumber() { m_internal_frame_number++; }
2019-11-07 15:07:39 +00:00
const Settings& GetSettings() { return m_host_interface->GetSettings(); }
const std::string& GetRunningPath() const { return m_running_game_path; }
const std::string& GetRunningCode() const { return m_running_game_code; }
const std::string& GetRunningTitle() const { return m_running_game_title; }
float GetFPS() const { return m_fps; }
float GetVPS() const { return m_vps; }
float GetEmulationSpeed() const { return m_speed; }
float GetAverageFrameTime() const { return m_average_frame_time; }
float GetWorstFrameTime() const { return m_worst_frame_time; }
bool Boot(const SystemBootParameters& params);
2019-09-09 07:01:26 +00:00
void Reset();
2019-09-14 10:28:47 +00:00
bool LoadState(ByteStream* state);
bool SaveState(ByteStream* state);
/// Recreates the GPU component, saving/loading the state so it is preserved. Call when the GPU renderer changes.
bool RecreateGPU(GPURenderer renderer);
/// Updates GPU settings, without recreating the renderer.
void UpdateGPUSettings();
/// Forcibly changes the CPU execution mode, ignoring settings.
void SetCPUExecutionMode(CPUExecutionMode mode);
2019-09-09 07:01:26 +00:00
void RunFrame();
/// Adjusts the throttle frequency, i.e. how many times we should sleep per second.
void SetThrottleFrequency(float frequency);
/// Updates the throttle period, call when target emulation speed changes.
void UpdateThrottlePeriod();
/// Throttles the system, i.e. sleeps until it's time to execute the next frame.
void Throttle();
void UpdatePerformanceCounters();
void ResetPerformanceCounters();
bool LoadEXE(const char* filename, std::vector<u8>& bios_image);
bool LoadEXEFromBuffer(const void* buffer, u32 buffer_size, std::vector<u8>& bios_image);
bool LoadPSF(const char* filename, std::vector<u8>& bios_image);
2019-09-22 15:28:00 +00:00
bool SetExpansionROM(const char* filename);
// Adds ticks to the global tick counter, simulating the CPU being stalled.
void StallCPU(TickCount ticks);
// Access controllers for simulating input.
Controller* GetController(u32 slot) const;
void UpdateControllers();
2019-10-27 06:45:23 +00:00
void UpdateMemoryCards();
2019-09-20 10:14:00 +00:00
bool HasMedia() const;
bool InsertMedia(const char* path);
void RemoveMedia();
/// Creates a new event.
std::unique_ptr<TimingEvent> CreateTimingEvent(std::string name, TickCount period, TickCount interval,
TimingEventCallback callback, bool activate);
2019-09-09 07:01:26 +00:00
private:
System(HostInterface* host_interface);
2019-09-14 10:28:47 +00:00
bool DoState(StateWrapper& sw);
bool CreateGPU(GPURenderer renderer);
void InitializeComponents();
void DestroyComponents();
// Active event management
void AddActiveEvent(TimingEvent* event);
void RemoveActiveEvent(TimingEvent* event);
void SortEvents();
// Runs any pending events. Call when CPU downcount is zero.
void RunEvents();
// Updates the downcount of the CPU (event scheduling).
void UpdateCPUDowncount();
bool DoEventsState(StateWrapper& sw);
// Event lookup, use with care.
// If you modify an event, call SortEvents afterwards.
TimingEvent* FindActiveEvent(const char* name);
// Event enumeration, use with care.
// Don't remove an event while enumerating the list, as it will invalidate the iterator.
template<typename T>
void EnumerateActiveEvents(T callback) const
{
for (const TimingEvent* ev : m_events)
callback(ev);
}
2019-09-14 10:28:47 +00:00
void UpdateRunningGame(const char* path, CDImage* image);
2019-09-12 14:18:13 +00:00
HostInterface* m_host_interface;
2019-09-12 02:53:04 +00:00
std::unique_ptr<CPU::Core> m_cpu;
std::unique_ptr<CPU::CodeCache> m_cpu_code_cache;
2019-09-12 02:53:04 +00:00
std::unique_ptr<Bus> m_bus;
std::unique_ptr<DMA> m_dma;
2019-09-17 06:26:00 +00:00
std::unique_ptr<InterruptController> m_interrupt_controller;
2019-09-12 02:53:04 +00:00
std::unique_ptr<GPU> m_gpu;
2019-09-17 09:22:39 +00:00
std::unique_ptr<CDROM> m_cdrom;
std::unique_ptr<Pad> m_pad;
2019-09-20 13:40:19 +00:00
std::unique_ptr<Timers> m_timers;
std::unique_ptr<SPU> m_spu;
2019-09-29 02:51:34 +00:00
std::unique_ptr<MDEC> m_mdec;
std::unique_ptr<SIO> m_sio;
ConsoleRegion m_region = ConsoleRegion::NTSC_U;
2019-11-23 10:22:09 +00:00
CPUExecutionMode m_cpu_execution_mode = CPUExecutionMode::Interpreter;
u32 m_frame_number = 1;
u32 m_internal_frame_number = 1;
2019-10-04 10:48:29 +00:00
u32 m_global_tick_counter = 0;
std::vector<TimingEvent*> m_events;
u32 m_last_event_run_time = 0;
bool m_running_events = false;
bool m_events_need_sorting = false;
bool m_frame_done = false;
std::string m_running_game_path;
std::string m_running_game_code;
std::string m_running_game_title;
float m_throttle_frequency = 60.0f;
s32 m_throttle_period = 0;
u64 m_last_throttle_time = 0;
Common::Timer m_throttle_timer;
Common::Timer m_speed_lost_time_timestamp;
float m_average_frame_time_accumulator = 0.0f;
float m_worst_frame_time_accumulator = 0.0f;
float m_vps = 0.0f;
float m_fps = 0.0f;
float m_speed = 0.0f;
float m_worst_frame_time = 0.0f;
float m_average_frame_time = 0.0f;
u32 m_last_frame_number = 0;
u32 m_last_internal_frame_number = 0;
u32 m_last_global_tick_counter = 0;
Common::Timer m_fps_timer;
Common::Timer m_frame_timer;
2019-09-09 07:01:26 +00:00
};