lifning
/
dolphin
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge pull request #8417 from jordan-woyak/setting-expressions 

InputCommon: Allow controller settings specified with input expresions.
This commit is contained in:
Tilka 2020-02-09 01:37:30 +00:00 committed by GitHub
parent 7fe11c9578 0a1634bedf
commit 2e2540317e
20 changed files with 315 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
Source/Core/Core/HW/WiimoteEmu/Dynamics.cpp
View File

@ -330,8 +330,7 @@ void EmulateIMUCursor(IMUCursorState* state, ControllerEmu::IMUCursor* imu_ir_gr
auto target_yaw = std::clamp(yaw, -max_yaw, max_yaw);
// Handle the "Recenter" button being pressed.
if (imu_ir_group->controls[0]->control_ref->State() >
ControllerEmu::Buttons::ACTIVATION_THRESHOLD)
if (imu_ir_group->controls[0]->control_ref->GetState<bool>())
{
state->recentered_pitch = std::asin((inv_rotation * Common::Vec3{0, 1, 0}).z);
target_yaw = 0;

4
Source/Core/DolphinQt/Config/Mapping/MappingButton.cpp
View File

@ -132,11 +132,9 @@ void MappingButton::UpdateIndicator()
if (!isActiveWindow())
return;
const auto state = m_reference->State();
QFont f = m_parent->font();
if (state > ControllerEmu::Buttons::ACTIVATION_THRESHOLD)
if (m_reference->GetState<bool>())
f.setBold(true);
setFont(f);

59
Source/Core/DolphinQt/Config/Mapping/MappingNumeric.cpp
View File

@ -4,6 +4,8 @@
#include "DolphinQt/Config/Mapping/MappingNumeric.h"
#include <limits>
#include "DolphinQt/Config/Mapping/MappingWidget.h"
#include "InputCommon/ControllerEmu/ControllerEmu.h"
@ -12,24 +14,20 @@
MappingDouble::MappingDouble(MappingWidget* parent, ControllerEmu::NumericSetting<double>* setting)
: QDoubleSpinBox(parent), m_setting(*setting)
{
setRange(m_setting.GetMinValue(), m_setting.GetMaxValue());
setDecimals(2);
setFixedWidth(WIDGET_MAX_WIDTH);
if (const auto ui_suffix = m_setting.GetUISuffix())
setSuffix(QLatin1Char{' '} + tr(ui_suffix));
if (const auto ui_description = m_setting.GetUIDescription())
setToolTip(tr(ui_description));
connect(this, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this,
[this, parent](double value) {
m_setting.SetValue(value);
ConfigChanged();
parent->SaveSettings();
});
connect(parent, &MappingWidget::ConfigChanged, this, &MappingDouble::ConfigChanged);
connect(parent, &MappingWidget::Update, this, &MappingDouble::Update);
}
// Overriding QDoubleSpinBox's fixup to set the default value when input is cleared.
@ -41,6 +39,36 @@ void MappingDouble::fixup(QString& input) const
void MappingDouble::ConfigChanged()
{
const QSignalBlocker blocker(this);
QString suffix;
if (const auto ui_suffix = m_setting.GetUISuffix())
suffix += QLatin1Char{' '} + tr(ui_suffix);
if (m_setting.IsSimpleValue())
{
setRange(m_setting.GetMinValue(), m_setting.GetMaxValue());
setButtonSymbols(ButtonSymbols::UpDownArrows);
}
else
{
constexpr auto inf = std::numeric_limits<double>::infinity();
setRange(-inf, inf);
setButtonSymbols(ButtonSymbols::NoButtons);
suffix += QString::fromUtf8(" 🎮");
}
setSuffix(suffix);
setValue(m_setting.GetValue());
}
void MappingDouble::Update()
{
if (m_setting.IsSimpleValue() || hasFocus())
return;
const QSignalBlocker blocker(this);
setValue(m_setting.GetValue());
}
@ -49,14 +77,33 @@ MappingBool::MappingBool(MappingWidget* parent, ControllerEmu::NumericSetting<bo
{
connect(this, &QCheckBox::stateChanged, this, [this, parent](int value) {
m_setting.SetValue(value != 0);
ConfigChanged();
parent->SaveSettings();
});
connect(parent, &MappingWidget::ConfigChanged, this, &MappingBool::ConfigChanged);
connect(parent, &MappingWidget::Update, this, &MappingBool::Update);
setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Ignored);
}
void MappingBool::ConfigChanged()
{
const QSignalBlocker blocker(this);
if (m_setting.IsSimpleValue())
setText({});
else
setText(QString::fromUtf8("🎮"));
setChecked(m_setting.GetValue());
}
void MappingBool::Update()
{
if (m_setting.IsSimpleValue())
return;
const QSignalBlocker blocker(this);
setChecked(m_setting.GetValue());
}

2
Source/Core/DolphinQt/Config/Mapping/MappingNumeric.h
View File

@ -21,6 +21,7 @@ private:
void fixup(QString& input) const override;
void ConfigChanged();
void Update();
ControllerEmu::NumericSetting<double>& m_setting;
};
@ -32,6 +33,7 @@ public:
private:
void ConfigChanged();
void Update();
ControllerEmu::NumericSetting<bool>& m_setting;
};

