Merge pull request dolphin-emu#12606 from mitaclaw/state-global-system

AdmiralCurtiss · web-flow · commit 3948ac9513b3 · 2024-03-22T04:27:12.000+01:00
State: Avoid Global System Accessor
diff --git a/Source/Android/jni/MainAndroid.cpp b/Source/Android/jni/MainAndroid.cpp
@@ -315,29 +315,29 @@ JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_SaveState(JN
                                                                               jboolean wait)
 {
   HostThreadLock guard;
-  State::Save(slot, wait);
+  State::Save(Core::System::GetInstance(), slot, wait);
 }
 
 JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_SaveStateAs(JNIEnv* env, jclass,
                                                                                 jstring path,
                                                                                 jboolean wait)
 {
   HostThreadLock guard;
-  State::SaveAs(GetJString(env, path), wait);
+  State::SaveAs(Core::System::GetInstance(), GetJString(env, path), wait);
 }
 
 JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_LoadState(JNIEnv*, jclass,
                                                                               jint slot)
 {
   HostThreadLock guard;
-  State::Load(slot);
+  State::Load(Core::System::GetInstance(), slot);
 }
 
 JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_LoadStateAs(JNIEnv* env, jclass,
                                                                                 jstring path)
 {
   HostThreadLock guard;
-  State::LoadAs(GetJString(env, path));
+  State::LoadAs(Core::System::GetInstance(), GetJString(env, path));
 }
 
 JNIEXPORT jlong JNICALL
diff --git a/Source/Core/Core/Core.cpp b/Source/Core/Core/Core.cpp
@@ -389,7 +389,7 @@ static void CpuThread(Core::System& system, const std::optional<std::string>& sa
 
   if (savestate_path)
   {
-    ::State::LoadAs(*savestate_path);
+    ::State::LoadAs(system, *savestate_path);
     if (delete_savestate)
       File::Delete(*savestate_path);
   }
diff --git a/Source/Core/Core/HW/HW.cpp b/Source/Core/Core/HW/HW.cpp
@@ -35,7 +35,7 @@ void Init(Core::System& system, const Sram* override_sram)
   system.GetCoreTiming().Init();
   system.GetSystemTimers().PreInit();
 
-  State::Init();
+  State::Init(system);
 
   // Init the whole Hardware
   system.GetAudioInterface().Init();
diff --git a/Source/Core/Core/Movie.cpp b/Source/Core/Core/Movie.cpp
@@ -541,7 +541,7 @@ bool MovieManager::BeginRecordingInput(const ControllerTypeArray& controllers,
       if (File::Exists(save_path))
         File::Delete(save_path);
 
-      State::SaveAs(save_path);
+      State::SaveAs(m_system, save_path);
       m_recording_from_save_state = true;
 
       std::thread md5thread(&MovieManager::GetMD5, this);
diff --git a/Source/Core/Core/State.cpp b/Source/Core/Core/State.cpp
@@ -138,10 +138,8 @@ void EnableCompression(bool compression)
   s_use_compression = compression;
 }
 
-static void DoState(PointerWrap& p)
+static void DoState(Core::System& system, PointerWrap& p)
 {
-  auto& system = Core::System::GetInstance();
-
   bool is_wii = system.IsWii() || system.IsMIOS();
   const bool is_wii_currently = is_wii;
   p.Do(is_wii);
@@ -202,7 +200,7 @@ static void DoState(PointerWrap& p)
   p.DoMarker("Gecko");
 }
 
-void LoadFromBuffer(std::vector<u8>& buffer)
+void LoadFromBuffer(Core::System& system, std::vector<u8>& buffer)
 {
   if (NetPlay::IsNetPlayRunning())
   {
@@ -222,25 +220,25 @@ void LoadFromBuffer(std::vector<u8>& buffer)
       [&] {
         u8* ptr = buffer.data();
         PointerWrap p(&ptr, buffer.size(), PointerWrap::Mode::Read);
-        DoState(p);
+        DoState(system, p);
       },
       true);
 }
 
-void SaveToBuffer(std::vector<u8>& buffer)
+void SaveToBuffer(Core::System& system, std::vector<u8>& buffer)
 {
   Core::RunOnCPUThread(
       [&] {
         u8* ptr = nullptr;
         PointerWrap p_measure(&ptr, 0, PointerWrap::Mode::Measure);
 
-        DoState(p_measure);
+        DoState(system, p_measure);
         const size_t buffer_size = reinterpret_cast<size_t>(ptr);
         buffer.resize(buffer_size);
 
         ptr = buffer.data();
         PointerWrap p(&ptr, buffer_size, PointerWrap::Mode::Write);
-        DoState(p);
+        DoState(system, p);
       },
       true);
 }
@@ -382,7 +380,7 @@ static void WriteHeadersToFile(size_t uncompressed_size, File::IOFile& f)
   // If StateExtendedHeader is amended to include more than the base, add WriteBytes() calls here.
 }
 
