dist/XDG: add more file associations

Update video core popup

.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()
@@ -131,7 +131,7 @@ add_definitions(-DBOOST_ASIO_DISABLE_CONCEPTS)
 if (MSVC)
     add_compile_options($<$<COMPILE_LANGUAGE:CXX>:/std:c++latest>)
 
-    # cubeb and boost still make use of deprecated result_of.
+    # boost still makes use of deprecated result_of.
     add_definitions(-D_HAS_DEPRECATED_RESULT_OF)
 else()
     set(CMAKE_CXX_STANDARD 20)
@@ -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"
@@ -370,7 +370,7 @@ if (ENABLE_SDL2)
     if (YUZU_USE_BUNDLED_SDL2)
         # Detect toolchain and platform
         if ((MSVC_VERSION GREATER_EQUAL 1920 AND MSVC_VERSION LESS 1940) AND ARCHITECTURE_x86_64)
-            set(SDL2_VER "SDL2-2.0.16")
+            set(SDL2_VER "SDL2-2.0.18")
         else()
             message(FATAL_ERROR "No bundled SDL2 binaries for your toolchain. Disable YUZU_USE_BUNDLED_SDL2 and provide your own.")
         endif()
@@ -390,7 +390,7 @@ if (ENABLE_SDL2)
     elseif (YUZU_USE_EXTERNAL_SDL2)
         message(STATUS "Using SDL2 from externals.")
     else()
-        find_package(SDL2 2.0.16 REQUIRED)
+        find_package(SDL2 2.0.18 REQUIRED)
 
         # Some installations don't set SDL2_LIBRARIES
         if("${SDL2_LIBRARIES}" STREQUAL "")
@@ -411,12 +411,13 @@ if (CONAN_REQUIRED_LIBS)
     # Download conan.cmake automatically, you can also just copy the conan.cmake file
     if(NOT EXISTS "${CMAKE_BINARY_DIR}/conan.cmake")
         message(STATUS "Downloading conan.cmake from https://github.com/conan-io/cmake-conan")
-        file(DOWNLOAD "https://github.com/conan-io/cmake-conan/raw/v0.15/conan.cmake"
+        # TODO: Use a tagged release. The latest tagged release does not support VS2022 as of this writing.
+        file(DOWNLOAD "https://raw.githubusercontent.com/conan-io/cmake-conan/43e385830ee35377dbd2dcbe8d5a9e750301ea00/conan.cmake"
                         "${CMAKE_BINARY_DIR}/conan.cmake")
     endif()
     include(${CMAKE_BINARY_DIR}/conan.cmake)
 
-    conan_check(VERSION 1.24.0 REQUIRED)
+    conan_check(VERSION 1.41.0 REQUIRED)
 
     # Manually add iconv to fix a dep conflict between qt and sdl2
     # We don't need to add it through find_package or anything since the other two can find it just fine
@@ -599,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
@@ -619,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}
             )
@@ -669,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}"

README.md

@@ -17,7 +17,7 @@ It is written in C++ with portability in mind, and we actively maintain builds f
             alt="Azure Mainline CI Build Status">
     </a>
     <a href="https://discord.com/invite/u77vRWY">
-        <img src="https://img.shields.io/discord/398318088170242053?color=%237289DA&label=yuzu&logo=discord&logoColor=white"
+        <img src="https://img.shields.io/discord/398318088170242053?color=5865F2&label=yuzu&logo=discord&logoColor=white"
             alt="Discord">
     </a>
 </p>

dist/yuzu.desktop

@@ -8,5 +8,5 @@ Icon=yuzu
 TryExec=yuzu
 Exec=yuzu %f
 Categories=Game;Emulator;Qt;
-MimeType=application/x-nx-nro;application/x-nx-nso;
+MimeType=application/x-nx-nro;application/x-nx-nso;application/x-nx-nsp;application/x-nx-xci;
 Keywords=Switch;Nintendo;

dist/yuzu.xml

@@ -15,4 +15,19 @@
         <glob pattern="*.nso"/>
         <magic><match value="NSO" type="string" offset="0"/></magic>
     </mime-type>
+
+    <mime-type type="application/x-nx-nsp">
+        <comment>Nintendo Switch Package</comment>
+        <acronym>NSP</acronym>
+        <icon name="yuzu"/>
+        <glob pattern="*.nsp"/>
+        <magic><match value="PFS" type="string" offset="0"/></magic>
+    </mime-type>
+
+    <mime-type type="application/x-nx-xci">
+        <comment>Nintendo Switch Card Image</comment>
+        <acronym>XCI</acronym>
+        <icon name="yuzu"/>
+        <glob pattern="*.xci"/>
+    </mime-type>
 </mime-info>

externals/CMakeLists.txt

@@ -44,10 +44,6 @@ target_include_directories(mbedtls PUBLIC ./mbedtls/include)
 add_library(microprofile INTERFACE)
 target_include_directories(microprofile INTERFACE ./microprofile)
 
-# Unicorn
-add_library(unicorn-headers INTERFACE)
-target_include_directories(unicorn-headers INTERFACE ./unicorn/include)
-
 # libusb
 if (NOT LIBUSB_FOUND OR YUZU_USE_BUNDLED_LIBUSB)
     add_subdirectory(libusb)

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.

externals/find-modules/FindUnicorn.cmake

@@ -1,18 +0,0 @@
-# Exports:
-#  LIBUNICORN_FOUND
-#  LIBUNICORN_INCLUDE_DIR
-#  LIBUNICORN_LIBRARY
-
-find_path(LIBUNICORN_INCLUDE_DIR
-          unicorn/unicorn.h
-          HINTS $ENV{UNICORNDIR}
-          PATH_SUFFIXES include)
-
-find_library(LIBUNICORN_LIBRARY
-             NAMES unicorn
-             HINTS $ENV{UNICORNDIR})
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(unicorn DEFAULT_MSG
-                                  LIBUNICORN_LIBRARY LIBUNICORN_INCLUDE_DIR)
-mark_as_advanced(LIBUNICORN_INCLUDE_DIR LIBUNICORN_LIBRARY)

src/CMakeLists.txt

@@ -24,6 +24,7 @@ if (MSVC)
     # /W3                 - Level 3 warnings
     # /MP                 - Multi-threaded compilation
     # /Zi                 - Output debugging information
+    # /Zm                 - Specifies the precompiled header memory allocation limit
     # /Zo                 - Enhanced debug info for optimized builds
     # /permissive-        - Enables stricter C++ standards conformance checks
     # /EHsc               - C++-only exception handling semantics
@@ -32,9 +33,11 @@ if (MSVC)
     # /Zc:externConstexpr - Allow extern constexpr variables to have external linkage, like the standard mandates
     # /Zc:inline          - Let codegen omit inline functions in object files
     # /Zc:throwingNew     - Let codegen assume `operator new` (without std::nothrow) will never return null
+    # /GT                 - Supports fiber safety for data allocated using static thread-local storage
     add_compile_options(
         /MP
         /Zi
+        /Zm200
         /Zo
         /permissive-
         /EHsc
@@ -44,6 +47,7 @@ if (MSVC)
         /Zc:externConstexpr
         /Zc:inline
         /Zc:throwingNew
+        /GT
 
         # External headers diagnostics
         /experimental:external  # Enables the external headers options. This option isn't required in Visual Studio 2019 version 16.10 and later
@@ -69,6 +73,10 @@ if (MSVC)
         /we5038 # data member 'member1' will be initialized after data member 'member2'
     )
 
+    if (ARCHITECTURE_x86_64)
+        add_compile_options(/QIntel-jcc-erratum)
+    endif()
+
     # /GS- - No stack buffer overflow checks
     add_compile_options("$<$<CONFIG:Release>:/GS->")
 

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

@@ -55,6 +55,7 @@ add_library(common STATIC
     dynamic_library.h
     error.cpp
     error.h
+    expected.h
     fiber.cpp
     fiber.h
     fs/file.cpp
@@ -72,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/alignment.h

@@ -64,7 +64,7 @@ public:
     using propagate_on_container_copy_assignment = std::true_type;
     using propagate_on_container_move_assignment = std::true_type;
     using propagate_on_container_swap = std::true_type;
-    using is_always_equal = std::true_type;
+    using is_always_equal = std::false_type;
 
     constexpr AlignmentAllocator() noexcept = default;
 
@@ -83,6 +83,11 @@ public:
     struct rebind {
         using other = AlignmentAllocator<T2, Align>;
     };
+
+    template <typename T2, size_t Align2>
+    constexpr bool operator==(const AlignmentAllocator<T2, Align2>&) const noexcept {
+        return std::is_same_v<T, T2> && Align == Align2;
+    }
 };
 
 } // namespace Common

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/expected.h