45
Source/Core/DolphinQt/Config/Mapping/MappingWidget.cpp
View File

@ -9,8 +9,8 @@
#include <QGroupBox>
#include <QLabel>
#include <QPushButton>
#include <QTimer>
#include "DolphinQt/Config/Mapping/IOWindow.h"
#include "DolphinQt/Config/Mapping/MappingButton.h"
#include "DolphinQt/Config/Mapping/MappingIndicator.h"
#include "DolphinQt/Config/Mapping/MappingNumeric.h"
@ -28,14 +28,6 @@ MappingWidget::MappingWidget(MappingWindow* parent) : m_parent(parent)
connect(parent, &MappingWindow::Update, this, &MappingWidget::Update);
connect(parent, &MappingWindow::Save, this, &MappingWidget::SaveSettings);
connect(parent, &MappingWindow::ConfigChanged, this, &MappingWidget::ConfigChanged);
const auto timer = new QTimer(this);
connect(timer, &QTimer::timeout, this, [this] {
const auto lock = m_parent->GetController()->GetStateLock();
emit Update();
});
timer->start(1000 / INDICATOR_UPDATE_FREQ);
}
MappingWindow* MappingWidget::GetParent() const
@ -138,10 +130,21 @@ QGroupBox* MappingWidget::CreateGroupBox(const QString& name, ControllerEmu::Con
setting_widget =
new MappingBool(this, static_cast<ControllerEmu::NumericSetting<bool>*>(setting.get()));
break;
default:
// FYI: Widgets for additional types can be implemented as needed.
break;
}
if (setting_widget)
form_layout->addRow(tr(setting->GetUIName()), setting_widget);
{
const auto hbox = new QHBoxLayout;
hbox->addWidget(setting_widget);
hbox->addWidget(CreateSettingAdvancedMappingButton(*setting));
form_layout->addRow(tr(setting->GetUIName()), hbox);
}
}
if (group->can_be_disabled)
@ -173,3 +176,25 @@ ControllerEmu::EmulatedController* MappingWidget::GetController() const
{
return m_parent->GetController();
}
QPushButton*
MappingWidget::CreateSettingAdvancedMappingButton(ControllerEmu::NumericSettingBase& setting)
{
const auto button = new QPushButton(tr("..."));
button->setFixedWidth(QFontMetrics(font()).boundingRect(button->text()).width() * 2);
button->connect(button, &QPushButton::clicked, [this, &setting]() {
if (setting.IsSimpleValue())
setting.SetExpressionFromValue();
IOWindow io(this, GetController(), &setting.GetInputReference(), IOWindow::Type::Input);
io.exec();
setting.SimplifyIfPossible();
ConfigChanged();
SaveSettings();
});
return button;
}

9
Source/Core/DolphinQt/Config/Mapping/MappingWidget.h
View File

