ControllerEmu: Separate ControlGroup from ControllerEmu

ControllerEmu, the class, is essentially acting like a namespace for
ControlGroup. This makes it impossible to forward declare any of the
internals. It also globs a bunch of classes together which is kind of a
pain to manage.

This splits ControlGroup and the classes it contains into their own source
files and situates them all within a namespace, which gets them out of
global scope.

Since this allows forward declarations for the once-internal classes, it
now requires significantly less files to be rebuilt if anything is changed
in the ControllerEmu portion of code.

It does not split out the settings classes yet, however, as it
would be preferable to make a settings base class that all settings derive
from, but this would be a functional change -- this commit only intends to
move around existing code. Extracting the settings class will be done in
another commit.

Source/Core/InputCommon/ControllerEmu/Control/Control.cpp

@@ -0,0 +1,15 @@
+// Copyright 2017 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#include "InputCommon/ControllerEmu/Control/Control.h"
+#include "InputCommon/ControlReference/ControlReference.h"
+
+namespace ControllerEmu
+{
+Control::Control(ControlReference* ref, const std::string& name_) : control_ref(ref), name(name_)
+{
+}
+
+Control::~Control() = default;
+}  // namespace ControllerEmu

Source/Core/InputCommon/ControllerEmu/Control/Control.h

@@ -0,0 +1,25 @@
+// Copyright 2017 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <memory>
+#include <string>
+
+class ControlReference;
+
+namespace ControllerEmu
+{
+class Control
+{
+public:
+  virtual ~Control();
+
+  std::unique_ptr<ControlReference> const control_ref;
+  const std::string name;
+
+protected:
+  Control(ControlReference* ref, const std::string& name);
+};
+}  // namespace ControllerEmu

Source/Core/InputCommon/ControllerEmu/Control/Input.cpp

@@ -0,0 +1,15 @@
+// Copyright 2017 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#include "InputCommon/ControllerEmu/Control/Input.h"
+
+#include <string>
+#include "InputCommon/ControlReference/ControlReference.h"
+
+namespace ControllerEmu
+{
+Input::Input(const std::string& name_) : Control(new InputReference, name_)
+{
+}
+}  // namespace ControllerEmu

Source/Core/InputCommon/ControllerEmu/Control/Input.h

@@ -0,0 +1,17 @@
+// Copyright 2017 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <string>
+#include "InputCommon/ControllerEmu/Control/Control.h"
+
+namespace ControllerEmu
+{
+class Input : public Control
+{
+public:
+  explicit Input(const std::string& name);
+};
+}  // namespace ControllerEmu

Source/Core/InputCommon/ControllerEmu/Control/Output.cpp

@@ -0,0 +1,15 @@
+// Copyright 2017 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#include "InputCommon/ControllerEmu/Control/Output.h"
+
+#include <string>
+#include "InputCommon/ControlReference/ControlReference.h"
+
+namespace ControllerEmu
+{
+Output::Output(const std::string& name_) : Control(new OutputReference, name_)
+{
+}
+}  // namespace ControllerEmu

Source/Core/InputCommon/ControllerEmu/Control/Output.h

@@ -0,0 +1,17 @@
+// Copyright 2017 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <string>
+#include "InputCommon/ControllerEmu/Control/Control.h"
+
+namespace ControllerEmu
+{
+class Output : public Control
+{
+public:
+  explicit Output(const std::string& name);
+};
+}  // namespace ControllerEmu

Source/Core/InputCommon/ControllerEmu/ControlGroup/AnalogStick.cpp

