Emulation/Mesen2
1
0
Fork 0
mirror of https://github.com/SourMesen/Mesen2.git synced 2024-06-22 22:22:51 -04:00
Code Issues Packages Projects Releases Wiki Activity

Core: Reduce shared_ptr usage, refactor netplay code to remove static instances

Browse source
This commit is contained in:
Sour 2022-01-21 21:25:33 -05:00
parent 4244928bd8
commit 0d78c064f3
133 changed files with 729 additions and 755 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
Core/Debugger/BaseTraceLogger.h
View file

@ -399,7 +399,7 @@ public:
_debugger = debugger;
_console = debugger->GetConsole();
_settings = debugger->GetEmulator()->GetSettings();
_labelManager = debugger->GetLabelManager().get();
_labelManager = debugger->GetLabelManager();
_memoryDumper = debugger->GetMemoryDumper();
_options = {};
_currentPos = 0;

34
Core/Debugger/Debugger.cpp
View file

@ -99,7 +99,7 @@ Debugger::Debugger(Emulator* emu, IConsole* console)
}
string cdlFile = FolderUtilities::CombinePath(FolderUtilities::GetDebuggerFolder(), FolderUtilities::GetFilename(_emu->GetRomInfo().RomFile.GetFileName(), false) + ".cdl");
shared_ptr<CodeDataLogger> cdl = _debuggers[(int)_mainCpuType].Debugger->GetCodeDataLogger();
CodeDataLogger* cdl = _debuggers[(int)_mainCpuType].Debugger->GetCodeDataLogger();
if(cdl) {
cdl->LoadCdlFile(cdlFile, _settings->CheckDebuggerFlag(DebuggerFlags::AutoResetCdl), _emu->GetCrc32());
}
@ -123,7 +123,7 @@ Debugger::~Debugger()
void Debugger::Release()
{
string cdlFile = FolderUtilities::CombinePath(FolderUtilities::GetDebuggerFolder(), FolderUtilities::GetFilename(_emu->GetRomInfo().RomFile.GetFileName(), false) + ".cdl");
shared_ptr<CodeDataLogger> cdl = _debuggers[(int)_mainCpuType].Debugger->GetCodeDataLogger();
CodeDataLogger* cdl = _debuggers[(int)_mainCpuType].Debugger->GetCodeDataLogger();
if(cdl) {
cdl->SaveCdlFile(cdlFile, _emu->GetCrc32());
}
@ -283,7 +283,7 @@ void Debugger::ProcessEvent(EventType type)
case EventType::StartFrame: {
_emu->GetNotificationManager()->SendNotification(ConsoleNotificationType::EventViewerRefresh, (void*)_mainCpuType);
shared_ptr<BaseEventManager> evtMgr = GetEventManager(_mainCpuType);
BaseEventManager* evtMgr = GetEventManager(_mainCpuType);
if(evtMgr) {
evtMgr->ClearFrameEvents();
}
@ -530,7 +530,7 @@ void Debugger::RefreshCodeCache()
void Debugger::RebuildPrgCache(CpuType cpuType)
{
shared_ptr<CodeDataLogger> cdl = GetCodeDataLogger(cpuType);
CodeDataLogger* cdl = GetCodeDataLogger(cpuType);
if(!cdl) {
return;
}
@ -549,7 +549,7 @@ void Debugger::RebuildPrgCache(CpuType cpuType)
void Debugger::GetCdlData(uint32_t offset, uint32_t length, SnesMemoryType memoryType, uint8_t* cdlData)
{
CpuType cpuType = DebugUtilities::ToCpuType(memoryType);
shared_ptr<CodeDataLogger> cdl = GetCodeDataLogger(cpuType);
CodeDataLogger* cdl = GetCodeDataLogger(cpuType);
SnesMemoryType prgType = cdl->GetPrgMemoryType();
if(memoryType == prgType) {
cdl->GetCdlData(offset, length, cdlData);
@ -693,12 +693,12 @@ MemoryDumper* Debugger::GetMemoryDumper()
return _memoryDumper.get();
}
shared_ptr<MemoryAccessCounter> Debugger::GetMemoryAccessCounter()
MemoryAccessCounter* Debugger::GetMemoryAccessCounter()
{
return _memoryAccessCounter;
return _memoryAccessCounter.get();
}
shared_ptr<CodeDataLogger> Debugger::GetCodeDataLogger(CpuType cpuType)
CodeDataLogger* Debugger::GetCodeDataLogger(CpuType cpuType)
{
if(_debuggers[(int)cpuType].Debugger) {
return _debuggers[(int)cpuType].Debugger->GetCodeDataLogger();
@ -706,9 +706,9 @@ shared_ptr<CodeDataLogger> Debugger::GetCodeDataLogger(CpuType cpuType)
throw std::runtime_error("GetCodeDataLogger() - Unsupported CPU type");
}
shared_ptr<Disassembler> Debugger::GetDisassembler()
Disassembler* Debugger::GetDisassembler()
{
return _disassembler;
return _disassembler.get();
}
PpuTools* Debugger::GetPpuTools(CpuType cpuType)
@ -719,7 +719,7 @@ PpuTools* Debugger::GetPpuTools(CpuType cpuType)
return nullptr;
}
shared_ptr<BaseEventManager> Debugger::GetEventManager(CpuType cpuType)
BaseEventManager* Debugger::GetEventManager(CpuType cpuType)
{
if(_debuggers[(int)cpuType].Debugger) {
return _debuggers[(int)cpuType].Debugger->GetEventManager();
@ -727,17 +727,17 @@ shared_ptr<BaseEventManager> Debugger::GetEventManager(CpuType cpuType)
return nullptr;
}
shared_ptr<LabelManager> Debugger::GetLabelManager()
LabelManager* Debugger::GetLabelManager()
{
return _labelManager;
return _labelManager.get();
}
shared_ptr<ScriptManager> Debugger::GetScriptManager()
ScriptManager* Debugger::GetScriptManager()
{
return _scriptManager;
return _scriptManager.get();
}
shared_ptr<CallstackManager> Debugger::GetCallstackManager(CpuType cpuType)
CallstackManager* Debugger::GetCallstackManager(CpuType cpuType)
{
if(_debuggers[(int)cpuType].Debugger) {
return _debuggers[(int)cpuType].Debugger->GetCallstackManager();
@ -755,7 +755,7 @@ Emulator* Debugger::GetEmulator()
return _emu;
}
shared_ptr<IAssembler> Debugger::GetAssembler(CpuType cpuType)
IAssembler* Debugger::GetAssembler(CpuType cpuType)
{
if(_debuggers[(int)cpuType].Debugger) {
return _debuggers[(int)cpuType].Debugger->GetAssembler();

28
Core/Debugger/Debugger.h
View file

@ -60,12 +60,12 @@ private:
vector<CpuType> _cpuTypes;
ConsoleType _consoleType = ConsoleType::Snes;
shared_ptr<ScriptManager> _scriptManager;
shared_ptr<MemoryDumper> _memoryDumper;
shared_ptr<MemoryAccessCounter> _memoryAccessCounter;
shared_ptr<CodeDataLogger> _codeDataLogger;
shared_ptr<Disassembler> _disassembler;
shared_ptr<LabelManager> _labelManager;
unique_ptr<ScriptManager> _scriptManager;
unique_ptr<MemoryDumper> _memoryDumper;
unique_ptr<MemoryAccessCounter> _memoryAccessCounter;
unique_ptr<CodeDataLogger> _codeDataLogger;
unique_ptr<Disassembler> _disassembler;
unique_ptr<LabelManager> _labelManager;
unique_ptr<TraceLogFileSaver> _traceLogSaver;
@ -142,15 +142,15 @@ public:
TraceLogFileSaver* GetTraceLogFileSaver();
ITraceLogger* GetTraceLogger(CpuType cpuType);
MemoryDumper* GetMemoryDumper();
shared_ptr<MemoryAccessCounter> GetMemoryAccessCounter();
shared_ptr<CodeDataLogger> GetCodeDataLogger(CpuType cpuType);
shared_ptr<Disassembler> GetDisassembler();
MemoryAccessCounter* GetMemoryAccessCounter();
CodeDataLogger* GetCodeDataLogger(CpuType cpuType);
Disassembler* GetDisassembler();
PpuTools* GetPpuTools(CpuType cpuType);
shared_ptr<BaseEventManager> GetEventManager(CpuType cpuType);
shared_ptr<LabelManager> GetLabelManager();
shared_ptr<ScriptManager> GetScriptManager();
shared_ptr<CallstackManager> GetCallstackManager(CpuType cpuType);
BaseEventManager* GetEventManager(CpuType cpuType);
LabelManager* GetLabelManager();
ScriptManager* GetScriptManager();
CallstackManager* GetCallstackManager(CpuType cpuType);
IConsole* GetConsole();
Emulator* GetEmulator();
shared_ptr<IAssembler> GetAssembler(CpuType cpuType);
IAssembler* GetAssembler(CpuType cpuType);
};

6
Core/Debugger/Disassembler.cpp
View file

@ -122,7 +122,7 @@ vector<DisassemblyResult> Disassembler::Disassemble(CpuType cpuType, uint16_t ba
AddressInfo prevAddrInfo = {};
int byteCounter = 0;
shared_ptr<CodeDataLogger> cdl = _debugger->GetCodeDataLogger(cpuType);
CodeDataLogger* cdl = _debugger->GetCodeDataLogger(cpuType);
SnesMemoryType cdlMemType = cdl->GetPrgMemoryType();
AddressInfo relAddress = {};
@ -345,7 +345,7 @@ CodeLineData Disassembler::GetLineData(DisassemblyResult& row, CpuType type, Sne
state.PC = (uint16_t)row.CpuAddress;
state.K = (row.CpuAddress >> 16);
CodeDataLogger* cdl = _debugger->GetCodeDataLogger(lineCpuType).get();
CodeDataLogger* cdl = _debugger->GetCodeDataLogger(lineCpuType);
if(!disInfo.IsInitialized()) {
disInfo = DisassemblyInfo(src.Data + row.Address.Address, state.PS, lineCpuType);
} else {
@ -454,7 +454,7 @@ CodeLineData Disassembler::GetLineData(DisassemblyResult& row, CpuType type, Sne
}
string text;
disInfo.GetDisassembly(text, row.CpuAddress, _labelManager.get(), _settings);
disInfo.GetDisassembly(text, row.CpuAddress, _labelManager, _settings);
memcpy(data.Text, text.c_str(), std::min<int>((int)text.size(), 1000));
disInfo.GetByteCode(data.ByteCode);

2
Core/Debugger/Disassembler.h
View file

@ -27,7 +27,7 @@ private:
IConsole *_console;
EmuSettings* _settings;
Debugger *_debugger;
shared_ptr<LabelManager> _labelManager;
LabelManager* _labelManager;
MemoryDumper *_memoryDumper;
DisassemblerSource _sources[(int)SnesMemoryType::Register] = {};

2
Core/Debugger/ExpressionEvaluator.cpp
View file

@ -661,7 +661,7 @@ int32_t ExpressionEvaluator::Evaluate(ExpressionData &data, BaseState &state, Ev
ExpressionEvaluator::ExpressionEvaluator(Debugger* debugger, CpuType cpuType)
{
_debugger = debugger;
_labelManager = debugger->GetLabelManager().get();
_labelManager = debugger->GetLabelManager();
_cpuType = cpuType;
_cpuMemory = DebugUtilities::GetCpuMemoryType(cpuType);
}

8
Core/Debugger/IDebugger.h
View file

@ -27,10 +27,10 @@ public:
virtual void ProcessInterrupt(uint32_t originalPc, uint32_t currentPc, bool forNmi) {}
virtual BreakpointManager* GetBreakpointManager() = 0;
virtual shared_ptr<CallstackManager> GetCallstackManager() = 0;
virtual shared_ptr<IAssembler> GetAssembler() = 0;
virtual shared_ptr<BaseEventManager> GetEventManager() = 0;
virtual shared_ptr<CodeDataLogger> GetCodeDataLogger() = 0;
virtual CallstackManager* GetCallstackManager() = 0;
virtual IAssembler* GetAssembler() = 0;
virtual BaseEventManager* GetEventManager() = 0;
virtual CodeDataLogger* GetCodeDataLogger() = 0;
virtual ITraceLogger* GetTraceLogger() = 0;
virtual PpuTools* GetPpuTools() { return nullptr; }

2
Core/Debugger/LuaApi.cpp
View file

@ -215,7 +215,7 @@ int LuaApi::GetLabelAddress(lua_State *lua)
checkparams();
errorCond(label.length() == 0, "label cannot be empty");
std::shared_ptr<LabelManager> lblMan = _debugger->GetLabelManager();
LabelManager* lblMan = _debugger->GetLabelManager();
int32_t value = lblMan->GetLabelRelativeAddress(label);
if(value == -2) {
//Check to see if the label is a multi-byte label instead

10
Core/Debugger/MemoryDumper.cpp
View file

@ -25,15 +25,15 @@ MemoryDumper::MemoryDumper(Debugger* debugger)
{
_debugger = debugger;
_emu = debugger->GetEmulator();
_disassembler = debugger->GetDisassembler().get();
_disassembler = debugger->GetDisassembler();
IConsole* console = _debugger->GetConsole();
//TODO
if(Console* c = dynamic_cast<Console*>(console)) {
_ppu = c->GetPpu().get();
_spc = c->GetSpc().get();
_memoryManager = c->GetMemoryManager().get();
_cartridge = c->GetCartridge().get();
_ppu = c->GetPpu();
_spc = c->GetSpc();
_memoryManager = c->GetMemoryManager();
_cartridge = c->GetCartridge();
_gameboy = c->GetCartridge()->GetGameboy();
} else if(NesConsole* c = dynamic_cast<NesConsole*>(console)) {
_nesConsole = c;

2
Core/Gameboy/Debugger/GbAssembler.cpp
View file

@ -8,7 +8,7 @@
static const std::regex labelRegex = std::regex("^\\s*([@_a-zA-Z][@_a-zA-Z0-9]*)", std::regex_constants::icase);
GbAssembler::GbAssembler(shared_ptr<LabelManager> labelManager)
GbAssembler::GbAssembler(LabelManager* labelManager)
{
_labelManager = labelManager;
InitAssembler();

4
Core/Gameboy/Debugger/GbAssembler.h
View file

@ -34,7 +34,7 @@ class GbAssembler : public IAssembler
{
private:
unordered_map<string, vector<OpCodeEntry>> _opCodes;
shared_ptr<LabelManager> _labelManager;
LabelManager* _labelManager;
void InitParamEntry(ParamEntry& entry, string param);
bool IsRegisterName(string op);
@ -49,7 +49,7 @@ private:
void RunPass(vector<int16_t>& output, string code, uint32_t address, int16_t* assembledCode, bool firstPass, unordered_map<string, uint16_t>& localLabels);
public:
GbAssembler(shared_ptr<LabelManager> labelManager);
GbAssembler(LabelManager* labelManager);
virtual ~GbAssembler();
uint32_t AssembleCode(string code, uint32_t startAddress, int16_t* assembledCode);

20
Core/Gameboy/Debugger/GbDebugger.cpp
View file

@ -29,8 +29,8 @@ GbDebugger::GbDebugger(Debugger* debugger)
_debugger = debugger;
_emu = debugger->GetEmulator();
_disassembler = debugger->GetDisassembler().get();
_memoryAccessCounter = debugger->GetMemoryAccessCounter().get();
_disassembler = debugger->GetDisassembler();
_memoryAccessCounter = debugger->GetMemoryAccessCounter();
if(_emu->GetConsoleType() == ConsoleType::Snes) {
_gameboy = ((Console*)debugger->GetConsole())->GetCartridge()->GetGameboy();
@ -275,24 +275,24 @@ void GbDebugger::ProcessPpuCycle()
}
}
shared_ptr<BaseEventManager> GbDebugger::GetEventManager()
BaseEventManager* GbDebugger::GetEventManager()
{
return _eventManager;
return _eventManager.get();
}
shared_ptr<IAssembler> GbDebugger::GetAssembler()
IAssembler* GbDebugger::GetAssembler()
{
return _assembler;
return _assembler.get();
}
shared_ptr<CallstackManager> GbDebugger::GetCallstackManager()
CallstackManager* GbDebugger::GetCallstackManager()
{
return _callstackManager;
return _callstackManager.get();
}
shared_ptr<CodeDataLogger> GbDebugger::GetCodeDataLogger()
CodeDataLogger* GbDebugger::GetCodeDataLogger()
{
return _codeDataLogger;
return _codeDataLogger.get();
}
BreakpointManager* GbDebugger::GetBreakpointManager()

16
Core/Gameboy/Debugger/GbDebugger.h
View file

@ -33,12 +33,12 @@ class GbDebugger final : public IDebugger
Gameboy* _gameboy;
EmuSettings* _settings;
shared_ptr<GbEventManager> _eventManager;
shared_ptr<CallstackManager> _callstackManager;
shared_ptr<CodeDataLogger> _codeDataLogger;
unique_ptr<GbEventManager> _eventManager;
unique_ptr<CallstackManager> _callstackManager;
unique_ptr<CodeDataLogger> _codeDataLogger;
unique_ptr<BreakpointManager> _breakpointManager;
unique_ptr<StepRequest> _step;
shared_ptr<GbAssembler> _assembler;
unique_ptr<GbAssembler> _assembler;
unique_ptr<GbTraceLogger> _traceLogger;
unique_ptr<GbPpuTools> _ppuTools;
@ -62,10 +62,10 @@ public:
void Run() override;
void Step(int32_t stepCount, StepType type) override;
shared_ptr<BaseEventManager> GetEventManager() override;
shared_ptr<IAssembler> GetAssembler() override;
shared_ptr<CallstackManager> GetCallstackManager() override;
shared_ptr<CodeDataLogger> GetCodeDataLogger() override;
BaseEventManager* GetEventManager() override;
IAssembler* GetAssembler() override;
CallstackManager* GetCallstackManager() override;
CodeDataLogger* GetCodeDataLogger() override;
BreakpointManager* GetBreakpointManager() override;
ITraceLogger* GetTraceLogger() override;
PpuTools* GetPpuTools() override;

4
Core/Gameboy/Gameboy.cpp
View file

@ -447,9 +447,9 @@ void Gameboy::ProcessEndOfFrame()
_controlManager->UpdateInputState();
}
shared_ptr<IControlManager> Gameboy::GetControlManager()
IControlManager* Gameboy::GetControlManager()
{
return _controlManager;
return _controlManager.get();
}
ConsoleType Gameboy::GetConsoleType()

4
Core/Gameboy/Gameboy.h
View file

@ -36,7 +36,7 @@ private:
unique_ptr<GbCart> _cart;
unique_ptr<GbTimer> _timer;
unique_ptr<GbDmaController> _dmaController;
shared_ptr<GbControlManager> _controlManager;
unique_ptr<GbControlManager> _controlManager;
GameboyModel _model = GameboyModel::Auto;
@ -108,7 +108,7 @@ public:
LoadRomResult LoadRom(VirtualFile& romFile) override;
void Init() override;
void RunFrame() override;
shared_ptr<IControlManager> GetControlManager() override;
IControlManager* GetControlManager() override;
ConsoleRegion GetRegion() override;
ConsoleType GetConsoleType() override;
double GetFrameDelay() override;

2
Core/Gameboy/GbApu.cpp
View file

@ -30,7 +30,7 @@ void GbApu::Init(Emulator* emu, Gameboy* gameboy)
_emu = emu;
_settings = emu->GetSettings();
_soundMixer = emu->GetSoundMixer().get();
_soundMixer = emu->GetSoundMixer();
_gameboy = gameboy;
_state = {};

2
Core/Gameboy/GbMemoryManager.cpp
View file

@ -29,7 +29,7 @@ void GbMemoryManager::Init(Emulator* emu, Gameboy* gameboy, GbCart* cart, GbPpu*
_cart = cart;
_timer = timer;
_dmaController = dmaController;
_controlManager = gameboy->GetControlManager().get();
_controlManager = gameboy->GetControlManager();
_settings = _emu->GetSettings();
memset(_reads, 0, sizeof(_reads));

2
Core/NES/BaseMapper.cpp
View file

@ -1226,7 +1226,7 @@ bool BaseMapper::HasPrgChrChanges()
return false;
}
void BaseMapper::CopyPrgChrRom(shared_ptr<BaseMapper> mapper)
void BaseMapper::CopyPrgChrRom(BaseMapper* mapper)
{
if(_prgSize == mapper->_prgSize && _chrRomSize == mapper->_chrRomSize) {
memcpy(_prgRom, mapper->_prgRom, _prgSize);

2
Core/NES/BaseMapper.h
View file

@ -236,6 +236,6 @@ public:
void RestorePrgChrBackup(vector<uint8_t>& backupData);
void RevertPrgChrChanges();
bool HasPrgChrChanges();
void CopyPrgChrRom(shared_ptr<BaseMapper> mapper);
void CopyPrgChrRom(BaseMapper* mapper);
void SwapMemoryAccess(BaseMapper* sub, bool mainHasAccess);
};

2
Core/NES/Debugger/NesAssembler.cpp
View file

@ -383,7 +383,7 @@ void NesAssembler::AssembleInstruction(NesLineData& lineData, uint32_t &instruct
}
}
NesAssembler::NesAssembler(shared_ptr<LabelManager> labelManager)
NesAssembler::NesAssembler(LabelManager* labelManager)
{
_labelManager = labelManager;
}

4
Core/NES/Debugger/NesAssembler.h
View file

@ -26,7 +26,7 @@ private:
std::unordered_map<string, unordered_set<int>> _availableModesByOpName;
bool _needSecondPass = false;
shared_ptr<LabelManager> _labelManager;
LabelManager* _labelManager;
void ProcessLine(string code, uint32_t &instructionAddress, vector<int16_t>& output, unordered_map<string, uint16_t> &labels, bool firstPass, unordered_map<string, uint16_t> &currentPassLabels);
AssemblerSpecialCodes GetLineData(std::smatch match, NesLineData& lineData, unordered_map<string, uint16_t> &labels, bool firstPass);
AssemblerSpecialCodes GetAddrModeAndOperandSize(NesLineData& lineData, unordered_map<string, uint16_t> &labels, bool firstPass);
@ -35,7 +35,7 @@ private:
bool IsOpModeAvailable(string &opCode, NesAddrMode mode);
public:
NesAssembler(shared_ptr<LabelManager> labelManager);
NesAssembler(LabelManager* labelManager);
virtual ~NesAssembler() = default;
uint32_t AssembleCode(string code, uint32_t startAddress, int16_t* assembledCode);

20
Core/NES/Debugger/NesDebugger.cpp
View file

@ -39,8 +39,8 @@ NesDebugger::NesDebugger(Debugger* debugger)
_traceLogger.reset(new NesTraceLogger(debugger, _ppu));
_ppuTools.reset(new NesPpuTools(debugger, debugger->GetEmulator(), console));
_disassembler = debugger->GetDisassembler().get();
_memoryAccessCounter = debugger->GetMemoryAccessCounter().get();
_disassembler = debugger->GetDisassembler();
_memoryAccessCounter = debugger->GetMemoryAccessCounter();
_settings = debugger->GetEmulator()->GetSettings();
_codeDataLogger.reset(new CodeDataLogger(SnesMemoryType::NesPrgRom, _emu->GetMemory(SnesMemoryType::NesPrgRom).Size, CpuType::Nes));
@ -285,9 +285,9 @@ bool NesDebugger::IsRegister(MemoryOperationInfo& op)
return false;
}
shared_ptr<CallstackManager> NesDebugger::GetCallstackManager()
CallstackManager* NesDebugger::GetCallstackManager()
{
return _callstackManager;
return _callstackManager.get();
}
BreakpointManager* NesDebugger::GetBreakpointManager()
@ -295,19 +295,19 @@ BreakpointManager* NesDebugger::GetBreakpointManager()
return _breakpointManager.get();
}
shared_ptr<IAssembler> NesDebugger::GetAssembler()
IAssembler* NesDebugger::GetAssembler()
{
return _assembler;
return _assembler.get();
}
shared_ptr<BaseEventManager> NesDebugger::GetEventManager()
BaseEventManager* NesDebugger::GetEventManager()
{
return _eventManager;
return _eventManager.get();
}
shared_ptr<CodeDataLogger> NesDebugger::GetCodeDataLogger()
CodeDataLogger* NesDebugger::GetCodeDataLogger()
{
return _codeDataLogger;
return _codeDataLogger.get();
}
BaseState& NesDebugger::GetState()

17
Core/NES/Debugger/NesDebugger.h
View file

@ -38,11 +38,10 @@ class NesDebugger final : public IDebugger
BaseNesPpu* _ppu;
BaseMapper* _mapper;
shared_ptr<CodeDataLogger> _codeDataLogger;
shared_ptr<BaseEventManager> _eventManager;
shared_ptr<IAssembler> _assembler;
shared_ptr<CallstackManager> _callstackManager;
unique_ptr<CodeDataLogger> _codeDataLogger;
unique_ptr<BaseEventManager> _eventManager;
unique_ptr<IAssembler> _assembler;
unique_ptr<CallstackManager> _callstackManager;
unique_ptr<BreakpointManager> _breakpointManager;
unique_ptr<NesTraceLogger> _traceLogger;
unique_ptr<StepRequest> _step;
@ -72,10 +71,10 @@ public:
BreakpointManager* GetBreakpointManager() override;
ITraceLogger* GetTraceLogger() override;
PpuTools* GetPpuTools() override;
shared_ptr<CallstackManager> GetCallstackManager() override;
shared_ptr<IAssembler> GetAssembler() override;
shared_ptr<BaseEventManager> GetEventManager() override;
shared_ptr<CodeDataLogger> GetCodeDataLogger() override;
CallstackManager* GetCallstackManager() override;
IAssembler* GetAssembler() override;
BaseEventManager* GetEventManager() override;
CodeDataLogger* GetCodeDataLogger() override;
BaseState& GetState() override;
void GetPpuState(BaseState& state) override;

2
Core/NES/Loaders/RomLoader.cpp
View file

@ -106,7 +106,7 @@ RomData RomLoader::GetRomData()
string RomLoader::FindMatchingRomInFile(string filePath, HashInfo hashInfo, int &iterationCount)
{
shared_ptr<ArchiveReader> reader = ArchiveReader::GetReader(filePath);
unique_ptr<ArchiveReader> reader = ArchiveReader::GetReader(filePath);
if(reader) {
for(string file : reader->GetFileList(VirtualFile::RomExtensions)) {
RomLoader loader(true);

4
Core/NES/Mappers/VsSystem/VsControlManager.cpp
View file

@ -121,7 +121,7 @@ uint8_t VsControlManager::ReadRam(uint16_t addr)
if(!_console->IsVsMainConsole()) {
//Copy the insert coin 3/4 + service button "2" bits from the main console to this one
NesConsole* mainConsole = _console->GetVsMainConsole();
VsInputButtons* mainButtons = ((VsControlManager*)mainConsole->GetControlManager().get())->_input.get();
VsInputButtons* mainButtons = ((VsControlManager*)mainConsole->GetControlManager())->_input.get();
_input->SetBitValue(VsInputButtons::VsButtons::InsertCoin1, mainButtons->IsPressed(VsInputButtons::VsButtons::InsertCoin3));
_input->SetBitValue(VsInputButtons::VsButtons::InsertCoin2, mainButtons->IsPressed(VsInputButtons::VsButtons::InsertCoin4));
_input->SetBitValue(VsInputButtons::VsButtons::ServiceButton, mainButtons->IsPressed(VsInputButtons::VsButtons::ServiceButton2));
@ -264,7 +264,7 @@ void VsControlManager::UpdateControlDevices()
bool VsControlManager::SetInput(BaseControlDevice* device)
{
uint8_t port = device->GetPort();
NesControlManager* mainControlManager = (NesControlManager*)_console->GetVsMainConsole()->GetControlManager().get();
NesControlManager* mainControlManager = (NesControlManager*)_console->GetVsMainConsole()->GetControlManager();
if(mainControlManager && port <= 1) {
shared_ptr<BaseControlDevice> controlDevice = mainControlManager->GetControlDevice(port + 2);
if(controlDevice) {

2
Core/NES/Mappers/VsSystem/VsSystem.h
View file

@ -64,7 +64,7 @@ protected:
uint8_t chrOuter = _console->IsVsMainConsole() ? 0 : 2;
SelectCHRPage(0, 0 | chrOuter);
_controlManager = dynamic_cast<VsControlManager*>(_console->GetControlManager().get());
_controlManager = (VsControlManager*)_console->GetControlManager();
}
void Reset(bool softReset) override

4
Core/NES/NesConsole.cpp
View file

@ -269,9 +269,9 @@ void NesConsole::RunVsSubConsole()
}
}
shared_ptr<IControlManager> NesConsole::GetControlManager()
IControlManager* NesConsole::GetControlManager()
{
return std::dynamic_pointer_cast<IControlManager>(_controlManager);
return _controlManager.get();
}
double NesConsole::GetFrameDelay()

4
Core/NES/NesConsole.h
View file

@ -35,7 +35,7 @@ private:
unique_ptr<NesApu> _apu;
unique_ptr<NesMemoryManager> _memoryManager;
unique_ptr<BaseMapper> _mapper;
shared_ptr<NesControlManager> _controlManager;
unique_ptr<NesControlManager> _controlManager;
unique_ptr<NesSoundMixer> _mixer;
unique_ptr<HdPackData> _hdData;
@ -77,7 +77,7 @@ public:
LoadRomResult LoadRom(VirtualFile& romFile) override;
void Init() override;
void RunFrame() override;
shared_ptr<IControlManager> GetControlManager() override;
IControlManager* GetControlManager() override;
double GetFrameDelay() override;
double GetFps() override;
void RunSingleFrame() override;

2
Core/NES/NesMemoryManager.h
View file

@ -20,7 +20,7 @@ class NesMemoryManager : public ISerializable
static constexpr int VRAMSize = 0x4000;
Emulator* _emu = nullptr;
shared_ptr<CheatManager> _cheatManager;
CheatManager* _cheatManager;
NesConsole* _console;
BaseMapper* _mapper;

4
Core/NES/NesPpu.cpp
View file

@ -1256,8 +1256,8 @@ template<class T> void NesPpu<T>::ProcessScanlineFirstCycle()
UpdateApuStatus();
if(_scanline == _console->GetNesConfig().InputScanline) {
((NesControlManager*)_console->GetControlManager().get())->UpdateControlDevices();
((NesControlManager*)_console->GetControlManager().get())->UpdateInputState();
_console->GetControlManager()->UpdateControlDevices();
_console->GetControlManager()->UpdateInputState();
}
//Cycle = 0

2
Core/NES/NesSoundMixer.cpp
View file

@ -13,7 +13,7 @@ NesSoundMixer::NesSoundMixer(NesConsole* console)
{
_clockRate = 0;
_console = console;
_mixer = console->GetEmulator()->GetSoundMixer().get();
_mixer = console->GetEmulator()->GetSoundMixer();
_outputBuffer = new int16_t[NesSoundMixer::MaxSamplesPerFrame];
_blipBufLeft = blip_new(NesSoundMixer::MaxSamplesPerFrame);
_blipBufRight = blip_new(NesSoundMixer::MaxSamplesPerFrame);

78
Core/Netplay/GameClient.cpp
View file

@ -1,7 +1,4 @@
#include "stdafx.h"
#include <thread>
using std::thread;
#include "Netplay/GameClient.h"
#include "Netplay/ClientConnectionData.h"
#include "Netplay/GameClientConnection.h"
@ -10,62 +7,45 @@ using std::thread;
#include "Shared/NotificationManager.h"
#include "Utilities/Socket.h"
shared_ptr<GameClient> GameClient::_instance;
GameClient::GameClient(shared_ptr<Emulator> emu)
GameClient::GameClient(Emulator* emu)
{
_emu = emu;
_stop = false;
_connected = false;
}
GameClient::~GameClient()
{
_stop = true;
if(_clientThread) {
_clientThread->join();
}
}
bool GameClient::Connected()
{
shared_ptr<GameClient> instance = _instance;
return instance ? instance->_connected : false;
return _connected;
}
void GameClient::Connect(shared_ptr<Emulator> emu, ClientConnectionData &connectionData)
void GameClient::Connect(ClientConnectionData &connectionData)
{
_instance.reset(new GameClient(emu));
emu->GetNotificationManager()->RegisterNotificationListener(_instance);
shared_ptr<GameClient> instance = _instance;
if(instance) {
instance->PrivateConnect(connectionData);
instance->_clientThread.reset(new thread(&GameClient::Exec, instance.get()));
_emu->GetNotificationManager()->RegisterNotificationListener(shared_from_this());
_stop = false;
unique_ptr<Socket> socket(new Socket());
if(socket->Connect(connectionData.Host.c_str(), connectionData.Port)) {
_connection.reset(new GameClientConnection(_emu, std::move(socket), connectionData));
_connected = true;
_clientThread.reset(new thread(&GameClient::Exec, this));
} else {
MessageManager::DisplayMessage("NetPlay", "CouldNotConnect");
_connected = false;
}
}
void GameClient::Disconnect()
{
_instance.reset();
}
shared_ptr<GameClientConnection> GameClient::GetConnection()
{
shared_ptr<GameClient> instance = _instance;
return instance ? instance->_connection : nullptr;
}
void GameClient::PrivateConnect(ClientConnectionData &connectionData)
{
_stop = false;
shared_ptr<Socket> socket(new Socket());
if(socket->Connect(connectionData.Host.c_str(), connectionData.Port)) {
_connection.reset(new GameClientConnection(_emu, socket, connectionData));
_emu->GetNotificationManager()->RegisterNotificationListener(_connection);
_connected = true;
} else {
MessageManager::DisplayMessage("NetPlay", "CouldNotConnect");
_connected = false;
_stop = true;
_connected = false;
if(_clientThread) {
_clientThread->join();
_clientThread.reset();
}
}
@ -79,7 +59,6 @@ void GameClient::Exec()
} else {
_connected = false;
_connection->Shutdown();
_connection.reset();
break;
}
std::this_thread::sleep_for(std::chrono::duration<int, std::milli>(1));
@ -95,26 +74,27 @@ void GameClient::ProcessNotification(ConsoleNotificationType type, void* paramet
) {
//Disconnect if the client tried to manually load a game
//A deadlock occurs if this is called from the emulation thread while a network message is being processed
GameClient::Disconnect();
Disconnect();
}
if(_connection) {
_connection->ProcessNotification(type, parameter);
}
}
void GameClient::SelectController(uint8_t port)
{
shared_ptr<GameClientConnection> connection = GetConnection();
if(connection) {
connection->SelectController(port);
if(_connection) {
_connection->SelectController(port);
}
}
uint8_t GameClient::GetAvailableControllers()
{
shared_ptr<GameClientConnection> connection = GetConnection();
return connection ? connection->GetAvailableControllers() : 0;
return _connection ? _connection->GetAvailableControllers() : 0;
}
uint8_t GameClient::GetControllerPort()
{
shared_ptr<GameClientConnection> connection = GetConnection();
return connection ? connection->GetControllerPort() : GameConnection::SpectatorPort;
return _connection ? _connection->GetControllerPort() : GameConnection::SpectatorPort;
}

31
Core/Netplay/GameClient.h
View file

@ -1,42 +1,35 @@
#pragma once
#include "stdafx.h"
#include <thread>
#include "Shared/Interfaces/INotificationListener.h"
using std::thread;
class Socket;
class GameClientConnection;
class ClientConnectionData;
class Emulator;
class GameClient : public INotificationListener
class GameClient : public INotificationListener, public std::enable_shared_from_this<GameClient>
{
private:
static shared_ptr<GameClient> _instance;
shared_ptr<Emulator> _emu;
Emulator* _emu;
unique_ptr<thread> _clientThread;
unique_ptr<GameClientConnection> _connection;
atomic<bool> _stop;
atomic<bool> _connected;
shared_ptr<GameClientConnection> _connection;
bool _connected = false;
static shared_ptr<GameClientConnection> GetConnection();
void PrivateConnect(ClientConnectionData &connectionData);
void Exec();
public:
GameClient(shared_ptr<Emulator> emu);
GameClient(Emulator* emu);
virtual ~GameClient();
static bool Connected();
static void Connect(shared_ptr<Emulator> emu, ClientConnectionData &connectionData);
static void Disconnect();
bool Connected();
void Connect(ClientConnectionData &connectionData);
void Disconnect();
static void SelectController(uint8_t port);
static uint8_t GetControllerPort();
static uint8_t GetAvailableControllers();
void SelectController(uint8_t port);
uint8_t GetControllerPort();
uint8_t GetAvailableControllers();
void ProcessNotification(ConsoleNotificationType type, void* parameter) override;
};

8
Core/Netplay/GameClientConnection.cpp
View file

@ -16,7 +16,7 @@
#include "Shared/NotificationManager.h"
#include "RomFinder.h"
GameClientConnection::GameClientConnection(shared_ptr<Emulator> emu, shared_ptr<Socket> socket, ClientConnectionData &connectionData) : GameConnection(emu, socket)
GameClientConnection::GameClientConnection(Emulator* emu, unique_ptr<Socket> socket, ClientConnectionData &connectionData) : GameConnection(emu, std::move(socket))
{
_connectionData = connectionData;
_shutdown = false;
@ -38,7 +38,7 @@ void GameClientConnection::Shutdown()
DisableControllers();
if(_emu->IsRunning()) {
shared_ptr<IControlManager> controlManager = _emu->GetControlManager();
IControlManager* controlManager = _emu->GetControlManager();
if(controlManager) {
controlManager->UnregisterInputProvider(this);
}
@ -144,7 +144,7 @@ void GameClientConnection::ProcessMessage(NetMessage* message)
bool GameClientConnection::AttemptLoadGame(string filename, string sha1Hash)
{
if(filename.size() > 0) {
if(!RomFinder::LoadMatchingRom(_emu.get(), filename, sha1Hash)) {
if(!RomFinder::LoadMatchingRom(_emu, filename, sha1Hash)) {
MessageManager::DisplayMessage("NetPlay", "CouldNotFindRom", filename);
return false;
} else {
@ -216,7 +216,7 @@ bool GameClientConnection::SetInput(BaseControlDevice *device)
void GameClientConnection::InitControlDevice()
{
//Pretend we are using port 0 (to use player 1's keybindings during netplay)
shared_ptr<IControlManager> controlManager = _emu->GetControlManager();
IControlManager* controlManager = _emu->GetControlManager();
shared_ptr<BaseControlDevice> device = controlManager->GetControlDevice(_controllerPort);
if(device) {
ControllerType type = device->GetControllerType();

2
Core/Netplay/GameClientConnection.h
View file

@ -45,7 +45,7 @@ protected:
void ProcessMessage(NetMessage* message) override;
public:
GameClientConnection(shared_ptr<Emulator> emu, shared_ptr<Socket> socket, ClientConnectionData &connectionData);
GameClientConnection(Emulator* emu, unique_ptr<Socket> socket, ClientConnectionData &connectionData);
virtual ~GameClientConnection();
void Shutdown();

4
Core/Netplay/GameConnection.cpp
View file

@ -11,10 +11,10 @@
#include "Netplay/ForceDisconnectMessage.h"
#include "Netplay/ServerInformationMessage.h"
GameConnection::GameConnection(shared_ptr<Emulator> emu, shared_ptr<Socket> socket)
GameConnection::GameConnection(Emulator* emu, unique_ptr<Socket> socket)
{
_emu = emu;
_socket = socket;
_socket.swap(socket);
}
void GameConnection::ReadSocket()

6
Core/Netplay/GameConnection.h
View file

@ -17,8 +17,8 @@ class GameConnection
protected:
static constexpr int MaxMsgLength = 1500000;
shared_ptr<Socket> _socket;
shared_ptr<Emulator> _emu;
unique_ptr<Socket> _socket;
Emulator* _emu;
uint8_t _readBuffer[GameConnection::MaxMsgLength] = {};
uint8_t _messageBuffer[GameConnection::MaxMsgLength] = {};
@ -39,7 +39,7 @@ protected:
public:
static constexpr uint8_t SpectatorPort = 0xFF;
GameConnection(shared_ptr<Emulator> emu, shared_ptr<Socket> socket);
GameConnection(Emulator* emu, unique_ptr<Socket> socket);
bool ConnectionError();
void ProcessMessages();

164
Core/Netplay/GameServer.cpp
View file

@ -1,8 +1,6 @@
#include "stdafx.h"
#include <thread>
using std::thread;
#include "Netplay/GameServer.h"
#include "Netplay/GameServerConnection.h"
#include "Netplay/PlayerListMessage.h"
#include "Shared/Emulator.h"
#include "Shared/Interfaces/IControlManager.h"
@ -11,40 +9,22 @@ using std::thread;
#include "Shared/MessageManager.h"
#include "Utilities/Socket.h"
shared_ptr<GameServer> GameServer::Instance;
GameServer::GameServer(shared_ptr<Emulator> emu, uint16_t listenPort, string password)
GameServer::GameServer(Emulator* emu)
{
_emu = emu;
_stop = false;
_port = listenPort;
_password = password;
_initialized = false;
_hostControllerPort = 0;
//If a game is already running, register ourselves as an input recorder/provider right away
RegisterServerInput();
}
GameServer::~GameServer()
{
_stop = true;
_serverThread->join();
Stop();
if(_emu->IsRunning()) {
shared_ptr<IControlManager> controlManager = _emu->GetControlManager();
if(controlManager) {
controlManager->UnregisterInputRecorder(this);
controlManager->UnregisterInputProvider(this);
}
}
}
void GameServer::RegisterServerInput()
{
if(_emu->IsRunning()) {
shared_ptr<IControlManager> controlManager = _emu->GetControlManager();
IControlManager* controlManager = _emu->GetControlManager();
if(controlManager) {
controlManager->RegisterInputRecorder(this);
controlManager->RegisterInputProvider(this);
@ -55,11 +35,9 @@ void GameServer::RegisterServerInput()
void GameServer::AcceptConnections()
{
while(true) {
shared_ptr<Socket> socket = _listener->Accept();
unique_ptr<Socket> socket = _listener->Accept();
if(!socket->ConnectionError()) {
auto connection = shared_ptr<GameServerConnection>(new GameServerConnection(_emu, socket, _password));
_emu->GetNotificationManager()->RegisterNotificationListener(connection);
_openConnections.push_back(connection);
_openConnections.push_back(unique_ptr<GameServerConnection>(new GameServerConnection(this, _emu, std::move(socket), _password)));
} else {
break;
}
@ -69,27 +47,14 @@ void GameServer::AcceptConnections()
void GameServer::UpdateConnections()
{
vector<shared_ptr<GameServerConnection>> connectionsToRemove;
for(shared_ptr<GameServerConnection> connection : _openConnections) {
if(connection->ConnectionError()) {
connectionsToRemove.push_back(connection);
vector<unique_ptr<GameServerConnection>> connectionsToRemove;
for(int i = (int)_openConnections.size() - 1; i>=0; i++) {
if(_openConnections[i]->ConnectionError()) {
_openConnections.erase(_openConnections.begin() + i);
} else {
connection->ProcessMessages();
_openConnections[i]->ProcessMessages();
}
}
for(shared_ptr<GameServerConnection> gameConnection : connectionsToRemove) {
_openConnections.remove(gameConnection);
}
}
list<shared_ptr<GameServerConnection>> GameServer::GetConnectionList()
{
if(GameServer::Started()) {
return Instance->_openConnections;
} else {
return list<shared_ptr<GameServerConnection>>();
}
}
bool GameServer::SetInput(BaseControlDevice *device)
@ -99,19 +64,19 @@ bool GameServer::SetInput(BaseControlDevice *device)
//TODO?
if(device->GetControllerType() == ControllerType::Multitap) {
//Need special handling for the multitap, merge data from P3/4/5 with P1 (or P2, depending which port the multitap is plugged into)
GameServerConnection* connection = GameServerConnection::GetNetPlayDevice(port);
GameServerConnection* connection = GetNetPlayDevice(port);
if(connection) {
((Multitap*)device)->SetControllerState(0, connection->GetState());
}
for(int i = 2; i < 5; i++) {
GameServerConnection* connection = GameServerConnection::GetNetPlayDevice(i);
GameServerConnection* connection = GetNetPlayDevice(i);
if(connection) {
((Multitap*)device)->SetControllerState(i - 1, connection->GetState());
}
}
} else {
GameServerConnection* connection = GameServerConnection::GetNetPlayDevice(port);
GameServerConnection* connection = GetNetPlayDevice(port);
if(connection) {
//Device is controlled by a client
device->SetRawState(connection->GetState());
@ -126,7 +91,7 @@ bool GameServer::SetInput(BaseControlDevice *device)
void GameServer::RecordInput(vector<shared_ptr<BaseControlDevice>> devices)
{
for(shared_ptr<BaseControlDevice> &device : devices) {
for(shared_ptr<GameServerConnection> connection : _openConnections) {
for(unique_ptr<GameServerConnection>& connection : _openConnections) {
if(!connection->ConnectionError()) {
//Send movie stream
connection->SendMovieData(device->GetPort(), device->GetRawState());
@ -137,6 +102,10 @@ void GameServer::RecordInput(vector<shared_ptr<BaseControlDevice>> devices)
void GameServer::ProcessNotification(ConsoleNotificationType type, void * parameter)
{
for(unique_ptr<GameServerConnection>& connection : _openConnections) {
connection->ProcessNotification(type, parameter);
}
if(type == ConsoleNotificationType::GameLoaded) {
//Register the server as an input provider/recorder
RegisterServerInput();
@ -160,54 +129,60 @@ void GameServer::Exec()
}
}
void GameServer::Stop()
void GameServer::StartServer(uint16_t port, string password)
{
_initialized = false;
_listener.reset();
MessageManager::DisplayMessage("NetPlay", "ServerStopped");
}
_port = port;
_password = password;
void GameServer::StartServer(shared_ptr<Emulator> emu, uint16_t port, string password)
{
Instance.reset(new GameServer(emu, port, password));
emu->GetNotificationManager()->RegisterNotificationListener(Instance);
Instance->_serverThread.reset(new thread(&GameServer::Exec, Instance.get()));
_emu->GetNotificationManager()->RegisterNotificationListener(shared_from_this());
//If a game is already running, register ourselves as an input recorder/provider
RegisterServerInput();
_serverThread.reset(new thread(&GameServer::Exec, this));
}
void GameServer::StopServer()
{
if(Instance) {
Instance.reset();
_stop = true;
if(_serverThread) {
_serverThread->join();
_serverThread.reset();
}
_initialized = false;
_listener.reset();
MessageManager::DisplayMessage("NetPlay", "ServerStopped");
if(_emu->IsRunning()) {
IControlManager* controlManager = _emu->GetControlManager();
if(controlManager) {
controlManager->UnregisterInputRecorder(this);
controlManager->UnregisterInputProvider(this);
}
}
}
bool GameServer::Started()
{
if(Instance) {
return Instance->_initialized;
} else {
return false;
}
return _initialized;
}
uint8_t GameServer::GetHostControllerPort()
{
if(GameServer::Started()) {
return Instance->_hostControllerPort;
}
return GameConnection::SpectatorPort;
return _hostControllerPort;
}
void GameServer::SetHostControllerPort(uint8_t port)
{
if(GameServer::Started()) {
Instance->_emu->Lock();
if(Started()) {
auto lock = _emu->AcquireLock();
if(port == GameConnection::SpectatorPort || GetAvailableControllers() & (1 << port)) {
//Port is available
Instance->_hostControllerPort = port;
_hostControllerPort = port;
SendPlayerList();
}
Instance->_emu->Unlock();
}
}
@ -231,7 +206,7 @@ vector<PlayerInfo> GameServer::GetPlayerList()
playerInfo.IsHost = true;
playerList.push_back(playerInfo);
for(shared_ptr<GameServerConnection> &connection : GetConnectionList()) {
for(unique_ptr<GameServerConnection>& connection : _openConnections) {
playerInfo.ControllerPort = connection->GetControllerPort();
playerInfo.IsHost = false;
playerList.push_back(playerInfo);
@ -244,9 +219,42 @@ void GameServer::SendPlayerList()
{
vector<PlayerInfo> playerList = GetPlayerList();
for(shared_ptr<GameServerConnection> &connection : GetConnectionList()) {
for(unique_ptr<GameServerConnection>& connection : _openConnections) {
//Send player list update to all connections
PlayerListMessage message(playerList);
connection->SendNetMessage(message);
}
}
}
void GameServer::RegisterNetPlayDevice(GameServerConnection* device, uint8_t port)
{
_netPlayDevices[port] = device;
}
void GameServer::UnregisterNetPlayDevice(GameServerConnection* device)
{
if(device != nullptr) {
for(int i = 0; i < BaseControlDevice::PortCount; i++) {
if(_netPlayDevices[i] == device) {
_netPlayDevices[i] = nullptr;
break;
}
}
}
}
GameServerConnection* GameServer::GetNetPlayDevice(uint8_t port)
{
return _netPlayDevices[port];
}
uint8_t GameServer::GetFirstFreeControllerPort()
{
uint8_t hostPost = _emu->GetGameServer()->GetHostControllerPort();
for(int i = 0; i < BaseControlDevice::PortCount; i++) {
if(hostPost != i && _netPlayDevices[i] == nullptr) {
return i;
}
}
return GameConnection::SpectatorPort;
}

38
Core/Netplay/GameServer.h
View file

@ -6,21 +6,21 @@
#include "Shared/Interfaces/IInputProvider.h"
#include "Shared/Interfaces/IInputRecorder.h"
using std::thread;
class Emulator;
class GameServer : public IInputRecorder, public IInputProvider, public INotificationListener
class GameServer : public IInputRecorder, public IInputProvider, public INotificationListener, public std::enable_shared_from_this<GameServer>
{
private:
static shared_ptr<GameServer> Instance;
shared_ptr<Emulator> _emu;
Emulator* _emu;
unique_ptr<thread> _serverThread;
atomic<bool> _stop;
unique_ptr<Socket> _listener;
atomic<bool> _stop;
uint16_t _port = 0;
string _password;
list<shared_ptr<GameServerConnection>> _openConnections;
vector<unique_ptr<GameServerConnection>> _openConnections;
bool _initialized = false;
GameServerConnection* _netPlayDevices[BaseControlDevice::PortCount] = {};
uint8_t _hostControllerPort = 0;
@ -28,29 +28,31 @@ private:
void UpdateConnections();
void Exec();
void Stop();
public:
GameServer(shared_ptr<Emulator> emu, uint16_t port, string password);
GameServer(Emulator* emu);
virtual ~GameServer();
void RegisterServerInput();
static void StartServer(shared_ptr<Emulator> emu, uint16_t port, string password);
static void StopServer();
static bool Started();
void StartServer(uint16_t port, string password);
void StopServer();
bool Started();
static uint8_t GetHostControllerPort();
static void SetHostControllerPort(uint8_t port);
static uint8_t GetAvailableControllers();
static vector<PlayerInfo> GetPlayerList();
static void SendPlayerList();
static list<shared_ptr<GameServerConnection>> GetConnectionList();
uint8_t GetHostControllerPort();
void SetHostControllerPort(uint8_t port);
uint8_t GetAvailableControllers();
vector<PlayerInfo> GetPlayerList();
void SendPlayerList();
bool SetInput(BaseControlDevice *device) override;
void RecordInput(vector<shared_ptr<BaseControlDevice>> devices) override;
// Inherited via INotificationListener
virtual void ProcessNotification(ConsoleNotificationType type, void * parameter) override;
void RegisterNetPlayDevice(GameServerConnection* connection, uint8_t port);
void UnregisterNetPlayDevice(GameServerConnection* device);
uint8_t GetFirstFreeControllerPort();
GameServerConnection* GetNetPlayDevice(uint8_t port);
};

56
Core/Netplay/GameServerConnection.cpp
View file

@ -17,11 +17,10 @@
#include "Shared/EmuSettings.h"
#include "Shared/BaseControlDevice.h"
GameServerConnection* GameServerConnection::_netPlayDevices[BaseControlDevice::PortCount] = { };
GameServerConnection::GameServerConnection(shared_ptr<Emulator> emu, shared_ptr<Socket> socket, string serverPassword) : GameConnection(emu, socket)
GameServerConnection::GameServerConnection(GameServer* gameServer, Emulator* emu, unique_ptr<Socket> socket, string serverPassword) : GameConnection(emu, std::move(socket))
{
//Server-side connection
_server = gameServer;
_serverPassword = serverPassword;
_controllerPort = GameConnection::SpectatorPort;
SendServerInformation();
@ -30,7 +29,7 @@ GameServerConnection::GameServerConnection(shared_ptr<Emulator> emu, shared_ptr<
GameServerConnection::~GameServerConnection()
{
MessageManager::DisplayMessage("NetPlay", "Player " + std::to_string(_controllerPort + 1) + " disconnected.");
UnregisterNetPlayDevice(this);
_server->UnregisterNetPlayDevice(this);
}
void GameServerConnection::SendServerInformation()
@ -106,7 +105,7 @@ void GameServerConnection::ProcessHandshakeResponse(HandShakeMessage* message)
if(message->CheckPassword(_serverPassword, _connectionHash)) {
_emu->Lock();
_controllerPort = message->IsSpectator() ? GameConnection::SpectatorPort : GetFirstFreeControllerPort();
_controllerPort = message->IsSpectator() ? GameConnection::SpectatorPort : _server->GetFirstFreeControllerPort();
MessageManager::DisplayMessage("NetPlay", playerPortMessage + " connected.");
@ -115,8 +114,8 @@ void GameServerConnection::ProcessHandshakeResponse(HandShakeMessage* message)
}
_handshakeCompleted = true;
RegisterNetPlayDevice(this, _controllerPort);
GameServer::SendPlayerList();
_server->RegisterNetPlayDevice(this, _controllerPort);
_server->SendPlayerList();
_emu->Unlock();
} else {
SendForceDisconnectMessage("The password you provided did not match - you have been disconnected.");
@ -160,23 +159,23 @@ void GameServerConnection::SelectControllerPort(uint8_t port)
_emu->Lock();
if(port == GameConnection::SpectatorPort) {
//Client wants to be a spectator, make sure we are not using any controller
UnregisterNetPlayDevice(this);
_server->UnregisterNetPlayDevice(this);
_controllerPort = port;
} else {
GameServerConnection* netPlayDevice = GetNetPlayDevice(port);
GameServerConnection* netPlayDevice = _server->GetNetPlayDevice(port);
if(netPlayDevice == this) {
//Nothing to do, we're already this player
} else if(netPlayDevice == nullptr) {
//This port is free, we can switch
UnregisterNetPlayDevice(this);
RegisterNetPlayDevice(this, port);
_server->UnregisterNetPlayDevice(this);
_server->RegisterNetPlayDevice(this, port);
_controllerPort = port;
} else {
//Another player is using this port, we can't use it
}
}
SendGameInformation();
GameServer::SendPlayerList();
_server->SendPlayerList();
_emu->Unlock();
}
@ -205,39 +204,6 @@ void GameServerConnection::ProcessNotification(ConsoleNotificationType type, voi
}
}
void GameServerConnection::RegisterNetPlayDevice(GameServerConnection* device, uint8_t port)
{
GameServerConnection::_netPlayDevices[port] = device;
}
void GameServerConnection::UnregisterNetPlayDevice(GameServerConnection* device)
{
if(device != nullptr) {
for(int i = 0; i < BaseControlDevice::PortCount; i++) {
if(GameServerConnection::_netPlayDevices[i] == device) {
GameServerConnection::_netPlayDevices[i] = nullptr;
break;
}
}
}
}
GameServerConnection* GameServerConnection::GetNetPlayDevice(uint8_t port)
{
return GameServerConnection::_netPlayDevices[port];
}
uint8_t GameServerConnection::GetFirstFreeControllerPort()
{
uint8_t hostPost = GameServer::GetHostControllerPort();
for(int i = 0; i < BaseControlDevice::PortCount; i++) {
if(hostPost != i && GameServerConnection::_netPlayDevices[i] == nullptr) {
return i;
}
}
return GameConnection::SpectatorPort;
}
uint8_t GameServerConnection::GetControllerPort()
{
return _controllerPort;

12
Core/Netplay/GameServerConnection.h
View file

@ -7,12 +7,12 @@
#include "Shared/ControlDeviceState.h"
class HandShakeMessage;
class GameServer;
class GameServerConnection : public GameConnection, public INotificationListener
{
private:
static GameServerConnection* _netPlayDevices[BaseControlDevice::PortCount];
GameServer* _server;
list<ControlDeviceState> _inputData;
int _controllerPort = 0;
string _connectionHash;
@ -28,15 +28,11 @@ private:
void ProcessHandshakeResponse(HandShakeMessage* message);
static void RegisterNetPlayDevice(GameServerConnection* connection, uint8_t port);
static void UnregisterNetPlayDevice(GameServerConnection* device);
static uint8_t GetFirstFreeControllerPort();
protected:
void ProcessMessage(NetMessage* message) override;
public:
GameServerConnection(shared_ptr<Emulator> emu, shared_ptr<Socket> socket, string serverPassword);
GameServerConnection(GameServer* gameServer, Emulator* emu, unique_ptr<Socket> socket, string serverPassword);
virtual ~GameServerConnection();
ControlDeviceState GetState();
@ -45,6 +41,4 @@ public:
uint8_t GetControllerPort();
virtual void ProcessNotification(ConsoleNotificationType type, void* parameter) override;
static GameServerConnection* GetNetPlayDevice(uint8_t port);
};

4
Core/Netplay/SaveStateMessage.h
View file

@ -30,7 +30,7 @@ protected:
public:
SaveStateMessage(void* buffer, uint32_t length) : NetMessage(buffer, length) { }
SaveStateMessage(shared_ptr<Emulator> emu) : NetMessage(MessageType::SaveState)
SaveStateMessage(Emulator* emu) : NetMessage(MessageType::SaveState)
{
//Used when sending state to clients
emu->Lock();
@ -59,7 +59,7 @@ public:
state.read((char*)_stateData.data(), dataSize);
}
void LoadState(shared_ptr<Emulator> emu)
void LoadState(Emulator* emu)
{
std::stringstream ss;
ss.write((char*)_stateData.data(), _stateData.size());

6
Core/SNES/BaseCartridge.cpp
View file

@ -40,10 +40,10 @@ BaseCartridge::~BaseCartridge()
delete[] _saveRam;
}
shared_ptr<BaseCartridge> BaseCartridge::CreateCartridge(Console* console, VirtualFile &romFile)
unique_ptr<BaseCartridge> BaseCartridge::CreateCartridge(Console* console, VirtualFile &romFile)
{
if(romFile.IsValid()) {
shared_ptr<BaseCartridge> cart(new BaseCartridge());
unique_ptr<BaseCartridge> cart(new BaseCartridge());
vector<uint8_t> romData;
romFile.ReadFile(romData);
@ -331,7 +331,7 @@ vector<uint8_t> BaseCartridge::GetOriginalPrgRom()
{
RomInfo romInfo = GetRomInfo();
//TODO
shared_ptr<BaseCartridge> originalCart = BaseCartridge::CreateCartridge(_console, romInfo.RomFile);
unique_ptr<BaseCartridge> originalCart = BaseCartridge::CreateCartridge(_console, romInfo.RomFile);
if(originalCart->_gameboy) {
uint8_t* orgPrgRom = originalCart->_gameboy->DebugGetMemory(SnesMemoryType::GbPrgRom);
uint32_t orgRomSize = originalCart->_gameboy->DebugGetMemorySize(SnesMemoryType::GbPrgRom);

4
Core/SNES/BaseCartridge.h
View file

@ -58,7 +58,7 @@ private:
uint32_t _saveRamSize = 0;
uint32_t _coprocessorRamSize = 0;
shared_ptr<SpcFileData> _spcData;
unique_ptr<SpcFileData> _spcData;
vector<uint8_t> _embeddedFirmware;
void LoadBattery();
@ -87,7 +87,7 @@ private:
public:
virtual ~BaseCartridge();
static shared_ptr<BaseCartridge> CreateCartridge(Console* console, VirtualFile &romFile);
static unique_ptr<BaseCartridge> CreateCartridge(Console* console, VirtualFile &romFile);
void Reset();

42
Core/SNES/Console.cpp
View file

@ -32,6 +32,8 @@
#include "Utilities/PlatformUtilities.h"
#include "Utilities/FolderUtilities.h"
#include "EventType.h"
#include "SNES/RegisterHandlerA.h"
#include "SNES/RegisterHandlerB.h"
Console::Console(Emulator* emu)
{
@ -124,9 +126,9 @@ void Console::Reset()
LoadRomResult Console::LoadRom(VirtualFile& romFile)
{
shared_ptr<BaseCartridge> cart = BaseCartridge::CreateCartridge(this, romFile);
unique_ptr<BaseCartridge> cart = BaseCartridge::CreateCartridge(this, romFile);
if(cart) {
_cart = cart;
_cart.swap(cart);
UpdateRegion();
@ -337,49 +339,49 @@ void Console::Serialize(Serializer& s)
}
}
shared_ptr<Cpu> Console::GetCpu()
Cpu* Console::GetCpu()
{
return _cpu;
return _cpu.get();
}
shared_ptr<Ppu> Console::GetPpu()
Ppu* Console::GetPpu()
{
return _ppu;
return _ppu.get();
}
shared_ptr<Spc> Console::GetSpc()
Spc* Console::GetSpc()
{
return _spc;
return _spc.get();
}
shared_ptr<BaseCartridge> Console::GetCartridge()
BaseCartridge* Console::GetCartridge()
{
return _cart;
return _cart.get();
}
shared_ptr<MemoryManager> Console::GetMemoryManager()
MemoryManager* Console::GetMemoryManager()
{
return _memoryManager;
return _memoryManager.get();
}
shared_ptr<InternalRegisters> Console::GetInternalRegisters()
InternalRegisters* Console::GetInternalRegisters()
{
return _internalRegisters;
return _internalRegisters.get();
}
shared_ptr<IControlManager> Console::GetControlManager()
IControlManager* Console::GetControlManager()
{
return _controlManager;
return _controlManager.get();
}
shared_ptr<DmaController> Console::GetDmaController()
DmaController* Console::GetDmaController()
{
return _dmaController;
return _dmaController.get();
}
shared_ptr<Msu1> Console::GetMsu1()
Msu1* Console::GetMsu1()
{
return _msu1;
return _msu1.get();
}
Emulator* Console::GetEmulator()

36
Core/SNES/Console.h
View file

@ -45,16 +45,16 @@ enum class ConsoleType;
class Console final : public std::enable_shared_from_this<Console>, public IConsole
{
private:
shared_ptr<Cpu> _cpu;
shared_ptr<Ppu> _ppu;
shared_ptr<Spc> _spc;
shared_ptr<MemoryManager> _memoryManager;
shared_ptr<BaseCartridge> _cart;
shared_ptr<InternalRegisters> _internalRegisters;
shared_ptr<ControlManager> _controlManager;
shared_ptr<DmaController> _dmaController;
unique_ptr<Cpu> _cpu;
unique_ptr<Ppu> _ppu;
unique_ptr<Spc> _spc;
unique_ptr<MemoryManager> _memoryManager;
unique_ptr<BaseCartridge> _cart;
unique_ptr<InternalRegisters> _internalRegisters;
unique_ptr<ControlManager> _controlManager;
unique_ptr<DmaController> _dmaController;
shared_ptr<Msu1> _msu1;
unique_ptr<Msu1> _msu1;
EmuSettings* _settings;
Emulator* _emu;
@ -93,15 +93,15 @@ public:
void Serialize(Serializer& s) override;
shared_ptr<Cpu> GetCpu();
shared_ptr<Ppu> GetPpu();
shared_ptr<Spc> GetSpc();
shared_ptr<BaseCartridge> GetCartridge();
shared_ptr<MemoryManager> GetMemoryManager();
shared_ptr<InternalRegisters> GetInternalRegisters();
shared_ptr<IControlManager> GetControlManager() override;
shared_ptr<DmaController> GetDmaController();
shared_ptr<Msu1> GetMsu1();
Cpu* GetCpu();
Ppu* GetPpu();
Spc* GetSpc();
BaseCartridge* GetCartridge();
MemoryManager* GetMemoryManager();
InternalRegisters* GetInternalRegisters();
IControlManager* GetControlManager() override;
DmaController* GetDmaController();
Msu1* GetMsu1();
Emulator* GetEmulator();

2
Core/SNES/Coprocessors/BSX/BsxCart.cpp
View file

@ -14,7 +14,7 @@
BsxCart::BsxCart(Console* console, BsxMemoryPack* memPack) : BaseCoprocessor(SnesMemoryType::Register)
{
_console = console;
_memoryManager = _console->GetMemoryManager().get();
_memoryManager = _console->GetMemoryManager();
_memPack = memPack;
MemoryMappings* mm = _console->GetMemoryManager()->GetMemoryMappings();

2
Core/SNES/Coprocessors/BSX/BsxSatellaview.cpp
View file

@ -9,7 +9,7 @@
BsxSatellaview::BsxSatellaview(Console* console, IMemoryHandler* bBusHandler) : IMemoryHandler(SnesMemoryType::Register)
{
_console = console;
_memoryManager = console->GetMemoryManager().get();
_memoryManager = console->GetMemoryManager();
_customDate = console->GetEmulator()->GetSettings()->GetSnesConfig().BsxCustomDate;
_bBusHandler = bBusHandler;
Reset();

2
Core/SNES/Coprocessors/BSX/BsxStream.cpp
View file

@ -13,7 +13,7 @@ BsxStream::BsxStream()
void BsxStream::Reset(Console* console, int64_t resetDate)
{
_console = console;
_memoryManager = console->GetMemoryManager().get();
_memoryManager = console->GetMemoryManager();
_file.close();

4
Core/SNES/Coprocessors/CX4/Cx4.cpp
View file

@ -20,8 +20,8 @@ Cx4::Cx4(Console* console) : BaseCoprocessor(SnesMemoryType::Register)
_emu = console->GetEmulator();
_console = console;
_memoryType = SnesMemoryType::Register;
_memoryManager = console->GetMemoryManager().get();
_cpu = console->GetCpu().get();
_memoryManager = console->GetMemoryManager();
_cpu = console->GetCpu();
_emu->RegisterMemory(SnesMemoryType::Cx4DataRam, _dataRam, Cx4::DataRamSize);
_emu->GetSettings()->InitializeRam(_dataRam, Cx4::DataRamSize);

2
Core/SNES/Coprocessors/DSP/NecDsp.cpp
View file

@ -20,7 +20,7 @@ NecDsp::NecDsp(CoprocessorType type, Console* console, vector<uint8_t> &programR
_console = console;
_emu = console->GetEmulator();
_type = type;
_memoryManager = console->GetMemoryManager().get();
_memoryManager = console->GetMemoryManager();
_memoryType = SnesMemoryType::Register;
MemoryMappings *mm = _memoryManager->GetMemoryMappings();

4
Core/SNES/Coprocessors/GSU/Gsu.cpp
View file

@ -19,8 +19,8 @@ Gsu::Gsu(Console *console, uint32_t gsuRamSize) : BaseCoprocessor(SnesMemoryType
{
_emu = console->GetEmulator();
_console = console;
_memoryManager = console->GetMemoryManager().get();
_cpu = console->GetCpu().get();
_memoryManager = console->GetMemoryManager();
_cpu = console->GetCpu();
_memoryType = SnesMemoryType::Register;
_settings = _emu->GetSettings();

6
Core/SNES/Coprocessors/SA1/Sa1.cpp
View file

@ -23,12 +23,12 @@ Sa1::Sa1(Console* console) : BaseCoprocessor(SnesMemoryType::Register)
{
_console = console;
_emu = console->GetEmulator();
_memoryManager = console->GetMemoryManager().get();
_memoryManager = console->GetMemoryManager();
_memoryType = SnesMemoryType::Register;
_lastAccessMemType = SnesMemoryType::PrgRom;
_openBus = 0;
_cart = _console->GetCartridge().get();
_snesCpu = _console->GetCpu().get();
_cart = _console->GetCartridge();
_snesCpu = _console->GetCpu();
_iRam = new uint8_t[Sa1::InternalRamSize];
_emu->RegisterMemory(SnesMemoryType::Sa1InternalRam, _iRam, Sa1::InternalRamSize);

2
Core/SNES/Coprocessors/SDD1/Sdd1.cpp
View file

@ -10,7 +10,7 @@
Sdd1::Sdd1(Console* console) : BaseCoprocessor(SnesMemoryType::Register)
{
//This handler is used to dynamically map the ROM based on the banking registers
_sdd1Mmc.reset(new Sdd1Mmc(_state, console->GetCartridge().get()));
_sdd1Mmc.reset(new Sdd1Mmc(_state, console->GetCartridge()));
MemoryMappings *cpuMappings = console->GetMemoryManager()->GetMemoryMappings();
vector<unique_ptr<IMemoryHandler>> &prgRomHandlers = console->GetCartridge()->GetPrgRomHandlers();

6
Core/SNES/Coprocessors/SGB/SuperGameboy.cpp
View file

@ -20,9 +20,9 @@ SuperGameboy::SuperGameboy(Console* console, Gameboy* gameboy) : BaseCoprocessor
_console = console;
_emu = console->GetEmulator();
_memoryManager = console->GetMemoryManager().get();
_cart = _console->GetCartridge().get();
_spc = _console->GetSpc().get();
_memoryManager = console->GetMemoryManager();
_cart = _console->GetCartridge();
_spc = _console->GetSpc();
_gameboy = gameboy;
_ppu = gameboy->GetPpu();

2
Core/SNES/Coprocessors/SPC7110/Spc7110.cpp
View file

@ -16,7 +16,7 @@ Spc7110::Spc7110(Console* console, bool useRtc) : BaseCoprocessor(SnesMemoryType
{
_console = console;
_emu = console->GetEmulator();
_cart = console->GetCartridge().get();
_cart = console->GetCartridge();
_useRtc = useRtc;
MemoryMappings* mappings = console->GetMemoryManager()->GetMemoryMappings();

4
Core/SNES/Cpu.cpp
View file

@ -16,8 +16,8 @@ Cpu::Cpu(Console *console)
{
_console = console;
_emu = console->GetEmulator();
_memoryManager = console->GetMemoryManager().get();
_dmaController = console->GetDmaController().get();
_memoryManager = console->GetMemoryManager();
_dmaController = console->GetDmaController();
}
#endif

40
Core/SNES/Debugger/CpuDebugger.cpp
View file

@ -37,15 +37,15 @@ CpuDebugger::CpuDebugger(Debugger* debugger, CpuType cpuType)
_debugger = debugger;
Console* console = (Console*)debugger->GetConsole();
_console = console;
_disassembler = debugger->GetDisassembler().get();
_memoryAccessCounter = debugger->GetMemoryAccessCounter().get();
_cpu = console->GetCpu().get();
_disassembler = debugger->GetDisassembler();
_memoryAccessCounter = debugger->GetMemoryAccessCounter();
_cpu = console->GetCpu();
_sa1 = console->GetCartridge()->GetSa1();
_settings = debugger->GetEmulator()->GetSettings();
_memoryManager = console->GetMemoryManager().get();
_cart = console->GetCartridge().get();
_spc = console->GetSpc().get();
_ppu = console->GetPpu().get();
_memoryManager = console->GetMemoryManager();
_cart = console->GetCartridge();
_spc = console->GetSpc();
_ppu = console->GetPpu();
_traceLogger.reset(new SnesCpuTraceLogger(debugger, cpuType, _ppu, _memoryManager));
_ppuTools.reset(new SnesPpuTools(debugger, debugger->GetEmulator()));
@ -55,13 +55,11 @@ CpuDebugger::CpuDebugger(Debugger* debugger, CpuType cpuType)
_memoryMappings = _sa1->GetMemoryMappings();
}
if(cpuType == CpuType::Sa1) {
_codeDataLogger = _debugger->GetCodeDataLogger(CpuType::Cpu);
} else {
if(cpuType == CpuType::Cpu) {
_codeDataLogger.reset(new CodeDataLogger(SnesMemoryType::PrgRom, console->GetCartridge()->DebugGetPrgRomSize(), CpuType::Cpu));
}
_eventManager.reset(new SnesEventManager(debugger, _cpu, console->GetPpu().get(), _memoryManager, console->GetDmaController().get()));
_eventManager.reset(new SnesEventManager(debugger, _cpu, console->GetPpu(), _memoryManager, console->GetDmaController()));
_callstackManager.reset(new CallstackManager(debugger));
_breakpointManager.reset(new BreakpointManager(debugger, cpuType, _eventManager.get()));
_step.reset(new StepRequest());
@ -316,9 +314,9 @@ bool CpuDebugger::IsRegister(uint32_t addr)
return _cpuType == CpuType::Cpu && _memoryManager->IsRegister(addr);
}
shared_ptr<CallstackManager> CpuDebugger::GetCallstackManager()
CallstackManager* CpuDebugger::GetCallstackManager()
{
return _callstackManager;
return _callstackManager.get();
}
ITraceLogger* CpuDebugger::GetTraceLogger()
@ -331,19 +329,23 @@ BreakpointManager* CpuDebugger::GetBreakpointManager()
return _breakpointManager.get();
}
shared_ptr<IAssembler> CpuDebugger::GetAssembler()
IAssembler* CpuDebugger::GetAssembler()
{
return _assembler;
return _assembler.get();
}
shared_ptr<BaseEventManager> CpuDebugger::GetEventManager()
BaseEventManager* CpuDebugger::GetEventManager()
{
return _eventManager;
return _eventManager.get();
}
shared_ptr<CodeDataLogger> CpuDebugger::GetCodeDataLogger()
CodeDataLogger* CpuDebugger::GetCodeDataLogger()
{
return _codeDataLogger;
if(_cpuType == CpuType::Sa1) {
return _debugger->GetCodeDataLogger(CpuType::Cpu);
} else {
return _codeDataLogger.get();
}
}
PpuTools* CpuDebugger::GetPpuTools()

16
Core/SNES/Debugger/CpuDebugger.h
View file

@ -42,10 +42,10 @@ class CpuDebugger final : public IDebugger
Ppu* _ppu;
MemoryMappings* _memoryMappings;
shared_ptr<CodeDataLogger> _codeDataLogger;
shared_ptr<BaseEventManager> _eventManager;
shared_ptr<SnesAssembler> _assembler;
shared_ptr<CallstackManager> _callstackManager;
unique_ptr<CodeDataLogger> _codeDataLogger;
unique_ptr<BaseEventManager> _eventManager;
unique_ptr<SnesAssembler> _assembler;
unique_ptr<CallstackManager> _callstackManager;
unique_ptr<BreakpointManager> _breakpointManager;
unique_ptr<StepRequest> _step;
unique_ptr<SnesCpuTraceLogger> _traceLogger;
@ -81,10 +81,10 @@ public:
ITraceLogger* GetTraceLogger() override;
BreakpointManager* GetBreakpointManager() override;
shared_ptr<CallstackManager> GetCallstackManager() override;
shared_ptr<IAssembler> GetAssembler() override;
shared_ptr<BaseEventManager> GetEventManager() override;
shared_ptr<CodeDataLogger> GetCodeDataLogger() override;
CallstackManager* GetCallstackManager() override;
IAssembler* GetAssembler() override;
BaseEventManager* GetEventManager() override;
CodeDataLogger* GetCodeDataLogger() override;
PpuTools* GetPpuTools() override;
BaseState& GetState() override;

20
Core/SNES/Debugger/Cx4Debugger.cpp
View file

@ -23,16 +23,16 @@ Cx4Debugger::Cx4Debugger(Debugger* debugger)
Console* console = (Console*)debugger->GetConsole();
_debugger = debugger;
_codeDataLogger = debugger->GetCodeDataLogger(CpuType::Cpu).get();
_disassembler = debugger->GetDisassembler().get();
_memoryAccessCounter = debugger->GetMemoryAccessCounter().get();
_codeDataLogger = debugger->GetCodeDataLogger(CpuType::Cpu);
_disassembler = debugger->GetDisassembler();
_memoryAccessCounter = debugger->GetMemoryAccessCounter();
_cx4 = console->GetCartridge()->GetCx4();
_memoryManager = console->GetMemoryManager().get();
_memoryManager = console->GetMemoryManager();
_settings = debugger->GetEmulator()->GetSettings();
_traceLogger.reset(new Cx4TraceLogger(debugger, console->GetPpu().get(), _memoryManager));
_traceLogger.reset(new Cx4TraceLogger(debugger, console->GetPpu(), _memoryManager));
_breakpointManager.reset(new BreakpointManager(debugger, CpuType::Cx4, debugger->GetEventManager(CpuType::Cpu).get()));
_breakpointManager.reset(new BreakpointManager(debugger, CpuType::Cx4, debugger->GetEventManager(CpuType::Cpu)));
_step.reset(new StepRequest());
}
@ -124,22 +124,22 @@ BreakpointManager* Cx4Debugger::GetBreakpointManager()
return _breakpointManager.get();
}
shared_ptr<CallstackManager> Cx4Debugger::GetCallstackManager()
CallstackManager* Cx4Debugger::GetCallstackManager()
{
throw std::runtime_error("Call stack not supported for CX4");
}
shared_ptr<IAssembler> Cx4Debugger::GetAssembler()
IAssembler* Cx4Debugger::GetAssembler()
{
throw std::runtime_error("Assembler not supported for CX4");
}
shared_ptr<BaseEventManager> Cx4Debugger::GetEventManager()
BaseEventManager* Cx4Debugger::GetEventManager()
{
throw std::runtime_error("Event manager not supported for CX4");
}
shared_ptr<CodeDataLogger> Cx4Debugger::GetCodeDataLogger()
CodeDataLogger* Cx4Debugger::GetCodeDataLogger()
{
return nullptr;
}

8
Core/SNES/Debugger/Cx4Debugger.h
View file

@ -44,10 +44,10 @@ public:
void Step(int32_t stepCount, StepType type) override;
BreakpointManager* GetBreakpointManager() override;
shared_ptr<CallstackManager> GetCallstackManager() override;
shared_ptr<IAssembler> GetAssembler() override;
shared_ptr<BaseEventManager> GetEventManager() override;
shared_ptr<CodeDataLogger> GetCodeDataLogger() override;
CallstackManager* GetCallstackManager() override;
IAssembler* GetAssembler() override;
BaseEventManager* GetEventManager() override;
CodeDataLogger* GetCodeDataLogger() override;
ITraceLogger* GetTraceLogger() override;
BaseState& GetState() override;

20
Core/SNES/Debugger/GsuDebugger.cpp
View file

@ -22,16 +22,16 @@ GsuDebugger::GsuDebugger(Debugger* debugger)
Console* console = (Console*)debugger->GetConsole();
_debugger = debugger;
_codeDataLogger = debugger->GetCodeDataLogger(CpuType::Cpu).get();
_disassembler = debugger->GetDisassembler().get();
_memoryAccessCounter = debugger->GetMemoryAccessCounter().get();
_codeDataLogger = debugger->GetCodeDataLogger(CpuType::Cpu);
_disassembler = debugger->GetDisassembler();
_memoryAccessCounter = debugger->GetMemoryAccessCounter();
_gsu = console->GetCartridge()->GetGsu();
_memoryManager = console->GetMemoryManager().get();
_memoryManager = console->GetMemoryManager();
_settings = debugger->GetEmulator()->GetSettings();
_traceLogger.reset(new GsuTraceLogger(debugger, console->GetPpu().get(), _memoryManager));
_traceLogger.reset(new GsuTraceLogger(debugger, console->GetPpu(), _memoryManager));
_breakpointManager.reset(new BreakpointManager(debugger, CpuType::Gsu, debugger->GetEventManager(CpuType::Cpu).get()));
_breakpointManager.reset(new BreakpointManager(debugger, CpuType::Gsu, debugger->GetEventManager(CpuType::Cpu)));
_step.reset(new StepRequest());
}
@ -127,22 +127,22 @@ BreakpointManager* GsuDebugger::GetBreakpointManager()
return _breakpointManager.get();
}
shared_ptr<CallstackManager> GsuDebugger::GetCallstackManager()
CallstackManager* GsuDebugger::GetCallstackManager()
{
throw std::runtime_error("Call stack not supported for GSU");
}
shared_ptr<IAssembler> GsuDebugger::GetAssembler()
IAssembler* GsuDebugger::GetAssembler()
{
throw std::runtime_error("Assembler not supported for GSU");
}
shared_ptr<BaseEventManager> GsuDebugger::GetEventManager()
BaseEventManager* GsuDebugger::GetEventManager()
{
throw std::runtime_error("Event manager not supported for GSU");
}
shared_ptr<CodeDataLogger> GsuDebugger::GetCodeDataLogger()
CodeDataLogger* GsuDebugger::GetCodeDataLogger()
{
return nullptr;
}

8
Core/SNES/Debugger/GsuDebugger.h
View file

@ -44,10 +44,10 @@ public:
void Step(int32_t stepCount, StepType type) override;
BreakpointManager* GetBreakpointManager() override;
shared_ptr<CallstackManager> GetCallstackManager() override;
shared_ptr<IAssembler> GetAssembler() override;
shared_ptr<BaseEventManager> GetEventManager() override;
shared_ptr<CodeDataLogger> GetCodeDataLogger() override;
CallstackManager* GetCallstackManager() override;
IAssembler* GetAssembler() override;
BaseEventManager* GetEventManager() override;
CodeDataLogger* GetCodeDataLogger() override;
ITraceLogger* GetTraceLogger() override;
BaseState& GetState() override;

14
Core/SNES/Debugger/NecDspDebugger.cpp
View file

@ -21,13 +21,13 @@ NecDspDebugger::NecDspDebugger(Debugger* debugger)
Console* console = (Console*)debugger->GetConsole();
_debugger = debugger;
_disassembler = debugger->GetDisassembler().get();
_disassembler = debugger->GetDisassembler();
_dsp = console->GetCartridge()->GetDsp();
_settings = debugger->GetEmulator()->GetSettings();
_traceLogger.reset(new NecDspTraceLogger(debugger, console->GetPpu().get(), console->GetMemoryManager().get()));
_traceLogger.reset(new NecDspTraceLogger(debugger, console->GetPpu(), console->GetMemoryManager()));
_breakpointManager.reset(new BreakpointManager(debugger, CpuType::NecDsp, debugger->GetEventManager(CpuType::Cpu).get()));
_breakpointManager.reset(new BreakpointManager(debugger, CpuType::NecDsp, debugger->GetEventManager(CpuType::Cpu)));
_step.reset(new StepRequest());
}
@ -93,7 +93,7 @@ void NecDspDebugger::Step(int32_t stepCount, StepType type)
_step.reset(new StepRequest(step));
}
shared_ptr<CallstackManager> NecDspDebugger::GetCallstackManager()
CallstackManager* NecDspDebugger::GetCallstackManager()
{
throw std::runtime_error("Callstack not supported for NEC DSP");
}
@ -103,17 +103,17 @@ BreakpointManager* NecDspDebugger::GetBreakpointManager()
return _breakpointManager.get();
}
shared_ptr<IAssembler> NecDspDebugger::GetAssembler()
IAssembler* NecDspDebugger::GetAssembler()
{
throw std::runtime_error("Assembler not supported for NEC DSP");
}
shared_ptr<BaseEventManager> NecDspDebugger::GetEventManager()
BaseEventManager* NecDspDebugger::GetEventManager()
{
throw std::runtime_error("Event manager not supported for NEC DSP");
}
shared_ptr<CodeDataLogger> NecDspDebugger::GetCodeDataLogger()
CodeDataLogger* NecDspDebugger::GetCodeDataLogger()
{
return nullptr;
}

8
Core/SNES/Debugger/NecDspDebugger.h
View file

@ -39,11 +39,11 @@ public:
void Run() override;
void Step(int32_t stepCount, StepType type) override;
shared_ptr<CallstackManager> GetCallstackManager() override;
CallstackManager* GetCallstackManager() override;
BreakpointManager* GetBreakpointManager() override;
shared_ptr<IAssembler> GetAssembler() override;
shared_ptr<BaseEventManager> GetEventManager() override;
shared_ptr<CodeDataLogger> GetCodeDataLogger() override;
IAssembler* GetAssembler() override;
BaseEventManager* GetEventManager() override;
CodeDataLogger* GetCodeDataLogger() override;
ITraceLogger* GetTraceLogger() override;
BaseState& GetState() override;

2
Core/SNES/Debugger/SnesAssembler.cpp
View file

@ -410,7 +410,7 @@ void SnesAssembler::AssembleInstruction(SnesLineData& lineData, uint32_t& instru
}
}
SnesAssembler::SnesAssembler(shared_ptr<LabelManager> labelManager)
SnesAssembler::SnesAssembler(LabelManager* labelManager)
{
_labelManager = labelManager;
}

4
Core/SNES/Debugger/SnesAssembler.h
View file

@ -27,7 +27,7 @@ private:
std::unordered_map<string, std::unordered_set<int>> _availableModesByOpName;
bool _needSecondPass = false;
shared_ptr<LabelManager> _labelManager;
LabelManager* _labelManager;
void ProcessLine(string code, uint32_t& instructionAddress, vector<int16_t>& output, std::unordered_map<string, uint32_t>& labels, bool firstPass, std::unordered_map<string, uint32_t>& currentPassLabels);
AssemblerSpecialCodes GetLineData(std::smatch match, SnesLineData& lineData, std::unordered_map<string, uint32_t>& labels, bool firstPass);
AssemblerSpecialCodes GetAddrModeAndOperandSize(SnesLineData& lineData, std::unordered_map<string, uint32_t>& labels, bool firstPass);
@ -36,7 +36,7 @@ private:
bool IsOpModeAvailable(string& opCode, AddrMode mode);
public:
SnesAssembler(shared_ptr<LabelManager> labelManager);
SnesAssembler(LabelManager* labelManager);
virtual ~SnesAssembler();
uint32_t AssembleCode(string code, uint32_t startAddress, int16_t* assembledCode);

22
Core/SNES/Debugger/SpcDebugger.cpp
View file

@ -18,18 +18,18 @@
SpcDebugger::SpcDebugger(Debugger* debugger)
{
_debugger = debugger;
_disassembler = debugger->GetDisassembler().get();
_memoryAccessCounter = debugger->GetMemoryAccessCounter().get();
_disassembler = debugger->GetDisassembler();
_memoryAccessCounter = debugger->GetMemoryAccessCounter();
Console* console = (Console*)debugger->GetConsole();
_spc = console->GetSpc().get();
_memoryManager = console->GetMemoryManager().get();
_spc = console->GetSpc();
_memoryManager = console->GetMemoryManager();
_settings = debugger->GetEmulator()->GetSettings();
_traceLogger.reset(new SpcTraceLogger(debugger, console->GetPpu().get(), console->GetMemoryManager().get()));
_traceLogger.reset(new SpcTraceLogger(debugger, console->GetPpu(), console->GetMemoryManager()));
_callstackManager.reset(new CallstackManager(debugger));
_breakpointManager.reset(new BreakpointManager(debugger, CpuType::Spc, debugger->GetEventManager(CpuType::Cpu).get()));
_breakpointManager.reset(new BreakpointManager(debugger, CpuType::Spc, debugger->GetEventManager(CpuType::Cpu)));
_step.reset(new StepRequest());
}
@ -155,9 +155,9 @@ void SpcDebugger::Step(int32_t stepCount, StepType type)
_step.reset(new StepRequest(step));
}
shared_ptr<CallstackManager> SpcDebugger::GetCallstackManager()
CallstackManager* SpcDebugger::GetCallstackManager()
{
return _callstackManager;
return _callstackManager.get();
}
BreakpointManager* SpcDebugger::GetBreakpointManager()
@ -165,17 +165,17 @@ BreakpointManager* SpcDebugger::GetBreakpointManager()
return _breakpointManager.get();
}
shared_ptr<IAssembler> SpcDebugger::GetAssembler()
IAssembler* SpcDebugger::GetAssembler()
{
throw std::runtime_error("Assembler not supported for SPC");
}
shared_ptr<BaseEventManager> SpcDebugger::GetEventManager()
BaseEventManager* SpcDebugger::GetEventManager()
{
throw std::runtime_error("Event manager not supported for SPC");
}
shared_ptr<CodeDataLogger> SpcDebugger::GetCodeDataLogger()
CodeDataLogger* SpcDebugger::GetCodeDataLogger()
{
return nullptr;
}

10
Core/SNES/Debugger/SpcDebugger.h
View file

@ -24,7 +24,7 @@ class SpcDebugger final : public IDebugger
Spc* _spc;
EmuSettings* _settings;
shared_ptr<CallstackManager> _callstackManager;
unique_ptr<CallstackManager> _callstackManager;
unique_ptr<BreakpointManager> _breakpointManager;
unique_ptr<SpcTraceLogger> _traceLogger;
unique_ptr<StepRequest> _step;
@ -43,11 +43,11 @@ public:
void Run() override;
void Step(int32_t stepCount, StepType type) override;
shared_ptr<CallstackManager> GetCallstackManager() override;
CallstackManager* GetCallstackManager() override;
BreakpointManager* GetBreakpointManager() override;
shared_ptr<IAssembler> GetAssembler() override;
shared_ptr<BaseEventManager> GetEventManager() override;
shared_ptr<CodeDataLogger> GetCodeDataLogger() override;
IAssembler* GetAssembler() override;
BaseEventManager* GetEventManager() override;
CodeDataLogger* GetCodeDataLogger() override;
ITraceLogger* GetTraceLogger() override;
BaseState& GetState() override;

2
Core/SNES/Debugger/SpcDisUtils.cpp
View file

@ -131,7 +131,7 @@ void SpcDisUtils::GetDisassembly(DisassemblyInfo &info, string &out, uint32_t me
int32_t SpcDisUtils::GetEffectiveAddress(DisassemblyInfo &info, Console *console, SpcState &state)
{
if(_needAddress[info.GetOpCode()]) {
Spc* spc = console->GetSpc().get();
Spc* spc = console->GetSpc();
DummySpc dummySpc(spc->GetSpcRam(), state);
dummySpc.Step();
uint32_t addr;

2
Core/SNES/Input/Multitap.cpp
View file

@ -105,7 +105,7 @@ Multitap::Multitap(Console* console, uint8_t port, KeyMappingSet keyMappings1, K
_mappings[1] = keyMappings2.GetKeyMappingArray();
_mappings[2] = keyMappings3.GetKeyMappingArray();
_mappings[3] = keyMappings4.GetKeyMappingArray();
_internalRegs = console->GetInternalRegisters().get();
_internalRegs = console->GetInternalRegisters();
}
void Multitap::SetControllerState(uint8_t controllerNumber, ControlDeviceState state)

2
Core/SNES/Input/SuperScope.h
View file

@ -95,7 +95,7 @@ protected:
public:
SuperScope(Console* console, uint8_t port, KeyMappingSet keyMappings) : BaseControlDevice(console->GetEmulator(), ControllerType::SuperScope, port, keyMappings)
{
_ppu = console->GetPpu().get();
_ppu = console->GetPpu();
}
uint8_t ReadRam(uint16_t addr) override

8
Core/SNES/InternalRegisters.cpp
View file

@ -16,11 +16,11 @@ InternalRegisters::InternalRegisters()
void InternalRegisters::Initialize(Console* console)
{
_cpu = console->GetCpu().get();
_cpu = console->GetCpu();
_aluMulDiv.Initialize(_cpu);
_console = console;
_memoryManager = console->GetMemoryManager().get();
_ppu = _console->GetPpu().get();
_memoryManager = console->GetMemoryManager();
_ppu = _console->GetPpu();
Reset();
//Power on values
@ -48,7 +48,7 @@ void InternalRegisters::ProcessAutoJoypadRead()
return;
}
ControlManager* controlManager = (ControlManager*)_console->GetControlManager().get();
ControlManager* controlManager = (ControlManager*)_console->GetControlManager();
controlManager->Write(0x4016, 1);
controlManager->Write(0x4016, 0);

18
Core/SNES/MemoryManager.cpp
View file

@ -24,26 +24,26 @@ void MemoryManager::Initialize(Console *console)
_cpuSpeed = 8;
_console = console;
_emu = console->GetEmulator();
_regs = console->GetInternalRegisters().get();
_cpu = console->GetCpu().get();
_ppu = console->GetPpu().get();
_cart = console->GetCartridge().get();
_cheatManager = _emu->GetCheatManager().get();
_regs = console->GetInternalRegisters();
_cpu = console->GetCpu();
_ppu = console->GetPpu();
_cart = console->GetCartridge();
_cheatManager = _emu->GetCheatManager();
_workRam = new uint8_t[MemoryManager::WorkRamSize];
_emu->RegisterMemory(SnesMemoryType::WorkRam, _workRam, MemoryManager::WorkRamSize);
_emu->GetSettings()->InitializeRam(_workRam, MemoryManager::WorkRamSize);
_registerHandlerA.reset(new RegisterHandlerA(
console->GetDmaController().get(),
console->GetInternalRegisters().get(),
(ControlManager*)console->GetControlManager().get()
console->GetDmaController(),
console->GetInternalRegisters(),
(ControlManager*)console->GetControlManager()
));
_registerHandlerB.reset(new RegisterHandlerB(
_console,
_ppu,
console->GetSpc().get(),
console->GetSpc(),
_workRam
));

4
Core/SNES/MemoryManager.h
View file

@ -35,8 +35,8 @@ private:
Console* _console;
Emulator* _emu;
shared_ptr<RegisterHandlerA> _registerHandlerA;
shared_ptr<RegisterHandlerB> _registerHandlerB;
unique_ptr<RegisterHandlerA> _registerHandlerA;
unique_ptr<RegisterHandlerB> _registerHandlerB;
InternalRegisters *_regs;
Ppu* _ppu;

6
Core/SNES/Ppu.cpp
View file

@ -56,10 +56,10 @@ Ppu::~Ppu()
void Ppu::PowerOn()
{
_skipRender = false;
_regs = _console->GetInternalRegisters().get();
_regs = _console->GetInternalRegisters();
_settings = _emu->GetSettings();
_spc = _console->GetSpc().get();
_memoryManager = _console->GetMemoryManager().get();
_spc = _console->GetSpc();
_memoryManager = _console->GetMemoryManager();
_currentBuffer = _outputBuffers[0];

4
Core/SNES/RegisterHandlerB.cpp
View file

@ -14,11 +14,11 @@ RegisterHandlerB::RegisterHandlerB(Console *console, Ppu * ppu, Spc * spc, uint8
{
_console = console;
_emu = console->GetEmulator();
_cheatManager = _emu->GetCheatManager().get();
_cheatManager = _emu->GetCheatManager();
_sa1 = console->GetCartridge()->GetSa1();
_ppu = ppu;
_spc = spc;
_msu1 = console->GetMsu1().get();
_msu1 = console->GetMsu1();
_workRam = workRam;
_wramPosition = 0;
}

2
Core/SNES/Spc.cpp
View file

@ -20,7 +20,7 @@ Spc::Spc(Console* console)
{
_emu = console->GetEmulator();
_console = console;
_memoryManager = console->GetMemoryManager().get();
_memoryManager = console->GetMemoryManager();
_soundBuffer = new int16_t[Spc::SampleBufferSize];
_ram = new uint8_t[Spc::SpcRamSize];

4
Core/Shared/Audio/AudioPlayerHud.cpp
View file

@ -11,8 +11,8 @@ static constexpr double PI = 3.14159265358979323846;
AudioPlayerHud::AudioPlayerHud(Emulator* emu)
{
_emu = emu;
_mixer = emu->GetSoundMixer().get();
_hud = emu->GetDebugHud().get();
_mixer = emu->GetSoundMixer();
_hud = emu->GetDebugHud();
for(int i = 0; i < N; i++) {
_hannWindow[i] = 0.5f * (1.0f - cos(2.0f * PI * (float)(i) / (float)(N - 1.0f)));

2
Core/Shared/Audio/SoundMixer.cpp
View file

@ -118,7 +118,7 @@ void SoundMixer::PlayAudioBuffer(int16_t* samples, uint32_t sampleCount, uint32_
}
}
shared_ptr<RewindManager> rewindManager = _emu->GetRewindManager();
RewindManager* rewindManager = _emu->GetRewindManager();
if(!_emu->IsRunAheadFrame() && rewindManager && rewindManager->SendAudio(out, count)) {
bool isRecording = _waveRecorder || _emu->GetVideoRenderer()->IsRecording();
if(isRecording) {

159
Core/Shared/Emulator.cpp
View file

@ -1,4 +1,5 @@
#include "stdafx.h"
#include <assert.h>
#include "Shared/Emulator.h"
#include "Shared/NotificationManager.h"
#include "Shared/Audio/SoundMixer.h"
@ -21,6 +22,8 @@
#include "Shared/SystemActionManager.h"
#include "Shared/Movies/MovieManager.h"
#include "Shared/TimingInfo.h"
#include "Netplay/GameServer.h"
#include "Netplay/GameClient.h"
#include "Shared/Interfaces/IConsole.h"
#include "Shared/Interfaces/IControlManager.h"
#include "SNES/Console.h"
@ -39,19 +42,32 @@
#include "MemoryOperationType.h"
#include "EventType.h"
Emulator::Emulator()
Emulator::Emulator() :
_settings(new EmuSettings(this)),
_debugHud(new DebugHud()),
_notificationManager(new NotificationManager()),
_batteryManager(new BatteryManager()),
_videoDecoder(new VideoDecoder(this)),
_videoRenderer(new VideoRenderer(this)),
_saveStateManager(new SaveStateManager(this)),
_soundMixer(new SoundMixer(this)),
_cheatManager(new CheatManager(this)),
_movieManager(new MovieManager(this)),
_gameServer(new GameServer(this)),
_gameClient(new GameClient(this))
{
_settings.reset(new EmuSettings(this));
_paused = false;
_pauseOnNextFrame = false;
_stopFlag = false;
_isRunAheadFrame = false;
_lockCounter = 0;
_threadPaused = false;
_lockCounter = 0;
_debugRequestCount = 0;
_allowDebuggerRequest = true;
_videoDecoder->Init();
}
Emulator::~Emulator()
@ -60,23 +76,10 @@ Emulator::~Emulator()
void Emulator::Initialize()
{
_lockCounter = 0;
_debugHud.reset(new DebugHud());
_notificationManager.reset(new NotificationManager());
_systemActionManager.reset(new SystemActionManager(this));
_shortcutKeyHandler.reset(new ShortcutKeyHandler(this));
_notificationManager->RegisterNotificationListener(_shortcutKeyHandler);
_batteryManager.reset(new BatteryManager());
_videoDecoder.reset(new VideoDecoder(shared_from_this()));
_videoRenderer.reset(new VideoRenderer(shared_from_this()));
_saveStateManager.reset(new SaveStateManager(this));
_soundMixer.reset(new SoundMixer(this));
_cheatManager.reset(new CheatManager(this));
_movieManager.reset(new MovieManager(shared_from_this()));
_systemActionManager.reset(new SystemActionManager(this));
_videoDecoder->StartThread();
_videoRenderer->StartThread();
}
@ -85,19 +88,12 @@ void Emulator::Release()
{
Stop(true);
_gameClient->Disconnect();
_gameServer->StopServer();
_videoDecoder->StopThread();
_videoRenderer->StopThread();
_videoDecoder.reset();
_videoRenderer.reset();
_debugHud.reset();
_shortcutKeyHandler.reset();
_notificationManager.reset();
_saveStateManager.reset();
_soundMixer.reset();
_settings.reset();
_cheatManager.reset();
_movieManager.reset();
}
void Emulator::Run()
@ -258,6 +254,26 @@ void Emulator::RunSingleFrame()
_controlManager->UpdateControlDevices();*/
}
shared_ptr<Debugger> Emulator::SafeGetDebugger()
{
auto lock = _debuggerLock.AcquireSafe();
shared_ptr<Debugger> debugger = _debugger;
return debugger;
}
void Emulator::SafeResetDebugger(Debugger* dbg = nullptr)
{
if(_emulationThreadId == std::this_thread::get_id()) {
auto dbgLock = _debuggerLock.AcquireSafe();
_debugger.reset(dbg);
} else {
//Need to pause emulator to change _debugger (when not called from the emulation thread)
auto emuLock = AcquireLock();
auto dbgLock = _debuggerLock.AcquireSafe();
_debugger.reset(dbg);
}
}
void Emulator::Stop(bool sendNotification)
{
BlockDebuggerRequests();
@ -266,7 +282,7 @@ void Emulator::Stop(bool sendNotification)
_notificationManager->SendNotification(ConsoleNotificationType::BeforeGameUnload);
shared_ptr<Debugger> debugger = _debugger;
shared_ptr<Debugger> debugger = SafeGetDebugger();
if(debugger) {
debugger->SuspendDebugger(false);
debugger->Run();
@ -324,9 +340,7 @@ void Emulator::Reset()
void Emulator::ReloadRom(bool forPowerCycle)
{
RomInfo info = GetRomInfo();
Lock();
LoadRom(info.RomFile, info.PatchFile, false, forPowerCycle);
Unlock();
}
void Emulator::PowerCycle()
@ -336,20 +350,19 @@ void Emulator::PowerCycle()
bool Emulator::LoadRom(VirtualFile romFile, VirtualFile patchFile, bool stopRom, bool forPowerCycle)
{
auto emuLock = AcquireLock();
auto lock = _loadLock.AcquireSafe();
if(!romFile.IsValid()) {
return false;
}
_debuggerLock.Acquire();
BlockDebuggerRequests();
//Keep a reference to the original debugger, and reset the member to avoid any calls to the debugger by the init process
bool debuggerActive = _debugger != nullptr;
shared_ptr<Debugger> debugger = _debugger;
_debugger.reset();
_debuggerLock.Release();
shared_ptr<Debugger> debugger = SafeGetDebugger();
bool debuggerActive = debugger != nullptr;
SafeResetDebugger();
if(patchFile.IsValid()) {
if(romFile.ApplyPatch(patchFile)) {
@ -373,7 +386,7 @@ bool Emulator::LoadRom(VirtualFile romFile, VirtualFile patchFile, bool stopRom,
static const vector<string> _snesExtensions = { { ".sfc", ".swc", ".fig", ".smc", ".bs", ".gb", ".gbc", ".spc" } };
static const vector<string> _gbExtensions = { { ".gb", ".gbc", ".gbs" } };
shared_ptr<IConsole> console;
unique_ptr<IConsole> console;
string romExt = romFile.GetFileExtension();
LoadRomResult result = LoadRomResult::UnknownType;
@ -438,14 +451,14 @@ bool Emulator::LoadRom(VirtualFile romFile, VirtualFile patchFile, bool stopRom,
//TODO
//UpdateRegion();
_console = console;
console->Init();
_console.swap(console);
_console->Init();
if(debuggerActive) {
InitDebugger();
}
_rewindManager.reset(new RewindManager(shared_from_this()));
_rewindManager.reset(new RewindManager(this));
_notificationManager->RegisterNotificationListener(_rewindManager);
//TODO
@ -749,29 +762,29 @@ void Emulator::Deserialize(istream& in, uint32_t fileFormatVersion, bool compres
_notificationManager->SendNotification(ConsoleNotificationType::StateLoaded);
}
shared_ptr<SoundMixer> Emulator::GetSoundMixer()
SoundMixer* Emulator::GetSoundMixer()
{
return _soundMixer;
return _soundMixer.get();
}
shared_ptr<VideoRenderer> Emulator::GetVideoRenderer()
VideoRenderer* Emulator::GetVideoRenderer()
{
return _videoRenderer;
return _videoRenderer.get();
}
shared_ptr<VideoDecoder> Emulator::GetVideoDecoder()
VideoDecoder* Emulator::GetVideoDecoder()
{
return _videoDecoder;
return _videoDecoder.get();
}
shared_ptr<ShortcutKeyHandler> Emulator::GetShortcutKeyHandler()
ShortcutKeyHandler* Emulator::GetShortcutKeyHandler()
{
return _shortcutKeyHandler;
return _shortcutKeyHandler.get();
}
shared_ptr<NotificationManager> Emulator::GetNotificationManager()
NotificationManager* Emulator::GetNotificationManager()
{
return _notificationManager;
return _notificationManager.get();
}
EmuSettings* Emulator::GetSettings()
@ -779,34 +792,44 @@ EmuSettings* Emulator::GetSettings()
return _settings.get();
}
shared_ptr<SaveStateManager> Emulator::GetSaveStateManager()
SaveStateManager* Emulator::GetSaveStateManager()
{
return _saveStateManager;
return _saveStateManager.get();
}
shared_ptr<RewindManager> Emulator::GetRewindManager()
RewindManager* Emulator::GetRewindManager()
{
return _rewindManager;
return _rewindManager.get();
}
shared_ptr<DebugHud> Emulator::GetDebugHud()
DebugHud* Emulator::GetDebugHud()
{
return _debugHud;
return _debugHud.get();
}
shared_ptr<BatteryManager> Emulator::GetBatteryManager()
BatteryManager* Emulator::GetBatteryManager()
{
return _batteryManager;
return _batteryManager.get();
}
shared_ptr<CheatManager> Emulator::GetCheatManager()
CheatManager* Emulator::GetCheatManager()
{
return _cheatManager;
return _cheatManager.get();
}
shared_ptr<MovieManager> Emulator::GetMovieManager()
MovieManager* Emulator::GetMovieManager()
{
return _movieManager;
return _movieManager.get();
}
GameServer* Emulator::GetGameServer()
{
return _gameServer.get();
}
GameClient* Emulator::GetGameClient()
{
return _gameClient.get();
}
shared_ptr<SystemActionManager> Emulator::GetSystemActionManager()
@ -814,9 +837,13 @@ shared_ptr<SystemActionManager> Emulator::GetSystemActionManager()
return _systemActionManager;
}
shared_ptr<IControlManager> Emulator::GetControlManager()
IControlManager* Emulator::GetControlManager()
{
return _console->GetControlManager();
if(_console) {
return _console->GetControlManager();
} else {
return nullptr;
}
}
BaseVideoFilter* Emulator::GetVideoFilter()
@ -858,7 +885,7 @@ void Emulator::InitDebugger()
//Lock to make sure we don't try to start debuggers in 2 separate threads at once
auto lock = _debuggerLock.AcquireSafe();
if(!_debugger) {
_debugger.reset(new Debugger(this, _console.get()));
SafeResetDebugger(new Debugger(this, _console.get()));
}
}
}
@ -885,7 +912,7 @@ void Emulator::StopDebugger()
bool Emulator::IsDebugging()
{
return _debugger != nullptr;
return SafeGetDebugger() != nullptr;
}
thread::id Emulator::GetEmulationThreadId()

61
Core/Shared/Emulator.h
View file

@ -29,6 +29,8 @@ class BaseVideoFilter;
class ShortcutKeyHandler;
class SystemActionManager;
class AudioPlayerHud;
class GameServer;
class GameClient;
struct RomInfo;
struct TimingInfo;
@ -50,26 +52,27 @@ class Emulator : public std::enable_shared_from_this<Emulator>
{
private:
unique_ptr<thread> _emuThread;
shared_ptr<Debugger> _debugger;
unique_ptr<AudioPlayerHud> _audioPlayerHud;
unique_ptr<IConsole> _console;
shared_ptr<ShortcutKeyHandler> _shortcutKeyHandler;
shared_ptr<NotificationManager> _notificationManager;
shared_ptr<BatteryManager> _batteryManager;
shared_ptr<SoundMixer> _soundMixer;
shared_ptr<VideoRenderer> _videoRenderer;
shared_ptr<VideoDecoder> _videoDecoder;
shared_ptr<DebugHud> _debugHud;
shared_ptr<EmuSettings> _settings;
shared_ptr<SaveStateManager> _saveStateManager;
shared_ptr<RewindManager> _rewindManager;
shared_ptr<CheatManager> _cheatManager;
shared_ptr<MovieManager> _movieManager;
shared_ptr<Debugger> _debugger;
shared_ptr<SystemActionManager> _systemActionManager;
shared_ptr<IConsole> _console;
unique_ptr<AudioPlayerHud> _audioPlayerHud;
const unique_ptr<EmuSettings> _settings;
const unique_ptr<DebugHud> _debugHud;
const unique_ptr<NotificationManager> _notificationManager;
const unique_ptr<BatteryManager> _batteryManager;
const unique_ptr<SoundMixer> _soundMixer;
const unique_ptr<VideoRenderer> _videoRenderer;
const unique_ptr<VideoDecoder> _videoDecoder;
const unique_ptr<SaveStateManager> _saveStateManager;
const unique_ptr<CheatManager> _cheatManager;
const unique_ptr<MovieManager> _movieManager;
const shared_ptr<GameServer> _gameServer;
const shared_ptr<GameClient> _gameClient;
thread::id _emulationThreadId;
@ -106,6 +109,8 @@ private:
void RunFrameWithRunAhead();
void BlockDebuggerRequests();
shared_ptr<Debugger> SafeGetDebugger();
void SafeResetDebugger(Debugger* dbg);
public:
class DebuggerRequest
@ -181,21 +186,23 @@ public:
void Serialize(ostream& out, int compressionLevel = 1);
void Deserialize(istream& in, uint32_t fileFormatVersion, bool compressed = true);
shared_ptr<SoundMixer> GetSoundMixer();
shared_ptr<VideoRenderer> GetVideoRenderer();
shared_ptr<VideoDecoder> GetVideoDecoder();
shared_ptr<ShortcutKeyHandler> GetShortcutKeyHandler();
shared_ptr<NotificationManager> GetNotificationManager();
SoundMixer* GetSoundMixer();
VideoRenderer* GetVideoRenderer();
VideoDecoder* GetVideoDecoder();
ShortcutKeyHandler* GetShortcutKeyHandler();
NotificationManager* GetNotificationManager();
EmuSettings* GetSettings();
shared_ptr<SaveStateManager> GetSaveStateManager();
shared_ptr<RewindManager> GetRewindManager();
shared_ptr<DebugHud> GetDebugHud();
shared_ptr<BatteryManager> GetBatteryManager();
shared_ptr<CheatManager> GetCheatManager();
shared_ptr<MovieManager> GetMovieManager();
SaveStateManager* GetSaveStateManager();
RewindManager* GetRewindManager();
DebugHud* GetDebugHud();
BatteryManager* GetBatteryManager();
CheatManager* GetCheatManager();
MovieManager* GetMovieManager();
GameServer* GetGameServer();
GameClient* GetGameClient();
shared_ptr<SystemActionManager> GetSystemActionManager();
shared_ptr<IControlManager> GetControlManager();
IControlManager* GetControlManager();
BaseVideoFilter* GetVideoFilter();

2
Core/Shared/Interfaces/IConsole.h
View file

@ -47,7 +47,7 @@ public:
virtual void SaveBattery() = 0;
virtual shared_ptr<IControlManager> GetControlManager() = 0;
virtual IControlManager* GetControlManager() = 0;
virtual ConsoleRegion GetRegion() = 0;
virtual ConsoleType GetConsoleType() = 0;

4
Core/Shared/Movies/MesenMovie.cpp
View file

@ -16,7 +16,7 @@
#include "Utilities/HexUtilities.h"
#include "Utilities/VirtualFile.h"
MesenMovie::MesenMovie(shared_ptr<Emulator> emu, bool forTest)
MesenMovie::MesenMovie(Emulator* emu, bool forTest)
{
_emu = emu;
_forTest = forTest;
@ -127,7 +127,7 @@ bool MesenMovie::Play(VirtualFile &file)
//bool autoConfigureInput = _console->GetSettings()->CheckFlag(EmulationFlags::AutoConfigureInput);
//_console->GetSettings()->ClearFlags(EmulationFlags::AutoConfigureInput);
IControlManager *controlManager = _emu->GetControlManager().get();
IControlManager *controlManager = _emu->GetControlManager();
if(controlManager) {
//ControlManager can be empty if no game is loaded
controlManager->SetPollCounter(0);

6
Core/Shared/Movies/MesenMovie.h
View file

@ -13,10 +13,10 @@ struct CheatCode;
class MesenMovie : public IMovie, public INotificationListener, public IBatteryProvider, public std::enable_shared_from_this<MesenMovie>
{
private:
shared_ptr<Emulator> _emu;
Emulator* _emu;
VirtualFile _movieFile;
shared_ptr<ZipReader> _reader;
unique_ptr<ZipReader> _reader;
bool _playing = false;
size_t _deviceIndex = 0;
uint32_t _lastPollCounter = 0;
@ -41,7 +41,7 @@ private:
bool LoadCheat(string cheatData, CheatCode &code);
public:
MesenMovie(shared_ptr<Emulator> emu, bool silent);
MesenMovie(Emulator* emu, bool silent);
virtual ~MesenMovie();
bool Play(VirtualFile &file) override;

5
Core/Shared/Movies/MovieManager.cpp
View file

@ -8,7 +8,7 @@
#include "Shared/Movies/MesenMovie.h"
#include "Shared/Movies/MovieRecorder.h"
MovieManager::MovieManager(shared_ptr<Emulator> emu)
MovieManager::MovieManager(Emulator* emu)
{
_emu = emu;
}
@ -54,8 +54,7 @@ void MovieManager::Stop()
bool MovieManager::Playing()
{
shared_ptr<IMovie> player = _player;
return player && player->IsPlaying();
return _player != nullptr;
}
bool MovieManager::Recording()

6
Core/Shared/Movies/MovieManager.h
View file

@ -3,8 +3,8 @@
#include "Shared/MessageManager.h"
#include "Shared/Interfaces/IInputProvider.h"
#include "Shared/Movies/MovieTypes.h"
#include "Shared/Movies/MovieRecorder.h"
class MovieRecorder;
class VirtualFile;
class Emulator;
@ -18,12 +18,12 @@ public:
class MovieManager
{
private:
shared_ptr<Emulator> _emu;
Emulator* _emu;
shared_ptr<IMovie> _player;
shared_ptr<MovieRecorder> _recorder;
public:
MovieManager(shared_ptr<Emulator> emu);
MovieManager(Emulator* emu);
void Record(RecordMovieOptions options);
void Play(VirtualFile file, bool silent = false);

2
Core/Shared/Movies/MovieRecorder.cpp
View file

@ -17,7 +17,7 @@
#include "Shared/BatteryManager.h"
#include "Shared/CheatManager.h"
MovieRecorder::MovieRecorder(shared_ptr<Emulator> emu)
MovieRecorder::MovieRecorder(Emulator* emu)
{
_emu = emu;
}

4
Core/Shared/Movies/MovieRecorder.h
View file

@ -15,7 +15,7 @@ class MovieRecorder : public INotificationListener, public IInputRecorder, publi
private:
static const uint32_t MovieFormatVersion = 1;
shared_ptr<Emulator> _emu;
Emulator* _emu;
string _filename;
string _author;
string _description;
@ -32,7 +32,7 @@ private:
void WriteBool(stringstream &out, string name, bool enabled);
public:
MovieRecorder(shared_ptr<Emulator> emu);
MovieRecorder(Emulator* emu);
virtual ~MovieRecorder();
bool Record(RecordMovieOptions options);

9
Core/Shared/RecordedRomTest.cpp
View file

@ -13,14 +13,9 @@
#include "Utilities/ZipReader.h"
#include "Utilities/ArchiveReader.h"
RecordedRomTest::RecordedRomTest(shared_ptr<Emulator> emu)
RecordedRomTest::RecordedRomTest(Emulator* emu)
{
if(emu) {
_emu = emu;
} else {
_emu.reset(new Emulator());
_emu->Initialize();
}
_emu = emu;
Reset();
}

4
Core/Shared/RecordedRomTest.h
View file

@ -11,7 +11,7 @@ class Emulator;
class RecordedRomTest : public INotificationListener, public std::enable_shared_from_this<RecordedRomTest>
{
private:
shared_ptr<Emulator> _emu;
Emulator* _emu;
bool _recording = false;
bool _runningTest = false;
@ -34,7 +34,7 @@ private:
void Save();
public:
RecordedRomTest(shared_ptr<Emulator> console = nullptr);
RecordedRomTest(Emulator* console = nullptr);
virtual ~RecordedRomTest();
void ProcessNotification(ConsoleNotificationType type, void* parameter) override;

4
Core/Shared/RewindData.cpp
View file

@ -9,7 +9,7 @@ void RewindData::GetStateData(stringstream &stateData)
stateData.write((char*)SaveStateData.data(), SaveStateData.size());
}
void RewindData::LoadState(shared_ptr<Emulator> &emu)
void RewindData::LoadState(Emulator* emu)
{
if(SaveStateData.size() > 0) {
stringstream stream;
@ -20,7 +20,7 @@ void RewindData::LoadState(shared_ptr<Emulator> &emu)
}
}
void RewindData::SaveState(shared_ptr<Emulator> &emu)
void RewindData::SaveState(Emulator* emu)
{
std::stringstream state;
emu->Serialize(state);

4
Core/Shared/RewindData.h
View file

@ -17,6 +17,6 @@ public:
void GetStateData(stringstream &stateData);
void LoadState(shared_ptr<Emulator> &emu);
void SaveState(shared_ptr<Emulator> &emu);
void LoadState(Emulator* emu);
void SaveState(Emulator* emu);
};

2
Core/Shared/RewindManager.cpp
View file

@ -8,7 +8,7 @@
#include "Shared/BaseControlDevice.h"
#include "Shared/Interfaces/IControlManager.h"
RewindManager::RewindManager(shared_ptr<Emulator> emu)
RewindManager::RewindManager(Emulator* emu)
{
_emu = emu;
_settings = emu->GetSettings();

4
Core/Shared/RewindManager.h
View file

@ -30,7 +30,7 @@ class RewindManager : public INotificationListener, public IInputProvider, publi
private:
static constexpr int32_t BufferSize = 60; //Number of frames between each save state
shared_ptr<Emulator> _emu;
Emulator* _emu;
EmuSettings* _settings;
bool _hasHistory;
@ -60,7 +60,7 @@ private:
void ClearBuffer();
public:
RewindManager(shared_ptr<Emulator> emu);
RewindManager(Emulator* emu);
virtual ~RewindManager();
void ProcessNotification(ConsoleNotificationType type, void* parameter) override;

2
Core/Shared/SaveStateManager.cpp
View file

@ -149,7 +149,7 @@ bool SaveStateManager::GetScreenshotData(vector<uint8_t>& out, uint32_t &width,
bool SaveStateManager::LoadState(istream &stream, bool hashCheckRequired)
{
if(GameClient::Connected()) {
if(_emu->GetGameClient()->Connected()) {
MessageManager::DisplayMessage("Netplay", "NetplayNotAllowed");
return false;
}

19
Core/Shared/ShortcutKeyHandler.cpp
View file

@ -17,6 +17,7 @@ ShortcutKeyHandler::ShortcutKeyHandler(Emulator* emu)
_keySetIndex = 0;
_isKeyUp = false;
_repeatStarted = false;
_needRepeat = false;
_stopThread = false;
_thread = std::thread([=]() {
@ -99,20 +100,15 @@ bool ShortcutKeyHandler::DetectKeyRelease(EmulatorShortcut shortcut)
void ShortcutKeyHandler::ProcessRunSingleFrame()
{
shared_ptr<Timer> timer = _runSingleFrameRepeatTimer;
if(!timer) {
timer.reset(new Timer());
_runSingleFrameRepeatTimer = timer;
}
timer->Reset();
_runSingleFrameRepeatTimer.Reset();
_needRepeat = true;
_emu->PauseOnNextFrame();
}
bool ShortcutKeyHandler::IsShortcutAllowed(EmulatorShortcut shortcut)
{
bool isRunning = _emu->IsRunning();
bool isNetplayClient = GameClient::Connected();
bool isNetplayClient = _emu->GetGameClient()->Connected();
bool isMoviePlaying = _emu->GetMovieManager()->Playing();
bool isMovieRecording = _emu->GetMovieManager()->Recording();
bool isMovieActive = isMoviePlaying || isMovieRecording;
@ -261,8 +257,8 @@ void ShortcutKeyHandler::ProcessShortcutReleased(EmulatorShortcut shortcut)
case EmulatorShortcut::Rewind: _emu->GetRewindManager()->StopRewinding(); break;
case EmulatorShortcut::RunSingleFrame:
_runSingleFrameRepeatTimer.reset();
_repeatStarted = false;
_needRepeat = false;
break;
}
}
@ -323,9 +319,8 @@ void ShortcutKeyHandler::ProcessKeys()
_lastPressedKeys = _pressedKeys;
}
shared_ptr<Timer> timer = _runSingleFrameRepeatTimer;
if(timer) {
double elapsedMs = timer->GetElapsedMS();
if(_needRepeat) {
double elapsedMs = _runSingleFrameRepeatTimer.GetElapsedMS();
if((_repeatStarted && elapsedMs >= 50) || (!_repeatStarted && elapsedMs >= 500)) {
//Over 500ms has elapsed since the key was first pressed, or over 50ms since repeat mode started (20fps)
//In this case, run another frame and pause again.

5
Core/Shared/ShortcutKeyHandler.h
View file

@ -21,8 +21,9 @@ private:
vector<uint32_t> _lastPressedKeys;
bool _isKeyUp;
shared_ptr<Timer> _runSingleFrameRepeatTimer;
bool _repeatStarted;
Timer _runSingleFrameRepeatTimer;
atomic<bool> _repeatStarted;
atomic<bool> _needRepeat;
unordered_set<uint32_t> _keysDown[2];
unordered_set<uint32_t> _prevKeysDown[2];

2
Core/Shared/Video/BaseRenderer.cpp
View file

@ -5,7 +5,7 @@
#include "Shared/EmuSettings.h"
#include "Shared/MessageManager.h"
BaseRenderer::BaseRenderer(shared_ptr<Emulator> emu, bool registerAsMessageManager)
BaseRenderer::BaseRenderer(Emulator* emu, bool registerAsMessageManager)
{
_emu = emu;

4
Core/Shared/Video/BaseRenderer.h
View file

@ -8,11 +8,11 @@ class Emulator;
class BaseRenderer
{
protected:
shared_ptr<Emulator> _emu;
Emulator* _emu;
uint32_t _screenWidth = 0;
uint32_t _screenHeight = 0;
BaseRenderer(shared_ptr<Emulator> emu, bool registerAsMessageManager);
BaseRenderer(Emulator* emu, bool registerAsMessageManager);
virtual ~BaseRenderer();
};

Some files were not shown because too many files have changed in this diff Show more