@ -14,10 +14,10 @@ constexpr int WIDGET_MAX_WIDTH = 112;
class ControlGroupBox;
class InputConfig;
class IOWindow;
class MappingButton;
class MappingNumeric;
class MappingWindow;
class QPushButton;
class QGroupBox;
namespace ControllerEmu
@ -25,13 +25,9 @@ namespace ControllerEmu
class Control;
class ControlGroup;
class EmulatedController;
class NumericSettingBase;
} // namespace ControllerEmu
namespace ciface::Core
{
class Device;
} // namespace ciface::Core
constexpr int INDICATOR_UPDATE_FREQ = 30;
class MappingWidget : public QWidget
@ -57,6 +53,7 @@ protected:
QGroupBox* CreateGroupBox(ControllerEmu::ControlGroup* group);
QGroupBox* CreateGroupBox(const QString& name, ControllerEmu::ControlGroup* group);
QPushButton* CreateSettingAdvancedMappingButton(ControllerEmu::NumericSettingBase& setting);
private:
MappingWindow* m_parent;

15
Source/Core/DolphinQt/Config/Mapping/MappingWindow.cpp
View File

@ -11,6 +11,7 @@
#include <QHBoxLayout>
#include <QPushButton>
#include <QTabWidget>
#include <QTimer>
#include <QVBoxLayout>
#include "Core/Core.h"
@ -62,6 +63,15 @@ MappingWindow::MappingWindow(QWidget* parent, Type type, int port_num)
ConnectWidgets();
SetMappingType(type);
const auto timer = new QTimer(this);
connect(timer, &QTimer::timeout, this, [this] {
const auto lock = GetController()->GetStateLock();
emit Update();
});
timer->start(1000 / INDICATOR_UPDATE_FREQ);
GetController()->GetStateLock();
emit ConfigChanged();
}
@ -235,6 +245,7 @@ void MappingWindow::OnLoadProfilePressed()
m_controller->LoadConfig(ini.GetOrCreateSection("Profile"));
m_controller->UpdateReferences(g_controller_interface);
GetController()->GetStateLock();
emit ConfigChanged();
}
@ -426,6 +437,8 @@ void MappingWindow::OnDefaultFieldsPressed()
{
m_controller->LoadDefaults(g_controller_interface);
m_controller->UpdateReferences(g_controller_interface);
GetController()->GetStateLock();
emit ConfigChanged();
emit Save();
}
@ -441,6 +454,8 @@ void MappingWindow::OnClearFieldsPressed()
m_controller->SetDefaultDevice(default_device);
m_controller->UpdateReferences(g_controller_interface);
GetController()->GetStateLock();
emit ConfigChanged();
emit Save();
}

41
Source/Core/DolphinQt/Config/Mapping/WiimoteEmuGeneral.cpp
View File