@@ -0,0 +1,71 @@
+// Copyright 2017 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#include "InputCommon/ControllerEmu/ControlGroup/AnalogStick.h"
+
+#include <algorithm>
+#include <cmath>
+#include <memory>
+
+#include "Common/Common.h"
+
+#include "InputCommon/ControlReference/ControlReference.h"
+#include "InputCommon/ControllerEmu/Control/Control.h"
+#include "InputCommon/ControllerEmu/Control/Input.h"
+#include "InputCommon/ControllerEmu/ControllerEmu.h"
+
+namespace ControllerEmu
+{
+AnalogStick::AnalogStick(const char* const name_, ControlState default_radius)
+    : AnalogStick(name_, name_, default_radius)
+{
+}
+
+AnalogStick::AnalogStick(const char* const name_, const char* const ui_name_,
+                         ControlState default_radius)
+    : ControlGroup(name_, ui_name_, GROUP_TYPE_STICK)
+{
+  for (auto& named_direction : named_directions)
+    controls.emplace_back(std::make_unique<Input>(named_direction));
+
+  controls.emplace_back(std::make_unique<Input>(_trans("Modifier")));
+  numeric_settings.emplace_back(
+      std::make_unique<NumericSetting>(_trans("Radius"), default_radius, 0, 100));
+  numeric_settings.emplace_back(std::make_unique<NumericSetting>(_trans("Dead Zone"), 0, 0, 50));
+}
+
+void AnalogStick::GetState(ControlState* const x, ControlState* const y)
+{
+  ControlState yy = controls[0]->control_ref->State() - controls[1]->control_ref->State();
+  ControlState xx = controls[3]->control_ref->State() - controls[2]->control_ref->State();
+
+  ControlState radius = numeric_settings[SETTING_RADIUS]->GetValue();
+  ControlState deadzone = numeric_settings[SETTING_DEADZONE]->GetValue();
+  ControlState m = controls[4]->control_ref->State();
+
+  ControlState ang = atan2(yy, xx);
+  ControlState ang_sin = sin(ang);
+  ControlState ang_cos = cos(ang);
+
+  ControlState dist = sqrt(xx * xx + yy * yy);
+
+  // dead zone code
+  dist = std::max(0.0, dist - deadzone);
+  dist /= (1 - deadzone);
+
+  // radius
+  dist *= radius;
+
+  // The modifier halves the distance by 50%, which is useful
+  // for keyboard controls.
+  if (m)
+    dist *= 0.5;
+
+  yy = std::max(-1.0, std::min(1.0, ang_sin * dist));
+  xx = std::max(-1.0, std::min(1.0, ang_cos * dist));
+
+  *y = yy;
+  *x = xx;
+}
+}  // namespace ControllerEmu

Source/Core/InputCommon/ControllerEmu/ControlGroup/AnalogStick.h

@@ -0,0 +1,26 @@
+// Copyright 2017 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "InputCommon/ControllerEmu/ControlGroup/ControlGroup.h"
+
+namespace ControllerEmu
+{
+class AnalogStick : public ControlGroup
+{
+public:
+  enum
+  {
+    SETTING_RADIUS,
+    SETTING_DEADZONE,
+  };
+
+  // The GameCube controller and Wiimote attachments have a different default radius
+  AnalogStick(const char* name, ControlState default_radius);
+  AnalogStick(const char* name, const char* ui_name, ControlState default_radius);
+
+  void GetState(ControlState* x, ControlState* y);
+};
+}  // namespace ControllerEmu

Source/Core/InputCommon/ControllerEmu/ControlGroup/Buttons.cpp

@@ -0,0 +1,24 @@
+// Copyright 2017 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#include "InputCommon/ControllerEmu/ControlGroup/Buttons.h"
+
+#include <memory>
+#include <string>
+
+#include "Common/Common.h"
+
+namespace ControllerEmu
+{
+Buttons::Buttons(const std::string& name_) : ControlGroup(name_, name_, GROUP_TYPE_BUTTONS)
+{
+  numeric_settings.emplace_back(std::make_unique<NumericSetting>(_trans("Threshold"), 0.5));
+}
+
+Buttons::Buttons(const std::string& ini_name, const std::string& group_name)
+    : ControlGroup(ini_name, group_name, GROUP_TYPE_BUTTONS)
+{
+  numeric_settings.emplace_back(std::make_unique<NumericSetting>(_trans("Threshold"), 0.5));
+}
+}  // namespace ControllerEmu

