general: Add missing copyright notices

core/hid: Add missing controller type

.ci/scripts/merge/apply-patches-by-label-private.py

@@ -25,7 +25,7 @@ def check_individual(repo_id, pr_id):
 
 def merge_pr(pn, ref):
     print("Matched PR# %s" % pn)
-    print(subprocess.check_output(["git", "fetch", "https://%sdev.azure.com/%s/_git/%s" % (user, org, repo), ref, "-f"]))
+    print(subprocess.check_output(["git", "fetch", "https://%sdev.azure.com/%s/_git/%s" % (user, org, repo), ref, "-f", "--no-recurse-submodules"]))
     print(subprocess.check_output(["git", "merge", "--squash", 'origin/' + ref.replace('refs/heads/','')]))
     print(subprocess.check_output(["git", "commit", "-m\"Merge %s PR %s\"" % (tagline, pn)]))
 

.ci/scripts/merge/apply-patches-by-label.py

@@ -1,7 +1,7 @@
 # Download all pull requests as patches that match a specific label
 # Usage: python download-patches-by-label.py <Label to Match> <Root Path Folder to DL to>
 
-import requests, sys, json, urllib3.request, shutil, subprocess, os
+import requests, sys, json, urllib3.request, shutil, subprocess, os, traceback
 
 tagline = sys.argv[2]
 
@@ -25,7 +25,7 @@ def do_page(page):
             if (check_individual(pr["labels"])):
                 pn = pr["number"]
                 print("Matched PR# %s" % pn)
-                print(subprocess.check_output(["git", "fetch", "https://github.com/yuzu-emu/yuzu.git", "pull/%s/head:pr-%s" % (pn, pn), "-f"]))
+                print(subprocess.check_output(["git", "fetch", "https://github.com/yuzu-emu/yuzu.git", "pull/%s/head:pr-%s" % (pn, pn), "-f", "--no-recurse-submodules"]))
                 print(subprocess.check_output(["git", "merge", "--squash", "pr-%s" % pn]))
                 print(subprocess.check_output(["git", "commit", "-m\"Merge %s PR %s\"" % (tagline, pn)]))
 
@@ -33,4 +33,5 @@ try:
     for i in range(1,30):
         do_page(i)
 except:
+    traceback.print_exc(file=sys.stdout)
     sys.exit(-1)

CMakeLists.txt

@@ -57,7 +57,7 @@ function(check_submodules_present)
         string(REGEX REPLACE "path *= *" "" module ${module})
         if (NOT EXISTS "${PROJECT_SOURCE_DIR}/${module}/.git")
             message(FATAL_ERROR "Git submodule ${module} not found. "
-                    "Please run: git submodule update --init --recursive")
+                    "Please run: \ngit submodule update --init --recursive")
         endif()
     endforeach()
 endfunction()
@@ -166,8 +166,8 @@ macro(yuzu_find_packages)
     # Capitalization matters here. We need the naming to match the generated paths from Conan
     set(REQUIRED_LIBS
     #    Cmake Pkg Prefix  Version     Conan Pkg
-        "Catch2            2.13        catch2/2.13.0"
-        "fmt               8.0         fmt/8.0.0"
+        "Catch2            2.13.7      catch2/2.13.7"
+        "fmt               8.0.1       fmt/8.0.1"
         "lz4               1.8         lz4/1.9.2"
         "nlohmann_json     3.8         nlohmann_json/3.8.0"
         "ZLIB              1.2         zlib/1.2.11"
@@ -600,6 +600,7 @@ if (YUZU_USE_BUNDLED_FFMPEG)
                 ${LIBVA_LIBRARIES})
             set(FFmpeg_HWACCEL_FLAGS
                 --enable-hwaccel=h264_vaapi
+                --enable-hwaccel=vp8_vaapi
                 --enable-hwaccel=vp9_vaapi
                 --enable-libdrm)
             list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS
@@ -620,6 +621,7 @@ if (YUZU_USE_BUNDLED_FFMPEG)
                 --enable-ffnvcodec
                 --enable-nvdec
                 --enable-hwaccel=h264_nvdec
+                --enable-hwaccel=vp8_nvdec
                 --enable-hwaccel=vp9_nvdec
                 --extra-cflags=-I${CUDA_INCLUDE_DIRS}
             )
@@ -670,6 +672,7 @@ if (YUZU_USE_BUNDLED_FFMPEG)
                     --disable-postproc
                     --disable-swresample
                     --enable-decoder=h264
+                    --enable-decoder=vp8
                     --enable-decoder=vp9
                     --cc="${CMAKE_C_COMPILER}"
                     --cxx="${CMAKE_CXX_COMPILER}"

externals/FidelityFX-FSR/license.txt

@@ -0,0 +1,19 @@
+Copyright (c) 2021 Advanced Micro Devices, Inc. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

src/audio_core/delay_line.cpp

@@ -1,3 +1,7 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
 #include <cstring>
 #include "audio_core/delay_line.h"
 

src/audio_core/delay_line.h

@@ -1,3 +1,7 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
 #pragma once
 
 #include "common/common_types.h"

src/common/CMakeLists.txt

@@ -73,6 +73,7 @@ add_library(common STATIC
     hex_util.h
     host_memory.cpp
     host_memory.h
+    input.h
     intrusive_red_black_tree.h
     literals.h
     logging/backend.cpp

src/common/bit_util.h

@@ -7,6 +7,7 @@
 #include <bit>
 #include <climits>
 #include <cstddef>
+#include <type_traits>
 
 #include "common/common_types.h"
 
@@ -44,4 +45,10 @@ template <typename T>
     return static_cast<u32>(log2_f + static_cast<u64>((value ^ (1ULL << log2_f)) != 0ULL));
 }
 
+template <typename T>
+requires std::is_integral_v<T>
+[[nodiscard]] T NextPow2(T value) {
+    return static_cast<T>(1ULL << ((8U * sizeof(T)) - std::countl_zero(value - 1U)));
+}
+
 } // namespace Common

src/common/host_memory.cpp

@@ -1,3 +1,7 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
 #ifdef _WIN32
 
 #include <iterator>

src/common/input.h

@@ -0,0 +1,372 @@
+// Copyright 2017 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include "common/logging/log.h"
+#include "common/param_package.h"
+#include "common/uuid.h"
+
+namespace Common::Input {
+
+// Type of data that is expected to recieve or send
+enum class InputType {
+    None,
+    Battery,
+    Button,
+    Stick,
+    Analog,
+    Trigger,
+    Motion,
+    Touch,
+    Color,
+    Vibration,
+    Nfc,
+    Ir,
+};
+
+// Internal battery charge level
+enum class BatteryLevel : u32 {
+    None,
+    Empty,
+    Critical,
+    Low,
+    Medium,
+    Full,
+    Charging,
+};
+
+enum class PollingMode {
+    // Constant polling of buttons, analogs and motion data
+    Active,
+    // Only update on button change, digital analogs
+    Pasive,
+    // Enable near field communication polling
+    NFC,
+    // Enable infrared camera polling
+    IR,
+};
+
+// Vibration reply from the controller
+enum class VibrationError {
+    None,
+    NotSupported,
+    Disabled,
+    Unknown,
+};
+
+// Polling mode reply from the controller
+enum class PollingError {
+    None,
+    NotSupported,
+    Unknown,
+};
+
+// Hint for amplification curve to be used
+enum class VibrationAmplificationType {
+    Linear,
+    Exponential,
+};
+
+// Analog properties for calibration
+struct AnalogProperties {
+    // Anything below this value will be detected as zero
+    float deadzone{};
+    // Anyting above this values will be detected as one
+    float range{1.0f};
+    // Minimum value to be detected as active
+    float threshold{0.5f};
+    // Drift correction applied to the raw data
+    float offset{};
+    // Invert direction of the sensor data
+    bool inverted{};
+};
+
+// Single analog sensor data
+struct AnalogStatus {
+    float value{};
+    float raw_value{};
+    AnalogProperties properties{};
+};
+
+// Button data
+struct ButtonStatus {
+    Common::UUID uuid{};
+    bool value{};
+    bool inverted{};
+    bool toggle{};
+    bool locked{};
+};
+
+// Internal battery data
+using BatteryStatus = BatteryLevel;
+
+// Analog and digital joystick data
+struct StickStatus {
+    Common::UUID uuid{};
+    AnalogStatus x{};
+    AnalogStatus y{};
+    bool left{};
+    bool right{};
+    bool up{};
+    bool down{};
+};
+
+// Analog and digital trigger data
+struct TriggerStatus {
+    Common::UUID uuid{};
+    AnalogStatus analog{};
+    ButtonStatus pressed{};
+};
+
+// 3D vector representing motion input
+struct MotionSensor {
+    AnalogStatus x{};
+    AnalogStatus y{};
+    AnalogStatus z{};
+};
+
+// Motion data used to calculate controller orientation
+struct MotionStatus {
+    // Gyroscope vector measurement in radians/s.
+    MotionSensor gyro{};
+    // Acceleration vector measurement in G force
+    MotionSensor accel{};
+    // Time since last measurement in microseconds
+    u64 delta_timestamp{};
+    // Request to update after reading the value
+    bool force_update{};
+};
+
+// Data of a single point on a touch screen
+struct TouchStatus {
+    ButtonStatus pressed{};
+    AnalogStatus x{};
+    AnalogStatus y{};
+    int id{};
+};
+
+// Physical controller color in RGB format
+struct BodyColorStatus {
+    u32 body{};
+    u32 buttons{};
+};
+
+// HD rumble data
+struct VibrationStatus {
+    f32 low_amplitude{};
+    f32 low_frequency{};
+    f32 high_amplitude{};
+    f32 high_frequency{};
+    VibrationAmplificationType type;
+};
+
+// Physical controller LED pattern
+struct LedStatus {
+    bool led_1{};
+    bool led_2{};
+    bool led_3{};
+    bool led_4{};
+};
+
+// List of buttons to be passed to Qt that can be translated
+enum class ButtonNames {
+    Undefined,
+    Invalid,
+    // This will display the engine name instead of the button name
+    Engine,
+    // This will display the button by value instead of the button name
+    Value,
+    ButtonLeft,
+    ButtonRight,
+    ButtonDown,
+    ButtonUp,
+    TriggerZ,
+    TriggerR,
+    TriggerL,
+    ButtonA,
+    ButtonB,
+    ButtonX,
+    ButtonY,
+    ButtonStart,
+
+    // DS4 button names
+    L1,
+    L2,
+    L3,
+    R1,
+    R2,
+    R3,
+    Circle,
+    Cross,
+    Square,
+    Triangle,
+    Share,
+    Options,
+};
+
+// Callback data consisting of an input type and the equivalent data status
+struct CallbackStatus {
+    InputType type{InputType::None};
+    ButtonStatus button_status{};
+    StickStatus stick_status{};
+    AnalogStatus analog_status{};
+    TriggerStatus trigger_status{};
+    MotionStatus motion_status{};
+    TouchStatus touch_status{};
+    BodyColorStatus color_status{};
+    BatteryStatus battery_status{};
+    VibrationStatus vibration_status{};
+};
+
+// Triggered once every input change
+struct InputCallback {
+    std::function<void(CallbackStatus)> on_change;
+};
+
+/// An abstract class template for an input device (a button, an analog input, etc.).
+class InputDevice {
+public:
+    virtual ~InputDevice() = default;
+
+    // Request input device to update if necessary
+    virtual void SoftUpdate() {
+        return;
+    }
+
+    // Force input device to update data regardless of the current state
+    virtual void ForceUpdate() {
+        return;
+    }
+
+    // Sets the function to be triggered when input changes
+    void SetCallback(InputCallback callback_) {
+        callback = std::move(callback_);
+    }
+
+    // Triggers the function set in the callback
+    void TriggerOnChange(CallbackStatus status) {
+        if (callback.on_change) {
+            callback.on_change(status);
+        }
+    }
+
+private:
+    InputCallback callback;
+};
+
+/// An abstract class template for an output device (rumble, LED pattern, polling mode).
+class OutputDevice {
+public:
+    virtual ~OutputDevice() = default;
+
+    virtual void SetLED([[maybe_unused]] LedStatus led_status) {
+        return;
+    }
+
+    virtual VibrationError SetVibration([[maybe_unused]] VibrationStatus vibration_status) {
+        return VibrationError::NotSupported;
+    }
+
+    virtual PollingError SetPollingMode([[maybe_unused]] PollingMode polling_mode) {
+        return PollingError::NotSupported;
+    }
+};
+
+/// An abstract class template for a factory that can create input devices.
+template <typename InputDeviceType>
+class Factory {
+public:
+    virtual ~Factory() = default;
+    virtual std::unique_ptr<InputDeviceType> Create(const Common::ParamPackage&) = 0;
+};
+
+namespace Impl {
+
+template <typename InputDeviceType>
+using FactoryListType = std::unordered_map<std::string, std::shared_ptr<Factory<InputDeviceType>>>;
+
+template <typename InputDeviceType>
+struct FactoryList {
+    static FactoryListType<InputDeviceType> list;
+};
+
+template <typename InputDeviceType>
+FactoryListType<InputDeviceType> FactoryList<InputDeviceType>::list;
+
+} // namespace Impl
+
+/**
+ * Registers an input device factory.
+ * @tparam InputDeviceType the type of input devices the factory can create
+ * @param name the name of the factory. Will be used to match the "engine" parameter when creating
+ *     a device
+ * @param factory the factory object to register
+ */
+template <typename InputDeviceType>
+void RegisterFactory(const std::string& name, std::shared_ptr<Factory<InputDeviceType>> factory) {
+    auto pair = std::make_pair(name, std::move(factory));
+    if (!Impl::FactoryList<InputDeviceType>::list.insert(std::move(pair)).second) {
+        LOG_ERROR(Input, "Factory '{}' already registered", name);
+    }
+}
+
+/**
+ * Unregisters an input device factory.
+ * @tparam InputDeviceType the type of input devices the factory can create
+ * @param name the name of the factory to unregister
+ */
+template <typename InputDeviceType>
+void UnregisterFactory(const std::string& name) {
+    if (Impl::FactoryList<InputDeviceType>::list.erase(name) == 0) {
+        LOG_ERROR(Input, "Factory '{}' not registered", name);
+    }
+}
+
+/**
+ * Create an input device from given paramters.
+ * @tparam InputDeviceType the type of input devices to create
+ * @param params a serialized ParamPackage string that contains all parameters for creating the
+ * device
+ */
+template <typename InputDeviceType>
+std::unique_ptr<InputDeviceType> CreateDeviceFromString(const std::string& params) {
+    const Common::ParamPackage package(params);
+    const std::string engine = package.Get("engine", "null");
+    const auto& factory_list = Impl::FactoryList<InputDeviceType>::list;
+    const auto pair = factory_list.find(engine);
+    if (pair == factory_list.end()) {
+        if (engine != "null") {
+            LOG_ERROR(Input, "Unknown engine name: {}", engine);
+        }
+        return std::make_unique<InputDeviceType>();
+    }
+    return pair->second->Create(package);
+}
+
+/**
+ * Create an input device from given paramters.
+ * @tparam InputDeviceType the type of input devices to create
+ * @param A ParamPackage that contains all parameters for creating the device
+ */
+template <typename InputDeviceType>
+std::unique_ptr<InputDeviceType> CreateDevice(const Common::ParamPackage package) {
+    const std::string engine = package.Get("engine", "null");
+    const auto& factory_list = Impl::FactoryList<InputDeviceType>::list;
+    const auto pair = factory_list.find(engine);
+    if (pair == factory_list.end()) {
+        if (engine != "null") {
+            LOG_ERROR(Input, "Unknown engine name: {}", engine);
+        }
+        return std::make_unique<InputDeviceType>();
+    }
+    return pair->second->Create(package);
+}
+
+} // namespace Common::Input

src/common/logging/backend.cpp

@@ -6,6 +6,7 @@
 #include <chrono>
 #include <climits>
 #include <exception>
+#include <stop_token>
 #include <thread>
 #include <vector>
 
@@ -186,6 +187,10 @@ public:
         initialization_in_progress_suppress_logging = false;
     }
 
+    static void Start() {
+        instance->StartBackendThread();
+    }
+
     Impl(const Impl&) = delete;
     Impl& operator=(const Impl&) = delete;
 
@@ -201,7 +206,7 @@ public:
     }
 
     void PushEntry(Class log_class, Level log_level, const char* filename, unsigned int line_num,
-                   const char* function, std::string message) {
+                   const char* function, std::string&& message) {
         if (!filter.CheckMessage(log_class, log_level))
             return;
         const Entry& entry =
@@ -211,40 +216,41 @@ public:
 
 private:
     Impl(const std::filesystem::path& file_backend_filename, const Filter& filter_)
-        : filter{filter_}, file_backend{file_backend_filename}, backend_thread{std::thread([this] {
-              Common::SetCurrentThreadName("yuzu:Log");
-              Entry entry;
-              const auto write_logs = [this, &entry]() {
-                  ForEachBackend([&entry](Backend& backend) { backend.Write(entry); });
-              };
-              while (true) {
-                  entry = message_queue.PopWait();
-                  if (entry.final_entry) {
-                      break;
-                  }
-                  write_logs();
-              }
-              // Drain the logging queue. Only writes out up to MAX_LOGS_TO_WRITE to prevent a
-              // case where a system is repeatedly spamming logs even on close.
-              int max_logs_to_write = filter.IsDebug() ? INT_MAX : 100;
-              while (max_logs_to_write-- && message_queue.Pop(entry)) {
-                  write_logs();
-              }
-          })} {}
+        : filter{filter_}, file_backend{file_backend_filename} {}
 
     ~Impl() {
         StopBackendThread();
     }
 
+    void StartBackendThread() {
+        backend_thread = std::thread([this] {
+            Common::SetCurrentThreadName("yuzu:Log");
+            Entry entry;
+            const auto write_logs = [this, &entry]() {
+                ForEachBackend([&entry](Backend& backend) { backend.Write(entry); });
+            };
+            while (!stop.stop_requested()) {
+                entry = message_queue.PopWait(stop.get_token());
+                if (entry.filename != nullptr) {
+                    write_logs();
+                }
+            }
+            // Drain the logging queue. Only writes out up to MAX_LOGS_TO_WRITE to prevent a
+            // case where a system is repeatedly spamming logs even on close.
+            int max_logs_to_write = filter.IsDebug() ? INT_MAX : 100;
+            while (max_logs_to_write-- && message_queue.Pop(entry)) {
+                write_logs();
+            }
+        });
+    }
+
     void StopBackendThread() {
-        Entry stop_entry{};
-        stop_entry.final_entry = true;
-        message_queue.Push(stop_entry);
+        stop.request_stop();
         backend_thread.join();
     }
 
     Entry CreateEntry(Class log_class, Level log_level, const char* filename, unsigned int line_nr,
-                      const char* function, std::string message) const {
+                      const char* function, std::string&& message) const {
         using std::chrono::duration_cast;
         using std::chrono::microseconds;
         using std::chrono::steady_clock;
@@ -257,7 +263,6 @@ private:
             .line_num = line_nr,
             .function = function,
             .message = std::move(message),
-            .final_entry = false,
         };
     }
 
@@ -278,8 +283,9 @@ private:
     ColorConsoleBackend color_console_backend{};
     FileBackend file_backend;
 
+    std::stop_source stop;
     std::thread backend_thread;
-    MPSCQueue<Entry> message_queue{};
+    MPSCQueue<Entry, true> message_queue{};
     std::chrono::steady_clock::time_point time_origin{std::chrono::steady_clock::now()};
 };
 } // namespace
@@ -288,6 +294,10 @@ void Initialize() {
     Impl::Initialize();
 }
 
+void Start() {
+    Impl::Start();
+}
+
 void DisableLoggingInTests() {
     initialization_in_progress_suppress_logging = true;
 }

src/common/logging/backend.h

@@ -14,6 +14,8 @@ class Filter;
 /// Initializes the logging system. This should be the first thing called in main.
 void Initialize();
 