@ -8,6 +8,8 @@
#include <QFormLayout>
#include <QGridLayout>
#include <QGroupBox>
#include <QLabel>
#include <QPushButton>
#include "Core/HW/Wiimote.h"
#include "Core/HW/WiimoteEmu/WiimoteEmu.h"
@ -22,7 +24,7 @@ WiimoteEmuGeneral::WiimoteEmuGeneral(MappingWindow* window, WiimoteEmuExtension*
: MappingWidget(window), m_extension_widget(extension)
{
CreateMainLayout();
Connect(window);
Connect();
}
void WiimoteEmuGeneral::CreateMainLayout()
@ -45,14 +47,20 @@ void WiimoteEmuGeneral::CreateMainLayout()
Wiimote::GetWiimoteGroup(GetPort(), WiimoteEmu::WiimoteGroup::Attachments);
auto* extension = CreateGroupBox(tr("Extension"), extension_group);
auto* ce_extension = static_cast<ControllerEmu::Attachments*>(extension_group);
m_extension_combo = new QComboBox();
const auto combo_hbox = new QHBoxLayout;
combo_hbox->addWidget(m_extension_combo = new QComboBox());
combo_hbox->addWidget(m_extension_combo_dynamic_indicator = new QLabel(QString::fromUtf8("🎮")));
combo_hbox->addWidget(CreateSettingAdvancedMappingButton(ce_extension->GetSelectionSetting()));
m_extension_combo_dynamic_indicator->setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Ignored);
for (const auto& attachment : ce_extension->GetAttachmentList())
m_extension_combo->addItem(tr(attachment->GetDisplayName().c_str()));
extension->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
static_cast<QFormLayout*>(extension->layout())->insertRow(0, m_extension_combo);
static_cast<QFormLayout*>(extension->layout())->insertRow(0, combo_hbox);
layout->addWidget(extension, 0, 3);
layout->addWidget(CreateGroupBox(tr("Rumble"), Wiimote::GetWiimoteGroup(
@ -67,11 +75,14 @@ void WiimoteEmuGeneral::CreateMainLayout()
setLayout(layout);
}
void WiimoteEmuGeneral::Connect(MappingWindow* window)
void WiimoteEmuGeneral::Connect()
{
connect(m_extension_combo, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
this, &WiimoteEmuGeneral::OnAttachmentChanged);
connect(window, &MappingWindow::ConfigChanged, this, &WiimoteEmuGeneral::ConfigChanged);
connect(m_extension_combo, QOverload<int>::of(&QComboBox::currentIndexChanged), this,
&WiimoteEmuGeneral::OnAttachmentChanged);
connect(m_extension_combo, QOverload<int>::of(&QComboBox::activated), this,
&WiimoteEmuGeneral::OnAttachmentSelected);
connect(this, &MappingWidget::ConfigChanged, this, &WiimoteEmuGeneral::ConfigChanged);
connect(this, &MappingWidget::Update, this, &WiimoteEmuGeneral::Update);
}
void WiimoteEmuGeneral::OnAttachmentChanged(int extension)
@ -79,15 +90,31 @@ void WiimoteEmuGeneral::OnAttachmentChanged(int extension)
GetParent()->ShowExtensionMotionTabs(extension == WiimoteEmu::ExtensionNumber::NUNCHUK);
m_extension_widget->ChangeExtensionType(extension);
}
void WiimoteEmuGeneral::OnAttachmentSelected(int extension)
{
auto* ce_extension = static_cast<ControllerEmu::Attachments*>(
Wiimote::GetWiimoteGroup(GetPort(), WiimoteEmu::WiimoteGroup::Attachments));
ce_extension->SetSelectedAttachment(extension);
ConfigChanged();
SaveSettings();
}
void WiimoteEmuGeneral::ConfigChanged()
{
auto* ce_extension = static_cast<ControllerEmu::Attachments*>(
Wiimote::GetWiimoteGroup(GetPort(), WiimoteEmu::WiimoteGroup::Attachments));
m_extension_combo->setCurrentIndex(ce_extension->GetSelectedAttachment());
m_extension_combo_dynamic_indicator->setVisible(
!ce_extension->GetSelectionSetting().IsSimpleValue());
}
void WiimoteEmuGeneral::Update()
{
auto* ce_extension = static_cast<ControllerEmu::Attachments*>(
Wiimote::GetWiimoteGroup(GetPort(), WiimoteEmu::WiimoteGroup::Attachments));

10
Source/Core/DolphinQt/Config/Mapping/WiimoteEmuGeneral.h
View File

@ -7,6 +7,7 @@
#include "DolphinQt/Config/Mapping/MappingWidget.h"
class QComboBox;
class QLabel;
class WiimoteEmuExtension;
class WiimoteEmuGeneral final : public MappingWidget
@ -21,12 +22,19 @@ private:
void LoadSettings() override;
void SaveSettings() override;
void CreateMainLayout();
void Connect(MappingWindow* window);
void Connect();
// Index changed by code/expression.
void OnAttachmentChanged(int index);
// Selection chosen by user.
void OnAttachmentSelected(int index);
void ConfigChanged();
void Update();
// Extensions
QComboBox* m_extension_combo;
QLabel* m_extension_combo_dynamic_indicator;
WiimoteEmuExtension* m_extension_widget;
};

16
Source/Core/InputCommon/ControlReference/ControlReference.h
View File

@ -7,6 +7,7 @@
#include <memory>
#include "InputCommon/ControlReference/ExpressionParser.h"
#include "InputCommon/ControlReference/FunctionExpression.h"
#include "InputCommon/ControllerInterface/Device.h"
// ControlReference
@ -30,6 +31,9 @@ public:
virtual ControlState State(const ControlState state = 0) = 0;
virtual bool IsInput() const = 0;
template <typename T>
T GetState();
int BoundCount() const;
ciface::ExpressionParser::ParseStatus GetParseStatus() const;
void UpdateReference(ciface::ExpressionParser::ControlEnvironment& env);
@ -45,6 +49,18 @@ protected:
ciface::ExpressionParser::ParseStatus m_parse_status;
};
template <>
inline bool ControlReference::GetState<bool>()
{
return State() > ciface::ExpressionParser::CONDITION_THRESHOLD;
}
template <typename T>
T ControlReference::GetState()
{
return State();
}
//
// InputReference
//