Source/Core/InputCommon/ControllerEmu/ControlGroup/Buttons.h

@@ -0,0 +1,33 @@
+// Copyright 2017 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <string>
+
+#include "InputCommon/ControlReference/ControlReference.h"
+#include "InputCommon/ControllerEmu/Control/Control.h"
+#include "InputCommon/ControllerEmu/ControlGroup/ControlGroup.h"
+
+namespace ControllerEmu
+{
+class Buttons : public ControlGroup
+{
+public:
+  explicit Buttons(const std::string& name_);
+  Buttons(const std::string& ini_name, const std::string& group_name);
+
+  template <typename C>
+  void GetState(C* const buttons, const C* bitmasks)
+  {
+    for (auto& control : controls)
+    {
+      if (control->control_ref->State() > numeric_settings[0]->GetValue())  // threshold
+        *buttons |= *bitmasks;
+
+      bitmasks++;
+    }
+  }
+};
+}  // namespace ControllerEmu

Source/Core/InputCommon/ControllerEmu/ControlGroup/ControlGroup.cpp

@@ -0,0 +1,132 @@
+// Copyright 2017 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#include "InputCommon/ControllerEmu/ControlGroup/ControlGroup.h"
+
+#include "Common/CommonTypes.h"
+#include "Common/IniFile.h"
+
+#include "InputCommon/ControlReference/ControlReference.h"
+#include "InputCommon/ControllerEmu/Control/Control.h"
+#include "InputCommon/ControllerEmu/ControlGroup/Extension.h"
+#include "InputCommon/ControllerEmu/ControllerEmu.h"
+
+namespace ControllerEmu
+{
+ControlGroup::ControlGroup(const std::string& name_, const u32 type_)
+    : name(name_), ui_name(name_), type(type_)
+{
+}
+
+ControlGroup::ControlGroup(const std::string& name_, const std::string& ui_name_, const u32 type_)
+    : name(name_), ui_name(ui_name_), type(type_)
+{
+}
+
+ControlGroup::~ControlGroup() = default;
+
+ControlGroup::BooleanSetting::~BooleanSetting() = default;
+
+void ControlGroup::LoadConfig(IniFile::Section* sec, const std::string& defdev,
+                              const std::string& base)
+{
+  std::string group(base + name + "/");
+
+  // settings
+  for (auto& s : numeric_settings)
+  {
+    if (s->m_type == SettingType::VIRTUAL)
+      continue;
+
+    sec->Get(group + s->m_name, &s->m_value, s->m_default_value * 100);
+    s->m_value /= 100;
+  }
+
+  for (auto& s : boolean_settings)
+  {
+    if (s->m_type == SettingType::VIRTUAL)
+      continue;
+
+    sec->Get(group + s->m_name, &s->m_value, s->m_default_value);
+  }
+
+  for (auto& c : controls)
+  {
+    // control expression
+    sec->Get(group + c->name, &c->control_ref->expression, "");
+
+    // range
+    sec->Get(group + c->name + "/Range", &c->control_ref->range, 100.0);
+    c->control_ref->range /= 100;
+  }
+
+  // extensions
+  if (type == GROUP_TYPE_EXTENSION)
+  {
+    Extension* const ext = (Extension*)this;
+
+    ext->switch_extension = 0;
+    u32 n = 0;
+    std::string extname;
+    sec->Get(base + name, &extname, "");
+
+    for (auto& ai : ext->attachments)
+    {
+      ai->default_device.FromString(defdev);
+      ai->LoadConfig(sec, base + ai->GetName() + "/");
+
+      if (ai->GetName() == extname)
+        ext->switch_extension = n;
+
+      n++;
+    }
+  }
+}
+
+void ControlGroup::SaveConfig(IniFile::Section* sec, const std::string& defdev,
+                              const std::string& base)
+{
+  std::string group(base + name + "/");
+
+  for (auto& s : numeric_settings)
+  {
+    if (s->m_type == SettingType::VIRTUAL)
+      continue;
+
+    sec->Set(group + s->m_name, s->m_value * 100.0, s->m_default_value * 100.0);
+  }
+
+  for (auto& s : boolean_settings)
+  {
+    if (s->m_type == SettingType::VIRTUAL)
+      continue;
+
+    sec->Set(group + s->m_name, s->m_value, s->m_default_value);
+  }
+
+  for (auto& c : controls)
+  {
+    // control expression
+    sec->Set(group + c->name, c->control_ref->expression, "");
+
+    // range
+    sec->Set(group + c->name + "/Range", c->control_ref->range * 100.0, 100.0);
+  }
+
+  // extensions
+  if (type == GROUP_TYPE_EXTENSION)
+  {
+    Extension* const ext = (Extension*)this;
+    sec->Set(base + name, ext->attachments[ext->switch_extension]->GetName(), "None");
+
+    for (auto& ai : ext->attachments)
+      ai->SaveConfig(sec, base + ai->GetName() + "/");
+  }
+}
+
+void ControlGroup::SetControlExpression(int index, const std::string& expression)
+{
+  controls.at(index)->control_ref->expression = expression;
+}
+}  // namespace ControllerEmu

