diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt index 689d2c9da..85804eef5 100644 --- a/src/core/CMakeLists.txt +++ b/src/core/CMakeLists.txt @@ -51,12 +51,14 @@ add_library(core gte.cpp gte.h gte_types.h + host.h host_display.cpp host_display.h host_interface.cpp host_interface.h host_interface_progress_callback.cpp host_interface_progress_callback.h + host_settings.h imgui_styles.cpp imgui_styles.h imgui_fullscreen.cpp diff --git a/src/core/core.vcxproj b/src/core/core.vcxproj index 33a6a4106..8d1bcd3a8 100644 --- a/src/core/core.vcxproj +++ b/src/core/core.vcxproj @@ -117,9 +117,11 @@ + + diff --git a/src/core/core.vcxproj.filters b/src/core/core.vcxproj.filters index d1a7fb20e..4343db72d 100644 --- a/src/core/core.vcxproj.filters +++ b/src/core/core.vcxproj.filters @@ -126,5 +126,7 @@ + + \ No newline at end of file diff --git a/src/core/host.h b/src/core/host.h new file mode 100644 index 000000000..b810315c7 --- /dev/null +++ b/src/core/host.h @@ -0,0 +1,29 @@ +#pragma once + +#include "common/types.h" + +#include +#include +#include +#include + +namespace Host { +/// Reads a file from the resources directory of the application. +/// This may be outside of the "normal" filesystem on platforms such as Mac. +std::optional> ReadResourceFile(const char* filename); + +/// Reads a resource file file from the resources directory as a string. +std::optional ReadResourceFileToString(const char* filename); + +/// Adds OSD messages, duration is in seconds. +void AddOSDMessage(std::string message, float duration = 2.0f); +void AddKeyedOSDMessage(std::string key, std::string message, float duration = 2.0f); +void AddFormattedOSDMessage(float duration, const char* format, ...); +void AddKeyedFormattedOSDMessage(std::string key, float duration, const char* format, ...); +void RemoveKeyedOSDMessage(std::string key); +void ClearOSDMessages(); + +/// Displays an asynchronous error on the UI thread, i.e. doesn't block the caller. +void ReportErrorAsync(const std::string_view& title, const std::string_view& message); +void ReportFormattedErrorAsync(const std::string_view& title, const char* format, ...); +} // namespace Host diff --git a/src/core/host_settings.h b/src/core/host_settings.h new file mode 100644 index 000000000..8d70221ab --- /dev/null +++ b/src/core/host_settings.h @@ -0,0 +1,70 @@ +#pragma once + +#include "common/types.h" +#include +#include +#include + +class SettingsInterface; + +namespace Host { +// Base setting retrieval, bypasses layers. +std::string GetBaseStringSettingValue(const char* section, const char* key, const char* default_value = ""); +bool GetBaseBoolSettingValue(const char* section, const char* key, bool default_value = false); +s32 GetBaseIntSettingValue(const char* section, const char* key, s32 default_value = 0); +u32 GetBaseUIntSettingValue(const char* section, const char* key, u32 default_value = 0); +float GetBaseFloatSettingValue(const char* section, const char* key, float default_value = 0.0f); +double GetBaseDoubleSettingValue(const char* section, const char* key, double default_value = 0.0); +std::vector GetBaseStringListSetting(const char* section, const char* key); + +// Allows the emucore to write settings back to the frontend. Use with care. +// You should call CommitBaseSettingChanges() after finishing writing, or it may not be written to disk. +void SetBaseBoolSettingValue(const char* section, const char* key, bool value); +void SetBaseIntSettingValue(const char* section, const char* key, s32 value); +void SetBaseUIntSettingValue(const char* section, const char* key, u32 value); +void SetBaseFloatSettingValue(const char* section, const char* key, float value); +void SetBaseStringSettingValue(const char* section, const char* key, const char* value); +void SetBaseStringListSettingValue(const char* section, const char* key, const std::vector& values); +void DeleteBaseSettingValue(const char* section, const char* key); +void CommitBaseSettingChanges(); + +// Settings access, thread-safe. +std::string GetStringSettingValue(const char* section, const char* key, const char* default_value = ""); +bool GetBoolSettingValue(const char* section, const char* key, bool default_value = false); +int GetIntSettingValue(const char* section, const char* key, s32 default_value = 0); +u32 GetUIntSettingValue(const char* section, const char* key, u32 default_value = 0); +float GetFloatSettingValue(const char* section, const char* key, float default_value = 0.0f); +double GetDoubleSettingValue(const char* section, const char* key, double default_value = 0.0); +std::vector GetStringListSetting(const char* section, const char* key); + +/// Direct access to settings interface. Must hold the lock when calling GetSettingsInterface() and while using it. +std::unique_lock GetSettingsLock(); +SettingsInterface* GetSettingsInterface(); + +/// Returns the settings interface that controller bindings should be loaded from. +/// If an input profile is being used, this will be the input layer, otherwise the layered interface. +SettingsInterface* GetSettingsInterfaceForBindings(); + +namespace Internal { +/// Retrieves the base settings layer. Must call with lock held. +SettingsInterface* GetBaseSettingsLayer(); + +/// Retrieves the game settings layer, if present. Must call with lock held. +SettingsInterface* GetGameSettingsLayer(); + +/// Retrieves the input settings layer, if present. Must call with lock held. +SettingsInterface* GetInputSettingsLayer(); + +/// Sets the base settings layer. Should be called by the host at initialization time. +void SetBaseSettingsLayer(SettingsInterface* sif); + +/// Sets the game settings layer. Called by VMManager when the game changes. +void SetGameSettingsLayer(SettingsInterface* sif); + +/// Sets the input profile settings layer. Called by VMManager when the game changes. +void SetInputSettingsLayer(SettingsInterface* sif); + +/// Updates the variables in the EmuFolders namespace, reloading subsystems if needed. Must call with the lock held. +void UpdateEmuFolders(); +} // namespace Internal +} // namespace Host \ No newline at end of file diff --git a/src/frontend-common/CMakeLists.txt b/src/frontend-common/CMakeLists.txt index 4238bc3ff..53d8cbd29 100644 --- a/src/frontend-common/CMakeLists.txt +++ b/src/frontend-common/CMakeLists.txt @@ -15,6 +15,7 @@ add_library(frontend-common game_list.h game_settings.cpp game_settings.h + host_settings.cpp icon.cpp icon.h inhibit_screensaver.cpp diff --git a/src/frontend-common/frontend-common.vcxproj b/src/frontend-common/frontend-common.vcxproj index bd043dfea..f0b15cfe4 100644 --- a/src/frontend-common/frontend-common.vcxproj +++ b/src/frontend-common/frontend-common.vcxproj @@ -17,6 +17,7 @@ + diff --git a/src/frontend-common/frontend-common.vcxproj.filters b/src/frontend-common/frontend-common.vcxproj.filters index 984952650..211e68cea 100644 --- a/src/frontend-common/frontend-common.vcxproj.filters +++ b/src/frontend-common/frontend-common.vcxproj.filters @@ -31,6 +31,7 @@ + diff --git a/src/frontend-common/host_settings.cpp b/src/frontend-common/host_settings.cpp new file mode 100644 index 000000000..1e9ef11aa --- /dev/null +++ b/src/frontend-common/host_settings.cpp @@ -0,0 +1,192 @@ +#include "core/host.h" +#include "core/host_settings.h" +#include "common/assert.h" +#include "common/layered_settings_interface.h" + +static std::mutex s_settings_mutex; +static LayeredSettingsInterface s_layered_settings_interface; + +std::unique_lock Host::GetSettingsLock() +{ + return std::unique_lock(s_settings_mutex); +} + +SettingsInterface* Host::GetSettingsInterface() +{ + return &s_layered_settings_interface; +} + +SettingsInterface* Host::GetSettingsInterfaceForBindings() +{ + SettingsInterface* input_layer = s_layered_settings_interface.GetLayer(LayeredSettingsInterface::LAYER_INPUT); + return input_layer ? input_layer : &s_layered_settings_interface; +} + +std::string Host::GetBaseStringSettingValue(const char* section, const char* key, const char* default_value /*= ""*/) +{ + std::unique_lock lock(s_settings_mutex); + return s_layered_settings_interface.GetLayer(LayeredSettingsInterface::LAYER_BASE)->GetStringValue(section, key, default_value); +} + +bool Host::GetBaseBoolSettingValue(const char* section, const char* key, bool default_value /*= false*/) +{ + std::unique_lock lock(s_settings_mutex); + return s_layered_settings_interface.GetLayer(LayeredSettingsInterface::LAYER_BASE)->GetBoolValue(section, key, default_value); +} + +s32 Host::GetBaseIntSettingValue(const char* section, const char* key, s32 default_value /*= 0*/) +{ + std::unique_lock lock(s_settings_mutex); + return s_layered_settings_interface.GetLayer(LayeredSettingsInterface::LAYER_BASE)->GetIntValue(section, key, default_value); +} + +u32 Host::GetBaseUIntSettingValue(const char* section, const char* key, u32 default_value /*= 0*/) +{ + std::unique_lock lock(s_settings_mutex); + return s_layered_settings_interface.GetLayer(LayeredSettingsInterface::LAYER_BASE)->GetUIntValue(section, key, default_value); +} + +float Host::GetBaseFloatSettingValue(const char* section, const char* key, float default_value /*= 0.0f*/) +{ + std::unique_lock lock(s_settings_mutex); + return s_layered_settings_interface.GetLayer(LayeredSettingsInterface::LAYER_BASE)->GetFloatValue(section, key, default_value); +} + +double Host::GetBaseDoubleSettingValue(const char* section, const char* key, double default_value /* = 0.0f */) +{ + std::unique_lock lock(s_settings_mutex); + return s_layered_settings_interface.GetLayer(LayeredSettingsInterface::LAYER_BASE)->GetDoubleValue(section, key, default_value); +} + +std::vector Host::GetBaseStringListSetting(const char* section, const char* key) +{ + std::unique_lock lock(s_settings_mutex); + return s_layered_settings_interface.GetLayer(LayeredSettingsInterface::LAYER_BASE)->GetStringList(section, key); +} + +void Host::SetBaseBoolSettingValue(const char* section, const char* key, bool value) +{ + std::unique_lock lock(s_settings_mutex); + s_layered_settings_interface.GetLayer(LayeredSettingsInterface::LAYER_BASE)->SetBoolValue(section, key, value); +} + +void Host::SetBaseIntSettingValue(const char* section, const char* key, s32 value) +{ + std::unique_lock lock(s_settings_mutex); + s_layered_settings_interface.GetLayer(LayeredSettingsInterface::LAYER_BASE)->SetIntValue(section, key, value); +} + +void Host::SetBaseUIntSettingValue(const char* section, const char* key, u32 value) +{ + std::unique_lock lock(s_settings_mutex); + s_layered_settings_interface.GetLayer(LayeredSettingsInterface::LAYER_BASE)->SetUIntValue(section, key, value); +} + +void Host::SetBaseFloatSettingValue(const char* section, const char* key, float value) +{ + std::unique_lock lock(s_settings_mutex); + s_layered_settings_interface.GetLayer(LayeredSettingsInterface::LAYER_BASE)->SetFloatValue(section, key, value); +} + +void Host::SetBaseStringSettingValue(const char* section, const char* key, const char* value) +{ + std::unique_lock lock(s_settings_mutex); + s_layered_settings_interface.GetLayer(LayeredSettingsInterface::LAYER_BASE)->SetStringValue(section, key, value); +} + +void Host::SetBaseStringListSettingValue(const char* section, const char* key, const std::vector& values) +{ + std::unique_lock lock(s_settings_mutex); + s_layered_settings_interface.GetLayer(LayeredSettingsInterface::LAYER_BASE)->SetStringList(section, key, values); +} + +void Host::DeleteBaseSettingValue(const char* section, const char* key) +{ + std::unique_lock lock(s_settings_mutex); + s_layered_settings_interface.GetLayer(LayeredSettingsInterface::LAYER_BASE)->DeleteValue(section, key); +} + +void Host::CommitBaseSettingChanges() +{ + std::unique_lock lock(s_settings_mutex); + s_layered_settings_interface.GetLayer(LayeredSettingsInterface::LAYER_BASE)->Save(); +} + +std::string Host::GetStringSettingValue(const char* section, const char* key, const char* default_value /*= ""*/) +{ + std::unique_lock lock(s_settings_mutex); + return s_layered_settings_interface.GetStringValue(section, key, default_value); +} + +bool Host::GetBoolSettingValue(const char* section, const char* key, bool default_value /*= false*/) +{ + std::unique_lock lock(s_settings_mutex); + return s_layered_settings_interface.GetBoolValue(section, key, default_value); +} + +s32 Host::GetIntSettingValue(const char* section, const char* key, s32 default_value /*= 0*/) +{ + std::unique_lock lock(s_settings_mutex); + return s_layered_settings_interface.GetIntValue(section, key, default_value); +} + +u32 Host::GetUIntSettingValue(const char* section, const char* key, u32 default_value /*= 0*/) +{ + std::unique_lock lock(s_settings_mutex); + return s_layered_settings_interface.GetUIntValue(section, key, default_value); +} + +float Host::GetFloatSettingValue(const char* section, const char* key, float default_value /*= 0.0f*/) +{ + std::unique_lock lock(s_settings_mutex); + return s_layered_settings_interface.GetFloatValue(section, key, default_value); +} + +double Host::GetDoubleSettingValue(const char* section, const char* key, double default_value /*= 0.0f*/) +{ + std::unique_lock lock(s_settings_mutex); + return s_layered_settings_interface.GetDoubleValue(section, key, default_value); +} + +std::vector Host::GetStringListSetting(const char* section, const char* key) +{ + std::unique_lock lock(s_settings_mutex); + return s_layered_settings_interface.GetStringList(section, key); +} + +SettingsInterface* Host::Internal::GetBaseSettingsLayer() +{ + return s_layered_settings_interface.GetLayer(LayeredSettingsInterface::LAYER_BASE); +} + +SettingsInterface* Host::Internal::GetGameSettingsLayer() +{ + return s_layered_settings_interface.GetLayer(LayeredSettingsInterface::LAYER_GAME); +} + +SettingsInterface* Host::Internal::GetInputSettingsLayer() +{ + return s_layered_settings_interface.GetLayer(LayeredSettingsInterface::LAYER_INPUT); +} + +void Host::Internal::SetBaseSettingsLayer(SettingsInterface* sif) +{ + AssertMsg(s_layered_settings_interface.GetLayer(LayeredSettingsInterface::LAYER_BASE) == nullptr, "Base layer has not been set"); + s_layered_settings_interface.SetLayer(LayeredSettingsInterface::LAYER_BASE, sif); +} + +void Host::Internal::SetGameSettingsLayer(SettingsInterface* sif) +{ + std::unique_lock lock(s_settings_mutex); + s_layered_settings_interface.SetLayer(LayeredSettingsInterface::LAYER_GAME, sif); +} + +void Host::Internal::SetInputSettingsLayer(SettingsInterface* sif) +{ + std::unique_lock lock(s_settings_mutex); + s_layered_settings_interface.SetLayer(LayeredSettingsInterface::LAYER_INPUT, sif); +} + +void Host::Internal::UpdateEmuFolders() +{ +}