+void Start();
+
 void DisableLoggingInTests();
 
 /**

src/common/logging/log_entry.h

@@ -22,7 +22,6 @@ struct Entry {
     unsigned int line_num = 0;
     std::string function;
     std::string message;
-    bool final_entry = false;
 };
 
 } // namespace Common::Log

src/common/math_util.h

@@ -48,8 +48,8 @@ struct Rectangle {
     }
 
     [[nodiscard]] Rectangle<T> Scale(const float s) const {
-        return Rectangle{left, top, static_cast<T>(left + GetWidth() * s),
-                         static_cast<T>(top + GetHeight() * s)};
+        return Rectangle{left, top, static_cast<T>(static_cast<float>(left + GetWidth()) * s),
+                         static_cast<T>(static_cast<float>(top + GetHeight()) * s)};
     }
 };
 

src/common/settings.cpp

@@ -47,7 +47,9 @@ void LogSettings() {
     log_setting("System_TimeZoneIndex", values.time_zone_index.GetValue());
     log_setting("Core_UseMultiCore", values.use_multi_core.GetValue());
     log_setting("CPU_Accuracy", values.cpu_accuracy.GetValue());
-    log_setting("Renderer_UseResolutionFactor", values.resolution_factor.GetValue());
+    log_setting("Renderer_UseResolutionScaling", values.resolution_setup.GetValue());
+    log_setting("Renderer_ScalingFilter", values.scaling_filter.GetValue());
+    log_setting("Renderer_AntiAliasing", values.anti_aliasing.GetValue());
     log_setting("Renderer_UseSpeedLimit", values.use_speed_limit.GetValue());
     log_setting("Renderer_SpeedLimit", values.speed_limit.GetValue());
     log_setting("Renderer_UseDiskShaderCache", values.use_disk_shader_cache.GetValue());
@@ -105,6 +107,55 @@ float Volume() {
     return values.volume.GetValue() / 100.0f;
 }
 
+void UpdateRescalingInfo() {
+    const auto setup = values.resolution_setup.GetValue();
+    auto& info = values.resolution_info;
+    info.downscale = false;
+    switch (setup) {
+    case ResolutionSetup::Res1_2X:
+        info.up_scale = 1;
+        info.down_shift = 1;
+        info.downscale = true;
+        break;
+    case ResolutionSetup::Res3_4X:
+        info.up_scale = 3;
+        info.down_shift = 2;
+        info.downscale = true;
+        break;
+    case ResolutionSetup::Res1X:
+        info.up_scale = 1;
+        info.down_shift = 0;
+        break;
+    case ResolutionSetup::Res2X:
+        info.up_scale = 2;
+        info.down_shift = 0;
+        break;
+    case ResolutionSetup::Res3X:
+        info.up_scale = 3;
+        info.down_shift = 0;
+        break;
+    case ResolutionSetup::Res4X:
+        info.up_scale = 4;
+        info.down_shift = 0;
+        break;
+    case ResolutionSetup::Res5X:
+        info.up_scale = 5;
+        info.down_shift = 0;
+        break;
+    case ResolutionSetup::Res6X:
+        info.up_scale = 6;
+        info.down_shift = 0;
+        break;
+    default:
+        UNREACHABLE();
+        info.up_scale = 1;
+        info.down_shift = 0;
+    }
+    info.up_factor = static_cast<f32>(info.up_scale) / (1U << info.down_shift);
+    info.down_factor = static_cast<f32>(1U << info.down_shift) / info.up_scale;
+    info.active = info.up_scale != 1 || info.down_shift != 0;
+}
+
 void RestoreGlobalState(bool is_powered_on) {
     // If a game is running, DO NOT restore the global settings state
     if (is_powered_on) {
@@ -132,6 +183,7 @@ void RestoreGlobalState(bool is_powered_on) {
     values.max_anisotropy.SetGlobal(true);
     values.use_speed_limit.SetGlobal(true);
     values.speed_limit.SetGlobal(true);
+    values.fps_cap.SetGlobal(true);
     values.use_disk_shader_cache.SetGlobal(true);
     values.gpu_accuracy.SetGlobal(true);
     values.use_asynchronous_gpu_emulation.SetGlobal(true);

src/common/settings.h

@@ -6,7 +6,6 @@
 
 #include <algorithm>
 #include <array>
-#include <atomic>
 #include <map>
 #include <optional>
 #include <string>
@@ -52,6 +51,56 @@ enum class NvdecEmulation : u32 {
     GPU = 2,
 };
 
+enum class ResolutionSetup : u32 {
+    Res1_2X = 0,
+    Res3_4X = 1,
+    Res1X = 2,
+    Res2X = 3,
+    Res3X = 4,
+    Res4X = 5,
+    Res5X = 6,
+    Res6X = 7,
+};
+
+enum class ScalingFilter : u32 {
+    NearestNeighbor = 0,
+    Bilinear = 1,
+    Bicubic = 2,
+    Gaussian = 3,
+    ScaleForce = 4,
+    Fsr = 5,
+    LastFilter = Fsr,
+};
+
+enum class AntiAliasing : u32 {
+    None = 0,
+    Fxaa = 1,
+    LastAA = Fxaa,
+};
+
+struct ResolutionScalingInfo {
+    u32 up_scale{1};
+    u32 down_shift{0};
+    f32 up_factor{1.0f};
+    f32 down_factor{1.0f};
+    bool active{};
+    bool downscale{};
+
+    s32 ScaleUp(s32 value) const {
+        if (value == 0) {
+            return 0;
+        }
+        return std::max((value * static_cast<s32>(up_scale)) >> static_cast<s32>(down_shift), 1);
+    }
+
+    u32 ScaleUp(u32 value) const {
+        if (value == 0U) {
+            return 0U;
+        }
+        return std::max((value * up_scale) >> down_shift, 1U);
+    }
+};
+
 /** The BasicSetting class is a simple resource manager. It defines a label and default value
  * alongside the actual value of the setting for simpler and less-error prone use with frontend
  * configurations. Setting a default value and label is required, though subclasses may deviate from
@@ -451,7 +500,10 @@ struct Values {
                                                          "disable_shader_loop_safety_checks"};
     Setting<int> vulkan_device{0, "vulkan_device"};
 
-    Setting<u16> resolution_factor{1, "resolution_factor"};
+    ResolutionScalingInfo resolution_info{};
+    Setting<ResolutionSetup> resolution_setup{ResolutionSetup::Res1X, "resolution_setup"};
+    Setting<ScalingFilter> scaling_filter{ScalingFilter::Bilinear, "scaling_filter"};
+    Setting<AntiAliasing> anti_aliasing{AntiAliasing::None, "anti_aliasing"};
     // *nix platforms may have issues with the borderless windowed fullscreen mode.
     // Default to exclusive fullscreen on these platforms for now.
     RangedSetting<FullscreenMode> fullscreen_mode{
@@ -462,7 +514,7 @@ struct Values {
 #endif
         FullscreenMode::Borderless, FullscreenMode::Exclusive, "fullscreen_mode"};
     RangedSetting<int> aspect_ratio{0, 0, 3, "aspect_ratio"};
-    RangedSetting<int> max_anisotropy{0, 0, 4, "max_anisotropy"};
+    RangedSetting<int> max_anisotropy{0, 0, 5, "max_anisotropy"};
     Setting<bool> use_speed_limit{true, "use_speed_limit"};
     RangedSetting<u16> speed_limit{100, 0, 9999, "speed_limit"};
     Setting<bool> use_disk_shader_cache{true, "use_disk_shader_cache"};
@@ -472,7 +524,7 @@ struct Values {
     Setting<NvdecEmulation> nvdec_emulation{NvdecEmulation::GPU, "nvdec_emulation"};
     Setting<bool> accelerate_astc{true, "accelerate_astc"};
     Setting<bool> use_vsync{true, "use_vsync"};
-    BasicRangedSetting<u16> fps_cap{1000, 1, 1000, "fps_cap"};
+    RangedSetting<u16> fps_cap{1000, 1, 1000, "fps_cap"};
     BasicSetting<bool> disable_fps_limit{false, "disable_fps_limit"};
     RangedSetting<ShaderBackend> shader_backend{ShaderBackend::GLASM, ShaderBackend::GLSL,
                                                 ShaderBackend::SPIRV, "shader_backend"};
@@ -507,25 +559,19 @@ struct Values {
     Setting<bool> enable_accurate_vibrations{false, "enable_accurate_vibrations"};
 
     Setting<bool> motion_enabled{true, "motion_enabled"};
-    BasicSetting<std::string> motion_device{"engine:motion_emu,update_period:100,sensitivity:0.01",
-                                            "motion_device"};
     BasicSetting<std::string> udp_input_servers{"127.0.0.1:26760", "udp_input_servers"};
+    BasicSetting<bool> enable_udp_controller{false, "enable_udp_controller"};
 
     BasicSetting<bool> pause_tas_on_load{true, "pause_tas_on_load"};
     BasicSetting<bool> tas_enable{false, "tas_enable"};
     BasicSetting<bool> tas_loop{false, "tas_loop"};
-    BasicSetting<bool> tas_swap_controllers{true, "tas_swap_controllers"};
 
     BasicSetting<bool> mouse_panning{false, "mouse_panning"};
     BasicRangedSetting<u8> mouse_panning_sensitivity{10, 1, 100, "mouse_panning_sensitivity"};
     BasicSetting<bool> mouse_enabled{false, "mouse_enabled"};
-    std::string mouse_device;
-    MouseButtonsRaw mouse_buttons;
 
     BasicSetting<bool> emulate_analog_keyboard{false, "emulate_analog_keyboard"};
     BasicSetting<bool> keyboard_enabled{false, "keyboard_enabled"};
-    KeyboardKeysRaw keyboard_keys;
-    KeyboardModsRaw keyboard_mods;
 
     BasicSetting<bool> debug_pad_enabled{false, "debug_pad_enabled"};
     ButtonsRaw debug_pad_buttons;
@@ -533,14 +579,11 @@ struct Values {
 
     TouchscreenInput touchscreen;
 
-    BasicSetting<bool> use_touch_from_button{false, "use_touch_from_button"};
     BasicSetting<std::string> touch_device{"min_x:100,min_y:50,max_x:1800,max_y:850",
                                            "touch_device"};
     BasicSetting<int> touch_from_button_map_index{0, "touch_from_button_map"};
     std::vector<TouchFromButtonMap> touch_from_button_maps;
 
-    std::atomic_bool is_device_reload_pending{true};
-
     // Data Storage
     BasicSetting<bool> use_virtual_sd{true, "use_virtual_sd"};
     BasicSetting<bool> gamecard_inserted{false, "gamecard_inserted"};
@@ -561,6 +604,7 @@ struct Values {
     BasicSetting<bool> extended_logging{false, "extended_logging"};
     BasicSetting<bool> use_debug_asserts{false, "use_debug_asserts"};
     BasicSetting<bool> use_auto_stub{false, "use_auto_stub"};
+    BasicSetting<bool> enable_all_controllers{false, "enable_all_controllers"};
 
     // Miscellaneous
     BasicSetting<std::string> log_filter{"*:Info", "log_filter"};
@@ -595,6 +639,8 @@ std::string GetTimeZoneString();
 
 void LogSettings();
 
+void UpdateRescalingInfo();
+
 // Restore the global state of all applicable settings in the Values struct
 void RestoreGlobalState(bool is_powered_on);
 

src/common/settings_input.h

@@ -62,11 +62,22 @@ enum Values : int {
 
 constexpr int STICK_HID_BEGIN = LStick;
 constexpr int STICK_HID_END = NumAnalogs;
-constexpr int NUM_STICKS_HID = NumAnalogs;
 
 extern const std::array<const char*, NumAnalogs> mapping;
 } // namespace NativeAnalog
 
+namespace NativeTrigger {
+enum Values : int {
+    LTrigger,
+    RTrigger,
+
+    NumTriggers,
+};
+
+constexpr int TRIGGER_HID_BEGIN = LTrigger;
+constexpr int TRIGGER_HID_END = NumTriggers;
+} // namespace NativeTrigger
+
 namespace NativeVibration {
 enum Values : int {
     LeftVibrationDevice,
@@ -115,10 +126,20 @@ constexpr int NUM_MOUSE_HID = NumMouseButtons;
 extern const std::array<const char*, NumMouseButtons> mapping;
 } // namespace NativeMouseButton
 
+namespace NativeMouseWheel {
+enum Values {
+    X,
+    Y,
+
+    NumMouseWheels,
+};
+
+extern const std::array<const char*, NumMouseWheels> mapping;
+} // namespace NativeMouseWheel
+
 namespace NativeKeyboard {
 enum Keys {
     None,
-    Error,
 
     A = 4,
     B,
@@ -156,22 +177,22 @@ enum Keys {
     N8,
     N9,
     N0,
-    Enter,
+    Return,
     Escape,
     Backspace,
     Tab,
     Space,
     Minus,
-    Equal,
-    LeftBrace,
-    RightBrace,
-    Backslash,
+    Plus,
+    OpenBracket,
+    CloseBracket,
+    Pipe,
     Tilde,
     Semicolon,
-    Apostrophe,
-    Grave,
+    Quote,
+    Backquote,
     Comma,
-    Dot,
+    Period,
     Slash,
     CapsLockKey,
 
@@ -188,7 +209,7 @@ enum Keys {
     F11,
     F12,
 
-    SystemRequest,
+    PrintScreen,
     ScrollLockKey,
     Pause,
     Insert,
@@ -257,8 +278,18 @@ enum Keys {
     ScrollLockActive,
     KPComma,
 
-    KPLeftParenthesis,
-    KPRightParenthesis,
+    Ro = 0x87,
+    KatakanaHiragana,
+    Yen,
+    Henkan,
+    Muhenkan,
+    NumPadCommaPc98,
+
+    HangulEnglish = 0x90,
+    Hanja,
+    KatakanaKey,
+    HiraganaKey,
+    ZenkakuHankaku,
 
     LeftControlKey = 0xE0,
     LeftShiftKey,
@@ -307,6 +338,8 @@ enum Modifiers {
     CapsLock,
     ScrollLock,
     NumLock,
+    Katakana,
+    Hiragana,
 
     NumKeyboardMods,
 };
@@ -324,11 +357,6 @@ constexpr int NUM_KEYBOARD_MODS_HID = NumKeyboardMods;
 using AnalogsRaw = std::array<std::string, NativeAnalog::NumAnalogs>;
 using ButtonsRaw = std::array<std::string, NativeButton::NumButtons>;
 using MotionsRaw = std::array<std::string, NativeMotion::NumMotions>;
-using VibrationsRaw = std::array<std::string, NativeVibration::NumVibrations>;
-
-using MouseButtonsRaw = std::array<std::string, NativeMouseButton::NumMouseButtons>;
-using KeyboardKeysRaw = std::array<std::string, NativeKeyboard::NumKeyboardKeys>;
-using KeyboardModsRaw = std::array<std::string, NativeKeyboard::NumKeyboardMods>;
 
 constexpr u32 JOYCON_BODY_NEON_RED = 0xFF3C28;
 constexpr u32 JOYCON_BUTTONS_NEON_RED = 0x1E0A0A;
@@ -342,6 +370,11 @@ enum class ControllerType {
     RightJoycon,
     Handheld,
     GameCube,
+    Pokeball,
+    NES,
+    SNES,
+    N64,
+    SegaGenesis,
 };
 
 struct PlayerInput {
@@ -349,7 +382,6 @@ struct PlayerInput {
     ControllerType controller_type;
     ButtonsRaw buttons;
     AnalogsRaw analogs;
-    VibrationsRaw vibrations;
     MotionsRaw motions;
 
     bool vibration_enabled;

src/common/x64/native_clock.cpp

@@ -15,26 +15,26 @@
 namespace Common {
 
 u64 EstimateRDTSCFrequency() {
-    const auto milli_10 = std::chrono::milliseconds{10};
-    // get current time
+    // Discard the first result measuring the rdtsc.
     _mm_mfence();
-    const u64 tscStart = __rdtsc();
-    const auto startTime = std::chrono::high_resolution_clock::now();
-    // wait roughly 3 seconds
-    while (true) {
-        auto milli = std::chrono::duration_cast<std::chrono::milliseconds>(
-            std::chrono::high_resolution_clock::now() - startTime);
-        if (milli.count() >= 3000)
-            break;
-        std::this_thread::sleep_for(milli_10);
-    }
-    const auto endTime = std::chrono::high_resolution_clock::now();
+    __rdtsc();
+    std::this_thread::sleep_for(std::chrono::milliseconds{1});
     _mm_mfence();
-    const u64 tscEnd = __rdtsc();
-    // calculate difference
-    const u64 timer_diff =
-        std::chrono::duration_cast<std::chrono::nanoseconds>(endTime - startTime).count();
-    const u64 tsc_diff = tscEnd - tscStart;
+    __rdtsc();
+
+    // Get the current time.
+    const auto start_time = std::chrono::steady_clock::now();
+    _mm_mfence();
+    const u64 tsc_start = __rdtsc();
+    // Wait for 200 milliseconds.
+    std::this_thread::sleep_for(std::chrono::milliseconds{200});
+    const auto end_time = std::chrono::steady_clock::now();
+    _mm_mfence();
+    const u64 tsc_end = __rdtsc();
+    // Calculate differences.
+    const u64 timer_diff = static_cast<u64>(
+        std::chrono::duration_cast<std::chrono::nanoseconds>(end_time - start_time).count());
+    const u64 tsc_diff = tsc_end - tsc_start;
     const u64 tsc_freq = MultiplyAndDivide64(tsc_diff, 1000000000ULL, timer_diff);
     return tsc_freq;
 }

src/core/CMakeLists.txt

@@ -132,11 +132,23 @@ add_library(core STATIC
     frontend/emu_window.h
     frontend/framebuffer_layout.cpp
     frontend/framebuffer_layout.h
-    frontend/input_interpreter.cpp
-    frontend/input_interpreter.h
-    frontend/input.h
     hardware_interrupt_manager.cpp
     hardware_interrupt_manager.h
+    hid/emulated_console.cpp
+    hid/emulated_console.h
+    hid/emulated_controller.cpp
+    hid/emulated_controller.h
+    hid/emulated_devices.cpp
+    hid/emulated_devices.h
+    hid/hid_core.cpp
+    hid/hid_core.h
+    hid/hid_types.h
+    hid/input_converter.cpp
+    hid/input_converter.h
+    hid/input_interpreter.cpp
+    hid/input_interpreter.h
+    hid/motion_input.cpp
+    hid/motion_input.h
     hle/api_version.h
     hle/ipc.h
     hle/ipc_helpers.h
@@ -402,6 +414,7 @@ add_library(core STATIC
     hle/service/hid/hid.h
     hle/service/hid/irs.cpp
     hle/service/hid/irs.h
+    hle/service/hid/ring_lifo.h
     hle/service/hid/xcd.cpp
     hle/service/hid/xcd.h
     hle/service/hid/errors.h
@@ -466,6 +479,8 @@ add_library(core STATIC
     hle/service/ns/language.h
     hle/service/ns/ns.cpp
     hle/service/ns/ns.h
+    hle/service/ns/pdm_qry.cpp
+    hle/service/ns/pdm_qry.h
     hle/service/ns/pl_u.cpp
     hle/service/ns/pl_u.h
     hle/service/nvdrv/devices/nvdevice.h

src/core/arm/dynarmic/arm_dynarmic_64.cpp

@@ -86,6 +86,26 @@ public:
                   num_instructions, MemoryReadCode(pc));
     }
 
+    void InstructionCacheOperationRaised(Dynarmic::A64::InstructionCacheOperation op,
+                                         VAddr value) override {
+        switch (op) {
+        case Dynarmic::A64::InstructionCacheOperation::InvalidateByVAToPoU: {
+            static constexpr u64 ICACHE_LINE_SIZE = 64;
+
+            const u64 cache_line_start = value & ~(ICACHE_LINE_SIZE - 1);
+            parent.InvalidateCacheRange(cache_line_start, ICACHE_LINE_SIZE);
+            break;
+        }
+        case Dynarmic::A64::InstructionCacheOperation::InvalidateAllToPoU:
+            parent.ClearInstructionCache();
+            break;
+        case Dynarmic::A64::InstructionCacheOperation::InvalidateAllToPoUInnerSharable:
+        default:
+            LOG_DEBUG(Core_ARM, "Unprocesseed instruction cache operation: {}", op);
+            break;
+        }
+    }
+
     void ExceptionRaised(u64 pc, Dynarmic::A64::Exception exception) override {
         switch (exception) {
         case Dynarmic::A64::Exception::WaitForInterrupt:

src/core/core.cpp

@@ -27,6 +27,7 @@
 #include "core/file_sys/vfs_concat.h"
 #include "core/file_sys/vfs_real.h"
 #include "core/hardware_interrupt_manager.h"
+#include "core/hid/hid_core.h"
 #include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/k_scheduler.h"
 #include "core/hle/kernel/kernel.h"
@@ -126,7 +127,7 @@ FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
 
 struct System::Impl {
     explicit Impl(System& system)
-        : kernel{system}, fs_controller{system}, memory{system},
+        : kernel{system}, fs_controller{system}, memory{system}, hid_core{},
           cpu_manager{system}, reporter{system}, applet_manager{system}, time_manager{system} {}
 
     SystemResultStatus Run() {
@@ -349,7 +350,7 @@ struct System::Impl {
         }
 
         Service::Glue::ApplicationLaunchProperty launch{};
-        launch.title_id = process.GetTitleID();
+        launch.title_id = process.GetProgramID();
 
         FileSys::PatchManager pm{launch.title_id, fs_controller, *content_provider};
         launch.version = pm.GetGameVersion().value_or(0);
@@ -391,6 +392,7 @@ struct System::Impl {
     std::unique_ptr<Hardware::InterruptManager> interrupt_manager;
     std::unique_ptr<Core::DeviceMemory> device_memory;
     Core::Memory::Memory memory;
+    Core::HID::HIDCore hid_core;
     CpuManager cpu_manager;
     std::atomic_bool is_powered_on{};
     bool exit_lock = false;
@@ -615,6 +617,14 @@ const Kernel::KernelCore& System::Kernel() const {
     return impl->kernel;
 }
 
+HID::HIDCore& System::HIDCore() {
+    return impl->hid_core;
+}
+
+const HID::HIDCore& System::HIDCore() const {
+    return impl->hid_core;
+}
+
 Timing::CoreTiming& System::CoreTiming() {
     return impl->core_timing;
 }
@@ -639,6 +649,10 @@ const Core::SpeedLimiter& System::SpeedLimiter() const {
     return impl->speed_limiter;
 }
 
+u64 System::GetCurrentProcessProgramID() const {
+    return impl->kernel.CurrentProcess()->GetProgramID();
+}
+
 Loader::ResultStatus System::GetGameName(std::string& out) const {
     return impl->GetGameName(out);
 }
@@ -821,8 +835,6 @@ void System::ApplySettings() {
     if (IsPoweredOn()) {
         Renderer().RefreshBaseSettings();
     }
-
-    Service::HID::ReloadInputDevices();
 }
 
 } // namespace Core

src/core/core.h

@@ -89,6 +89,10 @@ namespace Core::Hardware {
 class InterruptManager;
 }
 
+namespace Core::HID {
+class HIDCore;
+}
+
 namespace Core {
 
 class ARM_Interface;
@@ -285,6 +289,12 @@ public:
     /// Provides a constant reference to the kernel instance.
     [[nodiscard]] const Kernel::KernelCore& Kernel() const;
 
+    /// Gets a mutable reference to the HID interface.
+    [[nodiscard]] HID::HIDCore& HIDCore();
+
+    /// Gets an immutable reference to the HID interface.
+    [[nodiscard]] const HID::HIDCore& HIDCore() const;
+
     /// Provides a reference to the internal PerfStats instance.
     [[nodiscard]] Core::PerfStats& GetPerfStats();
 
@@ -297,6 +307,8 @@ public:
     /// Provides a constant reference to the speed limiter
     [[nodiscard]] const Core::SpeedLimiter& SpeedLimiter() const;
 
+    [[nodiscard]] u64 GetCurrentProcessProgramID() const;
+
     /// Gets the name of the current game
     [[nodiscard]] Loader::ResultStatus GetGameName(std::string& out) const;
 

src/core/file_sys/program_metadata.cpp

@@ -53,13 +53,16 @@ Loader::ResultStatus ProgramMetadata::Load(VirtualFile file) {
 }
 
 /*static*/ ProgramMetadata ProgramMetadata::GetDefault() {
+    // Allow use of cores 0~3 and thread priorities 1~63.
+    constexpr u32 default_thread_info_capability = 0x30007F7;
+
     ProgramMetadata result;
 
     result.LoadManual(
         true /*is_64_bit*/, FileSys::ProgramAddressSpaceType::Is39Bit /*address_space*/,
         0x2c /*main_thread_prio*/, 0 /*main_thread_core*/, 0x00100000 /*main_thread_stack_size*/,
         0 /*title_id*/, 0xFFFFFFFFFFFFFFFF /*filesystem_permissions*/,
-        0x1FE00000 /*system_resource_size*/, {} /*capabilities*/);
+        0x1FE00000 /*system_resource_size*/, {default_thread_info_capability} /*capabilities*/);
 
     return result;
 }

src/core/file_sys/savedata_factory.cpp

@@ -9,7 +9,6 @@
 #include "core/core.h"
 #include "core/file_sys/savedata_factory.h"
 #include "core/file_sys/vfs.h"