2
Source/Core/InputCommon/ControlReference/FunctionExpression.cpp
View File

@ -10,8 +10,6 @@
namespace ciface::ExpressionParser
{
constexpr ControlState CONDITION_THRESHOLD = 0.5;
using Clock = std::chrono::steady_clock;
using FSec = std::chrono::duration<ControlState>;

2
Source/Core/InputCommon/ControlReference/FunctionExpression.h
View File

@ -15,6 +15,8 @@
namespace ciface::ExpressionParser
{
constexpr ControlState CONDITION_THRESHOLD = 0.5;
class FunctionExpression : public Expression
{
public:

14
Source/Core/InputCommon/ControllerEmu/ControlGroup/Attachments.cpp
View File

@ -17,12 +17,22 @@ void Attachments::AddAttachment(std::unique_ptr<EmulatedController> att)
u32 Attachments::GetSelectedAttachment() const
{
return m_selected_attachment;
const u32 value = m_selection_value.GetValue();
if (value < m_attachments.size())
return value;
return 0;
}
void Attachments::SetSelectedAttachment(u32 val)
{
m_selected_attachment = val;
m_selection_setting.SetValue(val);
}
NumericSetting<int>& Attachments::GetSelectionSetting()
{
return m_selection_setting;
}
const std::vector<std::unique_ptr<EmulatedController>>& Attachments::GetAttachmentList() const

8
Source/Core/InputCommon/ControllerEmu/ControlGroup/Attachments.h
View File

@ -12,6 +12,7 @@
#include "Common/CommonTypes.h"
#include "InputCommon/ControllerEmu/ControlGroup/ControlGroup.h"
#include "InputCommon/ControllerEmu/ControllerEmu.h"
#include "InputCommon/ControllerEmu/Setting/NumericSetting.h"
namespace ControllerEmu
{
@ -27,11 +28,14 @@ public:
u32 GetSelectedAttachment() const;
void SetSelectedAttachment(u32 val);
NumericSetting<int>& GetSelectionSetting();
const std::vector<std::unique_ptr<EmulatedController>>& GetAttachmentList() const;
private:
std::vector<std::unique_ptr<EmulatedController>> m_attachments;
SettingValue<int> m_selection_value;
NumericSetting<int> m_selection_setting = {&m_selection_value, {""}, 0, 0, 0};
std::atomic<u32> m_selected_attachment = {};
std::vector<std::unique_ptr<EmulatedController>> m_attachments;
};
} // namespace ControllerEmu

4
Source/Core/InputCommon/ControllerEmu/ControlGroup/Buttons.h
View File

@ -24,13 +24,11 @@ public:
{
for (auto& control : controls)
{
if (control->control_ref->State() > ACTIVATION_THRESHOLD)
if (control->control_ref->GetState<bool>())
*buttons |= *bitmasks;
bitmasks++;
}
}
static constexpr ControlState ACTIVATION_THRESHOLD = 0.5;
};
} // namespace ControllerEmu

22
Source/Core/InputCommon/ControllerEmu/ControlGroup/ControlGroup.cpp
View File