Source/Core/InputCommon/ControllerEmu/ControlGroup/ControlGroup.h

@@ -0,0 +1,117 @@
+// Copyright 2017 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "Common/CommonTypes.h"
+#include "Common/IniFile.h"
+#include "Core/ConfigManager.h"
+#include "InputCommon/ControllerInterface/Device.h"
+
+namespace ControllerEmu
+{
+class Control;
+
+enum
+{
+  GROUP_TYPE_OTHER,
+  GROUP_TYPE_STICK,
+  GROUP_TYPE_MIXED_TRIGGERS,
+  GROUP_TYPE_BUTTONS,
+  GROUP_TYPE_FORCE,
+  GROUP_TYPE_EXTENSION,
+  GROUP_TYPE_TILT,
+  GROUP_TYPE_CURSOR,
+  GROUP_TYPE_TRIGGERS,
+  GROUP_TYPE_SLIDER
+};
+
+class ControlGroup
+{
+public:
+  enum class SettingType
+  {
+    NORMAL,   // normal settings are saved to configuration files
+    VIRTUAL,  // virtual settings are not saved at all
+  };
+
+  class NumericSetting
+  {
+  public:
+    NumericSetting(const std::string& setting_name, const ControlState default_value,
+                   const u32 low = 0, const u32 high = 100,
+                   const SettingType setting_type = SettingType::NORMAL)
+        : m_type(setting_type), m_name(setting_name), m_default_value(default_value), m_low(low),
+          m_high(high)
+    {
+    }
+
+    ControlState GetValue() const { return m_value; }
+    void SetValue(ControlState value) { m_value = value; }
+    const SettingType m_type;
+    const std::string m_name;
+    const ControlState m_default_value;
+    const u32 m_low;
+    const u32 m_high;
+    ControlState m_value;
+  };
+
+  class BooleanSetting
+  {
+  public:
+    BooleanSetting(const std::string& setting_name, const bool default_value,
+                   const SettingType setting_type = SettingType::NORMAL)
+        : m_type(setting_type), m_name(setting_name), m_default_value(default_value)
+    {
+    }
+    virtual ~BooleanSetting();
+
+    virtual bool GetValue() const { return m_value; }
+    virtual void SetValue(bool value) { m_value = value; }
+    const SettingType m_type;
+    const std::string m_name;
+    const bool m_default_value;
+    bool m_value;
+  };
+
+  class BackgroundInputSetting : public BooleanSetting
+  {
+  public:
+    BackgroundInputSetting(const std::string& setting_name)
+        : BooleanSetting(setting_name, false, SettingType::VIRTUAL)
+    {
+    }
+
+    bool GetValue() const override { return SConfig::GetInstance().m_BackgroundInput; }
+    void SetValue(bool value) override
+    {
+      m_value = value;
+      SConfig::GetInstance().m_BackgroundInput = value;
+    }
+  };
+
+  explicit ControlGroup(const std::string& name, u32 type = GROUP_TYPE_OTHER);
+  ControlGroup(const std::string& name, const std::string& ui_name, u32 type = GROUP_TYPE_OTHER);
+  virtual ~ControlGroup();
+
+  virtual void LoadConfig(IniFile::Section* sec, const std::string& defdev = "",
+                          const std::string& base = "");
+  virtual void SaveConfig(IniFile::Section* sec, const std::string& defdev = "",
+                          const std::string& base = "");
+
+  void SetControlExpression(int index, const std::string& expression);
+
+  const std::string name;
+  const std::string ui_name;
+  const u32 type;
+
+  std::vector<std::unique_ptr<Control>> controls;
+  std::vector<std::unique_ptr<NumericSetting>> numeric_settings;
+  std::vector<std::unique_ptr<BooleanSetting>> boolean_settings;
+};
+}  // namespace ControllerEmu

