yuzu/src/input_common/input_engine.cpp

369 lines
13 KiB
C++
Raw Normal View History

// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
2021-09-20 23:34:05 +02:00
#include "common/logging/log.h"
#include "input_common/input_engine.h"
namespace InputCommon {
void InputEngine::PreSetController(const PadIdentifier& identifier) {
std::scoped_lock lock{mutex};
controller_list.try_emplace(identifier);
2021-09-20 23:34:05 +02:00
}
void InputEngine::PreSetButton(const PadIdentifier& identifier, int button) {
std::scoped_lock lock{mutex};
2021-09-20 23:34:05 +02:00
ControllerData& controller = controller_list.at(identifier);
controller.buttons.try_emplace(button, false);
2021-09-20 23:34:05 +02:00
}
void InputEngine::PreSetHatButton(const PadIdentifier& identifier, int button) {
std::scoped_lock lock{mutex};
2021-09-20 23:34:05 +02:00
ControllerData& controller = controller_list.at(identifier);
controller.hat_buttons.try_emplace(button, u8{0});
2021-09-20 23:34:05 +02:00
}
void InputEngine::PreSetAxis(const PadIdentifier& identifier, int axis) {
std::scoped_lock lock{mutex};
2021-09-20 23:34:05 +02:00
ControllerData& controller = controller_list.at(identifier);
controller.axes.try_emplace(axis, 0.0f);
2021-09-20 23:34:05 +02:00
}
void InputEngine::PreSetMotion(const PadIdentifier& identifier, int motion) {
std::scoped_lock lock{mutex};
2021-09-20 23:34:05 +02:00
ControllerData& controller = controller_list.at(identifier);
controller.motions.try_emplace(motion);
2021-09-20 23:34:05 +02:00
}
void InputEngine::SetButton(const PadIdentifier& identifier, int button, bool value) {
{
std::scoped_lock lock{mutex};
2021-09-20 23:34:05 +02:00
ControllerData& controller = controller_list.at(identifier);
if (!configuring) {
controller.buttons.insert_or_assign(button, value);
}
}
TriggerOnButtonChange(identifier, button, value);
}
void InputEngine::SetHatButton(const PadIdentifier& identifier, int button, u8 value) {
{
std::scoped_lock lock{mutex};
2021-09-20 23:34:05 +02:00
ControllerData& controller = controller_list.at(identifier);
if (!configuring) {
controller.hat_buttons.insert_or_assign(button, value);
}
}
TriggerOnHatButtonChange(identifier, button, value);
}
void InputEngine::SetAxis(const PadIdentifier& identifier, int axis, f32 value) {
{
std::scoped_lock lock{mutex};
2021-09-20 23:34:05 +02:00
ControllerData& controller = controller_list.at(identifier);
if (!configuring) {
controller.axes.insert_or_assign(axis, value);
}
}
TriggerOnAxisChange(identifier, axis, value);
}
void InputEngine::SetBattery(const PadIdentifier& identifier, Common::Input::BatteryLevel value) {
2021-09-20 23:34:05 +02:00
{
std::scoped_lock lock{mutex};
2021-09-20 23:34:05 +02:00
ControllerData& controller = controller_list.at(identifier);
if (!configuring) {
controller.battery = value;
}
}
TriggerOnBatteryChange(identifier, value);
}
void InputEngine::SetMotion(const PadIdentifier& identifier, int motion, const BasicMotion& value) {
2021-09-20 23:34:05 +02:00
{
std::scoped_lock lock{mutex};
2021-09-20 23:34:05 +02:00
ControllerData& controller = controller_list.at(identifier);
if (!configuring) {
controller.motions.insert_or_assign(motion, value);
}
}
TriggerOnMotionChange(identifier, motion, value);
}
bool InputEngine::GetButton(const PadIdentifier& identifier, int button) const {
std::scoped_lock lock{mutex};
const auto controller_iter = controller_list.find(identifier);
if (controller_iter == controller_list.cend()) {
LOG_ERROR(Input, "Invalid identifier guid={}, pad={}, port={}", identifier.guid.RawString(),
2021-09-20 23:34:05 +02:00
identifier.pad, identifier.port);
return false;
}
const ControllerData& controller = controller_iter->second;
const auto button_iter = controller.buttons.find(button);
if (button_iter == controller.buttons.cend()) {
2021-09-20 23:34:05 +02:00
LOG_ERROR(Input, "Invalid button {}", button);
return false;
}
return button_iter->second;
2021-09-20 23:34:05 +02:00
}
bool InputEngine::GetHatButton(const PadIdentifier& identifier, int button, u8 direction) const {
std::scoped_lock lock{mutex};
const auto controller_iter = controller_list.find(identifier);
if (controller_iter == controller_list.cend()) {
LOG_ERROR(Input, "Invalid identifier guid={}, pad={}, port={}", identifier.guid.RawString(),
2021-09-20 23:34:05 +02:00
identifier.pad, identifier.port);
return false;
}
const ControllerData& controller = controller_iter->second;
const auto hat_iter = controller.hat_buttons.find(button);
if (hat_iter == controller.hat_buttons.cend()) {
2021-09-20 23:34:05 +02:00
LOG_ERROR(Input, "Invalid hat button {}", button);
return false;
}
return (hat_iter->second & direction) != 0;
2021-09-20 23:34:05 +02:00
}
f32 InputEngine::GetAxis(const PadIdentifier& identifier, int axis) const {
std::scoped_lock lock{mutex};
const auto controller_iter = controller_list.find(identifier);
if (controller_iter == controller_list.cend()) {
LOG_ERROR(Input, "Invalid identifier guid={}, pad={}, port={}", identifier.guid.RawString(),
2021-09-20 23:34:05 +02:00
identifier.pad, identifier.port);
return 0.0f;
}
const ControllerData& controller = controller_iter->second;
const auto axis_iter = controller.axes.find(axis);
if (axis_iter == controller.axes.cend()) {
2021-09-20 23:34:05 +02:00
LOG_ERROR(Input, "Invalid axis {}", axis);
return 0.0f;
}
return axis_iter->second;
2021-09-20 23:34:05 +02:00
}
Common::Input::BatteryLevel InputEngine::GetBattery(const PadIdentifier& identifier) const {
std::scoped_lock lock{mutex};
const auto controller_iter = controller_list.find(identifier);
if (controller_iter == controller_list.cend()) {
LOG_ERROR(Input, "Invalid identifier guid={}, pad={}, port={}", identifier.guid.RawString(),
2021-09-20 23:34:05 +02:00
identifier.pad, identifier.port);
return Common::Input::BatteryLevel::Charging;
2021-09-20 23:34:05 +02:00
}
const ControllerData& controller = controller_iter->second;
2021-09-20 23:34:05 +02:00
return controller.battery;
}
BasicMotion InputEngine::GetMotion(const PadIdentifier& identifier, int motion) const {
std::scoped_lock lock{mutex};
const auto controller_iter = controller_list.find(identifier);
if (controller_iter == controller_list.cend()) {
LOG_ERROR(Input, "Invalid identifier guid={}, pad={}, port={}", identifier.guid.RawString(),
2021-09-20 23:34:05 +02:00
identifier.pad, identifier.port);
return {};
}
const ControllerData& controller = controller_iter->second;
2021-09-20 23:34:05 +02:00
return controller.motions.at(motion);
}
void InputEngine::ResetButtonState() {
for (const auto& controller : controller_list) {
for (const auto& button : controller.second.buttons) {
2021-09-20 23:34:05 +02:00
SetButton(controller.first, button.first, false);
}
for (const auto& button : controller.second.hat_buttons) {
SetHatButton(controller.first, button.first, 0);
2021-09-20 23:34:05 +02:00
}
}
}
void InputEngine::ResetAnalogState() {
for (const auto& controller : controller_list) {
for (const auto& axis : controller.second.axes) {
2021-09-20 23:34:05 +02:00
SetAxis(controller.first, axis.first, 0.0);
}
}
}
void InputEngine::TriggerOnButtonChange(const PadIdentifier& identifier, int button, bool value) {
std::scoped_lock lock{mutex_callback};
for (const auto& poller_pair : callback_list) {
2021-09-20 23:34:05 +02:00
const InputIdentifier& poller = poller_pair.second;
if (!IsInputIdentifierEqual(poller, identifier, EngineInputType::Button, button)) {
continue;
}
if (poller.callback.on_change) {
poller.callback.on_change();
}
}
if (!configuring || !mapping_callback.on_data) {
return;
}
PreSetButton(identifier, button);
2021-09-20 23:34:05 +02:00
if (value == GetButton(identifier, button)) {
return;
}
mapping_callback.on_data(MappingData{
.engine = GetEngineName(),
.pad = identifier,
.type = EngineInputType::Button,
.index = button,
.button_value = value,
});
}
void InputEngine::TriggerOnHatButtonChange(const PadIdentifier& identifier, int button, u8 value) {
std::scoped_lock lock{mutex_callback};
for (const auto& poller_pair : callback_list) {
2021-09-20 23:34:05 +02:00
const InputIdentifier& poller = poller_pair.second;
if (!IsInputIdentifierEqual(poller, identifier, EngineInputType::HatButton, button)) {
continue;
}
if (poller.callback.on_change) {
poller.callback.on_change();
}
}
if (!configuring || !mapping_callback.on_data) {
return;
}
for (std::size_t index = 1; index < 0xff; index <<= 1) {
bool button_value = (value & index) != 0;
if (button_value == GetHatButton(identifier, button, static_cast<u8>(index))) {
continue;
}
mapping_callback.on_data(MappingData{
.engine = GetEngineName(),
.pad = identifier,
.type = EngineInputType::HatButton,
.index = button,
.hat_name = GetHatButtonName(static_cast<u8>(index)),
});
}
}
void InputEngine::TriggerOnAxisChange(const PadIdentifier& identifier, int axis, f32 value) {
std::scoped_lock lock{mutex_callback};
for (const auto& poller_pair : callback_list) {
2021-09-20 23:34:05 +02:00
const InputIdentifier& poller = poller_pair.second;
if (!IsInputIdentifierEqual(poller, identifier, EngineInputType::Analog, axis)) {
continue;
}
if (poller.callback.on_change) {
poller.callback.on_change();
}
}
if (!configuring || !mapping_callback.on_data) {
return;
}
if (std::abs(value - GetAxis(identifier, axis)) < 0.5f) {
return;
}
mapping_callback.on_data(MappingData{
.engine = GetEngineName(),
.pad = identifier,
.type = EngineInputType::Analog,
.index = axis,
.axis_value = value,
});
}
void InputEngine::TriggerOnBatteryChange(const PadIdentifier& identifier,
[[maybe_unused]] Common::Input::BatteryLevel value) {
std::scoped_lock lock{mutex_callback};
for (const auto& poller_pair : callback_list) {
2021-09-20 23:34:05 +02:00
const InputIdentifier& poller = poller_pair.second;
if (!IsInputIdentifierEqual(poller, identifier, EngineInputType::Battery, 0)) {
continue;
}
if (poller.callback.on_change) {
poller.callback.on_change();
}
}
}
void InputEngine::TriggerOnMotionChange(const PadIdentifier& identifier, int motion,
const BasicMotion& value) {
std::scoped_lock lock{mutex_callback};
for (const auto& poller_pair : callback_list) {
2021-09-20 23:34:05 +02:00
const InputIdentifier& poller = poller_pair.second;
if (!IsInputIdentifierEqual(poller, identifier, EngineInputType::Motion, motion)) {
continue;
}
if (poller.callback.on_change) {
poller.callback.on_change();
}
}
if (!configuring || !mapping_callback.on_data) {
return;
}
bool is_active = false;
if (std::abs(value.accel_x) > 1.5f || std::abs(value.accel_y) > 1.5f ||
std::abs(value.accel_z) > 1.5f) {
is_active = true;
}
if (std::abs(value.gyro_x) > 0.6f || std::abs(value.gyro_y) > 0.6f ||
std::abs(value.gyro_z) > 0.6f) {
is_active = true;
}
if (!is_active) {
2021-09-20 23:34:05 +02:00
return;
}
mapping_callback.on_data(MappingData{
.engine = GetEngineName(),
.pad = identifier,
.type = EngineInputType::Motion,
.index = motion,
.motion_value = value,
});
}
bool InputEngine::IsInputIdentifierEqual(const InputIdentifier& input_identifier,
const PadIdentifier& identifier, EngineInputType type,
int index) const {
2021-09-20 23:34:05 +02:00
if (input_identifier.type != type) {
return false;
}
if (input_identifier.index != index) {
return false;
}
if (input_identifier.identifier != identifier) {
return false;
}
return true;
}
void InputEngine::BeginConfiguration() {
configuring = true;
}
void InputEngine::EndConfiguration() {
configuring = false;
}
const std::string& InputEngine::GetEngineName() const {
return input_engine;
}
int InputEngine::SetCallback(InputIdentifier input_identifier) {
std::scoped_lock lock{mutex_callback};
callback_list.insert_or_assign(last_callback_key, std::move(input_identifier));
2021-09-20 23:34:05 +02:00
return last_callback_key++;
}
void InputEngine::SetMappingCallback(MappingCallback callback) {
std::scoped_lock lock{mutex_callback};
2021-09-20 23:34:05 +02:00
mapping_callback = std::move(callback);
}
void InputEngine::DeleteCallback(int key) {
std::scoped_lock lock{mutex_callback};
2021-11-01 21:17:53 +01:00
const auto& iterator = callback_list.find(key);
if (iterator == callback_list.end()) {
2021-09-20 23:34:05 +02:00
LOG_ERROR(Input, "Tried to delete non-existent callback {}", key);
return;
}
2021-11-01 21:17:53 +01:00
callback_list.erase(iterator);
2021-09-20 23:34:05 +02:00
}
} // namespace InputCommon