-#include "core/hle/kernel/k_process.h"
 
 namespace FileSys {
 
@@ -143,7 +142,7 @@ std::string SaveDataFactory::GetFullPath(Core::System& system, SaveDataSpaceId s
     // be interpreted as the title id of the current process.
     if (type == SaveDataType::SaveData || type == SaveDataType::DeviceSaveData) {
         if (title_id == 0) {
-            title_id = system.CurrentProcess()->GetTitleID();
+            title_id = system.GetCurrentProcessProgramID();
         }
     }
 

src/core/frontend/applets/controller.cpp

@@ -5,16 +5,15 @@
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "core/frontend/applets/controller.h"
-#include "core/hle/service/hid/controllers/npad.h"
-#include "core/hle/service/hid/hid.h"
-#include "core/hle/service/sm/sm.h"
+#include "core/hid/emulated_controller.h"
+#include "core/hid/hid_core.h"
+#include "core/hid/hid_types.h"
 
 namespace Core::Frontend {
 
 ControllerApplet::~ControllerApplet() = default;
 
-DefaultControllerApplet::DefaultControllerApplet(Service::SM::ServiceManager& service_manager_)
-    : service_manager{service_manager_} {}
+DefaultControllerApplet::DefaultControllerApplet(HID::HIDCore& hid_core_) : hid_core{hid_core_} {}
 
 DefaultControllerApplet::~DefaultControllerApplet() = default;
 
@@ -22,24 +21,20 @@ void DefaultControllerApplet::ReconfigureControllers(std::function<void()> callb
                                                      const ControllerParameters& parameters) const {
     LOG_INFO(Service_HID, "called, deducing the best configuration based on the given parameters!");
 
-    auto& npad =
-        service_manager.GetService<Service::HID::Hid>("hid")
-            ->GetAppletResource()
-            ->GetController<Service::HID::Controller_NPad>(Service::HID::HidController::NPad);
-
-    auto& players = Settings::values.players.GetValue();
-
     const std::size_t min_supported_players =
         parameters.enable_single_mode ? 1 : parameters.min_players;
 
     // Disconnect Handheld first.
-    npad.DisconnectNpadAtIndex(8);
+    auto* handheld = hid_core.GetEmulatedController(Core::HID::NpadIdType::Handheld);
+    handheld->Disconnect();
 
     // Deduce the best configuration based on the input parameters.
-    for (std::size_t index = 0; index < players.size() - 2; ++index) {
+    for (std::size_t index = 0; index < hid_core.available_controllers - 2; ++index) {
+        auto* controller = hid_core.GetEmulatedControllerByIndex(index);
+
         // First, disconnect all controllers regardless of the value of keep_controllers_connected.
         // This makes it easy to connect the desired controllers.
-        npad.DisconnectNpadAtIndex(index);
+        controller->Disconnect();
 
         // Only connect the minimum number of required players.
         if (index >= min_supported_players) {
@@ -49,27 +44,27 @@ void DefaultControllerApplet::ReconfigureControllers(std::function<void()> callb
         // Connect controllers based on the following priority list from highest to lowest priority:
         // Pro Controller -> Dual Joycons -> Left Joycon/Right Joycon -> Handheld
         if (parameters.allow_pro_controller) {
-            npad.AddNewControllerAt(
-                npad.MapSettingsTypeToNPad(Settings::ControllerType::ProController), index);
+            controller->SetNpadStyleIndex(Core::HID::NpadStyleIndex::ProController);
+            controller->Connect();
         } else if (parameters.allow_dual_joycons) {
-            npad.AddNewControllerAt(
-                npad.MapSettingsTypeToNPad(Settings::ControllerType::DualJoyconDetached), index);
+            controller->SetNpadStyleIndex(Core::HID::NpadStyleIndex::JoyconDual);
+            controller->Connect();
         } else if (parameters.allow_left_joycon && parameters.allow_right_joycon) {
             // Assign left joycons to even player indices and right joycons to odd player indices.
             // We do this since Captain Toad Treasure Tracker expects a left joycon for Player 1 and
             // a right Joycon for Player 2 in 2 Player Assist mode.
             if (index % 2 == 0) {
-                npad.AddNewControllerAt(
-                    npad.MapSettingsTypeToNPad(Settings::ControllerType::LeftJoycon), index);
+                controller->SetNpadStyleIndex(Core::HID::NpadStyleIndex::JoyconLeft);
+                controller->Connect();
             } else {
-                npad.AddNewControllerAt(
-                    npad.MapSettingsTypeToNPad(Settings::ControllerType::RightJoycon), index);
+                controller->SetNpadStyleIndex(Core::HID::NpadStyleIndex::JoyconRight);
+                controller->Connect();
             }
         } else if (index == 0 && parameters.enable_single_mode && parameters.allow_handheld &&
                    !Settings::values.use_docked_mode.GetValue()) {
             // We should *never* reach here under any normal circumstances.
-            npad.AddNewControllerAt(npad.MapSettingsTypeToNPad(Settings::ControllerType::Handheld),
-                                    index);
+            controller->SetNpadStyleIndex(Core::HID::NpadStyleIndex::Handheld);
+            controller->Connect();
         } else {
             UNREACHABLE_MSG("Unable to add a new controller based on the given parameters!");
         }

src/core/frontend/applets/controller.h

@@ -8,8 +8,8 @@
 
 #include "common/common_types.h"
 
-namespace Service::SM {
-class ServiceManager;
+namespace Core::HID {
+class HIDCore;
 }
 
 namespace Core::Frontend {
@@ -44,14 +44,14 @@ public:
 
 class DefaultControllerApplet final : public ControllerApplet {
 public:
-    explicit DefaultControllerApplet(Service::SM::ServiceManager& service_manager_);
+    explicit DefaultControllerApplet(HID::HIDCore& hid_core_);
     ~DefaultControllerApplet() override;
 
     void ReconfigureControllers(std::function<void()> callback,
                                 const ControllerParameters& parameters) const override;
 
 private:
-    Service::SM::ServiceManager& service_manager;
+    HID::HIDCore& hid_core;
 };
 
 } // namespace Core::Frontend

src/core/frontend/applets/software_keyboard.cpp

@@ -16,7 +16,8 @@ DefaultSoftwareKeyboardApplet::~DefaultSoftwareKeyboardApplet() = default;
 
 void DefaultSoftwareKeyboardApplet::InitializeKeyboard(
     bool is_inline, KeyboardInitializeParameters initialize_parameters,
-    std::function<void(Service::AM::Applets::SwkbdResult, std::u16string)> submit_normal_callback_,
+    std::function<void(Service::AM::Applets::SwkbdResult, std::u16string, bool)>
+        submit_normal_callback_,
     std::function<void(Service::AM::Applets::SwkbdReplyType, std::u16string, s32)>
         submit_inline_callback_) {
     if (is_inline) {
@@ -128,7 +129,7 @@ void DefaultSoftwareKeyboardApplet::ExitKeyboard() const {
 }
 
 void DefaultSoftwareKeyboardApplet::SubmitNormalText(std::u16string text) const {
-    submit_normal_callback(Service::AM::Applets::SwkbdResult::Ok, text);
+    submit_normal_callback(Service::AM::Applets::SwkbdResult::Ok, text, true);
 }
 
 void DefaultSoftwareKeyboardApplet::SubmitInlineText(std::u16string_view text) const {

src/core/frontend/applets/software_keyboard.h

@@ -57,7 +57,7 @@ public:
 
     virtual void InitializeKeyboard(
         bool is_inline, KeyboardInitializeParameters initialize_parameters,
-        std::function<void(Service::AM::Applets::SwkbdResult, std::u16string)>
+        std::function<void(Service::AM::Applets::SwkbdResult, std::u16string, bool)>
             submit_normal_callback_,
         std::function<void(Service::AM::Applets::SwkbdReplyType, std::u16string, s32)>
             submit_inline_callback_) = 0;
@@ -82,7 +82,7 @@ public:
 
     void InitializeKeyboard(
         bool is_inline, KeyboardInitializeParameters initialize_parameters,
-        std::function<void(Service::AM::Applets::SwkbdResult, std::u16string)>
+        std::function<void(Service::AM::Applets::SwkbdResult, std::u16string, bool)>
             submit_normal_callback_,
         std::function<void(Service::AM::Applets::SwkbdReplyType, std::u16string, s32)>
             submit_inline_callback_) override;
@@ -106,7 +106,7 @@ private:
 
     KeyboardInitializeParameters parameters;
 
-    mutable std::function<void(Service::AM::Applets::SwkbdResult, std::u16string)>
+    mutable std::function<void(Service::AM::Applets::SwkbdResult, std::u16string, bool)>
         submit_normal_callback;
     mutable std::function<void(Service::AM::Applets::SwkbdReplyType, std::u16string, s32)>
         submit_inline_callback;

src/core/frontend/emu_window.cpp

@@ -3,66 +3,31 @@
 // Refer to the license.txt file included.
 
 #include <mutex>
-#include "common/settings.h"
 #include "core/frontend/emu_window.h"
-#include "core/frontend/input.h"
 
 namespace Core::Frontend {
 
 GraphicsContext::~GraphicsContext() = default;
 
-class EmuWindow::TouchState : public Input::Factory<Input::TouchDevice>,
-                              public std::enable_shared_from_this<TouchState> {
-public:
-    std::unique_ptr<Input::TouchDevice> Create(const Common::ParamPackage&) override {
-        return std::make_unique<Device>(shared_from_this());
-    }
-
-    std::mutex mutex;
-
-    Input::TouchStatus status;
-
-private:
-    class Device : public Input::TouchDevice {
-    public:
-        explicit Device(std::weak_ptr<TouchState>&& touch_state_) : touch_state(touch_state_) {}
-        Input::TouchStatus GetStatus() const override {
-            if (auto state = touch_state.lock()) {
-                std::lock_guard guard{state->mutex};
-                return state->status;
-            }
-            return {};
-        }
-
-    private:
-        std::weak_ptr<TouchState> touch_state;
-    };
-};
-
 EmuWindow::EmuWindow() {
     // TODO: Find a better place to set this.
     config.min_client_area_size =
         std::make_pair(Layout::MinimumSize::Width, Layout::MinimumSize::Height);
     active_config = config;
-    touch_state = std::make_shared<TouchState>();
-    Input::RegisterFactory<Input::TouchDevice>("emu_window", touch_state);
 }
 
-EmuWindow::~EmuWindow() {
-    Input::UnregisterFactory<Input::TouchDevice>("emu_window");
-}
+EmuWindow::~EmuWindow() {}
 
-/**
- * Check if the given x/y coordinates are within the touchpad specified by the framebuffer layout
- * @param layout FramebufferLayout object describing the framebuffer size and screen positions
- * @param framebuffer_x Framebuffer x-coordinate to check
- * @param framebuffer_y Framebuffer y-coordinate to check
- * @return True if the coordinates are within the touchpad, otherwise false
- */
-static bool IsWithinTouchscreen(const Layout::FramebufferLayout& layout, u32 framebuffer_x,
-                                u32 framebuffer_y) {
-    return (framebuffer_y >= layout.screen.top && framebuffer_y < layout.screen.bottom &&
-            framebuffer_x >= layout.screen.left && framebuffer_x < layout.screen.right);
+std::pair<f32, f32> EmuWindow::MapToTouchScreen(u32 framebuffer_x, u32 framebuffer_y) const {
+    std::tie(framebuffer_x, framebuffer_y) = ClipToTouchScreen(framebuffer_x, framebuffer_y);
+    const float x =
+        static_cast<float>(framebuffer_x - framebuffer_layout.screen.left) /
+        static_cast<float>(framebuffer_layout.screen.right - framebuffer_layout.screen.left);
+    const float y =
+        static_cast<float>(framebuffer_y - framebuffer_layout.screen.top) /
+        static_cast<float>(framebuffer_layout.screen.bottom - framebuffer_layout.screen.top);
+
+    return std::make_pair(x, y);
 }
 
 std::pair<u32, u32> EmuWindow::ClipToTouchScreen(u32 new_x, u32 new_y) const {
@@ -75,49 +40,6 @@ std::pair<u32, u32> EmuWindow::ClipToTouchScreen(u32 new_x, u32 new_y) const {
     return std::make_pair(new_x, new_y);
 }
 
-void EmuWindow::TouchPressed(u32 framebuffer_x, u32 framebuffer_y, size_t id) {
-    if (!IsWithinTouchscreen(framebuffer_layout, framebuffer_x, framebuffer_y)) {
-        return;
-    }
-    if (id >= touch_state->status.size()) {
-        return;
-    }
-
-    std::lock_guard guard{touch_state->mutex};
-    const float x =
-        static_cast<float>(framebuffer_x - framebuffer_layout.screen.left) /
-        static_cast<float>(framebuffer_layout.screen.right - framebuffer_layout.screen.left);
-    const float y =
-        static_cast<float>(framebuffer_y - framebuffer_layout.screen.top) /
-        static_cast<float>(framebuffer_layout.screen.bottom - framebuffer_layout.screen.top);
-
-    touch_state->status[id] = std::make_tuple(x, y, true);
-}
-
-void EmuWindow::TouchReleased(size_t id) {
-    if (id >= touch_state->status.size()) {
-        return;
-    }
-    std::lock_guard guard{touch_state->mutex};
-    touch_state->status[id] = std::make_tuple(0.0f, 0.0f, false);
-}
-
-void EmuWindow::TouchMoved(u32 framebuffer_x, u32 framebuffer_y, size_t id) {
-    if (id >= touch_state->status.size()) {
-        return;
-    }
-
-    if (!std::get<2>(touch_state->status[id])) {
-        return;
-    }
-
-    if (!IsWithinTouchscreen(framebuffer_layout, framebuffer_x, framebuffer_y)) {
-        std::tie(framebuffer_x, framebuffer_y) = ClipToTouchScreen(framebuffer_x, framebuffer_y);
-    }
-
-    TouchPressed(framebuffer_x, framebuffer_y, id);
-}
-
 void EmuWindow::UpdateCurrentFramebufferLayout(u32 width, u32 height) {
     NotifyFramebufferLayoutChanged(Layout::DefaultFrameLayout(width, height));
 }

src/core/frontend/emu_window.h

@@ -112,28 +112,6 @@ public:
     /// Returns if window is shown (not minimized)
     virtual bool IsShown() const = 0;
 
-    /**
-     * Signal that a touch pressed event has occurred (e.g. mouse click pressed)
-     * @param framebuffer_x Framebuffer x-coordinate that was pressed
-     * @param framebuffer_y Framebuffer y-coordinate that was pressed
-     * @param id Touch event ID
-     */
-    void TouchPressed(u32 framebuffer_x, u32 framebuffer_y, size_t id);
-
-    /**
-     * Signal that a touch released event has occurred (e.g. mouse click released)
-     * @param id Touch event ID
-     */
-    void TouchReleased(size_t id);
-
-    /**
-     * Signal that a touch movement event has occurred (e.g. mouse was moved over the emu window)
-     * @param framebuffer_x Framebuffer x-coordinate
-     * @param framebuffer_y Framebuffer y-coordinate
-     * @param id Touch event ID
-     */
-    void TouchMoved(u32 framebuffer_x, u32 framebuffer_y, size_t id);
-
     /**
      * Returns currently active configuration.
      * @note Accesses to the returned object need not be consistent because it may be modified in
@@ -212,6 +190,11 @@ protected:
         client_area_height = size.second;
     }
 
+    /**
+     * Converts a screen postion into the equivalent touchscreen position.
+     */
+    std::pair<f32, f32> MapToTouchScreen(u32 framebuffer_x, u32 framebuffer_y) const;
+
     WindowSystemInfo window_info;
 
 private:
@@ -237,9 +220,6 @@ private:
     WindowConfig config;        ///< Internal configuration (changes pending for being applied in
                                 /// ProcessConfigurationChanges)
     WindowConfig active_config; ///< Internal active configuration
-
-    class TouchState;
-    std::shared_ptr<TouchState> touch_state;
 };
 
 } // namespace Core::Frontend

src/core/frontend/framebuffer_layout.cpp

@@ -25,7 +25,12 @@ FramebufferLayout DefaultFrameLayout(u32 width, u32 height) {
     ASSERT(height > 0);
     // The drawing code needs at least somewhat valid values for both screens
     // so just calculate them both even if the other isn't showing.
-    FramebufferLayout res{width, height, false, {}};
+    FramebufferLayout res{
+        .width = width,
+        .height = height,
+        .screen = {},
+        .is_srgb = false,
+    };
 
     const float window_aspect_ratio = static_cast<float>(height) / static_cast<float>(width);
     const float emulation_aspect_ratio = EmulationAspectRatio(
@@ -44,16 +49,13 @@ FramebufferLayout DefaultFrameLayout(u32 width, u32 height) {
     return res;
 }
 
-FramebufferLayout FrameLayoutFromResolutionScale(u32 res_scale) {
-    u32 width, height;
+FramebufferLayout FrameLayoutFromResolutionScale(f32 res_scale) {
+    const bool is_docked = Settings::values.use_docked_mode.GetValue();
+    const u32 screen_width = is_docked ? ScreenDocked::Width : ScreenUndocked::Width;
+    const u32 screen_height = is_docked ? ScreenDocked::Height : ScreenUndocked::Height;
 
-    if (Settings::values.use_docked_mode.GetValue()) {
-        width = ScreenDocked::Width * res_scale;
-        height = ScreenDocked::Height * res_scale;
-    } else {
-        width = ScreenUndocked::Width * res_scale;
-        height = ScreenUndocked::Height * res_scale;
-    }
+    const u32 width = static_cast<u32>(static_cast<f32>(screen_width) * res_scale);
+    const u32 height = static_cast<u32>(static_cast<f32>(screen_height) * res_scale);
 
     return DefaultFrameLayout(width, height);
 }

src/core/frontend/framebuffer_layout.h

@@ -35,17 +35,8 @@ enum class AspectRatio {
 struct FramebufferLayout {
     u32 width{ScreenUndocked::Width};
     u32 height{ScreenUndocked::Height};
-    bool is_srgb{};
-
     Common::Rectangle<u32> screen;
-
-    /**
-     * Returns the ration of pixel size of the screen, compared to the native size of the undocked
-     * Switch screen.
-     */
-    float GetScalingRatio() const {
-        return static_cast<float>(screen.GetWidth()) / ScreenUndocked::Width;
-    }
+    bool is_srgb{};
 };
 
 /**
@@ -60,7 +51,7 @@ FramebufferLayout DefaultFrameLayout(u32 width, u32 height);
  * Convenience method to get frame layout by resolution scale
  * @param res_scale resolution scale factor
  */
-FramebufferLayout FrameLayoutFromResolutionScale(u32 res_scale);
+FramebufferLayout FrameLayoutFromResolutionScale(f32 res_scale);
 
 /**
  * Convenience method to determine emulation aspect ratio

src/core/frontend/input.h

@@ -1,217 +0,0 @@
-// Copyright 2017 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <functional>
-#include <memory>
-#include <string>
-#include <tuple>
-#include <unordered_map>
-#include <utility>
-#include "common/logging/log.h"
-#include "common/param_package.h"
-#include "common/quaternion.h"
-#include "common/vector_math.h"
-
-namespace Input {
-
-enum class AnalogDirection : u8 {
-    RIGHT,
-    LEFT,
-    UP,
-    DOWN,
-};
-struct AnalogProperties {
-    float deadzone;
-    float range;
-    float threshold;
-};
-template <typename StatusType>
-struct InputCallback {
-    std::function<void(StatusType)> on_change;
-};
-
-/// An abstract class template for an input device (a button, an analog input, etc.).
-template <typename StatusType>
-class InputDevice {
-public:
-    virtual ~InputDevice() = default;
-    virtual StatusType GetStatus() const {
-        return {};
-    }
-    virtual StatusType GetRawStatus() const {
-        return GetStatus();
-    }
-    virtual AnalogProperties GetAnalogProperties() const {
-        return {};
-    }
-    virtual bool GetAnalogDirectionStatus([[maybe_unused]] AnalogDirection direction) const {
-        return {};
-    }
-    virtual bool SetRumblePlay([[maybe_unused]] f32 amp_low, [[maybe_unused]] f32 freq_low,
-                               [[maybe_unused]] f32 amp_high,
-                               [[maybe_unused]] f32 freq_high) const {
-        return {};
-    }
-    void SetCallback(InputCallback<StatusType> callback_) {
-        callback = std::move(callback_);
-    }
-    void TriggerOnChange() {
-        if (callback.on_change) {
-            callback.on_change(GetStatus());
-        }
-    }
-
-private:
-    InputCallback<StatusType> callback;
-};
-
-/// An abstract class template for a factory that can create input devices.
-template <typename InputDeviceType>
-class Factory {
-public:
-    virtual ~Factory() = default;
-    virtual std::unique_ptr<InputDeviceType> Create(const Common::ParamPackage&) = 0;
-};
-
-namespace Impl {
-
-template <typename InputDeviceType>
-using FactoryListType = std::unordered_map<std::string, std::shared_ptr<Factory<InputDeviceType>>>;
-
-template <typename InputDeviceType>
-struct FactoryList {
-    static FactoryListType<InputDeviceType> list;
-};
-
-template <typename InputDeviceType>
-FactoryListType<InputDeviceType> FactoryList<InputDeviceType>::list;
-
-} // namespace Impl
-
-/**
- * Registers an input device factory.
- * @tparam InputDeviceType the type of input devices the factory can create
- * @param name the name of the factory. Will be used to match the "engine" parameter when creating
- *     a device
- * @param factory the factory object to register
- */
-template <typename InputDeviceType>
-void RegisterFactory(const std::string& name, std::shared_ptr<Factory<InputDeviceType>> factory) {
-    auto pair = std::make_pair(name, std::move(factory));
-    if (!Impl::FactoryList<InputDeviceType>::list.insert(std::move(pair)).second) {
-        LOG_ERROR(Input, "Factory '{}' already registered", name);
-    }
-}
-
-/**
- * Unregisters an input device factory.
- * @tparam InputDeviceType the type of input devices the factory can create
- * @param name the name of the factory to unregister
- */
-template <typename InputDeviceType>
-void UnregisterFactory(const std::string& name) {
-    if (Impl::FactoryList<InputDeviceType>::list.erase(name) == 0) {
-        LOG_ERROR(Input, "Factory '{}' not registered", name);
-    }
-}
-
-/**
- * Create an input device from given paramters.
- * @tparam InputDeviceType the type of input devices to create
- * @param params a serialized ParamPackage string contains all parameters for creating the device
- */
-template <typename InputDeviceType>
-std::unique_ptr<InputDeviceType> CreateDevice(const std::string& params) {
-    const Common::ParamPackage package(params);
-    const std::string engine = package.Get("engine", "null");
-    const auto& factory_list = Impl::FactoryList<InputDeviceType>::list;
-    const auto pair = factory_list.find(engine);
-    if (pair == factory_list.end()) {
-        if (engine != "null") {
-            LOG_ERROR(Input, "Unknown engine name: {}", engine);
-        }
-        return std::make_unique<InputDeviceType>();
-    }
-    return pair->second->Create(package);
-}
-
-/**
- * A button device is an input device that returns bool as status.
- * true for pressed; false for released.
- */
-using ButtonDevice = InputDevice<bool>;
-
-/**
- * An analog device is an input device that returns a tuple of x and y coordinates as status. The
- * coordinates are within the unit circle. x+ is defined as right direction, and y+ is defined as up
- * direction
- */
-using AnalogDevice = InputDevice<std::tuple<float, float>>;
-
-/**
- * A vibration device is an input device that returns an unsigned byte as status.
- * It represents whether the vibration device supports vibration or not.
- * If the status returns 1, it supports vibration. Otherwise, it does not support vibration.
- */
-using VibrationDevice = InputDevice<u8>;
-
-/**
- * A motion status is an object that returns a tuple of accelerometer state vector,
- * gyroscope state vector, rotation state vector, orientation state matrix and quaterion state
- * vector.
- *
- * For both 3D vectors:
- *   x+ is the same direction as RIGHT on D-pad.
- *   y+ is normal to the touch screen, pointing outward.
- *   z+ is the same direction as UP on D-pad.
- *
- * For accelerometer state vector
- *   Units: g (gravitational acceleration)
- *
- * For gyroscope state vector:
- *   Orientation is determined by right-hand rule.
- *   Units: deg/sec
- *
- * For rotation state vector
- *   Units: rotations
- *
- * For orientation state matrix
- *   x vector
- *   y vector
- *   z vector
- *
- * For quaternion state vector
- *   xyz vector
- *   w float
- */
-using MotionStatus = std::tuple<Common::Vec3<float>, Common::Vec3<float>, Common::Vec3<float>,
-                                std::array<Common::Vec3f, 3>, Common::Quaternion<f32>>;
-
-/**
- * A motion device is an input device that returns a motion status object
- */
-using MotionDevice = InputDevice<MotionStatus>;
-
-/**
- * A touch status is an object that returns an array of 16 tuple elements of two floats and a bool.
- * The floats are x and y coordinates in the range 0.0 - 1.0, and the bool indicates whether it is
- * pressed.
- */
-using TouchStatus = std::array<std::tuple<float, float, bool>, 16>;
-
-/**
- * A touch device is an input device that returns a touch status object
- */
-using TouchDevice = InputDevice<TouchStatus>;
-
-/**
- * A mouse device is an input device that returns a tuple of two floats and four ints.
- * The first two floats are X and Y device coordinates of the mouse (from 0-1).
- * The s32s are the mouse wheel.
- */
-using MouseDevice = InputDevice<std::tuple<float, float, s32, s32>>;
-
-} // namespace Input

src/core/hid/emulated_console.cpp

@@ -0,0 +1,229 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included
+
+#include "common/settings.h"
+#include "core/hid/emulated_console.h"
+#include "core/hid/input_converter.h"
+
+namespace Core::HID {
+EmulatedConsole::EmulatedConsole() = default;
+
+EmulatedConsole::~EmulatedConsole() = default;
+
+void EmulatedConsole::ReloadFromSettings() {
+    // Using first motion device from player 1. No need to assign any unique config at the moment
+    const auto& player = Settings::values.players.GetValue()[0];
+    motion_params = Common::ParamPackage(player.motions[0]);
+
+    ReloadInput();
+}
+
+void EmulatedConsole::SetTouchParams() {
+    // TODO(german77): Support any number of fingers
+    std::size_t index = 0;
+
+    // Hardcode mouse, touchscreen and cemuhook parameters
+    if (!Settings::values.mouse_enabled) {
+        // We can't use mouse as touch if native mouse is enabled
+        touch_params[index++] = Common::ParamPackage{"engine:mouse,axis_x:10,axis_y:11,button:0"};
+    }
+    touch_params[index++] = Common::ParamPackage{"engine:touch,axis_x:0,axis_y:1,button:0"};
+    touch_params[index++] = Common::ParamPackage{"engine:touch,axis_x:2,axis_y:3,button:1"};
+    touch_params[index++] =
+        Common::ParamPackage{"engine:cemuhookudp,axis_x:17,axis_y:18,button:65536"};
+    touch_params[index++] =
+        Common::ParamPackage{"engine:cemuhookudp,axis_x:19,axis_y:20,button:131072"};
+
+    const auto button_index =
+        static_cast<u64>(Settings::values.touch_from_button_map_index.GetValue());
+    const auto& touch_buttons = Settings::values.touch_from_button_maps[button_index].buttons;
+
+    // Map the rest of the fingers from touch from button configuration
+    for (const auto& config_entry : touch_buttons) {
+        if (index >= touch_params.size()) {
+            continue;
+        }
+        Common::ParamPackage params{config_entry};
+        Common::ParamPackage touch_button_params;
+        const int x = params.Get("x", 0);
+        const int y = params.Get("y", 0);
+        params.Erase("x");
+        params.Erase("y");
+        touch_button_params.Set("engine", "touch_from_button");
+        touch_button_params.Set("button", params.Serialize());
+        touch_button_params.Set("x", x);
+        touch_button_params.Set("y", y);
+        touch_button_params.Set("touch_id", static_cast<int>(index));
+        touch_params[index] = touch_button_params;
+        index++;
+    }
+}
+
+void EmulatedConsole::ReloadInput() {
+    // If you load any device here add the equivalent to the UnloadInput() function
+    SetTouchParams();
+
+    motion_devices = Common::Input::CreateDevice<Common::Input::InputDevice>(motion_params);
+    if (motion_devices) {
+        Common::Input::InputCallback motion_callback{
+            [this](Common::Input::CallbackStatus callback) { SetMotion(callback); }};
+        motion_devices->SetCallback(motion_callback);
+    }
+
+    // Unique index for identifying touch device source
+    std::size_t index = 0;
+    for (auto& touch_device : touch_devices) {
+        touch_device = Common::Input::CreateDevice<Common::Input::InputDevice>(touch_params[index]);
+        if (!touch_device) {
+            continue;
+        }
+        Common::Input::InputCallback touch_callback{
+            [this, index](Common::Input::CallbackStatus callback) { SetTouch(callback, index); }};
+        touch_device->SetCallback(touch_callback);
+        index++;
+    }
+}
+
+void EmulatedConsole::UnloadInput() {
+    motion_devices.reset();
+    for (auto& touch : touch_devices) {
+        touch.reset();
+    }
+}
+
+void EmulatedConsole::EnableConfiguration() {
+    is_configuring = true;
+    SaveCurrentConfig();
+}
+
+void EmulatedConsole::DisableConfiguration() {
+    is_configuring = false;
+}
+
+bool EmulatedConsole::IsConfiguring() const {
+    return is_configuring;
+}
+
+void EmulatedConsole::SaveCurrentConfig() {
+    if (!is_configuring) {
+        return;
+    }
+}
+
+void EmulatedConsole::RestoreConfig() {
+    if (!is_configuring) {
+        return;
+    }
+    ReloadFromSettings();
+}
+
+Common::ParamPackage EmulatedConsole::GetMotionParam() const {
+    return motion_params;
+}
+
+void EmulatedConsole::SetMotionParam(Common::ParamPackage param) {
+    motion_params = param;
+    ReloadInput();
+}
+
+void EmulatedConsole::SetMotion(Common::Input::CallbackStatus callback) {
+    std::lock_guard lock{mutex};
+    auto& raw_status = console.motion_values.raw_status;
+    auto& emulated = console.motion_values.emulated;
+
+    raw_status = TransformToMotion(callback);
+    emulated.SetAcceleration(Common::Vec3f{
+        raw_status.accel.x.value,
+        raw_status.accel.y.value,
+        raw_status.accel.z.value,
+    });
+    emulated.SetGyroscope(Common::Vec3f{
+        raw_status.gyro.x.value,
+        raw_status.gyro.y.value,
+        raw_status.gyro.z.value,
+    });
+    emulated.UpdateRotation(raw_status.delta_timestamp);
+    emulated.UpdateOrientation(raw_status.delta_timestamp);
+
+    if (is_configuring) {
+        TriggerOnChange(ConsoleTriggerType::Motion);
+        return;
+    }
+
+    auto& motion = console.motion_state;
+    motion.accel = emulated.GetAcceleration();
+    motion.gyro = emulated.GetGyroscope();
+    motion.rotation = emulated.GetGyroscope();
+    motion.orientation = emulated.GetOrientation();
+    motion.quaternion = emulated.GetQuaternion();
+    motion.is_at_rest = !emulated.IsMoving(motion_sensitivity);
+
+    TriggerOnChange(ConsoleTriggerType::Motion);
+}
+
+void EmulatedConsole::SetTouch(Common::Input::CallbackStatus callback,
+                               [[maybe_unused]] std::size_t index) {
+    if (index >= console.touch_values.size()) {
+        return;
+    }
+    std::lock_guard lock{mutex};
+
+    console.touch_values[index] = TransformToTouch(callback);
+
+    if (is_configuring) {
+        TriggerOnChange(ConsoleTriggerType::Touch);
+        return;
+    }
+
+    // TODO(german77): Remap touch id in sequential order
+    console.touch_state[index] = {
+        .position = {console.touch_values[index].x.value, console.touch_values[index].y.value},
+        .id = static_cast<u32>(console.touch_values[index].id),
+        .pressed = console.touch_values[index].pressed.value,
+    };
+
+    TriggerOnChange(ConsoleTriggerType::Touch);
+}
+
+ConsoleMotionValues EmulatedConsole::GetMotionValues() const {
+    return console.motion_values;
+}
+
+TouchValues EmulatedConsole::GetTouchValues() const {
+    return console.touch_values;
+}
+
+ConsoleMotion EmulatedConsole::GetMotion() const {
+    return console.motion_state;
+}
+
+TouchFingerState EmulatedConsole::GetTouch() const {
+    return console.touch_state;
+}
+
+void EmulatedConsole::TriggerOnChange(ConsoleTriggerType type) {
+    for (const auto& poller_pair : callback_list) {
+        const ConsoleUpdateCallback& poller = poller_pair.second;
+        if (poller.on_change) {
+            poller.on_change(type);
+        }
+    }
+}
+
+int EmulatedConsole::SetCallback(ConsoleUpdateCallback update_callback) {
+    std::lock_guard lock{mutex};
+    callback_list.insert_or_assign(last_callback_key, update_callback);
+    return last_callback_key++;
+}
+
+void EmulatedConsole::DeleteCallback(int key) {
+    std::lock_guard lock{mutex};
+    const auto& iterator = callback_list.find(key);
+    if (iterator == callback_list.end()) {
+        LOG_ERROR(Input, "Tried to delete non-existent callback {}", key);
+        return;
+    }
+    callback_list.erase(iterator);
+}
+} // namespace Core::HID

src/core/hid/emulated_console.h

@@ -0,0 +1,190 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <array>
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <unordered_map>
+
+#include "common/common_types.h"
+#include "common/input.h"
+#include "common/param_package.h"
+#include "common/point.h"
+#include "common/quaternion.h"
+#include "common/vector_math.h"
+#include "core/hid/hid_types.h"
+#include "core/hid/motion_input.h"
+
+namespace Core::HID {
+
+struct ConsoleMotionInfo {
+    Common::Input::MotionStatus raw_status{};
+    MotionInput emulated{};
+};
+
+using ConsoleMotionDevices = std::unique_ptr<Common::Input::InputDevice>;
+using TouchDevices = std::array<std::unique_ptr<Common::Input::InputDevice>, 16>;
+
+using ConsoleMotionParams = Common::ParamPackage;
+using TouchParams = std::array<Common::ParamPackage, 16>;
+
+using ConsoleMotionValues = ConsoleMotionInfo;
+using TouchValues = std::array<Common::Input::TouchStatus, 16>;
+
+struct TouchFinger {
+    u64 last_touch{};
+    Common::Point<float> position{};
+    u32 id{};
+    TouchAttribute attribute{};
+    bool pressed{};
+};
+
+// Contains all motion related data that is used on the services
+struct ConsoleMotion {
+    Common::Vec3f accel{};
+    Common::Vec3f gyro{};
+    Common::Vec3f rotation{};
+    std::array<Common::Vec3f, 3> orientation{};
+    Common::Quaternion<f32> quaternion{};
+    bool is_at_rest{};
+};
+
+using TouchFingerState = std::array<TouchFinger, 16>;
+
+struct ConsoleStatus {
+    // Data from input_common
+    ConsoleMotionValues motion_values{};
+    TouchValues touch_values{};
+
+    // Data for HID services
+    ConsoleMotion motion_state{};
+    TouchFingerState touch_state{};
+};
+
+enum class ConsoleTriggerType {
+    Motion,
+    Touch,
+    All,
+};
+
+struct ConsoleUpdateCallback {
+    std::function<void(ConsoleTriggerType)> on_change;
+};
+
+class EmulatedConsole {
+public:
+    /**
+     * Contains all input data within the emulated switch console tablet such as touch and motion
+     */
+    explicit EmulatedConsole();
+    ~EmulatedConsole();
+
+    YUZU_NON_COPYABLE(EmulatedConsole);
+    YUZU_NON_MOVEABLE(EmulatedConsole);
+
+    /// Removes all callbacks created from input devices
+    void UnloadInput();
+
+    /**
+     * Sets the emulated console into configuring mode
+     * This prevents the modification of the HID state of the emulated console by input commands
+     */
+    void EnableConfiguration();
+
+    /// Returns the emulated console into normal mode, allowing the modification of the HID state
+    void DisableConfiguration();
+
+    /// Returns true if the emulated console is in configuring mode
+    bool IsConfiguring() const;
+
+    /// Reload all input devices
+    void ReloadInput();
+
+    /// Overrides current mapped devices with the stored configuration and reloads all input devices
+    void ReloadFromSettings();
+
+    /// Saves the current mapped configuration
+    void SaveCurrentConfig();
+
+    /// Reverts any mapped changes made that weren't saved
+    void RestoreConfig();
+
+    // Returns the current mapped motion device
+    Common::ParamPackage GetMotionParam() const;
+
+    /**
+     * Updates the current mapped motion device
+     * @param param ParamPackage with controller data to be mapped
+     */
+    void SetMotionParam(Common::ParamPackage param);
+
+    /// Returns the latest status of motion input from the console with parameters
+    ConsoleMotionValues GetMotionValues() const;
+
+    /// Returns the latest status of touch input from the console with parameters
+    TouchValues GetTouchValues() const;
+
+    /// Returns the latest status of motion input from the console
+    ConsoleMotion GetMotion() const;
+
+    /// Returns the latest status of touch input from the console
+    TouchFingerState GetTouch() const;
+
+    /**
+     * Adds a callback to the list of events
+     * @param update_callback A ConsoleUpdateCallback that will be triggered
+     * @return an unique key corresponding to the callback index in the list
+     */
+    int SetCallback(ConsoleUpdateCallback update_callback);
+
+    /**
+     * Removes a callback from the list stopping any future events to this object
+     * @param key Key corresponding to the callback index in the list
+     */
+    void DeleteCallback(int key);
+
+private:
+    /// Creates and stores the touch params
+    void SetTouchParams();
+
+    /**
+     * Updates the motion status of the console
+     * @param callback A CallbackStatus containing gyro and accelerometer data
+     */
+    void SetMotion(Common::Input::CallbackStatus callback);
+
+    /**
+     * Updates the touch status of the console
+     * @param callback A CallbackStatus containing the touch position
+     * @param index Finger ID to be updated
+     */
+    void SetTouch(Common::Input::CallbackStatus callback, std::size_t index);
+
+    /**
+     * Triggers a callback that something has changed on the console status
+     * @param type Input type of the event to trigger
+     */
+    void TriggerOnChange(ConsoleTriggerType type);
+
+    bool is_configuring{false};
+    f32 motion_sensitivity{0.01f};
+
+    ConsoleMotionParams motion_params;
+    TouchParams touch_params;
+
+    ConsoleMotionDevices motion_devices;
+    TouchDevices touch_devices;
+
+    mutable std::mutex mutex;
+    std::unordered_map<int, ConsoleUpdateCallback> callback_list;
+    int last_callback_key = 0;
+
+    // Stores the current status of all console input
+    ConsoleStatus console;
+};
+
+} // namespace Core::HID

src/core/hid/emulated_controller.h

@@ -0,0 +1,408 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <array>
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <unordered_map>
+
+#include "common/common_types.h"
+#include "common/input.h"
+#include "common/param_package.h"
+#include "common/point.h"
+#include "common/quaternion.h"
+#include "common/settings.h"
+#include "common/vector_math.h"
+#include "core/hid/hid_types.h"
+#include "core/hid/motion_input.h"
+
+namespace Core::HID {
+const std::size_t max_emulated_controllers = 2;
+struct ControllerMotionInfo {
+    Common::Input::MotionStatus raw_status{};
+    MotionInput emulated{};
+};
+
+using ButtonDevices =
+    std::array<std::unique_ptr<Common::Input::InputDevice>, Settings::NativeButton::NumButtons>;
+using StickDevices =
+    std::array<std::unique_ptr<Common::Input::InputDevice>, Settings::NativeAnalog::NumAnalogs>;
+using ControllerMotionDevices =
+    std::array<std::unique_ptr<Common::Input::InputDevice>, Settings::NativeMotion::NumMotions>;
+using TriggerDevices =
+    std::array<std::unique_ptr<Common::Input::InputDevice>, Settings::NativeTrigger::NumTriggers>;
+using BatteryDevices =
+    std::array<std::unique_ptr<Common::Input::InputDevice>, max_emulated_controllers>;
+using OutputDevices =
+    std::array<std::unique_ptr<Common::Input::OutputDevice>, max_emulated_controllers>;
+
+using ButtonParams = std::array<Common::ParamPackage, Settings::NativeButton::NumButtons>;
+using StickParams = std::array<Common::ParamPackage, Settings::NativeAnalog::NumAnalogs>;
+using ControllerMotionParams = std::array<Common::ParamPackage, Settings::NativeMotion::NumMotions>;
+using TriggerParams = std::array<Common::ParamPackage, Settings::NativeTrigger::NumTriggers>;
+using BatteryParams = std::array<Common::ParamPackage, max_emulated_controllers>;
+using OutputParams = std::array<Common::ParamPackage, max_emulated_controllers>;
+
+using ButtonValues = std::array<Common::Input::ButtonStatus, Settings::NativeButton::NumButtons>;
+using SticksValues = std::array<Common::Input::StickStatus, Settings::NativeAnalog::NumAnalogs>;
+using TriggerValues =
+    std::array<Common::Input::TriggerStatus, Settings::NativeTrigger::NumTriggers>;
+using ControllerMotionValues = std::array<ControllerMotionInfo, Settings::NativeMotion::NumMotions>;
+using ColorValues = std::array<Common::Input::BodyColorStatus, max_emulated_controllers>;
+using BatteryValues = std::array<Common::Input::BatteryStatus, max_emulated_controllers>;
+using VibrationValues = std::array<Common::Input::VibrationStatus, max_emulated_controllers>;
+
+struct AnalogSticks {
+    AnalogStickState left{};
+    AnalogStickState right{};
+};
+
+struct ControllerColors {
+    NpadControllerColor fullkey{};
+    NpadControllerColor left{};
+    NpadControllerColor right{};
+};
+
+struct BatteryLevelState {
+    NpadPowerInfo dual{};
+    NpadPowerInfo left{};
+    NpadPowerInfo right{};
+};
+
+struct ControllerMotion {
+    Common::Vec3f accel{};
+    Common::Vec3f gyro{};
+    Common::Vec3f rotation{};
+    std::array<Common::Vec3f, 3> orientation{};
+    bool is_at_rest{};
+};
+
+enum EmulatedDeviceIndex : u8 {
+    LeftIndex,
+    RightIndex,
+    DualIndex,
+    AllDevices,
+};
+
+using MotionState = std::array<ControllerMotion, 2>;
+
+struct ControllerStatus {
+    // Data from input_common
+    ButtonValues button_values{};
+    SticksValues stick_values{};
+    ControllerMotionValues motion_values{};
+    TriggerValues trigger_values{};
+    ColorValues color_values{};
+    BatteryValues battery_values{};
+    VibrationValues vibration_values{};
+
+    // Data for HID serices
+    NpadButtonState npad_button_state{};
+    DebugPadButton debug_pad_button_state{};
+    AnalogSticks analog_stick_state{};
+    MotionState motion_state{};
+    NpadGcTriggerState gc_trigger_state{};
+    ControllerColors colors_state{};
+    BatteryLevelState battery_state{};
+};
+
+enum class ControllerTriggerType {
+    Button,
+    Stick,
+    Trigger,
+    Motion,
+    Color,
+    Battery,
+    Vibration,
+    Connected,
+    Disconnected,
+    Type,
+    All,
+};
+
+struct ControllerUpdateCallback {
+    std::function<void(ControllerTriggerType)> on_change;
+    bool is_npad_service;
+};
+
+class EmulatedController {
+public:
+    /**
+     * Contains all input data (buttons, joysticks, vibration, and motion) within this controller.
+     * @param npad_id_type npad id type for this specific controller
+     */
+    explicit EmulatedController(NpadIdType npad_id_type_);
+    ~EmulatedController();
+
+    YUZU_NON_COPYABLE(EmulatedController);
+    YUZU_NON_MOVEABLE(EmulatedController);
+
+    /// Converts the controller type from settings to npad type
+    static NpadStyleIndex MapSettingsTypeToNPad(Settings::ControllerType type);
+
+    /// Converts npad type to the equivalent of controller type from settings
+    static Settings::ControllerType MapNPadToSettingsType(NpadStyleIndex type);
+
+    /// Gets the NpadIdType for this controller
+    NpadIdType GetNpadIdType() const;
+
+    /// Sets the NpadStyleIndex for this controller
+    void SetNpadStyleIndex(NpadStyleIndex npad_type_);
+
+    /**
+     * Gets the NpadStyleIndex for this controller
+     * @param get_temporary_value If true tmp_npad_type will be returned
+     * @return NpadStyleIndex set on the controller
+     */
+    NpadStyleIndex GetNpadStyleIndex(bool get_temporary_value = false) const;
+
+    /**
+     * Sets the supported controller types. Disconnects the controller if current type is not
+     * supported
+     * @param supported_styles bitflag with supported types
+     */
+    void SetSupportedNpadStyleTag(NpadStyleTag supported_styles);
+
+    /// Sets the connected status to true
+    void Connect();
+
+    /// Sets the connected status to false
+    void Disconnect();
+
+    /**
+     * Is the emulated connected
+     * @param get_temporary_value If true tmp_is_connected will be returned
+     * @return true if the controller has the connected status
+     */
+    bool IsConnected(bool get_temporary_value = false) const;
+
+    /// Returns true if vibration is enabled
+    bool IsVibrationEnabled() const;
+
+    /// Removes all callbacks created from input devices
+    void UnloadInput();
+
+    /**
+     * Sets the emulated controller into configuring mode
+     * This prevents the modification of the HID state of the emulated controller by input commands
+     */
+    void EnableConfiguration();
+
+    /// Returns the emulated controller into normal mode, allowing the modification of the HID state
+    void DisableConfiguration();
+
+    /// Returns true if the emulated controller is in configuring mode
+    bool IsConfiguring() const;
+
+    /// Reload all input devices
+    void ReloadInput();
+
+    /// Overrides current mapped devices with the stored configuration and reloads all input devices
+    void ReloadFromSettings();
+
+    /// Saves the current mapped configuration
+    void SaveCurrentConfig();
+
+    /// Reverts any mapped changes made that weren't saved
+    void RestoreConfig();
+
+    /// Returns a vector of mapped devices from the mapped button and stick parameters
+    std::vector<Common::ParamPackage> GetMappedDevices(EmulatedDeviceIndex device_index) const;
+
+    // Returns the current mapped button device
+    Common::ParamPackage GetButtonParam(std::size_t index) const;
+
+    // Returns the current mapped stick device
+    Common::ParamPackage GetStickParam(std::size_t index) const;
+
+    // Returns the current mapped motion device
+    Common::ParamPackage GetMotionParam(std::size_t index) const;
+
+    /**
+     * Updates the current mapped button device
+     * @param param ParamPackage with controller data to be mapped
+     */
+    void SetButtonParam(std::size_t index, Common::ParamPackage param);
+
+    /**
+     * Updates the current mapped stick device
+     * @param param ParamPackage with controller data to be mapped
+     */
+    void SetStickParam(std::size_t index, Common::ParamPackage param);
+
+    /**
+     * Updates the current mapped motion device
+     * @param param ParamPackage with controller data to be mapped
+     */
+    void SetMotionParam(std::size_t index, Common::ParamPackage param);
+
+    /// Returns the latest button status from the controller with parameters
+    ButtonValues GetButtonsValues() const;
+
+    /// Returns the latest analog stick status from the controller with parameters
+    SticksValues GetSticksValues() const;
+
+    /// Returns the latest trigger status from the controller with parameters
+    TriggerValues GetTriggersValues() const;
+
+    /// Returns the latest motion status from the controller with parameters
+    ControllerMotionValues GetMotionValues() const;
+
+    /// Returns the latest color status from the controller with parameters
+    ColorValues GetColorsValues() const;
+
+    /// Returns the latest battery status from the controller with parameters
+    BatteryValues GetBatteryValues() const;
+
+    /// Returns the latest status of button input for the npad service
+    NpadButtonState GetNpadButtons() const;
+
+    /// Returns the latest status of button input for the debug pad service
+    DebugPadButton GetDebugPadButtons() const;
+
+    /// Returns the latest status of stick input from the mouse
+    AnalogSticks GetSticks() const;
+
+    /// Returns the latest status of trigger input from the mouse
+    NpadGcTriggerState GetTriggers() const;
+
+    /// Returns the latest status of motion input from the mouse
+    MotionState GetMotions() const;
+
+    /// Returns the latest color value from the controller
+    ControllerColors GetColors() const;
+
+    /// Returns the latest battery status from the controller
+    BatteryLevelState GetBattery() const;
+
+    /**
+     * Sends a specific vibration to the output device
+     * @return returns true if vibration had no errors
+     */
+    bool SetVibration(std::size_t device_index, VibrationValue vibration);
+
+    /**
+     * Sends a small vibration to the output device
+     * @return returns true if SetVibration was successfull
+     */
+    bool TestVibration(std::size_t device_index);
+
+    /// Returns the led pattern corresponding to this emulated controller
+    LedPattern GetLedPattern() const;
+
+    /// Asks the output device to change the player led pattern
+    void SetLedPattern();
+
+    /**
+     * Adds a callback to the list of events
+     * @param update_callback A ConsoleUpdateCallback that will be triggered
+     * @return an unique key corresponding to the callback index in the list
+     */
+    int SetCallback(ControllerUpdateCallback update_callback);
+
+    /**
+     * Removes a callback from the list stopping any future events to this object
+     * @param key Key corresponding to the callback index in the list
+     */
+    void DeleteCallback(int key);
+
+private:
+    /// creates input devices from params
+    void LoadDevices();
+
+    /// Set the params for TAS devices
+    void LoadTASParams();
+
+    /**
+     * Checks the current controller type against the supported_style_tag
+     * @return true if the controller is supported
+     */
+    bool IsControllerSupported() const;
+
+    /**
+     * Updates the button status of the controller
+     * @param callback A CallbackStatus containing the button status
+     * @param index Button ID of the to be updated
+     */
+    void SetButton(Common::Input::CallbackStatus callback, std::size_t index, Common::UUID uuid);
+
+    /**
+     * Updates the analog stick status of the controller
+     * @param callback A CallbackStatus containing the analog stick status
+     * @param index stick ID of the to be updated
+     */
+    void SetStick(Common::Input::CallbackStatus callback, std::size_t index, Common::UUID uuid);
+
+    /**
+     * Updates the trigger status of the controller
+     * @param callback A CallbackStatus containing the trigger status
+     * @param index trigger ID of the to be updated
+     */
+    void SetTrigger(Common::Input::CallbackStatus callback, std::size_t index, Common::UUID uuid);
+
+    /**
+     * Updates the motion status of the controller
+     * @param callback A CallbackStatus containing gyro and accelerometer data
+     * @param index motion ID of the to be updated
+     */
+    void SetMotion(Common::Input::CallbackStatus callback, std::size_t index);
+
+    /**
+     * Updates the battery status of the controller
+     * @param callback A CallbackStatus containing the battery status
+     * @param index Button ID of the to be updated
+     */
+    void SetBattery(Common::Input::CallbackStatus callback, std::size_t index);
+
+    /**
+     * Triggers a callback that something has changed on the controller status
+     * @param type Input type of the event to trigger
+     * @param is_service_update indicates if this event should only be sent to HID services
+     */
+    void TriggerOnChange(ControllerTriggerType type, bool is_service_update);
+
+    NpadIdType npad_id_type;
+    NpadStyleIndex npad_type{NpadStyleIndex::None};
+    NpadStyleTag supported_style_tag{NpadStyleSet::All};
+    bool is_connected{false};
+    bool is_configuring{false};
+    f32 motion_sensitivity{0.01f};
+    bool force_update_motion{false};
+
+    // Temporary values to avoid doing changes while the controller is in configuring mode
+    NpadStyleIndex tmp_npad_type{NpadStyleIndex::None};
+    bool tmp_is_connected{false};
+
+    ButtonParams button_params;
+    StickParams stick_params;
+    ControllerMotionParams motion_params;
+    TriggerParams trigger_params;
+    BatteryParams battery_params;
+    OutputParams output_params;
+
+    ButtonDevices button_devices;
+    StickDevices stick_devices;
+    ControllerMotionDevices motion_devices;
+    TriggerDevices trigger_devices;
+    BatteryDevices battery_devices;
+    OutputDevices output_devices;
+
+    // TAS related variables
+    ButtonParams tas_button_params;
+    StickParams tas_stick_params;
+    ButtonDevices tas_button_devices;
+    StickDevices tas_stick_devices;
+
+    mutable std::mutex mutex;
+    std::unordered_map<int, ControllerUpdateCallback> callback_list;
+    int last_callback_key = 0;
+
+    // Stores the current status of all controller input
+    ControllerStatus controller;
+};
+
+} // namespace Core::HID

src/core/hid/emulated_devices.cpp

@@ -0,0 +1,451 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included
+
+#include <algorithm>
+#include <fmt/format.h>
+
+#include "core/hid/emulated_devices.h"
+#include "core/hid/input_converter.h"
+
+namespace Core::HID {
+
+EmulatedDevices::EmulatedDevices() = default;
+
+EmulatedDevices::~EmulatedDevices() = default;
+
+void EmulatedDevices::ReloadFromSettings() {
+    ReloadInput();
+}
+
+void EmulatedDevices::ReloadInput() {
+    // If you load any device here add the equivalent to the UnloadInput() function
+    std::size_t key_index = 0;
+    for (auto& mouse_device : mouse_button_devices) {
+        Common::ParamPackage mouse_params;
+        mouse_params.Set("engine", "mouse");
+        mouse_params.Set("button", static_cast<int>(key_index));
+        mouse_device = Common::Input::CreateDevice<Common::Input::InputDevice>(mouse_params);
+        key_index++;
+    }
+
+    mouse_stick_device = Common::Input::CreateDeviceFromString<Common::Input::InputDevice>(
+        "engine:mouse,axis_x:0,axis_y:1");
+
+    // First two axis are reserved for mouse position
+    key_index = 2;
+    for (auto& mouse_device : mouse_analog_devices) {
+        Common::ParamPackage mouse_params;
+        mouse_params.Set("engine", "mouse");
+        mouse_params.Set("axis", static_cast<int>(key_index));
+        mouse_device = Common::Input::CreateDevice<Common::Input::InputDevice>(mouse_params);
+        key_index++;
+    }
+
+    key_index = 0;
+    for (auto& keyboard_device : keyboard_devices) {
+        // Keyboard keys are only mapped on port 1, pad 0
+        Common::ParamPackage keyboard_params;
+        keyboard_params.Set("engine", "keyboard");
+        keyboard_params.Set("button", static_cast<int>(key_index));
+        keyboard_params.Set("port", 1);
+        keyboard_params.Set("pad", 0);
+        keyboard_device = Common::Input::CreateDevice<Common::Input::InputDevice>(keyboard_params);
+        key_index++;
+    }
+
+    key_index = 0;
+    for (auto& keyboard_device : keyboard_modifier_devices) {
+        // Keyboard moddifiers are only mapped on port 1, pad 1
+        Common::ParamPackage keyboard_params;
+        keyboard_params.Set("engine", "keyboard");
+        keyboard_params.Set("button", static_cast<int>(key_index));
+        keyboard_params.Set("port", 1);
+        keyboard_params.Set("pad", 1);
+        keyboard_device = Common::Input::CreateDevice<Common::Input::InputDevice>(keyboard_params);
+        key_index++;
+    }
+
+    for (std::size_t index = 0; index < mouse_button_devices.size(); ++index) {
+        if (!mouse_button_devices[index]) {
+            continue;
+        }
+        Common::Input::InputCallback button_callback{
+            [this, index](Common::Input::CallbackStatus callback) {
+                SetMouseButton(callback, index);
+            }};
+        mouse_button_devices[index]->SetCallback(button_callback);
+    }
+
+    for (std::size_t index = 0; index < mouse_analog_devices.size(); ++index) {
+        if (!mouse_analog_devices[index]) {
+            continue;
+        }
+        Common::Input::InputCallback button_callback{
+            [this, index](Common::Input::CallbackStatus callback) {
+                SetMouseAnalog(callback, index);
+            }};
+        mouse_analog_devices[index]->SetCallback(button_callback);
+    }
+
+    if (mouse_stick_device) {
+        Common::Input::InputCallback button_callback{
+            [this](Common::Input::CallbackStatus callback) { SetMouseStick(callback); }};
+        mouse_stick_device->SetCallback(button_callback);
+    }
+
+    for (std::size_t index = 0; index < keyboard_devices.size(); ++index) {
+        if (!keyboard_devices[index]) {
+            continue;
+        }
+        Common::Input::InputCallback button_callback{
+            [this, index](Common::Input::CallbackStatus callback) {
+                SetKeyboardButton(callback, index);
+            }};
+        keyboard_devices[index]->SetCallback(button_callback);
+    }
+
+    for (std::size_t index = 0; index < keyboard_modifier_devices.size(); ++index) {
+        if (!keyboard_modifier_devices[index]) {
+            continue;
+        }
+        Common::Input::InputCallback button_callback{
+            [this, index](Common::Input::CallbackStatus callback) {
+                SetKeyboardModifier(callback, index);
+            }};
+        keyboard_modifier_devices[index]->SetCallback(button_callback);
+    }
+}
+
+void EmulatedDevices::UnloadInput() {
+    for (auto& button : mouse_button_devices) {
+        button.reset();
+    }
+    for (auto& analog : mouse_analog_devices) {
+        analog.reset();
+    }
+    mouse_stick_device.reset();
+    for (auto& button : keyboard_devices) {
+        button.reset();
+    }
+    for (auto& button : keyboard_modifier_devices) {
+        button.reset();
+    }
+}
+
+void EmulatedDevices::EnableConfiguration() {
+    is_configuring = true;
+    SaveCurrentConfig();
+}
+
+void EmulatedDevices::DisableConfiguration() {
+    is_configuring = false;
+}
+
+bool EmulatedDevices::IsConfiguring() const {
+    return is_configuring;
+}
+
+void EmulatedDevices::SaveCurrentConfig() {
+    if (!is_configuring) {
+        return;
+    }
+}
+
+void EmulatedDevices::RestoreConfig() {
+    if (!is_configuring) {
+        return;
+    }
+    ReloadFromSettings();
+}
+
+void EmulatedDevices::SetKeyboardButton(Common::Input::CallbackStatus callback, std::size_t index) {
+    if (index >= device_status.keyboard_values.size()) {
+        return;
+    }
+    std::lock_guard lock{mutex};
+    bool value_changed = false;
+    const auto new_status = TransformToButton(callback);
+    auto& current_status = device_status.keyboard_values[index];
+    current_status.toggle = new_status.toggle;
+
+    // Update button status with current status
+    if (!current_status.toggle) {
+        current_status.locked = false;
+        if (current_status.value != new_status.value) {
+            current_status.value = new_status.value;
+            value_changed = true;
+        }
+    } else {
+        // Toggle button and lock status
+        if (new_status.value && !current_status.locked) {
+            current_status.locked = true;
+            current_status.value = !current_status.value;
+            value_changed = true;
+        }
+
+        // Unlock button, ready for next press
+        if (!new_status.value && current_status.locked) {
+            current_status.locked = false;
+        }
+    }
+
+    if (!value_changed) {
+        return;
+    }
+
+    if (is_configuring) {
+        TriggerOnChange(DeviceTriggerType::Keyboard);
+        return;
+    }
+
+    // Index should be converted from NativeKeyboard to KeyboardKeyIndex
+    UpdateKey(index, current_status.value);
+
+    TriggerOnChange(DeviceTriggerType::Keyboard);
+}
+
+void EmulatedDevices::UpdateKey(std::size_t key_index, bool status) {
+    constexpr std::size_t KEYS_PER_BYTE = 8;
+    auto& entry = device_status.keyboard_state.key[key_index / KEYS_PER_BYTE];
+    const u8 mask = static_cast<u8>(1 << (key_index % KEYS_PER_BYTE));
+    if (status) {
+        entry = entry | mask;
+    } else {
+        entry = static_cast<u8>(entry & ~mask);
+    }
+}
+
+void EmulatedDevices::SetKeyboardModifier(Common::Input::CallbackStatus callback,
+                                          std::size_t index) {
+    if (index >= device_status.keyboard_moddifier_values.size()) {
+        return;
+    }
+    std::lock_guard lock{mutex};
+    bool value_changed = false;
+    const auto new_status = TransformToButton(callback);
+    auto& current_status = device_status.keyboard_moddifier_values[index];
+    current_status.toggle = new_status.toggle;
+
+    // Update button status with current
+    if (!current_status.toggle) {
+        current_status.locked = false;
+        if (current_status.value != new_status.value) {
+            current_status.value = new_status.value;
+            value_changed = true;
+        }
+    } else {
+        // Toggle button and lock status
+        if (new_status.value && !current_status.locked) {
+            current_status.locked = true;
+            current_status.value = !current_status.value;
+            value_changed = true;
+        }
+
+        // Unlock button ready for next press
+        if (!new_status.value && current_status.locked) {
+            current_status.locked = false;
+        }
+    }
+
+    if (!value_changed) {
+        return;
+    }
+
+    if (is_configuring) {
+        TriggerOnChange(DeviceTriggerType::KeyboardModdifier);
+        return;
+    }
+
+    switch (index) {
+    case Settings::NativeKeyboard::LeftControl:
+    case Settings::NativeKeyboard::RightControl:
+        device_status.keyboard_moddifier_state.control.Assign(current_status.value);
+        break;
+    case Settings::NativeKeyboard::LeftShift:
+    case Settings::NativeKeyboard::RightShift:
+        device_status.keyboard_moddifier_state.shift.Assign(current_status.value);
+        break;
+    case Settings::NativeKeyboard::LeftAlt:
+        device_status.keyboard_moddifier_state.left_alt.Assign(current_status.value);
+        break;
+    case Settings::NativeKeyboard::RightAlt:
+        device_status.keyboard_moddifier_state.right_alt.Assign(current_status.value);
+        break;
+    case Settings::NativeKeyboard::CapsLock:
+        device_status.keyboard_moddifier_state.caps_lock.Assign(current_status.value);
+        break;
+    case Settings::NativeKeyboard::ScrollLock:
+        device_status.keyboard_moddifier_state.scroll_lock.Assign(current_status.value);
+        break;
+    case Settings::NativeKeyboard::NumLock:
+        device_status.keyboard_moddifier_state.num_lock.Assign(current_status.value);
+        break;
+    }
+
+    TriggerOnChange(DeviceTriggerType::KeyboardModdifier);
+}
+
+void EmulatedDevices::SetMouseButton(Common::Input::CallbackStatus callback, std::size_t index) {
+    if (index >= device_status.mouse_button_values.size()) {
+        return;
+    }
+    std::lock_guard lock{mutex};
+    bool value_changed = false;
+    const auto new_status = TransformToButton(callback);
+    auto& current_status = device_status.mouse_button_values[index];
+    current_status.toggle = new_status.toggle;
+
+    // Update button status with current
+    if (!current_status.toggle) {
+        current_status.locked = false;
+        if (current_status.value != new_status.value) {
+            current_status.value = new_status.value;
+            value_changed = true;
+        }
+    } else {
+        // Toggle button and lock status
+        if (new_status.value && !current_status.locked) {
+            current_status.locked = true;
+            current_status.value = !current_status.value;
+            value_changed = true;
+        }
+
+        // Unlock button ready for next press
+        if (!new_status.value && current_status.locked) {
+            current_status.locked = false;
+        }
+    }
+
+    if (!value_changed) {
+        return;
+    }
+
+    if (is_configuring) {
+        TriggerOnChange(DeviceTriggerType::Mouse);
+        return;
+    }
+
+    switch (index) {
+    case Settings::NativeMouseButton::Left:
+        device_status.mouse_button_state.left.Assign(current_status.value);
+        break;
+    case Settings::NativeMouseButton::Right:
+        device_status.mouse_button_state.right.Assign(current_status.value);
+        break;
+    case Settings::NativeMouseButton::Middle:
+        device_status.mouse_button_state.middle.Assign(current_status.value);
+        break;
+    case Settings::NativeMouseButton::Forward:
+        device_status.mouse_button_state.forward.Assign(current_status.value);
+        break;
+    case Settings::NativeMouseButton::Back:
+        device_status.mouse_button_state.back.Assign(current_status.value);
+        break;
+    }
+
+    TriggerOnChange(DeviceTriggerType::Mouse);
+}
+
+void EmulatedDevices::SetMouseAnalog(Common::Input::CallbackStatus callback, std::size_t index) {
+    if (index >= device_status.mouse_analog_values.size()) {
+        return;
+    }
+    std::lock_guard lock{mutex};
+    const auto analog_value = TransformToAnalog(callback);
+
+    device_status.mouse_analog_values[index] = analog_value;
+
+    if (is_configuring) {
+        device_status.mouse_position_state = {};
+        TriggerOnChange(DeviceTriggerType::Mouse);
+        return;
+    }
+
+    switch (index) {
+    case Settings::NativeMouseWheel::X:
+        device_status.mouse_wheel_state.x = static_cast<s32>(analog_value.value);
+        break;
+    case Settings::NativeMouseWheel::Y:
+        device_status.mouse_wheel_state.y = static_cast<s32>(analog_value.value);
+        break;
+    }
+
+    TriggerOnChange(DeviceTriggerType::Mouse);
+}
+
+void EmulatedDevices::SetMouseStick(Common::Input::CallbackStatus callback) {
+    std::lock_guard lock{mutex};
+    const auto touch_value = TransformToTouch(callback);
+
+    device_status.mouse_stick_value = touch_value;
+
+    if (is_configuring) {
+        device_status.mouse_position_state = {};
+        TriggerOnChange(DeviceTriggerType::Mouse);
+        return;
+    }
+
+    device_status.mouse_position_state.x = touch_value.x.value;
+    device_status.mouse_position_state.y = touch_value.y.value;
+
+    TriggerOnChange(DeviceTriggerType::Mouse);
+}
+
+KeyboardValues EmulatedDevices::GetKeyboardValues() const {
+    return device_status.keyboard_values;
+}
+
+KeyboardModifierValues EmulatedDevices::GetKeyboardModdifierValues() const {
+    return device_status.keyboard_moddifier_values;
+}
+
+MouseButtonValues EmulatedDevices::GetMouseButtonsValues() const {
+    return device_status.mouse_button_values;
+}
+
+KeyboardKey EmulatedDevices::GetKeyboard() const {
+    return device_status.keyboard_state;
+}
+
+KeyboardModifier EmulatedDevices::GetKeyboardModifier() const {
+    return device_status.keyboard_moddifier_state;
+}
+
+MouseButton EmulatedDevices::GetMouseButtons() const {
+    return device_status.mouse_button_state;
+}
+
+MousePosition EmulatedDevices::GetMousePosition() const {
+    return device_status.mouse_position_state;
+}
+
+AnalogStickState EmulatedDevices::GetMouseWheel() const {
+    return device_status.mouse_wheel_state;
+}
+
+void EmulatedDevices::TriggerOnChange(DeviceTriggerType type) {
+    for (const auto& poller_pair : callback_list) {
+        const InterfaceUpdateCallback& poller = poller_pair.second;
+        if (poller.on_change) {
+            poller.on_change(type);
+        }
+    }
+}
+
+int EmulatedDevices::SetCallback(InterfaceUpdateCallback update_callback) {
+    std::lock_guard lock{mutex};
+    callback_list.insert_or_assign(last_callback_key, update_callback);
+    return last_callback_key++;
+}
+
+void EmulatedDevices::DeleteCallback(int key) {
+    std::lock_guard lock{mutex};
+    const auto& iterator = callback_list.find(key);
+    if (iterator == callback_list.end()) {
+        LOG_ERROR(Input, "Tried to delete non-existent callback {}", key);
+        return;
+    }
+    callback_list.erase(iterator);
+}
+} // namespace Core::HID

src/core/hid/emulated_devices.h

@@ -0,0 +1,211 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <array>
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <unordered_map>
+
+#include "common/common_types.h"
+#include "common/input.h"
+#include "common/param_package.h"
+#include "common/settings.h"
+#include "core/hid/hid_types.h"
+
+namespace Core::HID {
+using KeyboardDevices = std::array<std::unique_ptr<Common::Input::InputDevice>,
+                                   Settings::NativeKeyboard::NumKeyboardKeys>;
+using KeyboardModifierDevices = std::array<std::unique_ptr<Common::Input::InputDevice>,
+                                           Settings::NativeKeyboard::NumKeyboardMods>;
+using MouseButtonDevices = std::array<std::unique_ptr<Common::Input::InputDevice>,
+                                      Settings::NativeMouseButton::NumMouseButtons>;
+using MouseAnalogDevices = std::array<std::unique_ptr<Common::Input::InputDevice>,
+                                      Settings::NativeMouseWheel::NumMouseWheels>;
+using MouseStickDevice = std::unique_ptr<Common::Input::InputDevice>;
+
+using MouseButtonParams =
+    std::array<Common::ParamPackage, Settings::NativeMouseButton::NumMouseButtons>;
+
+using KeyboardValues =
+    std::array<Common::Input::ButtonStatus, Settings::NativeKeyboard::NumKeyboardKeys>;
+using KeyboardModifierValues =
+    std::array<Common::Input::ButtonStatus, Settings::NativeKeyboard::NumKeyboardMods>;
+using MouseButtonValues =
+    std::array<Common::Input::ButtonStatus, Settings::NativeMouseButton::NumMouseButtons>;
+using MouseAnalogValues =
+    std::array<Common::Input::AnalogStatus, Settings::NativeMouseWheel::NumMouseWheels>;
+using MouseStickValue = Common::Input::TouchStatus;
+
+struct MousePosition {
+    f32 x;
+    f32 y;
+};
+
+struct DeviceStatus {
+    // Data from input_common
+    KeyboardValues keyboard_values{};
+    KeyboardModifierValues keyboard_moddifier_values{};
+    MouseButtonValues mouse_button_values{};
+    MouseAnalogValues mouse_analog_values{};
+    MouseStickValue mouse_stick_value{};
+
+    // Data for HID serices
+    KeyboardKey keyboard_state{};
+    KeyboardModifier keyboard_moddifier_state{};
+    MouseButton mouse_button_state{};
+    MousePosition mouse_position_state{};
+    AnalogStickState mouse_wheel_state{};
+};
+
+enum class DeviceTriggerType {
+    Keyboard,
+    KeyboardModdifier,
+    Mouse,
+};
+
+struct InterfaceUpdateCallback {
+    std::function<void(DeviceTriggerType)> on_change;
+};
+
+class EmulatedDevices {
+public:
+    /**
+     * Contains all input data related to external devices that aren't necesarily a controller
+     * This includes devices such as the keyboard or mouse
+     */
+    explicit EmulatedDevices();
+    ~EmulatedDevices();
+
+    YUZU_NON_COPYABLE(EmulatedDevices);
+    YUZU_NON_MOVEABLE(EmulatedDevices);
+
+    /// Removes all callbacks created from input devices
+    void UnloadInput();
+
+    /**
+     * Sets the emulated devices into configuring mode
+     * This prevents the modification of the HID state of the emulated devices by input commands
+     */
+    void EnableConfiguration();
+
+    /// Returns the emulated devices into normal mode, allowing the modification of the HID state
+    void DisableConfiguration();
+
+    /// Returns true if the emulated device is in configuring mode
+    bool IsConfiguring() const;
+
+    /// Reload all input devices
+    void ReloadInput();
+
+    /// Overrides current mapped devices with the stored configuration and reloads all input devices
+    void ReloadFromSettings();
+
+    /// Saves the current mapped configuration
+    void SaveCurrentConfig();
+
+    /// Reverts any mapped changes made that weren't saved
+    void RestoreConfig();
+
+    /// Returns the latest status of button input from the keyboard with parameters
+    KeyboardValues GetKeyboardValues() const;
+
+    /// Returns the latest status of button input from the keyboard modifiers with parameters
+    KeyboardModifierValues GetKeyboardModdifierValues() const;
+
+    /// Returns the latest status of button input from the mouse with parameters
+    MouseButtonValues GetMouseButtonsValues() const;
+
+    /// Returns the latest status of button input from the keyboard
+    KeyboardKey GetKeyboard() const;
+
+    /// Returns the latest status of button input from the keyboard modifiers
+    KeyboardModifier GetKeyboardModifier() const;
+
+    /// Returns the latest status of button input from the mouse
+    MouseButton GetMouseButtons() const;
+
+    /// Returns the latest mouse coordinates
+    MousePosition GetMousePosition() const;
+
+    /// Returns the latest mouse wheel change
+    AnalogStickState GetMouseWheel() const;
+
+    /**
+     * Adds a callback to the list of events
+     * @param update_callback InterfaceUpdateCallback that will be triggered
+     * @return an unique key corresponding to the callback index in the list
+     */
+    int SetCallback(InterfaceUpdateCallback update_callback);
+
+    /**
+     * Removes a callback from the list stopping any future events to this object
+     * @param key Key corresponding to the callback index in the list
+     */
+    void DeleteCallback(int key);
+
+private:
+    /// Helps assigning a value to keyboard_state
+    void UpdateKey(std::size_t key_index, bool status);
+
+    /**
+     * Updates the touch status of the keyboard device
+     * @param callback A CallbackStatus containing the key status
+     * @param index key ID to be updated
+     */
+    void SetKeyboardButton(Common::Input::CallbackStatus callback, std::size_t index);
+
+    /**
+     * Updates the keyboard status of the keyboard device
+     * @param callback A CallbackStatus containing the modifier key status
+     * @param index modifier key ID to be updated
+     */
+    void SetKeyboardModifier(Common::Input::CallbackStatus callback, std::size_t index);
+
+    /**
+     * Updates the mouse button status of the mouse device
+     * @param callback A CallbackStatus containing the button status
+     * @param index Button ID to be updated
+     */
+    void SetMouseButton(Common::Input::CallbackStatus callback, std::size_t index);
+
+    /**
+     * Updates the mouse wheel status of the mouse device
+     * @param callback A CallbackStatus containing the wheel status
+     * @param index wheel ID to be updated
+     */
+    void SetMouseAnalog(Common::Input::CallbackStatus callback, std::size_t index);
+
+    /**
+     * Updates the mouse position status of the mouse device
+     * @param callback A CallbackStatus containing the position status
+     * @param index stick ID to be updated
+     */
+    void SetMouseStick(Common::Input::CallbackStatus callback);
+
+    /**
+     * Triggers a callback that something has changed on the device status
+     * @param type Input type of the event to trigger
+     */
+    void TriggerOnChange(DeviceTriggerType type);
+
+    bool is_configuring{false};
+
+    KeyboardDevices keyboard_devices;
+    KeyboardModifierDevices keyboard_modifier_devices;
+    MouseButtonDevices mouse_button_devices;
+    MouseAnalogDevices mouse_analog_devices;
+    MouseStickDevice mouse_stick_device;
+
+    mutable std::mutex mutex;
+    std::unordered_map<int, InterfaceUpdateCallback> callback_list;
+    int last_callback_key = 0;
+
+    // Stores the current status of all external device input
+    DeviceStatus device_status;
+};
+
+} // namespace Core::HID

src/core/hid/hid_core.cpp

@@ -0,0 +1,204 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "common/assert.h"
+#include "core/hid/emulated_console.h"
+#include "core/hid/emulated_controller.h"
+#include "core/hid/emulated_devices.h"
+#include "core/hid/hid_core.h"
+
+namespace Core::HID {
+
+HIDCore::HIDCore()
+    : player_1{std::make_unique<EmulatedController>(NpadIdType::Player1)},
+      player_2{std::make_unique<EmulatedController>(NpadIdType::Player2)},
+      player_3{std::make_unique<EmulatedController>(NpadIdType::Player3)},
+      player_4{std::make_unique<EmulatedController>(NpadIdType::Player4)},
+      player_5{std::make_unique<EmulatedController>(NpadIdType::Player5)},
+      player_6{std::make_unique<EmulatedController>(NpadIdType::Player6)},
+      player_7{std::make_unique<EmulatedController>(NpadIdType::Player7)},
+      player_8{std::make_unique<EmulatedController>(NpadIdType::Player8)},
+      other{std::make_unique<EmulatedController>(NpadIdType::Other)},
+      handheld{std::make_unique<EmulatedController>(NpadIdType::Handheld)},
+      console{std::make_unique<EmulatedConsole>()}, devices{std::make_unique<EmulatedDevices>()} {}
+
+HIDCore::~HIDCore() = default;
+
+EmulatedController* HIDCore::GetEmulatedController(NpadIdType npad_id_type) {
+    switch (npad_id_type) {
+    case NpadIdType::Player1:
+        return player_1.get();
+    case NpadIdType::Player2:
+        return player_2.get();
+    case NpadIdType::Player3:
+        return player_3.get();
+    case NpadIdType::Player4:
+        return player_4.get();
+    case NpadIdType::Player5:
+        return player_5.get();
+    case NpadIdType::Player6:
+        return player_6.get();
+    case NpadIdType::Player7:
+        return player_7.get();
+    case NpadIdType::Player8:
+        return player_8.get();
+    case NpadIdType::Other:
+        return other.get();
+    case NpadIdType::Handheld:
+        return handheld.get();
+    case NpadIdType::Invalid:
+    default:
+        UNREACHABLE_MSG("Invalid NpadIdType={}", npad_id_type);
+        return nullptr;
+    }
+}
+
+const EmulatedController* HIDCore::GetEmulatedController(NpadIdType npad_id_type) const {
+    switch (npad_id_type) {
+    case NpadIdType::Player1:
+        return player_1.get();
+    case NpadIdType::Player2:
+        return player_2.get();
+    case NpadIdType::Player3:
+        return player_3.get();
+    case NpadIdType::Player4:
+        return player_4.get();
+    case NpadIdType::Player5:
+        return player_5.get();
+    case NpadIdType::Player6:
+        return player_6.get();
+    case NpadIdType::Player7:
+        return player_7.get();
+    case NpadIdType::Player8:
+        return player_8.get();
+    case NpadIdType::Other:
+        return other.get();
+    case NpadIdType::Handheld:
+        return handheld.get();
+    case NpadIdType::Invalid:
+    default:
+        UNREACHABLE_MSG("Invalid NpadIdType={}", npad_id_type);
+        return nullptr;
+    }
+}
+EmulatedConsole* HIDCore::GetEmulatedConsole() {
+    return console.get();
+}
+
+const EmulatedConsole* HIDCore::GetEmulatedConsole() const {
+    return console.get();
+}
+
+EmulatedDevices* HIDCore::GetEmulatedDevices() {
+    return devices.get();
+}
+
+const EmulatedDevices* HIDCore::GetEmulatedDevices() const {
+    return devices.get();
+}
+
+EmulatedController* HIDCore::GetEmulatedControllerByIndex(std::size_t index) {
+    return GetEmulatedController(IndexToNpadIdType(index));
+}
+
+const EmulatedController* HIDCore::GetEmulatedControllerByIndex(std::size_t index) const {
+    return GetEmulatedController(IndexToNpadIdType(index));
+}
+
+void HIDCore::SetSupportedStyleTag(NpadStyleTag style_tag) {
+    supported_style_tag.raw = style_tag.raw;
+    player_1->SetSupportedNpadStyleTag(supported_style_tag);
+    player_2->SetSupportedNpadStyleTag(supported_style_tag);
+    player_3->SetSupportedNpadStyleTag(supported_style_tag);
+    player_4->SetSupportedNpadStyleTag(supported_style_tag);
+    player_5->SetSupportedNpadStyleTag(supported_style_tag);
+    player_6->SetSupportedNpadStyleTag(supported_style_tag);
+    player_7->SetSupportedNpadStyleTag(supported_style_tag);
+    player_8->SetSupportedNpadStyleTag(supported_style_tag);
+    other->SetSupportedNpadStyleTag(supported_style_tag);
+    handheld->SetSupportedNpadStyleTag(supported_style_tag);
+}
+
+NpadStyleTag HIDCore::GetSupportedStyleTag() const {
+    return supported_style_tag;
+}
+
+s8 HIDCore::GetPlayerCount() const {
+    s8 active_players = 0;
+    for (std::size_t player_index = 0; player_index < available_controllers - 2; ++player_index) {
+        const auto* const controller = GetEmulatedControllerByIndex(player_index);
+        if (controller->IsConnected()) {
+            active_players++;
+        }
+    }
+    return active_players;
+}
+
+NpadIdType HIDCore::GetFirstNpadId() const {
+    for (std::size_t player_index = 0; player_index < available_controllers; ++player_index) {
+        const auto* const controller = GetEmulatedControllerByIndex(player_index);
+        if (controller->IsConnected()) {
+            return controller->GetNpadIdType();
+        }
+    }
+    return NpadIdType::Player1;
+}
+
+void HIDCore::EnableAllControllerConfiguration() {
+    player_1->EnableConfiguration();
+    player_2->EnableConfiguration();
+    player_3->EnableConfiguration();
+    player_4->EnableConfiguration();
+    player_5->EnableConfiguration();
+    player_6->EnableConfiguration();
+    player_7->EnableConfiguration();
+    player_8->EnableConfiguration();
+    other->EnableConfiguration();
+    handheld->EnableConfiguration();
+}
+
+void HIDCore::DisableAllControllerConfiguration() {
+    player_1->DisableConfiguration();
+    player_2->DisableConfiguration();
+    player_3->DisableConfiguration();
+    player_4->DisableConfiguration();
+    player_5->DisableConfiguration();
+    player_6->DisableConfiguration();
+    player_7->DisableConfiguration();
+    player_8->DisableConfiguration();
+    other->DisableConfiguration();
+    handheld->DisableConfiguration();
+}
+
+void HIDCore::ReloadInputDevices() {
+    player_1->ReloadFromSettings();
+    player_2->ReloadFromSettings();
+    player_3->ReloadFromSettings();
+    player_4->ReloadFromSettings();
+    player_5->ReloadFromSettings();
+    player_6->ReloadFromSettings();
+    player_7->ReloadFromSettings();
+    player_8->ReloadFromSettings();
+    other->ReloadFromSettings();
+    handheld->ReloadFromSettings();
+    console->ReloadFromSettings();
+    devices->ReloadFromSettings();
+}
+
+void HIDCore::UnloadInputDevices() {
+    player_1->UnloadInput();
+    player_2->UnloadInput();
+    player_3->UnloadInput();
+    player_4->UnloadInput();
+    player_5->UnloadInput();
+    player_6->UnloadInput();
+    player_7->UnloadInput();
+    player_8->UnloadInput();
+    other->UnloadInput();
+    handheld->UnloadInput();
+    console->UnloadInput();
+    devices->UnloadInput();
+}
+
+} // namespace Core::HID

src/core/hid/hid_core.h

@@ -0,0 +1,79 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <memory>
+
+#include "core/hid/hid_types.h"
+
+namespace Core::HID {
+class EmulatedConsole;
+class EmulatedController;
+class EmulatedDevices;
+} // namespace Core::HID
+
+namespace Core::HID {
+
+class HIDCore {
+public:
+    explicit HIDCore();
+    ~HIDCore();
+
+    YUZU_NON_COPYABLE(HIDCore);
+    YUZU_NON_MOVEABLE(HIDCore);
+
+    EmulatedController* GetEmulatedController(NpadIdType npad_id_type);
+    const EmulatedController* GetEmulatedController(NpadIdType npad_id_type) const;
+
+    EmulatedController* GetEmulatedControllerByIndex(std::size_t index);
+    const EmulatedController* GetEmulatedControllerByIndex(std::size_t index) const;
+
+    EmulatedConsole* GetEmulatedConsole();
+    const EmulatedConsole* GetEmulatedConsole() const;
+
+    EmulatedDevices* GetEmulatedDevices();
+    const EmulatedDevices* GetEmulatedDevices() const;
+
+    void SetSupportedStyleTag(NpadStyleTag style_tag);
+    NpadStyleTag GetSupportedStyleTag() const;
+
+    /// Counts the connected players from P1-P8
+    s8 GetPlayerCount() const;
+
+    /// Returns the first connected npad id
+    NpadIdType GetFirstNpadId() const;
+
+    /// Sets all emulated controllers into configuring mode.
+    void EnableAllControllerConfiguration();
+
+    /// Sets all emulated controllers into normal mode.
+    void DisableAllControllerConfiguration();
+
+    /// Reloads all input devices from settings
+    void ReloadInputDevices();
+
+    /// Removes all callbacks from input common
+    void UnloadInputDevices();
+
+    /// Number of emulated controllers
+    static constexpr std::size_t available_controllers{10};
+
+private:
+    std::unique_ptr<EmulatedController> player_1;
+    std::unique_ptr<EmulatedController> player_2;
+    std::unique_ptr<EmulatedController> player_3;
+    std::unique_ptr<EmulatedController> player_4;
+    std::unique_ptr<EmulatedController> player_5;
+    std::unique_ptr<EmulatedController> player_6;
+    std::unique_ptr<EmulatedController> player_7;
+    std::unique_ptr<EmulatedController> player_8;
+    std::unique_ptr<EmulatedController> other;
+    std::unique_ptr<EmulatedController> handheld;
+    std::unique_ptr<EmulatedConsole> console;
+    std::unique_ptr<EmulatedDevices> devices;
+    NpadStyleTag supported_style_tag{NpadStyleSet::All};
+};
+
+} // namespace Core::HID

src/core/hid/hid_types.h

@@ -0,0 +1,635 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "common/bit_field.h"
+#include "common/common_funcs.h"
+#include "common/common_types.h"
+#include "common/point.h"
+#include "common/uuid.h"
+
+namespace Core::HID {
+
+enum class DeviceIndex : u8 {
+    Left = 0,
+    Right = 1,
+    None = 2,
+    MaxDeviceIndex = 3,
+};
+
+// This is nn::hid::NpadButton
+enum class NpadButton : u64 {
+    None = 0,
+    A = 1U << 0,
+    B = 1U << 1,
+    X = 1U << 2,
+    Y = 1U << 3,
+    StickL = 1U << 4,
+    StickR = 1U << 5,
+    L = 1U << 6,
+    R = 1U << 7,
+    ZL = 1U << 8,
+    ZR = 1U << 9,
+    Plus = 1U << 10,
+    Minus = 1U << 11,
+
+    Left = 1U << 12,
+    Up = 1U << 13,
+    Right = 1U << 14,
+    Down = 1U << 15,
+
+    StickLLeft = 1U << 16,
+    StickLUp = 1U << 17,
+    StickLRight = 1U << 18,
+    StickLDown = 1U << 19,
+
+    StickRLeft = 1U << 20,
+    StickRUp = 1U << 21,
+    StickRRight = 1U << 22,
+    StickRDown = 1U << 23,
+
+    LeftSL = 1U << 24,
+    LeftSR = 1U << 25,
+
+    RightSL = 1U << 26,
+    RightSR = 1U << 27,
+
+    Palma = 1U << 28,
+    Verification = 1U << 29,
+    HandheldLeftB = 1U << 30,
+    LagonCLeft = 1U << 31,
+    LagonCUp = 1ULL << 32,
+    LagonCRight = 1ULL << 33,
+    LagonCDown = 1ULL << 34,
+
+    All = 0xFFFFFFFFFFFFFFFFULL,
+};
+DECLARE_ENUM_FLAG_OPERATORS(NpadButton);
+
+enum class KeyboardKeyIndex : u32 {
+    A = 4,
+    B = 5,
+    C = 6,
+    D = 7,
+    E = 8,
+    F = 9,
+    G = 10,
+    H = 11,
+    I = 12,
+    J = 13,
+    K = 14,
+    L = 15,
+    M = 16,
+    N = 17,
+    O = 18,
+    P = 19,
+    Q = 20,
+    R = 21,
+    S = 22,
+    T = 23,
+    U = 24,
+    V = 25,
+    W = 26,
+    X = 27,
+    Y = 28,
+    Z = 29,
+    D1 = 30,
+    D2 = 31,
+    D3 = 32,
+    D4 = 33,
+    D5 = 34,
+    D6 = 35,
+    D7 = 36,
+    D8 = 37,
+    D9 = 38,
+    D0 = 39,
+    Return = 40,
+    Escape = 41,
+    Backspace = 42,
+    Tab = 43,
+    Space = 44,
+    Minus = 45,
+    Plus = 46,
+    OpenBracket = 47,
+    CloseBracket = 48,
+    Pipe = 49,
+    Tilde = 50,
+    Semicolon = 51,
+    Quote = 52,
+    Backquote = 53,
+    Comma = 54,
+    Period = 55,
+    Slash = 56,
+    CapsLock = 57,
+    F1 = 58,
+    F2 = 59,
+    F3 = 60,
+    F4 = 61,
+    F5 = 62,
+    F6 = 63,
+    F7 = 64,
+    F8 = 65,
+    F9 = 66,
+    F10 = 67,
+    F11 = 68,
+    F12 = 69,
+    PrintScreen = 70,
+    ScrollLock = 71,
+    Pause = 72,
+    Insert = 73,
+    Home = 74,
+    PageUp = 75,
+    Delete = 76,
+    End = 77,
+    PageDown = 78,
+    RightArrow = 79,
+    LeftArrow = 80,
+    DownArrow = 81,
+    UpArrow = 82,
+    NumLock = 83,
+    NumPadDivide = 84,
+    NumPadMultiply = 85,
+    NumPadSubtract = 86,
+    NumPadAdd = 87,
+    NumPadEnter = 88,
+    NumPad1 = 89,
+    NumPad2 = 90,
+    NumPad3 = 91,
+    NumPad4 = 92,
+    NumPad5 = 93,
+    NumPad6 = 94,
+    NumPad7 = 95,
+    NumPad8 = 96,
+    NumPad9 = 97,
+    NumPad0 = 98,
+    NumPadDot = 99,
+    Backslash = 100,
+    Application = 101,
+    Power = 102,
+    NumPadEquals = 103,
+    F13 = 104,
+    F14 = 105,
+    F15 = 106,
+    F16 = 107,
+    F17 = 108,
+    F18 = 109,
+    F19 = 110,
+    F20 = 111,
+    F21 = 112,
+    F22 = 113,
+    F23 = 114,
+    F24 = 115,
+    NumPadComma = 133,
+    Ro = 135,
+    KatakanaHiragana = 136,
+    Yen = 137,
+    Henkan = 138,
+    Muhenkan = 139,
+    NumPadCommaPc98 = 140,
+    HangulEnglish = 144,
+    Hanja = 145,
+    Katakana = 146,
+    Hiragana = 147,
+    ZenkakuHankaku = 148,
+    LeftControl = 224,
+    LeftShift = 225,
+    LeftAlt = 226,
+    LeftGui = 227,
+    RightControl = 228,
+    RightShift = 229,
+    RightAlt = 230,
+    RightGui = 231,
+};
+
+// This is nn::hid::NpadIdType
+enum class NpadIdType : u32 {
+    Player1 = 0x0,
+    Player2 = 0x1,
+    Player3 = 0x2,
+    Player4 = 0x3,
+    Player5 = 0x4,
+    Player6 = 0x5,
+    Player7 = 0x6,
+    Player8 = 0x7,
+    Other = 0x10,
+    Handheld = 0x20,
+
+    Invalid = 0xFFFFFFFF,
+};
+
+// This is nn::hid::NpadStyleIndex
+enum class NpadStyleIndex : u8 {
+    None = 0,
+    ProController = 3,
+    Handheld = 4,
+    HandheldNES = 4,
+    JoyconDual = 5,
+    JoyconLeft = 6,
+    JoyconRight = 7,
+    GameCube = 8,
+    Pokeball = 9,
+    NES = 10,
+    SNES = 12,
+    N64 = 13,
+    SegaGenesis = 14,
+    SystemExt = 32,
+    System = 33,
+    MaxNpadType = 34,
+};
+
+// This is nn::hid::NpadStyleSet
+enum class NpadStyleSet : u32 {
+    None = 0,
+    Fullkey = 1U << 0,
+    Handheld = 1U << 1,
+    JoyDual = 1U << 2,
+    JoyLeft = 1U << 3,
+    JoyRight = 1U << 4,
+    Gc = 1U << 5,
+    Palma = 1U << 6,
+    Lark = 1U << 7,
+    HandheldLark = 1U << 8,
+    Lucia = 1U << 9,
+    Lagoon = 1U << 10,
+    Lager = 1U << 11,
+    SystemExt = 1U << 29,
+    System = 1U << 30,
+
+    All = 0xFFFFFFFFU,
+};
+static_assert(sizeof(NpadStyleSet) == 4, "NpadStyleSet is an invalid size");
+
+// This is nn::hid::VibrationDevicePosition
+enum class VibrationDevicePosition : u32 {
+    None = 0,
+    Left = 1,
+    Right = 2,
+};
+
+// This is nn::hid::VibrationDeviceType
+enum class VibrationDeviceType : u32 {
+    Unknown = 0,
+    LinearResonantActuator = 1,
+    GcErm = 2,
+};
+
+// This is nn::hid::VibrationGcErmCommand
+enum class VibrationGcErmCommand : u64 {
+    Stop = 0,
+    Start = 1,
+    StopHard = 2,
+};
+
+// This is nn::hid::NpadStyleTag
+struct NpadStyleTag {
+    union {
+        NpadStyleSet raw{};
+
+        BitField<0, 1, u32> fullkey;
+        BitField<1, 1, u32> handheld;
+        BitField<2, 1, u32> joycon_dual;
+        BitField<3, 1, u32> joycon_left;
+        BitField<4, 1, u32> joycon_right;
+        BitField<5, 1, u32> gamecube;
+        BitField<6, 1, u32> palma;
+        BitField<7, 1, u32> lark;
+        BitField<8, 1, u32> handheld_lark;
+        BitField<9, 1, u32> lucia;
+        BitField<10, 1, u32> lagoon;
+        BitField<11, 1, u32> lager;
+        BitField<29, 1, u32> system_ext;
+        BitField<30, 1, u32> system;
+    };
+};
+static_assert(sizeof(NpadStyleTag) == 4, "NpadStyleTag is an invalid size");
+
+// This is nn::hid::TouchAttribute
+struct TouchAttribute {
+    union {
+        u32 raw{};
+        BitField<0, 1, u32> start_touch;
+        BitField<1, 1, u32> end_touch;
+    };
+};
+static_assert(sizeof(TouchAttribute) == 0x4, "TouchAttribute is an invalid size");
+
+// This is nn::hid::TouchState
+struct TouchState {
+    u64 delta_time;
+    TouchAttribute attribute;
+    u32 finger;
+    Common::Point<u32> position;
+    u32 diameter_x;
+    u32 diameter_y;
+    u32 rotation_angle;
+};
+static_assert(sizeof(TouchState) == 0x28, "Touchstate is an invalid size");
+
+// This is nn::hid::NpadControllerColor
+struct NpadControllerColor {
+    u32 body;
+    u32 button;
+};
+static_assert(sizeof(NpadControllerColor) == 8, "NpadControllerColor is an invalid size");
+
+// This is nn::hid::AnalogStickState
+struct AnalogStickState {
+    s32 x;
+    s32 y;
+};
+static_assert(sizeof(AnalogStickState) == 8, "AnalogStickState is an invalid size");
+
+// This is nn::hid::server::NpadGcTriggerState
+struct NpadGcTriggerState {
+    s64 sampling_number{};
+    s32 left{};
+    s32 right{};
+};
+static_assert(sizeof(NpadGcTriggerState) == 0x10, "NpadGcTriggerState is an invalid size");
+
+// This is nn::hid::system::NpadBatteryLevel
+using NpadBatteryLevel = u32;
+static_assert(sizeof(NpadBatteryLevel) == 0x4, "NpadBatteryLevel is an invalid size");
+
+// This is nn::hid::system::NpadPowerInfo
+struct NpadPowerInfo {
+    bool is_powered;
+    bool is_charging;
+    INSERT_PADDING_BYTES(0x6);
+    NpadBatteryLevel battery_level;
+};
+static_assert(sizeof(NpadPowerInfo) == 0xC, "NpadPowerInfo is an invalid size");
+
+struct LedPattern {
+    explicit LedPattern(u64 light1, u64 light2, u64 light3, u64 light4) {
+        position1.Assign(light1);
+        position2.Assign(light2);
+        position3.Assign(light3);
+        position4.Assign(light4);
+    }
+    union {
+        u64 raw{};
+        BitField<0, 1, u64> position1;
+        BitField<1, 1, u64> position2;
+        BitField<2, 1, u64> position3;
+        BitField<3, 1, u64> position4;
+    };
+};
+
+struct NpadButtonState {
+    union {
+        NpadButton raw{};
+
+        // Buttons
+        BitField<0, 1, u64> a;
+        BitField<1, 1, u64> b;
+        BitField<2, 1, u64> x;
+        BitField<3, 1, u64> y;
+        BitField<4, 1, u64> stick_l;
+        BitField<5, 1, u64> stick_r;
+        BitField<6, 1, u64> l;
+        BitField<7, 1, u64> r;
+        BitField<8, 1, u64> zl;
+        BitField<9, 1, u64> zr;
+        BitField<10, 1, u64> plus;
+        BitField<11, 1, u64> minus;
+
+        // D-Pad
+        BitField<12, 1, u64> left;
+        BitField<13, 1, u64> up;
+        BitField<14, 1, u64> right;
+        BitField<15, 1, u64> down;
+
+        // Left JoyStick
+        BitField<16, 1, u64> stick_l_left;
+        BitField<17, 1, u64> stick_l_up;
+        BitField<18, 1, u64> stick_l_right;
+        BitField<19, 1, u64> stick_l_down;
+
+        // Right JoyStick
+        BitField<20, 1, u64> stick_r_left;
+        BitField<21, 1, u64> stick_r_up;
+        BitField<22, 1, u64> stick_r_right;
+        BitField<23, 1, u64> stick_r_down;
+
+        BitField<24, 1, u64> left_sl;
+        BitField<25, 1, u64> left_sr;
+
+        BitField<26, 1, u64> right_sl;
+        BitField<27, 1, u64> right_sr;
+
+        BitField<28, 1, u64> palma;
+        BitField<29, 1, u64> verification;
+        BitField<30, 1, u64> handheld_left_b;
+        BitField<31, 1, u64> lagon_c_left;
+        BitField<32, 1, u64> lagon_c_up;
+        BitField<33, 1, u64> lagon_c_right;
+        BitField<34, 1, u64> lagon_c_down;
+    };
+};
+static_assert(sizeof(NpadButtonState) == 0x8, "NpadButtonState has incorrect size.");
+
+// This is nn::hid::DebugPadButton
+struct DebugPadButton {
+    union {
+        u32 raw{};
+        BitField<0, 1, u32> a;
+        BitField<1, 1, u32> b;
+        BitField<2, 1, u32> x;
+        BitField<3, 1, u32> y;
+        BitField<4, 1, u32> l;
+        BitField<5, 1, u32> r;
+        BitField<6, 1, u32> zl;
+        BitField<7, 1, u32> zr;
+        BitField<8, 1, u32> plus;
+        BitField<9, 1, u32> minus;
+        BitField<10, 1, u32> d_left;
+        BitField<11, 1, u32> d_up;
+        BitField<12, 1, u32> d_right;
+        BitField<13, 1, u32> d_down;
+    };
+};
+static_assert(sizeof(DebugPadButton) == 0x4, "DebugPadButton is an invalid size");
+
+// This is nn::hid::ConsoleSixAxisSensorHandle
+struct ConsoleSixAxisSensorHandle {
+    u8 unknown_1;
+    u8 unknown_2;
+    INSERT_PADDING_BYTES_NOINIT(2);
+};
+static_assert(sizeof(ConsoleSixAxisSensorHandle) == 4,
+              "ConsoleSixAxisSensorHandle is an invalid size");
+
+// This is nn::hid::SixAxisSensorHandle
+struct SixAxisSensorHandle {
+    NpadStyleIndex npad_type;
+    u8 npad_id;
+    DeviceIndex device_index;
+    INSERT_PADDING_BYTES_NOINIT(1);
+};
+static_assert(sizeof(SixAxisSensorHandle) == 4, "SixAxisSensorHandle is an invalid size");
+
+struct SixAxisSensorFusionParameters {
+    f32 parameter1;
+    f32 parameter2;
+};
+static_assert(sizeof(SixAxisSensorFusionParameters) == 8,
+              "SixAxisSensorFusionParameters is an invalid size");
+
+// This is nn::hid::VibrationDeviceHandle
+struct VibrationDeviceHandle {
+    NpadStyleIndex npad_type;
+    u8 npad_id;
+    DeviceIndex device_index;
+    INSERT_PADDING_BYTES_NOINIT(1);
+};
+static_assert(sizeof(VibrationDeviceHandle) == 4, "SixAxisSensorHandle is an invalid size");
+
+// This is nn::hid::VibrationValue
+struct VibrationValue {
+    f32 low_amplitude;
+    f32 low_frequency;
+    f32 high_amplitude;
+    f32 high_frequency;
+};
+static_assert(sizeof(VibrationValue) == 0x10, "VibrationValue has incorrect size.");
+
+// This is nn::hid::VibrationDeviceInfo
+struct VibrationDeviceInfo {
+    VibrationDeviceType type{};
+    VibrationDevicePosition position{};
+};
+static_assert(sizeof(VibrationDeviceInfo) == 0x8, "VibrationDeviceInfo has incorrect size.");
+
+// This is nn::hid::KeyboardModifier
+struct KeyboardModifier {
+    union {
+        u32 raw{};
+        BitField<0, 1, u32> control;
+        BitField<1, 1, u32> shift;
+        BitField<2, 1, u32> left_alt;
+        BitField<3, 1, u32> right_alt;
+        BitField<4, 1, u32> gui;
+        BitField<8, 1, u32> caps_lock;
+        BitField<9, 1, u32> scroll_lock;
+        BitField<10, 1, u32> num_lock;
+        BitField<11, 1, u32> katakana;
+        BitField<12, 1, u32> hiragana;
+    };
+};
+
+static_assert(sizeof(KeyboardModifier) == 0x4, "KeyboardModifier is an invalid size");
+
+// This is nn::hid::KeyboardAttribute
+struct KeyboardAttribute {
+    union {
+        u32 raw{};
+        BitField<0, 1, u32> is_connected;
+    };
+};
+static_assert(sizeof(KeyboardAttribute) == 0x4, "KeyboardAttribute is an invalid size");
+
+// This is nn::hid::KeyboardKey
+struct KeyboardKey {
+    // This should be a 256 bit flag
+    std::array<u8, 32> key;
+};
+static_assert(sizeof(KeyboardKey) == 0x20, "KeyboardKey is an invalid size");
+
+// This is nn::hid::MouseButton
+struct MouseButton {
+    union {
+        u32_le raw{};
+        BitField<0, 1, u32> left;
+        BitField<1, 1, u32> right;
+        BitField<2, 1, u32> middle;
+        BitField<3, 1, u32> forward;
+        BitField<4, 1, u32> back;
+    };
+};
+static_assert(sizeof(MouseButton) == 0x4, "MouseButton is an invalid size");
+
+// This is nn::hid::MouseAttribute
+struct MouseAttribute {
+    union {
+        u32 raw{};
+        BitField<0, 1, u32> transferable;
+        BitField<1, 1, u32> is_connected;
+    };
+};
+static_assert(sizeof(MouseAttribute) == 0x4, "MouseAttribute is an invalid size");
+
+// This is nn::hid::detail::MouseState
+struct MouseState {
+    s64 sampling_number;
+    s32 x;
+    s32 y;
+    s32 delta_x;
+    s32 delta_y;
+    // Axis Order in HW is switched for the wheel
+    s32 delta_wheel_y;
+    s32 delta_wheel_x;
+    MouseButton button;
+    MouseAttribute attribute;
+};
+static_assert(sizeof(MouseState) == 0x28, "MouseState is an invalid size");
+
+/// Converts a NpadIdType to an array index.
+constexpr size_t NpadIdTypeToIndex(NpadIdType npad_id_type) {
+    switch (npad_id_type) {
+    case NpadIdType::Player1:
+        return 0;
+    case NpadIdType::Player2:
+        return 1;
+    case NpadIdType::Player3:
+        return 2;
+    case NpadIdType::Player4:
+        return 3;
+    case NpadIdType::Player5:
+        return 4;
+    case NpadIdType::Player6:
+        return 5;
+    case NpadIdType::Player7:
+        return 6;
+    case NpadIdType::Player8:
+        return 7;
+    case NpadIdType::Handheld:
+        return 8;
+    case NpadIdType::Other:
+        return 9;
+    default:
+        return 0;
+    }
+}
+
+/// Converts an array index to a NpadIdType
+constexpr NpadIdType IndexToNpadIdType(size_t index) {
+    switch (index) {
+    case 0:
+        return NpadIdType::Player1;
+    case 1:
+        return NpadIdType::Player2;
+    case 2:
+        return NpadIdType::Player3;
+    case 3:
+        return NpadIdType::Player4;
+    case 4:
+        return NpadIdType::Player5;
+    case 5:
+        return NpadIdType::Player6;
+    case 6:
+        return NpadIdType::Player7;
+    case 7:
+        return NpadIdType::Player8;
+    case 8:
+        return NpadIdType::Handheld;
+    case 9:
+        return NpadIdType::Other;
+    default:
+        return NpadIdType::Invalid;
+    }
+}
+
+} // namespace Core::HID

src/core/hid/input_converter.cpp

@@ -0,0 +1,383 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included
+
+#include <random>
+
+#include "common/input.h"
+#include "core/hid/input_converter.h"
+
+namespace Core::HID {
+
+Common::Input::BatteryStatus TransformToBattery(const Common::Input::CallbackStatus& callback) {
+    Common::Input::BatteryStatus battery{Common::Input::BatteryStatus::None};
+    switch (callback.type) {
+    case Common::Input::InputType::Analog:
+    case Common::Input::InputType::Trigger: {
+        const auto value = TransformToTrigger(callback).analog.value;
+        battery = Common::Input::BatteryLevel::Empty;
+        if (value > 0.2f) {
+            battery = Common::Input::BatteryLevel::Critical;
+        }
+        if (value > 0.4f) {
+            battery = Common::Input::BatteryLevel::Low;
+        }
+        if (value > 0.6f) {
+            battery = Common::Input::BatteryLevel::Medium;
+        }
+        if (value > 0.8f) {
+            battery = Common::Input::BatteryLevel::Full;
+        }
+        if (value >= 1.0f) {
+            battery = Common::Input::BatteryLevel::Charging;
+        }
+        break;
+    }
+    case Common::Input::InputType::Button:
+        battery = callback.button_status.value ? Common::Input::BatteryLevel::Charging
+                                               : Common::Input::BatteryLevel::Critical;
+        break;
+    case Common::Input::InputType::Battery:
+        battery = callback.battery_status;
+        break;
+    default:
+        LOG_ERROR(Input, "Conversion from type {} to battery not implemented", callback.type);
+        break;
+    }
+
+    return battery;
+}
+
+Common::Input::ButtonStatus TransformToButton(const Common::Input::CallbackStatus& callback) {
+    Common::Input::ButtonStatus status{};
+    switch (callback.type) {
+    case Common::Input::InputType::Analog:
+    case Common::Input::InputType::Trigger:
+        status.value = TransformToTrigger(callback).pressed.value;
+        break;
+    case Common::Input::InputType::Button:
+        status = callback.button_status;
+        break;
+    default:
+        LOG_ERROR(Input, "Conversion from type {} to button not implemented", callback.type);
+        break;
+    }
+
+    if (status.inverted) {
+        status.value = !status.value;
+    }
+
+    return status;
+}
+
+Common::Input::MotionStatus TransformToMotion(const Common::Input::CallbackStatus& callback) {
+    Common::Input::MotionStatus status{};
+    switch (callback.type) {
+    case Common::Input::InputType::Button: {
+        Common::Input::AnalogProperties properties{
+            .deadzone = 0.0f,
+            .range = 1.0f,
+            .offset = 0.0f,
+        };
+        status.delta_timestamp = 5000;
+        status.force_update = true;
+        status.accel.x = {
+            .value = 0.0f,
+            .raw_value = 0.0f,
+            .properties = properties,
+        };
+        status.accel.y = {
+            .value = 0.0f,
+            .raw_value = 0.0f,
+            .properties = properties,
+        };
+        status.accel.z = {
+            .value = 0.0f,
+            .raw_value = -1.0f,
+            .properties = properties,
+        };
+        status.gyro.x = {
+            .value = 0.0f,
+            .raw_value = 0.0f,
+            .properties = properties,
+        };
+        status.gyro.y = {
+            .value = 0.0f,
+            .raw_value = 0.0f,
+            .properties = properties,
+        };
+        status.gyro.z = {
+            .value = 0.0f,
+            .raw_value = 0.0f,
+            .properties = properties,
+        };
+        if (TransformToButton(callback).value) {
+            std::random_device device;
+            std::mt19937 gen(device());
+            std::uniform_int_distribution<s16> distribution(-1000, 1000);
+            status.accel.x.raw_value = static_cast<f32>(distribution(gen)) * 0.001f;
+            status.accel.y.raw_value = static_cast<f32>(distribution(gen)) * 0.001f;
+            status.accel.z.raw_value = static_cast<f32>(distribution(gen)) * 0.001f;
+            status.gyro.x.raw_value = static_cast<f32>(distribution(gen)) * 0.001f;
+            status.gyro.y.raw_value = static_cast<f32>(distribution(gen)) * 0.001f;
+            status.gyro.z.raw_value = static_cast<f32>(distribution(gen)) * 0.001f;
+        }
+        break;
+    }
+    case Common::Input::InputType::Motion:
+        status = callback.motion_status;
+        break;
+    default:
+        LOG_ERROR(Input, "Conversion from type {} to motion not implemented", callback.type);
+        break;
+    }
+    SanitizeAnalog(status.accel.x, false);
+    SanitizeAnalog(status.accel.y, false);
+    SanitizeAnalog(status.accel.z, false);
+    SanitizeAnalog(status.gyro.x, false);
+    SanitizeAnalog(status.gyro.y, false);
+    SanitizeAnalog(status.gyro.z, false);
+
+    return status;
+}
+
+Common::Input::StickStatus TransformToStick(const Common::Input::CallbackStatus& callback) {
+    Common::Input::StickStatus status{};
+
+    switch (callback.type) {
+    case Common::Input::InputType::Stick:
+        status = callback.stick_status;
+        break;
+    default:
+        LOG_ERROR(Input, "Conversion from type {} to stick not implemented", callback.type);
+        break;
+    }
+
+    SanitizeStick(status.x, status.y, true);
+    const auto& properties_x = status.x.properties;
+    const auto& properties_y = status.y.properties;
+    const float x = status.x.value;
+    const float y = status.y.value;
+
+    // Set directional buttons
+    status.right = x > properties_x.threshold;
+    status.left = x < -properties_x.threshold;
+    status.up = y > properties_y.threshold;
+    status.down = y < -properties_y.threshold;
+
+    return status;
+}
+
+Common::Input::TouchStatus TransformToTouch(const Common::Input::CallbackStatus& callback) {
+    Common::Input::TouchStatus status{};
+
+    switch (callback.type) {
+    case Common::Input::InputType::Touch:
+        status = callback.touch_status;
+        break;
+    case Common::Input::InputType::Stick:
+        status.x = callback.stick_status.x;
+        status.y = callback.stick_status.y;
+        break;
+    default:
+        LOG_ERROR(Input, "Conversion from type {} to touch not implemented", callback.type);
+        break;
+    }
+
+    SanitizeAnalog(status.x, true);
+    SanitizeAnalog(status.y, true);
+    float& x = status.x.value;
+    float& y = status.y.value;
+
+    // Adjust if value is inverted
+    x = status.x.properties.inverted ? 1.0f + x : x;
+    y = status.y.properties.inverted ? 1.0f + y : y;
+
+    // clamp value
+    x = std::clamp(x, 0.0f, 1.0f);
+    y = std::clamp(y, 0.0f, 1.0f);
+
+    if (status.pressed.inverted) {
+        status.pressed.value = !status.pressed.value;
+    }
+
+    return status;
+}
+
+Common::Input::TriggerStatus TransformToTrigger(const Common::Input::CallbackStatus& callback) {
+    Common::Input::TriggerStatus status{};
+    float& raw_value = status.analog.raw_value;
+    bool calculate_button_value = true;
+
+    switch (callback.type) {
+    case Common::Input::InputType::Analog:
+        status.analog.properties = callback.analog_status.properties;
+        raw_value = callback.analog_status.raw_value;
+        break;
+    case Common::Input::InputType::Button:
+        status.analog.properties.range = 1.0f;
+        status.analog.properties.inverted = callback.button_status.inverted;
+        raw_value = callback.button_status.value ? 1.0f : 0.0f;
+        break;
+    case Common::Input::InputType::Trigger:
+        status = callback.trigger_status;
+        calculate_button_value = false;
+        break;
+    default:
+        LOG_ERROR(Input, "Conversion from type {} to trigger not implemented", callback.type);
+        break;
+    }
+
+    SanitizeAnalog(status.analog, true);
+    const auto& properties = status.analog.properties;
+    float& value = status.analog.value;
+
+    // Set button status
+    if (calculate_button_value) {
+        status.pressed.value = value > properties.threshold;
+    }
+
+    // Adjust if value is inverted
+    value = properties.inverted ? 1.0f + value : value;
+
+    // clamp value
+    value = std::clamp(value, 0.0f, 1.0f);
+
+    return status;
+}
+
+Common::Input::AnalogStatus TransformToAnalog(const Common::Input::CallbackStatus& callback) {
+    Common::Input::AnalogStatus status{};
+
+    switch (callback.type) {
+    case Common::Input::InputType::Analog:
+        status.properties = callback.analog_status.properties;
+        status.raw_value = callback.analog_status.raw_value;
+        break;
+    default:
+        LOG_ERROR(Input, "Conversion from type {} to analog not implemented", callback.type);
+        break;
+    }
+
+    SanitizeAnalog(status, false);
+
+    // Adjust if value is inverted
+    status.value = status.properties.inverted ? -status.value : status.value;
+
+    return status;
+}
+
+void SanitizeAnalog(Common::Input::AnalogStatus& analog, bool clamp_value) {
+    const auto& properties = analog.properties;
+    float& raw_value = analog.raw_value;
+    float& value = analog.value;
+
+    if (!std::isnormal(raw_value)) {
+        raw_value = 0;
+    }
+
+    // Apply center offset
+    raw_value -= properties.offset;
+
+    // Set initial values to be formated
+    value = raw_value;
+
+    // Calculate vector size
+    const float r = std::abs(value);
+
+    // Return zero if value is smaller than the deadzone
+    if (r <= properties.deadzone || properties.deadzone == 1.0f) {
+        analog.value = 0;
+        return;
+    }
+
+    // Adjust range of value
+    const float deadzone_factor =
+        1.0f / r * (r - properties.deadzone) / (1.0f - properties.deadzone);
+    value = value * deadzone_factor / properties.range;
+
+    // Invert direction if needed
+    if (properties.inverted) {
+        value = -value;
+    }
+
+    // Clamp value
+    if (clamp_value) {
+        value = std::clamp(value, -1.0f, 1.0f);
+    }
+}
+
+void SanitizeStick(Common::Input::AnalogStatus& analog_x, Common::Input::AnalogStatus& analog_y,
+                   bool clamp_value) {
+    const auto& properties_x = analog_x.properties;
+    const auto& properties_y = analog_y.properties;
+    float& raw_x = analog_x.raw_value;
+    float& raw_y = analog_y.raw_value;
+    float& x = analog_x.value;
+    float& y = analog_y.value;
+
+    if (!std::isnormal(raw_x)) {
+        raw_x = 0;
+    }
+    if (!std::isnormal(raw_y)) {
+        raw_y = 0;
+    }
+
+    // Apply center offset
+    raw_x += properties_x.offset;
+    raw_y += properties_y.offset;
+
+    // Apply X scale correction from offset
+    if (std::abs(properties_x.offset) < 0.5f) {
+        if (raw_x > 0) {
+            raw_x /= 1 + properties_x.offset;
+        } else {
+            raw_x /= 1 - properties_x.offset;
+        }
+    }
+
+    // Apply Y scale correction from offset
+    if (std::abs(properties_y.offset) < 0.5f) {
+        if (raw_y > 0) {
+            raw_y /= 1 + properties_y.offset;
+        } else {
+            raw_y /= 1 - properties_y.offset;
+        }
+    }
+
+    // Invert direction if needed
+    raw_x = properties_x.inverted ? -raw_x : raw_x;
+    raw_y = properties_y.inverted ? -raw_y : raw_y;
+
+    // Set initial values to be formated
+    x = raw_x;
+    y = raw_y;
+
+    // Calculate vector size
+    float r = x * x + y * y;
+    r = std::sqrt(r);
+
+    // TODO(German77): Use deadzone and range of both axis
+
+    // Return zero if values are smaller than the deadzone
+    if (r <= properties_x.deadzone || properties_x.deadzone >= 1.0f) {
+        x = 0;
+        y = 0;
+        return;
+    }
+
+    // Adjust range of joystick
+    const float deadzone_factor =
+        1.0f / r * (r - properties_x.deadzone) / (1.0f - properties_x.deadzone);
+    x = x * deadzone_factor / properties_x.range;
+    y = y * deadzone_factor / properties_x.range;
+    r = r * deadzone_factor / properties_x.range;
+
+    // Normalize joystick
+    if (clamp_value && r > 1.0f) {
+        x /= r;
+        y /= r;
+    }
+}
+
+} // namespace Core::HID

src/core/hid/input_converter.h

@@ -0,0 +1,96 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included
+
+#pragma once
+
+namespace Common::Input {
+struct CallbackStatus;
+enum class BatteryLevel : u32;
+using BatteryStatus = BatteryLevel;
+struct AnalogStatus;
+struct ButtonStatus;
+struct MotionStatus;
+struct StickStatus;
+struct TouchStatus;
+struct TriggerStatus;
+}; // namespace Common::Input
+
+namespace Core::HID {
+
+/**
+ * Converts raw input data into a valid battery status.
+ *
+ * @param callback Supported callbacks: Analog, Battery, Trigger.
+ * @return A valid BatteryStatus object.
+ */
+Common::Input::BatteryStatus TransformToBattery(const Common::Input::CallbackStatus& callback);
+
+/**
+ * Converts raw input data into a valid button status. Applies invert properties to the output.
+ *
+ * @param callback Supported callbacks: Analog, Button, Trigger.
+ * @return A valid TouchStatus object.
+ */
+Common::Input::ButtonStatus TransformToButton(const Common::Input::CallbackStatus& callback);
+
+/**
+ * Converts raw input data into a valid motion status.
+ *
+ * @param callback Supported callbacks: Motion.
+ * @return A valid TouchStatus object.
+ */
+Common::Input::MotionStatus TransformToMotion(const Common::Input::CallbackStatus& callback);
+
+/**
+ * Converts raw input data into a valid stick status. Applies offset, deadzone, range and invert
+ * properties to the output.
+ *
+ * @param callback Supported callbacks: Stick.
+ * @return A valid StickStatus object.
+ */
+Common::Input::StickStatus TransformToStick(const Common::Input::CallbackStatus& callback);
+
+/**
+ * Converts raw input data into a valid touch status.
+ *
+ * @param callback Supported callbacks: Touch.
+ * @return A valid TouchStatus object.
+ */
+Common::Input::TouchStatus TransformToTouch(const Common::Input::CallbackStatus& callback);
+
+/**
+ * Converts raw input data into a valid trigger status. Applies offset, deadzone, range and
+ * invert properties to the output. Button status uses the threshold property if necessary.
+ *
+ * @param callback Supported callbacks: Analog, Button, Trigger.
+ * @return A valid TriggerStatus object.
+ */
+Common::Input::TriggerStatus TransformToTrigger(const Common::Input::CallbackStatus& callback);
+
+/**
+ * Converts raw input data into a valid analog status. Applies offset, deadzone, range and
+ * invert properties to the output.
+ *
+ * @param callback Supported callbacks: Analog.
+ * @return A valid AnalogStatus object.
+ */
+Common::Input::AnalogStatus TransformToAnalog(const Common::Input::CallbackStatus& callback);
+
+/**
+ * Converts raw analog data into a valid analog value
+ * @param analog An analog object containing raw data and properties
+ * @param clamp_value determines if the value needs to be clamped between -1.0f and 1.0f.
+ */
+void SanitizeAnalog(Common::Input::AnalogStatus& analog, bool clamp_value);
+
+/**
+ * Converts raw stick data into a valid stick value
+ * @param analog_x raw analog data and properties for the x-axis
+ * @param analog_y raw analog data and properties for the y-axis
+ * @param clamp_value bool that determines if the value needs to be clamped into the unit circle.
+ */
+void SanitizeStick(Common::Input::AnalogStatus& analog_x, Common::Input::AnalogStatus& analog_y,
+                   bool clamp_value);
+
+} // namespace Core::HID

src/core/hid/input_interpreter.cpp

@@ -3,7 +3,8 @@
 // Refer to the license.txt file included.
 
 #include "core/core.h"
-#include "core/frontend/input_interpreter.h"
+#include "core/hid/hid_types.h"
+#include "core/hid/input_interpreter.h"
 #include "core/hle/service/hid/controllers/npad.h"
 #include "core/hle/service/hid/hid.h"
 #include "core/hle/service/sm/sm.h"
@@ -19,7 +20,7 @@ InputInterpreter::InputInterpreter(Core::System& system)
 InputInterpreter::~InputInterpreter() = default;
 
 void InputInterpreter::PollInput() {
-    const u32 button_state = npad.GetAndResetPressState();
+    const auto button_state = npad.GetAndResetPressState();
 
     previous_index = current_index;
     current_index = (current_index + 1) % button_states.size();
@@ -31,32 +32,30 @@ void InputInterpreter::ResetButtonStates() {
     previous_index = 0;
     current_index = 0;
 
-    button_states[0] = 0xFFFFFFFF;
+    button_states[0] = Core::HID::NpadButton::All;
 
     for (std::size_t i = 1; i < button_states.size(); ++i) {
-        button_states[i] = 0;
+        button_states[i] = Core::HID::NpadButton::None;
     }
 }
 
-bool InputInterpreter::IsButtonPressed(HIDButton button) const {
-    return (button_states[current_index] & (1U << static_cast<u8>(button))) != 0;
+bool InputInterpreter::IsButtonPressed(Core::HID::NpadButton button) const {
+    return True(button_states[current_index] & button);
 }
 
-bool InputInterpreter::IsButtonPressedOnce(HIDButton button) const {
-    const bool current_press =
-        (button_states[current_index] & (1U << static_cast<u8>(button))) != 0;
-    const bool previous_press =
-        (button_states[previous_index] & (1U << static_cast<u8>(button))) != 0;
+bool InputInterpreter::IsButtonPressedOnce(Core::HID::NpadButton button) const {
+    const bool current_press = True(button_states[current_index] & button);
+    const bool previous_press = True(button_states[previous_index] & button);
 
     return current_press && !previous_press;
 }
 
-bool InputInterpreter::IsButtonHeld(HIDButton button) const {
-    u32 held_buttons{button_states[0]};
+bool InputInterpreter::IsButtonHeld(Core::HID::NpadButton button) const {
+    Core::HID::NpadButton held_buttons{button_states[0]};
 
     for (std::size_t i = 1; i < button_states.size(); ++i) {
         held_buttons &= button_states[i];
     }
 
-    return (held_buttons & (1U << static_cast<u8>(button))) != 0;
+    return True(held_buttons & button);
 }

src/core/hid/input_interpreter.h

@@ -12,46 +12,14 @@ namespace Core {
 class System;
 }
 
+namespace Core::HID {
+enum class NpadButton : u64;
+}
+
 namespace Service::HID {
 class Controller_NPad;
 }
 
-enum class HIDButton : u8 {
-    A,
-    B,
-    X,
-    Y,
-    LStick,
-    RStick,
-    L,
-    R,
-    ZL,
-    ZR,
-    Plus,
-    Minus,
-
-    DLeft,
-    DUp,
-    DRight,
-    DDown,
-
-    LStickLeft,
-    LStickUp,
-    LStickRight,
-    LStickDown,
-
-    RStickLeft,
-    RStickUp,
-    RStickRight,
-    RStickDown,
-
-    LeftSL,
-    LeftSR,
-
-    RightSL,
-    RightSR,
-};
-
 /**
  * The InputInterpreter class interfaces with HID to retrieve button press states.
  * Input is intended to be polled every 50ms so that a button is considered to be
@@ -76,7 +44,7 @@ public:
      *
      * @returns True when the button is pressed.
      */
-    [[nodiscard]] bool IsButtonPressed(HIDButton button) const;
+    [[nodiscard]] bool IsButtonPressed(Core::HID::NpadButton button) const;
 
     /**
      * Checks whether any of the buttons in the parameter list is pressed.
@@ -85,7 +53,7 @@ public:
      *
      * @returns True when at least one of the buttons is pressed.
      */
-    template <HIDButton... T>
+    template <Core::HID::NpadButton... T>
     [[nodiscard]] bool IsAnyButtonPressed() {
         return (IsButtonPressed(T) || ...);
     }
@@ -98,7 +66,7 @@ public:
      *
      * @returns True when the button is pressed once.
      */
-    [[nodiscard]] bool IsButtonPressedOnce(HIDButton button) const;
+    [[nodiscard]] bool IsButtonPressedOnce(Core::HID::NpadButton button) const;
 
     /**
      * Checks whether any of the buttons in the parameter list is pressed once.
@@ -107,7 +75,7 @@ public:
      *
      * @returns True when at least one of the buttons is pressed once.
      */
-    template <HIDButton... T>
+    template <Core::HID::NpadButton... T>
     [[nodiscard]] bool IsAnyButtonPressedOnce() const {
         return (IsButtonPressedOnce(T) || ...);
     }
@@ -119,7 +87,7 @@ public:
      *
      * @returns True when the button is held down.
      */
-    [[nodiscard]] bool IsButtonHeld(HIDButton button) const;
+    [[nodiscard]] bool IsButtonHeld(Core::HID::NpadButton button) const;
 
     /**
      * Checks whether any of the buttons in the parameter list is held down.
@@ -128,7 +96,7 @@ public:
      *
      * @returns True when at least one of the buttons is held down.
      */
-    template <HIDButton... T>
+    template <Core::HID::NpadButton... T>
     [[nodiscard]] bool IsAnyButtonHeld() const {
         return (IsButtonHeld(T) || ...);
     }
@@ -137,7 +105,7 @@ private:
     Service::HID::Controller_NPad& npad;
 
     /// Stores 9 consecutive button states polled from HID.
-    std::array<u32, 9> button_states{};
+    std::array<Core::HID::NpadButton, 9> button_states{};
 
     std::size_t previous_index{};
     std::size_t current_index{};

src/core/hid/motion_input.cpp

@@ -2,13 +2,21 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included
 
-#include <random>
 #include "common/math_util.h"
-#include "input_common/motion_input.h"
+#include "core/hid/motion_input.h"
 
-namespace InputCommon {
+namespace Core::HID {
 
-MotionInput::MotionInput(f32 new_kp, f32 new_ki, f32 new_kd) : kp(new_kp), ki(new_ki), kd(new_kd) {}
+MotionInput::MotionInput() {
+    // Initialize PID constants with default values
+    SetPID(0.3f, 0.005f, 0.0f);
+}
+
+void MotionInput::SetPID(f32 new_kp, f32 new_ki, f32 new_kd) {
+    kp = new_kp;
+    ki = new_ki;
+    kd = new_kd;
+}
 
 void MotionInput::SetAcceleration(const Common::Vec3f& acceleration) {
     accel = acceleration;
@@ -65,6 +73,8 @@ void MotionInput::UpdateRotation(u64 elapsed_time) {
     rotations += gyro * sample_period;
 }
 
+// Based on Madgwick's implementation of Mayhony's AHRS algorithm.
+// https://github.com/xioTechnologies/Open-Source-AHRS-With-x-IMU/blob/master/x-IMU%20IMU%20and%20AHRS%20Algorithms/x-IMU%20IMU%20and%20AHRS%20Algorithms/AHRS/MahonyAHRS.cs
 void MotionInput::UpdateOrientation(u64 elapsed_time) {
     if (!IsCalibrated(0.1f)) {
         ResetOrientation();
@@ -190,43 +200,6 @@ Common::Vec3f MotionInput::GetRotations() const {
     return rotations;
 }
 
-Input::MotionStatus MotionInput::GetMotion() const {
-    const Common::Vec3f gyroscope = GetGyroscope();
-    const Common::Vec3f accelerometer = GetAcceleration();
-    const Common::Vec3f rotation = GetRotations();
-    const std::array<Common::Vec3f, 3> orientation = GetOrientation();
-    const Common::Quaternion<f32> quaternion = GetQuaternion();
-    return {accelerometer, gyroscope, rotation, orientation, quaternion};
-}
-
-Input::MotionStatus MotionInput::GetRandomMotion(int accel_magnitude, int gyro_magnitude) const {
-    std::random_device device;
-    std::mt19937 gen(device());
-    std::uniform_int_distribution<s16> distribution(-1000, 1000);
-    const Common::Vec3f gyroscope{
-        static_cast<f32>(distribution(gen)) * 0.001f,
-        static_cast<f32>(distribution(gen)) * 0.001f,
-        static_cast<f32>(distribution(gen)) * 0.001f,
-    };
-    const Common::Vec3f accelerometer{
-        static_cast<f32>(distribution(gen)) * 0.001f,
-        static_cast<f32>(distribution(gen)) * 0.001f,
-        static_cast<f32>(distribution(gen)) * 0.001f,
-    };
-    constexpr Common::Vec3f rotation;
-    constexpr std::array orientation{
-        Common::Vec3f{1.0f, 0.0f, 0.0f},
-        Common::Vec3f{0.0f, 1.0f, 0.0f},
-        Common::Vec3f{0.0f, 0.0f, 1.0f},
-    };
-    constexpr Common::Quaternion<f32> quaternion{
-        {0.0f, 0.0f, 0.0f},
-        1.0f,
-    };
-    return {accelerometer * accel_magnitude, gyroscope * gyro_magnitude, rotation, orientation,
-            quaternion};
-}
-
 void MotionInput::ResetOrientation() {
     if (!reset_enabled || only_accelerometer) {
         return;
@@ -304,4 +277,4 @@ void MotionInput::SetOrientationFromAccelerometer() {
         quat = quat.Normalized();
     }
 }
-} // namespace InputCommon
+} // namespace Core::HID

src/core/hid/motion_input.h

@@ -7,13 +7,12 @@
 #include "common/common_types.h"
 #include "common/quaternion.h"
 #include "common/vector_math.h"
-#include "core/frontend/input.h"
 
-namespace InputCommon {
+namespace Core::HID {
 
 class MotionInput {
 public:
-    explicit MotionInput(f32 new_kp, f32 new_ki, f32 new_kd);
+    explicit MotionInput();
 
     MotionInput(const MotionInput&) = default;
     MotionInput& operator=(const MotionInput&) = default;
@@ -21,6 +20,7 @@ public:
     MotionInput(MotionInput&&) = default;
     MotionInput& operator=(MotionInput&&) = default;
 
+    void SetPID(f32 new_kp, f32 new_ki, f32 new_kd);
     void SetAcceleration(const Common::Vec3f& acceleration);
     void SetGyroscope(const Common::Vec3f& gyroscope);
     void SetQuaternion(const Common::Quaternion<f32>& quaternion);
@@ -38,9 +38,6 @@ public:
     [[nodiscard]] Common::Vec3f GetGyroscope() const;
     [[nodiscard]] Common::Vec3f GetRotations() const;
     [[nodiscard]] Common::Quaternion<f32> GetQuaternion() const;
-    [[nodiscard]] Input::MotionStatus GetMotion() const;
-    [[nodiscard]] Input::MotionStatus GetRandomMotion(int accel_magnitude,
-                                                      int gyro_magnitude) const;
 
     [[nodiscard]] bool IsMoving(f32 sensitivity) const;
     [[nodiscard]] bool IsCalibrated(f32 sensitivity) const;
@@ -59,16 +56,32 @@ private:
     Common::Vec3f integral_error;
     Common::Vec3f derivative_error;
 
+    // Quaternion containing the device orientation
     Common::Quaternion<f32> quat{{0.0f, 0.0f, -1.0f}, 0.0f};
+
+    // Number of full rotations in each axis
     Common::Vec3f rotations;
+
+    // Acceleration vector measurement in G force
     Common::Vec3f accel;
+
+    // Gyroscope vector measurement in radians/s.
     Common::Vec3f gyro;
+
+    // Vector to be substracted from gyro measurements
     Common::Vec3f gyro_drift;
 
+    // Minimum gyro amplitude to detect if the device is moving
     f32 gyro_threshold = 0.0f;
+
+    // Number of invalid sequential data
     u32 reset_counter = 0;
+
+    // If the provided data is invalid the device will be autocalibrated
     bool reset_enabled = true;
+
+    // Use accelerometer values to calculate position
     bool only_accelerometer = true;
 };
 
-} // namespace InputCommon
+} // namespace Core::HID

src/core/hle/kernel/k_page_table.cpp

@@ -685,8 +685,8 @@ ResultCode KPageTable::UnmapPages(VAddr addr, KPageLinkedList& page_linked_list,
     return ResultSuccess;
 }
 
-ResultCode KPageTable::SetCodeMemoryPermission(VAddr addr, std::size_t size,
-                                               KMemoryPermission perm) {
+ResultCode KPageTable::SetProcessMemoryPermission(VAddr addr, std::size_t size,
+                                                  KMemoryPermission perm) {
 
     std::lock_guard lock{page_table_lock};
 

src/core/hle/kernel/k_page_table.h

@@ -41,7 +41,7 @@ public:
     ResultCode MapPages(VAddr addr, KPageLinkedList& page_linked_list, KMemoryState state,
                         KMemoryPermission perm);
     ResultCode UnmapPages(VAddr addr, KPageLinkedList& page_linked_list, KMemoryState state);
-    ResultCode SetCodeMemoryPermission(VAddr addr, std::size_t size, KMemoryPermission perm);
+    ResultCode SetProcessMemoryPermission(VAddr addr, std::size_t size, KMemoryPermission perm);
     KMemoryInfo QueryInfo(VAddr addr);
     ResultCode ReserveTransferMemory(VAddr addr, std::size_t size, KMemoryPermission perm);
     ResultCode ResetTransferMemory(VAddr addr, std::size_t size);

src/core/hle/kernel/k_process.cpp

@@ -528,7 +528,7 @@ void KProcess::LoadModule(CodeSet code_set, VAddr base_addr) {
     std::lock_guard lock{HLE::g_hle_lock};
     const auto ReprotectSegment = [&](const CodeSet::Segment& segment,
                                       KMemoryPermission permission) {
-        page_table->SetCodeMemoryPermission(segment.addr + base_addr, segment.size, permission);
+        page_table->SetProcessMemoryPermission(segment.addr + base_addr, segment.size, permission);
     };
 
     kernel.System().Memory().WriteBlock(*this, base_addr, code_set.memory.data(),

src/core/hle/kernel/k_process.h

@@ -154,8 +154,8 @@ public:
         return process_id;
     }
 
-    /// Gets the title ID corresponding to this process.
-    u64 GetTitleID() const {
+    /// Gets the program ID corresponding to this process.
+    u64 GetProgramID() const {
         return program_id;
     }
 

src/core/hle/kernel/kernel.cpp

@@ -300,15 +300,16 @@ struct KernelCore::Impl {
     // Gets the dummy KThread for the caller, allocating a new one if this is the first time
     KThread* GetHostDummyThread() {
         auto make_thread = [this]() {
-            std::unique_ptr<KThread> thread = std::make_unique<KThread>(system.Kernel());
+            std::lock_guard lk(dummy_thread_lock);
+            auto& thread = dummy_threads.emplace_back(std::make_unique<KThread>(system.Kernel()));
             KAutoObject::Create(thread.get());
             ASSERT(KThread::InitializeDummyThread(thread.get()).IsSuccess());
             thread->SetName(fmt::format("DummyThread:{}", GetHostThreadId()));
-            return thread;
+            return thread.get();
         };
 
-        thread_local auto thread = make_thread();
-        return thread.get();
+        thread_local KThread* saved_thread = make_thread();
+        return saved_thread;
     }
 
     /// Registers a CPU core thread by allocating a host thread ID for it
@@ -695,6 +696,12 @@ struct KernelCore::Impl {
         return port;
     }
 
+    std::mutex server_ports_lock;
+    std::mutex server_sessions_lock;
+    std::mutex registered_objects_lock;
+    std::mutex registered_in_use_objects_lock;
+    std::mutex dummy_thread_lock;
+
     std::atomic<u32> next_object_id{0};
     std::atomic<u64> next_kernel_process_id{KProcess::InitialKIPIDMin};
     std::atomic<u64> next_user_process_id{KProcess::ProcessIDMin};
@@ -725,10 +732,6 @@ struct KernelCore::Impl {
     std::unordered_set<KServerSession*> server_sessions;
     std::unordered_set<KAutoObject*> registered_objects;
     std::unordered_set<KAutoObject*> registered_in_use_objects;
-    std::mutex server_ports_lock;
-    std::mutex server_sessions_lock;
-    std::mutex registered_objects_lock;
-    std::mutex registered_in_use_objects_lock;
 
     std::unique_ptr<Core::ExclusiveMonitor> exclusive_monitor;
     std::vector<Kernel::PhysicalCore> cores;
@@ -753,6 +756,9 @@ struct KernelCore::Impl {
     std::array<Core::CPUInterruptHandler, Core::Hardware::NUM_CPU_CORES> interrupts{};
     std::array<std::unique_ptr<Kernel::KScheduler>, Core::Hardware::NUM_CPU_CORES> schedulers{};
 
+    // Specifically tracked to be automatically destroyed with kernel
+    std::vector<std::unique_ptr<KThread>> dummy_threads;
+
     bool is_multicore{};
     bool is_phantom_mode_for_singlecore{};
     u32 single_core_thread_id{};

src/core/hle/kernel/svc.cpp

@@ -768,7 +768,7 @@ static ResultCode GetInfo(Core::System& system, u64* result, u64 info_id, Handle
             return ResultSuccess;
 
         case GetInfoType::TitleId:
-            *result = process->GetTitleID();
+            *result = process->GetProgramID();
             return ResultSuccess;
 
         case GetInfoType::UserExceptionContextAddr:
@@ -1169,6 +1169,8 @@ static u32 GetCurrentProcessorNumber32(Core::System& system) {
     return GetCurrentProcessorNumber(system);
 }
 
+namespace {
+
 constexpr bool IsValidSharedMemoryPermission(Svc::MemoryPermission perm) {
     switch (perm) {
     case Svc::MemoryPermission::Read:
@@ -1179,10 +1181,24 @@ constexpr bool IsValidSharedMemoryPermission(Svc::MemoryPermission perm) {
     }
 }
 
-constexpr bool IsValidRemoteSharedMemoryPermission(Svc::MemoryPermission perm) {
+[[maybe_unused]] constexpr bool IsValidRemoteSharedMemoryPermission(Svc::MemoryPermission perm) {
     return IsValidSharedMemoryPermission(perm) || perm == Svc::MemoryPermission::DontCare;
 }
 
+constexpr bool IsValidProcessMemoryPermission(Svc::MemoryPermission perm) {
+    switch (perm) {
+    case Svc::MemoryPermission::None:
+    case Svc::MemoryPermission::Read:
+    case Svc::MemoryPermission::ReadWrite:
+    case Svc::MemoryPermission::ReadExecute:
+        return true;
+    default:
+        return false;
+    }
+}
+
+} // Anonymous namespace
+
 static ResultCode MapSharedMemory(Core::System& system, Handle shmem_handle, VAddr address,
                                   u64 size, Svc::MemoryPermission map_perm) {
     LOG_TRACE(Kernel_SVC,
@@ -1262,6 +1278,34 @@ static ResultCode UnmapSharedMemory32(Core::System& system, Handle shmem_handle,
     return UnmapSharedMemory(system, shmem_handle, address, size);
 }
 
+static ResultCode SetProcessMemoryPermission(Core::System& system, Handle process_handle,
+                                             VAddr address, u64 size, Svc::MemoryPermission perm) {
+    LOG_TRACE(Kernel_SVC,
+              "called, process_handle=0x{:X}, addr=0x{:X}, size=0x{:X}, permissions=0x{:08X}",
+              process_handle, address, size, perm);
+
+    // Validate the address/size.
+    R_UNLESS(Common::IsAligned(address, PageSize), ResultInvalidAddress);
+    R_UNLESS(Common::IsAligned(size, PageSize), ResultInvalidSize);
+    R_UNLESS(size > 0, ResultInvalidSize);
+    R_UNLESS((address < address + size), ResultInvalidCurrentMemory);
+
+    // Validate the memory permission.
+    R_UNLESS(IsValidProcessMemoryPermission(perm), ResultInvalidNewMemoryPermission);
+
+    // Get the process from its handle.
+    KScopedAutoObject process =
+        system.CurrentProcess()->GetHandleTable().GetObject<KProcess>(process_handle);
+    R_UNLESS(process.IsNotNull(), ResultInvalidHandle);
+
+    // Validate that the address is in range.
+    auto& page_table = process->PageTable();
+    R_UNLESS(page_table.Contains(address, size), ResultInvalidCurrentMemory);
+
+    // Set the memory permission.
+    return page_table.SetProcessMemoryPermission(address, size, ConvertToKMemoryPermission(perm));
+}
+
 static ResultCode QueryProcessMemory(Core::System& system, VAddr memory_info_address,
                                      VAddr page_info_address, Handle process_handle,
                                      VAddr address) {
@@ -1459,10 +1503,14 @@ static void ExitProcess32(Core::System& system) {
     ExitProcess(system);
 }
 
-static constexpr bool IsValidVirtualCoreId(int32_t core_id) {
+namespace {
+
+constexpr bool IsValidVirtualCoreId(int32_t core_id) {
     return (0 <= core_id && core_id < static_cast<int32_t>(Core::Hardware::NUM_CPU_CORES));
 }
 
+} // Anonymous namespace
+
 /// Creates a new thread
 static ResultCode CreateThread(Core::System& system, Handle* out_handle, VAddr entry_point, u64 arg,
                                VAddr stack_bottom, u32 priority, s32 core_id) {
@@ -1846,7 +1894,9 @@ static ResultCode ResetSignal32(Core::System& system, Handle handle) {
     return ResetSignal(system, handle);
 }
 
-static constexpr bool IsValidTransferMemoryPermission(MemoryPermission perm) {
+namespace {
+
+constexpr bool IsValidTransferMemoryPermission(MemoryPermission perm) {
     switch (perm) {
     case MemoryPermission::None:
     case MemoryPermission::Read:
@@ -1857,6 +1907,8 @@ static constexpr bool IsValidTransferMemoryPermission(MemoryPermission perm) {
     }
 }
 
+} // Anonymous namespace
+
 /// Creates a TransferMemory object
 static ResultCode CreateTransferMemory(Core::System& system, Handle* out, VAddr address, u64 size,
                                        MemoryPermission map_perm) {
@@ -2588,7 +2640,7 @@ static const FunctionDef SVC_Table_64[] = {
     {0x70, nullptr, "CreatePort"},
     {0x71, nullptr, "ManageNamedPort"},
     {0x72, nullptr, "ConnectToPort"},
-    {0x73, nullptr, "SetProcessMemoryPermission"},
+    {0x73, SvcWrap64<SetProcessMemoryPermission>, "SetProcessMemoryPermission"},
     {0x74, nullptr, "MapProcessMemory"},
     {0x75, nullptr, "UnmapProcessMemory"},
     {0x76, SvcWrap64<QueryProcessMemory>, "QueryProcessMemory"},

src/core/hle/service/acc/acc.cpp

@@ -16,7 +16,6 @@
 #include "core/file_sys/control_metadata.h"
 #include "core/file_sys/patch_manager.h"
 #include "core/hle/ipc_helpers.h"
-#include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/service/acc/acc.h"
 #include "core/hle/service/acc/acc_aa.h"
@@ -759,9 +758,8 @@ ResultCode Module::Interface::InitializeApplicationInfoBase() {
     // TODO(ogniK): This should be changed to reflect the target process for when we have multiple
     // processes emulated. As we don't actually have pid support we should assume we're just using
     // our own process
-    const auto& current_process = system.Kernel().CurrentProcess();
     const auto launch_property =
-        system.GetARPManager().GetLaunchProperty(current_process->GetTitleID());
+        system.GetARPManager().GetLaunchProperty(system.GetCurrentProcessProgramID());
 
     if (launch_property.Failed()) {
         LOG_ERROR(Service_ACC, "Failed to get launch property");
@@ -805,7 +803,7 @@ void Module::Interface::IsUserAccountSwitchLocked(Kernel::HLERequestContext& ctx
     bool is_locked = false;
 
     if (res != Loader::ResultStatus::Success) {
-        const FileSys::PatchManager pm{system.CurrentProcess()->GetTitleID(),
+        const FileSys::PatchManager pm{system.GetCurrentProcessProgramID(),
                                        system.GetFileSystemController(),
                                        system.GetContentProvider()};
         const auto nacp_unique = pm.GetControlMetadata().first;

src/core/hle/service/am/am.cpp

@@ -15,7 +15,6 @@
 #include "core/file_sys/savedata_factory.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/k_event.h"
-#include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/k_transfer_memory.h"
 #include "core/hle/service/acc/profile_manager.h"
 #include "core/hle/service/am/am.h"
@@ -31,6 +30,7 @@
 #include "core/hle/service/apm/apm_controller.h"
 #include "core/hle/service/apm/apm_interface.h"
 #include "core/hle/service/bcat/backend/backend.h"
+#include "core/hle/service/caps/caps.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/ns/ns.h"
 #include "core/hle/service/nvflinger/nvflinger.h"
@@ -299,7 +299,7 @@ ISelfController::ISelfController(Core::System& system_, NVFlinger::NVFlinger& nv
         {91, &ISelfController::GetAccumulatedSuspendedTickChangedEvent, "GetAccumulatedSuspendedTickChangedEvent"},
         {100, &ISelfController::SetAlbumImageTakenNotificationEnabled, "SetAlbumImageTakenNotificationEnabled"},
         {110, nullptr, "SetApplicationAlbumUserData"},
-        {120, nullptr, "SaveCurrentScreenshot"},
+        {120, &ISelfController::SaveCurrentScreenshot, "SaveCurrentScreenshot"},
         {130, nullptr, "SetRecordVolumeMuted"},
         {1000, nullptr, "GetDebugStorageChannel"},
     };
@@ -580,6 +580,17 @@ void ISelfController::SetAlbumImageTakenNotificationEnabled(Kernel::HLERequestCo
     rb.Push(ResultSuccess);
 }
 
+void ISelfController::SaveCurrentScreenshot(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+
+    const auto album_report_option = rp.PopEnum<Capture::AlbumReportOption>();
+
+    LOG_WARNING(Service_AM, "(STUBBED) called. album_report_option={}", album_report_option);
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+
 AppletMessageQueue::AppletMessageQueue(Core::System& system)
     : service_context{system, "AppletMessageQueue"} {
     on_new_message = service_context.CreateEvent("AMMessageQueue:OnMessageReceived");
@@ -798,15 +809,11 @@ void ICommonStateGetter::GetDefaultDisplayResolution(Kernel::HLERequestContext&
     rb.Push(ResultSuccess);
 
     if (Settings::values.use_docked_mode.GetValue()) {
-        rb.Push(static_cast<u32>(Service::VI::DisplayResolution::DockedWidth) *
-                static_cast<u32>(Settings::values.resolution_factor.GetValue()));
-        rb.Push(static_cast<u32>(Service::VI::DisplayResolution::DockedHeight) *
-                static_cast<u32>(Settings::values.resolution_factor.GetValue()));
+        rb.Push(static_cast<u32>(Service::VI::DisplayResolution::DockedWidth));
+        rb.Push(static_cast<u32>(Service::VI::DisplayResolution::DockedHeight));
     } else {
-        rb.Push(static_cast<u32>(Service::VI::DisplayResolution::UndockedWidth) *
-                static_cast<u32>(Settings::values.resolution_factor.GetValue()));
-        rb.Push(static_cast<u32>(Service::VI::DisplayResolution::UndockedHeight) *
-                static_cast<u32>(Settings::values.resolution_factor.GetValue()));
+        rb.Push(static_cast<u32>(Service::VI::DisplayResolution::UndockedWidth));
+        rb.Push(static_cast<u32>(Service::VI::DisplayResolution::UndockedHeight));
     }
 }
 
@@ -1429,7 +1436,7 @@ void IApplicationFunctions::PopLaunchParameter(Kernel::HLERequestContext& ctx) {
         u64 build_id{};
         std::memcpy(&build_id, build_id_full.data(), sizeof(u64));
 
-        auto data = backend->GetLaunchParameter({system.CurrentProcess()->GetTitleID(), build_id});
+        auto data = backend->GetLaunchParameter({system.GetCurrentProcessProgramID(), build_id});
         if (data.has_value()) {
             IPC::ResponseBuilder rb{ctx, 2, 0, 1};
             rb.Push(ResultSuccess);
@@ -1481,7 +1488,7 @@ void IApplicationFunctions::EnsureSaveData(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_AM, "called, uid={:016X}{:016X}", user_id[1], user_id[0]);
 
     FileSys::SaveDataAttribute attribute{};
-    attribute.title_id = system.CurrentProcess()->GetTitleID();
+    attribute.title_id = system.GetCurrentProcessProgramID();
     attribute.user_id = user_id;
     attribute.type = FileSys::SaveDataType::SaveData;
     const auto res = system.GetFileSystemController().CreateSaveData(
@@ -1511,7 +1518,7 @@ void IApplicationFunctions::GetDisplayVersion(Kernel::HLERequestContext& ctx) {
     std::array<u8, 0x10> version_string{};
 
     const auto res = [this] {
-        const auto title_id = system.CurrentProcess()->GetTitleID();
+        const auto title_id = system.GetCurrentProcessProgramID();
 
         const FileSys::PatchManager pm{title_id, system.GetFileSystemController(),
                                        system.GetContentProvider()};
@@ -1548,7 +1555,7 @@ void IApplicationFunctions::GetDesiredLanguage(Kernel::HLERequestContext& ctx) {
     u32 supported_languages = 0;
 
     const auto res = [this] {
-        const auto title_id = system.CurrentProcess()->GetTitleID();
+        const auto title_id = system.GetCurrentProcessProgramID();
 
         const FileSys::PatchManager pm{title_id, system.GetFileSystemController(),
                                        system.GetContentProvider()};
@@ -1656,7 +1663,7 @@ void IApplicationFunctions::ExtendSaveData(Kernel::HLERequestContext& ctx) {
               static_cast<u8>(type), user_id[1], user_id[0], new_normal_size, new_journal_size);
 
     system.GetFileSystemController().WriteSaveDataSize(
-        type, system.CurrentProcess()->GetTitleID(), user_id, {new_normal_size, new_journal_size});
+        type, system.GetCurrentProcessProgramID(), user_id, {new_normal_size, new_journal_size});
 
     IPC::ResponseBuilder rb{ctx, 4};
     rb.Push(ResultSuccess);
@@ -1680,7 +1687,7 @@ void IApplicationFunctions::GetSaveDataSize(Kernel::HLERequestContext& ctx) {
               user_id[0]);
 
     const auto size = system.GetFileSystemController().ReadSaveDataSize(
-        type, system.CurrentProcess()->GetTitleID(), user_id);
+        type, system.GetCurrentProcessProgramID(), user_id);
 
     IPC::ResponseBuilder rb{ctx, 6};
     rb.Push(ResultSuccess);

src/core/hle/service/am/am.h

@@ -151,6 +151,7 @@ private:
     void GetAccumulatedSuspendedTickValue(Kernel::HLERequestContext& ctx);
     void GetAccumulatedSuspendedTickChangedEvent(Kernel::HLERequestContext& ctx);
     void SetAlbumImageTakenNotificationEnabled(Kernel::HLERequestContext& ctx);
+    void SaveCurrentScreenshot(Kernel::HLERequestContext& ctx);
 
     enum class ScreenshotPermission : u32 {
         Inherit = 0,

src/core/hle/service/am/applets/applet_controller.cpp

@@ -10,6 +10,9 @@
 #include "common/string_util.h"
 #include "core/core.h"
 #include "core/frontend/applets/controller.h"
+#include "core/hid/emulated_controller.h"
+#include "core/hid/hid_core.h"
+#include "core/hid/hid_types.h"
 #include "core/hle/result.h"
 #include "core/hle/service/am/am.h"
 #include "core/hle/service/am/applets/applet_controller.h"
@@ -25,7 +28,7 @@ namespace Service::AM::Applets {
 static Core::Frontend::ControllerParameters ConvertToFrontendParameters(
     ControllerSupportArgPrivate private_arg, ControllerSupportArgHeader header, bool enable_text,
     std::vector<IdentificationColor> identification_colors, std::vector<ExplainText> text) {
-    HID::Controller_NPad::NpadStyleSet npad_style_set;
+    Core::HID::NpadStyleTag npad_style_set;
     npad_style_set.raw = private_arg.style_set;
 
     return {
@@ -243,19 +246,11 @@ void Controller::Execute() {
 void Controller::ConfigurationComplete() {
     ControllerSupportResultInfo result_info{};
 
-    const auto& players = Settings::values.players.GetValue();
-
     // If enable_single_mode is enabled, player_count is 1 regardless of any other parameters.
     // Otherwise, only count connected players from P1-P8.
-    result_info.player_count =
-        is_single_mode
-            ? 1
-            : static_cast<s8>(std::count_if(players.begin(), players.end() - 2,
-                                            [](const auto& player) { return player.connected; }));
+    result_info.player_count = is_single_mode ? 1 : system.HIDCore().GetPlayerCount();
 
-    result_info.selected_id = HID::Controller_NPad::IndexToNPad(std::distance(
-        players.begin(), std::find_if(players.begin(), players.end(),
-                                      [](const auto& player) { return player.connected; })));
+    result_info.selected_id = static_cast<u32>(system.HIDCore().GetFirstNpadId());
 
     result_info.result = 0;
 

src/core/hle/service/am/applets/applet_controller.h

@@ -16,6 +16,10 @@ namespace Core {
 class System;
 }
 
+namespace Core::HID {
+enum class NpadStyleSet : u32;
+}
+
 namespace Service::AM::Applets {
 
 using IdentificationColor = std::array<u8, 4>;
@@ -52,7 +56,7 @@ struct ControllerSupportArgPrivate {
     bool flag_1{};
     ControllerSupportMode mode{};
     ControllerSupportCaller caller{};
-    u32 style_set{};
+    Core::HID::NpadStyleSet style_set{};
     u32 joy_hold_type{};
 };
 static_assert(sizeof(ControllerSupportArgPrivate) == 0x14,

src/core/hle/service/am/applets/applet_error.cpp

@@ -9,7 +9,6 @@
 #include "common/string_util.h"
 #include "core/core.h"
 #include "core/frontend/applets/error.h"
-#include "core/hle/kernel/k_process.h"
 #include "core/hle/service/am/am.h"
 #include "core/hle/service/am/applets/applet_error.h"
 #include "core/reporter.h"
@@ -167,7 +166,7 @@ void Error::Execute() {
     }
 
     const auto callback = [this] { DisplayCompleted(); };
-    const auto title_id = system.CurrentProcess()->GetTitleID();
+    const auto title_id = system.GetCurrentProcessProgramID();
     const auto& reporter{system.GetReporter()};
 
     switch (mode) {

src/core/hle/service/am/applets/applet_general_backend.cpp

@@ -7,7 +7,6 @@
 #include "common/logging/log.h"
 #include "core/core.h"
 #include "core/frontend/applets/general_frontend.h"
-#include "core/hle/kernel/k_process.h"
 #include "core/hle/result.h"
 #include "core/hle/service/am/am.h"
 #include "core/hle/service/am/applets/applet_general_backend.h"
@@ -187,7 +186,7 @@ void PhotoViewer::Execute() {
     const auto callback = [this] { ViewFinished(); };
     switch (mode) {
     case PhotoViewerAppletMode::CurrentApp:
-        frontend.ShowPhotosForApplication(system.CurrentProcess()->GetTitleID(), callback);
+        frontend.ShowPhotosForApplication(system.GetCurrentProcessProgramID(), callback);
         break;
     case PhotoViewerAppletMode::AllApps:
         frontend.ShowAllPhotos(callback);

src/core/hle/service/am/applets/applet_software_keyboard.cpp

@@ -109,13 +109,18 @@ void SoftwareKeyboard::Execute() {
     ShowNormalKeyboard();
 }
 
-void SoftwareKeyboard::SubmitTextNormal(SwkbdResult result, std::u16string submitted_text) {
+void SoftwareKeyboard::SubmitTextNormal(SwkbdResult result, std::u16string submitted_text,
+                                        bool confirmed) {
     if (complete) {
         return;
     }
 
     if (swkbd_config_common.use_text_check && result == SwkbdResult::Ok) {
-        SubmitForTextCheck(submitted_text);
+        if (confirmed) {
+            SubmitNormalOutputAndExit(result, submitted_text);
+        } else {
+            SubmitForTextCheck(submitted_text);
+        }
     } else {
         SubmitNormalOutputAndExit(result, submitted_text);
     }
@@ -273,13 +278,21 @@ void SoftwareKeyboard::ProcessTextCheck() {
 
     std::memcpy(&swkbd_text_check, text_check_data.data(), sizeof(SwkbdTextCheck));
 
-    std::u16string text_check_message =
-        swkbd_text_check.text_check_result == SwkbdTextCheckResult::Failure ||
-                swkbd_text_check.text_check_result == SwkbdTextCheckResult::Confirm
-            ? Common::UTF16StringFromFixedZeroTerminatedBuffer(
-                  swkbd_text_check.text_check_message.data(),
-                  swkbd_text_check.text_check_message.size())
-            : u"";
+    std::u16string text_check_message = [this, &swkbd_text_check]() -> std::u16string {
+        if (swkbd_text_check.text_check_result == SwkbdTextCheckResult::Failure ||
+            swkbd_text_check.text_check_result == SwkbdTextCheckResult::Confirm) {
+            return swkbd_config_common.use_utf8
+                       ? Common::UTF8ToUTF16(Common::StringFromFixedZeroTerminatedBuffer(
+                             reinterpret_cast<const char*>(
+                                 swkbd_text_check.text_check_message.data()),
+                             swkbd_text_check.text_check_message.size() * sizeof(char16_t)))
+                       : Common::UTF16StringFromFixedZeroTerminatedBuffer(
+                             swkbd_text_check.text_check_message.data(),
+                             swkbd_text_check.text_check_message.size());
+        } else {
+            return u"";
+        }
+    }();
 
     LOG_INFO(Service_AM, "\nTextCheckResult: {}\nTextCheckMessage: {}",
              GetTextCheckResultName(swkbd_text_check.text_check_result),
@@ -583,11 +596,12 @@ void SoftwareKeyboard::InitializeFrontendKeyboard() {
             .disable_cancel_button{disable_cancel_button},
         };
 
-        frontend.InitializeKeyboard(false, std::move(initialize_parameters),
-                                    [this](SwkbdResult result, std::u16string submitted_text) {
-                                        SubmitTextNormal(result, submitted_text);
-                                    },
-                                    {});
+        frontend.InitializeKeyboard(
+            false, std::move(initialize_parameters),
+            [this](SwkbdResult result, std::u16string submitted_text, bool confirmed) {
+                SubmitTextNormal(result, submitted_text, confirmed);
+            },
+            {});
     }
 }
 

src/core/hle/service/am/applets/applet_software_keyboard.h

@@ -36,8 +36,9 @@ public:
      *
      * @param result SwkbdResult enum
      * @param submitted_text UTF-16 encoded string
+     * @param confirmed Whether the text has been confirmed after TextCheckResult::Confirm
      */
-    void SubmitTextNormal(SwkbdResult result, std::u16string submitted_text);
+    void SubmitTextNormal(SwkbdResult result, std::u16string submitted_text, bool confirmed);
 
     /**
      * Submits the input text to the application.

src/core/hle/service/am/applets/applet_web_browser.cpp

@@ -18,7 +18,6 @@
 #include "core/file_sys/system_archive/system_archive.h"
 #include "core/file_sys/vfs_vector.h"
 #include "core/frontend/applets/web_browser.h"
-#include "core/hle/kernel/k_process.h"
 #include "core/hle/result.h"
 #include "core/hle/service/am/am.h"
 #include "core/hle/service/am/applets/applet_web_browser.h"
@@ -395,7 +394,7 @@ void WebBrowser::InitializeOffline() {
     switch (document_kind) {
     case DocumentKind::OfflineHtmlPage:
     default:
-        title_id = system.CurrentProcess()->GetTitleID();
+        title_id = system.GetCurrentProcessProgramID();
         nca_type = FileSys::ContentRecordType::HtmlDocument;
         additional_paths = "html-document";
         break;

src/core/hle/service/am/applets/applets.cpp

@@ -231,7 +231,7 @@ void AppletManager::SetDefaultAppletFrontendSet() {
 void AppletManager::SetDefaultAppletsIfMissing() {
     if (frontend.controller == nullptr) {
         frontend.controller =
-            std::make_unique<Core::Frontend::DefaultControllerApplet>(system.ServiceManager());
+            std::make_unique<Core::Frontend::DefaultControllerApplet>(system.HIDCore());
     }
 
     if (frontend.error == nullptr) {

src/core/hle/service/aoc/aoc_u.cpp

@@ -17,7 +17,6 @@
 #include "core/file_sys/registered_cache.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/k_event.h"
-#include "core/hle/kernel/k_process.h"
 #include "core/hle/service/aoc/aoc_u.h"
 #include "core/loader/loader.h"
 
@@ -123,9 +122,14 @@ AOC_U::AOC_U(Core::System& system_)
         {8, &AOC_U::GetAddOnContentListChangedEvent, "GetAddOnContentListChangedEvent"},
         {9, nullptr, "GetAddOnContentLostErrorCode"},
         {10, &AOC_U::GetAddOnContentListChangedEventWithProcessId, "GetAddOnContentListChangedEventWithProcessId"},
+        {11, &AOC_U::NotifyMountAddOnContent, "NotifyMountAddOnContent"},
+        {12, &AOC_U::NotifyUnmountAddOnContent, "NotifyUnmountAddOnContent"},
+        {13, nullptr, "IsAddOnContentMountedForDebug"},
+        {50, &AOC_U::CheckAddOnContentMountStatus, "CheckAddOnContentMountStatus"},
         {100, &AOC_U::CreateEcPurchasedEventManager, "CreateEcPurchasedEventManager"},
         {101, &AOC_U::CreatePermanentEcPurchasedEventManager, "CreatePermanentEcPurchasedEventManager"},
         {110, nullptr, "CreateContentsServiceManager"},
+        {200, nullptr, "SetRequiredAddOnContentsOnContentsAvailabilityTransition"},
     };
     // clang-format on
 
@@ -152,7 +156,7 @@ void AOC_U::CountAddOnContent(Kernel::HLERequestContext& ctx) {
     IPC::ResponseBuilder rb{ctx, 3};
     rb.Push(ResultSuccess);
 
-    const auto current = system.CurrentProcess()->GetTitleID();
+    const auto current = system.GetCurrentProcessProgramID();
 
     const auto& disabled = Settings::values.disabled_addons[current];
     if (std::find(disabled.begin(), disabled.end(), "DLC") != disabled.end()) {
@@ -179,7 +183,7 @@ void AOC_U::ListAddOnContent(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_AOC, "called with offset={}, count={}, process_id={}", offset, count,
               process_id);
 
-    const auto current = system.CurrentProcess()->GetTitleID();
+    const auto current = system.GetCurrentProcessProgramID();
 
     std::vector<u32> out;
     const auto& disabled = Settings::values.disabled_addons[current];
@@ -225,7 +229,7 @@ void AOC_U::GetAddOnContentBaseId(Kernel::HLERequestContext& ctx) {
     IPC::ResponseBuilder rb{ctx, 4};
     rb.Push(ResultSuccess);
 
-    const auto title_id = system.CurrentProcess()->GetTitleID();
+    const auto title_id = system.GetCurrentProcessProgramID();
     const FileSys::PatchManager pm{title_id, system.GetFileSystemController(),
                                    system.GetContentProvider()};
 
@@ -271,6 +275,27 @@ void AOC_U::GetAddOnContentListChangedEventWithProcessId(Kernel::HLERequestConte
     rb.PushCopyObjects(aoc_change_event->GetReadableEvent());
 }
 
+void AOC_U::NotifyMountAddOnContent(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_AOC, "(STUBBED) called");
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+
+void AOC_U::NotifyUnmountAddOnContent(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_AOC, "(STUBBED) called");
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+
+void AOC_U::CheckAddOnContentMountStatus(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_AOC, "(STUBBED) called");
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+
 void AOC_U::CreateEcPurchasedEventManager(Kernel::HLERequestContext& ctx) {
     LOG_WARNING(Service_AOC, "(STUBBED) called");
 

src/core/hle/service/aoc/aoc_u.h

@@ -29,6 +29,9 @@ private:
     void PrepareAddOnContent(Kernel::HLERequestContext& ctx);
     void GetAddOnContentListChangedEvent(Kernel::HLERequestContext& ctx);
     void GetAddOnContentListChangedEventWithProcessId(Kernel::HLERequestContext& ctx);
+    void NotifyMountAddOnContent(Kernel::HLERequestContext& ctx);
+    void NotifyUnmountAddOnContent(Kernel::HLERequestContext& ctx);
+    void CheckAddOnContentMountStatus(Kernel::HLERequestContext& ctx);
     void CreateEcPurchasedEventManager(Kernel::HLERequestContext& ctx);
     void CreatePermanentEcPurchasedEventManager(Kernel::HLERequestContext& ctx);
 

src/core/hle/service/audio/hwopus.cpp

@@ -96,7 +96,7 @@ private:
 
     bool DecodeOpusData(u32& consumed, u32& sample_count, const std::vector<u8>& input,
                         std::vector<opus_int16>& output, u64* out_performance_time) const {
-        const auto start_time = std::chrono::high_resolution_clock::now();
+        const auto start_time = std::chrono::steady_clock::now();
         const std::size_t raw_output_sz = output.size() * sizeof(opus_int16);
         if (sizeof(OpusPacketHeader) > input.size()) {
             LOG_ERROR(Audio, "Input is smaller than the header size, header_sz={}, input_sz={}",
@@ -135,7 +135,7 @@ private:
             return false;
         }
 
-        const auto end_time = std::chrono::high_resolution_clock::now() - start_time;
+        const auto end_time = std::chrono::steady_clock::now() - start_time;
         sample_count = out_sample_count;
         consumed = static_cast<u32>(sizeof(OpusPacketHeader) + hdr.size);
         if (out_performance_time != nullptr) {

src/core/hle/service/bcat/bcat_module.cpp

@@ -11,7 +11,6 @@
 #include "core/core.h"
 #include "core/file_sys/vfs.h"
 #include "core/hle/ipc_helpers.h"
-#include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/k_readable_event.h"
 #include "core/hle/service/bcat/backend/backend.h"
 #include "core/hle/service/bcat/bcat.h"
@@ -178,7 +177,7 @@ private:
     void RequestSyncDeliveryCache(Kernel::HLERequestContext& ctx) {
         LOG_DEBUG(Service_BCAT, "called");
 
-        backend.Synchronize({system.CurrentProcess()->GetTitleID(),
+        backend.Synchronize({system.GetCurrentProcessProgramID(),
                              GetCurrentBuildID(system.GetCurrentProcessBuildID())},
                             GetProgressBackend(SyncType::Normal));
 
@@ -195,7 +194,7 @@ private:
 
         LOG_DEBUG(Service_BCAT, "called, name={}", name);
 
-        backend.SynchronizeDirectory({system.CurrentProcess()->GetTitleID(),
+        backend.SynchronizeDirectory({system.GetCurrentProcessProgramID(),
                                       GetCurrentBuildID(system.GetCurrentProcessBuildID())},
                                      name, GetProgressBackend(SyncType::Directory));
 
@@ -556,7 +555,7 @@ private:
 void Module::Interface::CreateDeliveryCacheStorageService(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_BCAT, "called");
 
-    const auto title_id = system.CurrentProcess()->GetTitleID();
+    const auto title_id = system.GetCurrentProcessProgramID();
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(ResultSuccess);
     rb.PushIpcInterface<IDeliveryCacheStorageService>(system, fsc.GetBCATDirectory(title_id));

src/core/hle/service/caps/caps.h

@@ -24,7 +24,7 @@ enum class AlbumImageOrientation {
     Orientation3 = 3,
 };
 
-enum class AlbumReportOption {
+enum class AlbumReportOption : s32 {
     Disable = 0,
     Enable = 1,
 };

src/core/hle/service/fatal/fatal.cpp

@@ -11,7 +11,6 @@
 #include "common/swap.h"
 #include "core/core.h"
 #include "core/hle/ipc_helpers.h"
-#include "core/hle/kernel/k_process.h"
 #include "core/hle/service/fatal/fatal.h"
 #include "core/hle/service/fatal/fatal_p.h"
 #include "core/hle/service/fatal/fatal_u.h"
@@ -66,7 +65,7 @@ enum class FatalType : u32 {
 
 static void GenerateErrorReport(Core::System& system, ResultCode error_code,
                                 const FatalInfo& info) {
-    const auto title_id = system.CurrentProcess()->GetTitleID();
+    const auto title_id = system.GetCurrentProcessProgramID();
     std::string crash_report = fmt::format(
         "Yuzu {}-{} crash report\n"
         "Title ID:                        {:016x}\n"

src/core/hle/service/filesystem/filesystem.cpp

@@ -20,7 +20,6 @@
 #include "core/file_sys/sdmc_factory.h"
 #include "core/file_sys/vfs.h"
 #include "core/file_sys/vfs_offset.h"
-#include "core/hle/kernel/k_process.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/filesystem/fsp_ldr.h"
 #include "core/hle/service/filesystem/fsp_pr.h"
@@ -320,7 +319,7 @@ ResultVal<FileSys::VirtualFile> FileSystemController::OpenRomFSCurrentProcess()
         return ResultUnknown;
     }
 
-    return romfs_factory->OpenCurrentProcess(system.CurrentProcess()->GetTitleID());
+    return romfs_factory->OpenCurrentProcess(system.GetCurrentProcessProgramID());
 }
 
 ResultVal<FileSys::VirtualFile> FileSystemController::OpenPatchedRomFS(
@@ -505,7 +504,7 @@ FileSys::SaveDataSize FileSystemController::ReadSaveDataSize(FileSys::SaveDataTy
         const auto res = system.GetAppLoader().ReadControlData(nacp);
 
         if (res != Loader::ResultStatus::Success) {
-            const FileSys::PatchManager pm{system.CurrentProcess()->GetTitleID(),
+            const FileSys::PatchManager pm{system.GetCurrentProcessProgramID(),
                                            system.GetFileSystemController(),
                                            system.GetContentProvider()};
             const auto metadata = pm.GetControlMetadata();

src/core/hle/service/filesystem/fsp_srv.cpp

@@ -26,7 +26,6 @@
 #include "core/file_sys/system_archive/system_archive.h"
 #include "core/file_sys/vfs.h"
 #include "core/hle/ipc_helpers.h"
-#include "core/hle/kernel/k_process.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/filesystem/fsp_srv.h"
 #include "core/reporter.h"
@@ -1035,7 +1034,7 @@ void FSP_SRV::OpenDataStorageWithProgramIndex(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_FS, "called, program_index={}", program_index);
 
     auto patched_romfs = fsc.OpenPatchedRomFSWithProgramIndex(
-        system.CurrentProcess()->GetTitleID(), program_index, FileSys::ContentRecordType::Program);
+        system.GetCurrentProcessProgramID(), program_index, FileSys::ContentRecordType::Program);
 
     if (patched_romfs.Failed()) {
         // TODO: Find the right error code to use here

src/core/hle/service/friend/friend.cpp

@@ -17,10 +17,11 @@ namespace Service::Friend {
 
 class IFriendService final : public ServiceFramework<IFriendService> {
 public:
-    explicit IFriendService(Core::System& system_) : ServiceFramework{system_, "IFriendService"} {
+    explicit IFriendService(Core::System& system_)
+        : ServiceFramework{system_, "IFriendService"}, service_context{system, "IFriendService"} {
         // clang-format off
         static const FunctionInfo functions[] = {
-            {0, nullptr, "GetCompletionEvent"},
+            {0, &IFriendService::GetCompletionEvent, "GetCompletionEvent"},
             {1, nullptr, "Cancel"},
             {10100, nullptr, "GetFriendListIds"},
             {10101, &IFriendService::GetFriendList, "GetFriendList"},
@@ -109,6 +110,12 @@ public:
         // clang-format on
 
         RegisterHandlers(functions);
+
+        completion_event = service_context.CreateEvent("IFriendService:CompletionEvent");
+    }
+
+    ~IFriendService() override {
+        service_context.CloseEvent(completion_event);
     }
 
 private:
@@ -129,6 +136,14 @@ private:
     };
     static_assert(sizeof(SizedFriendFilter) == 0x10, "SizedFriendFilter is an invalid size");
 
+    void GetCompletionEvent(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_Friend, "called");
+
+        IPC::ResponseBuilder rb{ctx, 2, 1};
+        rb.Push(ResultSuccess);
+        rb.PushCopyObjects(completion_event->GetReadableEvent());
+    }
+
     void GetBlockedUserListIds(Kernel::HLERequestContext& ctx) {
         // This is safe to stub, as there should be no adverse consequences from reporting no
         // blocked users.
@@ -179,6 +194,10 @@ private:
         rb.Push<u32>(0); // Friend count
         // TODO(ogniK): Return a buffer of u64s which are the "NetworkServiceAccountId"
     }
+
+    KernelHelpers::ServiceContext service_context;
+
+    Kernel::KEvent* completion_event;
 };
 
 class INotificationService final : public ServiceFramework<INotificationService> {

src/core/hle/service/glue/arp.cpp

@@ -26,7 +26,7 @@ std::optional<u64> GetTitleIDForProcessID(const Core::System& system, u64 proces
         return std::nullopt;
     }
 
-    return (*iter)->GetTitleID();
+    return (*iter)->GetProgramID();
 }
 } // Anonymous namespace
 

src/core/hle/service/hid/controllers/console_sixaxis.cpp

@@ -4,13 +4,18 @@
 
 #include "common/settings.h"
 #include "core/core_timing.h"
+#include "core/hid/emulated_console.h"
+#include "core/hid/hid_core.h"
 #include "core/hle/service/hid/controllers/console_sixaxis.h"
 
 namespace Service::HID {
 constexpr std::size_t SHARED_MEMORY_OFFSET = 0x3C200;
 
-Controller_ConsoleSixAxis::Controller_ConsoleSixAxis(Core::System& system_)
-    : ControllerBase{system_} {}
+Controller_ConsoleSixAxis::Controller_ConsoleSixAxis(Core::HID::HIDCore& hid_core_)
+    : ControllerBase{hid_core_} {
+    console = hid_core.GetEmulatedConsole();
+}
+
 Controller_ConsoleSixAxis::~Controller_ConsoleSixAxis() = default;
 
 void Controller_ConsoleSixAxis::OnInit() {}
@@ -19,44 +24,31 @@ void Controller_ConsoleSixAxis::OnRelease() {}
 
 void Controller_ConsoleSixAxis::OnUpdate(const Core::Timing::CoreTiming& core_timing, u8* data,
                                          std::size_t size) {
-    seven_six_axis.header.timestamp = core_timing.GetCPUTicks();
-    seven_six_axis.header.total_entry_count = 17;
-
     if (!IsControllerActivated() || !is_transfer_memory_set) {
-        seven_six_axis.header.entry_count = 0;
-        seven_six_axis.header.last_entry_index = 0;
+        seven_sixaxis_lifo.buffer_count = 0;
+        seven_sixaxis_lifo.buffer_tail = 0;
         return;
     }
-    seven_six_axis.header.entry_count = 16;
 
-    const auto& last_entry =
-        seven_six_axis.sevensixaxis_states[seven_six_axis.header.last_entry_index];
-    seven_six_axis.header.last_entry_index = (seven_six_axis.header.last_entry_index + 1) % 17;
-    auto& cur_entry = seven_six_axis.sevensixaxis_states[seven_six_axis.header.last_entry_index];
-
-    cur_entry.sampling_number = last_entry.sampling_number + 1;
-    cur_entry.sampling_number2 = cur_entry.sampling_number;
+    const auto& last_entry = seven_sixaxis_lifo.ReadCurrentEntry().state;
+    next_seven_sixaxis_state.sampling_number = last_entry.sampling_number + 1;
 
     // Try to read sixaxis sensor states
-    MotionDevice motion_device{};
-    const auto& device = motions[0];
-    if (device) {
-        std::tie(motion_device.accel, motion_device.gyro, motion_device.rotation,
-                 motion_device.orientation, motion_device.quaternion) = device->GetStatus();
-        console_six_axis.is_seven_six_axis_sensor_at_rest = motion_device.gyro.Length2() < 0.0001f;
-    }
+    const auto motion_status = console->GetMotion();
 
-    cur_entry.accel = motion_device.accel;
+    console_six_axis.is_seven_six_axis_sensor_at_rest = motion_status.is_at_rest;
+
+    next_seven_sixaxis_state.accel = motion_status.accel;
     // Zero gyro values as they just mess up with the camera
     // Note: Probably a correct sensivity setting must be set
-    cur_entry.gyro = {};
-    cur_entry.quaternion = {
+    next_seven_sixaxis_state.gyro = {};
+    next_seven_sixaxis_state.quaternion = {
         {
-            motion_device.quaternion.xyz.y,
-            motion_device.quaternion.xyz.x,
-            -motion_device.quaternion.w,
+            motion_status.quaternion.xyz.y,
+            motion_status.quaternion.xyz.x,
+            -motion_status.quaternion.w,
         },
-        -motion_device.quaternion.xyz.z,
+        -motion_status.quaternion.xyz.z,
     };
 
     console_six_axis.sampling_number++;
@@ -67,14 +59,8 @@ void Controller_ConsoleSixAxis::OnUpdate(const Core::Timing::CoreTiming& core_ti
     // Update console six axis shared memory
     std::memcpy(data + SHARED_MEMORY_OFFSET, &console_six_axis, sizeof(console_six_axis));
     // Update seven six axis transfer memory
-    std::memcpy(transfer_memory, &seven_six_axis, sizeof(seven_six_axis));
-}
-
-void Controller_ConsoleSixAxis::OnLoadInputDevices() {
-    const auto player = Settings::values.players.GetValue()[0];
-    std::transform(player.motions.begin() + Settings::NativeMotion::MOTION_HID_BEGIN,
-                   player.motions.begin() + Settings::NativeMotion::MOTION_HID_END, motions.begin(),
-                   Input::CreateDevice<Input::MotionDevice>);
+    seven_sixaxis_lifo.WriteNextEntry(next_seven_sixaxis_state);
+    std::memcpy(transfer_memory, &seven_sixaxis_lifo, sizeof(seven_sixaxis_lifo));
 }
 
 void Controller_ConsoleSixAxis::SetTransferMemoryPointer(u8* t_mem) {
@@ -83,8 +69,7 @@ void Controller_ConsoleSixAxis::SetTransferMemoryPointer(u8* t_mem) {
 }
 
 void Controller_ConsoleSixAxis::ResetTimestamp() {
-    auto& cur_entry = seven_six_axis.sevensixaxis_states[seven_six_axis.header.last_entry_index];
-    cur_entry.sampling_number = 0;
-    cur_entry.sampling_number2 = 0;
+    seven_sixaxis_lifo.buffer_count = 0;
+    seven_sixaxis_lifo.buffer_tail = 0;
 }
 } // namespace Service::HID

src/core/hle/service/hid/controllers/console_sixaxis.h

@@ -5,16 +5,21 @@
 #pragma once
 
 #include <array>
-#include "common/bit_field.h"
+
 #include "common/common_types.h"
 #include "common/quaternion.h"
-#include "core/frontend/input.h"
+#include "core/hid/hid_types.h"
 #include "core/hle/service/hid/controllers/controller_base.h"
+#include "core/hle/service/hid/ring_lifo.h"
+
+namespace Core::HID {
+class EmulatedConsole;
+} // namespace Core::HID
 
 namespace Service::HID {
 class Controller_ConsoleSixAxis final : public ControllerBase {
 public:
-    explicit Controller_ConsoleSixAxis(Core::System& system_);
+    explicit Controller_ConsoleSixAxis(Core::HID::HIDCore& hid_core_);
     ~Controller_ConsoleSixAxis() override;
 
     // Called when the controller is initialized
@@ -26,9 +31,6 @@ public:
     // When the controller is requesting an update for the shared memory
     void OnUpdate(const Core::Timing::CoreTiming& core_timing, u8* data, size_t size) override;
 
-    // Called when input devices should be loaded
-    void OnLoadInputDevices() override;
-
     // Called on InitializeSevenSixAxisSensor
     void SetTransferMemoryPointer(u8* t_mem);
 
@@ -38,43 +40,31 @@ public:
 private:
     struct SevenSixAxisState {
         INSERT_PADDING_WORDS(4); // unused
-        s64_le sampling_number{};
-        s64_le sampling_number2{};
+        s64 sampling_number{};
         u64 unknown{};
         Common::Vec3f accel{};
         Common::Vec3f gyro{};
         Common::Quaternion<f32> quaternion{};
     };
-    static_assert(sizeof(SevenSixAxisState) == 0x50, "SevenSixAxisState is an invalid size");
-
-    struct SevenSixAxisMemory {
-        CommonHeader header{};
-        std::array<SevenSixAxisState, 0x21> sevensixaxis_states{};
-    };
-    static_assert(sizeof(SevenSixAxisMemory) == 0xA70, "SevenSixAxisMemory is an invalid size");
+    static_assert(sizeof(SevenSixAxisState) == 0x48, "SevenSixAxisState is an invalid size");
 
+    // This is nn::hid::detail::ConsoleSixAxisSensorSharedMemoryFormat
     struct ConsoleSharedMemory {
-        u64_le sampling_number{};
+        u64 sampling_number{};
         bool is_seven_six_axis_sensor_at_rest{};
+        INSERT_PADDING_BYTES(4); // padding
         f32 verticalization_error{};
         Common::Vec3f gyro_bias{};
     };
     static_assert(sizeof(ConsoleSharedMemory) == 0x20, "ConsoleSharedMemory is an invalid size");
 
-    struct MotionDevice {
-        Common::Vec3f accel;
-        Common::Vec3f gyro;
-        Common::Vec3f rotation;
-        std::array<Common::Vec3f, 3> orientation;
-        Common::Quaternion<f32> quaternion;
-    };
+    Lifo<SevenSixAxisState, 0x21> seven_sixaxis_lifo{};
+    static_assert(sizeof(seven_sixaxis_lifo) == 0xA70, "SevenSixAxisState is an invalid size");
 
-    using MotionArray =
-        std::array<std::unique_ptr<Input::MotionDevice>, Settings::NativeMotion::NUM_MOTIONS_HID>;
-    MotionArray motions;
+    Core::HID::EmulatedConsole* console;
     u8* transfer_memory = nullptr;
     bool is_transfer_memory_set = false;
     ConsoleSharedMemory console_six_axis{};
-    SevenSixAxisMemory seven_six_axis{};
+    SevenSixAxisState next_seven_sixaxis_state{};
 };
 } // namespace Service::HID

src/core/hle/service/hid/controllers/controller_base.cpp

@@ -6,12 +6,12 @@
 
 namespace Service::HID {
 
-ControllerBase::ControllerBase(Core::System& system_) : system(system_) {}
+ControllerBase::ControllerBase(Core::HID::HIDCore& hid_core_) : hid_core(hid_core_) {}
 ControllerBase::~ControllerBase() = default;
 
 void ControllerBase::ActivateController() {
     if (is_activated) {
-        OnRelease();
+        return;
     }
     is_activated = true;
     OnInit();