Xargon/Duckstation
1
0
Fork 0
mirror of https://github.com/RetroDECK/Duckstation.git synced 2025-02-18 20:05:39 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
Duckstation/src/frontend-common/common_host_interface.cpp
Connor McLaughlin a0086851ce Qt: Fix double-clicking psexes/psfs in game list
2021-03-16 01:59:17 +10:00

3394 lines
118 KiB
C++
Raw Blame History

#include "common_host_interface.h"
#include "common/assert.h"
#include "common/audio_stream.h"
#include "common/byte_stream.h"
#include "common/crash_handler.h"
#include "common/file_system.h"
#include "common/log.h"
#include "common/string_util.h"
#include "controller_interface.h"
#include "core/cdrom.h"
#include "core/cheats.h"
#include "core/cpu_code_cache.h"
#include "core/dma.h"
#include "core/gpu.h"
#include "core/host_display.h"
#include "core/mdec.h"
#include "core/pgxp.h"
#include "core/save_state_version.h"
#include "core/spu.h"
#include "core/system.h"
#include "core/texture_replacements.h"
#include "core/timers.h"
#include "cubeb_audio_stream.h"
#include "fullscreen_ui.h"
#include "game_list.h"
#include "icon.h"
#include "imgui.h"
#include "imgui_fullscreen.h"
#include "imgui_styles.h"
#include "ini_settings_interface.h"
#include "save_state_selector_ui.h"
#include "scmversion/scmversion.h"
#include <cmath>
#include <cstdio>
#include <cstring>
#include <ctime>
#ifdef WITH_SDL2
#include "sdl_audio_stream.h"
#endif
#ifdef WITH_DISCORD_PRESENCE
#include "discord_rpc.h"
#endif
#ifdef WITH_CHEEVOS
#include "cheevos.h"
#endif
#ifdef WIN32
#include "common/windows_headers.h"
#include <KnownFolders.h>
#include <ShlObj.h>
#include <mmsystem.h>
#endif
Log_SetChannel(CommonHostInterface);
static std::string s_settings_filename;
CommonHostInterface::CommonHostInterface() = default;
CommonHostInterface::~CommonHostInterface() = default;
bool CommonHostInterface::Initialize()
{
if (!HostInterface::Initialize())
return false;
InitializeUserDirectory();
// Change to the user directory so that all default/relative paths in the config are after this.
if (!FileSystem::SetWorkingDirectory(m_user_directory.c_str()))
Log_ErrorPrintf("Failed to set working directory to '%s'", m_user_directory.c_str());
// Set crash handler to dump to user directory, because of permissions.
CrashHandler::SetWriteDirectory(m_user_directory);
LoadSettings();
UpdateLogSettings(g_settings.log_level, g_settings.log_filter.empty() ? nullptr : g_settings.log_filter.c_str(),
g_settings.log_to_console, g_settings.log_to_debug, g_settings.log_to_window,
g_settings.log_to_file);
m_game_list = std::make_unique<GameList>();
m_game_list->SetCacheFilename(GetUserDirectoryRelativePath("cache/gamelist.cache"));
m_game_list->SetUserDatabaseFilename(GetUserDirectoryRelativePath("redump.dat"));
m_game_list->SetUserCompatibilityListFilename(GetUserDirectoryRelativePath("compatibility.xml"));
m_game_list->SetUserGameSettingsFilename(GetUserDirectoryRelativePath("gamesettings.ini"));
m_save_state_selector_ui = std::make_unique<FrontendCommon::SaveStateSelectorUI>(this);
RegisterHotkeys();
UpdateControllerInterface();
CreateImGuiContext();
#ifdef WITH_CHEEVOS
UpdateCheevosActive();
#endif
return true;
}
void CommonHostInterface::Shutdown()
{
HostInterface::Shutdown();
ImGui::DestroyContext();
#ifdef WITH_DISCORD_PRESENCE
ShutdownDiscordPresence();
#endif
#ifdef WITH_CHEEVOS
Cheevos::Shutdown();
#endif
if (m_controller_interface)
{
m_controller_interface->Shutdown();
m_controller_interface.reset();
}
}
void CommonHostInterface::InitializeUserDirectory()
{
std::fprintf(stdout, "User directory: \"%s\"\n", m_user_directory.c_str());
if (m_user_directory.empty())
Panic("Cannot continue without user directory set.");
if (!FileSystem::DirectoryExists(m_user_directory.c_str()))
{
std::fprintf(stderr, "User directory \"%s\" does not exist, creating.\n", m_user_directory.c_str());
if (!FileSystem::CreateDirectory(m_user_directory.c_str(), true))
std::fprintf(stderr, "Failed to create user directory \"%s\".\n", m_user_directory.c_str());
}
bool result = true;
result &= FileSystem::CreateDirectory(GetUserDirectoryRelativePath("bios").c_str(), false);
result &= FileSystem::CreateDirectory(GetUserDirectoryRelativePath("cache").c_str(), false);
result &= FileSystem::CreateDirectory(
GetUserDirectoryRelativePath("cache" FS_OSPATH_SEPARATOR_STR "achievement_badge").c_str(), false);
result &= FileSystem::CreateDirectory(
GetUserDirectoryRelativePath("cache" FS_OSPATH_SEPARATOR_STR "achievement_gameicon").c_str(), false);
result &= FileSystem::CreateDirectory(GetUserDirectoryRelativePath("cheats").c_str(), false);
result &= FileSystem::CreateDirectory(GetUserDirectoryRelativePath("covers").c_str(), false);
result &= FileSystem::CreateDirectory(GetUserDirectoryRelativePath("dump").c_str(), false);
result &=
FileSystem::CreateDirectory(GetUserDirectoryRelativePath("dump" FS_OSPATH_SEPARATOR_STR "audio").c_str(), false);
result &=
FileSystem::CreateDirectory(GetUserDirectoryRelativePath("dump" FS_OSPATH_SEPARATOR_STR "textures").c_str(), false);
result &= FileSystem::CreateDirectory(GetUserDirectoryRelativePath("inputprofiles").c_str(), false);
result &= FileSystem::CreateDirectory(GetUserDirectoryRelativePath("memcards").c_str(), false);
result &= FileSystem::CreateDirectory(GetUserDirectoryRelativePath("savestates").c_str(), false);
result &= FileSystem::CreateDirectory(GetUserDirectoryRelativePath("screenshots").c_str(), false);
result &= FileSystem::CreateDirectory(GetUserDirectoryRelativePath("shaders").c_str(), false);
result &= FileSystem::CreateDirectory(GetUserDirectoryRelativePath("textures").c_str(), false);
if (!result)
ReportError("Failed to create one or more user directories. This may cause issues at runtime.");
}
bool CommonHostInterface::BootSystem(const SystemBootParameters& parameters)
{
// If the fullscreen UI is enabled, make sure it's finished loading the game list so we don't race it.
if (m_display && m_fullscreen_ui_enabled)
FullscreenUI::EnsureGameListLoaded();
if (!HostInterface::BootSystem(parameters))
{
// if in batch mode, exit immediately if booting failed
if (InBatchMode())
RequestExit();
return false;
}
// enter fullscreen if requested in the parameters
if (!g_settings.start_paused && ((parameters.override_fullscreen.has_value() && *parameters.override_fullscreen) ||
(!parameters.override_fullscreen.has_value() && g_settings.start_fullscreen)))
{
SetFullscreen(true);
}
if (g_settings.audio_dump_on_boot)
StartDumpingAudio();
UpdateSpeedLimiterState();
return true;
}
void CommonHostInterface::DestroySystem()
{
SetTimerResolutionIncreased(false);
m_save_state_selector_ui->Close();
m_display->SetPostProcessingChain({});
HostInterface::DestroySystem();
}
void CommonHostInterface::PowerOffSystem(bool save_resume_state)
{
if (System::IsShutdown())
return;
if (save_resume_state)
SaveResumeSaveState();
DestroySystem();
if (InBatchMode())
RequestExit();
}
void CommonHostInterface::ResetSystem()
{
HostInterface::ResetSystem();
#ifdef WITH_CHEEVOS
Cheevos::Reset();
#endif
}
static void PrintCommandLineVersion(const char* frontend_name)
{
const bool was_console_enabled = Log::IsConsoleOutputEnabled();
if (!was_console_enabled)
Log::SetConsoleOutputParams(true);
std::fprintf(stderr, "%s Version %s (%s)\n", frontend_name, g_scm_tag_str, g_scm_branch_str);
std::fprintf(stderr, "https://github.com/stenzek/duckstation\n");
std::fprintf(stderr, "\n");
if (!was_console_enabled)
Log::SetConsoleOutputParams(false);
}
static void PrintCommandLineHelp(const char* progname, const char* frontend_name)
{
const bool was_console_enabled = Log::IsConsoleOutputEnabled();
if (!was_console_enabled)
Log::SetConsoleOutputParams(true);
PrintCommandLineVersion(frontend_name);
std::fprintf(stderr, "Usage: %s [parameters] [--] [boot filename]\n", progname);
std::fprintf(stderr, "\n");
std::fprintf(stderr, " -help: Displays this information and exits.\n");
std::fprintf(stderr, " -version: Displays version information and exits.\n");
std::fprintf(stderr, " -batch: Enables batch mode (exits after powering off).\n");
std::fprintf(stderr, " -fastboot: Force fast boot for provided filename.\n");
std::fprintf(stderr, " -slowboot: Force slow boot for provided filename.\n");
std::fprintf(stderr, " -resume: Load resume save state. If a boot filename is provided,\n"
" that game's resume state will be loaded, otherwise the most\n"
" recent resume save state will be loaded.\n");
std::fprintf(stderr, " -state <index>: Loads specified save state by index. If a boot\n"
" filename is provided, a per-game state will be loaded, otherwise\n"
" a global state will be loaded.\n");
std::fprintf(stderr, " -statefile <filename>: Loads state from the specified filename.\n"
" No boot filename is required with this option.\n");
std::fprintf(stderr, " -fullscreen: Enters fullscreen mode immediately after starting.\n");
std::fprintf(stderr, " -nofullscreen: Prevents fullscreen mode from triggering if enabled.\n");
std::fprintf(stderr, " -portable: Forces \"portable mode\", data in same directory.\n");
std::fprintf(stderr, " -nocontroller: Prevents the emulator from polling for controllers.\n"
" Try this option if you're having difficulties starting\n"
" the emulator.\n");
std::fprintf(stderr, " -settings <filename>: Loads a custom settings configuration from the\n"
" specified filename. Default settings applied if file not found.\n");
std::fprintf(stderr, " --: Signals that no more arguments will follow and the remaining\n"
" parameters make up the filename. Use when the filename contains\n"
" spaces or starts with a dash.\n");
std::fprintf(stderr, "\n");
if (!was_console_enabled)
Log::SetConsoleOutputParams(false);
}
bool CommonHostInterface::ParseCommandLineParameters(int argc, char* argv[],
std::unique_ptr<SystemBootParameters>* out_boot_params)
{
std::optional<bool> force_fast_boot;
std::optional<bool> force_fullscreen;
std::optional<s32> state_index;
std::string state_filename;
std::string boot_filename;
bool no_more_args = false;
for (int i = 1; i < argc; i++)
{
if (!no_more_args)
{
#define CHECK_ARG(str) !std::strcmp(argv[i], str)
#define CHECK_ARG_PARAM(str) (!std::strcmp(argv[i], str) && ((i + 1) < argc))
if (CHECK_ARG("-help"))
{
PrintCommandLineHelp(argv[0], GetFrontendName());
return false;
}
else if (CHECK_ARG("-version"))
{
PrintCommandLineVersion(GetFrontendName());
return false;
}
else if (CHECK_ARG("-batch"))
{
Log_InfoPrintf("Enabling batch mode.");
m_flags.batch_mode = true;
continue;
}
else if (CHECK_ARG("-fastboot"))
{
Log_InfoPrintf("Forcing fast boot.");
force_fast_boot = true;
continue;
}
else if (CHECK_ARG("-slowboot"))
{
Log_InfoPrintf("Forcing slow boot.");
force_fast_boot = false;
continue;
}
else if (CHECK_ARG("-nocontroller"))
{
Log_InfoPrintf("Disabling controller support.");
m_flags.disable_controller_interface = true;
continue;
}
else if (CHECK_ARG("-resume"))
{
state_index = -1;
continue;
}
else if (CHECK_ARG_PARAM("-state"))
{
state_index = std::atoi(argv[++i]);
continue;
}
else if (CHECK_ARG_PARAM("-statefile"))
{
state_filename = argv[++i];
continue;
}
else if (CHECK_ARG("-fullscreen"))
{
Log_InfoPrintf("Going fullscreen after booting.");
m_flags.start_fullscreen = true;
force_fullscreen = true;
continue;
}
else if (CHECK_ARG("-nofullscreen"))
{
Log_InfoPrintf("Preventing fullscreen after booting.");
force_fullscreen = false;
continue;
}
else if (CHECK_ARG("-portable"))
{
Log_InfoPrintf("Using portable mode.");
SetUserDirectoryToProgramDirectory();
continue;
}
else if (CHECK_ARG_PARAM("-resume"))
{
state_index = -1;
continue;
}
else if (CHECK_ARG_PARAM("-settings"))
{
s_settings_filename = argv[++i];
continue;
}
else if (CHECK_ARG("--"))
{
no_more_args = true;
continue;
}
else if (argv[i][0] == '-')
{
Log_ErrorPrintf("Unknown parameter: '%s'", argv[i]);
return false;
}
#undef CHECK_ARG
#undef CHECK_ARG_PARAM
}
if (!boot_filename.empty())
boot_filename += ' ';
boot_filename += argv[i];
}
if (state_index.has_value() || !boot_filename.empty() || !state_filename.empty())
{
// init user directory early since we need it for save states
SetUserDirectory();
if (state_index.has_value() && state_filename.empty())
{
// if a save state is provided, whether a boot filename was provided determines per-game/local
if (boot_filename.empty())
{
// loading a global state. if this is -1, we're loading the most recent resume state
if (*state_index < 0)
state_filename = GetMostRecentResumeSaveStatePath();
else
state_filename = GetGlobalSaveStateFileName(*state_index);
if (state_filename.empty() || !FileSystem::FileExists(state_filename.c_str()))
{
Log_ErrorPrintf("Could not find file for global save state %d", *state_index);
return false;
}
}
else
{
// find the game id, and get its save state path
std::string game_code = System::GetGameCodeForPath(boot_filename.c_str(), true);
if (game_code.empty())
{
Log_WarningPrintf("Could not identify game code for '%s', cannot load save state %d.", boot_filename.c_str(),
*state_index);
}
else
{
state_filename = GetGameSaveStateFileName(game_code.c_str(), *state_index);
if (state_filename.empty() || !FileSystem::FileExists(state_filename.c_str()))
{
if (state_index >= 0) // Do not exit if -resume is specified, but resume save state does not exist
{
Log_ErrorPrintf("Could not find file for game '%s' save state %d", game_code.c_str(), *state_index);
return false;
}
else
{
state_filename.clear();
}
}
}
}
}
std::unique_ptr<SystemBootParameters> boot_params = std::make_unique<SystemBootParameters>();
boot_params->filename = std::move(boot_filename);
boot_params->override_fast_boot = std::move(force_fast_boot);
boot_params->override_fullscreen = std::move(force_fullscreen);
if (!state_filename.empty())
{
std::unique_ptr<ByteStream> state_stream =
FileSystem::OpenFile(state_filename.c_str(), BYTESTREAM_OPEN_READ | BYTESTREAM_OPEN_STREAMED);
if (!state_stream)
{
Log_ErrorPrintf("Failed to open save state file '%s'", state_filename.c_str());
return false;
}
boot_params->state_stream = std::move(state_stream);
}
*out_boot_params = std::move(boot_params);
}
return true;
}
void CommonHostInterface::OnAchievementsRefreshed()
{
#ifdef WITH_CHEEVOS
// noop
#endif
}
void CommonHostInterface::PollAndUpdate()
{
if (m_controller_interface)
m_controller_interface->PollEvents();
if (m_fullscreen_ui_enabled)
FullscreenUI::SetImGuiNavInputs();
#ifdef WITH_DISCORD_PRESENCE
PollDiscordPresence();
#endif
#ifdef WITH_CHEEVOS
if (Cheevos::IsActive())
Cheevos::Update();
#endif
}
bool CommonHostInterface::IsFullscreen() const
{
return false;
}
bool CommonHostInterface::SetFullscreen(bool enabled)
{
return false;
}
void CommonHostInterface::CreateImGuiContext()
{
ImGui::CreateContext();
ImGui::GetIO().IniFilename = nullptr;
#ifndef __ANDROID__
// Android has no keyboard, nor are we using ImGui for any actual user-interactable windows.
ImGui::GetIO().ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard | ImGuiConfigFlags_NavEnableGamepad;
#endif
}
bool CommonHostInterface::CreateHostDisplayResources()
{
m_logo_texture = m_display->CreateTexture(APP_ICON_WIDTH, APP_ICON_HEIGHT, 1, 1, 1, HostDisplayPixelFormat::RGBA8,
APP_ICON_DATA, sizeof(u32) * APP_ICON_WIDTH, false);
if (!m_logo_texture)
Log_WarningPrintf("Failed to create logo texture");
const float framebuffer_scale = m_display->GetWindowScale();
ImGui::GetIO().DisplayFramebufferScale = ImVec2(framebuffer_scale, framebuffer_scale);
ImGui::GetStyle() = ImGuiStyle();
ImGui::StyleColorsDarker();
ImGui::GetStyle().ScaleAllSizes(framebuffer_scale);
if (!m_display->CreateImGuiContext())
{
Log_ErrorPrintf("Failed to create ImGui device context");
return false;
}
if (m_fullscreen_ui_enabled)
{
if (!FullscreenUI::Initialize(this))
{
Log_ErrorPrintf("Failed to initialize fullscreen UI, disabling.");
m_fullscreen_ui_enabled = false;
}
}
if (!m_fullscreen_ui_enabled)
ImGuiFullscreen::ResetFonts();
if (!m_display->UpdateImGuiFontTexture())
{
Log_ErrorPrintf("Failed to create ImGui font text");
if (m_fullscreen_ui_enabled)
FullscreenUI::Shutdown();
m_display->DestroyImGuiContext();
return false;
}
return true;
}
void CommonHostInterface::ReleaseHostDisplayResources()
{
if (m_fullscreen_ui_enabled)
FullscreenUI::Shutdown();
if (m_display)
m_display->DestroyImGuiContext();
m_logo_texture.reset();
}
void CommonHostInterface::OnHostDisplayResized(u32 new_width, u32 new_height, float new_scale)
{
if (new_scale != ImGui::GetIO().DisplayFramebufferScale.x)
{
ImGui::GetIO().DisplayFramebufferScale = ImVec2(new_scale, new_scale);
ImGui::GetStyle() = ImGuiStyle();
ImGui::StyleColorsDarker();
ImGui::GetStyle().ScaleAllSizes(new_scale);
ImGuiFullscreen::ResetFonts();
if (!m_display->UpdateImGuiFontTexture())
Panic("Failed to recreate font texture after resize");
}
if (m_fullscreen_ui_enabled)
{
if (ImGuiFullscreen::UpdateLayoutScale())
{
if (ImGuiFullscreen::UpdateFonts())
{
if (!m_display->UpdateImGuiFontTexture())
Panic("Failed to update font texture");
}
}
}
if (!System::IsShutdown())
g_gpu->UpdateResolutionScale();
}
std::unique_ptr<AudioStream> CommonHostInterface::CreateAudioStream(AudioBackend backend)
{
switch (backend)
{
case AudioBackend::Null:
return AudioStream::CreateNullAudioStream();
case AudioBackend::Cubeb:
return CubebAudioStream::Create();
#ifdef WITH_SDL2
case AudioBackend::SDL:
return SDLAudioStream::Create();
#endif
default:
return nullptr;
}
}
s32 CommonHostInterface::GetAudioOutputVolume() const
{
return g_settings.GetAudioOutputVolume(IsRunningAtNonStandardSpeed());
}
void CommonHostInterface::UpdateControllerInterface()
{
const std::string backend_str = GetStringSettingValue(
"Main", "ControllerBackend", ControllerInterface::GetBackendName(ControllerInterface::GetDefaultBackend()));
const std::optional<ControllerInterface::Backend> new_backend =
ControllerInterface::ParseBackendName(backend_str.c_str());
const ControllerInterface::Backend current_backend =
(m_controller_interface ? m_controller_interface->GetBackend() : ControllerInterface::Backend::None);
if (new_backend == current_backend || m_flags.disable_controller_interface)
return;
if (m_controller_interface)
{
ClearInputMap();
m_controller_interface->Shutdown();
m_controller_interface.reset();
}
if (!new_backend.has_value())
{
Log_ErrorPrintf("Invalid controller interface type: '%s'", backend_str.c_str());
return;
}
if (new_backend == ControllerInterface::Backend::None)
{
Log_WarningPrintf("No controller interface created, controller bindings are not possible.");
return;
}
m_controller_interface = ControllerInterface::Create(new_backend.value());
if (!m_controller_interface || !m_controller_interface->Initialize(this))
{
Log_WarningPrintf("Failed to initialize controller interface, bindings are not possible.");
if (m_controller_interface)
{
m_controller_interface->Shutdown();
m_controller_interface.reset();
}
}
}
bool CommonHostInterface::LoadState(const char* filename)
{
const bool system_was_valid = System::IsValid();
const bool result = HostInterface::LoadState(filename);
if (system_was_valid || !result)
{
#ifdef WITH_CHEEVOS
Cheevos::Reset();
#endif
}
return result;
}
bool CommonHostInterface::LoadState(bool global, s32 slot)
{
if (!global && (System::IsShutdown() || System::GetRunningCode().empty()))
{
ReportFormattedError("Can't save per-game state without a running game code.");
return false;
}
std::string save_path =
global ? GetGlobalSaveStateFileName(slot) : GetGameSaveStateFileName(System::GetRunningCode().c_str(), slot);
return LoadState(save_path.c_str());
}
bool CommonHostInterface::SaveState(bool global, s32 slot)
{
const std::string& code = System::GetRunningCode();
if (!global && code.empty())
{
ReportFormattedError("Can't save per-game state without a running game code.");
return false;
}
std::string save_path = global ? GetGlobalSaveStateFileName(slot) : GetGameSaveStateFileName(code.c_str(), slot);
if (!SaveState(save_path.c_str()))
return false;
OnSystemStateSaved(global, slot);
return true;
}
bool CommonHostInterface::CanResumeSystemFromFile(const char* filename)
{
if (GetBoolSettingValue("Main", "SaveStateOnExit", true) && !IsCheevosChallengeModeActive())
{
const GameListEntry* entry = m_game_list->GetEntryForPath(filename);
if (entry)
return !entry->code.empty();
else
return !System::GetGameCodeForPath(filename, true).empty();
}
return false;
}
bool CommonHostInterface::ResumeSystemFromState(const char* filename, bool boot_on_failure)
{
SystemBootParameters boot_params;
boot_params.filename = filename;
if (!BootSystem(boot_params))
return false;
const bool global = System::GetRunningCode().empty();
if (global)
{
ReportFormattedError("Cannot resume system with undetectable game code from '%s'.", filename);
if (!boot_on_failure)
{
DestroySystem();
return true;
}
}
else
{
const std::string path = GetGameSaveStateFileName(System::GetRunningCode().c_str(), -1);
if (FileSystem::FileExists(path.c_str()))
{
if (!LoadState(path.c_str()) && !boot_on_failure)
{
DestroySystem();
return false;
}
}
else if (!boot_on_failure)
{
ReportFormattedError("Resume save state not found for '%s' ('%s').", System::GetRunningCode().c_str(),
System::GetRunningTitle().c_str());
DestroySystem();
return false;
}
}
return true;
}
bool CommonHostInterface::ResumeSystemFromMostRecentState()
{
const std::string path = GetMostRecentResumeSaveStatePath();
if (path.empty())
{
ReportError("No resume save state found.");
return false;
}
return LoadState(path.c_str());
}
bool CommonHostInterface::ShouldSaveResumeState() const
{
return g_settings.save_state_on_exit;
}
bool CommonHostInterface::IsRunningAtNonStandardSpeed() const
{
if (!System::IsValid())
return false;
const float target_speed = System::GetTargetSpeed();
return (target_speed <= 0.95f || target_speed >= 1.05f);
}
void CommonHostInterface::UpdateSpeedLimiterState()
{
float target_speed = m_turbo_enabled ?
g_settings.turbo_speed :
(m_fast_forward_enabled ? g_settings.fast_forward_speed : g_settings.emulation_speed);
m_throttler_enabled = (target_speed != 0.0f);
m_display_all_frames = !m_throttler_enabled || g_settings.display_all_frames;
bool syncing_to_host = false;
if (g_settings.sync_to_host_refresh_rate && g_settings.audio_resampling && target_speed == 1.0f && m_display &&
System::IsRunning())
{
float host_refresh_rate;
if (m_display->GetHostRefreshRate(&host_refresh_rate))
{
const float ratio = host_refresh_rate / System::GetThrottleFrequency();
syncing_to_host = (ratio >= 0.95f && ratio <= 1.05f);
Log_InfoPrintf("Refresh rate: Host=%fhz Guest=%fhz Ratio=%f - %s", host_refresh_rate,
System::GetThrottleFrequency(), ratio, syncing_to_host ? "can sync" : "can't sync");
if (syncing_to_host)
target_speed *= ratio;
}
}
const bool is_non_standard_speed = (std::abs(target_speed - 1.0f) > 0.05f);
const bool audio_sync_enabled =
!System::IsRunning() || (m_throttler_enabled && g_settings.audio_sync_enabled && !is_non_standard_speed);
const bool video_sync_enabled =
!System::IsRunning() || (m_throttler_enabled && g_settings.video_sync_enabled && !is_non_standard_speed);
const float max_display_fps = (!System::IsValid() || m_throttler_enabled) ? 0.0f : g_settings.display_max_fps;
Log_InfoPrintf("Target speed: %f%%", target_speed * 100.0f);
Log_InfoPrintf("Syncing to %s%s", audio_sync_enabled ? "audio" : "",
(audio_sync_enabled && video_sync_enabled) ? " and video" : (video_sync_enabled ? "video" : ""));
Log_InfoPrintf("Max display fps: %f (%s)", max_display_fps,
m_display_all_frames ? "displaying all frames" : "skipping displaying frames when needed");
if (System::IsValid())
{
System::SetTargetSpeed(target_speed);
System::ResetPerformanceCounters();
}
if (m_audio_stream)
{
const u32 input_sample_rate = (target_speed == 0.0f || !g_settings.audio_resampling) ?
AUDIO_SAMPLE_RATE :
static_cast<u32>(static_cast<float>(AUDIO_SAMPLE_RATE) * target_speed);
Log_InfoPrintf("Audio input sample rate: %u hz", input_sample_rate);
m_audio_stream->SetInputSampleRate(input_sample_rate);
m_audio_stream->SetWaitForBufferFill(!m_display_all_frames);
m_audio_stream->SetOutputVolume(GetAudioOutputVolume());
m_audio_stream->SetSync(audio_sync_enabled);
if (audio_sync_enabled)
m_audio_stream->EmptyBuffers();
}
if (m_display)
{
m_display->SetDisplayMaxFPS(max_display_fps);
m_display->SetVSync(video_sync_enabled);
}
if (g_settings.increase_timer_resolution)
SetTimerResolutionIncreased(m_throttler_enabled);
// When syncing to host and using vsync, we don't need to sleep.
if (syncing_to_host && video_sync_enabled && m_display_all_frames)
{
Log_InfoPrintf("Using host vsync for throttling.");
m_throttler_enabled = false;
}
}
void CommonHostInterface::RecreateSystem()
{
const bool was_paused = System::IsPaused();
HostInterface::RecreateSystem();
if (was_paused)
PauseSystem(true);
}
void CommonHostInterface::UpdateLogSettings(LOGLEVEL level, const char* filter, bool log_to_console, bool log_to_debug,
bool log_to_window, bool log_to_file)
{
Log::SetFilterLevel(level);
Log::SetConsoleOutputParams(g_settings.log_to_console, filter, level);
Log::SetDebugOutputParams(g_settings.log_to_debug, filter, level);
if (log_to_file)
{
Log::SetFileOutputParams(g_settings.log_to_file, GetUserDirectoryRelativePath("duckstation.log").c_str(), true,
filter, level);
}
else
{
Log::SetFileOutputParams(false, nullptr);
}
}
void CommonHostInterface::SetUserDirectory()
{
if (!m_user_directory.empty())
return;
std::fprintf(stdout, "Program directory \"%s\"\n", m_program_directory.c_str());
if (FileSystem::FileExists(
StringUtil::StdStringFromFormat("%s" FS_OSPATH_SEPARATOR_STR "%s", m_program_directory.c_str(), "portable.txt")
.c_str()) ||
FileSystem::FileExists(
StringUtil::StdStringFromFormat("%s" FS_OSPATH_SEPARATOR_STR "%s", m_program_directory.c_str(), "settings.ini")
.c_str()))
{
std::fprintf(stdout, "portable.txt or old settings.ini found, using program directory as user directory.\n");
m_user_directory = m_program_directory;
}
else
{
#if defined(WIN32)
// On Windows, use My Documents\DuckStation.
PWSTR documents_directory;
if (SUCCEEDED(SHGetKnownFolderPath(FOLDERID_Documents, 0, NULL, &documents_directory)))
{
const std::string documents_directory_str(StringUtil::WideStringToUTF8String(documents_directory));
if (!documents_directory_str.empty())
{
m_user_directory = StringUtil::StdStringFromFormat("%s" FS_OSPATH_SEPARATOR_STR "%s",
documents_directory_str.c_str(), "DuckStation");
}
CoTaskMemFree(documents_directory);
}
#elif defined(__linux__) || defined(__FreeBSD__)
// On Linux, use .local/share/duckstation as a user directory by default.
const char* xdg_data_home = getenv("XDG_DATA_HOME");
if (xdg_data_home && xdg_data_home[0] == '/')
{
m_user_directory = StringUtil::StdStringFromFormat("%s/duckstation", xdg_data_home);
}
else
{
const char* home_path = getenv("HOME");
if (home_path)
m_user_directory = StringUtil::StdStringFromFormat("%s/.local/share/duckstation", home_path);
}
#elif defined(__APPLE__)
// On macOS, default to ~/Library/Application Support/DuckStation.
const char* home_path = getenv("HOME");
if (home_path)
m_user_directory = StringUtil::StdStringFromFormat("%s/Library/Application Support/DuckStation", home_path);
#endif
if (m_user_directory.empty())
{
std::fprintf(stderr, "User directory path could not be determined, falling back to program directory.");
m_user_directory = m_program_directory;
}
}
}
void CommonHostInterface::OnSystemCreated()
{
HostInterface::OnSystemCreated();
if (m_fullscreen_ui_enabled)
FullscreenUI::SystemCreated();
if (g_settings.display_post_processing && !m_display->SetPostProcessingChain(g_settings.display_post_process_chain))
AddOSDMessage(TranslateStdString("OSDMessage", "Failed to load post processing shader chain."), 20.0f);
}
void CommonHostInterface::OnSystemPaused(bool paused)
{
ReportFormattedMessage("System %s.", paused ? "paused" : "resumed");
if (m_fullscreen_ui_enabled)
FullscreenUI::SystemPaused(paused);
if (paused)
{
if (IsFullscreen() && !m_fullscreen_ui_enabled)
SetFullscreen(false);
StopControllerRumble();
}
UpdateSpeedLimiterState();
}
void CommonHostInterface::OnSystemDestroyed()
{
// Restore present-all-frames behavior.
if (m_display)
m_display->SetDisplayMaxFPS(0.0f);
HostInterface::OnSystemDestroyed();
if (m_fullscreen_ui_enabled)
FullscreenUI::SystemDestroyed();
StopControllerRumble();
}
void CommonHostInterface::OnRunningGameChanged(const std::string& path, CDImage* image, const std::string& game_code,
const std::string& game_title)
{
HostInterface::OnRunningGameChanged(path, image, game_code, game_title);
if (g_settings.apply_game_settings)
ApplySettings(true);
if (!System::IsShutdown())
{
System::SetCheatList(nullptr);
if (g_settings.auto_load_cheats)
{
DebugAssert(!IsCheevosChallengeModeActive());
LoadCheatListFromGameTitle();
}
}
#ifdef WITH_DISCORD_PRESENCE
UpdateDiscordPresence();
#endif
#ifdef WITH_CHEEVOS
if (Cheevos::IsLoggedIn())
Cheevos::GameChanged(path, image);
#endif
}
void CommonHostInterface::OnControllerTypeChanged(u32 slot)
{
HostInterface::OnControllerTypeChanged(slot);
UpdateInputMap();
}
void CommonHostInterface::DrawImGuiWindows()
{
if (m_save_state_selector_ui->IsOpen())
m_save_state_selector_ui->Draw();
if (m_fullscreen_ui_enabled)
{
FullscreenUI::Render();
return;
}
if (System::IsValid())
{
if (!IsCheevosChallengeModeActive())
DrawDebugWindows();
DrawFPSWindow();
}
DrawOSDMessages();
}
void CommonHostInterface::DrawFPSWindow()
{
if (!(g_settings.display_show_fps | g_settings.display_show_vps | g_settings.display_show_speed |
g_settings.display_show_resolution))
{
return;
}
const float scale = ImGui::GetIO().DisplayFramebufferScale.x;
const float shadow_offset = 1.0f * scale;
float margin = 10.0f * scale;
float spacing = 5.0f * scale;
float position_y = margin;
ImDrawList* dl = ImGui::GetBackgroundDrawList();
ImFont* font = ImGui::GetFont();
TinyString text;
ImVec2 text_size;
bool first = true;
#define DRAW_LINE(color) \
do \
{ \
text_size = font->CalcTextSizeA(font->FontSize, std::numeric_limits<float>::max(), -1.0f, text, \
text.GetCharArray() + text.GetLength(), nullptr); \
dl->AddText( \
font, font->FontSize, \
ImVec2(ImGui::GetIO().DisplaySize.x - margin - text_size.x + shadow_offset, position_y + shadow_offset), \
IM_COL32(0, 0, 0, 100), text, text.GetCharArray() + text.GetLength()); \
dl->AddText(font, font->FontSize, ImVec2(ImGui::GetIO().DisplaySize.x - margin - text_size.x, position_y), color, \
text, text.GetCharArray() + text.GetLength()); \
position_y += text_size.y + spacing; \
} while (0)
const System::State state = System::GetState();
if (System::GetState() == System::State::Running)
{
const float speed = System::GetEmulationSpeed();
if (g_settings.display_show_fps)
{
text.AppendFormattedString("%.2f", System::GetFPS());
first = false;
}
if (g_settings.display_show_vps)
{
text.AppendFormattedString("%s%.2f", first ? "" : " / ", System::GetVPS());
first = false;
}
if (g_settings.display_show_speed)
{
text.AppendFormattedString("%s%u%%", first ? "" : " / ", static_cast<u32>(std::round(speed)));
first = false;
}
if (!text.IsEmpty())
{
ImU32 color;
if (speed < 95.0f)
color = IM_COL32(255, 100, 100, 255);
else if (speed > 105.0f)
color = IM_COL32(100, 255, 100, 255);
else
color = IM_COL32(255, 255, 255, 255);
DRAW_LINE(color);
}
if (g_settings.display_show_resolution)
{
const auto [effective_width, effective_height] = g_gpu->GetEffectiveDisplayResolution();
const bool interlaced = g_gpu->IsInterlacedDisplayEnabled();
text.Format("%ux%u (%s)", effective_width, effective_height, interlaced ? "interlaced" : "progressive");
DRAW_LINE(IM_COL32(255, 255, 255, 255));
}
}
#undef DRAW_LINE
}
void CommonHostInterface::AddOSDMessage(std::string message, float duration /*= 2.0f*/)
{
OSDMessage msg;
msg.text = std::move(message);
msg.duration = duration;
std::unique_lock<std::mutex> lock(m_osd_messages_lock);
m_osd_posted_messages.push_back(std::move(msg));
}
void CommonHostInterface::ClearOSDMessages()
{
std::unique_lock<std::mutex> lock(m_osd_messages_lock);
m_osd_posted_messages.clear();
}
bool CommonHostInterface::EnumerateOSDMessages(std::function<bool(const std::string&, float)> callback)
{
auto iter = m_osd_active_messages.begin();
while (iter != m_osd_active_messages.end())
{
const OSDMessage& msg = *iter;
const double time = msg.time.GetTimeSeconds();
const float time_remaining = static_cast<float>(msg.duration - time);
if (time_remaining <= 0.0f)
{
iter = m_osd_active_messages.erase(iter);
continue;
}
if (callback && !callback(iter->text, time_remaining))
return false;
++iter;
}
return true;
}
void CommonHostInterface::AcquirePendingOSDMessages()
{
// memory_order_consume is roughly equivalent to adding a volatile keyword to the read from the deque.
// we just want to force the compiler to always reload the deque size value from memory.
//
// ARM doesn't have good atomic read guarantees so it _could_ read some non-zero value here spuriously,
// but that's OK because we lock the mutex later and recheck things anyway. This early out will still
// avoid 99.99% of the unnecessary lock attempts when size == 0.
std::atomic_thread_fence(std::memory_order_consume);
if (!m_osd_posted_messages.empty())
{
std::unique_lock<std::mutex> lock(m_osd_messages_lock);
for (;;)
{
// lock-and-copy mechanism.
// this allows us to unlock the deque and minimize time that the mutex is held.
// it is almost always the best model to follow for multithread deque.
if (m_osd_posted_messages.empty())
break;
if (g_settings.display_show_osd_messages)
m_osd_active_messages.push_back(std::move(m_osd_posted_messages.front()));
m_osd_posted_messages.pop_front();
// somewhat arbitrary hard cap on # of messages. This might be unnecessarily paranoid. If something is
// spamming the osd message log this badly, then probably this isn't going to really help things much.
static constexpr size_t MAX_ACTIVE_OSD_MESSAGES = 512;
if (m_osd_active_messages.size() > MAX_ACTIVE_OSD_MESSAGES)
m_osd_active_messages.pop_front();
}
}
}
void CommonHostInterface::DrawOSDMessages()
{
AcquirePendingOSDMessages();
constexpr ImGuiWindowFlags window_flags = ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoInputs |
ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoSavedSettings |
ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoNav |
ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoFocusOnAppearing;
const float scale = ImGui::GetIO().DisplayFramebufferScale.x;
const float spacing = 5.0f * scale;
const float margin = 10.0f * scale;
const float padding = 8.0f * scale;
const float rounding = 5.0f * scale;
const float max_width = ImGui::GetIO().DisplaySize.x - margin;
float position_x = margin;
float position_y = margin;
EnumerateOSDMessages([max_width, spacing, padding, rounding, &position_x, &position_y](const std::string& message,
float time_remaining) -> bool {
const float opacity = std::min(time_remaining, 1.0f);
const u32 alpha = static_cast<u32>(opacity * 255.0f);
if (position_y >= ImGui::GetIO().DisplaySize.y)
return false;
const ImVec2 pos(position_x, position_y);
const ImVec2 text_size(ImGui::CalcTextSize(message.c_str(), nullptr, false, max_width));
const ImVec2 size(text_size.x + padding * 2.0f, text_size.y + padding * 2.0f);
const ImVec4 text_rect(pos.x + padding, pos.y + padding, pos.x + size.x - padding, pos.y + size.y - padding);
ImDrawList* dl = ImGui::GetBackgroundDrawList();
ImFont* font = ImGui::GetFont();
dl->AddRectFilled(pos, ImVec2(pos.x + size.x, pos.y + size.y), IM_COL32(0x21, 0x21, 0x21, alpha), rounding);
dl->AddRect(pos, ImVec2(pos.x + size.x, pos.y + size.y), IM_COL32(0x48, 0x48, 0x48, alpha), rounding);
dl->AddText(font, font->FontSize, ImVec2(text_rect.x, text_rect.y), IM_COL32(0xff, 0xff, 0xff, alpha),
message.c_str(), nullptr, max_width, &text_rect);
position_y += size.y + spacing;
return true;
});
}
void CommonHostInterface::DrawDebugWindows()
{
if (g_settings.debugging.show_gpu_state)
g_gpu->DrawDebugStateWindow();
if (g_settings.debugging.show_cdrom_state)
g_cdrom.DrawDebugWindow();
if (g_settings.debugging.show_timers_state)
g_timers.DrawDebugStateWindow();
if (g_settings.debugging.show_spu_state)
g_spu.DrawDebugStateWindow();
if (g_settings.debugging.show_mdec_state)
g_mdec.DrawDebugStateWindow();
if (g_settings.debugging.show_dma_state)
g_dma.DrawDebugStateWindow();
}
bool CommonHostInterface::IsCheevosChallengeModeActive() const
{
#ifdef WITH_CHEEVOS
return Cheevos::IsChallengeModeActive();
#else
return false;
#endif
}
void CommonHostInterface::DoFrameStep()
{
if (System::IsShutdown())
return;
m_frame_step_request = true;
PauseSystem(false);
}
void CommonHostInterface::DoToggleCheats()
{
if (System::IsShutdown())
return;
CheatList* cl = System::GetCheatList();
if (!cl)
{
AddOSDMessage(TranslateStdString("OSDMessage", "No cheats are loaded."), 10.0f);
return;
}
cl->SetMasterEnable(!cl->GetMasterEnable());
AddOSDMessage(cl->GetMasterEnable() ?
TranslateStdString("OSDMessage", "%n cheats are now active.", "", cl->GetEnabledCodeCount()) :
TranslateStdString("OSDMessage", "%n cheats are now inactive.", "", cl->GetEnabledCodeCount()),
10.0f);
}
std::optional<CommonHostInterface::HostKeyCode>
CommonHostInterface::GetHostKeyCode(const std::string_view key_code) const
{
return std::nullopt;
}
void CommonHostInterface::RegisterHotkey(String category, String name, String display_name, InputButtonHandler handler)
{
m_hotkeys.push_back(HotkeyInfo{std::move(category), std::move(name), std::move(display_name), std::move(handler)});
}
bool CommonHostInterface::HandleHostKeyEvent(HostKeyCode code, HostKeyCode modifiers, bool pressed)
{
auto iter = m_keyboard_input_handlers.find(code | modifiers);
if (iter == m_keyboard_input_handlers.end())
{
// try without the modifier
if (modifiers == 0 || (iter = m_keyboard_input_handlers.find(code)) == m_keyboard_input_handlers.end())
return false;
}
iter->second(pressed);
return true;
}
bool CommonHostInterface::HandleHostMouseEvent(HostMouseButton button, bool pressed)
{
const auto iter = m_mouse_input_handlers.find(button);
if (iter == m_mouse_input_handlers.end())
return false;
iter->second(pressed);
return true;
}
void CommonHostInterface::UpdateInputMap(SettingsInterface& si)
{
ClearInputMap();
if (!UpdateControllerInputMapFromGameSettings())
UpdateControllerInputMap(si);
UpdateHotkeyInputMap(si);
}
void CommonHostInterface::ClearInputMap()
{
m_keyboard_input_handlers.clear();
m_mouse_input_handlers.clear();
m_controller_vibration_motors.clear();
if (m_controller_interface)
m_controller_interface->ClearBindings();
}
void CommonHostInterface::AddControllerRumble(u32 controller_index, u32 num_motors, ControllerRumbleCallback callback)
{
ControllerRumbleState rumble;
rumble.controller_index = 0;
rumble.num_motors = std::min<u32>(num_motors, ControllerRumbleState::MAX_MOTORS);
rumble.last_strength.fill(0.0f);
rumble.update_callback = std::move(callback);
rumble.last_update_time = Common::Timer::GetValue();
m_controller_vibration_motors.push_back(std::move(rumble));
}
void CommonHostInterface::UpdateControllerRumble()
{
if (m_controller_vibration_motors.empty())
return;
// Rumble update frequency in milliseconds.
// We won't send an update to the controller unless this amount of time has passed, if the value has not changed.
// This is because the rumble update is synchronous, and with bluetooth latency can severely impact fast forward
// performance.
static constexpr float UPDATE_FREQUENCY = 1000.0f;
const u64 time = Common::Timer::GetValue();
for (ControllerRumbleState& rumble : m_controller_vibration_motors)
{
Controller* controller = System::GetController(rumble.controller_index);
if (!controller)
continue;
bool changed = false;
for (u32 i = 0; i < rumble.num_motors; i++)
{
const float strength = controller->GetVibrationMotorStrength(i);
if (rumble.last_strength[i] != strength)
{
rumble.last_strength[i] = strength;
changed = true;
}
}
if (changed || Common::Timer::ConvertValueToMilliseconds(time - rumble.last_update_time) >= UPDATE_FREQUENCY)
{
rumble.last_update_time = time;
rumble.update_callback(rumble.last_strength.data(), rumble.num_motors);
}
}
}
void CommonHostInterface::StopControllerRumble()
{
for (ControllerRumbleState& rumble : m_controller_vibration_motors)
{
for (u32 i = 0; i < rumble.num_motors; i++)
rumble.last_strength[i] = 0.0f;
rumble.update_callback(rumble.last_strength.data(), rumble.num_motors);
}
}
static bool SplitBinding(const std::string& binding, std::string_view* device, std::string_view* sub_binding)
{
const std::string::size_type slash_pos = binding.find('/');
if (slash_pos == std::string::npos)
{
Log_WarningPrintf("Malformed binding: '%s'", binding.c_str());
return false;
}
*device = std::string_view(binding).substr(0, slash_pos);
*sub_binding = std::string_view(binding).substr(slash_pos + 1);
return true;
}
void CommonHostInterface::UpdateControllerInputMap(SettingsInterface& si)
{
StopControllerRumble();
m_controller_vibration_motors.clear();
for (u32 controller_index = 0; controller_index < NUM_CONTROLLER_AND_CARD_PORTS; controller_index++)
{
const ControllerType ctype = g_settings.controller_types[controller_index];
if (ctype == ControllerType::None)
continue;
const auto category = TinyString::FromFormat("Controller%u", controller_index + 1);
const auto button_names = Controller::GetButtonNames(ctype);
for (const auto& it : button_names)
{
const std::string& button_name = it.first;
const s32 button_code = it.second;
const std::vector<std::string> bindings =
si.GetStringList(category, TinyString::FromFormat("Button%s", button_name.c_str()));
for (const std::string& binding : bindings)
{
std::string_view device, button;
if (!SplitBinding(binding, &device, &button))
continue;
AddButtonToInputMap(binding, device, button, [controller_index, button_code](bool pressed) {
if (System::IsShutdown())
return;
Controller* controller = System::GetController(controller_index);
if (controller)
controller->SetButtonState(button_code, pressed);
});
}
}
const auto axis_names = Controller::GetAxisNames(ctype);
for (const auto& it : axis_names)
{
const std::string& axis_name = std::get<std::string>(it);
const s32 axis_code = std::get<s32>(it);
const auto axis_type = std::get<Controller::AxisType>(it);
const std::vector<std::string> bindings =
si.GetStringList(category, TinyString::FromFormat("Axis%s", axis_name.c_str()));
for (const std::string& binding : bindings)
{
std::string_view device, axis;
if (!SplitBinding(binding, &device, &axis))
continue;
AddAxisToInputMap(binding, device, axis, axis_type, [controller_index, axis_code](float value) {
if (System::IsShutdown())
return;
Controller* controller = System::GetController(controller_index);
if (controller)
controller->SetAxisState(axis_code, value);
});
}
}
const u32 num_motors = Controller::GetVibrationMotorCount(ctype);
if (num_motors > 0)
{
const std::vector<std::string> bindings = si.GetStringList(category, TinyString::FromFormat("Rumble"));
for (const std::string& binding : bindings)
AddRumbleToInputMap(binding, controller_index, num_motors);
}
if (m_controller_interface)
{
const float deadzone_size = si.GetFloatValue(category, "Deadzone", 0.25f);
m_controller_interface->SetControllerDeadzone(controller_index, deadzone_size);
}
}
}
void CommonHostInterface::UpdateHotkeyInputMap(SettingsInterface& si)
{
for (const HotkeyInfo& hi : m_hotkeys)
{
const std::vector<std::string> bindings = si.GetStringList("Hotkeys", hi.name);
for (const std::string& binding : bindings)
{
std::string_view device, button;
if (!SplitBinding(binding, &device, &button))
continue;
AddButtonToInputMap(binding, device, button, hi.handler);
}
}
m_save_state_selector_ui->RefreshHotkeyLegend();
}
bool CommonHostInterface::AddButtonToInputMap(const std::string& binding, const std::string_view& device,
const std::string_view& button, InputButtonHandler handler)
{
if (device == "Keyboard")
{
std::optional<int> key_id = GetHostKeyCode(button);
if (!key_id.has_value())
{
Log_WarningPrintf("Unknown keyboard key in binding '%s'", binding.c_str());
return false;
}
m_keyboard_input_handlers.emplace(key_id.value(), std::move(handler));
return true;
}
if (device == "Mouse")
{
if (StringUtil::StartsWith(button, "Button"))
{
const std::optional<s32> button_index = StringUtil::FromChars<s32>(button.substr(6));
if (!button_index.has_value())
{
Log_WarningPrintf("Invalid button in mouse binding '%s'", binding.c_str());
return false;
}
m_mouse_input_handlers.emplace(static_cast<HostMouseButton>(button_index.value()), std::move(handler));
return true;
}
Log_WarningPrintf("Malformed mouse binding '%s'", binding.c_str());
return false;
}
std::optional<int> controller_index;
if (m_controller_interface && (controller_index = m_controller_interface->GetControllerIndex(device)))
{
if (StringUtil::StartsWith(button, "Button"))
{
const std::optional<int> button_index = StringUtil::FromChars<int>(button.substr(6));
if (!button_index ||
!m_controller_interface->BindControllerButton(*controller_index, *button_index, std::move(handler)))
{
Log_WarningPrintf("Failed to bind controller button '%s' to button", binding.c_str());
return false;
}
return true;
}
else if (StringUtil::StartsWith(button, "+Axis") || StringUtil::StartsWith(button, "-Axis"))
{
const std::optional<int> axis_index = StringUtil::FromChars<int>(button.substr(5));
const bool positive = (button[0] == '+');
if (!axis_index || !m_controller_interface->BindControllerAxisToButton(*controller_index, *axis_index, positive,
std::move(handler)))
{
Log_WarningPrintf("Failed to bind controller axis '%s' to button", binding.c_str());
return false;
}
return true;
}
else if (StringUtil::StartsWith(button, "Hat"))
{
const std::optional<int> hat_index = StringUtil::FromChars<int>(button.substr(3));
const std::optional<std::string_view> hat_direction = [](const auto& button) {
std::optional<std::string_view> result;
const size_t pos = button.find(' ');
if (pos != button.npos)
{
result = button.substr(pos + 1);
}
return result;
}(button);
if (!hat_index || !hat_direction ||
!m_controller_interface->BindControllerHatToButton(*controller_index, *hat_index, *hat_direction,
std::move(handler)))
{
Log_WarningPrintf("Failed to bind controller hat '%s' to button", binding.c_str());
return false;
}
return true;
}
Log_WarningPrintf("Malformed controller binding '%s' in button", binding.c_str());
return false;
}
Log_WarningPrintf("Unknown input device in button binding '%s'", binding.c_str());
return false;
}
bool CommonHostInterface::AddAxisToInputMap(const std::string& binding, const std::string_view& device,
const std::string_view& axis, Controller::AxisType axis_type,
InputAxisHandler handler)
{
if (axis_type == Controller::AxisType::Half)
{
if (device == "Keyboard")
{
std::optional<int> key_id = GetHostKeyCode(axis);
if (!key_id.has_value())
{
Log_WarningPrintf("Unknown keyboard key in binding '%s'", binding.c_str());
return false;
}
m_keyboard_input_handlers.emplace(key_id.value(),
[cb = std::move(handler)](bool pressed) { cb(pressed ? 1.0f : -1.0f); });
return true;
}
if (device == "Mouse")
{
if (StringUtil::StartsWith(axis, "Button"))
{
const std::optional<s32> button_index = StringUtil::FromChars<s32>(axis.substr(6));
if (!button_index.has_value())
{
Log_WarningPrintf("Invalid button in mouse binding '%s'", binding.c_str());
return false;
}
m_mouse_input_handlers.emplace(static_cast<HostMouseButton>(button_index.value()),
[cb = std::move(handler)](bool pressed) { cb(pressed ? 1.0f : -1.0f); });
return true;
}
Log_WarningPrintf("Malformed mouse binding '%s'", binding.c_str());
return false;
}
}
std::optional<int> controller_index;
if (m_controller_interface && (controller_index = m_controller_interface->GetControllerIndex(device)))
{
if (StringUtil::StartsWith(axis, "Axis") || StringUtil::StartsWith(axis, "+Axis") ||
StringUtil::StartsWith(axis, "-Axis"))
{
const std::optional<int> axis_index =
StringUtil::FromChars<int>(axis.substr(axis[0] == '+' || axis[0] == '-' ? 5 : 4));
if (axis_index)
{
ControllerInterface::AxisSide axis_side = ControllerInterface::AxisSide::Full;
if (axis[0] == '+')
axis_side = ControllerInterface::AxisSide::Positive;
else if (axis[0] == '-')
axis_side = ControllerInterface::AxisSide::Negative;
const bool inverted = StringUtil::EndsWith(axis, "-");
if (!inverted)
{
if (m_controller_interface->BindControllerAxis(*controller_index, *axis_index, axis_side, std::move(handler)))
{
return true;
}
}
else
{
if (m_controller_interface->BindControllerAxis(*controller_index, *axis_index, axis_side,
[cb = std::move(handler)](float value) { cb(-value); }))
{
return true;
}
}
}
Log_WarningPrintf("Failed to bind controller axis '%s' to axis", binding.c_str());
return false;
}
else if (StringUtil::StartsWith(axis, "Button") && axis_type == Controller::AxisType::Half)
{
const std::optional<int> button_index = StringUtil::FromChars<int>(axis.substr(6));
if (!button_index ||
!m_controller_interface->BindControllerButtonToAxis(*controller_index, *button_index, std::move(handler)))
{
Log_WarningPrintf("Failed to bind controller button '%s' to axis", binding.c_str());
return false;
}
return true;
}
Log_WarningPrintf("Malformed controller binding '%s' in button", binding.c_str());
return false;
}
Log_WarningPrintf("Unknown input device in axis binding '%s'", binding.c_str());
return false;
}
bool CommonHostInterface::AddRumbleToInputMap(const std::string& binding, u32 controller_index, u32 num_motors)
{
std::optional<int> host_controller_index;
if (m_controller_interface && (host_controller_index = m_controller_interface->GetControllerIndex(binding)))
{
AddControllerRumble(controller_index, num_motors,
std::bind(&ControllerInterface::SetControllerRumbleStrength, m_controller_interface.get(),
host_controller_index.value(), std::placeholders::_1, std::placeholders::_2));
return true;
}
Log_WarningPrintf("Unknown input device in rumble binding '%s'", binding.c_str());
return false;
}
void CommonHostInterface::SetFastForwardEnabled(bool enabled)
{
if (!System::IsValid())
return;
m_fast_forward_enabled = enabled;
UpdateSpeedLimiterState();
AddOSDMessage(enabled ? TranslateStdString("OSDMessage", "Fast forwarding...") :
TranslateStdString("OSDMessage", "Stopped fast forwarding."),
2.0f);
}
void CommonHostInterface::SetTurboEnabled(bool enabled)
{
if (!System::IsValid())
return;
m_turbo_enabled = enabled;
UpdateSpeedLimiterState();
AddOSDMessage(enabled ? TranslateStdString("OSDMessage", "Turboing...") :
TranslateStdString("OSDMessage", "Stopped turboing."),
2.0f);
}
void CommonHostInterface::RegisterHotkeys()
{
RegisterGeneralHotkeys();
RegisterGraphicsHotkeys();
RegisterSaveStateHotkeys();
RegisterAudioHotkeys();
}
static void DisplayHotkeyBlockedByChallengeModeMessage()
{
g_host_interface->AddOSDMessage(g_host_interface->TranslateStdString(
"OSDMessage", "Hotkey unavailable because achievements hardcore mode is active."));
}
void CommonHostInterface::RegisterGeneralHotkeys()
{
RegisterHotkey(StaticString(TRANSLATABLE("Hotkeys", "General")), StaticString("OpenQuickMenu"),
TRANSLATABLE("Hotkeys", "Open Quick Menu"), [this](bool pressed) {
if (pressed && m_fullscreen_ui_enabled)
FullscreenUI::OpenQuickMenu();
});
RegisterHotkey(StaticString(TRANSLATABLE("Hotkeys", "General")), StaticString("FastForward"),
TRANSLATABLE("Hotkeys", "Fast Forward"), [this](bool pressed) { SetFastForwardEnabled(pressed); });
RegisterHotkey(StaticString(TRANSLATABLE("Hotkeys", "General")), StaticString("ToggleFastForward"),
StaticString(TRANSLATABLE("Hotkeys", "Toggle Fast Forward")), [this](bool pressed) {
if (pressed)
SetFastForwardEnabled(!m_fast_forward_enabled);
});
RegisterHotkey(StaticString(TRANSLATABLE("Hotkeys", "General")), StaticString("Turbo"),
TRANSLATABLE("Hotkeys", "Turbo"), [this](bool pressed) { SetTurboEnabled(pressed); });
RegisterHotkey(StaticString(TRANSLATABLE("Hotkeys", "General")), StaticString("ToggleTurbo"),
StaticString(TRANSLATABLE("Hotkeys", "Toggle Turbo")), [this](bool pressed) {
if (pressed)
SetTurboEnabled(!m_turbo_enabled);
});
#ifndef ANDROID
RegisterHotkey(StaticString(TRANSLATABLE("Hotkeys", "General")), StaticString("ToggleFullscreen"),
StaticString(TRANSLATABLE("Hotkeys", "Toggle Fullscreen")), [this](bool pressed) {
if (pressed)
SetFullscreen(!IsFullscreen());
});
RegisterHotkey(StaticString(TRANSLATABLE("Hotkeys", "General")), StaticString("TogglePause"),
StaticString(TRANSLATABLE("Hotkeys", "Toggle Pause")), [this](bool pressed) {
if (pressed && System::IsValid())
PauseSystem(!System::IsPaused());
});
RegisterHotkey(StaticString(TRANSLATABLE("Hotkeys", "General")), StaticString("ToggleCheats"),
StaticString(TRANSLATABLE("Hotkeys", "Toggle Cheats")), [this](bool pressed) {
if (pressed && System::IsValid())
{
if (!IsCheevosChallengeModeActive())
DoToggleCheats();
else
DisplayHotkeyBlockedByChallengeModeMessage();
}
});
RegisterHotkey(StaticString(TRANSLATABLE("Hotkeys", "General")), StaticString("PowerOff"),
StaticString(TRANSLATABLE("Hotkeys", "Power Off System")), [this](bool pressed) {
if (pressed && System::IsValid())
{
if (g_settings.confim_power_off && !InBatchMode())
{
SmallString confirmation_message(
TranslateString("CommonHostInterface", "Are you sure you want to stop emulation?"));
if (ShouldSaveResumeState())
{
confirmation_message.AppendString("\n\n");
confirmation_message.AppendString(
TranslateString("CommonHostInterface", "The current state will be saved."));
}
if (!ConfirmMessage(confirmation_message))
{
System::ResetPerformanceCounters();
return;
}
}
PowerOffSystem(ShouldSaveResumeState());
}
});
#else
RegisterHotkey(StaticString(TRANSLATABLE("Hotkeys", "General")), StaticString("TogglePatchCodes"),
StaticString(TRANSLATABLE("Hotkeys", "Toggle Patch Codes")), [this](bool pressed) {
if (pressed && System::IsValid() && !IsCheevosChallengeModeActive())
DoToggleCheats();
});
#endif
RegisterHotkey(StaticString(TRANSLATABLE("Hotkeys", "General")), StaticString("Reset"),
StaticString(TRANSLATABLE("Hotkeys", "Reset System")), [this](bool pressed) {
if (pressed && System::IsValid())
ResetSystem();
});
RegisterHotkey(StaticString(TRANSLATABLE("Hotkeys", "General")), StaticString("Screenshot"),
StaticString(TRANSLATABLE("Hotkeys", "Save Screenshot")), [this](bool pressed) {
if (pressed && System::IsValid())
SaveScreenshot();
});
RegisterHotkey(StaticString(TRANSLATABLE("Hotkeys", "General")), StaticString("FrameStep"),
StaticString(TRANSLATABLE("Hotkeys", "Frame Step")), [this](bool pressed) {
if (pressed && System::IsValid())
{
if (!IsCheevosChallengeModeActive())
DoFrameStep();
else
DisplayHotkeyBlockedByChallengeModeMessage();
}
});
#ifndef __ANDROID__
RegisterHotkey(StaticString(TRANSLATABLE("Hotkeys", "General")), StaticString("Rewind"),
StaticString(TRANSLATABLE("Hotkeys", "Rewind")), [this](bool pressed) {
if (System::IsValid())
{
if (!IsCheevosChallengeModeActive())
{
AddOSDMessage(pressed ? TranslateStdString("OSDMessage", "Rewinding...") :
TranslateStdString("OSDMessage", "Stopped rewinding."),
5.0f);
System::SetRewinding(pressed);
}
else
{
DisplayHotkeyBlockedByChallengeModeMessage();
}
}
});
#endif
}
void CommonHostInterface::RegisterGraphicsHotkeys()
{
RegisterHotkey(StaticString(TRANSLATABLE("Hotkeys", "Graphics")), StaticString("ToggleSoftwareRendering"),
StaticString(TRANSLATABLE("Hotkeys", "Toggle Software Rendering")), [this](bool pressed) {
if (pressed && System::IsValid())
ToggleSoftwareRendering();
});
RegisterHotkey(StaticString(TRANSLATABLE("Hotkeys", "Graphics")), StaticString("TogglePGXP"),
StaticString(TRANSLATABLE("Hotkeys", "Toggle PGXP")), [this](bool pressed) {
if (pressed && System::IsValid())
{
g_settings.gpu_pgxp_enable = !g_settings.gpu_pgxp_enable;
g_gpu->RestoreGraphicsAPIState();
g_gpu->UpdateSettings();
g_gpu->ResetGraphicsAPIState();
System::ClearMemorySaveStates();
AddOSDMessage(g_settings.gpu_pgxp_enable ?
TranslateStdString("OSDMessage", "PGXP is now enabled.") :
TranslateStdString("OSDMessage", "PGXP is now disabled."),
5.0f);
if (g_settings.gpu_pgxp_enable)
PGXP::Initialize();
else
PGXP::Shutdown();
// we need to recompile all blocks if pgxp is toggled on/off
if (g_settings.IsUsingCodeCache())
CPU::CodeCache::Flush();
}
});
RegisterHotkey(StaticString(TRANSLATABLE("Hotkeys", "Graphics")), StaticString("TogglePGXPDepth"),
StaticString(TRANSLATABLE("Hotkeys", "Toggle PGXP Depth Buffer")), [this](bool pressed) {
if (pressed && System::IsValid())
{
g_settings.gpu_pgxp_depth_buffer = !g_settings.gpu_pgxp_depth_buffer;
if (!g_settings.gpu_pgxp_enable)
return;
g_gpu->RestoreGraphicsAPIState();
g_gpu->UpdateSettings();
g_gpu->ResetGraphicsAPIState();
System::ClearMemorySaveStates();
AddOSDMessage(g_settings.gpu_pgxp_depth_buffer ?
TranslateStdString("OSDMessage", "PGXP Depth Buffer is now enabled.") :
TranslateStdString("OSDMessage", "PGXP Depth Buffer is now disabled."),
5.0f);
}
});
RegisterHotkey(StaticString(TRANSLATABLE("Hotkeys", "Graphics")), StaticString("IncreaseResolutionScale"),
StaticString(TRANSLATABLE("Hotkeys", "Increase Resolution Scale")), [this](bool pressed) {
if (pressed && System::IsValid())
ModifyResolutionScale(1);
});
RegisterHotkey(StaticString(TRANSLATABLE("Hotkeys", "Graphics")), StaticString("DecreaseResolutionScale"),
StaticString(TRANSLATABLE("Hotkeys", "Decrease Resolution Scale")), [this](bool pressed) {
if (pressed && System::IsValid())
ModifyResolutionScale(-1);
});
RegisterHotkey(StaticString(TRANSLATABLE("Hotkeys", "Graphics")), StaticString("TogglePostProcessing"),
StaticString(TRANSLATABLE("Hotkeys", "Toggle Post-Processing")), [this](bool pressed) {
if (pressed && System::IsValid())
TogglePostProcessing();
});
RegisterHotkey(StaticString(TRANSLATABLE("Hotkeys", "Graphics")), StaticString("ReloadPostProcessingShaders"),
StaticString(TRANSLATABLE("Hotkeys", "Reload Post Processing Shaders")), [this](bool pressed) {
if (pressed && System::IsValid())
ReloadPostProcessingShaders();
});
RegisterHotkey(StaticString(TRANSLATABLE("Hotkeys", "Graphics")), StaticString("ReloadTextureReplacements"),
StaticString(TRANSLATABLE("Hotkeys", "Reload Texture Replacements")), [this](bool pressed) {
if (pressed && System::IsValid())
{
AddOSDMessage(TranslateStdString("OSDMessage", "Texture replacements reloaded."), 10.0f);
g_texture_replacements.Reload();
}
});
}
void CommonHostInterface::RegisterSaveStateHotkeys()
{
RegisterHotkey(StaticString(TRANSLATABLE("Hotkeys", "Save States")), StaticString("LoadSelectedSaveState"),
StaticString(TRANSLATABLE("Hotkeys", "Load From Selected Slot")), [this](bool pressed) {
if (pressed)
{
if (!IsCheevosChallengeModeActive())
m_save_state_selector_ui->LoadCurrentSlot();
else
DisplayHotkeyBlockedByChallengeModeMessage();
}
});
RegisterHotkey(StaticString(TRANSLATABLE("Hotkeys", "Save States")), StaticString("SaveSelectedSaveState"),
StaticString(TRANSLATABLE("Hotkeys", "Save To Selected Slot")), [this](bool pressed) {
if (pressed)
m_save_state_selector_ui->SaveCurrentSlot();
});
RegisterHotkey(StaticString(TRANSLATABLE("Hotkeys", "Save States")), StaticString("SelectPreviousSaveStateSlot"),
StaticString(TRANSLATABLE("Hotkeys", "Select Previous Save Slot")), [this](bool pressed) {
if (pressed)
m_save_state_selector_ui->SelectPreviousSlot();
});
RegisterHotkey(StaticString(TRANSLATABLE("Hotkeys", "Save States")), StaticString("SelectNextSaveStateSlot"),
StaticString(TRANSLATABLE("Hotkeys", "Select Next Save Slot")), [this](bool pressed) {
if (pressed)
m_save_state_selector_ui->SelectNextSlot();
});
for (u32 slot = 1; slot <= PER_GAME_SAVE_STATE_SLOTS; slot++)
{
RegisterHotkey(StaticString(TRANSLATABLE("Hotkeys", "Save States")),
TinyString::FromFormat("LoadGameState%u", slot), TinyString::FromFormat("Load Game State %u", slot),
[this, slot](bool pressed) {
if (pressed)
{
if (!IsCheevosChallengeModeActive())
LoadState(false, slot);
else
DisplayHotkeyBlockedByChallengeModeMessage();
}
});
RegisterHotkey(StaticString(TRANSLATABLE("Hotkeys", "Save States")),
TinyString::FromFormat("SaveGameState%u", slot), TinyString::FromFormat("Save Game State %u", slot),
[this, slot](bool pressed) {
if (pressed)
SaveState(false, slot);
});
}
for (u32 slot = 1; slot <= GLOBAL_SAVE_STATE_SLOTS; slot++)
{
RegisterHotkey(StaticString(TRANSLATABLE("Hotkeys", "Save States")),
TinyString::FromFormat("LoadGlobalState%u", slot),
TinyString::FromFormat("Load Global State %u", slot), [this, slot](bool pressed) {
if (pressed)
{
if (!IsCheevosChallengeModeActive())
LoadState(true, slot);
else
DisplayHotkeyBlockedByChallengeModeMessage();
}
});
RegisterHotkey(StaticString(TRANSLATABLE("Hotkeys", "Save States")),
TinyString::FromFormat("SaveGlobalState%u", slot),
TinyString::FromFormat("Save Global State %u", slot), [this, slot](bool pressed) {
if (pressed)
SaveState(true, slot);
});
}
// Dummy strings for translation because we construct them in a loop.
(void)TRANSLATABLE("Hotkeys", "Load Game State 1");
(void)TRANSLATABLE("Hotkeys", "Load Game State 2");
(void)TRANSLATABLE("Hotkeys", "Load Game State 3");
(void)TRANSLATABLE("Hotkeys", "Load Game State 4");
(void)TRANSLATABLE("Hotkeys", "Load Game State 5");
(void)TRANSLATABLE("Hotkeys", "Load Game State 6");
(void)TRANSLATABLE("Hotkeys", "Load Game State 7");
(void)TRANSLATABLE("Hotkeys", "Load Game State 8");
(void)TRANSLATABLE("Hotkeys", "Load Game State 9");
(void)TRANSLATABLE("Hotkeys", "Load Game State 10");
(void)TRANSLATABLE("Hotkeys", "Save Game State 1");
(void)TRANSLATABLE("Hotkeys", "Save Game State 2");
(void)TRANSLATABLE("Hotkeys", "Save Game State 3");
(void)TRANSLATABLE("Hotkeys", "Save Game State 4");
(void)TRANSLATABLE("Hotkeys", "Save Game State 5");
(void)TRANSLATABLE("Hotkeys", "Save Game State 6");
(void)TRANSLATABLE("Hotkeys", "Save Game State 7");
(void)TRANSLATABLE("Hotkeys", "Save Game State 8");
(void)TRANSLATABLE("Hotkeys", "Save Game State 9");
(void)TRANSLATABLE("Hotkeys", "Save Game State 10");
(void)TRANSLATABLE("Hotkeys", "Load Global State 1");
(void)TRANSLATABLE("Hotkeys", "Load Global State 2");
(void)TRANSLATABLE("Hotkeys", "Load Global State 3");
(void)TRANSLATABLE("Hotkeys", "Load Global State 4");
(void)TRANSLATABLE("Hotkeys", "Load Global State 5");
(void)TRANSLATABLE("Hotkeys", "Load Global State 6");
(void)TRANSLATABLE("Hotkeys", "Load Global State 7");
(void)TRANSLATABLE("Hotkeys", "Load Global State 8");
(void)TRANSLATABLE("Hotkeys", "Load Global State 9");
(void)TRANSLATABLE("Hotkeys", "Load Global State 10");
(void)TRANSLATABLE("Hotkeys", "Save Global State 1");
(void)TRANSLATABLE("Hotkeys", "Save Global State 2");
(void)TRANSLATABLE("Hotkeys", "Save Global State 3");
(void)TRANSLATABLE("Hotkeys", "Save Global State 4");
(void)TRANSLATABLE("Hotkeys", "Save Global State 5");
(void)TRANSLATABLE("Hotkeys", "Save Global State 6");
(void)TRANSLATABLE("Hotkeys", "Save Global State 7");
(void)TRANSLATABLE("Hotkeys", "Save Global State 8");
(void)TRANSLATABLE("Hotkeys", "Save Global State 9");
(void)TRANSLATABLE("Hotkeys", "Save Global State 10");
}
void CommonHostInterface::RegisterAudioHotkeys()
{
RegisterHotkey(StaticString(TRANSLATABLE("Hotkeys", "Audio")), StaticString("AudioMute"),
StaticString(TRANSLATABLE("Hotkeys", "Toggle Mute")), [this](bool pressed) {
if (pressed && System::IsValid())
{
g_settings.audio_output_muted = !g_settings.audio_output_muted;
const s32 volume = GetAudioOutputVolume();
m_audio_stream->SetOutputVolume(volume);
if (g_settings.audio_output_muted)
AddOSDMessage(TranslateStdString("OSDMessage", "Volume: Muted"), 2.0f);
else
AddFormattedOSDMessage(2.0f, TranslateString("OSDMessage", "Volume: %d%%"), volume);
}
});
RegisterHotkey(StaticString(TRANSLATABLE("Hotkeys", "Audio")), StaticString("AudioCDAudioMute"),
StaticString(TRANSLATABLE("Hotkeys", "Toggle CD Audio Mute")), [this](bool pressed) {
if (pressed && System::IsValid())
{
g_settings.cdrom_mute_cd_audio = !g_settings.cdrom_mute_cd_audio;
AddOSDMessage(g_settings.cdrom_mute_cd_audio ?
TranslateStdString("OSDMessage", "CD Audio Muted.") :
TranslateStdString("OSDMessage", "CD Audio Unmuted."),
2.0f);
}
});
RegisterHotkey(StaticString(TRANSLATABLE("Hotkeys", "Audio")), StaticString("AudioVolumeUp"),
StaticString(TRANSLATABLE("Hotkeys", "Volume Up")), [this](bool pressed) {
if (pressed && System::IsValid())
{
g_settings.audio_output_muted = false;
const s32 volume = std::min<s32>(GetAudioOutputVolume() + 10, 100);
g_settings.audio_output_volume = volume;
g_settings.audio_fast_forward_volume = volume;
m_audio_stream->SetOutputVolume(volume);
AddFormattedOSDMessage(2.0f, TranslateString("OSDMessage", "Volume: %d%%"), volume);
}
});
RegisterHotkey(StaticString(TRANSLATABLE("Hotkeys", "Audio")), StaticString("AudioVolumeDown"),
StaticString(TRANSLATABLE("Hotkeys", "Volume Down")), [this](bool pressed) {
if (pressed && System::IsValid())
{
g_settings.audio_output_muted = false;
const s32 volume = std::max<s32>(GetAudioOutputVolume() - 10, 0);
g_settings.audio_output_volume = volume;
g_settings.audio_fast_forward_volume = volume;
m_audio_stream->SetOutputVolume(volume);
AddFormattedOSDMessage(2.0f, TranslateString("OSDMessage", "Volume: %d%%"), volume);
}
});
}
std::string CommonHostInterface::GetSavePathForInputProfile(const char* name) const
{
return GetUserDirectoryRelativePath("inputprofiles/%s.ini", name);
}
CommonHostInterface::InputProfileList CommonHostInterface::GetInputProfileList() const
{
InputProfileList profiles;
const std::string user_dir(GetUserDirectoryRelativePath("inputprofiles"));
const std::string program_dir(GetProgramDirectoryRelativePath("inputprofiles"));
FindInputProfiles(user_dir, &profiles);
if (user_dir != program_dir)
FindInputProfiles(program_dir, &profiles);
return profiles;
}
void CommonHostInterface::FindInputProfiles(const std::string& base_path, InputProfileList* out_list) const
{
FileSystem::FindResultsArray results;
FileSystem::FindFiles(base_path.c_str(), "*.ini", FILESYSTEM_FIND_FILES | FILESYSTEM_FIND_RELATIVE_PATHS, &results);
out_list->reserve(out_list->size() + results.size());
for (auto& it : results)
{
if (it.FileName.size() < 4)
continue;
std::string name(it.FileName.substr(0, it.FileName.length() - 4));
// skip duplicates, we prefer the user directory
if (std::any_of(out_list->begin(), out_list->end(),
[&name](const InputProfileEntry& e) { return (e.name == name); }))
{
continue;
}
std::string filename(
StringUtil::StdStringFromFormat("%s" FS_OSPATH_SEPARATOR_STR "%s", base_path.c_str(), it.FileName.c_str()));
out_list->push_back(InputProfileEntry{std::move(name), std::move(filename)});
}
}
std::string CommonHostInterface::GetInputProfilePath(const char* name) const
{
std::string path = GetUserDirectoryRelativePath("inputprofiles" FS_OSPATH_SEPARATOR_STR "%s.ini", name);
if (FileSystem::FileExists(path.c_str()))
return path;
path = GetProgramDirectoryRelativePath("inputprofiles" FS_OSPATH_SEPARATOR_STR "%s.ini", name);
if (FileSystem::FileExists(path.c_str()))
return path;
return {};
}
void CommonHostInterface::ClearAllControllerBindings()
{
for (u32 controller_index = 1; controller_index <= NUM_CONTROLLER_AND_CARD_PORTS; controller_index++)
m_settings_interface->ClearSection(TinyString::FromFormat("Controller%u", controller_index));
}
bool CommonHostInterface::ApplyInputProfile(const char* profile_path)
{
if (!FileSystem::FileExists(profile_path))
return false;
INISettingsInterface profile(profile_path);
std::lock_guard<std::recursive_mutex> guard(m_settings_mutex);
// clear bindings for all controllers
ClearAllControllerBindings();
for (u32 controller_index = 1; controller_index <= NUM_CONTROLLER_AND_CARD_PORTS; controller_index++)
{
const auto section_name = TinyString::FromFormat("Controller%u", controller_index);
const std::string ctype_str = profile.GetStringValue(section_name, "Type");
if (ctype_str.empty())
{
m_settings_interface->SetStringValue(section_name, "Type", Settings::GetControllerTypeName(ControllerType::None));
g_settings.controller_types[controller_index - 1] = ControllerType::None;
continue;
}
std::optional<ControllerType> ctype = Settings::ParseControllerTypeName(ctype_str.c_str());
if (!ctype)
{
Log_ErrorPrintf("Invalid controller type in profile: '%s'", ctype_str.c_str());
continue;
}
g_settings.controller_types[controller_index - 1] = *ctype;
HostInterface::OnControllerTypeChanged(controller_index - 1);
m_settings_interface->SetStringValue(section_name, "Type", Settings::GetControllerTypeName(*ctype));
for (const auto& button : Controller::GetButtonNames(*ctype))
{
const auto key_name = TinyString::FromFormat("Button%s", button.first.c_str());
m_settings_interface->DeleteValue(section_name, key_name);
const std::vector<std::string> bindings = profile.GetStringList(section_name, key_name);
for (const std::string& binding : bindings)
m_settings_interface->AddToStringList(section_name, key_name, binding.c_str());
}
for (const auto& axis : Controller::GetAxisNames(*ctype))
{
const auto key_name = TinyString::FromFormat("Axis%s", std::get<std::string>(axis).c_str());
m_settings_interface->DeleteValue(section_name, std::get<std::string>(axis).c_str());
const std::vector<std::string> bindings = profile.GetStringList(section_name, key_name);
for (const std::string& binding : bindings)
m_settings_interface->AddToStringList(section_name, key_name, binding.c_str());
}
m_settings_interface->DeleteValue(section_name, "Rumble");
if (Controller::GetVibrationMotorCount(*ctype) > 0)
{
const std::string rumble_value = profile.GetStringValue(section_name, "Rumble");
if (!rumble_value.empty())
m_settings_interface->SetStringValue(section_name, "Rumble", rumble_value.c_str());
}
Controller::SettingList settings = Controller::GetSettings(*ctype);
for (const SettingInfo& ssi : settings)
{
const std::string value = profile.GetStringValue(section_name, ssi.key, "");
if (!value.empty())
m_settings_interface->SetStringValue(section_name, ssi.key, value.c_str());
}
}
ReportFormattedMessage(TranslateString("OSDMessage", "Loaded input profile from '%s'"), profile_path);
ApplySettings(false);
return true;
}
bool CommonHostInterface::SaveInputProfile(const char* profile_path)
{
if (FileSystem::FileExists(profile_path))
Log_WarningPrintf("Existing input profile at '%s' will be overwritten", profile_path);
else
Log_WarningPrintf("Input profile at '%s' does not exist, new input profile will be created", profile_path);
INISettingsInterface profile(profile_path);
profile.Clear();
for (u32 controller_index = 1; controller_index <= NUM_CONTROLLER_AND_CARD_PORTS; controller_index++)
{
const ControllerType ctype = g_settings.controller_types[controller_index - 1];
if (ctype == ControllerType::None)
continue;
const auto section_name = TinyString::FromFormat("Controller%u", controller_index);
profile.SetStringValue(section_name, "Type", Settings::GetControllerTypeName(ctype));
for (const auto& button : Controller::GetButtonNames(ctype))
{
const auto key_name = TinyString::FromFormat("Button%s", button.first.c_str());
const std::vector<std::string> bindings = m_settings_interface->GetStringList(section_name, key_name);
for (const std::string& binding : bindings)
profile.AddToStringList(section_name, key_name, binding.c_str());
}
for (const auto& axis : Controller::GetAxisNames(ctype))
{
const auto key_name = TinyString::FromFormat("Axis%s", std::get<std::string>(axis).c_str());
const std::vector<std::string> bindings = m_settings_interface->GetStringList(section_name, key_name);
for (const std::string& binding : bindings)
profile.AddToStringList(section_name, key_name, binding.c_str());
}
if (Controller::GetVibrationMotorCount(ctype) > 0)
{
const std::string rumble_value = m_settings_interface->GetStringValue(section_name, "Rumble");
if (!rumble_value.empty())
profile.SetStringValue(section_name, "Rumble", rumble_value.c_str());
}
Controller::SettingList settings = Controller::GetSettings(ctype);
for (const SettingInfo& ssi : settings)
{
const std::string value = m_settings_interface->GetStringValue(section_name, ssi.key, "");
if (!value.empty())
profile.SetStringValue(section_name, ssi.key, value.c_str());
}
}
if (!profile.Save())
{
Log_ErrorPrintf("Failed to save input profile to '%s'", profile_path);
return false;
}
Log_InfoPrintf("Input profile saved to '%s'", profile_path);
return true;
}
std::string CommonHostInterface::GetSettingsFileName() const
{
std::string filename;
if (!s_settings_filename.empty())
filename = s_settings_filename;
else
filename = GetUserDirectoryRelativePath("settings.ini");
return filename;
}
std::string CommonHostInterface::GetGameSaveStateFileName(const char* game_code, s32 slot) const
{
if (slot < 0)
return GetUserDirectoryRelativePath("savestates" FS_OSPATH_SEPARATOR_STR "%s_resume.sav", game_code);
else
return GetUserDirectoryRelativePath("savestates" FS_OSPATH_SEPARATOR_STR "%s_%d.sav", game_code, slot);
}
std::string CommonHostInterface::GetGlobalSaveStateFileName(s32 slot) const
{
if (slot < 0)
return GetUserDirectoryRelativePath("savestates" FS_OSPATH_SEPARATOR_STR "resume.sav");
else
return GetUserDirectoryRelativePath("savestates" FS_OSPATH_SEPARATOR_STR "savestate_%d.sav", slot);
}
std::vector<CommonHostInterface::SaveStateInfo> CommonHostInterface::GetAvailableSaveStates(const char* game_code) const
{
std::vector<SaveStateInfo> si;
std::string path;
auto add_path = [&si](std::string path, s32 slot, bool global) {
FILESYSTEM_STAT_DATA sd;
if (!FileSystem::StatFile(path.c_str(), &sd))
return;
si.push_back(SaveStateInfo{std::move(path), sd.ModificationTime.AsUnixTimestamp(), static_cast<s32>(slot), global});
};
if (game_code && std::strlen(game_code) > 0)
{
add_path(GetGameSaveStateFileName(game_code, -1), -1, false);
for (s32 i = 1; i <= PER_GAME_SAVE_STATE_SLOTS; i++)
add_path(GetGameSaveStateFileName(game_code, i), i, false);
}
for (s32 i = 1; i <= GLOBAL_SAVE_STATE_SLOTS; i++)
add_path(GetGlobalSaveStateFileName(i), i, true);
return si;
}
std::optional<CommonHostInterface::SaveStateInfo> CommonHostInterface::GetSaveStateInfo(const char* game_code, s32 slot)
{
const bool global = (!game_code || game_code[0] == 0);
std::string path = global ? GetGlobalSaveStateFileName(slot) : GetGameSaveStateFileName(game_code, slot);
FILESYSTEM_STAT_DATA sd;
if (!FileSystem::StatFile(path.c_str(), &sd))
return std::nullopt;
return SaveStateInfo{std::move(path), sd.ModificationTime.AsUnixTimestamp(), slot, global};
}
std::optional<CommonHostInterface::ExtendedSaveStateInfo>
CommonHostInterface::GetExtendedSaveStateInfo(const char* game_code, s32 slot)
{
const bool global = (!game_code || game_code[0] == 0);
std::string path = global ? GetGlobalSaveStateFileName(slot) : GetGameSaveStateFileName(game_code, slot);
FILESYSTEM_STAT_DATA sd;
if (!FileSystem::StatFile(path.c_str(), &sd))
return std::nullopt;
std::unique_ptr<ByteStream> stream =
FileSystem::OpenFile(path.c_str(), BYTESTREAM_OPEN_READ | BYTESTREAM_OPEN_SEEKABLE);
if (!stream)
return std::nullopt;
SAVE_STATE_HEADER header;
if (!stream->Read(&header, sizeof(header)) || header.magic != SAVE_STATE_MAGIC)
return std::nullopt;
ExtendedSaveStateInfo ssi;
ssi.path = std::move(path);
ssi.timestamp = sd.ModificationTime.AsUnixTimestamp();
ssi.slot = slot;
ssi.global = global;
if (header.version < SAVE_STATE_MINIMUM_VERSION || header.version > SAVE_STATE_VERSION)
{
ssi.title = StringUtil::StdStringFromFormat(
TranslateString("CommonHostInterface", "Invalid version %u (%s version %u)"), header.version,
header.version > SAVE_STATE_VERSION ? "maximum" : "minimum",
header.version > SAVE_STATE_VERSION ? SAVE_STATE_VERSION : SAVE_STATE_MINIMUM_VERSION);
return ssi;
}
header.title[sizeof(header.title) - 1] = 0;
ssi.title = header.title;
header.game_code[sizeof(header.game_code) - 1] = 0;
ssi.game_code = header.game_code;
if (header.media_filename_length > 0 &&
(header.offset_to_media_filename + header.media_filename_length) <= stream->GetSize())
{
stream->SeekAbsolute(header.offset_to_media_filename);
ssi.media_path.resize(header.media_filename_length);
if (!stream->Read2(ssi.media_path.data(), header.media_filename_length))
std::string().swap(ssi.media_path);
}
if (header.screenshot_width > 0 && header.screenshot_height > 0 && header.screenshot_size > 0 &&
(static_cast<u64>(header.offset_to_screenshot) + static_cast<u64>(header.screenshot_size)) <= stream->GetSize())
{
stream->SeekAbsolute(header.offset_to_screenshot);
ssi.screenshot_data.resize((header.screenshot_size + 3u) / 4u);
if (stream->Read2(ssi.screenshot_data.data(), header.screenshot_size))
{
ssi.screenshot_width = header.screenshot_width;
ssi.screenshot_height = header.screenshot_height;
}
else
{
decltype(ssi.screenshot_data)().swap(ssi.screenshot_data);
}
}
return ssi;
}
void CommonHostInterface::DeleteSaveStates(const char* game_code, bool resume)
{
const std::vector<SaveStateInfo> states(GetAvailableSaveStates(game_code));
for (const SaveStateInfo& si : states)
{
if (si.global || (!resume && si.slot < 0))
continue;
Log_InfoPrintf("Removing save state at '%s'", si.path.c_str());
if (!FileSystem::DeleteFile(si.path.c_str()))
Log_ErrorPrintf("Failed to delete save state file '%s'", si.path.c_str());
}
}
std::string CommonHostInterface::GetMostRecentResumeSaveStatePath() const
{
std::vector<FILESYSTEM_FIND_DATA> files;
if (!FileSystem::FindFiles(GetUserDirectoryRelativePath("savestates").c_str(), "*resume.sav", FILESYSTEM_FIND_FILES,
&files) ||
files.empty())
{
return {};
}
FILESYSTEM_FIND_DATA* most_recent = &files[0];
for (FILESYSTEM_FIND_DATA& file : files)
{
if (file.ModificationTime > most_recent->ModificationTime)
most_recent = &file;
}
return std::move(most_recent->FileName);
}
void CommonHostInterface::SetDefaultSettings(SettingsInterface& si)
{
HostInterface::SetDefaultSettings(si);
// TODO: Maybe we should bind this to F1 in the future.
if (m_fullscreen_ui_enabled)
si.SetStringValue("Hotkeys", "OpenQuickMenu", "Keyboard/Escape");
si.SetStringValue("Controller1", "ButtonUp", "Keyboard/W");
si.SetStringValue("Controller1", "ButtonDown", "Keyboard/S");
si.SetStringValue("Controller1", "ButtonLeft", "Keyboard/A");
si.SetStringValue("Controller1", "ButtonRight", "Keyboard/D");
si.SetStringValue("Controller1", "ButtonSelect", "Keyboard/Backspace");
si.SetStringValue("Controller1", "ButtonStart", "Keyboard/Return");
si.SetStringValue("Controller1", "ButtonTriangle", "Keyboard/Keypad+8");
si.SetStringValue("Controller1", "ButtonCross", "Keyboard/Keypad+2");
si.SetStringValue("Controller1", "ButtonSquare", "Keyboard/Keypad+4");
si.SetStringValue("Controller1", "ButtonCircle", "Keyboard/Keypad+6");
si.SetStringValue("Controller1", "ButtonL1", "Keyboard/Q");
si.SetStringValue("Controller1", "ButtonL2", "Keyboard/1");
si.SetStringValue("Controller1", "ButtonR1", "Keyboard/E");
si.SetStringValue("Controller1", "ButtonR2", "Keyboard/3");
si.SetStringValue("Hotkeys", "FastForward", "Keyboard/Tab");
si.SetStringValue("Hotkeys", "TogglePause", "Keyboard/Pause");
si.SetStringValue("Hotkeys", "ToggleFullscreen", "Keyboard/Alt+Return");
si.SetStringValue("Hotkeys", "Screenshot", "Keyboard/F10");
si.SetStringValue("Hotkeys", "IncreaseResolutionScale", "Keyboard/PageUp");
si.SetStringValue("Hotkeys", "DecreaseResolutionScale", "Keyboard/PageDown");
si.SetStringValue("Hotkeys", "ToggleSoftwareRendering", "Keyboard/End");
si.SetStringValue("Main", "ControllerBackend",
ControllerInterface::GetBackendName(ControllerInterface::GetDefaultBackend()));
si.SetBoolValue("Display", "InternalResolutionScreenshots", false);
#ifdef WITH_DISCORD_PRESENCE
si.SetBoolValue("Main", "EnableDiscordPresence", false);
#endif
#ifdef WITH_CHEEVOS
si.SetBoolValue("Cheevos", "Enabled", false);
si.SetBoolValue("Cheevos", "TestMode", false);
si.SetBoolValue("Cheevos", "UseFirstDiscFromPlaylist", true);
si.DeleteValue("Cheevos", "Username");
si.DeleteValue("Cheevos", "Token");
#endif
}
void CommonHostInterface::LoadSettings()
{
// no lock needed here since it's done on startup
Assert(m_settings_interface);
#ifndef __ANDROID__
// we don't check the settings version on android, because it's not using the ini yet..
// we can re-enable this once we move it over.. eventually.
const int settings_version = m_settings_interface->GetIntValue("Main", "SettingsVersion", -1);
if (settings_version != SETTINGS_VERSION)
{
ReportFormattedError("Settings version %d does not match expected version %d, resetting", settings_version,
SETTINGS_VERSION);
m_settings_interface->Clear();
m_settings_interface->SetIntValue("Main", "SettingsVersion", SETTINGS_VERSION);
SetDefaultSettings(*m_settings_interface);
m_settings_interface->Save();
}
#endif
LoadSettings(*m_settings_interface);
FixIncompatibleSettings(false);
}
void CommonHostInterface::LoadSettings(SettingsInterface& si)
{
HostInterface::LoadSettings(si);
#ifdef WITH_DISCORD_PRESENCE
SetDiscordPresenceEnabled(si.GetBoolValue("Main", "EnableDiscordPresence", false));
#endif
#ifdef WITH_CHEEVOS
UpdateCheevosActive();
const bool cheevos_active = Cheevos::IsActive();
#else
const bool cheevos_active = false;
#endif
const bool fullscreen_ui_enabled =
si.GetBoolValue("Main", "EnableFullscreenUI", false) || cheevos_active || m_flags.force_fullscreen_ui;
if (fullscreen_ui_enabled != m_fullscreen_ui_enabled)
{
m_fullscreen_ui_enabled = fullscreen_ui_enabled;
if (m_display)
{
if (!fullscreen_ui_enabled)
{
FullscreenUI::Shutdown();
ImGuiFullscreen::ResetFonts();
if (!m_display->UpdateImGuiFontTexture())
Panic("Failed to recreate font texture after fullscreen UI disable");
}
else
{
if (FullscreenUI::Initialize(this))
{
if (!m_display->UpdateImGuiFontTexture())
Panic("Failed to recreate font textre after fullscreen UI enable");
}
else
{
Log_ErrorPrintf("Failed to initialize fullscreen UI. Disabling.");
m_fullscreen_ui_enabled = false;
}
}
}
}
}
void CommonHostInterface::SaveSettings(SettingsInterface& si)
{
HostInterface::SaveSettings(si);
}
void CommonHostInterface::FixIncompatibleSettings(bool display_osd_messages)
{
// if challenge mode is enabled, disable things like rewind since they use save states
if (IsCheevosChallengeModeActive())
{
g_settings.emulation_speed =
(g_settings.emulation_speed != 0.0f) ? std::max(g_settings.emulation_speed, 1.0f) : 0.0f;
g_settings.fast_forward_speed =
(g_settings.fast_forward_speed != 0.0f) ? std::max(g_settings.fast_forward_speed, 1.0f) : 0.0f;
g_settings.turbo_speed = (g_settings.turbo_speed != 0.0f) ? std::max(g_settings.turbo_speed, 1.0f) : 0.0f;
g_settings.rewind_enable = false;
g_settings.auto_load_cheats = false;
g_settings.debugging.enable_gdb_server = false;
g_settings.debugging.show_vram = false;
g_settings.debugging.show_gpu_state = false;
g_settings.debugging.show_cdrom_state = false;
g_settings.debugging.show_spu_state = false;
g_settings.debugging.show_timers_state = false;
g_settings.debugging.show_mdec_state = false;
g_settings.debugging.show_dma_state = false;
g_settings.debugging.dump_cpu_to_vram_copies = false;
g_settings.debugging.dump_vram_to_cpu_copies = false;
}
HostInterface::FixIncompatibleSettings(display_osd_messages);
}
void CommonHostInterface::ApplySettings(bool display_osd_messages)
{
Settings old_settings(std::move(g_settings));
{
std::lock_guard<std::recursive_mutex> guard(m_settings_mutex);
LoadSettings(*m_settings_interface.get());
ApplyGameSettings(display_osd_messages);
FixIncompatibleSettings(display_osd_messages);
}
CheckForSettingsChanges(old_settings);
}
void CommonHostInterface::UpdateInputMap()
{
std::lock_guard<std::recursive_mutex> lock(m_settings_mutex);
UpdateInputMap(*m_settings_interface.get());
}
void CommonHostInterface::CheckForSettingsChanges(const Settings& old_settings)
{
HostInterface::CheckForSettingsChanges(old_settings);
UpdateControllerInterface();
if (System::IsValid())
{
if (g_settings.audio_backend != old_settings.audio_backend ||
g_settings.audio_buffer_size != old_settings.audio_buffer_size ||
g_settings.video_sync_enabled != old_settings.video_sync_enabled ||
g_settings.audio_sync_enabled != old_settings.audio_sync_enabled ||
g_settings.increase_timer_resolution != old_settings.increase_timer_resolution ||
g_settings.emulation_speed != old_settings.emulation_speed ||
g_settings.fast_forward_speed != old_settings.fast_forward_speed ||
g_settings.display_max_fps != old_settings.display_max_fps ||
g_settings.display_all_frames != old_settings.display_all_frames ||
g_settings.audio_resampling != old_settings.audio_resampling ||
g_settings.sync_to_host_refresh_rate != old_settings.sync_to_host_refresh_rate)
{
UpdateSpeedLimiterState();
}
if (g_settings.display_post_processing != old_settings.display_post_processing ||
g_settings.display_post_process_chain != old_settings.display_post_process_chain)
{
if (g_settings.display_post_processing)
{
if (!m_display->SetPostProcessingChain(g_settings.display_post_process_chain))
AddOSDMessage(TranslateStdString("OSDMessage", "Failed to load post processing shader chain."), 20.0f);
}
else
{
m_display->SetPostProcessingChain({});
}
}
}
if (g_settings.log_level != old_settings.log_level || g_settings.log_filter != old_settings.log_filter ||
g_settings.log_to_console != old_settings.log_to_console ||
g_settings.log_to_window != old_settings.log_to_window || g_settings.log_to_file != old_settings.log_to_file)
{
UpdateLogSettings(g_settings.log_level, g_settings.log_filter.empty() ? nullptr : g_settings.log_filter.c_str(),
g_settings.log_to_console, g_settings.log_to_debug, g_settings.log_to_window,
g_settings.log_to_file);
}
UpdateInputMap();
}
std::string CommonHostInterface::GetStringSettingValue(const char* section, const char* key,
const char* default_value /*= ""*/)
{
std::lock_guard<std::recursive_mutex> guard(m_settings_mutex);
return m_settings_interface->GetStringValue(section, key, default_value);
}
bool CommonHostInterface::GetBoolSettingValue(const char* section, const char* key, bool default_value /* = false */)
{
std::lock_guard<std::recursive_mutex> guard(m_settings_mutex);
return m_settings_interface->GetBoolValue(section, key, default_value);
}
int CommonHostInterface::GetIntSettingValue(const char* section, const char* key, int default_value /* = 0 */)
{
std::lock_guard<std::recursive_mutex> guard(m_settings_mutex);
return m_settings_interface->GetIntValue(section, key, default_value);
}
float CommonHostInterface::GetFloatSettingValue(const char* section, const char* key, float default_value /* = 0.0f */)
{
std::lock_guard<std::recursive_mutex> guard(m_settings_mutex);
return m_settings_interface->GetFloatValue(section, key, default_value);
}
std::vector<std::string> CommonHostInterface::GetSettingStringList(const char* section, const char* key)
{
std::lock_guard<std::recursive_mutex> guard(m_settings_mutex);
return m_settings_interface->GetStringList(section, key);
}
void CommonHostInterface::SetTimerResolutionIncreased(bool enabled)
{
if (m_timer_resolution_increased == enabled)
return;
m_timer_resolution_increased = enabled;
#ifdef WIN32
if (enabled)
timeBeginPeriod(1);
else
timeEndPeriod(1);
#endif
}
void CommonHostInterface::DisplayLoadingScreen(const char* message, int progress_min /*= -1*/,
int progress_max /*= -1*/, int progress_value /*= -1*/)
{
const auto& io = ImGui::GetIO();
const float scale = io.DisplayFramebufferScale.x;
const float width = (400.0f * scale);
const bool has_progress = (progress_min < progress_max);
// eat the last imgui frame, it might've been partially rendered by the caller.
ImGui::NewFrame();
const float logo_width = static_cast<float>(APP_ICON_WIDTH) * scale;
const float logo_height = static_cast<float>(APP_ICON_HEIGHT) * scale;
ImGui::SetNextWindowSize(ImVec2(logo_width, logo_height), ImGuiCond_Always);
ImGui::SetNextWindowPos(ImVec2(io.DisplaySize.x * 0.5f, (io.DisplaySize.y * 0.5f) - (50.0f * scale)),
ImGuiCond_Always, ImVec2(0.5f, 0.5f));
if (ImGui::Begin("LoadingScreenLogo", nullptr,
ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoInputs | ImGuiWindowFlags_NoMove |
ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoNav |
ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoFocusOnAppearing |
ImGuiWindowFlags_NoBackground))
{
if (m_logo_texture)
ImGui::Image(m_logo_texture->GetHandle(), ImVec2(logo_width, logo_height));
}
ImGui::End();
ImGui::SetNextWindowSize(ImVec2(width, (has_progress ? 50.0f : 30.0f) * scale), ImGuiCond_Always);
ImGui::SetNextWindowPos(ImVec2(io.DisplaySize.x * 0.5f, (io.DisplaySize.y * 0.5f) + (100.0f * scale)),
ImGuiCond_Always, ImVec2(0.5f, 0.0f));
if (ImGui::Begin("LoadingScreen", nullptr,
ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoInputs | ImGuiWindowFlags_NoMove |
ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoNav |
ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoFocusOnAppearing))
{
if (has_progress)
{
ImGui::Text("%s: %d/%d", message, progress_value, progress_max);
ImGui::ProgressBar(static_cast<float>(progress_value) / static_cast<float>(progress_max - progress_min),
ImVec2(-1.0f, 0.0f), "");
Log_InfoPrintf("%s: %d/%d", message, progress_value, progress_max);
}
else
{
const ImVec2 text_size(ImGui::CalcTextSize(message));
ImGui::SetCursorPosX((width - text_size.x) / 2.0f);
ImGui::TextUnformatted(message);
Log_InfoPrintf("%s", message);
}
}
ImGui::End();
ImGui::EndFrame();
m_display->Render();
}
void CommonHostInterface::GetGameInfo(const char* path, CDImage* image, std::string* code, std::string* title)
{
const GameListEntry* list_entry = m_game_list->GetEntryForPath(path);
if (list_entry)
{
*code = list_entry->code;
*title = list_entry->title;
}
else
{
if (image)
*code = System::GetGameCodeForImage(image, true);
const GameListDatabaseEntry* db_entry = (!code->empty()) ? m_game_list->GetDatabaseEntryForCode(*code) : nullptr;
if (db_entry)
*title = db_entry->title;
else
*title = System::GetTitleForPath(path);
}
}
bool CommonHostInterface::SaveResumeSaveState()
{
if (System::IsShutdown())
return false;
const bool global = System::GetRunningCode().empty();
return SaveState(global, -1);
}
bool CommonHostInterface::IsDumpingAudio() const
{
return g_spu.IsDumpingAudio();
}
bool CommonHostInterface::StartDumpingAudio(const char* filename)
{
if (System::IsShutdown())
return false;
std::string auto_filename;
if (!filename)
{
const auto& code = System::GetRunningCode();
if (code.empty())
{
auto_filename = GetUserDirectoryRelativePath("dump/audio/%s.wav", GetTimestampStringForFileName().GetCharArray());
}
else
{
auto_filename = GetUserDirectoryRelativePath("dump/audio/%s_%s.wav", code.c_str(),
GetTimestampStringForFileName().GetCharArray());
}
filename = auto_filename.c_str();
}
if (g_spu.StartDumpingAudio(filename))
{
AddFormattedOSDMessage(5.0f, TranslateString("OSDMessage", "Started dumping audio to '%s'."), filename);
return true;
}
else
{
AddFormattedOSDMessage(10.0f, TranslateString("OSDMessage", "Failed to start dumping audio to '%s'."), filename);
return false;
}
}
void CommonHostInterface::StopDumpingAudio()
{
if (System::IsShutdown() || !g_spu.StopDumpingAudio())
return;
AddOSDMessage(TranslateStdString("OSDMessage", "Stopped dumping audio."), 5.0f);
}
bool CommonHostInterface::SaveScreenshot(const char* filename /* = nullptr */, bool full_resolution /* = true */,
bool apply_aspect_ratio /* = true */, bool compress_on_thread /* = true */)
{
if (System::IsShutdown())
return false;
std::string auto_filename;
if (!filename)
{
const auto& code = System::GetRunningCode();
const char* extension = "png";
if (code.empty())
{
auto_filename = GetUserDirectoryRelativePath("screenshots" FS_OSPATH_SEPARATOR_STR "%s.%s",
GetTimestampStringForFileName().GetCharArray(), extension);
}
else
{
auto_filename = GetUserDirectoryRelativePath("screenshots" FS_OSPATH_SEPARATOR_STR "%s_%s.%s", code.c_str(),
GetTimestampStringForFileName().GetCharArray(), extension);
}
filename = auto_filename.c_str();
}
if (FileSystem::FileExists(filename))
{
AddFormattedOSDMessage(10.0f, TranslateString("OSDMessage", "Screenshot file '%s' already exists."), filename);
return false;
}
const bool internal_resolution = GetBoolSettingValue("Display", "InternalResolutionScreenshots", false);
const bool screenshot_saved =
internal_resolution ?
m_display->WriteDisplayTextureToFile(filename, full_resolution, apply_aspect_ratio, compress_on_thread) :
m_display->WriteScreenshotToFile(filename, compress_on_thread);
if (!screenshot_saved)
{
AddFormattedOSDMessage(10.0f, TranslateString("OSDMessage", "Failed to save screenshot to '%s'"), filename);
return false;
}
AddFormattedOSDMessage(5.0f, TranslateString("OSDMessage", "Screenshot saved to '%s'."), filename);
return true;
}
void CommonHostInterface::ApplyGameSettings(bool display_osd_messages)
{
// this gets called while booting, so can't use valid
if (System::IsShutdown() || System::GetRunningCode().empty() || !g_settings.apply_game_settings)
return;
const GameSettings::Entry* gs = m_game_list->GetGameSettings(System::GetRunningPath(), System::GetRunningCode());
if (gs)
gs->ApplySettings(display_osd_messages);
}
bool CommonHostInterface::UpdateControllerInputMapFromGameSettings()
{
// this gets called while booting, so can't use valid
if (System::IsShutdown() || System::GetRunningCode().empty() || !g_settings.apply_game_settings)
return false;
const GameSettings::Entry* gs = m_game_list->GetGameSettings(System::GetRunningPath(), System::GetRunningCode());
if (!gs || gs->input_profile_name.empty())
return false;
std::string path = GetInputProfilePath(gs->input_profile_name.c_str());
if (path.empty())
{
AddFormattedOSDMessage(10.0f, TranslateString("OSDMessage", "Input profile '%s' cannot be found."),
gs->input_profile_name.c_str());
return false;
}
if (System::GetState() == System::State::Starting)
{
AddFormattedOSDMessage(5.0f, TranslateString("OSDMessage", "Using input profile '%s'."),
gs->input_profile_name.c_str());
}
INISettingsInterface si(std::move(path));
UpdateControllerInputMap(si);
return true;
}
std::string CommonHostInterface::GetCheatFileName() const
{
const std::string& title = System::GetRunningTitle();
if (title.empty())
return {};
return GetUserDirectoryRelativePath("cheats/%s.cht", title.c_str());
}
bool CommonHostInterface::LoadCheatList(const char* filename)
{
if (System::IsShutdown())
return false;
std::unique_ptr<CheatList> cl = std::make_unique<CheatList>();
if (!cl->LoadFromFile(filename, CheatList::Format::Autodetect))
{
AddFormattedOSDMessage(15.0f, TranslateString("OSDMessage", "Failed to load cheats from '%s'."), filename);
return false;
}
AddOSDMessage(TranslateStdString("OSDMessage", "Loaded %n cheats from list.", "", cl->GetCodeCount()) +
TranslateStdString("OSDMessage", " %n cheats are enabled.", "", cl->GetEnabledCodeCount()),
10.0f);
System::SetCheatList(std::move(cl));
return true;
}
bool CommonHostInterface::LoadCheatListFromGameTitle()
{
if (IsCheevosChallengeModeActive())
return false;
const std::string filename(GetCheatFileName());
if (filename.empty() || !FileSystem::FileExists(filename.c_str()))
return false;
return LoadCheatList(filename.c_str());
}
bool CommonHostInterface::LoadCheatListFromDatabase()
{
if (System::GetRunningCode().empty() || IsCheevosChallengeModeActive())
return false;
std::unique_ptr<CheatList> cl = std::make_unique<CheatList>();
if (!cl->LoadFromPackage(System::GetRunningCode()))
return false;
AddOSDMessage(TranslateStdString("OSDMessage", "Loaded %n cheats from database.", "", cl->GetCodeCount()), 10.0f);
System::SetCheatList(std::move(cl));
return true;
}
bool CommonHostInterface::SaveCheatList()
{
if (!System::IsValid() || !System::HasCheatList())
return false;
const std::string filename(GetCheatFileName());
if (filename.empty())
return false;
if (!System::GetCheatList()->SaveToPCSXRFile(filename.c_str()))
{
AddFormattedOSDMessage(15.0f, TranslateString("OSDMessage", "Failed to save cheat list to '%s'"), filename.c_str());
}
return true;
}
bool CommonHostInterface::SaveCheatList(const char* filename)
{
if (!System::IsValid() || !System::HasCheatList())
return false;
if (!System::GetCheatList()->SaveToPCSXRFile(filename))
return false;
// This shouldn't be needed, but lupdate doesn't gather this string otherwise...
const u32 code_count = System::GetCheatList()->GetCodeCount();
AddFormattedOSDMessage(5.0f, TranslateString("OSDMessage", "Saved %n cheats to '%s'.", "", code_count), filename);
return true;
}
bool CommonHostInterface::DeleteCheatList()
{
if (!System::IsValid())
return false;
const std::string filename(GetCheatFileName());
if (!filename.empty())
{
if (!FileSystem::DeleteFile(filename.c_str()))
return false;
AddFormattedOSDMessage(5.0f, TranslateString("OSDMessage", "Deleted cheat list '%s'."), filename.c_str());
}
System::SetCheatList(nullptr);
return true;
}
void CommonHostInterface::ClearCheatList(bool save_to_file)
{
if (!System::IsValid())
return;
CheatList* cl = System::GetCheatList();
if (!cl)
return;
while (cl->GetCodeCount() > 0)
cl->RemoveCode(cl->GetCodeCount() - 1);
if (save_to_file)
SaveCheatList();
}
void CommonHostInterface::SetCheatCodeState(u32 index, bool enabled, bool save_to_file)
{
if (!System::IsValid() || !System::HasCheatList())
return;
CheatList* cl = System::GetCheatList();
if (index >= cl->GetCodeCount())
return;
CheatCode& cc = cl->GetCode(index);
if (cc.enabled == enabled)
return;
cc.enabled = enabled;
if (enabled)
{
AddFormattedOSDMessage(5.0f, TranslateString("OSDMessage", "Cheat '%s' enabled."), cc.description.c_str());
}
else
{
AddFormattedOSDMessage(5.0f, TranslateString("OSDMessage", "Cheat '%s' disabled."), cc.description.c_str());
}
if (save_to_file)
SaveCheatList();
}
void CommonHostInterface::ApplyCheatCode(u32 index)
{
if (!System::HasCheatList() || index >= System::GetCheatList()->GetCodeCount())
return;
const CheatCode& cc = System::GetCheatList()->GetCode(index);
if (!cc.enabled)
{
cc.Apply();
AddFormattedOSDMessage(5.0f, TranslateString("OSDMessage", "Applied cheat '%s'."), cc.description.c_str());
}
else
{
AddFormattedOSDMessage(5.0f, TranslateString("OSDMessage", "Cheat '%s' is already enabled."),
cc.description.c_str());
}
}
void CommonHostInterface::TogglePostProcessing()
{
if (!m_display)
return;
g_settings.display_post_processing = !g_settings.display_post_processing;
if (g_settings.display_post_processing)
{
AddOSDMessage(TranslateStdString("OSDMessage", "Post-processing is now enabled."), 10.0f);
if (!m_display->SetPostProcessingChain(g_settings.display_post_process_chain))
AddOSDMessage(TranslateStdString("OSDMessage", "Failed to load post processing shader chain."), 20.0f);
}
else
{
AddOSDMessage(TranslateStdString("OSDMessage", "Post-processing is now disabled."), 10.0f);
m_display->SetPostProcessingChain({});
}
}
void CommonHostInterface::ReloadPostProcessingShaders()
{
if (!m_display || !g_settings.display_post_processing)
return;
if (!m_display->SetPostProcessingChain(g_settings.display_post_process_chain))
AddOSDMessage(TranslateStdString("OSDMessage", "Failed to load post-processing shader chain."), 20.0f);
else
AddOSDMessage(TranslateStdString("OSDMessage", "Post-processing shaders reloaded."), 10.0f);
}
bool CommonHostInterface::ParseFullscreenMode(const std::string_view& mode, u32* width, u32* height,
float* refresh_rate)
{
if (!mode.empty())
{
std::string_view::size_type sep1 = mode.find('x');
if (sep1 != std::string_view::npos)
{
std::optional<u32> owidth = StringUtil::FromChars<u32>(mode.substr(0, sep1));
sep1++;
while (sep1 < mode.length() && std::isspace(mode[sep1]))
sep1++;
if (owidth.has_value() && sep1 < mode.length())
{
std::string_view::size_type sep2 = mode.find('@', sep1);
if (sep2 != std::string_view::npos)
{
std::optional<u32> oheight = StringUtil::FromChars<u32>(mode.substr(sep1, sep2 - sep1));
sep2++;
while (sep2 < mode.length() && std::isspace(mode[sep2]))
sep2++;
if (oheight.has_value() && sep2 < mode.length())
{
std::optional<float> orefresh_rate = StringUtil::FromChars<float>(mode.substr(sep2));
if (orefresh_rate.has_value())
{
*width = owidth.value();
*height = oheight.value();
*refresh_rate = orefresh_rate.value();
return true;
}
}
}
}
}
}
*width = 0;
*height = 0;
*refresh_rate = 0;
return false;
}
std::string CommonHostInterface::GetFullscreenModeString(u32 width, u32 height, float refresh_rate)
{
return StringUtil::StdStringFromFormat("%u x %u @ %f hz", width, height, refresh_rate);
}
bool CommonHostInterface::RequestRenderWindowSize(s32 new_window_width, s32 new_window_height)
{
return false;
}
bool CommonHostInterface::RequestRenderWindowScale(float scale)
{
if (!System::IsValid() || scale == 0)
return false;
const float y_scale =
(static_cast<float>(m_display->GetDisplayWidth()) / static_cast<float>(m_display->GetDisplayHeight())) /
m_display->GetDisplayAspectRatio();
const u32 requested_width =
std::max<u32>(static_cast<u32>(std::ceil(static_cast<float>(m_display->GetDisplayWidth()) * scale)), 1);
const u32 requested_height =
std::max<u32>(static_cast<u32>(std::ceil(static_cast<float>(m_display->GetDisplayHeight()) * y_scale * scale)), 1);
return RequestRenderWindowSize(static_cast<s32>(requested_width), static_cast<s32>(requested_height));
}
void* CommonHostInterface::GetTopLevelWindowHandle() const
{
return nullptr;
}
std::unique_ptr<ByteStream> CommonHostInterface::OpenPackageFile(const char* path, u32 flags)
{
const u32 allowed_flags = (BYTESTREAM_OPEN_READ | BYTESTREAM_OPEN_SEEKABLE | BYTESTREAM_OPEN_STREAMED);
const std::string full_path(
StringUtil::StdStringFromFormat("%s" FS_OSPATH_SEPARATOR_STR "%s", m_program_directory.c_str(), path));
const u32 real_flags = (flags & allowed_flags) | BYTESTREAM_OPEN_READ;
Log_DevPrintf("Requesting package file '%s'", path);
return FileSystem::OpenFile(full_path.c_str(), real_flags);
}
bool CommonHostInterface::SetControllerNavigationButtonState(FrontendCommon::ControllerNavigationButton button,
bool pressed)
{
if (!m_fullscreen_ui_enabled)
return false;
return FullscreenUI::SetControllerNavInput(button, pressed);
}
#ifdef WITH_DISCORD_PRESENCE
void CommonHostInterface::SetDiscordPresenceEnabled(bool enabled)
{
if (m_discord_presence_enabled == enabled)
return;
m_discord_presence_enabled = enabled;
if (enabled)
InitializeDiscordPresence();
else
ShutdownDiscordPresence();
}
void CommonHostInterface::InitializeDiscordPresence()
{
if (m_discord_presence_active)
return;
DiscordEventHandlers handlers = {};
Discord_Initialize("705325712680288296", &handlers, 0, nullptr);
m_discord_presence_active = true;
UpdateDiscordPresence();
}
void CommonHostInterface::ShutdownDiscordPresence()
{
if (!m_discord_presence_active)
return;
Discord_ClearPresence();
Discord_Shutdown();
m_discord_presence_active = false;
}
void CommonHostInterface::UpdateDiscordPresence()
{
if (!m_discord_presence_active)
return;
// https://discord.com/developers/docs/rich-presence/how-to#updating-presence-update-presence-payload-fields
DiscordRichPresence rp = {};
rp.largeImageKey = "duckstation_logo";
rp.largeImageText = "DuckStation PS1/PSX Emulator";
rp.startTimestamp = std::time(nullptr);
SmallString details_string;
if (!System::IsShutdown())
{
details_string.AppendFormattedString("%s (%s)", System::GetRunningTitle().c_str(),
System::GetRunningCode().c_str());
}
else
{
details_string.AppendString("No Game Running");
}
rp.details = details_string;
Discord_UpdatePresence(&rp);
}
void CommonHostInterface::PollDiscordPresence()
{
if (!m_discord_presence_active)
return;
Discord_RunCallbacks();
}
#endif
#ifdef WITH_CHEEVOS
void CommonHostInterface::UpdateCheevosActive()
{
const bool cheevos_enabled = GetBoolSettingValue("Cheevos", "Enabled", false);
const bool cheevos_test_mode = GetBoolSettingValue("Cheevos", "TestMode", false);
const bool cheevos_use_first_disc_from_playlist = GetBoolSettingValue("Cheevos", "UseFirstDiscFromPlaylist", true);
const bool cheevos_rich_presence = GetBoolSettingValue("Cheevos", "RichPresence", true);
const bool cheevos_hardcore = GetBoolSettingValue("Cheevos", "ChallengeMode", false);
if (cheevos_enabled != Cheevos::IsActive() || cheevos_test_mode != Cheevos::IsTestModeActive() ||
cheevos_use_first_disc_from_playlist != Cheevos::IsUsingFirstDiscFromPlaylist() ||
cheevos_rich_presence != Cheevos::IsRichPresenceEnabled() ||
cheevos_hardcore != Cheevos::IsChallengeModeEnabled())
{
Cheevos::Shutdown();
if (cheevos_enabled)
{
if (!Cheevos::Initialize(cheevos_test_mode, cheevos_use_first_disc_from_playlist, cheevos_rich_presence,
cheevos_hardcore))
ReportError("Failed to initialize cheevos after settings change.");
}
}
}
#endif
Reference in a new issue View git blame Copy permalink