-static void CompressAndDumpState(CompressAndDumpState_args& save_args)
+static void CompressAndDumpState(Core::System& system, CompressAndDumpState_args& save_args)
 {
   const u8* const buffer_data = save_args.buffer_vector.data();
   const size_t buffer_size = save_args.buffer_vector.size();
@@ -442,7 +440,7 @@ static void CompressAndDumpState(CompressAndDumpState_args& save_args)
       }
     }
 
-    auto& movie = Core::System::GetInstance().GetMovie();
+    auto& movie = system.GetMovie();
     if ((movie.IsMovieActive()) && !movie.IsJustStartingRecordingInputFromSaveState())
       movie.SaveRecording(dtmname);
     else if (!movie.IsMovieActive())
@@ -468,7 +466,7 @@ static void CompressAndDumpState(CompressAndDumpState_args& save_args)
   Host_UpdateMainFrame();
 }
 
-void SaveAs(const std::string& filename, bool wait)
+void SaveAs(Core::System& system, const std::string& filename, bool wait)
 {
   std::unique_lock lk(s_load_or_save_in_progress_mutex, std::try_to_lock);
   if (!lk)
@@ -484,15 +482,15 @@ void SaveAs(const std::string& filename, bool wait)
         // Measure the size of the buffer.
         u8* ptr = nullptr;
         PointerWrap p_measure(&ptr, 0, PointerWrap::Mode::Measure);
-        DoState(p_measure);
+        DoState(system, p_measure);
         const size_t buffer_size = reinterpret_cast<size_t>(ptr);
 
         // Then actually do the write.
         std::vector<u8> current_buffer;
         current_buffer.resize(buffer_size);
         ptr = current_buffer.data();
         PointerWrap p(&ptr, buffer_size, PointerWrap::Mode::Write);
-        DoState(p);
+        DoState(system, p);
 
         if (p.IsWriteMode())
         {
@@ -849,7 +847,7 @@ static void LoadFileStateData(const std::string& filename, std::vector<u8>& ret_
   ret_data.swap(buffer);
 }
 
-void LoadAs(const std::string& filename)
+void LoadAs(Core::System& system, const std::string& filename)
 {
   if (!Core::IsRunning())
     return;
@@ -875,11 +873,11 @@ void LoadAs(const std::string& filename)
   Core::RunOnCPUThread(
       [&] {
         // Save temp buffer for undo load state
-        auto& movie = Core::System::GetInstance().GetMovie();
+        auto& movie = system.GetMovie();
         if (!movie.IsJustStartingRecordingInputFromSaveState())
         {
           std::lock_guard lk2(s_undo_load_buffer_mutex);
-          SaveToBuffer(s_undo_load_buffer);
+          SaveToBuffer(system, s_undo_load_buffer);
           const std::string dtmpath = File::GetUserPath(D_STATESAVES_IDX) + "undo.dtm";
           if (movie.IsMovieActive())
             movie.SaveRecording(dtmpath);
@@ -899,7 +897,7 @@ void LoadAs(const std::string& filename)
           {
             u8* ptr = buffer.data();
             PointerWrap p(&ptr, buffer.size(), PointerWrap::Mode::Read);
-            DoState(p);
+            DoState(system, p);
             loaded = true;
             loadedSuccessfully = p.IsReadMode();
           }
@@ -923,7 +921,7 @@ void LoadAs(const std::string& filename)
             Core::DisplayMessage("The savestate could not be loaded", OSD::Duration::NORMAL);
 
             // since we could be in an inconsistent state now (and might crash or whatever), undo.
-            UndoLoadState();
+            UndoLoadState(system);
           }
         }
 
@@ -938,10 +936,10 @@ void SetOnAfterLoadCallback(AfterLoadCallbackFunc callback)
   s_on_after_load_callback = std::move(callback);
 }
 
-void Init()
+void Init(Core::System& system)
 {
-  s_save_thread.Reset("Savestate Worker", [](CompressAndDumpState_args args) {
-    CompressAndDumpState(args);
+  s_save_thread.Reset("Savestate Worker", [&system](CompressAndDumpState_args args) {
+    CompressAndDumpState(system, args);
 
     {
       std::lock_guard lk(s_state_writes_in_queue_mutex);
@@ -973,17 +971,17 @@ static std::string MakeStateFilename(int number)
                      SConfig::GetInstance().GetGameID(), number);
 }
 
-void Save(int slot, bool wait)
+void Save(Core::System& system, int slot, bool wait)
 {
-  SaveAs(MakeStateFilename(slot), wait);
+  SaveAs(system, MakeStateFilename(slot), wait);
 }
 
-void Load(int slot)
+void Load(Core::System& system, int slot)
 {
-  LoadAs(MakeStateFilename(slot));
+  LoadAs(system, MakeStateFilename(slot));
 }
 
-void LoadLastSaved(int i)
+void LoadLastSaved(Core::System& system, int i)
 {
   if (i <= 0)
   {
@@ -999,38 +997,38 @@ void LoadLastSaved(int i)
   }
 
   std::stable_sort(used_slots.begin(), used_slots.end(), CompareTimestamp);
-  Load((used_slots.end() - i)->slot);
+  Load(system, (used_slots.end() - i)->slot);
 }
 
 // must wait for state to be written because it must know if all slots are taken
-void SaveFirstSaved()
+void SaveFirstSaved(Core::System& system)
 {
   std::vector<SlotWithTimestamp> used_slots = GetUsedSlotsWithTimestamp();
   if (used_slots.size() < NUM_STATES)
   {
     // save to an empty slot
-    Save(GetEmptySlot(used_slots), true);
+    Save(system, GetEmptySlot(used_slots), true);
     return;
   }
 
   // overwrite the oldest state
   std::stable_sort(used_slots.begin(), used_slots.end(), CompareTimestamp);
-  Save(used_slots.front().slot, true);
+  Save(system, used_slots.front().slot, true);
 }
 
 // Load the last state before loading the state
-void UndoLoadState()
+void UndoLoadState(Core::System& system)
 {
   std::lock_guard lk(s_undo_load_buffer_mutex);
   if (!s_undo_load_buffer.empty())
   {
-    auto& movie = Core::System::GetInstance().GetMovie();
+    auto& movie = system.GetMovie();
     if (movie.IsMovieActive())
     {
       const std::string dtmpath = File::GetUserPath(D_STATESAVES_IDX) + "undo.dtm";
       if (File::Exists(dtmpath))
       {
-        LoadFromBuffer(s_undo_load_buffer);
+        LoadFromBuffer(system, s_undo_load_buffer);
         movie.LoadInput(dtmpath);
       }
       else
@@ -1040,7 +1038,7 @@ void UndoLoadState()
     }
     else
     {
-      LoadFromBuffer(s_undo_load_buffer);
+      LoadFromBuffer(system, s_undo_load_buffer);
     }
   }
   else
@@ -1050,9 +1048,9 @@ void UndoLoadState()
 }
 
 // Load the state that the last save state overwritten on
-void UndoSaveState()
+void UndoSaveState(Core::System& system)
 {
-  LoadAs(File::GetUserPath(D_STATESAVES_IDX) + "lastState.sav");
+  LoadAs(system, File::GetUserPath(D_STATESAVES_IDX) + "lastState.sav");
 }
 
 }  // namespace State
diff --git a/Source/Core/Core/State.h b/Source/Core/Core/State.h
@@ -13,6 +13,11 @@
 
 #include "Common/CommonTypes.h"
 
+namespace Core
+{
+class System;
+}
+
 namespace State
 {
 // number of states
@@ -75,7 +80,7 @@ struct StateExtendedHeader
   // and WriteHeadersToFile()
 };
 
-void Init();
+void Init(Core::System& system);
 
 void Shutdown();
 
@@ -95,19 +100,19 @@ u64 GetUnixTimeOfSlot(int slot);
 //    If we're in the main CPU thread then they run immediately instead
 //    because some things (like Lua) need them to run immediately.
 // Slots from 0-99.
-void Save(int slot, bool wait = false);
-void Load(int slot);
+void Save(Core::System& system, int slot, bool wait = false);
+void Load(Core::System& system, int slot);
 
-void SaveAs(const std::string& filename, bool wait = false);
-void LoadAs(const std::string& filename);
+void SaveAs(Core::System& system, const std::string& filename, bool wait = false);
+void LoadAs(Core::System& system, const std::string& filename);
 
-void SaveToBuffer(std::vector<u8>& buffer);
-void LoadFromBuffer(std::vector<u8>& buffer);
+void SaveToBuffer(Core::System& system, std::vector<u8>& buffer);
+void LoadFromBuffer(Core::System& system, std::vector<u8>& buffer);
 
-void LoadLastSaved(int i = 1);
-void SaveFirstSaved();
-void UndoSaveState();
-void UndoLoadState();
+void LoadLastSaved(Core::System& system, int i = 1);
+void SaveFirstSaved(Core::System& system);
+void UndoSaveState(Core::System& system);
+void UndoLoadState(Core::System& system);
 
 // for calling back into UI code without introducing a dependency on it in core
 using AfterLoadCallbackFunc = std::function<void()>;
diff --git a/Source/Core/DolphinNoGUI/PlatformMacos.mm b/Source/Core/DolphinNoGUI/PlatformMacos.mm
@@ -55,27 +55,27 @@ - (void)saveScreenShot
 
 - (void)loadLastSaved
 {
-  State::LoadLastSaved();
+  State::LoadLastSaved(Core::System::GetInstance());
 }
 
 - (void)undoLoadState
 {
-  State::UndoLoadState();
+  State::UndoLoadState(Core::System::GetInstance());
 }
 
 - (void)undoSaveState
 {
-  State::UndoSaveState();
+  State::UndoSaveState(Core::System::GetInstance());
 }
 
 - (void)loadState:(id)sender
 {
-  State::Load([sender tag]);
+  State::Load(Core::System::GetInstance(), [sender tag]);
 }
 
 - (void)saveState:(id)sender
 {
-  State::Save([sender tag]);
+  State::Save(Core::System::GetInstance(), [sender tag]);
 }
 @end
 
diff --git a/Source/Core/DolphinNoGUI/PlatformX11.cpp b/Source/Core/DolphinNoGUI/PlatformX11.cpp
diff --git a/Source/Core/DolphinQt/MainWindow.cpp b/Source/Core/DolphinQt/MainWindow.cpp
diff --git a/Source/Core/DolphinQt/RenderWidget.cpp b/Source/Core/DolphinQt/RenderWidget.cpp

Original file line number	Diff line number	Diff line change
`@@ -315,29 +315,29 @@ JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_SaveState(JN`
`315`	`315`	`jboolean wait)`
`316`	`316`	`{`
`317`	`317`	`HostThreadLock guard;`
`318`		`- State::Save(slot, wait);`
	`318`	`+ State::Save(Core::System::GetInstance(), slot, wait);`
`319`	`319`	`}`
`320`	`320`
`321`	`321`	`JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_SaveStateAs(JNIEnv* env, jclass,`
`322`	`322`	`jstring path,`
`323`	`323`	`jboolean wait)`
`324`	`324`	`{`
`325`	`325`	`HostThreadLock guard;`
`326`		`- State::SaveAs(GetJString(env, path), wait);`
	`326`	`+ State::SaveAs(Core::System::GetInstance(), GetJString(env, path), wait);`
`327`	`327`	`}`
`328`	`328`
`329`	`329`	`JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_LoadState(JNIEnv*, jclass,`
`330`	`330`	`jint slot)`
`331`	`331`	`{`
`332`	`332`	`HostThreadLock guard;`
`333`		`- State::Load(slot);`
	`333`	`+ State::Load(Core::System::GetInstance(), slot);`
`334`	`334`	`}`
`335`	`335`
`336`	`336`	`JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_LoadStateAs(JNIEnv* env, jclass,`
`337`	`337`	`jstring path)`
`338`	`338`	`{`
`339`	`339`	`HostThreadLock guard;`
`340`		`- State::LoadAs(GetJString(env, path));`
	`340`	`+ State::LoadAs(Core::System::GetInstance(), GetJString(env, path));`
`341`	`341`	`}`
`342`	`342`
`343`	`343`	`JNIEXPORT jlong JNICALL`
Original file line number	Diff line number	Diff line change
`@@ -389,7 +389,7 @@ static void CpuThread(Core::System& system, const std::optional<std::string>& sa`
`389`	`389`
`390`	`390`	`if (savestate_path)`
`391`	`391`	`{`
`392`		`- ::State::LoadAs(*savestate_path);`
	`392`	`+ ::State::LoadAs(system, *savestate_path);`
`393`	`393`	`if (delete_savestate)`
`394`	`394`	`File::Delete(*savestate_path);`
`395`	`395`	`}`
Original file line number	Diff line number	Diff line change
`@@ -138,10 +138,8 @@ void EnableCompression(bool compression)`
`138`	`138`	`s_use_compression = compression;`
`139`	`139`	`}`
`140`	`140`
`141`		`-static void DoState(PointerWrap& p)`
	`141`	`+static void DoState(Core::System& system, PointerWrap& p)`
`142`	`142`	`{`
`143`		`- auto& system = Core::System::GetInstance();`
`144`		`-`
`145`	`143`	`bool is_wii = system.IsWii() \|\| system.IsMIOS();`
`146`	`144`	`const bool is_wii_currently = is_wii;`
`147`	`145`	`p.Do(is_wii);`
`@@ -202,7 +200,7 @@ static void DoState(PointerWrap& p)`
`202`	`200`	`p.DoMarker("Gecko");`
`203`	`201`	`}`
`204`	`202`
`205`		`-void LoadFromBuffer(std::vector<u8>& buffer)`
	`203`	`+void LoadFromBuffer(Core::System& system, std::vector<u8>& buffer)`
`206`	`204`	`{`
`207`	`205`	`if (NetPlay::IsNetPlayRunning())`
`208`	`206`	`{`
`@@ -222,25 +220,25 @@ void LoadFromBuffer(std::vector<u8>& buffer)`
`222`	`220`	`[&] {`
`223`	`221`	`u8* ptr = buffer.data();`
`224`	`222`	`PointerWrap p(&ptr, buffer.size(), PointerWrap::Mode::Read);`
`225`		`- DoState(p);`
	`223`	`+ DoState(system, p);`
`226`	`224`	`},`
`227`	`225`	`true);`
`228`	`226`	`}`
`229`	`227`
`230`		`-void SaveToBuffer(std::vector<u8>& buffer)`
	`228`	`+void SaveToBuffer(Core::System& system, std::vector<u8>& buffer)`
`231`	`229`	`{`
`232`	`230`	`Core::RunOnCPUThread(`
`233`	`231`	`[&] {`
`234`	`232`	`u8* ptr = nullptr;`
`235`	`233`	`PointerWrap p_measure(&ptr, 0, PointerWrap::Mode::Measure);`
`236`	`234`
`237`		`- DoState(p_measure);`
	`235`	`+ DoState(system, p_measure);`
`238`	`236`	`const size_t buffer_size = reinterpret_cast<size_t>(ptr);`
`239`	`237`	`buffer.resize(buffer_size);`
`240`	`238`
`241`	`239`	`ptr = buffer.data();`
`242`	`240`	`PointerWrap p(&ptr, buffer_size, PointerWrap::Mode::Write);`
`243`		`- DoState(p);`
	`241`	`+ DoState(system, p);`
`244`	`242`	`},`
`245`	`243`	`true);`
`246`	`244`	`}`
`@@ -382,7 +380,7 @@ static void WriteHeadersToFile(size_t uncompressed_size, File::IOFile& f)`
`382`	`380`	`// If StateExtendedHeader is amended to include more than the base, add WriteBytes() calls here.`
`383`	`381`	`}`
`384`	`382`
`385`		`-static void CompressAndDumpState(CompressAndDumpState_args& save_args)`
	`383`	`+static void CompressAndDumpState(Core::System& system, CompressAndDumpState_args& save_args)`
`386`	`384`	`{`
`387`	`385`	`const u8* const buffer_data = save_args.buffer_vector.data();`
`388`	`386`	`const size_t buffer_size = save_args.buffer_vector.size();`
`@@ -442,7 +440,7 @@ static void CompressAndDumpState(CompressAndDumpState_args& save_args)`
`442`	`440`	`}`
`443`	`441`	`}`
`444`	`442`
`445`		`- auto& movie = Core::System::GetInstance().GetMovie();`
	`443`	`+ auto& movie = system.GetMovie();`
`446`	`444`	`if ((movie.IsMovieActive()) && !movie.IsJustStartingRecordingInputFromSaveState())`
`447`	`445`	`movie.SaveRecording(dtmname);`
`448`	`446`	`else if (!movie.IsMovieActive())`
`@@ -468,7 +466,7 @@ static void CompressAndDumpState(CompressAndDumpState_args& save_args)`
`468`	`466`	`Host_UpdateMainFrame();`
`469`	`467`	`}`
`470`	`468`
`471`		`-void SaveAs(const std::string& filename, bool wait)`
	`469`	`+void SaveAs(Core::System& system, const std::string& filename, bool wait)`
`472`	`470`	`{`
`473`	`471`	`std::unique_lock lk(s_load_or_save_in_progress_mutex, std::try_to_lock);`
`474`	`472`	`if (!lk)`
`@@ -484,15 +482,15 @@ void SaveAs(const std::string& filename, bool wait)`
`484`	`482`	`// Measure the size of the buffer.`
`485`	`483`	`u8* ptr = nullptr;`
`486`	`484`	`PointerWrap p_measure(&ptr, 0, PointerWrap::Mode::Measure);`
`487`		`- DoState(p_measure);`
	`485`	`+ DoState(system, p_measure);`
`488`	`486`	`const size_t buffer_size = reinterpret_cast<size_t>(ptr);`
`489`	`487`
`490`	`488`	`// Then actually do the write.`
`491`	`489`	`std::vector<u8> current_buffer;`
`492`	`490`	`current_buffer.resize(buffer_size);`
`493`	`491`	`ptr = current_buffer.data();`
`494`	`492`	`PointerWrap p(&ptr, buffer_size, PointerWrap::Mode::Write);`
`495`		`- DoState(p);`
	`493`	`+ DoState(system, p);`
`496`	`494`
`497`	`495`	`if (p.IsWriteMode())`
`498`	`496`	`{`
`@@ -849,7 +847,7 @@ static void LoadFileStateData(const std::string& filename, std::vector<u8>& ret_`
`849`	`847`	`ret_data.swap(buffer);`
`850`	`848`	`}`
`851`	`849`
`852`		`-void LoadAs(const std::string& filename)`
	`850`	`+void LoadAs(Core::System& system, const std::string& filename)`
`853`	`851`	`{`
`854`	`852`	`if (!Core::IsRunning())`
`855`	`853`	`return;`
`@@ -875,11 +873,11 @@ void LoadAs(const std::string& filename)`
`875`	`873`	`Core::RunOnCPUThread(`
`876`	`874`	`[&] {`
`877`	`875`	`// Save temp buffer for undo load state`
`878`		`- auto& movie = Core::System::GetInstance().GetMovie();`
	`876`	`+ auto& movie = system.GetMovie();`
`879`	`877`	`if (!movie.IsJustStartingRecordingInputFromSaveState())`
`880`	`878`	`{`
`881`	`879`	`std::lock_guard lk2(s_undo_load_buffer_mutex);`
`882`		`- SaveToBuffer(s_undo_load_buffer);`
	`880`	`+ SaveToBuffer(system, s_undo_load_buffer);`
`883`	`881`	`const std::string dtmpath = File::GetUserPath(D_STATESAVES_IDX) + "undo.dtm";`
`884`	`882`	`if (movie.IsMovieActive())`
`885`	`883`	`movie.SaveRecording(dtmpath);`
`@@ -899,7 +897,7 @@ void LoadAs(const std::string& filename)`
`899`	`897`	`{`
`900`	`898`	`u8* ptr = buffer.data();`
`901`	`899`	`PointerWrap p(&ptr, buffer.size(), PointerWrap::Mode::Read);`
`902`		`- DoState(p);`
	`900`	`+ DoState(system, p);`
`903`	`901`	`loaded = true;`
`904`	`902`	`loadedSuccessfully = p.IsReadMode();`
`905`	`903`	`}`
`@@ -923,7 +921,7 @@ void LoadAs(const std::string& filename)`
`923`	`921`	`Core::DisplayMessage("The savestate could not be loaded", OSD::Duration::NORMAL);`
`924`	`922`
`925`	`923`	`// since we could be in an inconsistent state now (and might crash or whatever), undo.`
`926`		`- UndoLoadState();`
	`924`	`+ UndoLoadState(system);`
`927`	`925`	`}`
`928`	`926`	`}`
`929`	`927`
`@@ -938,10 +936,10 @@ void SetOnAfterLoadCallback(AfterLoadCallbackFunc callback)`
`938`	`936`	`s_on_after_load_callback = std::move(callback);`
`939`	`937`	`}`
`940`	`938`
`941`		`-void Init()`
	`939`	`+void Init(Core::System& system)`
`942`	`940`	`{`
`943`		`- s_save_thread.Reset("Savestate Worker", [](CompressAndDumpState_args args) {`
`944`		`- CompressAndDumpState(args);`
	`941`	`+ s_save_thread.Reset("Savestate Worker", [&system](CompressAndDumpState_args args) {`
	`942`	`+ CompressAndDumpState(system, args);`
`945`	`943`
`946`	`944`	`{`
`947`	`945`	`std::lock_guard lk(s_state_writes_in_queue_mutex);`
`@@ -973,17 +971,17 @@ static std::string MakeStateFilename(int number)`
`973`	`971`	`SConfig::GetInstance().GetGameID(), number);`
`974`	`972`	`}`
`975`	`973`
`976`		`-void Save(int slot, bool wait)`
	`974`	`+void Save(Core::System& system, int slot, bool wait)`
`977`	`975`	`{`
`978`		`- SaveAs(MakeStateFilename(slot), wait);`
	`976`	`+ SaveAs(system, MakeStateFilename(slot), wait);`
`979`	`977`	`}`
`980`	`978`
`981`		`-void Load(int slot)`
	`979`	`+void Load(Core::System& system, int slot)`
`982`	`980`	`{`
`983`		`- LoadAs(MakeStateFilename(slot));`
	`981`	`+ LoadAs(system, MakeStateFilename(slot));`
`984`	`982`	`}`
`985`	`983`
`986`		`-void LoadLastSaved(int i)`
	`984`	`+void LoadLastSaved(Core::System& system, int i)`
`987`	`985`	`{`
`988`	`986`	`if (i <= 0)`
`989`	`987`	`{`
`@@ -999,38 +997,38 @@ void LoadLastSaved(int i)`
`999`	`997`	`}`
`1000`	`998`
`1001`	`999`	`std::stable_sort(used_slots.begin(), used_slots.end(), CompareTimestamp);`
`1002`		`- Load((used_slots.end() - i)->slot);`
	`1000`	`+ Load(system, (used_slots.end() - i)->slot);`
`1003`	`1001`	`}`
`1004`	`1002`
`1005`	`1003`	`// must wait for state to be written because it must know if all slots are taken`
`1006`		`-void SaveFirstSaved()`
	`1004`	`+void SaveFirstSaved(Core::System& system)`
`1007`	`1005`	`{`
`1008`	`1006`	`std::vector<SlotWithTimestamp> used_slots = GetUsedSlotsWithTimestamp();`
`1009`	`1007`	`if (used_slots.size() < NUM_STATES)`
`1010`	`1008`	`{`
`1011`	`1009`	`// save to an empty slot`
`1012`		`- Save(GetEmptySlot(used_slots), true);`
	`1010`	`+ Save(system, GetEmptySlot(used_slots), true);`
`1013`	`1011`	`return;`
`1014`	`1012`	`}`
`1015`	`1013`
`1016`	`1014`	`// overwrite the oldest state`
`1017`	`1015`	`std::stable_sort(used_slots.begin(), used_slots.end(), CompareTimestamp);`
`1018`		`- Save(used_slots.front().slot, true);`
	`1016`	`+ Save(system, used_slots.front().slot, true);`
`1019`	`1017`	`}`
`1020`	`1018`
`1021`	`1019`	`// Load the last state before loading the state`
`1022`		`-void UndoLoadState()`
	`1020`	`+void UndoLoadState(Core::System& system)`
`1023`	`1021`	`{`
`1024`	`1022`	`std::lock_guard lk(s_undo_load_buffer_mutex);`
`1025`	`1023`	`if (!s_undo_load_buffer.empty())`
`1026`	`1024`	`{`
`1027`		`- auto& movie = Core::System::GetInstance().GetMovie();`
	`1025`	`+ auto& movie = system.GetMovie();`
`1028`	`1026`	`if (movie.IsMovieActive())`
`1029`	`1027`	`{`
`1030`	`1028`	`const std::string dtmpath = File::GetUserPath(D_STATESAVES_IDX) + "undo.dtm";`
`1031`	`1029`	`if (File::Exists(dtmpath))`
`1032`	`1030`	`{`
`1033`		`- LoadFromBuffer(s_undo_load_buffer);`
	`1031`	`+ LoadFromBuffer(system, s_undo_load_buffer);`
`1034`	`1032`	`movie.LoadInput(dtmpath);`
`1035`	`1033`	`}`
`1036`	`1034`	`else`
`@@ -1040,7 +1038,7 @@ void UndoLoadState()`
`1040`	`1038`	`}`
`1041`	`1039`	`else`
`1042`	`1040`	`{`
`1043`		`- LoadFromBuffer(s_undo_load_buffer);`
	`1041`	`+ LoadFromBuffer(system, s_undo_load_buffer);`
`1044`	`1042`	`}`
`1045`	`1043`	`}`
`1046`	`1044`	`else`
`@@ -1050,9 +1048,9 @@ void UndoLoadState()`
`1050`	`1048`	`}`
`1051`	`1049`
`1052`	`1050`	`// Load the state that the last save state overwritten on`
`1053`		`-void UndoSaveState()`
	`1051`	`+void UndoSaveState(Core::System& system)`
`1054`	`1052`	`{`
`1055`		`- LoadAs(File::GetUserPath(D_STATESAVES_IDX) + "lastState.sav");`
	`1053`	`+ LoadAs(system, File::GetUserPath(D_STATESAVES_IDX) + "lastState.sav");`
`1056`	`1054`	`}`
`1057`	`1055`
`1058`	`1056`	`} // namespace State`
Original file line number	Diff line number	Diff line change
`@@ -55,27 +55,27 @@ - (void)saveScreenShot`
`55`	`55`
`56`	`56`	`- (void)loadLastSaved`
`57`	`57`	`{`
`58`		`- State::LoadLastSaved();`
	`58`	`+ State::LoadLastSaved(Core::System::GetInstance());`
`59`	`59`	`}`
`60`	`60`
`61`	`61`	`- (void)undoLoadState`
`62`	`62`	`{`
`63`		`- State::UndoLoadState();`
	`63`	`+ State::UndoLoadState(Core::System::GetInstance());`
`64`	`64`	`}`
`65`	`65`
`66`	`66`	`- (void)undoSaveState`
`67`	`67`	`{`
`68`		`- State::UndoSaveState();`
	`68`	`+ State::UndoSaveState(Core::System::GetInstance());`
`69`	`69`	`}`
`70`	`70`
`71`	`71`	`- (void)loadState:(id)sender`
`72`	`72`	`{`
`73`		`- State::Load([sender tag]);`
	`73`	`+ State::Load(Core::System::GetInstance(), [sender tag]);`
`74`	`74`	`}`
`75`	`75`
`76`	`76`	`- (void)saveState:(id)sender`
`77`	`77`	`{`
`78`		`- State::Save([sender tag]);`
	`78`	`+ State::Save(Core::System::GetInstance(), [sender tag]);`
`79`	`79`	`}`
`80`	`80`	`@end`
`81`	`81`