Source/Core/InputCommon/ControllerEmu/ControlGroup/Cursor.cpp

@@ -0,0 +1,98 @@
+// Copyright 2017 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#include "InputCommon/ControllerEmu/ControlGroup/Cursor.h"
+
+#include <algorithm>
+#include <cmath>
+#include <memory>
+#include <string>
+
+#include "Common/Common.h"
+#include "Common/MathUtil.h"
+
+#include "InputCommon/ControlReference/ControlReference.h"
+#include "InputCommon/ControllerEmu/Control/Control.h"
+#include "InputCommon/ControllerEmu/Control/Input.h"
+#include "InputCommon/ControllerEmu/ControllerEmu.h"
+
+namespace ControllerEmu
+{
+Cursor::Cursor(const std::string& name_) : ControlGroup(name_, GROUP_TYPE_CURSOR)
+{
+  for (auto& named_direction : named_directions)
+    controls.emplace_back(std::make_unique<Input>(named_direction));
+
+  controls.emplace_back(std::make_unique<Input>("Forward"));
+  controls.emplace_back(std::make_unique<Input>("Backward"));
+  controls.emplace_back(std::make_unique<Input>(_trans("Hide")));
+  controls.emplace_back(std::make_unique<Input>("Recenter"));
+
+  numeric_settings.emplace_back(std::make_unique<NumericSetting>(_trans("Center"), 0.5));
+  numeric_settings.emplace_back(std::make_unique<NumericSetting>(_trans("Width"), 0.5));
+  numeric_settings.emplace_back(std::make_unique<NumericSetting>(_trans("Height"), 0.5));
+  numeric_settings.emplace_back(std::make_unique<NumericSetting>(_trans("Dead Zone"), 0, 0, 20));
+  boolean_settings.emplace_back(std::make_unique<BooleanSetting>(_trans("Relative Input"), false));
+}
+
+void Cursor::GetState(ControlState* const x, ControlState* const y, ControlState* const z,
+                      const bool adjusted)
+{
+  const ControlState zz = controls[4]->control_ref->State() - controls[5]->control_ref->State();
+
+  // silly being here
+  if (zz > m_z)
+    m_z = std::min(m_z + 0.1, zz);
+  else if (zz < m_z)
+    m_z = std::max(m_z - 0.1, zz);
+
+  *z = m_z;
+
+  // hide
+  if (controls[6]->control_ref->State() > 0.5)
+  {
+    *x = 10000;
+    *y = 0;
+  }
+  else
+  {
+    ControlState yy = controls[0]->control_ref->State() - controls[1]->control_ref->State();
+    ControlState xx = controls[3]->control_ref->State() - controls[2]->control_ref->State();
+
+    // adjust cursor according to settings
+    if (adjusted)
+    {
+      xx *= (numeric_settings[1]->GetValue() * 2);
+      yy *= (numeric_settings[2]->GetValue() * 2);
+      yy += (numeric_settings[0]->GetValue() - 0.5);
+    }
+
+    // relative input
+    if (boolean_settings[0]->GetValue())
+    {
+      const ControlState deadzone = numeric_settings[3]->GetValue();
+      // deadzone to avoid the cursor slowly drifting
+      if (std::abs(xx) > deadzone)
+        m_x = MathUtil::Clamp(m_x + xx * SPEED_MULTIPLIER, -1.0, 1.0);
+      if (std::abs(yy) > deadzone)
+        m_y = MathUtil::Clamp(m_y + yy * SPEED_MULTIPLIER, -1.0, 1.0);
+
+      // recenter
+      if (controls[7]->control_ref->State() > 0.5)
+      {
+        m_x = 0.0;
+        m_y = 0.0;
+      }
+    }
+    else
+    {
+      m_x = xx;
+      m_y = yy;
+    }
+
+    *x = m_x;
+    *y = m_y;
+  }
+}
+}  // namespace ControllerEmu

