mirror of
https://github.com/dolphin-emu/dolphin.git
synced 2026-11-18 01:38:08 -06:00
356 lines
8.7 KiB
C++
356 lines
8.7 KiB
C++
// Copyright 2026 Dolphin Emulator Project
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
#include "jni/HotkeyScheduler.h"
|
|
|
|
#include <chrono>
|
|
#include <cmath>
|
|
#include <jni.h>
|
|
#include <thread>
|
|
#include <vector>
|
|
|
|
#include <fmt/format.h>
|
|
|
|
#include "AudioCommon/AudioCommon.h"
|
|
#include "Common/CommonTypes.h"
|
|
#include "Common/Config/Config.h"
|
|
#include "Common/Event.h"
|
|
#include "Common/Flag.h"
|
|
#include "Common/Thread.h"
|
|
#include "Core/Config/GraphicsSettings.h"
|
|
#include "Core/Config/MainSettings.h"
|
|
#include "Core/Core.h"
|
|
#include "Core/HotkeyManager.h"
|
|
#include "Core/State.h"
|
|
#include "Core/System.h"
|
|
#include "InputCommon/ControlReference/ControlReference.h"
|
|
#include "InputCommon/ControllerEmu/Control/Control.h"
|
|
#include "InputCommon/ControllerEmu/ControlGroup/ControlGroup.h"
|
|
#include "InputCommon/ControllerInterface/ControllerInterface.h"
|
|
#include "VideoCommon/OnScreenDisplay.h"
|
|
#include "VideoCommon/VideoConfig.h"
|
|
|
|
namespace HotkeyScheduler
|
|
{
|
|
namespace
|
|
{
|
|
constexpr int POLL_INTERVAL_MS = 5;
|
|
|
|
std::thread s_thread;
|
|
Common::Flag s_stop_requested;
|
|
Common::Flag s_any_hotkey_set;
|
|
Common::Event s_wakeup;
|
|
|
|
bool IsHotkey(int id, bool held = false)
|
|
{
|
|
return HotkeyManagerEmu::IsPressed(id, held);
|
|
}
|
|
|
|
bool IsAnyHotkeySet()
|
|
{
|
|
InputConfig* const config = HotkeyManagerEmu::GetConfig();
|
|
if (config == nullptr || config->ControllersNeedToBeCreated())
|
|
return false;
|
|
|
|
auto* const hotkeys = static_cast<HotkeyManager*>(config->GetController(0));
|
|
|
|
for (const int hotkey : GetSupportedHotkeys())
|
|
{
|
|
const int group = hotkeys->FindGroupByID(hotkey);
|
|
const int index = hotkeys->GetIndexForGroup(group, hotkey);
|
|
const auto* const control_group =
|
|
HotkeyManagerEmu::GetHotkeyGroup(static_cast<HotkeyGroup>(group));
|
|
|
|
if (!control_group->controls[index]->control_ref->GetExpression().empty())
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool ShouldPoll()
|
|
{
|
|
if (!s_any_hotkey_set.IsSet() || !HotkeyManagerEmu::IsEnabled())
|
|
return false;
|
|
|
|
return Core::GetState(Core::System::GetInstance()) != Core::State::Stopping;
|
|
}
|
|
|
|
// Buttons already held when polling resumes must not count as new presses
|
|
void ConsumePendingPresses()
|
|
{
|
|
for (const int hotkey : GetSupportedHotkeys())
|
|
IsHotkey(hotkey);
|
|
}
|
|
|
|
void ShowVolumeOSD()
|
|
{
|
|
OSD::AddMessage(
|
|
fmt::format("Volume: {}", Config::Get(Config::MAIN_AUDIO_MUTED) ?
|
|
"Muted" :
|
|
fmt::format("{}%", Config::Get(Config::MAIN_AUDIO_VOLUME))));
|
|
}
|
|
|
|
void ShowEmulationSpeedOSD()
|
|
{
|
|
const float emulation_speed = Config::Get(Config::MAIN_EMULATION_SPEED);
|
|
OSD::AddMessage(emulation_speed <= 0 ?
|
|
"Speed Limit: Unlimited" :
|
|
fmt::format("Speed Limit: {}%", std::lround(emulation_speed * 100.f)));
|
|
}
|
|
|
|
void ShowInternalResolutionOSD(int new_efb_scale)
|
|
{
|
|
switch (new_efb_scale)
|
|
{
|
|
case EFB_SCALE_AUTO_INTEGRAL:
|
|
OSD::AddMessage("Internal Resolution: Auto (integral)");
|
|
break;
|
|
case 1:
|
|
OSD::AddMessage("Internal Resolution: Native");
|
|
break;
|
|
default:
|
|
OSD::AddMessage(fmt::format("Internal Resolution: {}x", new_efb_scale));
|
|
break;
|
|
}
|
|
}
|
|
|
|
void HandleGeneralHotkeys()
|
|
{
|
|
// TODO: add support for more general hotkeys
|
|
if (IsHotkey(HK_SCREENSHOT))
|
|
Core::SaveScreenShot();
|
|
}
|
|
|
|
void HandleEmulationSpeedHotkeys()
|
|
{
|
|
if (IsHotkey(HK_TOGGLE_THROTTLE))
|
|
Core::SetIsThrottlerTempDisabled(!Core::GetIsThrottlerTempDisabled());
|
|
|
|
if (IsHotkey(HK_DECREASE_EMULATION_SPEED))
|
|
{
|
|
auto speed = Config::Get(Config::MAIN_EMULATION_SPEED) - 0.1;
|
|
if (speed > 0)
|
|
{
|
|
speed = (speed >= 0.95 && speed <= 1.05) ? 1.0 : speed;
|
|
Config::SetCurrent(Config::MAIN_EMULATION_SPEED, speed);
|
|
}
|
|
ShowEmulationSpeedOSD();
|
|
}
|
|
|
|
if (IsHotkey(HK_INCREASE_EMULATION_SPEED))
|
|
{
|
|
auto speed = Config::Get(Config::MAIN_EMULATION_SPEED) + 0.1;
|
|
speed = (speed >= 0.95 && speed <= 1.05) ? 1.0 : speed;
|
|
Config::SetCurrent(Config::MAIN_EMULATION_SPEED, speed);
|
|
ShowEmulationSpeedOSD();
|
|
}
|
|
}
|
|
|
|
void HandleVolumeHotkeys(Core::System& system)
|
|
{
|
|
if (IsHotkey(HK_VOLUME_DOWN))
|
|
{
|
|
AudioCommon::DecreaseVolume(system, 3);
|
|
ShowVolumeOSD();
|
|
}
|
|
|
|
if (IsHotkey(HK_VOLUME_UP))
|
|
{
|
|
AudioCommon::IncreaseVolume(system, 3);
|
|
ShowVolumeOSD();
|
|
}
|
|
|
|
if (IsHotkey(HK_VOLUME_TOGGLE_MUTE))
|
|
{
|
|
AudioCommon::ToggleMuteVolume(system);
|
|
ShowVolumeOSD();
|
|
}
|
|
}
|
|
|
|
void HandleGraphicsHotkeys()
|
|
{
|
|
const auto efb_scale = Config::Get(Config::GFX_EFB_SCALE);
|
|
|
|
if (IsHotkey(HK_INCREASE_IR))
|
|
{
|
|
Config::SetCurrent(Config::GFX_EFB_SCALE, efb_scale + 1);
|
|
ShowInternalResolutionOSD(efb_scale + 1);
|
|
}
|
|
if (IsHotkey(HK_DECREASE_IR))
|
|
{
|
|
if (efb_scale > EFB_SCALE_AUTO_INTEGRAL)
|
|
{
|
|
Config::SetCurrent(Config::GFX_EFB_SCALE, efb_scale - 1);
|
|
ShowInternalResolutionOSD(efb_scale - 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
void HandleStateHotkeys(Core::System& system)
|
|
{
|
|
for (u32 i = 0; i < State::NUM_STATES; ++i)
|
|
{
|
|
if (IsHotkey(HK_LOAD_STATE_SLOT_1 + i))
|
|
State::Load(system, i + 1);
|
|
|
|
if (IsHotkey(HK_SAVE_STATE_SLOT_1 + i))
|
|
State::Save(system, i + 1);
|
|
|
|
if (IsHotkey(HK_LOAD_LAST_STATE_1 + i))
|
|
State::LoadLastSaved(system, i + 1);
|
|
|
|
if (IsHotkey(HK_SELECT_STATE_SLOT_1 + i))
|
|
State::SelectSlot(i + 1);
|
|
}
|
|
|
|
if (IsHotkey(HK_SAVE_STATE_SLOT_SELECTED))
|
|
State::SaveSelected(system);
|
|
|
|
if (IsHotkey(HK_LOAD_STATE_SLOT_SELECTED))
|
|
State::LoadSelected(system);
|
|
|
|
if (IsHotkey(HK_INCREMENT_SELECTED_STATE_SLOT))
|
|
State::SelectSlot(State::GetNextSlot());
|
|
|
|
if (IsHotkey(HK_DECREMENT_SELECTED_STATE_SLOT))
|
|
State::SelectSlot(State::GetPreviousSlot());
|
|
|
|
if (IsHotkey(HK_SAVE_FIRST_STATE))
|
|
State::SaveFirstSaved(system);
|
|
|
|
if (IsHotkey(HK_UNDO_LOAD_STATE))
|
|
State::UndoLoadState(system);
|
|
|
|
if (IsHotkey(HK_UNDO_SAVE_STATE))
|
|
State::UndoSaveState(system);
|
|
}
|
|
|
|
void Run()
|
|
{
|
|
Common::SetCurrentThreadName("HotkeyScheduler");
|
|
|
|
bool was_polling = false;
|
|
|
|
while (!s_stop_requested.IsSet())
|
|
{
|
|
if (!ShouldPoll())
|
|
{
|
|
was_polling = false;
|
|
s_wakeup.Wait();
|
|
continue;
|
|
}
|
|
|
|
s_wakeup.WaitFor(std::chrono::milliseconds(POLL_INTERVAL_MS));
|
|
|
|
if (s_stop_requested.IsSet())
|
|
break;
|
|
|
|
ControllerInterface::SetCurrentInputChannel(ciface::InputChannel::Host);
|
|
g_controller_interface.UpdateInput();
|
|
|
|
ControlReference::SetInputGate(true);
|
|
|
|
// These two cover disjoint sets of groups, see HotkeyManager::GetInput.
|
|
// Skipping either one leaves half the groups reading as unpressed.
|
|
HotkeyManagerEmu::GetStatus(false);
|
|
HotkeyManagerEmu::GetStatus(true);
|
|
|
|
if (!was_polling)
|
|
{
|
|
ConsumePendingPresses();
|
|
was_polling = true;
|
|
continue;
|
|
}
|
|
|
|
Core::System& system = Core::System::GetInstance();
|
|
|
|
HandleGeneralHotkeys();
|
|
HandleEmulationSpeedHotkeys();
|
|
HandleVolumeHotkeys(system);
|
|
HandleGraphicsHotkeys();
|
|
HandleStateHotkeys(system);
|
|
}
|
|
}
|
|
} // namespace
|
|
|
|
void Start()
|
|
{
|
|
if (s_thread.joinable())
|
|
return;
|
|
|
|
State::SetSelectedSlot(1);
|
|
s_any_hotkey_set.Set(IsAnyHotkeySet());
|
|
s_stop_requested.Clear();
|
|
s_wakeup.Reset();
|
|
s_thread = std::thread(Run);
|
|
}
|
|
|
|
void Stop()
|
|
{
|
|
if (!s_thread.joinable())
|
|
return;
|
|
|
|
s_stop_requested.Set();
|
|
s_wakeup.Set();
|
|
s_thread.join();
|
|
|
|
Core::SetIsThrottlerTempDisabled(false);
|
|
}
|
|
|
|
void RefreshActiveHotkeys()
|
|
{
|
|
s_any_hotkey_set.Set(IsAnyHotkeySet());
|
|
s_wakeup.Set();
|
|
}
|
|
|
|
const std::vector<int>& GetSupportedHotkeys()
|
|
{
|
|
static const std::vector<int> supported = [] {
|
|
std::vector<int> hotkeys{
|
|
// General - only the one entry, see HandleGeneralHotkeys
|
|
HK_SCREENSHOT,
|
|
// Emulation Speed
|
|
HK_TOGGLE_THROTTLE,
|
|
HK_DECREASE_EMULATION_SPEED,
|
|
HK_INCREASE_EMULATION_SPEED,
|
|
// Volume
|
|
HK_VOLUME_DOWN,
|
|
HK_VOLUME_UP,
|
|
HK_VOLUME_TOGGLE_MUTE,
|
|
// Internal Resolution
|
|
HK_INCREASE_IR,
|
|
HK_DECREASE_IR,
|
|
};
|
|
|
|
hotkeys.insert(hotkeys.end(),
|
|
{HK_SAVE_STATE_SLOT_SELECTED, HK_LOAD_STATE_SLOT_SELECTED,
|
|
HK_INCREMENT_SELECTED_STATE_SLOT, HK_DECREMENT_SELECTED_STATE_SLOT,
|
|
HK_SAVE_FIRST_STATE, HK_UNDO_LOAD_STATE, HK_UNDO_SAVE_STATE});
|
|
|
|
for (u32 i = 0; i < State::NUM_STATES; ++i)
|
|
hotkeys.push_back(HK_SAVE_STATE_SLOT_1 + i);
|
|
for (u32 i = 0; i < State::NUM_STATES; ++i)
|
|
hotkeys.push_back(HK_LOAD_STATE_SLOT_1 + i);
|
|
for (u32 i = 0; i < State::NUM_STATES; ++i)
|
|
hotkeys.push_back(HK_SELECT_STATE_SLOT_1 + i);
|
|
for (u32 i = 0; i < State::NUM_STATES; ++i)
|
|
hotkeys.push_back(HK_LOAD_LAST_STATE_1 + i);
|
|
|
|
return hotkeys;
|
|
}();
|
|
|
|
return supported;
|
|
}
|
|
} // namespace HotkeyScheduler
|
|
|
|
extern "C" {
|
|
|
|
JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_features_input_model_Hotkeys_setEnabled(
|
|
JNIEnv*, jclass, jboolean enabled)
|
|
{
|
|
HotkeyManagerEmu::Enable(enabled == JNI_TRUE);
|
|
HotkeyScheduler::RefreshActiveHotkeys();
|
|
}
|
|
}
|