@ -74,15 +74,19 @@ void ControlGroup::LoadConfig(IniFile::Section* sec, const std::string& defdev,
ext->SetSelectedAttachment(0);
u32 n = 0;
std::string extname;
sec->Get(base + name, &extname, "");
std::string attachment_text;
sec->Get(base + name, &attachment_text, "");
// First assume attachment string is a valid expression.
// If it instead matches one of the names of our attachments it is overridden below.
ext->GetSelectionSetting().GetInputReference().SetExpression(attachment_text);
for (auto& ai : ext->GetAttachmentList())
{
ai->SetDefaultDevice(defdev);
ai->LoadConfig(sec, base + ai->GetName() + "/");
if (ai->GetName() == extname)
if (ai->GetName() == attachment_text)
ext->SetSelectedAttachment(n);
n++;
@ -114,8 +118,16 @@ void ControlGroup::SaveConfig(IniFile::Section* sec, const std::string& defdev,
if (type == GroupType::Attachments)
{
auto* const ext = static_cast<Attachments*>(this);
sec->Set(base + name, ext->GetAttachmentList()[ext->GetSelectedAttachment()]->GetName(),
"None");
if (ext->GetSelectionSetting().IsSimpleValue())
{
sec->Set(base + name, ext->GetAttachmentList()[ext->GetSelectedAttachment()]->GetName(),
"None");
}
else
{
sec->Set(base + name, ext->GetSelectionSetting().GetInputReference().GetExpression(), "None");
}
for (auto& ai : ext->GetAttachmentList())
ai->SaveConfig(sec, base + ai->GetName() + "/");

8
Source/Core/InputCommon/ControllerEmu/ControlGroup/ModifySettingsButton.cpp
View File

@ -35,19 +35,19 @@ void ModifySettingsButton::GetState()
{
for (size_t i = 0; i < controls.size(); ++i)
{
ControlState state = controls[i]->control_ref->State();
const bool state = controls[i]->control_ref->GetState<bool>();
if (!associated_settings_toggle[i])
{
// not toggled
associated_settings[i] = state > ACTIVATION_THRESHOLD;
associated_settings[i] = state;
}
else
{
// toggle (loading savestates does not en-/disable toggle)
// after we passed the threshold, we en-/disable. but after that, we don't change it
// anymore
if (!threshold_exceeded[i] && state > ACTIVATION_THRESHOLD)
if (!threshold_exceeded[i] && state)
{
associated_settings[i] = !associated_settings[i];
@ -59,7 +59,7 @@ void ModifySettingsButton::GetState()
threshold_exceeded[i] = true;
}
if (state < ACTIVATION_THRESHOLD)
if (!state)
threshold_exceeded[i] = false;
}
}

10
Source/Core/InputCommon/ControllerEmu/ControllerEmu.cpp
View File

@ -14,6 +14,7 @@
#include "InputCommon/ControllerEmu/Control/Control.h"
#include "InputCommon/ControllerEmu/ControlGroup/Attachments.h"
#include "InputCommon/ControllerEmu/ControlGroup/ControlGroup.h"
#include "InputCommon/ControllerEmu/Setting/NumericSetting.h"
#include "InputCommon/ControllerInterface/ControllerInterface.h"
namespace ControllerEmu
@ -54,10 +55,17 @@ void EmulatedController::UpdateReferences(ciface::ExpressionParser::ControlEnvir
for (auto& control : ctrlGroup->controls)
control->control_ref->UpdateReference(env);
for (auto& setting : ctrlGroup->numeric_settings)
setting->GetInputReference().UpdateReference(env);
// Attachments:
if (ctrlGroup->type == GroupType::Attachments)
{
for (auto& attachment : static_cast<Attachments*>(ctrlGroup.get())->GetAttachmentList())
auto* const attachments = static_cast<Attachments*>(ctrlGroup.get());
attachments->GetSelectionSetting().GetInputReference().UpdateReference(env);
for (auto& attachment : attachments->GetAttachmentList())
attachment->UpdateReferences(env);
}
}

32
Source/Core/InputCommon/ControllerEmu/Setting/NumericSetting.cpp
View File

@ -4,6 +4,8 @@
#include "InputCommon/ControllerEmu/Setting/NumericSetting.h"
#include <sstream>
namespace ControllerEmu
{
NumericSettingBase::NumericSettingBase(const NumericSettingDetails& details) : m_details(details)
@ -25,6 +27,36 @@ const char* NumericSettingBase::GetUIDescription() const
return m_details.ui_description;
}
template <>
void NumericSetting<int>::SetExpressionFromValue()
{
m_value.m_input.SetExpression(ValueToString(GetValue()));
}
template <>
void NumericSetting<double>::SetExpressionFromValue()
{
// We must use a dot decimal separator for expression parser.
std::ostringstream ss;
ss.imbue(std::locale::classic());
ss << GetValue();
m_value.m_input.SetExpression(ss.str());
}
template <>
void NumericSetting<bool>::SetExpressionFromValue()
{
// Cast bool to prevent "true"/"false" strings.
m_value.m_input.SetExpression(ValueToString(int(GetValue())));
}
template <>
SettingType NumericSetting<int>::GetType() const
{
return SettingType::Int;
}
template <>
SettingType NumericSetting<double>::GetType() const
{

72
Source/Core/InputCommon/ControllerEmu/Setting/NumericSetting.h
View File

@ -9,12 +9,14 @@
#include "Common/CommonTypes.h"
#include "Common/IniFile.h"
#include "InputCommon/ControlReference/ControlReference.h"
#include "InputCommon/ControllerInterface/Device.h"
namespace ControllerEmu
{
enum class SettingType
{
Int,
Double,
Bool,
};
@ -52,6 +54,17 @@ public:
virtual void LoadFromIni(const IniFile::Section& section, const std::string& group_name) = 0;
virtual void SaveToIni(IniFile::Section& section, const std::string& group_name) const = 0;
virtual InputReference& GetInputReference() = 0;
virtual const InputReference& GetInputReference() const = 0;
virtual bool IsSimpleValue() const = 0;
// Convert a literal expression e.g. "7.0" to a regular value. (disables expression parsing)
virtual void SimplifyIfPossible() = 0;
// Convert a regular value to an expression. (used before expression editing)
virtual void SetExpressionFromValue() = 0;
virtual SettingType GetType() const = 0;
const char* GetUIName() const;
@ -66,13 +79,14 @@ template <typename T>
class SettingValue;
template <typename T>
class NumericSetting : public NumericSettingBase
class NumericSetting final : public NumericSettingBase
{
public:
using ValueType = T;
static_assert(std::is_same<ValueType, double>() || std::is_same<ValueType, bool>(),
"NumericSetting is only implemented for double and bool.");
static_assert(std::is_same<ValueType, int>() || std::is_same<ValueType, double>() ||
std::is_same<ValueType, bool>(),
"NumericSetting is only implemented for int, double, and bool.");
NumericSetting(SettingValue<ValueType>* value, const NumericSettingDetails& details,
ValueType default_value, ValueType min_value, ValueType max_value)
@ -84,16 +98,39 @@ public:
void LoadFromIni(const IniFile::Section& section, const std::string& group_name) override
{
ValueType value;
section.Get(group_name + m_details.ini_name, &value, m_default_value);
SetValue(value);
std::string str_value;
if (section.Get(group_name + m_details.ini_name, &str_value))
{
m_value.m_input.SetExpression(std::move(str_value));
SimplifyIfPossible();
}
else
{
SetValue(m_default_value);
}
}
void SaveToIni(IniFile::Section& section, const std::string& group_name) const override
{
section.Set(group_name + m_details.ini_name, GetValue(), m_default_value);
if (IsSimpleValue())
section.Set(group_name + m_details.ini_name, GetValue(), m_default_value);
else
section.Set(group_name + m_details.ini_name, m_value.m_input.GetExpression(), "");
}
bool IsSimpleValue() const override { return m_value.IsSimpleValue(); }
void SimplifyIfPossible() override
{
ValueType value;
if (TryParse(m_value.m_input.GetExpression(), &value))
m_value.SetValue(value);
}
void SetExpressionFromValue() override;
InputReference& GetInputReference() override { return m_value.m_input; }
const InputReference& GetInputReference() const override { return m_value.m_input; }
ValueType GetValue() const { return m_value.GetValue(); }
void SetValue(ValueType value) { m_value.SetValue(value); }
@ -119,13 +156,30 @@ class SettingValue
friend class NumericSetting<T>;
public:
ValueType GetValue() const { return m_value; }
ValueType GetValue() const
{
if (IsSimpleValue())
return m_value;
else
return m_input.GetState<ValueType>();
}
bool IsSimpleValue() const { return m_input.GetExpression().empty(); }
private:
void SetValue(ValueType value) { m_value = value; }
void SetValue(ValueType value)
{
m_value = value;
// Clear the expression to use our new "simple" value.
m_input.SetExpression("");
}
// Values are R/W by both UI and CPU threads.
std::atomic<ValueType> m_value = {};
// Unfortunately InputReference's state grabbing is non-const requiring mutable here.
mutable InputReference m_input;
};
} // namespace ControllerEmu