Source/Core/InputCommon/ControllerEmu/ControlGroup/Cursor.h

@@ -0,0 +1,29 @@
+// Copyright 2017 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <string>
+#include "InputCommon/ControllerEmu/ControlGroup/ControlGroup.h"
+
+namespace ControllerEmu
+{
+class Cursor : public ControlGroup
+{
+public:
+  explicit Cursor(const std::string& name);
+
+  void GetState(ControlState* x, ControlState* y, ControlState* z, bool adjusted = false);
+
+  ControlState m_z = 0.0;
+
+private:
+  // This is used to reduce the cursor speed for relative input
+  // to something that makes sense with the default range.
+  static constexpr double SPEED_MULTIPLIER = 0.04;
+
+  ControlState m_x = 0.0;
+  ControlState m_y = 0.0;
+};
+}  // namespace ControllerEmu

Source/Core/InputCommon/ControllerEmu/ControlGroup/Extension.cpp

@@ -0,0 +1,16 @@
+// Copyright 2017 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#include "InputCommon/ControllerEmu/ControlGroup/Extension.h"
+
+#include <string>
+
+#include "InputCommon/ControllerEmu/ControllerEmu.h"
+
+namespace ControllerEmu
+{
+Extension::Extension(const std::string& name_) : ControlGroup(name_, GROUP_TYPE_EXTENSION)
+{
+}
+}  // namespace ControllerEmu

Source/Core/InputCommon/ControllerEmu/ControlGroup/Extension.h

@@ -0,0 +1,31 @@
+// Copyright 2017 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "Common/CommonTypes.h"
+#include "InputCommon/ControllerEmu/ControlGroup/ControlGroup.h"
+
+namespace ControllerEmu
+{
+class EmulatedController;
+
+class Extension : public ControlGroup
+{
+public:
+  explicit Extension(const std::string& name);
+
+  void GetState(u8* data);
+  bool IsButtonPressed() const;
+
+  std::vector<std::unique_ptr<EmulatedController>> attachments;
+
+  int switch_extension = 0;
+  int active_extension = 0;
+};
+}  // namespace ControllerEmu

Source/Core/InputCommon/ControllerEmu/ControlGroup/Force.cpp