@@ -0,0 +1,987 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+// This is based on the proposed implementation of std::expected (P0323)
+// https://github.com/TartanLlama/expected/blob/master/include/tl/expected.hpp
+
+#pragma once
+
+#include <type_traits>
+#include <utility>
+
+namespace Common {
+
+template <typename T, typename E>
+class Expected;
+
+template <typename E>
+class Unexpected {
+public:
+    Unexpected() = delete;
+
+    constexpr explicit Unexpected(const E& e) : m_val{e} {}
+
+    constexpr explicit Unexpected(E&& e) : m_val{std::move(e)} {}
+
+    constexpr E& value() & {
+        return m_val;
+    }
+
+    constexpr const E& value() const& {
+        return m_val;
+    }
+
+    constexpr E&& value() && {
+        return std::move(m_val);
+    }
+
+    constexpr const E&& value() const&& {
+        return std::move(m_val);
+    }
+
+private:
+    E m_val;
+};
+
+template <typename E>
+constexpr auto operator<=>(const Unexpected<E>& lhs, const Unexpected<E>& rhs) {
+    return lhs.value() <=> rhs.value();
+}
+
+struct unexpect_t {
+    constexpr explicit unexpect_t() = default;
+};
+
+namespace detail {
+
+struct no_init_t {
+    constexpr explicit no_init_t() = default;
+};
+
+/**
+ * This specialization is for when T is not trivially destructible,
+ * so the destructor must be called on destruction of `expected'
+ * Additionally, this requires E to be trivially destructible
+ */
+template <typename T, typename E, bool = std::is_trivially_destructible_v<T>>
+requires std::is_trivially_destructible_v<E>
+struct expected_storage_base {
+    constexpr expected_storage_base() : m_val{T{}}, m_has_val{true} {}
+
+    constexpr expected_storage_base(no_init_t) : m_has_val{false} {}
+
+    template <typename... Args, std::enable_if_t<std::is_constructible_v<T, Args&&...>>* = nullptr>
+    constexpr expected_storage_base(std::in_place_t, Args&&... args)
+        : m_val{std::forward<Args>(args)...}, m_has_val{true} {}
+
+    template <typename U, typename... Args,
+              std::enable_if_t<std::is_constructible_v<T, std::initializer_list<U>&, Args&&...>>* =
+                  nullptr>
+    constexpr expected_storage_base(std::in_place_t, std::initializer_list<U> il, Args&&... args)
+        : m_val{il, std::forward<Args>(args)...}, m_has_val{true} {}
+
+    template <typename... Args, std::enable_if_t<std::is_constructible_v<E, Args&&...>>* = nullptr>
+    constexpr explicit expected_storage_base(unexpect_t, Args&&... args)
+        : m_unexpect{std::forward<Args>(args)...}, m_has_val{false} {}
+
+    template <typename U, typename... Args,
+              std::enable_if_t<std::is_constructible_v<E, std::initializer_list<U>&, Args&&...>>* =
+                  nullptr>
+    constexpr explicit expected_storage_base(unexpect_t, std::initializer_list<U> il,
+                                             Args&&... args)
+        : m_unexpect{il, std::forward<Args>(args)...}, m_has_val{false} {}
+
+    ~expected_storage_base() {
+        if (m_has_val) {
+            m_val.~T();
+        }
+    }
+
+    union {
+        T m_val;
+        Unexpected<E> m_unexpect;
+    };
+
+    bool m_has_val;
+};
+
+/**
+ * This specialization is for when T is trivially destructible,
+ * so the destructor of `expected` can be trivial
+ * Additionally, this requires E to be trivially destructible
+ */
+template <typename T, typename E>
+requires std::is_trivially_destructible_v<E>
+struct expected_storage_base<T, E, true> {
+    constexpr expected_storage_base() : m_val{T{}}, m_has_val{true} {}
+
+    constexpr expected_storage_base(no_init_t) : m_has_val{false} {}
+
+    template <typename... Args, std::enable_if_t<std::is_constructible_v<T, Args&&...>>* = nullptr>
+    constexpr expected_storage_base(std::in_place_t, Args&&... args)
+        : m_val{std::forward<Args>(args)...}, m_has_val{true} {}
+
+    template <typename U, typename... Args,
+              std::enable_if_t<std::is_constructible_v<T, std::initializer_list<U>&, Args&&...>>* =
+                  nullptr>
+    constexpr expected_storage_base(std::in_place_t, std::initializer_list<U> il, Args&&... args)
+        : m_val{il, std::forward<Args>(args)...}, m_has_val{true} {}
+
+    template <typename... Args, std::enable_if_t<std::is_constructible_v<E, Args&&...>>* = nullptr>
+    constexpr explicit expected_storage_base(unexpect_t, Args&&... args)
+        : m_unexpect{std::forward<Args>(args)...}, m_has_val{false} {}
+
+    template <typename U, typename... Args,
+              std::enable_if_t<std::is_constructible_v<E, std::initializer_list<U>&, Args&&...>>* =
+                  nullptr>
+    constexpr explicit expected_storage_base(unexpect_t, std::initializer_list<U> il,
+                                             Args&&... args)
+        : m_unexpect{il, std::forward<Args>(args)...}, m_has_val{false} {}
+
+    ~expected_storage_base() = default;
+
+    union {
+        T m_val;
+        Unexpected<E> m_unexpect;
+    };
+
+    bool m_has_val;
+};
+
+template <typename T, typename E>
+struct expected_operations_base : expected_storage_base<T, E> {
+    using expected_storage_base<T, E>::expected_storage_base;
+
+    template <typename... Args>
+    void construct(Args&&... args) noexcept {
+        new (std::addressof(this->m_val)) T{std::forward<Args>(args)...};
+        this->m_has_val = true;
+    }
+
+    template <typename Rhs>
+    void construct_with(Rhs&& rhs) noexcept {
+        new (std::addressof(this->m_val)) T{std::forward<Rhs>(rhs).get()};
+        this->m_has_val = true;
+    }
+
+    template <typename... Args>
+    void construct_error(Args&&... args) noexcept {
+        new (std::addressof(this->m_unexpect)) Unexpected<E>{std::forward<Args>(args)...};
+        this->m_has_val = false;
+    }
+
+    void assign(const expected_operations_base& rhs) noexcept {
+        if (!this->m_has_val && rhs.m_has_val) {
+            geterr().~Unexpected<E>();
+            construct(rhs.get());
+        } else {
+            assign_common(rhs);
+        }
+    }
+
+    void assign(expected_operations_base&& rhs) noexcept {
+        if (!this->m_has_val && rhs.m_has_val) {
+            geterr().~Unexpected<E>();
+            construct(std::move(rhs).get());
+        } else {
+            assign_common(rhs);
+        }
+    }
+
+    template <typename Rhs>
+    void assign_common(Rhs&& rhs) {
+        if (this->m_has_val) {
+            if (rhs.m_has_val) {
+                get() = std::forward<Rhs>(rhs).get();
+            } else {
+                destroy_val();
+                construct_error(std::forward<Rhs>(rhs).geterr());
+            }
+        } else {
+            if (!rhs.m_has_val) {
+                geterr() = std::forward<Rhs>(rhs).geterr();
+            }
+        }
+    }
+
+    bool has_value() const {
+        return this->m_has_val;
+    }
+
+    constexpr T& get() & {
+        return this->m_val;
+    }
+
+    constexpr const T& get() const& {
+        return this->m_val;
+    }
+
+    constexpr T&& get() && {
+        return std::move(this->m_val);
+    }
+
+    constexpr const T&& get() const&& {
+        return std::move(this->m_val);
+    }
+
+    constexpr Unexpected<E>& geterr() & {
+        return this->m_unexpect;
+    }
+
+    constexpr const Unexpected<E>& geterr() const& {
+        return this->m_unexpect;
+    }
+
+    constexpr Unexpected<E>&& geterr() && {
+        return std::move(this->m_unexpect);
+    }
+
+    constexpr const Unexpected<E>&& geterr() const&& {
+        return std::move(this->m_unexpect);
+    }
+
+    constexpr void destroy_val() {
+        get().~T();
+    }
+};
+
+/**
+ * This manages conditionally having a trivial copy constructor
+ * This specialization is for when T is trivially copy constructible
+ * Additionally, this requires E to be trivially copy constructible
+ */
+template <typename T, typename E, bool = std::is_trivially_copy_constructible_v<T>>
+requires std::is_trivially_copy_constructible_v<E>
+struct expected_copy_base : expected_operations_base<T, E> {
+    using expected_operations_base<T, E>::expected_operations_base;
+};
+
+/**
+ * This specialization is for when T is not trivially copy constructible
+ * Additionally, this requires E to be trivially copy constructible
+ */
+template <typename T, typename E>
+requires std::is_trivially_copy_constructible_v<E>
+struct expected_copy_base<T, E, false> : expected_operations_base<T, E> {
+    using expected_operations_base<T, E>::expected_operations_base;
+
+    expected_copy_base() = default;
+
+    expected_copy_base(const expected_copy_base& rhs)
+        : expected_operations_base<T, E>{no_init_t{}} {
+        if (rhs.has_value()) {
+            this->construct_with(rhs);
+        } else {
+            this->construct_error(rhs.geterr());
+        }
+    }
+
+    expected_copy_base(expected_copy_base&&) = default;
+
+    expected_copy_base& operator=(const expected_copy_base&) = default;
+
+    expected_copy_base& operator=(expected_copy_base&&) = default;
+};
+
+/**
+ * This manages conditionally having a trivial move constructor
+ * This specialization is for when T is trivially move constructible
+ * Additionally, this requires E to be trivially move constructible
+ */
+template <typename T, typename E, bool = std::is_trivially_move_constructible_v<T>>
+requires std::is_trivially_move_constructible_v<E>
+struct expected_move_base : expected_copy_base<T, E> {
+    using expected_copy_base<T, E>::expected_copy_base;
+};
+
+/**
+ * This specialization is for when T is not trivially move constructible
+ * Additionally, this requires E to be trivially move constructible
+ */
+template <typename T, typename E>
+requires std::is_trivially_move_constructible_v<E>
+struct expected_move_base<T, E, false> : expected_copy_base<T, E> {
+    using expected_copy_base<T, E>::expected_copy_base;
+
+    expected_move_base() = default;
+
+    expected_move_base(const expected_move_base&) = default;
+
+    expected_move_base(expected_move_base&& rhs) noexcept(std::is_nothrow_move_constructible_v<T>)
+        : expected_copy_base<T, E>{no_init_t{}} {
+        if (rhs.has_value()) {
+            this->construct_with(std::move(rhs));
+        } else {
+            this->construct_error(std::move(rhs.geterr()));
+        }
+    }
+
+    expected_move_base& operator=(const expected_move_base&) = default;
+
+    expected_move_base& operator=(expected_move_base&&) = default;
+};
+
+/**
+ * This manages conditionally having a trivial copy assignment operator
+ * This specialization is for when T is trivially copy assignable
+ * Additionally, this requires E to be trivially copy assignable
+ */
+template <typename T, typename E,
+          bool = std::conjunction_v<std::is_trivially_copy_assignable<T>,
+                                    std::is_trivially_copy_constructible<T>,
+                                    std::is_trivially_destructible<T>>>
+requires std::conjunction_v<std::is_trivially_copy_assignable<E>,
+                            std::is_trivially_copy_constructible<E>,
+                            std::is_trivially_destructible<E>>
+struct expected_copy_assign_base : expected_move_base<T, E> {
+    using expected_move_base<T, E>::expected_move_base;
+};
+
+/**
+ * This specialization is for when T is not trivially copy assignable
+ * Additionally, this requires E to be trivially copy assignable
+ */
+template <typename T, typename E>
+requires std::conjunction_v<std::is_trivially_copy_assignable<E>,
+                            std::is_trivially_copy_constructible<E>,
+                            std::is_trivially_destructible<E>>
+struct expected_copy_assign_base<T, E, false> : expected_move_base<T, E> {
+    using expected_move_base<T, E>::expected_move_base;
+
+    expected_copy_assign_base() = default;
+
+    expected_copy_assign_base(const expected_copy_assign_base&) = default;
+
+    expected_copy_assign_base(expected_copy_assign_base&&) = default;
+
+    expected_copy_assign_base& operator=(const expected_copy_assign_base& rhs) {
+        this->assign(rhs);
+        return *this;
+    }
+
+    expected_copy_assign_base& operator=(expected_copy_assign_base&&) = default;
+};
+
+/**
+ * This manages conditionally having a trivial move assignment operator
+ * This specialization is for when T is trivially move assignable
+ * Additionally, this requires E to be trivially move assignable
+ */
+template <typename T, typename E,
+          bool = std::conjunction_v<std::is_trivially_move_assignable<T>,
+                                    std::is_trivially_move_constructible<T>,
+                                    std::is_trivially_destructible<T>>>
+requires std::conjunction_v<std::is_trivially_move_assignable<E>,
+                            std::is_trivially_move_constructible<E>,
+                            std::is_trivially_destructible<E>>
+struct expected_move_assign_base : expected_copy_assign_base<T, E> {
+    using expected_copy_assign_base<T, E>::expected_copy_assign_base;
+};
+
+/**
+ * This specialization is for when T is not trivially move assignable
+ * Additionally, this requires E to be trivially move assignable
+ */
+template <typename T, typename E>
+requires std::conjunction_v<std::is_trivially_move_assignable<E>,
+                            std::is_trivially_move_constructible<E>,
+                            std::is_trivially_destructible<E>>
+struct expected_move_assign_base<T, E, false> : expected_copy_assign_base<T, E> {
+    using expected_copy_assign_base<T, E>::expected_copy_assign_base;
+
+    expected_move_assign_base() = default;
+
+    expected_move_assign_base(const expected_move_assign_base&) = default;
+
+    expected_move_assign_base(expected_move_assign_base&&) = default;
+
+    expected_move_assign_base& operator=(const expected_move_assign_base&) = default;
+
+    expected_move_assign_base& operator=(expected_move_assign_base&& rhs) noexcept(
+        std::conjunction_v<std::is_nothrow_move_constructible<T>,
+                           std::is_nothrow_move_assignable<T>>) {
+        this->assign(std::move(rhs));
+        return *this;
+    }
+};
+
+/**
+ * expected_delete_ctor_base will conditionally delete copy and move constructors
+ * depending on whether T is copy/move constructible
+ * Additionally, this requires E to be copy/move constructible
+ */
+template <typename T, typename E, bool EnableCopy = std::is_copy_constructible_v<T>,
+          bool EnableMove = std::is_move_constructible_v<T>>
+requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>>
+struct expected_delete_ctor_base {
+    expected_delete_ctor_base() = default;
+    expected_delete_ctor_base(const expected_delete_ctor_base&) = default;
+    expected_delete_ctor_base(expected_delete_ctor_base&&) noexcept = default;
+    expected_delete_ctor_base& operator=(const expected_delete_ctor_base&) = default;
+    expected_delete_ctor_base& operator=(expected_delete_ctor_base&&) noexcept = default;
+};
+
+template <typename T, typename E>
+requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>>
+struct expected_delete_ctor_base<T, E, true, false> {
+    expected_delete_ctor_base() = default;
+    expected_delete_ctor_base(const expected_delete_ctor_base&) = default;
+    expected_delete_ctor_base(expected_delete_ctor_base&&) noexcept = delete;
+    expected_delete_ctor_base& operator=(const expected_delete_ctor_base&) = default;
+    expected_delete_ctor_base& operator=(expected_delete_ctor_base&&) noexcept = default;
+};
+
+template <typename T, typename E>
+requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>>
+struct expected_delete_ctor_base<T, E, false, true> {
+    expected_delete_ctor_base() = default;
+    expected_delete_ctor_base(const expected_delete_ctor_base&) = delete;
+    expected_delete_ctor_base(expected_delete_ctor_base&&) noexcept = default;
+    expected_delete_ctor_base& operator=(const expected_delete_ctor_base&) = default;
+    expected_delete_ctor_base& operator=(expected_delete_ctor_base&&) noexcept = default;
+};
+
+template <typename T, typename E>
+requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>>
+struct expected_delete_ctor_base<T, E, false, false> {
+    expected_delete_ctor_base() = default;
+    expected_delete_ctor_base(const expected_delete_ctor_base&) = delete;
+    expected_delete_ctor_base(expected_delete_ctor_base&&) noexcept = delete;
+    expected_delete_ctor_base& operator=(const expected_delete_ctor_base&) = default;
+    expected_delete_ctor_base& operator=(expected_delete_ctor_base&&) noexcept = default;
+};
+
+/**
+ * expected_delete_assign_base will conditionally delete copy and move assignment operators
+ * depending on whether T is copy/move constructible + assignable
+ * Additionally, this requires E to be copy/move constructible + assignable
+ */
+template <
+    typename T, typename E,
+    bool EnableCopy = std::conjunction_v<std::is_copy_constructible<T>, std::is_copy_assignable<T>>,
+    bool EnableMove = std::conjunction_v<std::is_move_constructible<T>, std::is_move_assignable<T>>>
+requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>,
+                            std::is_copy_assignable<E>, std::is_move_assignable<E>>
+struct expected_delete_assign_base {
+    expected_delete_assign_base() = default;
+    expected_delete_assign_base(const expected_delete_assign_base&) = default;
+    expected_delete_assign_base(expected_delete_assign_base&&) noexcept = default;
+    expected_delete_assign_base& operator=(const expected_delete_assign_base&) = default;
+    expected_delete_assign_base& operator=(expected_delete_assign_base&&) noexcept = default;
+};
+
+template <typename T, typename E>
+requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>,
+                            std::is_copy_assignable<E>, std::is_move_assignable<E>>
+struct expected_delete_assign_base<T, E, true, false> {
+    expected_delete_assign_base() = default;
+    expected_delete_assign_base(const expected_delete_assign_base&) = default;
+    expected_delete_assign_base(expected_delete_assign_base&&) noexcept = default;
+    expected_delete_assign_base& operator=(const expected_delete_assign_base&) = default;
+    expected_delete_assign_base& operator=(expected_delete_assign_base&&) noexcept = delete;
+};
+
+template <typename T, typename E>
+requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>,
+                            std::is_copy_assignable<E>, std::is_move_assignable<E>>
+struct expected_delete_assign_base<T, E, false, true> {
+    expected_delete_assign_base() = default;
+    expected_delete_assign_base(const expected_delete_assign_base&) = default;
+    expected_delete_assign_base(expected_delete_assign_base&&) noexcept = default;
+    expected_delete_assign_base& operator=(const expected_delete_assign_base&) = delete;
+    expected_delete_assign_base& operator=(expected_delete_assign_base&&) noexcept = default;
+};
+
+template <typename T, typename E>
+requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>,
+                            std::is_copy_assignable<E>, std::is_move_assignable<E>>
+struct expected_delete_assign_base<T, E, false, false> {
+    expected_delete_assign_base() = default;
+    expected_delete_assign_base(const expected_delete_assign_base&) = default;
+    expected_delete_assign_base(expected_delete_assign_base&&) noexcept = default;
+    expected_delete_assign_base& operator=(const expected_delete_assign_base&) = delete;
+    expected_delete_assign_base& operator=(expected_delete_assign_base&&) noexcept = delete;
+};
+
+/**
+ * This is needed to be able to construct the expected_default_ctor_base which follows,
+ * while still conditionally deleting the default constructor.
+ */
+struct default_constructor_tag {
+    constexpr explicit default_constructor_tag() = default;
+};
+
+/**
+ * expected_default_ctor_base will ensure that expected
+ * has a deleted default constructor if T is not default constructible
+ * This specialization is for when T is default constructible
+ */
+template <typename T, typename E, bool Enable = std::is_default_constructible_v<T>>
+struct expected_default_ctor_base {
+    constexpr expected_default_ctor_base() noexcept = default;
+    constexpr expected_default_ctor_base(expected_default_ctor_base const&) noexcept = default;
+    constexpr expected_default_ctor_base(expected_default_ctor_base&&) noexcept = default;
+    expected_default_ctor_base& operator=(expected_default_ctor_base const&) noexcept = default;
+    expected_default_ctor_base& operator=(expected_default_ctor_base&&) noexcept = default;
+
+    constexpr explicit expected_default_ctor_base(default_constructor_tag) {}
+};
+
+template <typename T, typename E>
+struct expected_default_ctor_base<T, E, false> {
+    constexpr expected_default_ctor_base() noexcept = delete;
+    constexpr expected_default_ctor_base(expected_default_ctor_base const&) noexcept = default;
+    constexpr expected_default_ctor_base(expected_default_ctor_base&&) noexcept = default;
+    expected_default_ctor_base& operator=(expected_default_ctor_base const&) noexcept = default;
+    expected_default_ctor_base& operator=(expected_default_ctor_base&&) noexcept = default;
+
+    constexpr explicit expected_default_ctor_base(default_constructor_tag) {}
+};
+
+template <typename T, typename E, typename U>
+using expected_enable_forward_value =
+    std::enable_if_t<std::is_constructible_v<T, U&&> &&
+                     !std::is_same_v<std::remove_cvref_t<U>, std::in_place_t> &&
+                     !std::is_same_v<Expected<T, E>, std::remove_cvref_t<U>> &&
+                     !std::is_same_v<Unexpected<E>, std::remove_cvref_t<U>>>;
+
+template <typename T, typename E, typename U, typename G, typename UR, typename GR>
+using expected_enable_from_other = std::enable_if_t<
+    std::is_constructible_v<T, UR> && std::is_constructible_v<E, GR> &&
+    !std::is_constructible_v<T, Expected<U, G>&> && !std::is_constructible_v<T, Expected<U, G>&&> &&
+    !std::is_constructible_v<T, const Expected<U, G>&> &&
+    !std::is_constructible_v<T, const Expected<U, G>&&> &&
+    !std::is_convertible_v<Expected<U, G>&, T> && !std::is_convertible_v<Expected<U, G>&&, T> &&
+    !std::is_convertible_v<const Expected<U, G>&, T> &&
+    !std::is_convertible_v<const Expected<U, G>&&, T>>;
+
+} // namespace detail
+
+template <typename T, typename E>
+class Expected : private detail::expected_move_assign_base<T, E>,
+                 private detail::expected_delete_ctor_base<T, E>,
+                 private detail::expected_delete_assign_base<T, E>,
+                 private detail::expected_default_ctor_base<T, E> {
+public:
+    using value_type = T;
+    using error_type = E;
+    using unexpected_type = Unexpected<E>;
+
+    constexpr Expected() = default;
+    constexpr Expected(const Expected&) = default;
+    constexpr Expected(Expected&&) = default;
+    Expected& operator=(const Expected&) = default;
+    Expected& operator=(Expected&&) = default;
+
+    template <typename... Args, std::enable_if_t<std::is_constructible_v<T, Args&&...>>* = nullptr>
+    constexpr Expected(std::in_place_t, Args&&... args)
+        : impl_base{std::in_place, std::forward<Args>(args)...},
+          ctor_base{detail::default_constructor_tag{}} {}
+
+    template <typename U, typename... Args,
+              std::enable_if_t<std::is_constructible_v<T, std::initializer_list<U>&, Args&&...>>* =
+                  nullptr>
+    constexpr Expected(std::in_place_t, std::initializer_list<U> il, Args&&... args)
+        : impl_base{std::in_place, il, std::forward<Args>(args)...},
+          ctor_base{detail::default_constructor_tag{}} {}
+
+    template <typename G = E, std::enable_if_t<std::is_constructible_v<E, const G&>>* = nullptr,
+              std::enable_if_t<!std::is_convertible_v<const G&, E>>* = nullptr>
+    constexpr explicit Expected(const Unexpected<G>& e)
+        : impl_base{unexpect_t{}, e.value()}, ctor_base{detail::default_constructor_tag{}} {}
+
+    template <typename G = E, std::enable_if_t<std::is_constructible_v<E, const G&>>* = nullptr,
+              std::enable_if_t<std::is_convertible_v<const G&, E>>* = nullptr>
+    constexpr Expected(Unexpected<G> const& e)
+        : impl_base{unexpect_t{}, e.value()}, ctor_base{detail::default_constructor_tag{}} {}
+
+    template <typename G = E, std::enable_if_t<std::is_constructible_v<E, G&&>>* = nullptr,
+              std::enable_if_t<!std::is_convertible_v<G&&, E>>* = nullptr>
+    constexpr explicit Expected(Unexpected<G>&& e) noexcept(std::is_nothrow_constructible_v<E, G&&>)
+        : impl_base{unexpect_t{}, std::move(e.value())}, ctor_base{
+                                                             detail::default_constructor_tag{}} {}
+
+    template <typename G = E, std::enable_if_t<std::is_constructible_v<E, G&&>>* = nullptr,
+              std::enable_if_t<std::is_convertible_v<G&&, E>>* = nullptr>
+    constexpr Expected(Unexpected<G>&& e) noexcept(std::is_nothrow_constructible_v<E, G&&>)
+        : impl_base{unexpect_t{}, std::move(e.value())}, ctor_base{
+                                                             detail::default_constructor_tag{}} {}
+
+    template <typename... Args, std::enable_if_t<std::is_constructible_v<E, Args&&...>>* = nullptr>
+    constexpr explicit Expected(unexpect_t, Args&&... args)
+        : impl_base{unexpect_t{}, std::forward<Args>(args)...},
+          ctor_base{detail::default_constructor_tag{}} {}
+
+    template <typename U, typename... Args,
+              std::enable_if_t<std::is_constructible_v<E, std::initializer_list<U>&, Args&&...>>* =
+                  nullptr>
+    constexpr explicit Expected(unexpect_t, std::initializer_list<U> il, Args&&... args)
+        : impl_base{unexpect_t{}, il, std::forward<Args>(args)...},
+          ctor_base{detail::default_constructor_tag{}} {}
+
+    template <typename U, typename G,
+              std::enable_if_t<!(std::is_convertible_v<U const&, T> &&
+                                 std::is_convertible_v<G const&, E>)>* = nullptr,
+              detail::expected_enable_from_other<T, E, U, G, const U&, const G&>* = nullptr>
+    constexpr explicit Expected(const Expected<U, G>& rhs)
+        : ctor_base{detail::default_constructor_tag{}} {
+        if (rhs.has_value()) {
+            this->construct(*rhs);
+        } else {
+            this->construct_error(rhs.error());
+        }
+    }
+
+    template <typename U, typename G,
+              std::enable_if_t<(std::is_convertible_v<U const&, T> &&
+                                std::is_convertible_v<G const&, E>)>* = nullptr,
+              detail::expected_enable_from_other<T, E, U, G, const U&, const G&>* = nullptr>
+    constexpr Expected(const Expected<U, G>& rhs) : ctor_base{detail::default_constructor_tag{}} {
+        if (rhs.has_value()) {
+            this->construct(*rhs);
+        } else {
+            this->construct_error(rhs.error());
+        }
+    }
+
+    template <typename U, typename G,
+              std::enable_if_t<!(std::is_convertible_v<U&&, T> && std::is_convertible_v<G&&, E>)>* =
+                  nullptr,
+              detail::expected_enable_from_other<T, E, U, G, U&&, G&&>* = nullptr>
+    constexpr explicit Expected(Expected<U, G>&& rhs)
+        : ctor_base{detail::default_constructor_tag{}} {
+        if (rhs.has_value()) {
+            this->construct(std::move(*rhs));
+        } else {
+            this->construct_error(std::move(rhs.error()));
+        }
+    }
+
+    template <typename U, typename G,
+              std::enable_if_t<(std::is_convertible_v<U&&, T> && std::is_convertible_v<G&&, E>)>* =
+                  nullptr,
+              detail::expected_enable_from_other<T, E, U, G, U&&, G&&>* = nullptr>
+    constexpr Expected(Expected<U, G>&& rhs) : ctor_base{detail::default_constructor_tag{}} {
+        if (rhs.has_value()) {
+            this->construct(std::move(*rhs));
+        } else {
+            this->construct_error(std::move(rhs.error()));
+        }
+    }
+
+    template <typename U = T, std::enable_if_t<!std::is_convertible_v<U&&, T>>* = nullptr,
+              detail::expected_enable_forward_value<T, E, U>* = nullptr>
+    constexpr explicit Expected(U&& v) : Expected{std::in_place, std::forward<U>(v)} {}
+
+    template <typename U = T, std::enable_if_t<std::is_convertible_v<U&&, T>>* = nullptr,
+              detail::expected_enable_forward_value<T, E, U>* = nullptr>
+    constexpr Expected(U&& v) : Expected{std::in_place, std::forward<U>(v)} {}
+
+    template <typename U = T, typename G = T,
+              std::enable_if_t<std::is_nothrow_constructible_v<T, U&&>>* = nullptr,
+              std::enable_if_t<(
+                  !std::is_same_v<Expected<T, E>, std::remove_cvref_t<U>> &&
+                  !std::conjunction_v<std::is_scalar<T>, std::is_same<T, std::remove_cvref_t<U>>> &&
+                  std::is_constructible_v<T, U> && std::is_assignable_v<G&, U> &&
+                  std::is_nothrow_move_constructible_v<E>)>* = nullptr>
+    Expected& operator=(U&& v) {
+        if (has_value()) {
+            val() = std::forward<U>(v);
+        } else {
+            err().~Unexpected<E>();
+            new (valptr()) T{std::forward<U>(v)};
+            this->m_has_val = true;
+        }
+
+        return *this;
+    }
+
+    template <typename U = T, typename G = T,
+              std::enable_if_t<!std::is_nothrow_constructible_v<T, U&&>>* = nullptr,
+              std::enable_if_t<(
+                  !std::is_same_v<Expected<T, E>, std::remove_cvref_t<U>> &&
+                  !std::conjunction_v<std::is_scalar<T>, std::is_same<T, std::remove_cvref_t<U>>> &&
+                  std::is_constructible_v<T, U> && std::is_assignable_v<G&, U> &&
+                  std::is_nothrow_move_constructible_v<E>)>* = nullptr>
+    Expected& operator=(U&& v) {
+        if (has_value()) {
+            val() = std::forward<U>(v);
+        } else {
+            auto tmp = std::move(err());
+            err().~Unexpected<E>();
+            new (valptr()) T{std::forward<U>(v)};
+            this->m_has_val = true;
+        }
+
+        return *this;
+    }
+
+    template <typename G = E, std::enable_if_t<std::is_nothrow_copy_constructible_v<G> &&
+                                               std::is_assignable_v<G&, G>>* = nullptr>
+    Expected& operator=(const Unexpected<G>& rhs) {
+        if (!has_value()) {
+            err() = rhs;
+        } else {
+            this->destroy_val();
+            new (errptr()) Unexpected<E>{rhs};
+            this->m_has_val = false;
+        }
+
+        return *this;
+    }
+
+    template <typename G = E, std::enable_if_t<std::is_nothrow_move_constructible_v<G> &&
+                                               std::is_move_assignable_v<G>>* = nullptr>
+    Expected& operator=(Unexpected<G>&& rhs) noexcept {
+        if (!has_value()) {
+            err() = std::move(rhs);
+        } else {
+            this->destroy_val();
+            new (errptr()) Unexpected<E>{std::move(rhs)};
+            this->m_has_val = false;
+        }
+
+        return *this;
+    }
+
+    template <typename... Args,
+              std::enable_if_t<std::is_nothrow_constructible_v<T, Args&&...>>* = nullptr>
+    void emplace(Args&&... args) {
+        if (has_value()) {
+            val() = T{std::forward<Args>(args)...};
+        } else {
+            err().~Unexpected<E>();
+            new (valptr()) T{std::forward<Args>(args)...};
+            this->m_has_val = true;
+        }
+    }
+
+    template <typename... Args,
+              std::enable_if_t<!std::is_nothrow_constructible_v<T, Args&&...>>* = nullptr>
+    void emplace(Args&&... args) {
+        if (has_value()) {
+            val() = T{std::forward<Args>(args)...};
+        } else {
+            auto tmp = std::move(err());
+            err().~Unexpected<E>();
+            new (valptr()) T{std::forward<Args>(args)...};
+            this->m_has_val = true;
+        }
+    }
+
+    template <typename U, typename... Args,
+              std::enable_if_t<std::is_nothrow_constructible_v<T, std::initializer_list<U>&,
+                                                               Args&&...>>* = nullptr>
+    void emplace(std::initializer_list<U> il, Args&&... args) {
+        if (has_value()) {
+            T t{il, std::forward<Args>(args)...};
+            val() = std::move(t);
+        } else {
+            err().~Unexpected<E>();
+            new (valptr()) T{il, std::forward<Args>(args)...};
+            this->m_has_val = true;
+        }
+    }
+
+    template <typename U, typename... Args,
+              std::enable_if_t<!std::is_nothrow_constructible_v<T, std::initializer_list<U>&,
+                                                                Args&&...>>* = nullptr>
+    void emplace(std::initializer_list<U> il, Args&&... args) {
+        if (has_value()) {
+            T t{il, std::forward<Args>(args)...};
+            val() = std::move(t);
+        } else {
+            auto tmp = std::move(err());
+            err().~Unexpected<E>();
+            new (valptr()) T{il, std::forward<Args>(args)...};
+            this->m_has_val = true;
+        }
+    }
+
+    constexpr T* operator->() {
+        return valptr();
+    }
+
+    constexpr const T* operator->() const {
+        return valptr();
+    }
+
+    template <typename U = T>
+    constexpr U& operator*() & {
+        return val();
+    }
+
+    template <typename U = T>
+    constexpr const U& operator*() const& {
+        return val();
+    }
+
+    template <typename U = T>
+    constexpr U&& operator*() && {
+        return std::move(val());
+    }
+
+    template <typename U = T>
+    constexpr const U&& operator*() const&& {
+        return std::move(val());
+    }
+
+    constexpr bool has_value() const noexcept {
+        return this->m_has_val;
+    }
+
+    constexpr explicit operator bool() const noexcept {
+        return this->m_has_val;
+    }
+
+    template <typename U = T>
+    constexpr U& value() & {
+        return val();
+    }
+
+    template <typename U = T>
+    constexpr const U& value() const& {
+        return val();
+    }
+
+    template <typename U = T>
+    constexpr U&& value() && {
+        return std::move(val());
+    }
+
+    template <typename U = T>
+    constexpr const U&& value() const&& {
+        return std::move(val());
+    }
+
+    constexpr E& error() & {
+        return err().value();
+    }
+
+    constexpr const E& error() const& {
+        return err().value();
+    }
+
+    constexpr E&& error() && {
+        return std::move(err().value());
+    }
+
+    constexpr const E&& error() const&& {
+        return std::move(err().value());
+    }
+
+    template <typename U>
+    constexpr T value_or(U&& v) const& {
+        static_assert(std::is_copy_constructible_v<T> && std::is_convertible_v<U&&, T>,
+                      "T must be copy-constructible and convertible from U&&");
+        return bool(*this) ? **this : static_cast<T>(std::forward<U>(v));
+    }
+
+    template <typename U>
+    constexpr T value_or(U&& v) && {
+        static_assert(std::is_move_constructible_v<T> && std::is_convertible_v<U&&, T>,
+                      "T must be move-constructible and convertible from U&&");
+        return bool(*this) ? std::move(**this) : static_cast<T>(std::forward<U>(v));
+    }
+
+private:
+    static_assert(!std::is_reference_v<T>, "T must not be a reference");
+    static_assert(!std::is_same_v<T, std::remove_cv_t<std::in_place_t>>,
+                  "T must not be std::in_place_t");
+    static_assert(!std::is_same_v<T, std::remove_cv_t<unexpect_t>>, "T must not be unexpect_t");
+    static_assert(!std::is_same_v<T, std::remove_cv_t<Unexpected<E>>>,
+                  "T must not be Unexpected<E>");
+    static_assert(!std::is_reference_v<E>, "E must not be a reference");
+
+    T* valptr() {
+        return std::addressof(this->m_val);
+    }
+
+    const T* valptr() const {
+        return std::addressof(this->m_val);
+    }
+
+    Unexpected<E>* errptr() {
+        return std::addressof(this->m_unexpect);
+    }
+
+    const Unexpected<E>* errptr() const {
+        return std::addressof(this->m_unexpect);
+    }
+
+    template <typename U = T>
+    constexpr U& val() {
+        return this->m_val;
+    }
+
+    template <typename U = T>
+    constexpr const U& val() const {
+        return this->m_val;
+    }
+
+    constexpr Unexpected<E>& err() {
+        return this->m_unexpect;
+    }
+
+    constexpr const Unexpected<E>& err() const {
+        return this->m_unexpect;
+    }
+
+    using impl_base = detail::expected_move_assign_base<T, E>;
+    using ctor_base = detail::expected_default_ctor_base<T, E>;
+};
+
+template <typename T, typename E, typename U, typename F>
+constexpr bool operator==(const Expected<T, E>& lhs, const Expected<U, F>& rhs) {
+    return (lhs.has_value() != rhs.has_value())
+               ? false
+               : (!lhs.has_value() ? lhs.error() == rhs.error() : *lhs == *rhs);
+}
+
+template <typename T, typename E, typename U, typename F>
+constexpr bool operator!=(const Expected<T, E>& lhs, const Expected<U, F>& rhs) {
+    return !operator==(lhs, rhs);
+}
+
+template <typename T, typename E, typename U>
+constexpr bool operator==(const Expected<T, E>& x, const U& v) {
+    return x.has_value() ? *x == v : false;
+}
+
+template <typename T, typename E, typename U>
+constexpr bool operator==(const U& v, const Expected<T, E>& x) {
+    return x.has_value() ? *x == v : false;
+}
+
+template <typename T, typename E, typename U>
+constexpr bool operator!=(const Expected<T, E>& x, const U& v) {
+    return !operator==(x, v);
+}
+
+template <typename T, typename E, typename U>
+constexpr bool operator!=(const U& v, const Expected<T, E>& x) {
+    return !operator==(v, x);
+}
+
+template <typename T, typename E>
+constexpr bool operator==(const Expected<T, E>& x, const Unexpected<E>& e) {
+    return x.has_value() ? false : x.error() == e.value();
+}
+
+template <typename T, typename E>
+constexpr bool operator==(const Unexpected<E>& e, const Expected<T, E>& x) {
+    return x.has_value() ? false : x.error() == e.value();
+}
+
+template <typename T, typename E>
+constexpr bool operator!=(const Expected<T, E>& x, const Unexpected<E>& e) {
+    return !operator==(x, e);
+}
+
+template <typename T, typename E>
+constexpr bool operator!=(const Unexpected<E>& e, const Expected<T, E>& x) {
+    return !operator==(e, x);
+}
+
+} // 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,366 @@
+// 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(const 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() {}
+
+    // Force input device to update data regardless of the current state
+    virtual void ForceUpdate() {}
+
+    // 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(const 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]] const LedStatus& led_status) {}
+
+    virtual VibrationError SetVibration([[maybe_unused]] const 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/filter.cpp

@@ -114,6 +114,7 @@ bool ParseFilterRule(Filter& instance, Iterator begin, Iterator end) {
     SUB(Service, NGCT)                                                                             \
     SUB(Service, NIFM)                                                                             \
     SUB(Service, NIM)                                                                              \
+    SUB(Service, NOTIF)                                                                            \
     SUB(Service, NPNS)                                                                             \
     SUB(Service, NS)                                                                               \
     SUB(Service, NVDRV)                                                                            \

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/logging/types.h

@@ -82,6 +82,7 @@ enum class Class : u8 {
     Service_NGCT,      ///< The NGCT (No Good Content for Terra) service
     Service_NIFM,      ///< The NIFM (Network interface) service
     Service_NIM,       ///< The NIM service
+    Service_NOTIF,     ///< The NOTIF (Notification) service
     Service_NPNS,      ///< The NPNS service
     Service_NS,        ///< The NS services
     Service_NVDRV,     ///< The NVDRV (Nvidia driver) service

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,8 +6,6 @@
 
 #include <algorithm>
 #include <array>
-#include <atomic>
-#include <chrono>
 #include <map>
 #include <optional>
 #include <string>
@@ -53,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
@@ -452,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{
@@ -463,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"};
@@ -473,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"};
@@ -487,9 +538,9 @@ struct Values {
     // System
     Setting<std::optional<u32>> rng_seed{std::optional<u32>(), "rng_seed"};
     // Measured in seconds since epoch
-    std::optional<std::chrono::seconds> custom_rtc;
+    std::optional<s64> custom_rtc;
     // Set on game boot, reset on stop. Seconds difference between current time and `custom_rtc`
-    std::chrono::seconds custom_rtc_differential;
+    s64 custom_rtc_differential;
 
     BasicSetting<s32> current_user{0, "current_user"};
     RangedSetting<s32> language_index{1, 0, 17, "language_index"};
@@ -508,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;
@@ -534,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"};
@@ -562,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"};
@@ -596,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/cpu_detect.cpp

@@ -71,9 +71,6 @@ static CPUCaps Detect() {
     else
         caps.manufacturer = Manufacturer::Unknown;
 
-    u32 family = {};
-    u32 model = {};
-
     __cpuid(cpu_id, 0x80000000);
 
     u32 max_ex_fn = cpu_id[0];
@@ -84,15 +81,6 @@ static CPUCaps Detect() {
     // Detect family and other miscellaneous features
     if (max_std_fn >= 1) {
         __cpuid(cpu_id, 0x00000001);
-        family = (cpu_id[0] >> 8) & 0xf;
-        model = (cpu_id[0] >> 4) & 0xf;
-        if (family == 0xf) {
-            family += (cpu_id[0] >> 20) & 0xff;
-        }
-        if (family >= 6) {
-            model += ((cpu_id[0] >> 16) & 0xf) << 4;
-        }
-
         if ((cpu_id[3] >> 25) & 1)
             caps.sse = true;
         if ((cpu_id[3] >> 26) & 1)

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
@@ -167,12 +179,15 @@ add_library(core STATIC
     hle/kernel/k_client_port.h
     hle/kernel/k_client_session.cpp
     hle/kernel/k_client_session.h
+    hle/kernel/k_code_memory.cpp
+    hle/kernel/k_code_memory.h
     hle/kernel/k_condition_variable.cpp
     hle/kernel/k_condition_variable.h
     hle/kernel/k_event.cpp
     hle/kernel/k_event.h
     hle/kernel/k_handle_table.cpp
     hle/kernel/k_handle_table.h
+    hle/kernel/k_light_condition_variable.cpp
     hle/kernel/k_light_condition_variable.h
     hle/kernel/k_light_lock.cpp
     hle/kernel/k_light_lock.h
@@ -225,6 +240,7 @@ add_library(core STATIC
     hle/kernel/k_system_control.h
     hle/kernel/k_thread.cpp
     hle/kernel/k_thread.h
+    hle/kernel/k_thread_queue.cpp
     hle/kernel/k_thread_queue.h
     hle/kernel/k_trace.h
     hle/kernel/k_transfer_memory.cpp
@@ -396,12 +412,15 @@ add_library(core STATIC
     hle/service/glue/glue.h
     hle/service/glue/glue_manager.cpp
     hle/service/glue/glue_manager.h
+    hle/service/glue/notif.cpp
+    hle/service/glue/notif.h
     hle/service/grc/grc.cpp
     hle/service/grc/grc.h
     hle/service/hid/hid.cpp
     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 +485,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_32.h

@@ -9,7 +9,6 @@
 
 #include <dynarmic/interface/A32/a32.h>
 #include <dynarmic/interface/A64/a64.h>
-#include <dynarmic/interface/exclusive_monitor.h>
 #include "common/common_types.h"
 #include "common/hash.h"
 #include "core/arm/arm_interface.h"

src/core/arm/dynarmic/arm_dynarmic_64.cpp

@@ -18,7 +18,6 @@
 #include "core/core_timing.h"
 #include "core/hardware_properties.h"
 #include "core/hle/kernel/k_process.h"
-#include "core/hle/kernel/k_scheduler.h"
 #include "core/hle/kernel/svc.h"
 #include "core/memory.h"
 
@@ -87,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:
@@ -263,7 +282,7 @@ void ARM_Dynarmic_64::Run() {
 }
 
 void ARM_Dynarmic_64::Step() {
-    cb->InterpreterFallback(jit->GetPC(), 1);
+    jit->Step();
 }
 
 ARM_Dynarmic_64::ARM_Dynarmic_64(System& system_, CPUInterrupts& interrupt_handlers_,

src/core/arm/dynarmic/arm_dynarmic_cp15.cpp

@@ -8,7 +8,6 @@
 #include "core/arm/dynarmic/arm_dynarmic_cp15.h"
 #include "core/core.h"
 #include "core/core_timing.h"
-#include "core/core_timing_util.h"
 
 using Callback = Dynarmic::A32::Coprocessor::Callback;
 using CallbackOrAccessOneWord = Dynarmic::A32::Coprocessor::CallbackOrAccessOneWord;

src/core/arm/dynarmic/arm_dynarmic_cp15.h

@@ -4,7 +4,6 @@
 
 #pragma once
 
-#include <memory>
 #include <optional>
 
 #include <dynarmic/interface/A32/coprocessor.h>

src/core/arm/dynarmic/arm_exclusive_monitor.cpp

@@ -2,8 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <cinttypes>
-#include <memory>
 #include "core/arm/dynarmic/arm_exclusive_monitor.h"
 #include "core/memory.h"
 

src/core/arm/dynarmic/arm_exclusive_monitor.h

@@ -4,7 +4,6 @@
 
 #pragma once
 
-#include <memory>
 #include <unordered_map>
 
 #include <dynarmic/interface/exclusive_monitor.h>

src/core/core.cpp

@@ -19,20 +19,17 @@
 #include "core/cpu_manager.h"
 #include "core/device_memory.h"
 #include "core/file_sys/bis_factory.h"
-#include "core/file_sys/card_image.h"
 #include "core/file_sys/mode.h"
 #include "core/file_sys/patch_manager.h"
 #include "core/file_sys/registered_cache.h"
 #include "core/file_sys/romfs_factory.h"
 #include "core/file_sys/savedata_factory.h"
-#include "core/file_sys/sdmc_factory.h"
 #include "core/file_sys/vfs_concat.h"
 #include "core/file_sys/vfs_real.h"
 #include "core/hardware_interrupt_manager.h"
-#include "core/hle/kernel/k_client_port.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/k_thread.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/physical_core.h"
 #include "core/hle/service/am/applets/applets.h"
@@ -83,12 +80,6 @@ FileSys::StorageId GetStorageIdForFrontendSlot(
     }
 }
 
-void KProcessDeleter(Kernel::KProcess* process) {
-    process->Destroy();
-}
-
-using KProcessPtr = std::unique_ptr<Kernel::KProcess, decltype(&KProcessDeleter)>;
-
 } // Anonymous namespace
 
 FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
@@ -136,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() {
@@ -196,8 +187,9 @@ struct System::Impl {
         cpu_manager.Initialize();
         core_timing.Initialize([&system]() { system.RegisterHostThread(); });
 
-        const auto current_time = std::chrono::duration_cast<std::chrono::seconds>(
-            std::chrono::system_clock::now().time_since_epoch());
+        const auto posix_time = std::chrono::system_clock::now().time_since_epoch();
+        const auto current_time =
+            std::chrono::duration_cast<std::chrono::seconds>(posix_time).count();
         Settings::values.custom_rtc_differential =
             Settings::values.custom_rtc.value_or(current_time) - current_time;
 
@@ -260,11 +252,10 @@ struct System::Impl {
         }
 
         telemetry_session->AddInitialInfo(*app_loader, fs_controller, *content_provider);
-        main_process = KProcessPtr{Kernel::KProcess::Create(system.Kernel()), KProcessDeleter};
-        ASSERT(Kernel::KProcess::Initialize(main_process.get(), system, "main",
+        auto main_process = Kernel::KProcess::Create(system.Kernel());
+        ASSERT(Kernel::KProcess::Initialize(main_process, system, "main",
                                             Kernel::KProcess::ProcessType::Userland)
                    .IsSuccess());
-        main_process->Open();
         const auto [load_result, load_parameters] = app_loader->Load(*main_process, system);
         if (load_result != Loader::ResultStatus::Success) {
             LOG_CRITICAL(Core, "Failed to load ROM (Error {})!", load_result);
@@ -274,7 +265,7 @@ struct System::Impl {
                 static_cast<u32>(SystemResultStatus::ErrorLoader) + static_cast<u32>(load_result));
         }
         AddGlueRegistrationForProcess(*app_loader, *main_process);
-        kernel.MakeCurrentProcess(main_process.get());
+        kernel.MakeCurrentProcess(main_process);
         kernel.InitializeCores();
 
         // Initialize cheat engine
@@ -334,13 +325,11 @@ struct System::Impl {
         time_manager.Shutdown();
         core_timing.Shutdown();
         app_loader.reset();
-        perf_stats.reset();
         gpu_core.reset();
+        perf_stats.reset();
         kernel.Shutdown();
         memory.Reset();
         applet_manager.ClearAll();
-        // TODO: The main process should be freed based on KAutoObject ref counting.
-        main_process.reset();
 
         LOG_DEBUG(Core, "Shutdown OK");
     }
@@ -361,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);
@@ -402,8 +391,8 @@ struct System::Impl {
     std::unique_ptr<Tegra::GPU> gpu_core;
     std::unique_ptr<Hardware::InterruptManager> interrupt_manager;
     std::unique_ptr<Core::DeviceMemory> device_memory;
-    KProcessPtr main_process{nullptr, KProcessDeleter};
     Core::Memory::Memory memory;
+    Core::HID::HIDCore hid_core;
     CpuManager cpu_manager;
     std::atomic_bool is_powered_on{};
     bool exit_lock = false;
@@ -532,12 +521,6 @@ const ARM_Interface& System::CurrentArmInterface() const {
     return impl->kernel.CurrentPhysicalCore().ArmInterface();
 }
 
-std::size_t System::CurrentCoreIndex() const {
-    std::size_t core = impl->kernel.GetCurrentHostThreadID();
-    ASSERT(core < Core::Hardware::NUM_CPU_CORES);
-    return core;
-}
-
 Kernel::PhysicalCore& System::CurrentPhysicalCore() {
     return impl->kernel.CurrentPhysicalCore();
 }
@@ -628,6 +611,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;
 }
@@ -652,6 +643,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);
 }
@@ -834,8 +829,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;
@@ -204,9 +208,6 @@ public:
     /// Gets an ARM interface to the CPU core that is currently running
     [[nodiscard]] const ARM_Interface& CurrentArmInterface() const;
 
-    /// Gets the index of the currently running CPU core
-    [[nodiscard]] std::size_t CurrentCoreIndex() const;
-
     /// Gets the physical core for the CPU core that is currently running
     [[nodiscard]] Kernel::PhysicalCore& CurrentPhysicalCore();
 
@@ -285,6 +286,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 +304,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/core_timing.h

@@ -8,7 +8,6 @@
 #include <chrono>
 #include <functional>
 #include <memory>
-#include <mutex>
 #include <optional>
 #include <string>
 #include <thread>

src/core/cpu_manager.cpp

@@ -6,7 +6,6 @@
 #include "common/microprofile.h"
 #include "common/scope_exit.h"
 #include "common/thread.h"
-#include "core/arm/exclusive_monitor.h"
 #include "core/core.h"
 #include "core/core_timing.h"
 #include "core/cpu_manager.h"
@@ -118,17 +117,18 @@ void CpuManager::MultiCoreRunGuestLoop() {
             physical_core = &kernel.CurrentPhysicalCore();
         }
         system.ExitDynarmicProfile();
-        physical_core->ArmInterface().ClearExclusiveState();
-        kernel.CurrentScheduler()->RescheduleCurrentCore();
+        {
+            Kernel::KScopedDisableDispatch dd(kernel);
+            physical_core->ArmInterface().ClearExclusiveState();
+        }
     }
 }
 
 void CpuManager::MultiCoreRunIdleThread() {
     auto& kernel = system.Kernel();
     while (true) {
-        auto& physical_core = kernel.CurrentPhysicalCore();
-        physical_core.Idle();
-        kernel.CurrentScheduler()->RescheduleCurrentCore();
+        Kernel::KScopedDisableDispatch dd(kernel);
+        kernel.CurrentPhysicalCore().Idle();
     }
 }
 
@@ -136,12 +136,12 @@ void CpuManager::MultiCoreRunSuspendThread() {
     auto& kernel = system.Kernel();
     kernel.CurrentScheduler()->OnThreadStart();
     while (true) {
-        auto core = kernel.GetCurrentHostThreadID();
+        auto core = kernel.CurrentPhysicalCoreIndex();
         auto& scheduler = *kernel.CurrentScheduler();
         Kernel::KThread* current_thread = scheduler.GetCurrentThread();
         Common::Fiber::YieldTo(current_thread->GetHostContext(), *core_data[core].host_context);
         ASSERT(scheduler.ContextSwitchPending());
-        ASSERT(core == kernel.GetCurrentHostThreadID());
+        ASSERT(core == kernel.CurrentPhysicalCoreIndex());
         scheduler.RescheduleCurrentCore();
     }
 }
@@ -347,13 +347,9 @@ void CpuManager::RunThread(std::stop_token stop_token, std::size_t core) {
             sc_sync_first_use = false;
         }
 
-        // Abort if emulation was killed before the session really starts
-        if (!system.IsPoweredOn()) {
-            return;
-        }
-
+        // Emulation was stopped
         if (stop_token.stop_requested()) {
-            break;
+            return;
         }
 
         auto current_thread = system.Kernel().CurrentScheduler()->GetCurrentThread();

src/core/crypto/ctr_encryption_layer.cpp

@@ -4,7 +4,6 @@
 
 #include <algorithm>
 #include <cstring>
-#include "common/assert.h"
 #include "core/crypto/ctr_encryption_layer.h"
 
 namespace Core::Crypto {

src/core/crypto/key_manager.cpp

@@ -10,14 +10,12 @@
 #include <locale>
 #include <map>
 #include <sstream>
-#include <string_view>
 #include <tuple>
 #include <vector>
 #include <mbedtls/bignum.h>
 #include <mbedtls/cipher.h>
 #include <mbedtls/cmac.h>
 #include <mbedtls/sha256.h>
-#include "common/common_funcs.h"
 #include "common/fs/file.h"
 #include "common/fs/fs.h"
 #include "common/fs/path_util.h"
@@ -30,7 +28,6 @@
 #include "core/crypto/partition_data_manager.h"
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/nca_metadata.h"
-#include "core/file_sys/partition_filesystem.h"
 #include "core/file_sys/registered_cache.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/loader/loader.h"

src/core/crypto/key_manager.h

@@ -15,7 +15,6 @@
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "core/crypto/partition_data_manager.h"
-#include "core/file_sys/vfs_types.h"
 
 namespace Common::FS {
 class IOFile;

src/core/crypto/partition_data_manager.cpp

@@ -12,7 +12,6 @@
 #include <cctype>
 #include <cstring>
 #include <mbedtls/sha256.h>
-#include "common/assert.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/hex_util.h"

src/core/crypto/xts_encryption_layer.cpp

@@ -4,7 +4,6 @@
 
 #include <algorithm>
 #include <cstring>
-#include "common/assert.h"
 #include "core/crypto/xts_encryption_layer.h"
 
 namespace Core::Crypto {

src/core/file_sys/card_image.cpp

@@ -14,7 +14,6 @@
 #include "core/file_sys/nca_metadata.h"
 #include "core/file_sys/partition_filesystem.h"
 #include "core/file_sys/submission_package.h"
-#include "core/file_sys/vfs_concat.h"
 #include "core/file_sys/vfs_offset.h"
 #include "core/file_sys/vfs_vector.h"
 #include "core/loader/loader.h"

src/core/file_sys/control_metadata.cpp

@@ -9,7 +9,7 @@
 
 namespace FileSys {
 
-const std::array<const char*, 15> LANGUAGE_NAMES{{
+const std::array<const char*, 16> LANGUAGE_NAMES{{
     "AmericanEnglish",
     "BritishEnglish",
     "Japanese",
@@ -25,6 +25,7 @@ const std::array<const char*, 15> LANGUAGE_NAMES{{
     "Korean",
     "Taiwanese",
     "Chinese",
+    "BrazilianPortuguese",
 }};
 
 std::string LanguageEntry::GetApplicationName() const {

src/core/file_sys/control_metadata.h

@@ -5,7 +5,6 @@
 #pragma once
 
 #include <array>
-#include <memory>
 #include <string>
 #include "common/common_funcs.h"
 #include "common/common_types.h"
@@ -88,11 +87,12 @@ enum class Language : u8 {
     Korean = 12,
     Taiwanese = 13,
     Chinese = 14,
+    BrazilianPortuguese = 15,
 
     Default = 255,
 };
 
-extern const std::array<const char*, 15> LANGUAGE_NAMES;
+extern const std::array<const char*, 16> LANGUAGE_NAMES;
 
 // A class representing the format used by NX metadata files, typically named Control.nacp.
 // These store application name, dev name, title id, and other miscellaneous data.

src/core/file_sys/directory.h

@@ -6,7 +6,6 @@
 
 #include <cstddef>
 #include <iterator>
-#include <string_view>
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 

src/core/file_sys/nca_metadata.h

@@ -5,7 +5,6 @@
 #pragma once
 
 #include <array>
-#include <memory>
 #include <vector>
 #include "common/common_funcs.h"
 #include "common/common_types.h"

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/romfs_factory.cpp

@@ -6,7 +6,6 @@
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"
-#include "core/file_sys/card_image.h"
 #include "core/file_sys/common_funcs.h"
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/nca_metadata.h"
@@ -39,13 +38,12 @@ void RomFSFactory::SetPackedUpdate(VirtualFile update_raw_file) {
 
 ResultVal<VirtualFile> RomFSFactory::OpenCurrentProcess(u64 current_process_title_id) const {
     if (!updatable) {
-        return MakeResult<VirtualFile>(file);
+        return file;
     }
 
     const PatchManager patch_manager{current_process_title_id, filesystem_controller,
                                      content_provider};
-    return MakeResult<VirtualFile>(
-        patch_manager.PatchRomFS(file, ivfc_offset, ContentRecordType::Program, update_raw));
+    return patch_manager.PatchRomFS(file, ivfc_offset, ContentRecordType::Program, update_raw);
 }
 
 ResultVal<VirtualFile> RomFSFactory::OpenPatchedRomFS(u64 title_id, ContentRecordType type) const {
@@ -58,8 +56,7 @@ ResultVal<VirtualFile> RomFSFactory::OpenPatchedRomFS(u64 title_id, ContentRecor
 
     const PatchManager patch_manager{title_id, filesystem_controller, content_provider};
 
-    return MakeResult<VirtualFile>(
-        patch_manager.PatchRomFS(nca->GetRomFS(), nca->GetBaseIVFCOffset(), type));
+    return patch_manager.PatchRomFS(nca->GetRomFS(), nca->GetBaseIVFCOffset(), type);
 }
 
 ResultVal<VirtualFile> RomFSFactory::OpenPatchedRomFSWithProgramIndex(
@@ -83,7 +80,7 @@ ResultVal<VirtualFile> RomFSFactory::Open(u64 title_id, StorageId storage,
         return ResultUnknown;
     }
 
-    return MakeResult<VirtualFile>(romfs);
+    return romfs;
 }
 
 std::shared_ptr<NCA> RomFSFactory::GetEntry(u64 title_id, StorageId storage,

src/core/file_sys/romfs_factory.h

@@ -5,8 +5,9 @@
 #pragma once
 
 #include <memory>
+
 #include "common/common_types.h"
-#include "core/file_sys/vfs.h"
+#include "core/file_sys/vfs_types.h"
 #include "core/hle/result.h"
 
 namespace Loader {

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 {
 
@@ -94,7 +93,7 @@ ResultVal<VirtualDir> SaveDataFactory::Create(SaveDataSpaceId space,
         return ResultUnknown;
     }
 
-    return MakeResult<VirtualDir>(std::move(out));
+    return out;
 }
 
 ResultVal<VirtualDir> SaveDataFactory::Open(SaveDataSpaceId space,
@@ -115,7 +114,7 @@ ResultVal<VirtualDir> SaveDataFactory::Open(SaveDataSpaceId space,
         return ResultUnknown;
     }
 
-    return MakeResult<VirtualDir>(std::move(out));
+    return out;
 }
 
 VirtualDir SaveDataFactory::GetSaveDataSpaceDirectory(SaveDataSpaceId space) const {
@@ -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/file_sys/savedata_factory.h

@@ -8,7 +8,6 @@
 #include <string>
 #include "common/common_funcs.h"
 #include "common/common_types.h"
-#include "common/swap.h"
 #include "core/file_sys/vfs.h"
 #include "core/hle/result.h"
 

src/core/file_sys/sdmc_factory.cpp

@@ -25,7 +25,7 @@ SDMCFactory::SDMCFactory(VirtualDir sd_dir_, VirtualDir sd_mod_dir_)
 SDMCFactory::~SDMCFactory() = default;
 
 ResultVal<VirtualDir> SDMCFactory::Open() const {
-    return MakeResult<VirtualDir>(sd_dir);
+    return sd_dir;
 }
 
 VirtualDir SDMCFactory::GetSDMCModificationLoadRoot(u64 title_id) const {

src/core/file_sys/submission_package.cpp

@@ -4,7 +4,6 @@
 
 #include <algorithm>
 #include <cstring>
-#include <string_view>
 
 #include <fmt/ostream.h>
 

src/core/file_sys/system_archive/time_zone_binary.h

@@ -4,7 +4,6 @@
 
 #pragma once
 
-#include <string>
 #include "core/file_sys/vfs_types.h"
 
 namespace FileSys::SystemArchive {

src/core/file_sys/vfs.h

@@ -9,7 +9,6 @@
 #include <memory>
 #include <optional>
 #include <string>
-#include <string_view>
 #include <type_traits>
 #include <vector>
 

src/core/file_sys/vfs_concat.h

@@ -6,7 +6,6 @@
 
 #include <map>
 #include <memory>
-#include <string_view>
 #include "core/file_sys/vfs.h"
 
 namespace FileSys {

src/core/file_sys/vfs_offset.h

@@ -5,7 +5,6 @@
 #pragma once
 
 #include <memory>
-#include <string_view>
 
 #include "core/file_sys/vfs.h"
 

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/general_frontend.h

@@ -5,7 +5,6 @@
 #pragma once
 
 #include <functional>
-#include <optional>
 #include "common/common_types.h"
 
 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

@@ -5,7 +5,6 @@
 #pragma once
 
 #include <functional>
-#include <thread>
 
 #include "common/common_types.h"
 
@@ -58,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;
@@ -83,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;
@@ -107,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/applets/web_browser.h

@@ -5,7 +5,6 @@
 #pragma once
 
 #include <functional>
-#include <string_view>
 
 #include "core/hle/service/am/applets/applet_web_browser_types.h"
 

src/core/frontend/emu_window.cpp

@@ -2,68 +2,32 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <cmath>
 #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 {
@@ -76,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

@@ -5,7 +5,6 @@
 #pragma once
 
 #include <memory>
-#include <tuple>
 #include <utility>
 #include "common/common_types.h"
 #include "core/frontend/framebuffer_layout.h"
@@ -113,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
@@ -213,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:
@@ -238,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,232 @@
+// 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) {
+        motion_devices->SetCallback({
+            .on_change =
+                [this](const Common::Input::CallbackStatus& callback) { SetMotion(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;
+        }
+        touch_device->SetCallback({
+            .on_change =
+                [this, index](const Common::Input::CallbackStatus& callback) {
+                    SetTouch(callback, index);
+                },
+        });
+        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(const 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(const Common::Input::CallbackStatus& callback, 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(const 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(const 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