@@ -0,0 +1,51 @@
+// Copyright 2017 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#include "InputCommon/ControllerEmu/ControlGroup/Force.h"
+
+#include <cmath>
+#include <cstring>
+#include <memory>
+#include <string>
+
+#include "Common/Common.h"
+#include "Common/CommonTypes.h"
+#include "InputCommon/ControlReference/ControlReference.h"
+#include "InputCommon/ControllerEmu/Control/Input.h"
+#include "InputCommon/ControllerEmu/ControllerEmu.h"
+
+namespace ControllerEmu
+{
+Force::Force(const std::string& name_) : ControlGroup(name_, GROUP_TYPE_FORCE)
+{
+  memset(m_swing, 0, sizeof(m_swing));
+
+  controls.emplace_back(std::make_unique<Input>(_trans("Up")));
+  controls.emplace_back(std::make_unique<Input>(_trans("Down")));
+  controls.emplace_back(std::make_unique<Input>(_trans("Left")));
+  controls.emplace_back(std::make_unique<Input>(_trans("Right")));
+  controls.emplace_back(std::make_unique<Input>(_trans("Forward")));
+  controls.emplace_back(std::make_unique<Input>(_trans("Backward")));
+
+  numeric_settings.emplace_back(std::make_unique<NumericSetting>(_trans("Dead Zone"), 0, 0, 50));
+}
+
+void Force::GetState(ControlState* axis)
+{
+  const ControlState deadzone = numeric_settings[0]->GetValue();
+
+  for (u32 i = 0; i < 6; i += 2)
+  {
+    ControlState tmpf = 0;
+    const ControlState state =
+        controls[i + 1]->control_ref->State() - controls[i]->control_ref->State();
+    if (fabs(state) > deadzone)
+      tmpf = ((state - (deadzone * sign(state))) / (1 - deadzone));
+
+    ControlState& ax = m_swing[i >> 1];
+    *axis++ = (tmpf - ax);
+    ax = tmpf;
+  }
+}
+}  // namespace ControllerEmu

Source/Core/InputCommon/ControllerEmu/ControlGroup/Force.h

@@ -0,0 +1,22 @@
+// Copyright 2017 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <string>
+#include "InputCommon/ControllerEmu/ControlGroup/ControlGroup.h"
+
+namespace ControllerEmu
+{
+class Force : public ControlGroup
+{
+public:
+  explicit Force(const std::string& name);
+
+  void GetState(ControlState* axis);
+
+private:
+  ControlState m_swing[3];
+};
+}  // namespace ControllerEmu

Source/Core/InputCommon/ControllerEmu/ControlGroup/MixedTriggers.cpp

@@ -0,0 +1,42 @@
+// Copyright 2017 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#include "InputCommon/ControllerEmu/ControlGroup/MixedTriggers.h"
+
+#include <cstddef>
+#include <memory>
+#include <string>
+
+#include "Common/Common.h"
+#include "Common/CommonTypes.h"
+
+#include "InputCommon/ControlReference/ControlReference.h"
+#include "InputCommon/ControllerEmu/Control/Control.h"
+
+namespace ControllerEmu
+{
+MixedTriggers::MixedTriggers(const std::string& name_)
+    : ControlGroup(name_, GROUP_TYPE_MIXED_TRIGGERS)
+{
+  numeric_settings.emplace_back(std::make_unique<NumericSetting>(_trans("Threshold"), 0.9));
+}
+
+void MixedTriggers::GetState(u16* const digital, const u16* bitmasks, ControlState* analog)
+{
+  const size_t trigger_count = controls.size() / 2;
+
+  for (size_t i = 0; i < trigger_count; ++i, ++bitmasks, ++analog)
+  {
+    if (controls[i]->control_ref->State() > numeric_settings[0]->GetValue())  // threshold
+    {
+      *analog = 1.0;
+      *digital |= *bitmasks;
+    }
+    else
+    {
+      *analog = controls[i + trigger_count]->control_ref->State();
+    }
+  }
+}
+}  // namespace ControllerEmu

Source/Core/InputCommon/ControllerEmu/ControlGroup/MixedTriggers.h

@@ -0,0 +1,19 @@
+// Copyright 2017 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <string>
+#include "InputCommon/ControllerEmu/ControlGroup/ControlGroup.h"
+
+namespace ControllerEmu
+{
+class MixedTriggers : public ControlGroup
+{
+public:
+  explicit MixedTriggers(const std::string& name);
+
+  void GetState(u16* digital, const u16* bitmasks, ControlState* analog);
+};
+}  // namespace ControllerEmu